Compare commits
1
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
 Adam Honse
|
972c0f74e6 |
+1
-2
@@ -6,8 +6,6 @@ OpenRGB
|
||||
openrgb
|
||||
OpenRGB-x86_64.AppImage
|
||||
60-openrgb.rules
|
||||
debian/changelog
|
||||
fedora/OpenRGB.spec
|
||||
|
||||
# Directories
|
||||
.build/
|
||||
@@ -118,3 +116,4 @@ compile_commands.json
|
||||
|
||||
# Generated i18n files
|
||||
*.qm
|
||||
|
||||
|
||||
+33
-28
@@ -43,7 +43,6 @@ before_script:
|
||||
name: "${CI_PROJECT_NAME}_Supported_Devices_${CI_COMMIT_SHORT_SHA}"
|
||||
paths:
|
||||
- ./*.md
|
||||
- Supported Devices.csv
|
||||
exclude:
|
||||
- README.md
|
||||
- CONTRIBUTING.md
|
||||
@@ -109,10 +108,9 @@ before_script:
|
||||
image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:buster-32
|
||||
stage: build
|
||||
script:
|
||||
- ./scripts/build-package-files.sh debian/changelog
|
||||
- dpkg-architecture -l
|
||||
- dpkg-buildpackage --target-arch i386 -us -B
|
||||
- rm -v ../openrgb-dbgsym*.*deb
|
||||
- rm -v ../openrgb-dbgsym*.deb
|
||||
- mv -v ../openrgb*.deb ./
|
||||
|
||||
artifacts:
|
||||
@@ -120,7 +118,7 @@ before_script:
|
||||
paths:
|
||||
- openrgb*.deb
|
||||
exclude:
|
||||
- openrgb-dbgsym*.*deb
|
||||
- openrgb-dbgsym*.deb
|
||||
expire_in: 30 days
|
||||
|
||||
rules:
|
||||
@@ -138,10 +136,9 @@ before_script:
|
||||
image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:buster-64
|
||||
stage: build
|
||||
script:
|
||||
- ./scripts/build-package-files.sh debian/changelog
|
||||
- dpkg-architecture -l
|
||||
- dpkg-buildpackage -us -B
|
||||
- rm -v ../openrgb-dbgsym*.*deb
|
||||
- rm -v ../openrgb-dbgsym*.deb
|
||||
- mv -v ../openrgb*.deb ./
|
||||
|
||||
artifacts:
|
||||
@@ -149,7 +146,7 @@ before_script:
|
||||
paths:
|
||||
- openrgb*.deb
|
||||
exclude:
|
||||
- openrgb-dbgsym*.*deb
|
||||
- openrgb-dbgsym*.deb
|
||||
expire_in: 30 days
|
||||
|
||||
rules:
|
||||
@@ -167,10 +164,9 @@ before_script:
|
||||
image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bullseye-32
|
||||
stage: build
|
||||
script:
|
||||
- ./scripts/build-package-files.sh debian/changelog
|
||||
- dpkg-architecture -l
|
||||
- dpkg-buildpackage --target-arch i386 -us -B
|
||||
- rm -v ../openrgb-dbgsym*.*deb
|
||||
- rm -v ../openrgb-dbgsym*.deb
|
||||
- mv -v ../openrgb*.deb ./
|
||||
|
||||
artifacts:
|
||||
@@ -178,7 +174,7 @@ before_script:
|
||||
paths:
|
||||
- openrgb*.deb
|
||||
exclude:
|
||||
- openrgb-dbgsym*.*deb
|
||||
- openrgb-dbgsym*.deb
|
||||
expire_in: 30 days
|
||||
|
||||
rules:
|
||||
@@ -196,10 +192,9 @@ before_script:
|
||||
image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bullseye-64
|
||||
stage: build
|
||||
script:
|
||||
- ./scripts/build-package-files.sh debian/changelog
|
||||
- dpkg-architecture -l
|
||||
- dpkg-buildpackage -us -B
|
||||
- rm -v ../openrgb-dbgsym*.*deb
|
||||
- rm -v ../openrgb-dbgsym*.deb
|
||||
- mv -v ../openrgb*.deb ./
|
||||
|
||||
artifacts:
|
||||
@@ -207,7 +202,7 @@ before_script:
|
||||
paths:
|
||||
- openrgb*.deb
|
||||
exclude:
|
||||
- openrgb-dbgsym*.*deb
|
||||
- openrgb-dbgsym*.deb
|
||||
expire_in: 30 days
|
||||
|
||||
rules:
|
||||
@@ -225,7 +220,6 @@ before_script:
|
||||
image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bookworm-32
|
||||
stage: build
|
||||
script:
|
||||
- ./scripts/build-package-files.sh debian/changelog
|
||||
- dpkg-architecture -l
|
||||
- dpkg-buildpackage --target-arch i386 -us -B
|
||||
- rm -v ../openrgb-dbgsym*.deb
|
||||
@@ -254,7 +248,6 @@ before_script:
|
||||
image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:bookworm-64
|
||||
stage: build
|
||||
script:
|
||||
- ./scripts/build-package-files.sh debian/changelog
|
||||
- dpkg-architecture -l
|
||||
- dpkg-buildpackage -us -B
|
||||
- rm -v ../openrgb-dbgsym*.deb
|
||||
@@ -284,7 +277,6 @@ before_script:
|
||||
script:
|
||||
- dnf install rpmdevtools dnf-plugins-core -y
|
||||
- rpmdev-setuptree
|
||||
- ./scripts/build-package-files.sh fedora/OpenRGB.spec
|
||||
- ls /root/
|
||||
- cp fedora/OpenRGB.spec /root/rpmbuild/SPECS
|
||||
- cp ../OpenRGB /root/rpmbuild/SOURCES/ -r
|
||||
@@ -317,9 +309,8 @@ before_script:
|
||||
image: fedora:36
|
||||
stage: build
|
||||
script:
|
||||
- dnf install rpmdevtools dnf-plugins-core libcurl-devel qt5-qtbase-devel -y
|
||||
- dnf install rpmdevtools dnf-plugins-core libcurl-devel -y
|
||||
- rpmdev-setuptree
|
||||
- ./scripts/build-package-files.sh fedora/OpenRGB.spec
|
||||
- ls /root/
|
||||
- cp fedora/OpenRGB.spec /root/rpmbuild/SPECS
|
||||
- cp ../OpenRGB /root/rpmbuild/SOURCES/ -r
|
||||
@@ -355,6 +346,7 @@ before_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 (Debian Buster)"
|
||||
@@ -371,6 +363,7 @@ before_script:
|
||||
- apt update
|
||||
- DEBIAN_FRONTEND=noninteractive apt install -yq --no-install-recommends ./openrgb*amd64.deb
|
||||
- openrgb --version
|
||||
- openrgb -l
|
||||
- apt remove -y openrgb
|
||||
dependencies:
|
||||
- "Linux 64 .deb (Debian Buster)"
|
||||
@@ -387,6 +380,7 @@ before_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 (Debian Bullseye)"
|
||||
@@ -403,6 +397,7 @@ before_script:
|
||||
- apt update
|
||||
- DEBIAN_FRONTEND=noninteractive apt install -yq --no-install-recommends ./openrgb*amd64.deb
|
||||
- openrgb --version
|
||||
- openrgb -l
|
||||
- apt remove -y openrgb
|
||||
dependencies:
|
||||
- "Linux 64 .deb (Debian Bullseye)"
|
||||
@@ -419,6 +414,7 @@ before_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 (Debian Bookworm)"
|
||||
@@ -435,6 +431,7 @@ before_script:
|
||||
- apt update
|
||||
- DEBIAN_FRONTEND=noninteractive apt install -yq --no-install-recommends ./openrgb*amd64.deb
|
||||
- openrgb --version
|
||||
- openrgb -l
|
||||
- apt remove -y openrgb
|
||||
dependencies:
|
||||
- "Linux 64 .deb (Debian Bookworm)"
|
||||
@@ -451,6 +448,7 @@ before_script:
|
||||
- apt update
|
||||
- DEBIAN_FRONTEND=noninteractive apt install -yq --no-install-recommends ./openrgb*amd64.deb
|
||||
- openrgb --version
|
||||
- openrgb -l
|
||||
- apt remove -y openrgb
|
||||
dependencies:
|
||||
- "Linux 64 .deb (Debian Buster)"
|
||||
@@ -467,6 +465,7 @@ before_script:
|
||||
- apt update
|
||||
- DEBIAN_FRONTEND=noninteractive apt install -yq --no-install-recommends ./openrgb*amd64.deb
|
||||
- openrgb --version
|
||||
- openrgb -l
|
||||
- apt remove -y openrgb
|
||||
dependencies:
|
||||
- "Linux 64 .deb (Debian Bookworm)"
|
||||
@@ -482,6 +481,7 @@ before_script:
|
||||
script:
|
||||
- yum -y localinstall ./openrgb*64.rpm
|
||||
- openrgb --version
|
||||
- openrgb -l
|
||||
- yum -y remove openrgb
|
||||
dependencies:
|
||||
- "Linux 64 f35 rpm"
|
||||
@@ -497,6 +497,7 @@ before_script:
|
||||
script:
|
||||
- yum -y localinstall ./openrgb*64.rpm
|
||||
- openrgb --version
|
||||
- openrgb -l
|
||||
- yum -y remove openrgb
|
||||
dependencies:
|
||||
- "Linux 64 f36 rpm"
|
||||
@@ -528,9 +529,9 @@ before_script:
|
||||
- mkdir _qt
|
||||
- mkdir _qt_download
|
||||
- Push-Location _qt_download
|
||||
- curl.exe -LJ -o qt-base.7z 'https://gitlab.com/OpenRGBDevelopers/openrgb-linux-ci-deb-builder/-/package_files/55610076/download'
|
||||
- curl.exe -LJ -o qt-tools.7z 'https://gitlab.com/OpenRGBDevelopers/openrgb-linux-ci-deb-builder/-/package_files/55610097/download'
|
||||
- curl.exe -LJ -o qt-jom.zip 'https://gitlab.com/OpenRGBDevelopers/openrgb-linux-ci-deb-builder/-/package_files/55610138/download'
|
||||
- curl.exe -LJ -o qt-base.7z 'https://qt-mirror.dannhauer.de/online/qtsdkrepository/windows_x86/desktop/qt5_5150/qt.qt5.5150.win32_msvc2019/5.15.0-0-202005150700qtbase-Windows-Windows_10-MSVC2019-Windows-Windows_10-X86.7z'
|
||||
- curl.exe -LJ -o qt-tools.7z 'https://qt-mirror.dannhauer.de/online/qtsdkrepository/windows_x86/desktop/qt5_5150/qt.qt5.5150.win32_msvc2019/5.15.0-0-202005150700qttools-Windows-Windows_10-MSVC2019-Windows-Windows_10-X86.7z'
|
||||
- curl.exe -LJ -o qt-jom.zip 'https://qt-mirror.dannhauer.de/official_releases/jom/jom.zip'
|
||||
- _fold_final_
|
||||
|
||||
- _fold_start_ 'extracting the downloaded qt binaries'
|
||||
@@ -546,6 +547,10 @@ before_script:
|
||||
- Pop-Location
|
||||
- _fold_final_
|
||||
|
||||
- _fold_start_ 'Generate qm files'
|
||||
- .\_qt\5.15.0\msvc2019\bin\lrelease OpenRGB.pro
|
||||
- _fold_final_
|
||||
|
||||
- _fold_start_ 'run qmake and generate the msvc nmake makefile'
|
||||
- mkdir _build; cd _build
|
||||
- ..\_qt\5.15.0\msvc2019\bin\qmake ..\OpenRGB.pro
|
||||
@@ -570,8 +575,6 @@ before_script:
|
||||
name: "${CI_PROJECT_NAME}_Windows_32_${CI_COMMIT_SHORT_SHA}"
|
||||
paths:
|
||||
- 'OpenRGB Windows 32-bit'
|
||||
exclude:
|
||||
- 'OpenRGB Windows 32-bit\*.qm'
|
||||
expire_in: 30 days
|
||||
|
||||
rules:
|
||||
@@ -606,9 +609,9 @@ before_script:
|
||||
- mkdir _qt
|
||||
- mkdir _qt_download
|
||||
- Push-Location _qt_download
|
||||
- curl.exe -LJ -o qt-base.7z 'https://gitlab.com/OpenRGBDevelopers/openrgb-linux-ci-deb-builder/-/package_files/55610116/download'
|
||||
- curl.exe -LJ -o qt-tools.7z 'https://gitlab.com/OpenRGBDevelopers/openrgb-linux-ci-deb-builder/-/package_files/55610131/download'
|
||||
- curl.exe -LJ -o qt-jom.zip 'https://gitlab.com/OpenRGBDevelopers/openrgb-linux-ci-deb-builder/-/package_files/55610138/download'
|
||||
- curl.exe -LJ -o qt-base.7z 'https://qt-mirror.dannhauer.de/online/qtsdkrepository/windows_x86/desktop/qt5_5150/qt.qt5.5150.win64_msvc2019_64/5.15.0-0-202005150700qtbase-Windows-Windows_10-MSVC2019-Windows-Windows_10-X86_64.7z'
|
||||
- curl.exe -LJ -o qt-tools.7z 'https://qt-mirror.dannhauer.de/online/qtsdkrepository/windows_x86/desktop/qt5_5150/qt.qt5.5150.win64_msvc2019_64/5.15.0-0-202005150700qttools-Windows-Windows_10-MSVC2019-Windows-Windows_10-X86_64.7z'
|
||||
- curl.exe -LJ -o qt-jom.zip 'https://qt-mirror.dannhauer.de/official_releases/jom/jom.zip'
|
||||
- _fold_final_
|
||||
|
||||
- _fold_start_ 'extracting the downloaded qt binaries'
|
||||
@@ -624,6 +627,10 @@ before_script:
|
||||
- Pop-Location
|
||||
- _fold_final_
|
||||
|
||||
- _fold_start_ 'Generate qm files'
|
||||
- .\_qt\5.15.0\msvc2019_64\bin\lrelease OpenRGB.pro
|
||||
- _fold_final_
|
||||
|
||||
- _fold_start_ 'run qmake and generate the msvc nmake makefile'
|
||||
- mkdir _build; cd _build
|
||||
- ..\_qt\5.15.0\msvc2019_64\bin\qmake ..\OpenRGB.pro
|
||||
@@ -648,8 +655,6 @@ before_script:
|
||||
name: "${CI_PROJECT_NAME}_Windows_64_${CI_COMMIT_SHORT_SHA}"
|
||||
paths:
|
||||
- 'OpenRGB Windows 64-bit'
|
||||
exclude:
|
||||
- 'OpenRGB Windows 64-bit\*.qm'
|
||||
expire_in: 30 days
|
||||
|
||||
#-----------------------------------------------------------------------#
|
||||
|
||||
Vendored
-10
@@ -1,10 +0,0 @@
|
||||
{
|
||||
// See http://go.microsoft.com/fwlink/?LinkId=827846
|
||||
// for the documentation about the extensions.json format
|
||||
"recommendations": [
|
||||
"EditorConfig.EditorConfig"
|
||||
],
|
||||
"unwantedRecommendations": [
|
||||
"ms-vscode.cpptools-extension-pack"
|
||||
]
|
||||
}
|
||||
@@ -17,6 +17,8 @@ AMDWraithPrismController::AMDWraithPrismController(hid_device* dev_handle, const
|
||||
dev = dev_handle;
|
||||
location = path;
|
||||
|
||||
strcpy(device_name, "AMD Wraith Prism");
|
||||
|
||||
current_fan_mode = AMD_WRAITH_PRISM_FAN_LOGO_MODE_STATIC;
|
||||
current_fan_speed = 0xFF;
|
||||
current_fan_random_color = false;
|
||||
@@ -31,6 +33,8 @@ AMDWraithPrismController::AMDWraithPrismController(hid_device* dev_handle, const
|
||||
current_ring_speed = 0xFF;
|
||||
current_ring_direction = false;
|
||||
current_ring_brightness = 0xFF;
|
||||
|
||||
SendEnableCommand();
|
||||
}
|
||||
|
||||
AMDWraithPrismController::~AMDWraithPrismController()
|
||||
@@ -43,6 +47,11 @@ std::string AMDWraithPrismController::GetLocationString()
|
||||
return("HID: " + location);
|
||||
}
|
||||
|
||||
char* AMDWraithPrismController::GetDeviceName()
|
||||
{
|
||||
return device_name;
|
||||
}
|
||||
|
||||
std::string AMDWraithPrismController::GetSerialString()
|
||||
{
|
||||
wchar_t serial_string[128];
|
||||
@@ -59,6 +68,41 @@ std::string AMDWraithPrismController::GetSerialString()
|
||||
return(return_string);
|
||||
}
|
||||
|
||||
std::string AMDWraithPrismController::GetEffectChannelString(unsigned char channel)
|
||||
{
|
||||
std::string ret_string = "";
|
||||
|
||||
unsigned char usb_buf[] =
|
||||
{
|
||||
0x00,
|
||||
0x40, 0x21, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00,
|
||||
};
|
||||
|
||||
usb_buf[0x03] = channel;
|
||||
|
||||
hid_write(dev, usb_buf, 65);
|
||||
hid_read(dev, usb_buf, 64);
|
||||
|
||||
ret_string.append((char *)&usb_buf[0x08]);
|
||||
|
||||
return(ret_string);
|
||||
}
|
||||
|
||||
std::string AMDWraithPrismController::GetFirmwareVersionString()
|
||||
{
|
||||
std::string ret_string = "";
|
||||
@@ -188,7 +232,7 @@ void AMDWraithPrismController::SetRingEffectChannel(unsigned char channel)
|
||||
SendChannelRemap(channel, AMD_WRAITH_PRISM_EFFECT_CHANNEL_LOGO_LED, AMD_WRAITH_PRISM_EFFECT_CHANNEL_FAN_LED);
|
||||
}
|
||||
|
||||
void AMDWraithPrismController::SendEnableCommand(bool direct)
|
||||
void AMDWraithPrismController::SendEnableCommand()
|
||||
{
|
||||
unsigned char usb_buf[] =
|
||||
{
|
||||
@@ -211,11 +255,6 @@ void AMDWraithPrismController::SendEnableCommand(bool direct)
|
||||
0x00, 0x00, 0x00, 0x00,
|
||||
};
|
||||
|
||||
if(direct)
|
||||
{
|
||||
usb_buf[0x02] = 0x03;
|
||||
}
|
||||
|
||||
hid_write(dev, usb_buf, 65);
|
||||
hid_read(dev, usb_buf, 64);
|
||||
}
|
||||
@@ -247,48 +286,6 @@ void AMDWraithPrismController::SendApplyCommand()
|
||||
hid_read(dev, usb_buf, 64);
|
||||
}
|
||||
|
||||
void AMDWraithPrismController::SendDirectPacket
|
||||
(
|
||||
unsigned char size,
|
||||
unsigned char * led_ids,
|
||||
RGBColor * colors
|
||||
)
|
||||
{
|
||||
unsigned char usb_buf[] =
|
||||
{
|
||||
0x00,
|
||||
0xC0, 0x01, size, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00,
|
||||
};
|
||||
|
||||
for(unsigned int led_idx = 0; led_idx < size; led_idx++)
|
||||
{
|
||||
unsigned int index = led_idx * 4;
|
||||
|
||||
usb_buf[index + 5] = led_ids[led_idx];
|
||||
usb_buf[index + 6] = RGBGetRValue(colors[led_idx]);
|
||||
usb_buf[index + 7] = RGBGetGValue(colors[led_idx]);
|
||||
usb_buf[index + 8] = RGBGetBValue(colors[led_idx]);
|
||||
}
|
||||
|
||||
hid_write(dev, usb_buf, 65);
|
||||
hid_read(dev, usb_buf, 64);
|
||||
}
|
||||
|
||||
void AMDWraithPrismController::SendEffectChannelUpdate
|
||||
(
|
||||
unsigned char effect_channel,
|
||||
|
||||
@@ -10,8 +10,6 @@
|
||||
#include <string>
|
||||
#include <hidapi/hidapi.h>
|
||||
|
||||
#include "RGBController.h"
|
||||
|
||||
#pragma once
|
||||
|
||||
#define AMD_WRAITH_PRISM_FAN_BRIGHTNESS_DEFAULT_MAX 0xFF
|
||||
@@ -76,7 +74,6 @@ enum
|
||||
AMD_WRAITH_PRISM_EFFECT_CHANNEL_CHASE = 0x09, /* Chase effect channel */
|
||||
AMD_WRAITH_PRISM_EFFECT_CHANNEL_SWIRL = 0x0A, /* Swirl effect channel */
|
||||
AMD_WRAITH_PRISM_EFFECT_CHANNEL_MORSE = 0x0B, /* Morse code effect channel */
|
||||
AMD_WRAITH_PRISM_EFFECT_CHANNEL_DIRECT = 0xFF, /* Value for direct mode */
|
||||
};
|
||||
|
||||
enum
|
||||
@@ -94,11 +91,29 @@ public:
|
||||
AMDWraithPrismController(hid_device* dev_handle, const char* path);
|
||||
~AMDWraithPrismController();
|
||||
|
||||
char* GetDeviceName();
|
||||
|
||||
std::string GetEffectChannelString(unsigned char channel);
|
||||
std::string GetFirmwareVersionString();
|
||||
std::string GetLocationString();
|
||||
std::string GetSerialString();
|
||||
|
||||
void SetRingEffectChannel(unsigned char channel);
|
||||
|
||||
void SetFanMode(unsigned char mode, unsigned char speed, unsigned char brightness, bool random_color);
|
||||
void SetFanColor(unsigned char red, unsigned char green, unsigned char blue);
|
||||
|
||||
void SetLogoMode(unsigned char mode, unsigned char speed, unsigned char brightness, bool random_color);
|
||||
void SetLogoColor(unsigned char red, unsigned char green, unsigned char blue);
|
||||
|
||||
void SetRingMode(unsigned char mode, unsigned char speed, unsigned char brightness, bool direction, bool random_color);
|
||||
void SetRingColor(unsigned char red, unsigned char green, unsigned char blue);
|
||||
|
||||
private:
|
||||
char device_name[32];
|
||||
hid_device* dev;
|
||||
std::string location;
|
||||
|
||||
unsigned char current_fan_mode;
|
||||
unsigned char current_fan_speed;
|
||||
unsigned char current_fan_brightness;
|
||||
@@ -115,30 +130,10 @@ public:
|
||||
bool current_ring_direction;
|
||||
bool current_ring_random_color;
|
||||
|
||||
void SetFanMode(unsigned char mode, unsigned char speed, unsigned char brightness, bool random_color);
|
||||
void SetFanColor(unsigned char red, unsigned char green, unsigned char blue);
|
||||
void SetLogoMode(unsigned char mode, unsigned char speed, unsigned char brightness, bool random_color);
|
||||
void SetLogoColor(unsigned char red, unsigned char green, unsigned char blue);
|
||||
void SetRingMode(unsigned char mode, unsigned char speed, unsigned char brightness, bool direction, bool random_color);
|
||||
void SetRingColor(unsigned char red, unsigned char green, unsigned char blue);
|
||||
|
||||
void SendDirectPacket
|
||||
(
|
||||
unsigned char size,
|
||||
unsigned char * led_ids,
|
||||
RGBColor * colors
|
||||
);
|
||||
|
||||
void SendEnableCommand(bool direct);
|
||||
void SendEnableCommand();
|
||||
|
||||
void SendApplyCommand();
|
||||
|
||||
private:
|
||||
hid_device* dev;
|
||||
std::string location;
|
||||
|
||||
void SetRingEffectChannel(unsigned char channel);
|
||||
|
||||
void SendEffectChannelUpdate
|
||||
(
|
||||
unsigned char effect_channel,
|
||||
|
||||
@@ -33,29 +33,33 @@ RGBController_AMDWraithPrism::RGBController_AMDWraithPrism(AMDWraithPrismControl
|
||||
description = "AMD Wraith Prism Device";
|
||||
version = controller->GetFirmwareVersionString();
|
||||
location = controller->GetLocationString();
|
||||
/*-----------------------------------------------------*\
|
||||
| Don't use HID serial string, it is inconsistent on my |
|
||||
| Wraith Prism |
|
||||
\*-----------------------------------------------------*/
|
||||
serial = "";//controller->GetSerialString();
|
||||
|
||||
mode Direct;
|
||||
Direct.name = "Direct";
|
||||
Direct.value = AMD_WRAITH_PRISM_EFFECT_CHANNEL_DIRECT;
|
||||
Direct.value = AMD_WRAITH_PRISM_EFFECT_CHANNEL_STATIC;
|
||||
Direct.flags = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
|
||||
Direct.brightness_min = 0;
|
||||
Direct.brightness_max = 0;
|
||||
Direct.brightness = 0;
|
||||
Direct.brightness_max = AMD_WRAITH_PRISM_FAN_BRIGHTNESS_DEFAULT_MAX;
|
||||
Direct.brightness = AMD_WRAITH_PRISM_FAN_BRIGHTNESS_DEFAULT_MAX;
|
||||
Direct.color_mode = MODE_COLORS_PER_LED;
|
||||
modes.push_back(Direct);
|
||||
|
||||
mode Breathing;
|
||||
Breathing.name = "Breathing";
|
||||
Breathing.value = AMD_WRAITH_PRISM_EFFECT_CHANNEL_BREATHING;
|
||||
Breathing.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
|
||||
Breathing.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
|
||||
Breathing.speed_min = AMD_WRAITH_PRISM_SPEED_SLOWEST;
|
||||
Breathing.speed_max = AMD_WRAITH_PRISM_SPEED_FASTEST;
|
||||
Breathing.brightness_min = 0;
|
||||
Breathing.brightness_max = AMD_WRAITH_PRISM_FAN_BRIGHTNESS_DEFAULT_MAX;
|
||||
Breathing.brightness = AMD_WRAITH_PRISM_FAN_BRIGHTNESS_DEFAULT_MAX;
|
||||
Breathing.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Breathing.color_mode = MODE_COLORS_PER_LED;
|
||||
Breathing.speed = AMD_WRAITH_PRISM_SPEED_NORMAL;
|
||||
Breathing.colors.resize(3);
|
||||
modes.push_back(Breathing);
|
||||
|
||||
mode ColorCycle;
|
||||
@@ -100,29 +104,27 @@ RGBController_AMDWraithPrism::RGBController_AMDWraithPrism(AMDWraithPrismControl
|
||||
mode Chase;
|
||||
Chase.name = "Chase";
|
||||
Chase.value = AMD_WRAITH_PRISM_EFFECT_CHANNEL_CHASE;
|
||||
Chase.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
|
||||
Chase.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
|
||||
Chase.speed_min = AMD_WRAITH_PRISM_SPEED_SLOWEST;
|
||||
Chase.speed_max = AMD_WRAITH_PRISM_SPEED_FASTEST;
|
||||
Chase.brightness_min = 0;
|
||||
Chase.brightness_max = AMD_WRAITH_PRISM_FAN_BRIGHTNESS_DEFAULT_MAX;
|
||||
Chase.brightness = AMD_WRAITH_PRISM_FAN_BRIGHTNESS_DEFAULT_MAX;
|
||||
Chase.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Chase.color_mode = MODE_COLORS_PER_LED;
|
||||
Chase.speed = AMD_WRAITH_PRISM_SPEED_NORMAL;
|
||||
Chase.colors.resize(3);
|
||||
modes.push_back(Chase);
|
||||
|
||||
mode Swirl;
|
||||
Swirl.name = "Swirl";
|
||||
Swirl.value = AMD_WRAITH_PRISM_EFFECT_CHANNEL_SWIRL;
|
||||
Swirl.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
|
||||
Swirl.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
|
||||
Swirl.speed_min = AMD_WRAITH_PRISM_SPEED_SLOWEST;
|
||||
Swirl.speed_max = AMD_WRAITH_PRISM_SPEED_FASTEST;
|
||||
Swirl.brightness_min = 0;
|
||||
Swirl.brightness_max = AMD_WRAITH_PRISM_FAN_BRIGHTNESS_DEFAULT_MAX;
|
||||
Swirl.brightness = AMD_WRAITH_PRISM_FAN_BRIGHTNESS_DEFAULT_MAX;
|
||||
Swirl.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Swirl.color_mode = MODE_COLORS_PER_LED;
|
||||
Swirl.speed = AMD_WRAITH_PRISM_SPEED_NORMAL;
|
||||
Swirl.colors.resize(3);
|
||||
modes.push_back(Swirl);
|
||||
|
||||
SetupZones();
|
||||
@@ -135,14 +137,6 @@ RGBController_AMDWraithPrism::~RGBController_AMDWraithPrism()
|
||||
|
||||
void RGBController_AMDWraithPrism::SetupZones()
|
||||
{
|
||||
/*---------------------------------------------------------*\
|
||||
| LED maps |
|
||||
\*---------------------------------------------------------*/
|
||||
const unsigned int logo_leds[1] = { 0x00 };
|
||||
const unsigned int fan_leds[1] = { 0x01 };
|
||||
const unsigned int ring_leds[14] = { 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x10, 0x0F,
|
||||
0x0E, 0x0D, 0x0C, 0x0B, 0x0A, 0x09 };
|
||||
|
||||
/*---------------------------------------------------------*\
|
||||
| Set up zones |
|
||||
\*---------------------------------------------------------*/
|
||||
@@ -166,39 +160,27 @@ void RGBController_AMDWraithPrism::SetupZones()
|
||||
|
||||
zone ring_zone;
|
||||
ring_zone.name = "Ring";
|
||||
ring_zone.type = ZONE_TYPE_LINEAR;
|
||||
ring_zone.leds_min = 14;
|
||||
ring_zone.leds_max = 14;
|
||||
ring_zone.leds_count = 14;
|
||||
ring_zone.type = ZONE_TYPE_SINGLE;
|
||||
ring_zone.leds_min = 1;
|
||||
ring_zone.leds_max = 1;
|
||||
ring_zone.leds_count = 1;
|
||||
ring_zone.matrix_map = NULL;
|
||||
zones.push_back(ring_zone);
|
||||
|
||||
/*---------------------------------------------------------*\
|
||||
| Set up LEDs |
|
||||
\*---------------------------------------------------------*/
|
||||
for(unsigned int led_idx = 0; led_idx < 1; led_idx++)
|
||||
{
|
||||
led logo_led;
|
||||
logo_led.name = "Logo LED";
|
||||
logo_led.value = logo_leds[led_idx];
|
||||
leds.push_back(logo_led);
|
||||
}
|
||||
led logo_led;
|
||||
logo_led.name = "Logo LED";
|
||||
leds.push_back(logo_led);
|
||||
|
||||
for(unsigned int led_idx = 0; led_idx < 1; led_idx++)
|
||||
{
|
||||
led fan_led;
|
||||
fan_led.name = "Fan LED";
|
||||
fan_led.value = fan_leds[led_idx];
|
||||
leds.push_back(fan_led);
|
||||
}
|
||||
led fan_led;
|
||||
fan_led.name = "Fan LED";
|
||||
leds.push_back(fan_led);
|
||||
|
||||
for(unsigned int led_idx = 0; led_idx < 14; led_idx++)
|
||||
{
|
||||
led ring_led;
|
||||
ring_led.name = "Ring LED";
|
||||
ring_led.value = ring_leds[led_idx];
|
||||
leds.push_back(ring_led);
|
||||
}
|
||||
led ring_led;
|
||||
ring_led.name = "Ring LED";
|
||||
leds.push_back(ring_led);
|
||||
|
||||
SetupColors();
|
||||
}
|
||||
@@ -212,95 +194,68 @@ void RGBController_AMDWraithPrism::ResizeZone(int /*zone*/, int /*new_size*/)
|
||||
|
||||
void RGBController_AMDWraithPrism::DeviceUpdateLEDs()
|
||||
{
|
||||
if(modes[active_mode].color_mode == MODE_COLORS_PER_LED)
|
||||
unsigned char red = RGBGetRValue(colors[0]);
|
||||
unsigned char grn = RGBGetGValue(colors[0]);
|
||||
unsigned char blu = RGBGetBValue(colors[0]);
|
||||
controller->SetLogoColor(red, grn, blu);
|
||||
|
||||
red = RGBGetRValue(colors[1]);
|
||||
grn = RGBGetGValue(colors[1]);
|
||||
blu = RGBGetBValue(colors[1]);
|
||||
controller->SetFanColor(red, grn, blu);
|
||||
|
||||
red = RGBGetRValue(colors[2]);
|
||||
grn = RGBGetGValue(colors[2]);
|
||||
blu = RGBGetBValue(colors[2]);
|
||||
controller->SetRingColor(red, grn, blu);
|
||||
}
|
||||
|
||||
void RGBController_AMDWraithPrism::UpdateZoneLEDs(int zone)
|
||||
{
|
||||
RGBColor color = colors[zone];
|
||||
unsigned char red = RGBGetRValue(color);
|
||||
unsigned char grn = RGBGetGValue(color);
|
||||
unsigned char blu = RGBGetBValue(color);
|
||||
|
||||
if(zone == 0)
|
||||
{
|
||||
unsigned char led_ids[15];
|
||||
RGBColor color_buf[15];
|
||||
unsigned int leds_count = 0;
|
||||
|
||||
for(unsigned int led_idx = 0; led_idx < colors.size(); led_idx++)
|
||||
{
|
||||
led_ids[leds_count] = (unsigned char)leds[led_idx].value;
|
||||
color_buf[leds_count] = colors[led_idx];
|
||||
|
||||
leds_count++;
|
||||
|
||||
if(leds_count >= 15)
|
||||
{
|
||||
controller->SendDirectPacket(15, led_ids, color_buf);
|
||||
leds_count = 0;
|
||||
}
|
||||
}
|
||||
|
||||
if(leds_count > 0)
|
||||
{
|
||||
controller->SendDirectPacket(leds_count, led_ids, color_buf);
|
||||
}
|
||||
}
|
||||
else if(modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC)
|
||||
{
|
||||
unsigned char red = RGBGetRValue(modes[active_mode].colors[0]);
|
||||
unsigned char grn = RGBGetGValue(modes[active_mode].colors[0]);
|
||||
unsigned char blu = RGBGetBValue(modes[active_mode].colors[0]);
|
||||
controller->SetLogoColor(red, grn, blu);
|
||||
|
||||
red = RGBGetRValue(modes[active_mode].colors[1]);
|
||||
grn = RGBGetGValue(modes[active_mode].colors[1]);
|
||||
blu = RGBGetBValue(modes[active_mode].colors[1]);
|
||||
}
|
||||
else if(zone == 1)
|
||||
{
|
||||
controller->SetFanColor(red, grn, blu);
|
||||
|
||||
red = RGBGetRValue(modes[active_mode].colors[2]);
|
||||
grn = RGBGetGValue(modes[active_mode].colors[2]);
|
||||
blu = RGBGetBValue(modes[active_mode].colors[2]);
|
||||
}
|
||||
else if(zone == 2)
|
||||
{
|
||||
controller->SetRingColor(red, grn, blu);
|
||||
}
|
||||
else
|
||||
{
|
||||
controller->SetLogoColor(0, 0, 0);
|
||||
controller->SetFanColor(0, 0, 0);
|
||||
controller->SetRingColor(0, 0, 0);
|
||||
}
|
||||
}
|
||||
|
||||
void RGBController_AMDWraithPrism::UpdateZoneLEDs(int /*zone*/)
|
||||
void RGBController_AMDWraithPrism::UpdateSingleLED(int led)
|
||||
{
|
||||
DeviceUpdateLEDs();
|
||||
}
|
||||
|
||||
void RGBController_AMDWraithPrism::UpdateSingleLED(int /*led*/)
|
||||
{
|
||||
DeviceUpdateLEDs();
|
||||
UpdateZoneLEDs(led);
|
||||
}
|
||||
|
||||
void RGBController_AMDWraithPrism::DeviceUpdateMode()
|
||||
{
|
||||
bool random = (modes[active_mode].color_mode == MODE_COLORS_RANDOM);
|
||||
|
||||
controller->SetRingMode(modes[active_mode].value, modes[active_mode].speed, modes[active_mode].brightness, modes[active_mode].direction, random);
|
||||
|
||||
switch(modes[active_mode].value)
|
||||
{
|
||||
case AMD_WRAITH_PRISM_EFFECT_CHANNEL_DIRECT:
|
||||
controller->SendEnableCommand(true);
|
||||
controller->SendApplyCommand();
|
||||
break;
|
||||
|
||||
case AMD_WRAITH_PRISM_EFFECT_CHANNEL_COLOR_CYCLE:
|
||||
controller->SendEnableCommand(false);
|
||||
controller->SetRingMode(modes[active_mode].value, modes[active_mode].speed, modes[active_mode].brightness, modes[active_mode].direction, random);
|
||||
controller->SetFanMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_COLOR_CYCLE, modes[active_mode].speed, modes[active_mode].brightness, random);
|
||||
controller->SetLogoMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_COLOR_CYCLE, modes[active_mode].speed, modes[active_mode].brightness, random);
|
||||
break;
|
||||
|
||||
case AMD_WRAITH_PRISM_EFFECT_CHANNEL_RAINBOW:
|
||||
case AMD_WRAITH_PRISM_EFFECT_CHANNEL_BOUNCE:
|
||||
controller->SendEnableCommand(false);
|
||||
controller->SetRingMode(modes[active_mode].value, modes[active_mode].speed, modes[active_mode].brightness, modes[active_mode].direction, random);
|
||||
controller->SetFanMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_COLOR_CYCLE, modes[active_mode].speed, (modes[active_mode].brightness >> 1), random);
|
||||
controller->SetLogoMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_COLOR_CYCLE, modes[active_mode].speed, (modes[active_mode].brightness >> 1), random);
|
||||
break;
|
||||
|
||||
case AMD_WRAITH_PRISM_EFFECT_CHANNEL_BREATHING:
|
||||
controller->SendEnableCommand(false);
|
||||
controller->SetRingMode(modes[active_mode].value, modes[active_mode].speed, modes[active_mode].brightness, modes[active_mode].direction, random);
|
||||
controller->SetFanMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_BREATHING, modes[active_mode].speed, modes[active_mode].brightness, random);
|
||||
controller->SetLogoMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_BREATHING, modes[active_mode].speed, modes[active_mode].brightness, random);
|
||||
break;
|
||||
@@ -308,15 +263,11 @@ void RGBController_AMDWraithPrism::DeviceUpdateMode()
|
||||
default:
|
||||
if(random)
|
||||
{
|
||||
controller->SendEnableCommand(false);
|
||||
controller->SetRingMode(modes[active_mode].value, modes[active_mode].speed, modes[active_mode].brightness, modes[active_mode].direction, random);
|
||||
controller->SetFanMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_COLOR_CYCLE, modes[active_mode].speed, modes[active_mode].brightness, random);
|
||||
controller->SetLogoMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_COLOR_CYCLE, modes[active_mode].speed, modes[active_mode].brightness, random);
|
||||
}
|
||||
else
|
||||
{
|
||||
controller->SendEnableCommand(false);
|
||||
controller->SetRingMode(modes[active_mode].value, modes[active_mode].speed, modes[active_mode].brightness, modes[active_mode].direction, random);
|
||||
controller->SetFanMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_STATIC, modes[active_mode].speed, modes[active_mode].brightness, random);
|
||||
controller->SetLogoMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_STATIC, modes[active_mode].speed, modes[active_mode].brightness, random);
|
||||
}
|
||||
|
||||
@@ -1,211 +0,0 @@
|
||||
/*-----------------------------------------*\
|
||||
| AOCKeyboardController.cpp |
|
||||
| |
|
||||
| Driver for AOC Keyboard lighting |
|
||||
| controller |
|
||||
| |
|
||||
| Adam Honse (CalcProgrammer1) 5/10/2023 |
|
||||
\*-----------------------------------------*/
|
||||
|
||||
#include "AOCKeyboardController.h"
|
||||
|
||||
#include <cstring>
|
||||
#include <chrono>
|
||||
#include <thread>
|
||||
|
||||
using namespace std::chrono_literals;
|
||||
|
||||
AOCKeyboardController::AOCKeyboardController(hid_device* dev_handle, const char* path)
|
||||
{
|
||||
dev = dev_handle;
|
||||
location = path;
|
||||
}
|
||||
|
||||
AOCKeyboardController::~AOCKeyboardController()
|
||||
{
|
||||
hid_close(dev);
|
||||
}
|
||||
|
||||
std::string AOCKeyboardController::GetDeviceLocation()
|
||||
{
|
||||
return("HID " + location);
|
||||
}
|
||||
|
||||
std::string AOCKeyboardController::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 AOCKeyboardController::SetLightingConfig
|
||||
(
|
||||
unsigned char mode,
|
||||
unsigned char random,
|
||||
unsigned char brightness,
|
||||
unsigned char speed,
|
||||
unsigned char direction,
|
||||
RGBColor* color_data
|
||||
)
|
||||
{
|
||||
SendStartPacket();
|
||||
std::this_thread::sleep_for(5ms);
|
||||
|
||||
SendLightingConfigPacket(mode, random, brightness, speed, direction, color_data);
|
||||
std::this_thread::sleep_for(5ms);
|
||||
|
||||
SendEndPacket();
|
||||
std::this_thread::sleep_for(10ms);
|
||||
}
|
||||
|
||||
void AOCKeyboardController::SetCustom
|
||||
(
|
||||
RGBColor* color_data
|
||||
)
|
||||
{
|
||||
SendStartPacket();
|
||||
std::this_thread::sleep_for(5ms);
|
||||
|
||||
SendCustomPacket(color_data);
|
||||
std::this_thread::sleep_for(5ms);
|
||||
|
||||
SendEndPacket();
|
||||
std::this_thread::sleep_for(5ms);
|
||||
}
|
||||
|
||||
/*-------------------------------------------------------------------------------------------------*\
|
||||
| Private packet sending functions. |
|
||||
\*-------------------------------------------------------------------------------------------------*/
|
||||
|
||||
void AOCKeyboardController::SendStartPacket()
|
||||
{
|
||||
unsigned char buf[64];
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Zero out buffer |
|
||||
\*-----------------------------------------------------*/
|
||||
memset(buf, 0x00, sizeof(buf));
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Set up start packet |
|
||||
\*-----------------------------------------------------*/
|
||||
buf[0x00] = 0x09;
|
||||
buf[0x01] = 0x21;
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Send packet |
|
||||
\*-----------------------------------------------------*/
|
||||
hid_write(dev, buf, sizeof(buf));
|
||||
}
|
||||
|
||||
void AOCKeyboardController::SendEndPacket()
|
||||
{
|
||||
unsigned char buf[64];
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Zero out buffer |
|
||||
\*-----------------------------------------------------*/
|
||||
memset(buf, 0x00, sizeof(buf));
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Set up end packet |
|
||||
\*-----------------------------------------------------*/
|
||||
buf[0x00] = 0x09;
|
||||
buf[0x01] = 0x22;
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Send packet |
|
||||
\*-----------------------------------------------------*/
|
||||
hid_write(dev, buf, sizeof(buf));
|
||||
}
|
||||
|
||||
void AOCKeyboardController::SendCustomPacket
|
||||
(
|
||||
RGBColor* color_data
|
||||
)
|
||||
{
|
||||
unsigned char buf[361];
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Zero out buffer |
|
||||
\*-----------------------------------------------------*/
|
||||
memset(buf, 0x00, sizeof(buf));
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Set up custom lighting packet |
|
||||
\*-----------------------------------------------------*/
|
||||
buf[0x00] = 0x20;
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Copy in color data |
|
||||
\*-----------------------------------------------------*/
|
||||
for(unsigned int color_idx = 0; color_idx < 120; color_idx++)
|
||||
{
|
||||
buf[color_idx + 1] = RGBGetRValue(color_data[color_idx]);
|
||||
buf[color_idx + 121] = RGBGetGValue(color_data[color_idx]);
|
||||
buf[color_idx + 241] = RGBGetBValue(color_data[color_idx]);
|
||||
}
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Send packet |
|
||||
\*-----------------------------------------------------*/
|
||||
hid_send_feature_report(dev, buf, sizeof(buf));
|
||||
}
|
||||
|
||||
void AOCKeyboardController::SendLightingConfigPacket
|
||||
(
|
||||
unsigned char mode,
|
||||
unsigned char random,
|
||||
unsigned char brightness,
|
||||
unsigned char speed,
|
||||
unsigned char direction,
|
||||
RGBColor* color_data
|
||||
)
|
||||
{
|
||||
unsigned char buf[117];
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Zero out buffer |
|
||||
\*-----------------------------------------------------*/
|
||||
memset(buf, 0x00, sizeof(buf));
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Set up lighting configuration packet |
|
||||
\*-----------------------------------------------------*/
|
||||
buf[0x00] = 0x14;
|
||||
buf[0x01] = 0x01;
|
||||
|
||||
buf[0x06] = mode;
|
||||
|
||||
buf[0x07 + (9 * mode) + 0] = RGBGetRValue(color_data[0]);
|
||||
buf[0x07 + (9 * mode) + 1] = RGBGetGValue(color_data[0]);
|
||||
buf[0x07 + (9 * mode) + 2] = RGBGetBValue(color_data[0]);
|
||||
buf[0x07 + (9 * mode) + 3] = random;
|
||||
buf[0x07 + (9 * mode) + 4] = direction;
|
||||
buf[0x07 + (9 * mode) + 5] = speed;
|
||||
buf[0x07 + (9 * mode) + 6] = brightness;
|
||||
|
||||
unsigned short checksum = 0x4A9E;
|
||||
|
||||
for(unsigned int buf_idx = 0; buf_idx < 115; buf_idx++)
|
||||
{
|
||||
checksum += buf[buf_idx];
|
||||
}
|
||||
|
||||
buf[115] = checksum & 0xFF;
|
||||
buf[116] = checksum >> 8;
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Send packet |
|
||||
\*-----------------------------------------------------*/
|
||||
hid_send_feature_report(dev, buf, 117);
|
||||
}
|
||||
@@ -1,107 +0,0 @@
|
||||
/*-----------------------------------------*\
|
||||
| AOCKeyboardController.h |
|
||||
| |
|
||||
| Definitions and types for AOC keyboard |
|
||||
| lighting controller |
|
||||
| |
|
||||
| Adam Honse (CalcProgrammer1) 5/10/2023 |
|
||||
\*-----------------------------------------*/
|
||||
|
||||
#include "RGBController.h"
|
||||
#include <hidapi/hidapi.h>
|
||||
#include <string>
|
||||
|
||||
#pragma once
|
||||
|
||||
/*-----------------------------------------*\
|
||||
| AOC Keyboard Modes |
|
||||
\*-----------------------------------------*/
|
||||
enum
|
||||
{
|
||||
AOC_KEYBOARD_MODE_STATIC = 0x00, /* Static mode */
|
||||
AOC_KEYBOARD_MODE_BREATHING = 0x01, /* Breathing mode */
|
||||
AOC_KEYBOARD_MODE_REACT = 0x02, /* React mode */
|
||||
AOC_KEYBOARD_MODE_RIPPLE = 0x04, /* Ripple mode */
|
||||
AOC_KEYBOARD_MODE_RADAR = 0x05, /* Radar mode */
|
||||
AOC_KEYBOARD_MODE_FIREWORKS = 0x06, /* Fireworks mode */
|
||||
AOC_KEYBOARD_MODE_BLINK = 0x07, /* Blink mode */
|
||||
AOC_KEYBOARD_MODE_WAVE = 0x08, /* Wave mode */
|
||||
AOC_KEYBOARD_MODE_CUSTOM = 0x09, /* Custom mode */
|
||||
AOC_KEYBOARD_MODE_CONCENTRIC_CIRCLES = 0x0A, /* Concentric Circles mode */
|
||||
AOC_KEYBOARD_MODE_W_WAVE = 0x0B, /* W Wave mode */
|
||||
};
|
||||
|
||||
enum
|
||||
{
|
||||
AOC_KEYBOARD_SPEED_SLOW = 0x03, /* Slowest speed */
|
||||
AOC_KEYBOARD_SPEED_MEDIUM = 0x02, /* Medium speed */
|
||||
AOC_KEYBOARD_SPEED_FAST = 0x01, /* Fastest speed */
|
||||
};
|
||||
|
||||
enum
|
||||
{
|
||||
AOC_KEYBOARD_BRIGHTNESS_OFF = 0x00, /* Lowest brightness (off) */
|
||||
AOC_KEYBOARD_BRIGHTNESS_LOW = 0x01, /* Low brightness */
|
||||
AOC_KEYBOARD_BRIGHTNESS_MEDIUM = 0x02, /* Medium brightness */
|
||||
AOC_KEYBOARD_BRIGHTNESS_HIGH = 0x03, /* Highest brightness */
|
||||
};
|
||||
|
||||
enum
|
||||
{
|
||||
AOC_KEYBOARD_SINGLE_COLOR = 0x00, /* Single color mode */
|
||||
AOC_KEYBOARD_RANDOM = 0x01, /* Random color mode */
|
||||
};
|
||||
|
||||
enum
|
||||
{
|
||||
AOC_KEYBOARD_DIRECTION_CLOCKWISE = 0x00, /* Clockwise direction */
|
||||
AOC_KEYBOARD_DIRECTION_COUNTERCLOCKWISE = 0x01, /* Counter-clockwise direction */
|
||||
};
|
||||
|
||||
|
||||
class AOCKeyboardController
|
||||
{
|
||||
public:
|
||||
AOCKeyboardController(hid_device* dev_handle, const char* path);
|
||||
~AOCKeyboardController();
|
||||
|
||||
std::string GetDeviceLocation();
|
||||
std::string GetSerialString();
|
||||
|
||||
void SetLightingConfig
|
||||
(
|
||||
unsigned char mode,
|
||||
unsigned char random,
|
||||
unsigned char brightness,
|
||||
unsigned char speed,
|
||||
unsigned char direction,
|
||||
RGBColor* color_data
|
||||
);
|
||||
|
||||
void SetCustom
|
||||
(
|
||||
RGBColor* color_data
|
||||
);
|
||||
|
||||
private:
|
||||
hid_device* dev;
|
||||
std::string location;
|
||||
|
||||
void SendStartPacket();
|
||||
void SendEndPacket();
|
||||
|
||||
void SendCustomPacket
|
||||
(
|
||||
RGBColor* color_data
|
||||
);
|
||||
|
||||
void SendLightingConfigPacket
|
||||
(
|
||||
unsigned char mode,
|
||||
unsigned char random,
|
||||
unsigned char brightness,
|
||||
unsigned char speed,
|
||||
unsigned char direction,
|
||||
RGBColor* color_data
|
||||
);
|
||||
};
|
||||
@@ -1,34 +0,0 @@
|
||||
#include "Detector.h"
|
||||
#include "AOCKeyboardController.h"
|
||||
#include "RGBController.h"
|
||||
#include "RGBController_AOCKeyboard.h"
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| AOC Mousemat IDs |
|
||||
\*-----------------------------------------------------*/
|
||||
#define AOC_VID 0x3938
|
||||
#define AOC_GK500_PID 0x1178
|
||||
|
||||
/******************************************************************************************\
|
||||
* *
|
||||
* DetectAOCKeyboardControllers *
|
||||
* *
|
||||
* Tests the USB address to see if an AOC Keyboard controller exists there. *
|
||||
* *
|
||||
\******************************************************************************************/
|
||||
|
||||
void DetectAOCKeyboardControllers(hid_device_info* info, const std::string& name)
|
||||
{
|
||||
hid_device* dev = hid_open_path(info->path);
|
||||
|
||||
if(dev)
|
||||
{
|
||||
AOCKeyboardController* controller = new AOCKeyboardController(dev, info->path);
|
||||
RGBController_AOCKeyboard* rgb_controller = new RGBController_AOCKeyboard(controller);
|
||||
rgb_controller->name = name;
|
||||
|
||||
ResourceManager::get()->RegisterRGBController(rgb_controller);
|
||||
}
|
||||
}
|
||||
|
||||
REGISTER_HID_DETECTOR_PU("AOC GK500", DetectAOCKeyboardControllers, AOC_VID, AOC_GK500_PID, 0xFF19, 0xFF19);
|
||||
@@ -1,370 +0,0 @@
|
||||
/*-----------------------------------------*\
|
||||
| RGBController_AOCKeyboard.cpp |
|
||||
| |
|
||||
| Generic RGB Interface for AOC keyboard |
|
||||
| |
|
||||
| Adam Honse (CalcProgrammer1) 5/10/2023 |
|
||||
\*-----------------------------------------*/
|
||||
|
||||
#include "RGBController_AOCKeyboard.h"
|
||||
#include "KeyboardLayoutManager.h"
|
||||
|
||||
/**--------------------------------------------------------------------*\
|
||||
@name AOC Keyboard
|
||||
@category Keyboard
|
||||
@type USB
|
||||
@save :x:
|
||||
@direct :white_check_mark:
|
||||
@effects :white_check_mark:
|
||||
@detectors DetectAOCKeyboardControllers
|
||||
@comment
|
||||
\*---------------------------------------------------------------------*/
|
||||
|
||||
/*---------------------------------------------------------------------*\
|
||||
| AOC Keyboard KLM Layout |
|
||||
\*---------------------------------------------------------------------*/
|
||||
layout_values aoc_keyboard_offset_values =
|
||||
{
|
||||
{
|
||||
/* ESC F1 F2 F3 F4 F5 F6 F7 F8 F9 F10 F11 F12 PRSC SCLK PSBK */
|
||||
90, 92, 77, 63, 79, 94, 81, 96, 82, 83, 98, 40, 55, 85, 100, 104,
|
||||
/* BKTK 1 2 3 4 5 6 7 8 9 0 - = BSPC INS HOME PGUP NLCK NP/ NP* NP- */
|
||||
75, 76, 91, 62, 48, 64, 50, 65, 66, 67, 97, 68, 84, 70, 59, 74, 89, 58, 73, 88, 103,
|
||||
/* TAB Q W E R T Y U I O P [ ] \ DEL END PGDN NP7 NP8 NP9 NP+ */
|
||||
60, 61, 47, 78, 33, 49, 35, 80, 51, 52, 53, 69, 99, 25, 44, 29, 14, 43, 28, 13, 102,
|
||||
/* CPLK A S D F G H J K L ; " ENTR NP4 NP5 NP6 */
|
||||
45, 46, 32, 93, 18, 34, 20, 95, 36, 37, 38, 54, 10, 57, 72, 87,
|
||||
/* LSFT Z X C V B N M , . / RSFT ARWU NP1 NP2 NP3 NPEN */
|
||||
30, 31, 17, 2, 3, 19, 5, 6, 21, 22, 23, 39, 11, 42, 27, 12, 101,
|
||||
/* LCTL LWIN LALT SPC RALT RFNC RMNU RCTL ARWL ARWD ARWR NP0 NP. */
|
||||
15, 0, 1, 4, 7, 8, 24, 9, 26, 41, 56, 71, 86
|
||||
},
|
||||
{
|
||||
/* Add more regional layout fixes here */
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
RGBController_AOCKeyboard::RGBController_AOCKeyboard(AOCKeyboardController* controller_ptr)
|
||||
{
|
||||
controller = controller_ptr;
|
||||
|
||||
name = "AOC Keyboard Device";
|
||||
vendor = "AOC";
|
||||
type = DEVICE_TYPE_KEYBOARD;
|
||||
description = "AOC Keyboard Device";
|
||||
location = controller->GetDeviceLocation();
|
||||
serial = controller->GetSerialString();
|
||||
|
||||
mode Static;
|
||||
Static.name = "Static";
|
||||
Static.value = AOC_KEYBOARD_MODE_STATIC;
|
||||
Static.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
|
||||
Static.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Static.brightness_min = AOC_KEYBOARD_BRIGHTNESS_OFF;
|
||||
Static.brightness_max = AOC_KEYBOARD_BRIGHTNESS_HIGH;
|
||||
Static.brightness = AOC_KEYBOARD_BRIGHTNESS_HIGH;
|
||||
Static.colors_min = 1;
|
||||
Static.colors_max = 1;
|
||||
Static.colors.resize(1);
|
||||
modes.push_back(Static);
|
||||
|
||||
mode SpectrumCycle;
|
||||
SpectrumCycle.name = "Spectrum Cycle";
|
||||
SpectrumCycle.value = AOC_KEYBOARD_MODE_STATIC;
|
||||
SpectrumCycle.flags = MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
|
||||
SpectrumCycle.color_mode = MODE_COLORS_RANDOM;
|
||||
SpectrumCycle.brightness_min = AOC_KEYBOARD_BRIGHTNESS_OFF;
|
||||
SpectrumCycle.brightness_max = AOC_KEYBOARD_BRIGHTNESS_HIGH;
|
||||
SpectrumCycle.brightness = AOC_KEYBOARD_BRIGHTNESS_HIGH;
|
||||
SpectrumCycle.speed_min = AOC_KEYBOARD_SPEED_SLOW;
|
||||
SpectrumCycle.speed_max = AOC_KEYBOARD_SPEED_FAST;
|
||||
SpectrumCycle.speed = AOC_KEYBOARD_SPEED_MEDIUM;
|
||||
modes.push_back(SpectrumCycle);
|
||||
|
||||
mode Breathing;
|
||||
Breathing.name = "Breathing";
|
||||
Breathing.value = AOC_KEYBOARD_MODE_BREATHING;
|
||||
Breathing.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
|
||||
Breathing.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Breathing.brightness_min = AOC_KEYBOARD_BRIGHTNESS_OFF;
|
||||
Breathing.brightness_max = AOC_KEYBOARD_BRIGHTNESS_HIGH;
|
||||
Breathing.brightness = AOC_KEYBOARD_BRIGHTNESS_HIGH;
|
||||
Breathing.speed_min = AOC_KEYBOARD_SPEED_SLOW;
|
||||
Breathing.speed_max = AOC_KEYBOARD_SPEED_FAST;
|
||||
Breathing.speed = AOC_KEYBOARD_SPEED_MEDIUM;
|
||||
Breathing.colors_min = 1;
|
||||
Breathing.colors_max = 1;
|
||||
Breathing.colors.resize(1);
|
||||
modes.push_back(Breathing);
|
||||
|
||||
mode React;
|
||||
React.name = "React";
|
||||
React.value = AOC_KEYBOARD_MODE_REACT;
|
||||
React.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
|
||||
React.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
React.brightness_min = AOC_KEYBOARD_BRIGHTNESS_OFF;
|
||||
React.brightness_max = AOC_KEYBOARD_BRIGHTNESS_HIGH;
|
||||
React.brightness = AOC_KEYBOARD_BRIGHTNESS_HIGH;
|
||||
React.speed_min = AOC_KEYBOARD_SPEED_SLOW;
|
||||
React.speed_max = AOC_KEYBOARD_SPEED_FAST;
|
||||
React.speed = AOC_KEYBOARD_SPEED_MEDIUM;
|
||||
React.colors_min = 1;
|
||||
React.colors_max = 1;
|
||||
React.colors.resize(1);
|
||||
modes.push_back(React);
|
||||
|
||||
mode Ripple;
|
||||
Ripple.name = "Ripple";
|
||||
Ripple.value = AOC_KEYBOARD_MODE_RIPPLE;
|
||||
Ripple.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
|
||||
Ripple.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Ripple.brightness_min = AOC_KEYBOARD_BRIGHTNESS_OFF;
|
||||
Ripple.brightness_max = AOC_KEYBOARD_BRIGHTNESS_HIGH;
|
||||
Ripple.brightness = AOC_KEYBOARD_BRIGHTNESS_HIGH;
|
||||
Ripple.speed_min = AOC_KEYBOARD_SPEED_SLOW;
|
||||
Ripple.speed_max = AOC_KEYBOARD_SPEED_FAST;
|
||||
Ripple.speed = AOC_KEYBOARD_SPEED_MEDIUM;
|
||||
Ripple.colors_min = 1;
|
||||
Ripple.colors_max = 1;
|
||||
Ripple.colors.resize(1);
|
||||
modes.push_back(Ripple);
|
||||
|
||||
mode Radar;
|
||||
Radar.name = "Radar";
|
||||
Radar.value = AOC_KEYBOARD_MODE_RADAR;
|
||||
Radar.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
|
||||
Radar.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Radar.brightness_min = AOC_KEYBOARD_BRIGHTNESS_OFF;
|
||||
Radar.brightness_max = AOC_KEYBOARD_BRIGHTNESS_HIGH;
|
||||
Radar.brightness = AOC_KEYBOARD_BRIGHTNESS_HIGH;
|
||||
Radar.speed_min = AOC_KEYBOARD_SPEED_SLOW;
|
||||
Radar.speed_max = AOC_KEYBOARD_SPEED_FAST;
|
||||
Radar.speed = AOC_KEYBOARD_SPEED_MEDIUM;
|
||||
Radar.colors_min = 1;
|
||||
Radar.colors_max = 1;
|
||||
Radar.colors.resize(1);
|
||||
modes.push_back(Radar);
|
||||
|
||||
mode Fireworks;
|
||||
Fireworks.name = "Fireworks";
|
||||
Fireworks.value = AOC_KEYBOARD_MODE_FIREWORKS;
|
||||
Fireworks.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
|
||||
Fireworks.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Fireworks.brightness_min = AOC_KEYBOARD_BRIGHTNESS_OFF;
|
||||
Fireworks.brightness_max = AOC_KEYBOARD_BRIGHTNESS_HIGH;
|
||||
Fireworks.brightness = AOC_KEYBOARD_BRIGHTNESS_HIGH;
|
||||
Fireworks.speed_min = AOC_KEYBOARD_SPEED_SLOW;
|
||||
Fireworks.speed_max = AOC_KEYBOARD_SPEED_FAST;
|
||||
Fireworks.speed = AOC_KEYBOARD_SPEED_MEDIUM;
|
||||
Fireworks.colors_min = 1;
|
||||
Fireworks.colors_max = 1;
|
||||
Fireworks.colors.resize(1);
|
||||
modes.push_back(Fireworks);
|
||||
|
||||
mode Blink;
|
||||
Blink.name = "Flashing";
|
||||
Blink.value = AOC_KEYBOARD_MODE_BLINK;
|
||||
Blink.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
|
||||
Blink.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Blink.brightness_min = AOC_KEYBOARD_BRIGHTNESS_OFF;
|
||||
Blink.brightness_max = AOC_KEYBOARD_BRIGHTNESS_HIGH;
|
||||
Blink.brightness = AOC_KEYBOARD_BRIGHTNESS_HIGH;
|
||||
Blink.speed_min = AOC_KEYBOARD_SPEED_SLOW;
|
||||
Blink.speed_max = AOC_KEYBOARD_SPEED_FAST;
|
||||
Blink.speed = AOC_KEYBOARD_SPEED_MEDIUM;
|
||||
Blink.colors_min = 1;
|
||||
Blink.colors_max = 1;
|
||||
Blink.colors.resize(1);
|
||||
modes.push_back(Blink);
|
||||
|
||||
mode Wave;
|
||||
Wave.name = "Wave";
|
||||
Wave.value = AOC_KEYBOARD_MODE_WAVE;
|
||||
Wave.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
|
||||
Wave.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Wave.brightness_min = AOC_KEYBOARD_BRIGHTNESS_OFF;
|
||||
Wave.brightness_max = AOC_KEYBOARD_BRIGHTNESS_HIGH;
|
||||
Wave.brightness = AOC_KEYBOARD_BRIGHTNESS_HIGH;
|
||||
Wave.speed_min = AOC_KEYBOARD_SPEED_SLOW;
|
||||
Wave.speed_max = AOC_KEYBOARD_SPEED_FAST;
|
||||
Wave.speed = AOC_KEYBOARD_SPEED_MEDIUM;
|
||||
Wave.colors_min = 1;
|
||||
Wave.colors_max = 1;
|
||||
Wave.colors.resize(1);
|
||||
modes.push_back(Wave);
|
||||
|
||||
mode RainbowWave;
|
||||
RainbowWave.name = "Rainbow Wave";
|
||||
RainbowWave.value = AOC_KEYBOARD_MODE_WAVE;
|
||||
RainbowWave.flags = MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
|
||||
RainbowWave.color_mode = MODE_COLORS_RANDOM;
|
||||
RainbowWave.brightness_min = AOC_KEYBOARD_BRIGHTNESS_OFF;
|
||||
RainbowWave.brightness_max = AOC_KEYBOARD_BRIGHTNESS_HIGH;
|
||||
RainbowWave.brightness = AOC_KEYBOARD_BRIGHTNESS_HIGH;
|
||||
RainbowWave.speed_min = AOC_KEYBOARD_SPEED_SLOW;
|
||||
RainbowWave.speed_max = AOC_KEYBOARD_SPEED_FAST;
|
||||
RainbowWave.speed = AOC_KEYBOARD_SPEED_MEDIUM;
|
||||
modes.push_back(RainbowWave);
|
||||
|
||||
mode ConcentricCircles;
|
||||
ConcentricCircles.name = "Concentric Circles";
|
||||
ConcentricCircles.value = AOC_KEYBOARD_MODE_CONCENTRIC_CIRCLES;
|
||||
ConcentricCircles.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
|
||||
ConcentricCircles.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
ConcentricCircles.brightness_min= AOC_KEYBOARD_BRIGHTNESS_OFF;
|
||||
ConcentricCircles.brightness_max= AOC_KEYBOARD_BRIGHTNESS_HIGH;
|
||||
ConcentricCircles.brightness = AOC_KEYBOARD_BRIGHTNESS_HIGH;
|
||||
ConcentricCircles.speed_min = AOC_KEYBOARD_SPEED_SLOW;
|
||||
ConcentricCircles.speed_max = AOC_KEYBOARD_SPEED_FAST;
|
||||
ConcentricCircles.speed = AOC_KEYBOARD_SPEED_MEDIUM;
|
||||
ConcentricCircles.colors_min = 1;
|
||||
ConcentricCircles.colors_max = 1;
|
||||
ConcentricCircles.colors.resize(1);
|
||||
modes.push_back(ConcentricCircles);
|
||||
|
||||
mode WWave;
|
||||
WWave.name = "W Wave";
|
||||
WWave.value = AOC_KEYBOARD_MODE_W_WAVE;
|
||||
WWave.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
|
||||
WWave.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
WWave.brightness_min = AOC_KEYBOARD_BRIGHTNESS_OFF;
|
||||
WWave.brightness_max = AOC_KEYBOARD_BRIGHTNESS_HIGH;
|
||||
WWave.brightness = AOC_KEYBOARD_BRIGHTNESS_HIGH;
|
||||
WWave.speed_min = AOC_KEYBOARD_SPEED_SLOW;
|
||||
WWave.speed_max = AOC_KEYBOARD_SPEED_FAST;
|
||||
WWave.speed = AOC_KEYBOARD_SPEED_MEDIUM;
|
||||
WWave.colors_min = 1;
|
||||
WWave.colors_max = 1;
|
||||
WWave.colors.resize(1);
|
||||
modes.push_back(WWave);
|
||||
|
||||
mode Direct;
|
||||
Direct.name = "Direct";
|
||||
Direct.value = AOC_KEYBOARD_MODE_CUSTOM;
|
||||
Direct.flags = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
|
||||
Direct.color_mode = MODE_COLORS_PER_LED;
|
||||
Direct.brightness_min = AOC_KEYBOARD_BRIGHTNESS_OFF;
|
||||
Direct.brightness_max = AOC_KEYBOARD_BRIGHTNESS_HIGH;
|
||||
Direct.brightness = AOC_KEYBOARD_BRIGHTNESS_HIGH;
|
||||
modes.push_back(Direct);
|
||||
|
||||
SetupZones();
|
||||
};
|
||||
|
||||
RGBController_AOCKeyboard::~RGBController_AOCKeyboard()
|
||||
{
|
||||
delete controller;
|
||||
}
|
||||
|
||||
void RGBController_AOCKeyboard::SetupZones()
|
||||
{
|
||||
/*---------------------------------------------------------*\
|
||||
| Create the keyboard zone usiung Keyboard Layout Manager |
|
||||
\*---------------------------------------------------------*/
|
||||
zone new_zone;
|
||||
new_zone.name = ZONE_EN_KEYBOARD;
|
||||
new_zone.type = ZONE_TYPE_MATRIX;
|
||||
|
||||
KeyboardLayoutManager new_kb(KEYBOARD_LAYOUT_ANSI_QWERTY, KEYBOARD_SIZE_FULL, aoc_keyboard_offset_values);
|
||||
|
||||
matrix_map_type * new_map = new matrix_map_type;
|
||||
new_zone.matrix_map = new_map;
|
||||
new_zone.matrix_map->height = new_kb.GetRowCount();
|
||||
new_zone.matrix_map->width = new_kb.GetColumnCount();
|
||||
|
||||
new_zone.matrix_map->map = new unsigned int[new_map->height * new_map->width];
|
||||
new_zone.leds_count = new_kb.GetKeyCount();
|
||||
new_zone.leds_min = new_zone.leds_count;
|
||||
new_zone.leds_max = new_zone.leds_count;
|
||||
|
||||
/*---------------------------------------------------------*\
|
||||
| Matrix map still uses declared zone rows and columns |
|
||||
| as the packet structure depends on the matrix map |
|
||||
\*---------------------------------------------------------*/
|
||||
new_kb.GetKeyMap(new_map->map, KEYBOARD_MAP_FILL_TYPE_COUNT, new_map->height, new_map->width);
|
||||
|
||||
/*---------------------------------------------------------*\
|
||||
| Create LEDs for the Matrix zone |
|
||||
| Place keys in the layout to populate the matrix |
|
||||
\*---------------------------------------------------------*/
|
||||
for(size_t led_idx = 0; led_idx < new_zone.leds_count; led_idx++)
|
||||
{
|
||||
led new_led;
|
||||
|
||||
new_led.name = new_kb.GetKeyNameAt(led_idx);
|
||||
new_led.value = new_kb.GetKeyValueAt(led_idx);
|
||||
leds.push_back(new_led);
|
||||
}
|
||||
|
||||
zones.push_back(new_zone);
|
||||
|
||||
|
||||
|
||||
SetupColors();
|
||||
}
|
||||
|
||||
void RGBController_AOCKeyboard::ResizeZone(int /*zone*/, int /*new_size*/)
|
||||
{
|
||||
/*---------------------------------------------------------*\
|
||||
| This device does not support resizing zones |
|
||||
\*---------------------------------------------------------*/
|
||||
}
|
||||
|
||||
void RGBController_AOCKeyboard::DeviceUpdateLEDs()
|
||||
{
|
||||
if(modes[active_mode].value == AOC_KEYBOARD_MODE_CUSTOM)
|
||||
{
|
||||
RGBColor color_buf[120];
|
||||
|
||||
for(unsigned int led_idx = 0; led_idx < leds.size(); led_idx++)
|
||||
{
|
||||
color_buf[leds[led_idx].value] = colors[led_idx];
|
||||
}
|
||||
|
||||
controller->SetCustom(&color_buf[0]);
|
||||
}
|
||||
else
|
||||
{
|
||||
DeviceUpdateMode();
|
||||
}
|
||||
}
|
||||
|
||||
void RGBController_AOCKeyboard::UpdateZoneLEDs(int /*zone*/)
|
||||
{
|
||||
DeviceUpdateLEDs();
|
||||
}
|
||||
|
||||
void RGBController_AOCKeyboard::UpdateSingleLED(int /*led*/)
|
||||
{
|
||||
DeviceUpdateLEDs();
|
||||
}
|
||||
|
||||
void RGBController_AOCKeyboard::DeviceUpdateMode()
|
||||
{
|
||||
unsigned char aoc_direction = AOC_KEYBOARD_DIRECTION_CLOCKWISE;
|
||||
unsigned char aoc_random = AOC_KEYBOARD_SINGLE_COLOR;
|
||||
RGBColor* aoc_colors = &colors[0];
|
||||
|
||||
if(modes[active_mode].direction == MODE_DIRECTION_LEFT)
|
||||
{
|
||||
aoc_direction = AOC_KEYBOARD_DIRECTION_COUNTERCLOCKWISE;
|
||||
}
|
||||
|
||||
if(modes[active_mode].color_mode == MODE_COLORS_RANDOM)
|
||||
{
|
||||
aoc_random = AOC_KEYBOARD_RANDOM;
|
||||
}
|
||||
|
||||
if(modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC)
|
||||
{
|
||||
aoc_colors = &modes[active_mode].colors[0];
|
||||
}
|
||||
|
||||
controller->SetLightingConfig(modes[active_mode].value,
|
||||
aoc_random,
|
||||
modes[active_mode].brightness,
|
||||
modes[active_mode].speed,
|
||||
aoc_direction,
|
||||
aoc_colors);
|
||||
}
|
||||
@@ -1,32 +0,0 @@
|
||||
/*-----------------------------------------*\
|
||||
| RGBController_AOCKeyboard.h |
|
||||
| |
|
||||
| Generic RGB Interface for AOC keyboard |
|
||||
| |
|
||||
| Adam Honse (CalcProgrammer1) 5/10/2023 |
|
||||
\*-----------------------------------------*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include "RGBController.h"
|
||||
#include "AOCKeyboardController.h"
|
||||
|
||||
class RGBController_AOCKeyboard : public RGBController
|
||||
{
|
||||
public:
|
||||
RGBController_AOCKeyboard(AOCKeyboardController* controller_ptr);
|
||||
~RGBController_AOCKeyboard();
|
||||
|
||||
void SetupZones();
|
||||
|
||||
void ResizeZone(int zone, int new_size);
|
||||
|
||||
void DeviceUpdateLEDs();
|
||||
void UpdateZoneLEDs(int zone);
|
||||
void UpdateSingleLED(int led);
|
||||
|
||||
void DeviceUpdateMode();
|
||||
|
||||
private:
|
||||
AOCKeyboardController* controller;
|
||||
};
|
||||
@@ -1,130 +0,0 @@
|
||||
/*-----------------------------------------*\
|
||||
| AOCMouseController.cpp |
|
||||
| |
|
||||
| Driver for AOC Mouse lighting controller |
|
||||
| |
|
||||
| Adam Honse (CalcProgrammer1) 4/20/2023 |
|
||||
\*-----------------------------------------*/
|
||||
|
||||
#include "AOCMouseController.h"
|
||||
|
||||
#include <cstring>
|
||||
|
||||
AOCMouseController::AOCMouseController(hid_device* dev_handle, const char* path)
|
||||
{
|
||||
dev = dev_handle;
|
||||
location = path;
|
||||
}
|
||||
|
||||
AOCMouseController::~AOCMouseController()
|
||||
{
|
||||
hid_close(dev);
|
||||
}
|
||||
|
||||
std::string AOCMouseController::GetDeviceLocation()
|
||||
{
|
||||
return("HID " + location);
|
||||
}
|
||||
|
||||
std::string AOCMouseController::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);
|
||||
}
|
||||
|
||||
/*-------------------------------------------------------------------------------------------------*\
|
||||
| Private packet sending functions. |
|
||||
\*-------------------------------------------------------------------------------------------------*/
|
||||
|
||||
void AOCMouseController::SendDirect
|
||||
(
|
||||
RGBColor* color_data
|
||||
)
|
||||
{
|
||||
SendPacket(AOC_MOUSE_MODE_STATIC_SINGLE_COLOR,
|
||||
AOC_MOUSE_BRIGHTNESS_HIGH,
|
||||
AOC_MOUSE_SPEED_MEDIUM,
|
||||
AOC_MOUSE_DIRECTION_CLOCKWISE,
|
||||
color_data);
|
||||
}
|
||||
|
||||
void AOCMouseController::SendPacket
|
||||
(
|
||||
unsigned char mode,
|
||||
unsigned char brightness,
|
||||
unsigned char speed,
|
||||
unsigned char direction,
|
||||
RGBColor* color_data
|
||||
)
|
||||
{
|
||||
unsigned char buf[60];
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Zero out buffer |
|
||||
\*-----------------------------------------------------*/
|
||||
memset(buf, 0x00, sizeof(buf));
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Set up packet |
|
||||
\*-----------------------------------------------------*/
|
||||
buf[0x00] = 0x20;
|
||||
buf[0x01] = 0x03;
|
||||
buf[0x02] = 0x01;
|
||||
buf[0x03] = mode;
|
||||
buf[0x04] = speed;
|
||||
buf[0x05] = brightness;
|
||||
buf[0x06] = direction;
|
||||
buf[0x07] = 0x01;
|
||||
buf[0x08] = 0x02;
|
||||
buf[0x09] = 0xFF;
|
||||
buf[0x0D] = 0x01;
|
||||
buf[0x0E] = 0x03;
|
||||
buf[0x0F] = 0xFF;
|
||||
buf[0x10] = 0x7F;
|
||||
buf[0x13] = 0x01;
|
||||
buf[0x14] = 0x04;
|
||||
buf[0x17] = 0xFF;
|
||||
buf[0x19] = 0x01;
|
||||
buf[0x1A] = 0x05;
|
||||
buf[0x1C] = 0xFF;
|
||||
buf[0x1F] = 0x01;
|
||||
buf[0x20] = 0x06;
|
||||
buf[0x21] = 0xFF;
|
||||
buf[0x23] = 0xFF;
|
||||
buf[0x25] = 0x01;
|
||||
buf[0x26] = 0x07;
|
||||
buf[0x27] = 0xFF;
|
||||
buf[0x28] = 0xFF;
|
||||
buf[0x2C] = 0x0A;
|
||||
buf[0x2D] = 0x0A;
|
||||
buf[0x30] = 0x14;
|
||||
buf[0x31] = 0x08;
|
||||
buf[0x3A] = 0x32;
|
||||
buf[0x3B] = 0x32;
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Copy in color |
|
||||
\*-----------------------------------------------------*/
|
||||
buf[0x33] = RGBGetRValue(color_data[0]);
|
||||
buf[0x34] = RGBGetGValue(color_data[0]);
|
||||
buf[0x35] = RGBGetBValue(color_data[0]);
|
||||
|
||||
buf[0x36] = RGBGetRValue(color_data[1]);
|
||||
buf[0x37] = RGBGetGValue(color_data[1]);
|
||||
buf[0x38] = RGBGetBValue(color_data[1]);
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Send packet |
|
||||
\*-----------------------------------------------------*/
|
||||
hid_send_feature_report(dev, buf, 60);
|
||||
}
|
||||
@@ -1,80 +0,0 @@
|
||||
/*-----------------------------------------*\
|
||||
| AOCMouseController.h |
|
||||
| |
|
||||
| Definitions and types for AOC mouse |
|
||||
| lighting controller |
|
||||
| |
|
||||
| Adam Honse (CalcProgrammer1) 4/20/2023 |
|
||||
\*-----------------------------------------*/
|
||||
|
||||
#include "RGBController.h"
|
||||
#include <hidapi/hidapi.h>
|
||||
#include <string>
|
||||
|
||||
#pragma once
|
||||
|
||||
/*-----------------------------------------*\
|
||||
| AOC Mousemat Modes |
|
||||
| Note: The 0x80 bit is the random flag |
|
||||
\*-----------------------------------------*/
|
||||
enum
|
||||
{
|
||||
AOC_MOUSE_MODE_STATIC_SINGLE_COLOR = 0x00, /* Static single color mode */
|
||||
AOC_MOUSE_MODE_STATIC_RANDOM = 0x80, /* Static random color mode */
|
||||
AOC_MOUSE_MODE_BREATHING_SINGLE_COLOR = 0x01, /* Breathing single color mode */
|
||||
AOC_MOUSE_MODE_BREATHING_RANDOM = 0x81, /* Breathing random color mode */
|
||||
AOC_MOUSE_MODE_BLINK_SINGLE_COLOR = 0x02, /* Blink single color mode */
|
||||
AOC_MOUSE_MODE_BLINK_RANDOM = 0x82, /* Blink random color mode */
|
||||
AOC_MOUSE_MODE_WAVE_SINGLE_COLOR = 0x03, /* Wave single color mode */
|
||||
AOC_MOUSE_MODE_WAVE_RANDOM = 0x83, /* Wave random color mode */
|
||||
AOC_MOUSE_MODE_DPI = 0x04, /* DPI mode */
|
||||
};
|
||||
|
||||
enum
|
||||
{
|
||||
AOC_MOUSE_SPEED_SLOW = 0x03, /* Slowest speed */
|
||||
AOC_MOUSE_SPEED_MEDIUM = 0x02, /* Medium speed */
|
||||
AOC_MOUSE_SPEED_FAST = 0x01, /* Fastest speed */
|
||||
};
|
||||
|
||||
enum
|
||||
{
|
||||
AOC_MOUSE_BRIGHTNESS_OFF = 0x00, /* Lowest brightness (off) */
|
||||
AOC_MOUSE_BRIGHTNESS_LOW = 0x01, /* Low brightness */
|
||||
AOC_MOUSE_BRIGHTNESS_MEDIUM = 0x02, /* Medium brightness */
|
||||
AOC_MOUSE_BRIGHTNESS_HIGH = 0x03, /* Highest brightness */
|
||||
};
|
||||
|
||||
enum
|
||||
{
|
||||
AOC_MOUSE_DIRECTION_CLOCKWISE = 0x00, /* Clockwise direction */
|
||||
AOC_MOUSE_DIRECTION_COUNTERCLOCKWISE = 0x01, /* Counter-clockwise direction */
|
||||
};
|
||||
|
||||
class AOCMouseController
|
||||
{
|
||||
public:
|
||||
AOCMouseController(hid_device* dev_handle, const char* path);
|
||||
~AOCMouseController();
|
||||
|
||||
std::string GetDeviceLocation();
|
||||
std::string GetSerialString();
|
||||
|
||||
void SendDirect
|
||||
(
|
||||
RGBColor* color_data
|
||||
);
|
||||
|
||||
void SendPacket
|
||||
(
|
||||
unsigned char mode,
|
||||
unsigned char brightness,
|
||||
unsigned char speed,
|
||||
unsigned char direction,
|
||||
RGBColor* color_data
|
||||
);
|
||||
|
||||
private:
|
||||
hid_device* dev;
|
||||
std::string location;
|
||||
};
|
||||
@@ -1,34 +0,0 @@
|
||||
#include "Detector.h"
|
||||
#include "AOCMouseController.h"
|
||||
#include "RGBController.h"
|
||||
#include "RGBController_AOCMouse.h"
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| AOC Mousemat IDs |
|
||||
\*-----------------------------------------------------*/
|
||||
#define AOC_VID 0x3938
|
||||
#define AOC_GM500_PID 0x1179
|
||||
|
||||
/******************************************************************************************\
|
||||
* *
|
||||
* DetectAOCMouseControllers *
|
||||
* *
|
||||
* Tests the USB address to see if an AOC Mouse controller exists there. *
|
||||
* *
|
||||
\******************************************************************************************/
|
||||
|
||||
void DetectAOCMouseControllers(hid_device_info* info, const std::string& name)
|
||||
{
|
||||
hid_device* dev = hid_open_path(info->path);
|
||||
|
||||
if(dev)
|
||||
{
|
||||
AOCMouseController* controller = new AOCMouseController(dev, info->path);
|
||||
RGBController_AOCMouse* rgb_controller = new RGBController_AOCMouse(controller);
|
||||
rgb_controller->name = name;
|
||||
|
||||
ResourceManager::get()->RegisterRGBController(rgb_controller);
|
||||
}
|
||||
}
|
||||
|
||||
REGISTER_HID_DETECTOR_IPU("AOC GM500", DetectAOCMouseControllers, AOC_VID, AOC_GM500_PID, 1, 0xFF19, 0xFF19);
|
||||
@@ -1,215 +0,0 @@
|
||||
/*-----------------------------------------*\
|
||||
| RGBController_AOCMouse.cpp |
|
||||
| |
|
||||
| Generic RGB Interface for AOC mouse |
|
||||
| |
|
||||
| Adam Honse (CalcProgrammer1) 4/20/2023 |
|
||||
\*-----------------------------------------*/
|
||||
|
||||
#include "RGBController_AOCMouse.h"
|
||||
|
||||
/**------------------------------------------------------------------*\
|
||||
@name AOC Mouse
|
||||
@category Mouse
|
||||
@type USB
|
||||
@save :x:
|
||||
@direct :white_check_mark:
|
||||
@effects :white_check_mark:
|
||||
@detectors DetectAOCMouseControllers
|
||||
@comment
|
||||
\*-------------------------------------------------------------------*/
|
||||
|
||||
RGBController_AOCMouse::RGBController_AOCMouse(AOCMouseController* controller_ptr)
|
||||
{
|
||||
controller = controller_ptr;
|
||||
|
||||
name = "AOC Mouse Device";
|
||||
vendor = "AOC";
|
||||
type = DEVICE_TYPE_MOUSE;
|
||||
description = "AOC Mouse Device";
|
||||
location = controller->GetDeviceLocation();
|
||||
serial = controller->GetSerialString();
|
||||
|
||||
mode Direct;
|
||||
Direct.name = "Direct";
|
||||
Direct.value = AOC_MOUSE_MODE_STATIC_SINGLE_COLOR;
|
||||
Direct.flags = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
|
||||
Direct.color_mode = MODE_COLORS_PER_LED;
|
||||
Direct.brightness_min = AOC_MOUSE_BRIGHTNESS_OFF;
|
||||
Direct.brightness_max = AOC_MOUSE_BRIGHTNESS_HIGH;
|
||||
Direct.brightness = AOC_MOUSE_BRIGHTNESS_HIGH;
|
||||
modes.push_back(Direct);
|
||||
|
||||
mode SpectrumCycle;
|
||||
SpectrumCycle.name = "Spectrum Cycle";
|
||||
SpectrumCycle.value = AOC_MOUSE_MODE_STATIC_RANDOM;
|
||||
SpectrumCycle.flags = MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
|
||||
SpectrumCycle.color_mode = MODE_COLORS_RANDOM;
|
||||
SpectrumCycle.brightness_min = AOC_MOUSE_BRIGHTNESS_OFF;
|
||||
SpectrumCycle.brightness_max = AOC_MOUSE_BRIGHTNESS_HIGH;
|
||||
SpectrumCycle.brightness = AOC_MOUSE_BRIGHTNESS_HIGH;
|
||||
SpectrumCycle.speed_min = AOC_MOUSE_SPEED_SLOW;
|
||||
SpectrumCycle.speed_max = AOC_MOUSE_SPEED_FAST;
|
||||
SpectrumCycle.speed = AOC_MOUSE_SPEED_MEDIUM;
|
||||
modes.push_back(SpectrumCycle);
|
||||
|
||||
mode Breathing;
|
||||
Breathing.name = "Breathing";
|
||||
Breathing.value = AOC_MOUSE_MODE_BREATHING_SINGLE_COLOR;
|
||||
Breathing.flags = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
|
||||
Breathing.color_mode = MODE_COLORS_PER_LED;
|
||||
Breathing.brightness_min = AOC_MOUSE_BRIGHTNESS_OFF;
|
||||
Breathing.brightness_max = AOC_MOUSE_BRIGHTNESS_HIGH;
|
||||
Breathing.brightness = AOC_MOUSE_BRIGHTNESS_HIGH;
|
||||
Breathing.speed_min = AOC_MOUSE_SPEED_SLOW;
|
||||
Breathing.speed_max = AOC_MOUSE_SPEED_FAST;
|
||||
Breathing.speed = AOC_MOUSE_SPEED_MEDIUM;
|
||||
modes.push_back(Breathing);
|
||||
|
||||
mode Blink;
|
||||
Blink.name = "Flashing";
|
||||
Blink.value = AOC_MOUSE_MODE_BLINK_SINGLE_COLOR;
|
||||
Blink.flags = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
|
||||
Blink.color_mode = MODE_COLORS_PER_LED;
|
||||
Blink.brightness_min = AOC_MOUSE_BRIGHTNESS_OFF;
|
||||
Blink.brightness_max = AOC_MOUSE_BRIGHTNESS_HIGH;
|
||||
Blink.brightness = AOC_MOUSE_BRIGHTNESS_HIGH;
|
||||
Blink.speed_min = AOC_MOUSE_SPEED_SLOW;
|
||||
Blink.speed_max = AOC_MOUSE_SPEED_FAST;
|
||||
Blink.speed = AOC_MOUSE_SPEED_MEDIUM;
|
||||
modes.push_back(Blink);
|
||||
|
||||
mode Wave;
|
||||
Wave.name = "Wave";
|
||||
Wave.value = AOC_MOUSE_MODE_WAVE_SINGLE_COLOR;
|
||||
Wave.flags = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
|
||||
Wave.color_mode = MODE_COLORS_PER_LED;
|
||||
Wave.brightness_min = AOC_MOUSE_BRIGHTNESS_OFF;
|
||||
Wave.brightness_max = AOC_MOUSE_BRIGHTNESS_HIGH;
|
||||
Wave.brightness = AOC_MOUSE_BRIGHTNESS_HIGH;
|
||||
Wave.speed_min = AOC_MOUSE_SPEED_SLOW;
|
||||
Wave.speed_max = AOC_MOUSE_SPEED_FAST;
|
||||
Wave.speed = AOC_MOUSE_SPEED_MEDIUM;
|
||||
modes.push_back(Wave);
|
||||
|
||||
mode RainbowWave;
|
||||
RainbowWave.name = "Rainbow Wave";
|
||||
RainbowWave.value = AOC_MOUSE_MODE_WAVE_RANDOM;
|
||||
RainbowWave.flags = MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
|
||||
RainbowWave.color_mode = MODE_COLORS_RANDOM;
|
||||
RainbowWave.brightness_min = AOC_MOUSE_BRIGHTNESS_OFF;
|
||||
RainbowWave.brightness_max = AOC_MOUSE_BRIGHTNESS_HIGH;
|
||||
RainbowWave.brightness = AOC_MOUSE_BRIGHTNESS_HIGH;
|
||||
RainbowWave.speed_min = AOC_MOUSE_SPEED_SLOW;
|
||||
RainbowWave.speed_max = AOC_MOUSE_SPEED_FAST;
|
||||
RainbowWave.speed = AOC_MOUSE_SPEED_MEDIUM;
|
||||
modes.push_back(RainbowWave);
|
||||
|
||||
mode DPI;
|
||||
DPI.name = "DPI";
|
||||
DPI.value = AOC_MOUSE_MODE_DPI;
|
||||
DPI.flags = MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
|
||||
DPI.color_mode = MODE_COLORS_RANDOM;
|
||||
DPI.brightness_min = AOC_MOUSE_BRIGHTNESS_OFF;
|
||||
DPI.brightness_max = AOC_MOUSE_BRIGHTNESS_HIGH;
|
||||
DPI.brightness = AOC_MOUSE_BRIGHTNESS_HIGH;
|
||||
modes.push_back(DPI);
|
||||
|
||||
SetupZones();
|
||||
};
|
||||
|
||||
RGBController_AOCMouse::~RGBController_AOCMouse()
|
||||
{
|
||||
delete controller;
|
||||
}
|
||||
|
||||
void RGBController_AOCMouse::SetupZones()
|
||||
{
|
||||
zone logo_zone;
|
||||
logo_zone.name = "Logo";
|
||||
logo_zone.type = ZONE_TYPE_SINGLE;
|
||||
logo_zone.leds_min = 1;
|
||||
logo_zone.leds_max = 1;
|
||||
logo_zone.leds_count = 1;
|
||||
logo_zone.matrix_map = NULL;
|
||||
zones.push_back(logo_zone);
|
||||
|
||||
led logo_led;
|
||||
logo_led.name = "Logo";
|
||||
leds.push_back(logo_led);
|
||||
|
||||
zone scroll_wheel_zone;
|
||||
scroll_wheel_zone.name = "Scroll Wheel";
|
||||
scroll_wheel_zone.type = ZONE_TYPE_SINGLE;
|
||||
scroll_wheel_zone.leds_min = 1;
|
||||
scroll_wheel_zone.leds_max = 1;
|
||||
scroll_wheel_zone.leds_count = 1;
|
||||
scroll_wheel_zone.matrix_map = NULL;
|
||||
zones.push_back(scroll_wheel_zone);
|
||||
|
||||
led scroll_wheel_led;
|
||||
scroll_wheel_led.name = "Scroll Wheel";
|
||||
leds.push_back(scroll_wheel_led);
|
||||
|
||||
SetupColors();
|
||||
}
|
||||
|
||||
void RGBController_AOCMouse::ResizeZone(int /*zone*/, int /*new_size*/)
|
||||
{
|
||||
/*---------------------------------------------------------*\
|
||||
| This device does not support resizing zones |
|
||||
\*---------------------------------------------------------*/
|
||||
}
|
||||
|
||||
void RGBController_AOCMouse::DeviceUpdateLEDs()
|
||||
{
|
||||
DeviceUpdateMode();
|
||||
}
|
||||
|
||||
void RGBController_AOCMouse::UpdateZoneLEDs(int /*zone*/)
|
||||
{
|
||||
DeviceUpdateLEDs();
|
||||
}
|
||||
|
||||
void RGBController_AOCMouse::UpdateSingleLED(int /*led*/)
|
||||
{
|
||||
DeviceUpdateLEDs();
|
||||
}
|
||||
|
||||
void RGBController_AOCMouse::DeviceUpdateMode()
|
||||
{
|
||||
if(modes[active_mode].value == AOC_MOUSE_MODE_STATIC_SINGLE_COLOR)
|
||||
{
|
||||
controller->SendDirect(&colors[0]);
|
||||
}
|
||||
else
|
||||
{
|
||||
unsigned char aoc_direction = AOC_MOUSE_DIRECTION_CLOCKWISE;
|
||||
unsigned int aoc_mode = modes[active_mode].value;
|
||||
|
||||
if(modes[active_mode].direction == MODE_DIRECTION_LEFT)
|
||||
{
|
||||
aoc_direction = AOC_MOUSE_DIRECTION_COUNTERCLOCKWISE;
|
||||
}
|
||||
|
||||
if(modes[active_mode].color_mode == MODE_COLORS_RANDOM)
|
||||
{
|
||||
switch(modes[active_mode].value)
|
||||
{
|
||||
case AOC_MOUSE_MODE_BREATHING_SINGLE_COLOR:
|
||||
aoc_mode = AOC_MOUSE_MODE_BREATHING_RANDOM;
|
||||
break;
|
||||
|
||||
case AOC_MOUSE_MODE_BLINK_SINGLE_COLOR:
|
||||
aoc_mode = AOC_MOUSE_MODE_BLINK_RANDOM;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
controller->SendPacket(aoc_mode,
|
||||
modes[active_mode].brightness,
|
||||
modes[active_mode].speed,
|
||||
aoc_direction,
|
||||
&colors[0]);
|
||||
}
|
||||
}
|
||||
@@ -1,32 +0,0 @@
|
||||
/*-----------------------------------------*\
|
||||
| RGBController_AOCMouse.h |
|
||||
| |
|
||||
| Generic RGB Interface for AOC mouse |
|
||||
| |
|
||||
| Adam Honse (CalcProgrammer1) 4/20/2023 |
|
||||
\*-----------------------------------------*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include "RGBController.h"
|
||||
#include "AOCMouseController.h"
|
||||
|
||||
class RGBController_AOCMouse : public RGBController
|
||||
{
|
||||
public:
|
||||
RGBController_AOCMouse(AOCMouseController* controller_ptr);
|
||||
~RGBController_AOCMouse();
|
||||
|
||||
void SetupZones();
|
||||
|
||||
void ResizeZone(int zone, int new_size);
|
||||
|
||||
void DeviceUpdateLEDs();
|
||||
void UpdateZoneLEDs(int zone);
|
||||
void UpdateSingleLED(int led);
|
||||
|
||||
void DeviceUpdateMode();
|
||||
|
||||
private:
|
||||
AOCMouseController* controller;
|
||||
};
|
||||
@@ -1,112 +0,0 @@
|
||||
/*-----------------------------------------*\
|
||||
| AOCMousematController.cpp |
|
||||
| |
|
||||
| Driver for AOC Mousemat lighting |
|
||||
| controller |
|
||||
| |
|
||||
| Adam Honse (CalcProgrammer1) 4/15/2023 |
|
||||
\*-----------------------------------------*/
|
||||
|
||||
#include "AOCMousematController.h"
|
||||
|
||||
#include <cstring>
|
||||
|
||||
AOCMousematController::AOCMousematController(hid_device* dev_handle, const char* path)
|
||||
{
|
||||
dev = dev_handle;
|
||||
location = path;
|
||||
}
|
||||
|
||||
AOCMousematController::~AOCMousematController()
|
||||
{
|
||||
hid_close(dev);
|
||||
}
|
||||
|
||||
std::string AOCMousematController::GetDeviceLocation()
|
||||
{
|
||||
return("HID " + location);
|
||||
}
|
||||
|
||||
std::string AOCMousematController::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);
|
||||
}
|
||||
|
||||
/*-------------------------------------------------------------------------------------------------*\
|
||||
| Private packet sending functions. |
|
||||
\*-------------------------------------------------------------------------------------------------*/
|
||||
|
||||
void AOCMousematController::SendDirect
|
||||
(
|
||||
RGBColor* color_data
|
||||
)
|
||||
{
|
||||
SendPacket(AOC_MOUSEMAT_MODE_STATIC_SINGLE_COLOR,
|
||||
AOC_MOUSEMAT_BRIGHTNESS_HIGH,
|
||||
AOC_MOUSEMAT_SPEED_MEDIUM,
|
||||
AOC_MOUSEMAT_DIRECTION_CLOCKWISE,
|
||||
color_data);
|
||||
}
|
||||
|
||||
void AOCMousematController::SendPacket
|
||||
(
|
||||
unsigned char mode,
|
||||
unsigned char brightness,
|
||||
unsigned char speed,
|
||||
unsigned char direction,
|
||||
RGBColor* color_data
|
||||
)
|
||||
{
|
||||
unsigned char buf[32];
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Zero out buffer |
|
||||
\*-----------------------------------------------------*/
|
||||
memset(buf, 0x00, sizeof(buf));
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Set up packet |
|
||||
\*-----------------------------------------------------*/
|
||||
buf[0x00] = 0x20;
|
||||
buf[0x01] = brightness;
|
||||
buf[0x02] = speed;
|
||||
buf[0x03] = direction;
|
||||
buf[0x04] = 0x01;
|
||||
buf[0x05] = mode;
|
||||
buf[0x09] = 0xFF;
|
||||
buf[0x0C] = 0xFF;
|
||||
buf[0x0D] = 0x3F;
|
||||
buf[0x0F] = 0xFF;
|
||||
buf[0x10] = 0xFF;
|
||||
buf[0x13] = 0xFF;
|
||||
buf[0x17] = 0xFF;
|
||||
buf[0x19] = 0xFF;
|
||||
buf[0x1A] = 0xFF;
|
||||
buf[0x1B] = 0xFF;
|
||||
buf[0x1D] = 0xFF;
|
||||
buf[0x1E] = 0x32;
|
||||
buf[0x1F] = 0x32;
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Copy in color |
|
||||
\*-----------------------------------------------------*/
|
||||
buf[0x06] = RGBGetRValue(color_data[0]);
|
||||
buf[0x07] = RGBGetGValue(color_data[0]);
|
||||
buf[0x08] = RGBGetBValue(color_data[0]);
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Send packet |
|
||||
\*-----------------------------------------------------*/
|
||||
hid_send_feature_report(dev, buf, 32);
|
||||
}
|
||||
@@ -1,79 +0,0 @@
|
||||
/*-----------------------------------------*\
|
||||
| AOCMousematController.h |
|
||||
| |
|
||||
| Definitions and types for AOC mousemat |
|
||||
| lighting controller |
|
||||
| |
|
||||
| Adam Honse (CalcProgrammer1) 4/15/2023 |
|
||||
\*-----------------------------------------*/
|
||||
|
||||
#include "RGBController.h"
|
||||
#include <hidapi/hidapi.h>
|
||||
#include <string>
|
||||
|
||||
#pragma once
|
||||
|
||||
/*-----------------------------------------*\
|
||||
| AOC Mousemat Modes |
|
||||
| Note: The 0x80 bit is the random flag |
|
||||
\*-----------------------------------------*/
|
||||
enum
|
||||
{
|
||||
AOC_MOUSEMAT_MODE_STATIC_SINGLE_COLOR = 0x00, /* Static single color mode */
|
||||
AOC_MOUSEMAT_MODE_STATIC_RANDOM = 0x80, /* Static random color mode */
|
||||
AOC_MOUSEMAT_MODE_BREATHING_SINGLE_COLOR = 0x01, /* Breathing single color mode */
|
||||
AOC_MOUSEMAT_MODE_BREATHING_RANDOM = 0x81, /* Breathing random color mode */
|
||||
AOC_MOUSEMAT_MODE_BLINK_SINGLE_COLOR = 0x02, /* Blink single color mode */
|
||||
AOC_MOUSEMAT_MODE_BLINK_RANDOM = 0x82, /* Blink random color mode */
|
||||
AOC_MOUSEMAT_MODE_WAVE_SINGLE_COLOR = 0x03, /* Wave single color mode */
|
||||
AOC_MOUSEMAT_MODE_WAVE_RANDOM = 0x83, /* Wave random color mode */
|
||||
};
|
||||
|
||||
enum
|
||||
{
|
||||
AOC_MOUSEMAT_SPEED_SLOW = 0x03, /* Slowest speed */
|
||||
AOC_MOUSEMAT_SPEED_MEDIUM = 0x02, /* Medium speed */
|
||||
AOC_MOUSEMAT_SPEED_FAST = 0x01, /* Fastest speed */
|
||||
};
|
||||
|
||||
enum
|
||||
{
|
||||
AOC_MOUSEMAT_BRIGHTNESS_OFF = 0x00, /* Lowest brightness (off) */
|
||||
AOC_MOUSEMAT_BRIGHTNESS_LOW = 0x01, /* Low brightness */
|
||||
AOC_MOUSEMAT_BRIGHTNESS_MEDIUM = 0x02, /* Medium brightness */
|
||||
AOC_MOUSEMAT_BRIGHTNESS_HIGH = 0x03, /* Highest brightness */
|
||||
};
|
||||
|
||||
enum
|
||||
{
|
||||
AOC_MOUSEMAT_DIRECTION_CLOCKWISE = 0x00, /* Clockwise direction */
|
||||
AOC_MOUSEMAT_DIRECTION_COUNTERCLOCKWISE = 0x01, /* Counter-clockwise direction */
|
||||
};
|
||||
|
||||
class AOCMousematController
|
||||
{
|
||||
public:
|
||||
AOCMousematController(hid_device* dev_handle, const char* path);
|
||||
~AOCMousematController();
|
||||
|
||||
std::string GetDeviceLocation();
|
||||
std::string GetSerialString();
|
||||
|
||||
void SendDirect
|
||||
(
|
||||
RGBColor* color_data
|
||||
);
|
||||
|
||||
void SendPacket
|
||||
(
|
||||
unsigned char mode,
|
||||
unsigned char brightness,
|
||||
unsigned char speed,
|
||||
unsigned char direction,
|
||||
RGBColor* color_data
|
||||
);
|
||||
|
||||
private:
|
||||
hid_device* dev;
|
||||
std::string location;
|
||||
};
|
||||
@@ -1,34 +0,0 @@
|
||||
#include "Detector.h"
|
||||
#include "AOCMousematController.h"
|
||||
#include "RGBController.h"
|
||||
#include "RGBController_AOCMousemat.h"
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| AOC Mousemat IDs |
|
||||
\*-----------------------------------------------------*/
|
||||
#define AOC_VID 0x3938
|
||||
#define AOC_AMM700_PID 0x1162
|
||||
|
||||
/******************************************************************************************\
|
||||
* *
|
||||
* DetectAOCMousematControllers *
|
||||
* *
|
||||
* Tests the USB address to see if an AOC Mousemat controller exists there. *
|
||||
* *
|
||||
\******************************************************************************************/
|
||||
|
||||
void DetectAOCMousematControllers(hid_device_info* info, const std::string& name)
|
||||
{
|
||||
hid_device* dev = hid_open_path(info->path);
|
||||
|
||||
if(dev)
|
||||
{
|
||||
AOCMousematController* controller = new AOCMousematController(dev, info->path);
|
||||
RGBController_AOCMousemat* rgb_controller = new RGBController_AOCMousemat(controller);
|
||||
rgb_controller->name = name;
|
||||
|
||||
ResourceManager::get()->RegisterRGBController(rgb_controller);
|
||||
}
|
||||
}
|
||||
|
||||
REGISTER_HID_DETECTOR_IPU("AOC AGON AMM700", DetectAOCMousematControllers, AOC_VID, AOC_AMM700_PID, 1, 0xFF19, 0xFF19);
|
||||
@@ -1,192 +0,0 @@
|
||||
/*-----------------------------------------*\
|
||||
| RGBController_AOCMousemat.cpp |
|
||||
| |
|
||||
| Generic RGB Interface for AOC mousemat |
|
||||
| |
|
||||
| Adam Honse (CalcProgrammer1) 4/15/2023 |
|
||||
\*-----------------------------------------*/
|
||||
|
||||
#include "RGBController_AOCMousemat.h"
|
||||
|
||||
/**------------------------------------------------------------------*\
|
||||
@name AOC Mousemat
|
||||
@category Mousemat
|
||||
@type USB
|
||||
@save :x:
|
||||
@direct :white_check_mark:
|
||||
@effects :white_check_mark:
|
||||
@detectors DetectAOCMousematControllers
|
||||
@comment
|
||||
\*-------------------------------------------------------------------*/
|
||||
|
||||
RGBController_AOCMousemat::RGBController_AOCMousemat(AOCMousematController* controller_ptr)
|
||||
{
|
||||
controller = controller_ptr;
|
||||
|
||||
name = "AOC Mousemat Device";
|
||||
vendor = "AOC";
|
||||
type = DEVICE_TYPE_MOUSEMAT;
|
||||
description = "AOC Mousemat Device";
|
||||
location = controller->GetDeviceLocation();
|
||||
serial = controller->GetSerialString();
|
||||
|
||||
mode Direct;
|
||||
Direct.name = "Direct";
|
||||
Direct.value = AOC_MOUSEMAT_MODE_STATIC_SINGLE_COLOR;
|
||||
Direct.flags = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
|
||||
Direct.color_mode = MODE_COLORS_PER_LED;
|
||||
Direct.brightness_min = AOC_MOUSEMAT_BRIGHTNESS_OFF;
|
||||
Direct.brightness_max = AOC_MOUSEMAT_BRIGHTNESS_HIGH;
|
||||
Direct.brightness = AOC_MOUSEMAT_BRIGHTNESS_HIGH;
|
||||
modes.push_back(Direct);
|
||||
|
||||
mode SpectrumCycle;
|
||||
SpectrumCycle.name = "Spectrum Cycle";
|
||||
SpectrumCycle.value = AOC_MOUSEMAT_MODE_STATIC_RANDOM;
|
||||
SpectrumCycle.flags = MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
|
||||
SpectrumCycle.color_mode = MODE_COLORS_RANDOM;
|
||||
SpectrumCycle.brightness_min = AOC_MOUSEMAT_BRIGHTNESS_OFF;
|
||||
SpectrumCycle.brightness_max = AOC_MOUSEMAT_BRIGHTNESS_HIGH;
|
||||
SpectrumCycle.brightness = AOC_MOUSEMAT_BRIGHTNESS_HIGH;
|
||||
SpectrumCycle.speed_min = AOC_MOUSEMAT_SPEED_SLOW;
|
||||
SpectrumCycle.speed_max = AOC_MOUSEMAT_SPEED_FAST;
|
||||
SpectrumCycle.speed = AOC_MOUSEMAT_SPEED_MEDIUM;
|
||||
modes.push_back(SpectrumCycle);
|
||||
|
||||
mode Breathing;
|
||||
Breathing.name = "Breathing";
|
||||
Breathing.value = AOC_MOUSEMAT_MODE_BREATHING_SINGLE_COLOR;
|
||||
Breathing.flags = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
|
||||
Breathing.color_mode = MODE_COLORS_PER_LED;
|
||||
Breathing.brightness_min = AOC_MOUSEMAT_BRIGHTNESS_OFF;
|
||||
Breathing.brightness_max = AOC_MOUSEMAT_BRIGHTNESS_HIGH;
|
||||
Breathing.brightness = AOC_MOUSEMAT_BRIGHTNESS_HIGH;
|
||||
Breathing.speed_min = AOC_MOUSEMAT_SPEED_SLOW;
|
||||
Breathing.speed_max = AOC_MOUSEMAT_SPEED_FAST;
|
||||
Breathing.speed = AOC_MOUSEMAT_SPEED_MEDIUM;
|
||||
modes.push_back(Breathing);
|
||||
|
||||
mode Blink;
|
||||
Blink.name = "Flashing";
|
||||
Blink.value = AOC_MOUSEMAT_MODE_BLINK_SINGLE_COLOR;
|
||||
Blink.flags = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
|
||||
Blink.color_mode = MODE_COLORS_PER_LED;
|
||||
Blink.brightness_min = AOC_MOUSEMAT_BRIGHTNESS_OFF;
|
||||
Blink.brightness_max = AOC_MOUSEMAT_BRIGHTNESS_HIGH;
|
||||
Blink.brightness = AOC_MOUSEMAT_BRIGHTNESS_HIGH;
|
||||
Blink.speed_min = AOC_MOUSEMAT_SPEED_SLOW;
|
||||
Blink.speed_max = AOC_MOUSEMAT_SPEED_FAST;
|
||||
Blink.speed = AOC_MOUSEMAT_SPEED_MEDIUM;
|
||||
modes.push_back(Blink);
|
||||
|
||||
mode Wave;
|
||||
Wave.name = "Wave";
|
||||
Wave.value = AOC_MOUSEMAT_MODE_WAVE_SINGLE_COLOR;
|
||||
Wave.flags = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
|
||||
Wave.color_mode = MODE_COLORS_PER_LED;
|
||||
Wave.brightness_min = AOC_MOUSEMAT_BRIGHTNESS_OFF;
|
||||
Wave.brightness_max = AOC_MOUSEMAT_BRIGHTNESS_HIGH;
|
||||
Wave.brightness = AOC_MOUSEMAT_BRIGHTNESS_HIGH;
|
||||
Wave.speed_min = AOC_MOUSEMAT_SPEED_SLOW;
|
||||
Wave.speed_max = AOC_MOUSEMAT_SPEED_FAST;
|
||||
Wave.speed = AOC_MOUSEMAT_SPEED_MEDIUM;
|
||||
modes.push_back(Wave);
|
||||
|
||||
mode RainbowWave;
|
||||
RainbowWave.name = "Rainbow Wave";
|
||||
RainbowWave.value = AOC_MOUSEMAT_MODE_WAVE_RANDOM;
|
||||
RainbowWave.flags = MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
|
||||
RainbowWave.color_mode = MODE_COLORS_RANDOM;
|
||||
RainbowWave.brightness_min = AOC_MOUSEMAT_BRIGHTNESS_OFF;
|
||||
RainbowWave.brightness_max = AOC_MOUSEMAT_BRIGHTNESS_HIGH;
|
||||
RainbowWave.brightness = AOC_MOUSEMAT_BRIGHTNESS_HIGH;
|
||||
RainbowWave.speed_min = AOC_MOUSEMAT_SPEED_SLOW;
|
||||
RainbowWave.speed_max = AOC_MOUSEMAT_SPEED_FAST;
|
||||
RainbowWave.speed = AOC_MOUSEMAT_SPEED_MEDIUM;
|
||||
modes.push_back(RainbowWave);
|
||||
|
||||
SetupZones();
|
||||
};
|
||||
|
||||
RGBController_AOCMousemat::~RGBController_AOCMousemat()
|
||||
{
|
||||
delete controller;
|
||||
}
|
||||
|
||||
void RGBController_AOCMousemat::SetupZones()
|
||||
{
|
||||
zone mousemat_zone;
|
||||
mousemat_zone.name = "Mousemat";
|
||||
mousemat_zone.type = ZONE_TYPE_SINGLE;
|
||||
mousemat_zone.leds_min = 1;
|
||||
mousemat_zone.leds_max = 1;
|
||||
mousemat_zone.leds_count = 1;
|
||||
mousemat_zone.matrix_map = NULL;
|
||||
zones.push_back(mousemat_zone);
|
||||
|
||||
led mousemat_led;
|
||||
mousemat_led.name = "Mousemat";
|
||||
leds.push_back(mousemat_led);
|
||||
|
||||
SetupColors();
|
||||
}
|
||||
|
||||
void RGBController_AOCMousemat::ResizeZone(int /*zone*/, int /*new_size*/)
|
||||
{
|
||||
/*---------------------------------------------------------*\
|
||||
| This device does not support resizing zones |
|
||||
\*---------------------------------------------------------*/
|
||||
}
|
||||
|
||||
void RGBController_AOCMousemat::DeviceUpdateLEDs()
|
||||
{
|
||||
DeviceUpdateMode();
|
||||
}
|
||||
|
||||
void RGBController_AOCMousemat::UpdateZoneLEDs(int /*zone*/)
|
||||
{
|
||||
DeviceUpdateLEDs();
|
||||
}
|
||||
|
||||
void RGBController_AOCMousemat::UpdateSingleLED(int /*led*/)
|
||||
{
|
||||
DeviceUpdateLEDs();
|
||||
}
|
||||
|
||||
void RGBController_AOCMousemat::DeviceUpdateMode()
|
||||
{
|
||||
if(modes[active_mode].value == AOC_MOUSEMAT_MODE_STATIC_SINGLE_COLOR)
|
||||
{
|
||||
controller->SendDirect(&colors[0]);
|
||||
}
|
||||
else
|
||||
{
|
||||
unsigned char aoc_direction = AOC_MOUSEMAT_DIRECTION_CLOCKWISE;
|
||||
unsigned int aoc_mode = modes[active_mode].value;
|
||||
|
||||
if(modes[active_mode].direction == MODE_DIRECTION_LEFT)
|
||||
{
|
||||
aoc_direction = AOC_MOUSEMAT_DIRECTION_COUNTERCLOCKWISE;
|
||||
}
|
||||
|
||||
if(modes[active_mode].color_mode == MODE_COLORS_RANDOM)
|
||||
{
|
||||
switch(modes[active_mode].value)
|
||||
{
|
||||
case AOC_MOUSEMAT_MODE_BREATHING_SINGLE_COLOR:
|
||||
aoc_mode = AOC_MOUSEMAT_MODE_BREATHING_RANDOM;
|
||||
break;
|
||||
|
||||
case AOC_MOUSEMAT_MODE_BLINK_SINGLE_COLOR:
|
||||
aoc_mode = AOC_MOUSEMAT_MODE_BLINK_RANDOM;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
controller->SendPacket(aoc_mode,
|
||||
modes[active_mode].brightness,
|
||||
modes[active_mode].speed,
|
||||
aoc_direction,
|
||||
&colors[0]);
|
||||
}
|
||||
}
|
||||
@@ -1,32 +0,0 @@
|
||||
/*-----------------------------------------*\
|
||||
| RGBController_AOCMousemat.h |
|
||||
| |
|
||||
| Generic RGB Interface for AOC mousemat |
|
||||
| |
|
||||
| Adam Honse (CalcProgrammer1) 4/15/2023 |
|
||||
\*-----------------------------------------*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include "RGBController.h"
|
||||
#include "AOCMousematController.h"
|
||||
|
||||
class RGBController_AOCMousemat : public RGBController
|
||||
{
|
||||
public:
|
||||
RGBController_AOCMousemat(AOCMousematController* controller_ptr);
|
||||
~RGBController_AOCMousemat();
|
||||
|
||||
void SetupZones();
|
||||
|
||||
void ResizeZone(int zone, int new_size);
|
||||
|
||||
void DeviceUpdateLEDs();
|
||||
void UpdateZoneLEDs(int zone);
|
||||
void UpdateSingleLED(int led);
|
||||
|
||||
void DeviceUpdateMode();
|
||||
|
||||
private:
|
||||
AOCMousematController* controller;
|
||||
};
|
||||
@@ -5,23 +5,18 @@
|
||||
| lighting controller |
|
||||
| |
|
||||
| Ed Kambulow (dredvard) 12/20/2020 |
|
||||
| Shady Nawara (ShadyNawara) 01/16/2023 |
|
||||
\*-----------------------------------------*/
|
||||
#include <cstring>
|
||||
#include <stdio.h>
|
||||
|
||||
#include "RGBController.h"
|
||||
#include "ResourceManager.h"
|
||||
#include "SettingsManager.h"
|
||||
#include "ASRockPolychromeUSBController.h"
|
||||
#include <cstring>
|
||||
#include <stdio.h>
|
||||
#include "dependencies/dmiinfo.h"
|
||||
|
||||
#define POLYCHROME_USB_READ_ZONE_CONFIG 0x11
|
||||
#define POLYCHROME_USB_READ_HEADER 0x14
|
||||
#define POLYCHROME_USB_WRITE_HEADER 0x15
|
||||
#define POLYCHROME_USB_SET_ZONE 0x10
|
||||
#define POLYCHROME_USB_INITIAL_CHUNK 0xE3
|
||||
#define POLYCHROME_USB_SEND_CHUNK 0xE4
|
||||
#define POLYCHROME_USB_INIT 0xA4
|
||||
#define POLYCHROME_USB_COMMIT 0x12
|
||||
|
||||
@@ -34,7 +29,7 @@ const char* polychrome_USB_zone_names[] =
|
||||
"PCH",
|
||||
"IO Cover",
|
||||
"PCB",
|
||||
"Addressable Header 3/Audio",
|
||||
"Audio",
|
||||
};
|
||||
|
||||
PolychromeUSBController::PolychromeUSBController(hid_device* dev_handle, const char* path)
|
||||
@@ -77,7 +72,7 @@ std::string PolychromeUSBController::GetSerialString()
|
||||
{
|
||||
return("");
|
||||
}
|
||||
|
||||
|
||||
std::wstring return_wstring = serial_string;
|
||||
std::string return_string(return_wstring.begin(), return_wstring.end());
|
||||
|
||||
@@ -87,64 +82,19 @@ std::string PolychromeUSBController::GetSerialString()
|
||||
void PolychromeUSBController::SetDeviceInfo()
|
||||
{
|
||||
PolychromeDeviceInfo newdev_info;
|
||||
|
||||
ReadConfigTables();
|
||||
|
||||
/*--------------------------------------------------*\
|
||||
| Read settings to check for configured RGSwap |
|
||||
\*--------------------------------------------------*/
|
||||
const std::string detector_name = "ASRock Polychrome USB";
|
||||
const std::string json_rgswap = "RGSwap";
|
||||
SettingsManager* settings_manager = ResourceManager::get()->GetSettingsManager();
|
||||
json device_settings = settings_manager->GetSettings(detector_name);
|
||||
|
||||
/*---------------------------------------------------------*\
|
||||
| Get RGSwap settings from the settings manager |
|
||||
| If RGSwap settings are not found then write them out |
|
||||
| Onboard leds are set to their existing values, |
|
||||
| Addressable RGB and RGB headers are set to false |
|
||||
\*---------------------------------------------------------*/
|
||||
if(!device_settings.contains(json_rgswap))
|
||||
{
|
||||
device_settings[json_rgswap][polychrome_USB_zone_names[0]] = false;
|
||||
device_settings[json_rgswap][polychrome_USB_zone_names[1]] = false;
|
||||
device_settings[json_rgswap][polychrome_USB_zone_names[2]] = false;
|
||||
device_settings[json_rgswap][polychrome_USB_zone_names[3]] = false;
|
||||
device_settings[json_rgswap][polychrome_USB_zone_names[4]] = ((configtable[8] >> 4) & 1) ? true : false;
|
||||
device_settings[json_rgswap][polychrome_USB_zone_names[5]] = ((configtable[8] >> 5) & 1) ? true : false;
|
||||
device_settings[json_rgswap][polychrome_USB_zone_names[6]] = ((configtable[8] >> 6) & 1) ? true : false;
|
||||
device_settings[json_rgswap][polychrome_USB_zone_names[7]] = false;
|
||||
|
||||
settings_manager->SetSettings(detector_name, device_settings);
|
||||
settings_manager->SaveSettings();
|
||||
}
|
||||
else
|
||||
{
|
||||
for(std::size_t idx = 0; idx < 8; idx++)
|
||||
{
|
||||
if(device_settings[json_rgswap].contains(polychrome_USB_zone_names[idx]))
|
||||
{
|
||||
rgswapconfig[idx] = device_settings[json_rgswap][polychrome_USB_zone_names[idx]];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
bool rgswap_final[8] = {0};
|
||||
|
||||
for (unsigned int zonecnt = 0; zonecnt < POLYCHROME_USB_ZONE_MAX_NUM; zonecnt++)
|
||||
{
|
||||
if(configtable[zonecnt] == 0x1E || !((configtable[9] >> zonecnt) & 1))
|
||||
if(configtable[zonecnt] == 0x1E)
|
||||
{
|
||||
/*-----------------------------------------------------------------------*\
|
||||
| If we don't have this device type (0x1E) we will skip it and continue. |
|
||||
| Or if the device is not available we skip it and continue |
|
||||
\*-----------------------------------------------------------------------*/
|
||||
continue;
|
||||
}
|
||||
|
||||
newdev_info.num_leds = configtable[zonecnt];
|
||||
newdev_info.rgswap = ((configtable[8] >> zonecnt) & 1) || rgswapconfig[zonecnt];
|
||||
rgswap_final[zonecnt] = newdev_info.rgswap;
|
||||
|
||||
/*--------------------------------------------------------------------------------------------------*\
|
||||
| We will need to know what zone type this is, so that we can look up the name and make calls later. |
|
||||
@@ -158,11 +108,6 @@ void PolychromeUSBController::SetDeviceInfo()
|
||||
\*-----------------------------------------*/
|
||||
case POLYCHROME_USB_ZONE_ARGB1:
|
||||
case POLYCHROME_USB_ZONE_ARGB2:
|
||||
/*---------------------------------------------*\
|
||||
| The last led channel is allocated to a |
|
||||
| third ARGB header on some newer motherboards |
|
||||
\*---------------------------------------------*/
|
||||
case POLYCHROME_USB_ZONE_AUDIO:
|
||||
newdev_info.device_type = PolychromeDeviceType::ADDRESSABLE;
|
||||
break;
|
||||
|
||||
@@ -172,9 +117,10 @@ void PolychromeUSBController::SetDeviceInfo()
|
||||
case POLYCHROME_USB_ZONE_PCH:
|
||||
case POLYCHROME_USB_ZONE_IOCOVER:
|
||||
case POLYCHROME_USB_ZONE_PCB:
|
||||
case POLYCHROME_USB_ZONE_AUDIO:
|
||||
newdev_info.device_type = PolychromeDeviceType::FIXED;
|
||||
break;
|
||||
|
||||
|
||||
/*-----------------------------------------*\
|
||||
| Type: Fixed |
|
||||
\*-----------------------------------------*/
|
||||
@@ -187,26 +133,6 @@ void PolychromeUSBController::SetDeviceInfo()
|
||||
|
||||
device_info.push_back(newdev_info);
|
||||
}
|
||||
|
||||
// set rgswap to match our settings
|
||||
WriteRGSwap(rgswap_final[0], rgswap_final[1], rgswap_final[2], rgswap_final[3], rgswap_final[4], rgswap_final[5], rgswap_final[6], rgswap_final[7]);
|
||||
}
|
||||
|
||||
void PolychromeUSBController::ResizeZone(int zone, int new_size)
|
||||
{
|
||||
unsigned char zonecfg[POLYCHROME_USB_ZONE_MAX_NUM];
|
||||
|
||||
memset(zonecfg, POLYCHROME_USB_ZONE_UNAVAILABLE, POLYCHROME_USB_ZONE_MAX_NUM);
|
||||
|
||||
configtable[zone] = new_size;
|
||||
|
||||
for(unsigned int i = 0; i < POLYCHROME_USB_ZONE_MAX_NUM; i++)
|
||||
{
|
||||
zonecfg[i] = configtable[i];
|
||||
}
|
||||
|
||||
unsigned char zonecmd = POLYCHROME_USB_LEDCOUNT_CFG;
|
||||
WriteHeader(zonecmd, zonecfg, sizeof(zonecfg));
|
||||
}
|
||||
|
||||
void PolychromeUSBController::WriteZone
|
||||
@@ -214,13 +140,13 @@ void PolychromeUSBController::WriteZone
|
||||
unsigned char zone,
|
||||
unsigned char mode,
|
||||
unsigned char speed,
|
||||
RGBColor rgb,
|
||||
RGBColor rgb,
|
||||
bool allzone = false
|
||||
)
|
||||
{
|
||||
|
||||
/*----------------------------------------------------*\
|
||||
| Get the device info so we can look up the zone type. |
|
||||
| Get the device info so we can look up the zone type. |
|
||||
\*----------------------------------------------------*/
|
||||
PolychromeDeviceInfo device_info = GetPolychromeDevices()[zone];
|
||||
|
||||
@@ -235,20 +161,10 @@ void PolychromeUSBController::WriteZone
|
||||
| Set up message packet with leading 00 |
|
||||
\*-----------------------------------------------------*/
|
||||
usb_buf[0x01] = POLYCHROME_USB_SET_ZONE;
|
||||
usb_buf[0x03] = device_info.zone_type;
|
||||
usb_buf[0x03] = device_info.zone_type;
|
||||
usb_buf[0x04] = mode;
|
||||
|
||||
if(device_info.rgswap)
|
||||
{
|
||||
usb_buf[0x05] = RGBGetRValue(rgb);
|
||||
usb_buf[0x06] = RGBGetGValue(rgb);
|
||||
}
|
||||
else
|
||||
{
|
||||
usb_buf[0x05] = RGBGetGValue(rgb);
|
||||
usb_buf[0x06] = RGBGetRValue(rgb);
|
||||
}
|
||||
|
||||
usb_buf[0x05] = RGBGetRValue(rgb);
|
||||
usb_buf[0x06] = RGBGetGValue(rgb);
|
||||
usb_buf[0x07] = RGBGetBValue(rgb);
|
||||
usb_buf[0x08] = speed;
|
||||
usb_buf[0x09] = 0xFF;
|
||||
@@ -263,126 +179,67 @@ void PolychromeUSBController::WriteZone
|
||||
|
||||
void PolychromeUSBController::WriteAllZones
|
||||
(
|
||||
const std::vector<PolychromeZoneInfo>& /*zones_info*/,
|
||||
const std::vector<PolychromeZoneInfo>& zones_info,
|
||||
const std::vector<zone>& zones
|
||||
)
|
||||
{
|
||||
std::vector<unsigned char> combined_leds_rgb;
|
||||
std::size_t max_led_count = 0;
|
||||
for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++){
|
||||
PolychromeDeviceInfo device_info = GetPolychromeDevices()[zone_idx];
|
||||
|
||||
for(std::size_t led_idx = 0; led_idx < zones[zone_idx].leds_count; led_idx++)
|
||||
{
|
||||
if(device_info.rgswap)
|
||||
{
|
||||
combined_leds_rgb.push_back(RGBGetRValue(zones[zone_idx].colors[led_idx]));
|
||||
combined_leds_rgb.push_back(RGBGetGValue(zones[zone_idx].colors[led_idx]));
|
||||
}
|
||||
else
|
||||
{
|
||||
combined_leds_rgb.push_back(RGBGetGValue(zones[zone_idx].colors[led_idx]));
|
||||
combined_leds_rgb.push_back(RGBGetRValue(zones[zone_idx].colors[led_idx]));
|
||||
}
|
||||
combined_leds_rgb.push_back(RGBGetBValue(zones[zone_idx].colors[led_idx]));
|
||||
}
|
||||
max_led_count += zones[zone_idx].leds_max;
|
||||
}
|
||||
combined_leds_rgb.resize((max_led_count + 8) * 3, 0);
|
||||
|
||||
unsigned char usb_buf[65];
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Zero out buffer |
|
||||
\*-----------------------------------------------------*/
|
||||
memset(usb_buf, 0x00, sizeof(usb_buf));
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Set up initial message packet with leading 00 |
|
||||
| Set up message packet with leading 00 |
|
||||
\*-----------------------------------------------------*/
|
||||
usb_buf[0x01] = POLYCHROME_USB_SET_ZONE;
|
||||
usb_buf[0x03] = 0xFF;
|
||||
usb_buf[0x04] = POLYCHROME_USB_INITIAL_CHUNK;
|
||||
usb_buf[0x07] = 0xFF;
|
||||
usb_buf[0x40] = 0x65;
|
||||
usb_buf[0x03] = 0x07;
|
||||
usb_buf[0x04] = zones_info[0].mode;
|
||||
usb_buf[0x04] = 0xE2;
|
||||
|
||||
std::size_t initial_led_offset = 9;
|
||||
std::size_t message_byte_capacity = 54; // 18 leds * 3 bytes
|
||||
|
||||
std::size_t led_byte_idx = 0;
|
||||
|
||||
while(led_byte_idx < combined_leds_rgb.size())
|
||||
for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
|
||||
{
|
||||
for(std::size_t byte_idx = 0; byte_idx < message_byte_capacity; byte_idx++)
|
||||
{
|
||||
usb_buf[initial_led_offset + byte_idx] = combined_leds_rgb[led_byte_idx++];
|
||||
if(led_byte_idx >= combined_leds_rgb.size())
|
||||
{
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Send packet |
|
||||
\*-----------------------------------------------------*/
|
||||
hid_write(dev, usb_buf, 65);
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Zero out buffer |
|
||||
\*-----------------------------------------------------*/
|
||||
memset(usb_buf, 0x00, sizeof(usb_buf));
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Set up message packet with leading 00 |
|
||||
\*-----------------------------------------------------*/
|
||||
usb_buf[0x01] = POLYCHROME_USB_SET_ZONE;
|
||||
usb_buf[0x03] = 0xFF;
|
||||
usb_buf[0x04] = POLYCHROME_USB_SEND_CHUNK;
|
||||
usb_buf[0x40] = 0x65;
|
||||
|
||||
initial_led_offset = 5;
|
||||
message_byte_capacity = 57; // 19 leds * 3 bytes
|
||||
}
|
||||
}
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| If reset is true, rgswap is set to the values |
|
||||
| specified in the settings file, otherwise set to off |
|
||||
\*-----------------------------------------------------*/
|
||||
void PolychromeUSBController::SetRGSwap(bool reset)
|
||||
{
|
||||
if(reset)
|
||||
{
|
||||
bool rg[8] = {0};
|
||||
std::vector<PolychromeDeviceInfo> devices_info = GetPolychromeDevices();
|
||||
for (PolychromeDeviceInfo device : devices_info)
|
||||
{
|
||||
rg[device.zone_type] = device.rgswap;
|
||||
}
|
||||
WriteRGSwap(rg[0], rg[1], rg[2], rg[3], rg[4], rg[5], rg[6], rg[7]);
|
||||
}
|
||||
else
|
||||
{
|
||||
/*-----------------------------------------------------------------*\
|
||||
| Disable RGSwap as it causes flashing on each update in direct mode|
|
||||
\*-----------------------------------------------------------------*/
|
||||
WriteRGSwap(0, 0, 0, 0, 0, 0, 0, 0);
|
||||
usb_buf[0x05 + (3 * zone_idx) ] = RGBGetRValue(zones[zone_idx].colors[0]);
|
||||
usb_buf[0x05 + (3 * zone_idx) + 1] = RGBGetGValue(zones[zone_idx].colors[0]);
|
||||
usb_buf[0x05 + (3 * zone_idx) + 2] = RGBGetBValue(zones[zone_idx].colors[0]);
|
||||
}
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Send packet |
|
||||
\*-----------------------------------------------------*/
|
||||
hid_write(dev, usb_buf, 65);
|
||||
hid_read(dev, usb_buf, 64);
|
||||
}
|
||||
|
||||
void PolychromeUSBController::WriteRGSwap
|
||||
(
|
||||
bool hdr0,
|
||||
bool hdr1,
|
||||
bool ahdr0,
|
||||
bool ahdr1,
|
||||
bool pch,
|
||||
bool io,
|
||||
bool pcb,
|
||||
bool chnl8
|
||||
bool ahdr0,
|
||||
bool hdr1,
|
||||
bool hdr0
|
||||
)
|
||||
{
|
||||
unsigned char rgconfig[1] = {static_cast<unsigned char>(((chnl8 << 7) | (pcb << 6) | (io << 5) | (pch << 4) | (ahdr1 << 3) | (ahdr0 << 2) | (hdr1 << 1) | hdr0))};
|
||||
WriteHeader(POLYCHROME_USB_RGSWAP_CFG, rgconfig, 1);
|
||||
unsigned char usb_buf[65];
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Zero out buffer |
|
||||
\*-----------------------------------------------------*/
|
||||
memset(usb_buf, 0x00, sizeof(usb_buf));
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Set up message packet with leading 00 |
|
||||
\*-----------------------------------------------------*/
|
||||
usb_buf[0x01] = POLYCHROME_USB_WRITE_HEADER;
|
||||
|
||||
usb_buf[0x04] = POLYCHROME_USB_RGSWAP_CFG;
|
||||
usb_buf[0x05] = ((ahdr1 << 3) & (ahdr0 << 2) & (hdr1 << 1) & hdr0) & 0x40;
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Send packet |
|
||||
\*-----------------------------------------------------*/
|
||||
hid_write(dev, usb_buf, 65);
|
||||
hid_read(dev, usb_buf, 64);
|
||||
}
|
||||
|
||||
void PolychromeUSBController::WriteHeader
|
||||
@@ -435,7 +292,7 @@ PolychromeZoneInfo PolychromeUSBController::GetZoneConfig(unsigned char zone)
|
||||
| Set up config table request packet |
|
||||
\*-----------------------------------------------------*/
|
||||
usb_buf[0x01] = POLYCHROME_USB_READ_ZONE_CONFIG;
|
||||
usb_buf[0x03] = device_info.zone_type;
|
||||
usb_buf[0x03] = device_info.zone_type;
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Send packet |
|
||||
@@ -447,28 +304,13 @@ PolychromeZoneInfo PolychromeUSBController::GetZoneConfig(unsigned char zone)
|
||||
\*-----------------------------------------------------*/
|
||||
memset(usb_buf, 0x00, sizeof(usb_buf));
|
||||
hid_read(dev, usb_buf, 64);
|
||||
|
||||
|
||||
r = usb_buf[0x05];
|
||||
g = usb_buf[0x06];
|
||||
b = usb_buf[0x07];
|
||||
|
||||
/*------------------------------------------------------*\
|
||||
| Set Chroma mode (0xE2) & Per-Led mode (0xE3) as Direct |
|
||||
\*------------------------------------------------------*/
|
||||
zoneinfo.mode = usb_buf[0x04] != 0xE2 && usb_buf[0x04] != 0xE3 && usb_buf[0x04] < 0x0F ? usb_buf[0x04] : 0x0F;
|
||||
|
||||
/*------------------------------------------------------*\
|
||||
| G & R are swapped since RGSwap is disabled on init, |
|
||||
| Unless overwritten in settings |
|
||||
\*------------------------------------------------------*/
|
||||
if(device_info.rgswap)
|
||||
{
|
||||
zoneinfo.color = ToRGBColor(r,g,b);
|
||||
}
|
||||
else
|
||||
{
|
||||
zoneinfo.color = ToRGBColor(g,r,b);
|
||||
}
|
||||
zoneinfo.mode = usb_buf[0x04] != 0xE2 ? usb_buf[0x04] : 0x0F;
|
||||
zoneinfo.color = ToRGBColor(r,g,b);
|
||||
zoneinfo.speed = usb_buf[0x08];
|
||||
zoneinfo.zone = usb_buf[0x03];
|
||||
|
||||
@@ -479,7 +321,7 @@ void PolychromeUSBController::ReadConfigTables()
|
||||
{
|
||||
unsigned char usb_buf[65];
|
||||
unsigned char maxzoneleds[8];
|
||||
unsigned char rgswap;
|
||||
unsigned char rgbswap;
|
||||
unsigned char header1;
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
@@ -506,7 +348,7 @@ void PolychromeUSBController::ReadConfigTables()
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Reads in format: RGB1, RGB2, ARGB1, ARGB2, PCH, IO, |
|
||||
| PCB, AUDIO/ARGB3 |
|
||||
| PCB, AUDIO |
|
||||
\*-----------------------------------------------------*/
|
||||
memcpy(&maxzoneleds,&usb_buf[0x04],8);
|
||||
|
||||
@@ -526,10 +368,10 @@ void PolychromeUSBController::ReadConfigTables()
|
||||
hid_read(dev, usb_buf, 64);
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Reads bitwise in format: AUDIO/ARGB3, PCB, IO, PCH, |
|
||||
| ARGB2,ARGB1, RGB2, RGB1 if available |
|
||||
| Reads bitwise in format: AUDIO, PCB, IO, PCH, ARGB2, |
|
||||
| ARGB1, RGB2, RGB1 if available |
|
||||
\*-----------------------------------------------------*/
|
||||
rgswap=usb_buf[4];
|
||||
rgbswap=usb_buf[4];
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Zero out buffer |
|
||||
@@ -545,15 +387,10 @@ void PolychromeUSBController::ReadConfigTables()
|
||||
hid_write(dev, usb_buf, 64);
|
||||
memset(usb_buf, 0x00, sizeof(usb_buf));
|
||||
hid_read(dev, usb_buf, 64);
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Reads bitwise in format: AUDIO/ARGB3, PCB, IO, PCH, |
|
||||
| ARGB2,ARGB1, RGB2, RGB1 if available |
|
||||
\*-----------------------------------------------------*/
|
||||
header1=usb_buf[4];
|
||||
|
||||
memcpy(configtable,&maxzoneleds,8);
|
||||
configtable[8]=rgswap;
|
||||
configtable[8]=rgbswap;
|
||||
configtable[9]=header1;
|
||||
return;
|
||||
}
|
||||
|
||||
@@ -5,7 +5,6 @@
|
||||
| lighting controller |
|
||||
| |
|
||||
| Ed Kambulow (dredvard) 12/20/2020 |
|
||||
| Shady Nawara (ShadyNawara) 01/16/2023 |
|
||||
\*-----------------------------------------*/
|
||||
|
||||
#include "RGBController.h"
|
||||
@@ -70,7 +69,7 @@ enum
|
||||
POLYCHROME_USB_ZONE_PCH = 0X04, // PCH
|
||||
POLYCHROME_USB_ZONE_IOCOVER = 0X05, // IOCOVER
|
||||
POLYCHROME_USB_ZONE_PCB = 0X06, // PCB - Could be mixed swapped with 0x07
|
||||
POLYCHROME_USB_ZONE_AUDIO = 0X07 // AUDIO/ARGB Header 3
|
||||
POLYCHROME_USB_ZONE_AUDIO = 0X07 // AUDIO
|
||||
};
|
||||
|
||||
enum class PolychromeDeviceType
|
||||
@@ -92,7 +91,6 @@ struct PolychromeDeviceInfo
|
||||
unsigned char effect_channel;
|
||||
unsigned char num_leds;
|
||||
unsigned char zone_type;
|
||||
bool rgswap;
|
||||
PolychromeDeviceType device_type;
|
||||
};
|
||||
|
||||
@@ -133,31 +131,17 @@ public:
|
||||
unsigned int configsize
|
||||
);
|
||||
|
||||
void ResizeZone(int zone, int new_size);
|
||||
void SetRGSwap(bool reset);
|
||||
|
||||
protected:
|
||||
hid_device* dev;
|
||||
std::vector<PolychromeDeviceInfo> device_info;
|
||||
std::string location;
|
||||
|
||||
void WriteRGSwap
|
||||
(
|
||||
bool hdr0,
|
||||
bool hdr1,
|
||||
bool ahdr0,
|
||||
bool ahdr1,
|
||||
bool pch,
|
||||
bool io,
|
||||
bool pcb,
|
||||
bool chnl8
|
||||
);
|
||||
void WriteRGSwap(bool ahdr1, bool ahdr0, bool hdr1, bool hdr0);
|
||||
|
||||
private:
|
||||
unsigned int led_count;
|
||||
std::string device_name;
|
||||
unsigned char configtable[12];
|
||||
bool rgswapconfig[8] = { 0 };
|
||||
|
||||
void SetDeviceInfo();
|
||||
void ReadConfigTables();
|
||||
|
||||
@@ -5,7 +5,6 @@
|
||||
| ASRock Polychrome USB Driver |
|
||||
| |
|
||||
| Ed Kambulow (Dredvard) 12/26/2020 |
|
||||
| Shady Nawara (ShadyNawara) 01/16/2023 |
|
||||
\*-----------------------------------------*/
|
||||
|
||||
#include "RGBController_ASRockPolychromeUSB.h"
|
||||
@@ -23,6 +22,7 @@
|
||||
@effects :white_check_mark:
|
||||
@detectors DetectPolychromeUSBControllers
|
||||
@comment ASRock Polychrome controllers will save with each update.
|
||||
Per ARGB LED support is not possible with these devices.
|
||||
\*-------------------------------------------------------------------*/
|
||||
|
||||
RGBController_PolychromeUSB::RGBController_PolychromeUSB(PolychromeUSBController* controller_ptr)
|
||||
@@ -181,6 +181,11 @@ RGBController_PolychromeUSB::RGBController_PolychromeUSB(PolychromeUSBController
|
||||
modes.push_back(Direct);
|
||||
|
||||
SetupZones();
|
||||
|
||||
/*-------------------------------------------------*\
|
||||
| Initialize active mode |
|
||||
\*-------------------------------------------------*/
|
||||
active_mode = GetDeviceMode(1);
|
||||
}
|
||||
|
||||
void RGBController_PolychromeUSB::SetupZones()
|
||||
@@ -233,6 +238,16 @@ void RGBController_PolychromeUSB::SetupZones()
|
||||
|
||||
SetupColors();
|
||||
|
||||
/*---------------------------------------------------------*\
|
||||
| Initialize colors for each LED |
|
||||
\*---------------------------------------------------------*/
|
||||
for(std::size_t led_idx = 0; led_idx < leds.size(); led_idx++)
|
||||
{
|
||||
unsigned char led = (unsigned char)leds[led_idx].value;
|
||||
|
||||
colors[led_idx] = controller->GetZoneConfig(led).color; // TODO Get addressable instead of zone idx
|
||||
}
|
||||
|
||||
/*---------------------------------------------------------*\
|
||||
| Initialize zone info to track zone, speed, mode |
|
||||
| B550 Boards have modes, speed for each zone |
|
||||
@@ -244,37 +259,26 @@ void RGBController_PolychromeUSB::SetupZones()
|
||||
zones_info.push_back(zoneinfo);
|
||||
}
|
||||
|
||||
/*---------------------------------------------------------*\
|
||||
| Initialize colors for each LED |
|
||||
| We cannot currently get the individual led color so |
|
||||
| we use the zone color in each zone to set all leds |
|
||||
| !!TODO: in Per-Led mode, zone color is always black |
|
||||
\*---------------------------------------------------------*/
|
||||
for(std::size_t led_idx = 0; led_idx < leds.size(); led_idx++)
|
||||
{
|
||||
unsigned char led = (unsigned char)leds[led_idx].value;
|
||||
|
||||
colors[led_idx] = zones_info[led].color;
|
||||
}
|
||||
|
||||
/*-------------------------------------------------*\
|
||||
| Initialize active mode |
|
||||
\*-------------------------------------------------*/
|
||||
active_mode = zones_info.size() > 1 ? zones_info[0].mode : 0x0;
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| If in Direct mode, reset all Leds to match interface |
|
||||
\*-----------------------------------------------------*/
|
||||
if(active_mode == 0x0F)
|
||||
{
|
||||
controller->WriteAllZones(zones_info, zones);
|
||||
}
|
||||
}
|
||||
|
||||
void RGBController_PolychromeUSB::ResizeZone(int zone, int new_size)
|
||||
{
|
||||
unsigned char zonecfg[ASROCK_USB_MAX_ZONES];
|
||||
|
||||
/*---------------------------------------------------------*\
|
||||
| This device does not currently support resizing zones |
|
||||
\*---------------------------------------------------------*/
|
||||
zones[zone].leds_count = (unsigned char) new_size;
|
||||
controller->ResizeZone(zones_info[zone].zone, new_size);
|
||||
|
||||
memset(zonecfg, POLYCHROME_USB_ZONE_UNAVAILABLE, ASROCK_USB_MAX_ZONES);
|
||||
|
||||
for(unsigned int i = 0; i < zones.size(); i++)
|
||||
{
|
||||
zonecfg[i]=zones[i].leds_count;
|
||||
}
|
||||
|
||||
// unsigned char zonecmd = POLYCHROME_USB_LEDCOUNT_CFG;
|
||||
// WriteHeader(zonecmd, zonecfg, sizeof(zonecfg));
|
||||
}
|
||||
|
||||
void RGBController_PolychromeUSB::DeviceUpdateLEDs()
|
||||
@@ -334,12 +338,6 @@ unsigned char RGBController_PolychromeUSB::GetDeviceMode(unsigned char zone)
|
||||
|
||||
void RGBController_PolychromeUSB::DeviceUpdateMode()
|
||||
{
|
||||
/*-----------------------------------------------------------------*\
|
||||
| Disable RGSwap as it causes flashing on each update in direct mode|
|
||||
| Otherwise, reset to values specified in settings.json |
|
||||
\*-----------------------------------------------------------------*/
|
||||
controller->SetRGSwap(modes[active_mode].name != "Direct");
|
||||
|
||||
for(unsigned int zone_idx = 0; zone_idx < zones.size(); zone_idx++)
|
||||
{
|
||||
if(zones[zone_idx].leds_count > 0)
|
||||
|
||||
@@ -5,7 +5,6 @@
|
||||
| ASRock Polychrome USB Driver |
|
||||
| |
|
||||
| Ed Kambulow (Dredvard) 12/26/2020 |
|
||||
| Shady Nawara (ShadyNawara) 01/16/2023 |
|
||||
\*-----------------------------------------*/
|
||||
|
||||
#pragma once
|
||||
|
||||
@@ -105,7 +105,7 @@ RGBController_ASRockPolychromeV1SMBus::RGBController_ASRockPolychromeV1SMBus(ASR
|
||||
mode Music;
|
||||
Music.name = "Music";
|
||||
Music.value = POLYCHROME_V1_MODE_MUSIC;
|
||||
Music.flags = MODE_FLAG_AUTOMATIC_SAVE;
|
||||
Music.flags = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
|
||||
Music.color_mode = MODE_COLORS_NONE;
|
||||
modes.push_back(Music);
|
||||
|
||||
@@ -122,6 +122,7 @@ RGBController_ASRockPolychromeV1SMBus::RGBController_ASRockPolychromeV1SMBus(ASR
|
||||
/*---------------------------------------------------------------------*\
|
||||
| Comment out until per zone modes are working. These are only for ARGB |
|
||||
\*---------------------------------------------------------------------*/
|
||||
/*
|
||||
mode Spring;
|
||||
Spring.name = "Spring";
|
||||
Spring.value = POLYCHROME_V1_MODE_SPRING;
|
||||
@@ -191,6 +192,7 @@ RGBController_ASRockPolychromeV1SMBus::RGBController_ASRockPolychromeV1SMBus(ASR
|
||||
Rainbow.speed = POLYCHROME_V1_SPEED_DEFAULT_RAINBOW;
|
||||
Rainbow.color_mode = MODE_COLORS_NONE;
|
||||
modes.push_back(Rainbow);
|
||||
*/
|
||||
|
||||
/*---------------------------------------------------------------------*\
|
||||
| This ARGB_Config section is a hack to allow users to configure the |
|
||||
|
||||
@@ -1,75 +0,0 @@
|
||||
/*---------------------------------------------------------*\
|
||||
| AcerMonitorController.cpp |
|
||||
| |
|
||||
| Driver for 2020/2021 Acer monitors with rear RGB strips. |
|
||||
| |
|
||||
| Shenghao Yang ([email protected]), 30/12/2021 |
|
||||
| Amended for code style by Adam Honse, 3/13/2022 |
|
||||
\*---------------------------------------------------------*/
|
||||
|
||||
#include "AcerMonitorController.h"
|
||||
#include <cstring>
|
||||
|
||||
AcerMonitorController::AcerMonitorController(hid_device* dev_handle, const char* path)
|
||||
{
|
||||
dev = dev_handle;
|
||||
location = path;
|
||||
}
|
||||
|
||||
AcerMonitorController::~AcerMonitorController()
|
||||
{
|
||||
hid_close(dev);
|
||||
}
|
||||
|
||||
std::string AcerMonitorController::GetDeviceLocation()
|
||||
{
|
||||
return("HID: " + location);
|
||||
}
|
||||
|
||||
std::string AcerMonitorController::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 AcerMonitorController::SetColors(RGBColor *colors, std::size_t num_leds)
|
||||
{
|
||||
char usb_buf[374];
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Zero out buffer |
|
||||
\*-----------------------------------------------------*/
|
||||
memset(usb_buf, 0x00, sizeof(usb_buf));
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Fill in Set Colors packet |
|
||||
\*-----------------------------------------------------*/
|
||||
usb_buf[ACER_MONITOR_OFFSET_REPORT_TYPE] = ACER_MONITOR_REPORT_TYPE;
|
||||
usb_buf[ACER_MONITOR_OFFSET_MAGIC_0] = ACER_MONITOR_MAGIC_0;
|
||||
usb_buf[ACER_MONITOR_OFFSET_MAGIC_1] = ACER_MONITOR_MAGIC_1;
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Fill in color data |
|
||||
\*-----------------------------------------------------*/
|
||||
for(unsigned int color_idx = 0; color_idx < num_leds; color_idx++)
|
||||
{
|
||||
usb_buf[ACER_MONITOR_OFFSET_RGB_DATA + 0 + (color_idx * 3)] = RGBGetRValue(colors[color_idx]);
|
||||
usb_buf[ACER_MONITOR_OFFSET_RGB_DATA + 1 + (color_idx * 3)] = RGBGetGValue(colors[color_idx]);
|
||||
usb_buf[ACER_MONITOR_OFFSET_RGB_DATA + 2 + (color_idx * 3)] = RGBGetBValue(colors[color_idx]);
|
||||
}
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Send packet |
|
||||
\*-----------------------------------------------------*/
|
||||
hid_write(dev, (unsigned char *)usb_buf, 374);
|
||||
}
|
||||
@@ -1,48 +0,0 @@
|
||||
/*---------------------------------------------------------*\
|
||||
| AcerMonitorController.h |
|
||||
| |
|
||||
| Driver for 2020/2021 Acer monitors with rear RGB strips. |
|
||||
| |
|
||||
| Shenghao Yang ([email protected]), 30/12/2021 |
|
||||
| Amended for code style by Adam Honse, 3/13/2022 |
|
||||
\*---------------------------------------------------------*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <RGBController.h>
|
||||
#include <hidapi/hidapi.h>
|
||||
|
||||
enum
|
||||
{
|
||||
ACER_MONITOR_OFFSET_REPORT_TYPE = 0x00, /* Offset of report type field in packet */
|
||||
ACER_MONITOR_OFFSET_MAGIC_0 = 0x01, /* Offset of magic 0 field in packet */
|
||||
ACER_MONITOR_OFFSET_MAGIC_1 = 0x02, /* Offset of magic 1 field in packet */
|
||||
ACER_MONITOR_OFFSET_PAD_0 = 0x03, /* Offset of pad 0 field in packet */
|
||||
ACER_MONITOR_OFFSET_NUM_LEDS = 0x04, /* Offset of number of LEDs field in packet */
|
||||
ACER_MONITOR_OFFSET_STRIP_INDEX = 0x05, /* Offset of strip index field in packet */
|
||||
ACER_MONITOR_OFFSET_PAD_1 = 0x06, /* Offset of pad 1 field in packet */
|
||||
ACER_MONITOR_OFFSET_RGB_DATA = 0x0E, /* Offset of RGB data field in packet */
|
||||
};
|
||||
|
||||
enum
|
||||
{
|
||||
ACER_MONITOR_REPORT_TYPE = 0x2A, /* Value of report type field in packet */
|
||||
ACER_MONITOR_MAGIC_0 = 0x0C, /* Value of magic 0 field in packet */
|
||||
ACER_MONITOR_MAGIC_1 = 0x02, /* Value of magic 1 field in packet */
|
||||
};
|
||||
|
||||
class AcerMonitorController
|
||||
{
|
||||
public:
|
||||
AcerMonitorController(hid_device* dev_handle, const char* path);
|
||||
~AcerMonitorController();
|
||||
|
||||
std::string GetDeviceLocation();
|
||||
std::string GetSerialString();
|
||||
|
||||
void SetColors(RGBColor *colors, std::size_t num_leds);
|
||||
|
||||
private:
|
||||
hid_device* dev;
|
||||
std::string location;
|
||||
};
|
||||
@@ -1,50 +0,0 @@
|
||||
/*---------------------------------------------------------*\
|
||||
| AcerMonitorControllerDetect.cpp |
|
||||
| |
|
||||
| Controller detection for 2020/2021 Acer monitors |
|
||||
| with rear RGB strips. |
|
||||
| |
|
||||
| Shenghao Yang ([email protected]), 30/12/2021 |
|
||||
| Amended for code style by Adam Honse, 3/13/2022 |
|
||||
\*---------------------------------------------------------*/
|
||||
|
||||
#include "Detector.h"
|
||||
#include "AcerMonitorController.h"
|
||||
#include "RGBController_AcerMonitor.h"
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Acer vendor ID |
|
||||
\*-----------------------------------------------------*/
|
||||
#define ACER_VID 0x042E
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Acer monitor product IDs |
|
||||
\*-----------------------------------------------------*/
|
||||
#define ACER_XB323QK_NV_PID 0xAC0B
|
||||
#define ACER_XB273U_NV_PID 0xAC0C
|
||||
#define ACER_X25_PID 0xAC0D
|
||||
|
||||
/*---------------------------------------------------------*\
|
||||
| DetectAcerMonitorControllers |
|
||||
| |
|
||||
| Detects Acer monitor controllers. |
|
||||
| |
|
||||
| info: HID device information. |
|
||||
\*---------------------------------------------------------*/
|
||||
void DetectAcerMonitorControllers(hid_device_info* info, const std::string& name)
|
||||
{
|
||||
hid_device* dev = hid_open_path(info->path);
|
||||
|
||||
if(dev)
|
||||
{
|
||||
AcerMonitorController* controller = new AcerMonitorController(dev, info->path);
|
||||
RGBController_AcerMonitor* rgb_controller = new RGBController_AcerMonitor(controller);
|
||||
rgb_controller->name = name;
|
||||
|
||||
ResourceManager::get()->RegisterRGBController(rgb_controller);
|
||||
}
|
||||
}
|
||||
|
||||
REGISTER_HID_DETECTOR("Acer XB323QK NV", DetectAcerMonitorControllers, ACER_VID, ACER_XB323QK_NV_PID);
|
||||
REGISTER_HID_DETECTOR("Acer XB273U NV", DetectAcerMonitorControllers, ACER_VID, ACER_XB273U_NV_PID );
|
||||
REGISTER_HID_DETECTOR("Acer X25", DetectAcerMonitorControllers, ACER_VID, ACER_X25_PID );
|
||||
@@ -1,111 +0,0 @@
|
||||
/*---------------------------------------------------------*\
|
||||
| RGBController_AcerMonitor.cpp |
|
||||
| |
|
||||
| RGBController interface implementation for 2020/2021 |
|
||||
| Acer monitors with rear RGB strips. |
|
||||
| |
|
||||
| Shenghao Yang ([email protected]), 30/12/2021 |
|
||||
| Amended for code style by Adam Honse, 3/13/2022 |
|
||||
\*---------------------------------------------------------*/
|
||||
|
||||
#include "RGBController_AcerMonitor.h"
|
||||
|
||||
RGBController_AcerMonitor::RGBController_AcerMonitor(AcerMonitorController* controller_ptr)
|
||||
{
|
||||
controller = controller_ptr;
|
||||
vendor = "Acer";
|
||||
type = DEVICE_TYPE_LEDSTRIP;
|
||||
description = "Acer Monitor Device";
|
||||
location = controller->GetDeviceLocation();
|
||||
serial = controller->GetSerialString();
|
||||
|
||||
mode Direct;
|
||||
Direct.name = "Direct";
|
||||
Direct.value = 0;
|
||||
Direct.flags = MODE_FLAG_HAS_PER_LED_COLOR;
|
||||
Direct.color_mode = MODE_COLORS_PER_LED;
|
||||
modes.push_back(Direct);
|
||||
|
||||
SetupZones();
|
||||
}
|
||||
|
||||
RGBController_AcerMonitor::~RGBController_AcerMonitor()
|
||||
{
|
||||
delete controller;
|
||||
}
|
||||
|
||||
void RGBController_AcerMonitor::SetupZones()
|
||||
{
|
||||
zones.clear();
|
||||
leds.clear();
|
||||
|
||||
// for(const auto *const *pz{ctrl->monitor->zones}; *pz; ++pz)
|
||||
// {
|
||||
// const Zone *z{*pz};
|
||||
// zone led_zone;
|
||||
|
||||
// led_zone.leds_count = z->leds;
|
||||
// led_zone.leds_max = led_zone.leds_count;
|
||||
// led_zone.leds_min = led_zone.leds_count;
|
||||
// led_zone.name = z->name;
|
||||
// led_zone.type = z->type;
|
||||
// led_zone.matrix_map = z->mmap;
|
||||
|
||||
// for (std::size_t i{}; i < z->leds; ++i)
|
||||
// {
|
||||
// led new_led{};
|
||||
|
||||
// new_led.name = led_zone.name + " LED ";
|
||||
// if (led_zone.leds_count > 1)
|
||||
// new_led.name.append(std::to_string(i + 1));
|
||||
|
||||
// leds.emplace_back(new_led);
|
||||
// }
|
||||
|
||||
// zones.emplace_back(led_zone);
|
||||
// }
|
||||
|
||||
SetupColors();
|
||||
}
|
||||
|
||||
void RGBController_AcerMonitor::ResizeZone(int, int)
|
||||
{
|
||||
/*---------------------------------------------------------*\
|
||||
| This device does not support resizing zones |
|
||||
\*---------------------------------------------------------*/
|
||||
}
|
||||
|
||||
void RGBController_AcerMonitor::DeviceUpdateLEDs()
|
||||
{
|
||||
// for (std::size_t i{}; i < zones.size(); ++i)
|
||||
// UpdateZoneLEDs(i);
|
||||
}
|
||||
|
||||
void RGBController_AcerMonitor::UpdateZoneLEDs(int zone)
|
||||
{
|
||||
//controller->SetLEDs(zone, zones[zone].colors);
|
||||
}
|
||||
|
||||
void RGBController_AcerMonitor::UpdateSingleLED(int led)
|
||||
{
|
||||
// /*-----------------------------------------------------*\
|
||||
// | Find the zone that the LED exists in. |
|
||||
// \*-----------------------------------------------------*/
|
||||
// std::size_t total{};
|
||||
// int zone{};
|
||||
// while (static_cast<std::size_t>(led) >= total)
|
||||
// total += zones[zone++].leds_count;
|
||||
|
||||
// --zone;
|
||||
// ctrl->SetLEDs(zone, zones[zone].colors);
|
||||
}
|
||||
|
||||
void RGBController_AcerMonitor::SetCustomMode()
|
||||
{
|
||||
active_mode = 0;
|
||||
}
|
||||
|
||||
void RGBController_AcerMonitor::DeviceUpdateMode()
|
||||
{
|
||||
|
||||
}
|
||||
@@ -1,35 +0,0 @@
|
||||
/*---------------------------------------------------------*\
|
||||
| RGBController_AcerMonitor.h |
|
||||
| |
|
||||
| RGBController interface implementation for 2020/2021 |
|
||||
| Acer monitors with rear RGB strips. |
|
||||
| |
|
||||
| Shenghao Yang ([email protected]), 30/12/2021 |
|
||||
| Amended for code style by Adam Honse, 3/13/2022 |
|
||||
\*---------------------------------------------------------*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include "RGBController.h"
|
||||
#include "AcerMonitorController.h"
|
||||
|
||||
class RGBController_AcerMonitor : public RGBController
|
||||
{
|
||||
public:
|
||||
RGBController_AcerMonitor(AcerMonitorController* controller_ptr);
|
||||
~RGBController_AcerMonitor();
|
||||
|
||||
void SetupZones();
|
||||
|
||||
void ResizeZone(int zone, int new_size);
|
||||
|
||||
void DeviceUpdateLEDs();
|
||||
void UpdateZoneLEDs(int zone);
|
||||
void UpdateSingleLED(int led);
|
||||
|
||||
void SetCustomMode();
|
||||
void DeviceUpdateMode();
|
||||
|
||||
private:
|
||||
AcerMonitorController* controller;
|
||||
};
|
||||
@@ -592,14 +592,13 @@ void AlienwareController::SetColor(uint8_t zone, RGBColor color)
|
||||
|
||||
void AlienwareController::SetColor(uint8_t zone, RGBColor color1, RGBColor color2)
|
||||
{
|
||||
if ((color1 == zones[zone].color[0]) && (color2 == zones[zone].color[1]))
|
||||
{
|
||||
return;
|
||||
}
|
||||
dirty = ((color1 != zones[zone].color[0]) || (color2 != zones[zone].color[1]));
|
||||
|
||||
zones[zone].color[0] = color1;
|
||||
zones[zone].color[1] = color2;
|
||||
dirty = true;
|
||||
if(dirty)
|
||||
{
|
||||
zones[zone].color[0] = color1;
|
||||
zones[zone].color[1] = color2;
|
||||
}
|
||||
}
|
||||
|
||||
void AlienwareController::SetPeriod(uint8_t zone, uint16_t period)
|
||||
|
||||
@@ -45,9 +45,9 @@ typedef struct
|
||||
const char * name;
|
||||
const unsigned char zone;
|
||||
const unsigned char idx;
|
||||
} aw510k_led_type;
|
||||
} led_type;
|
||||
|
||||
static const aw510k_led_type led_names[] =
|
||||
static const led_type led_names[] =
|
||||
{
|
||||
/* Key Label Zone, Index */
|
||||
{ KEY_EN_ESCAPE, ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD, 0xB0 },
|
||||
|
||||
@@ -40,9 +40,9 @@ typedef struct
|
||||
{
|
||||
const char * name;
|
||||
const unsigned char idx;
|
||||
} annepro2_led_type;
|
||||
} led_type;
|
||||
|
||||
static const annepro2_led_type led_names[] =
|
||||
static const led_type led_names[] =
|
||||
{
|
||||
/* Key Label Index */
|
||||
{ KEY_EN_ESCAPE, 0 },
|
||||
|
||||
@@ -9,8 +9,6 @@
|
||||
|
||||
#include "AsusAuraCoreLaptopController.h"
|
||||
|
||||
#include "SettingsManager.h"
|
||||
|
||||
static uint8_t packet_map[ASUSAURACORELAPTOP_KEYCOUNT +
|
||||
ASUSAURACORELAPTOP_LIGHTBARCOUNT +
|
||||
ASUSAURACORELAPTOP_LIDCOUNT ] =
|
||||
|
||||
@@ -406,8 +406,6 @@ void RGBController_AsusAuraCoreLaptop::Init_Controller()
|
||||
lightbar.leds_min = ASUSAURACORELAPTOP_LIGHTBARCOUNT;
|
||||
lightbar.leds_max = ASUSAURACORELAPTOP_LIGHTBARCOUNT;
|
||||
lightbar.leds_count = ASUSAURACORELAPTOP_LIGHTBARCOUNT;
|
||||
lightbar.matrix_map = NULL;
|
||||
|
||||
zones.push_back(lightbar);
|
||||
|
||||
zone lid;
|
||||
@@ -416,8 +414,6 @@ void RGBController_AsusAuraCoreLaptop::Init_Controller()
|
||||
lid.leds_min = ASUSAURACORELAPTOP_LIDCOUNT;
|
||||
lid.leds_max = ASUSAURACORELAPTOP_LIDCOUNT;
|
||||
lid.leds_count = ASUSAURACORELAPTOP_LIDCOUNT;
|
||||
lid.matrix_map = NULL;
|
||||
|
||||
zones.push_back(lid);
|
||||
}
|
||||
|
||||
|
||||
@@ -65,12 +65,7 @@ void DetectAsusAuraGPUControllers(i2c_smbus_interface* bus, uint8_t i2c_addr, co
|
||||
}
|
||||
} /* DetectAsusAuraGPUControllers() */
|
||||
|
||||
/*-----------------------------------------*\
|
||||
| NVidia GPUs |
|
||||
\*-----------------------------------------*/
|
||||
|
||||
REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1050 O2G Gaming" , DetectAsusAuraGPUControllers, NVIDIA_VEN, NVIDIA_GTX1050_DEV, ASUS_SUB_VEN, ASUS_GTX1050_STRIX_O2G_GAMING, 0x29);
|
||||
REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1050 TI 4G Gaming" , DetectAsusAuraGPUControllers, NVIDIA_VEN, NVIDIA_GTX1050TI_DEV, ASUS_SUB_VEN, ASUS_ROG_STRIX_GTX1050TI_4G_GAMING, 0x29);
|
||||
REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1050 TI O4G Gaming" , DetectAsusAuraGPUControllers, NVIDIA_VEN, NVIDIA_GTX1050TI_DEV, ASUS_SUB_VEN, ASUS_ROG_STRIX_GTX1050TI_O4G_GAMING, 0x29);
|
||||
REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1050 TI O4G Gaming" , DetectAsusAuraGPUControllers, NVIDIA_VEN, NVIDIA_GTX1050TI_DEV, ASUS_SUB_VEN, ASUS_ROG_STRIX_GTX1050TI_O4G_GAMING_2, 0x29);
|
||||
REGISTER_I2C_PCI_DETECTOR("ASUS GTX 1060 Strix 6G Gaming" , DetectAsusAuraGPUControllers, NVIDIA_VEN, NVIDIA_GTX1060_DEV, ASUS_SUB_VEN, ASUS_GTX1060_STRIX_6G_GAMING, 0x29);
|
||||
@@ -91,46 +86,38 @@ REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1650S OC 4G" , DetectAs
|
||||
REGISTER_I2C_PCI_DETECTOR("ASUS ROG Strix GTX 1660S O6G Gaming" , DetectAsusAuraGPUControllers, NVIDIA_VEN, NVIDIA_GTX1660S_DEV, ASUS_SUB_VEN, ASUS_ROG_STRIX_GTX1660S_O6G_GAMING, 0x2A);
|
||||
REGISTER_I2C_PCI_DETECTOR("ASUS ROG GTX 1660 Ti OC 6G" , DetectAsusAuraGPUControllers, NVIDIA_VEN, NVIDIA_GTX1660TI_DEV, ASUS_SUB_VEN, ASUS_ROG_GTX1660TI_OC, 0x2A);
|
||||
REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060 EVO Gaming 6G" , DetectAsusAuraGPUControllers, NVIDIA_VEN, NVIDIA_RTX2060_TU106_DEV, ASUS_SUB_VEN, ASUS_ROG_STRIX_RTX2060_EVO_GAMING, 0x2A);
|
||||
REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060 O6G Gaming" , DetectAsusAuraGPUControllers, NVIDIA_VEN, NVIDIA_RTX2060_TU106_DEV, ASUS_SUB_VEN, ASUS_ROG_STRIX_RTX2060_O6G_GAMING, 0x2A);
|
||||
REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060 O6G Gaming" , DetectAsusAuraGPUControllers, NVIDIA_VEN, NVIDIA_RTX2060_TU106_DEV, ASUS_SUB_VEN, ASUS_ROG_STRIX_RTX2060_O6G_GAMING_86D2, 0x2A);
|
||||
REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060 O6G Gaming 6G" , DetectAsusAuraGPUControllers, NVIDIA_VEN, NVIDIA_RTX2060_TU106_DEV, ASUS_SUB_VEN, ASUS_ROG_STRIX_RTX2060_O6G_GAMING, 0x2A);
|
||||
REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060 O6G EVO Gaming" , DetectAsusAuraGPUControllers, NVIDIA_VEN, NVIDIA_RTX2060_TU104_DEV, ASUS_SUB_VEN, ASUS_ROG_STRIX_RTX2060_O6G_EVO_GAMING, 0x2A);
|
||||
REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060S 8G Gaming" , DetectAsusAuraGPUControllers, NVIDIA_VEN, NVIDIA_RTX2060S_OC_DEV, ASUS_SUB_VEN, ASUS_ROG_STRIX_RTX2060S_8G_GAMING, 0x2A);
|
||||
REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060S A8G EVO Gaming" , DetectAsusAuraGPUControllers, NVIDIA_VEN, NVIDIA_RTX2060S_DEV, ASUS_SUB_VEN, ASUS_ROG_STRIX_RTX2060S_A8G_EVO_GAMING, 0x2A);
|
||||
REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060S O8G Gaming" , DetectAsusAuraGPUControllers, NVIDIA_VEN, NVIDIA_RTX2060S_OC_DEV, ASUS_SUB_VEN, ASUS_ROG_STRIX_RTX2060S_O8G_GAMING, 0x2A);
|
||||
REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060S A8G Gaming" , DetectAsusAuraGPUControllers, NVIDIA_VEN, NVIDIA_RTX2060S_OC_DEV, ASUS_SUB_VEN, ASUS_ROG_STRIX_RTX2060S_A8G_GAMING, 0x2A);
|
||||
REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070 A8G Gaming" , DetectAsusAuraGPUControllers, NVIDIA_VEN, NVIDIA_RTX2070_OC_DEV, ASUS_SUB_VEN, ASUS_ROG_STRIX_RTX2070_A8G_GAMING, 0x2A);
|
||||
REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070 O8G Gaming" , DetectAsusAuraGPUControllers, NVIDIA_VEN, NVIDIA_RTX2070_OC_DEV, ASUS_SUB_VEN, ASUS_ROG_STRIX_RTX2070_O8G_GAMING, 0x2A);
|
||||
REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070S A8G Gaming" , DetectAsusAuraGPUControllers, NVIDIA_VEN, NVIDIA_RTX2070S_DEV, ASUS_SUB_VEN, ASUS_ROG_STRIX_RTX2070S_A8G_GAMING_86FF, 0x2A);
|
||||
REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070S A8G Gaming" , DetectAsusAuraGPUControllers, NVIDIA_VEN, NVIDIA_RTX2070S_OC_DEV, ASUS_SUB_VEN, ASUS_ROG_STRIX_RTX2070S_A8G_GAMING, 0x2A);
|
||||
REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070S A8G Gaming" , DetectAsusAuraGPUControllers, NVIDIA_VEN, NVIDIA_RTX2070S_OC_DEV, ASUS_SUB_VEN, ASUS_ROG_STRIX_RTX2070S_A8G_GAMING_8706, 0x2A);
|
||||
REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060S 8G Gaming 8G" , DetectAsusAuraGPUControllers, NVIDIA_VEN, NVIDIA_RTX2060S_OC_DEV, ASUS_SUB_VEN, ASUS_ROG_STRIX_RTX2060S_8G_GAMING, 0x2A);
|
||||
REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060S A8G EVO Gaming 8G", DetectAsusAuraGPUControllers, NVIDIA_VEN, NVIDIA_RTX2060S_DEV, ASUS_SUB_VEN, ASUS_ROG_STRIX_RTX2060S_A8G_EVO_GAMING, 0x2A);
|
||||
REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060S O8G Gaming 8G" , DetectAsusAuraGPUControllers, NVIDIA_VEN, NVIDIA_RTX2060S_OC_DEV, ASUS_SUB_VEN, ASUS_ROG_STRIX_RTX2060S_O8G_GAMING, 0x2A);
|
||||
REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2060S A8G Gaming 8G" , DetectAsusAuraGPUControllers, NVIDIA_VEN, NVIDIA_RTX2060S_OC_DEV, ASUS_SUB_VEN, ASUS_ROG_STRIX_RTX2060S_A8G_GAMING, 0x2A);
|
||||
REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070 A8G Gaming 8G" , DetectAsusAuraGPUControllers, NVIDIA_VEN, NVIDIA_RTX2070_OC_DEV, ASUS_SUB_VEN, ASUS_ROG_STRIX_RTX2070_A8G_GAMING, 0x2A);
|
||||
REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070 O8G Gaming 8G" , DetectAsusAuraGPUControllers, NVIDIA_VEN, NVIDIA_RTX2070_OC_DEV, ASUS_SUB_VEN, ASUS_ROG_STRIX_RTX2070_O8G_GAMING, 0x2A);
|
||||
REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070S A8G Gaming 8G" , DetectAsusAuraGPUControllers, NVIDIA_VEN, NVIDIA_RTX2070S_DEV, ASUS_SUB_VEN, ASUS_ROG_STRIX_RTX2070S_A8G_GAMING_86FF, 0x2A);
|
||||
REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070S A8G Gaming 8G" , DetectAsusAuraGPUControllers, NVIDIA_VEN, NVIDIA_RTX2070S_OC_DEV, ASUS_SUB_VEN, ASUS_ROG_STRIX_RTX2070S_A8G_GAMING, 0x2A);
|
||||
REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070S A8G Gaming 8G" , DetectAsusAuraGPUControllers, NVIDIA_VEN, NVIDIA_RTX2070S_OC_DEV, ASUS_SUB_VEN, ASUS_ROG_STRIX_RTX2070S_A8G_GAMING_8706, 0x2A);
|
||||
REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070S O8G Gaming" , DetectAsusAuraGPUControllers, NVIDIA_VEN, NVIDIA_RTX2070S_OC_DEV, ASUS_SUB_VEN, ASUS_ROG_STRIX_RTX2070S_O8G_GAMING_8729, 0x2A);
|
||||
REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070S 8G Gaming" , DetectAsusAuraGPUControllers, NVIDIA_VEN, NVIDIA_RTX2070S_OC_DEV, ASUS_SUB_VEN, ASUS_ROG_STRIX_RTX2070S_8G_GAMING_8707, 0x2A);
|
||||
REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070S O8G Gaming" , DetectAsusAuraGPUControllers, NVIDIA_VEN, NVIDIA_RTX2070S_OC_DEV, ASUS_SUB_VEN, ASUS_ROG_STRIX_RTX2070S_O8G_GAMING, 0x2A);
|
||||
REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080 8G Gaming" , DetectAsusAuraGPUControllers, NVIDIA_VEN, NVIDIA_RTX2080_DEV, ASUS_SUB_VEN, ASUS_ROG_STRIX_RTX2080_8G_GAMING, 0x2A);
|
||||
REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2070S O8G Gaming 8G" , DetectAsusAuraGPUControllers, NVIDIA_VEN, NVIDIA_RTX2070S_OC_DEV, ASUS_SUB_VEN, ASUS_ROG_STRIX_RTX2070S_O8G_GAMING, 0x2A);
|
||||
REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080 O8G Gaming" , DetectAsusAuraGPUControllers, NVIDIA_VEN, NVIDIA_RTX2080_A_DEV, ASUS_SUB_VEN, ASUS_ROG_STRIX_RTX2080_O8G_GAMING, 0x2A);
|
||||
REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080 O8G V2 Gaming" , DetectAsusAuraGPUControllers, NVIDIA_VEN, NVIDIA_RTX2080_A_DEV, ASUS_SUB_VEN, ASUS_ROG_STRIX_RTX2080_O8G_V2_GAMING, 0x2A);
|
||||
REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080 8G Gaming" , DetectAsusAuraGPUControllers, NVIDIA_VEN, NVIDIA_RTX2080_DEV, ASUS_SUB_VEN, ASUS_ROG_STRIX_RTX2080_8G_GAMING, 0x2A);
|
||||
REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080S A8G Gaming" , DetectAsusAuraGPUControllers, NVIDIA_VEN, NVIDIA_RTX2080S_DEV, ASUS_SUB_VEN, ASUS_ROG_STRIX_RTX2080S_A8G_GAMING, 0x2A);
|
||||
REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080S O8G Gaming" , DetectAsusAuraGPUControllers, NVIDIA_VEN, NVIDIA_RTX2080S_DEV, ASUS_SUB_VEN, ASUS_ROG_STRIX_RTX2080S_O8G_GAMING, 0x2A);
|
||||
REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080S O8G White" , DetectAsusAuraGPUControllers, NVIDIA_VEN, NVIDIA_RTX2080S_DEV, ASUS_SUB_VEN, ASUS_ROG_STRIX_RTX2080S_O8G_WHITE, 0x2A);
|
||||
REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080 Ti 11G Gaming" , DetectAsusAuraGPUControllers, NVIDIA_VEN, NVIDIA_RTX2080TI_DEV, ASUS_SUB_VEN, ASUS_ROG_STRIX_RTX2080TI_11G_GAMING, 0x2A);
|
||||
REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080 Ti 11G Gaming" , DetectAsusAuraGPUControllers, NVIDIA_VEN, NVIDIA_RTX2080TI_A_DEV, ASUS_SUB_VEN, ASUS_ROG_STRIX_RTX2080TI_11G_GAMING_866C, 0x2A);
|
||||
REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080 Ti A11G Gaming" , DetectAsusAuraGPUControllers, NVIDIA_VEN, NVIDIA_RTX2080TI_A_DEV, ASUS_SUB_VEN, ASUS_ROG_STRIX_RTX2080TI_A11G_GAMING, 0x2A);
|
||||
REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080 Ti O11G Gaming" , DetectAsusAuraGPUControllers, NVIDIA_VEN, NVIDIA_RTX2080TI_A_DEV, ASUS_SUB_VEN, ASUS_ROG_STRIX_RTX2080TI_O11G_GAMING, 0x2A);
|
||||
REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RTX 2080 Ti A11G Gaming" , DetectAsusAuraGPUControllers, NVIDIA_VEN, NVIDIA_RTX2080TI_A_DEV, ASUS_SUB_VEN, ASUS_ROG_STRIX_RTX2080TI_A11G_GAMING, 0x2A);
|
||||
REGISTER_I2C_PCI_DETECTOR("ASUS TUF RTX 3060 Ti 8G Gaming OC" , DetectAsusAuraGPUControllers, NVIDIA_VEN, NVIDIA_RTX3060TI_LHR_DEV, ASUS_SUB_VEN, ASUS_TUF_RTX_3060_TI_O8G_OC, 0x2A);
|
||||
|
||||
/*-----------------------------------------*\
|
||||
| AMD GPUs |
|
||||
\*-----------------------------------------*/
|
||||
|
||||
REGISTER_I2C_PCI_DETECTOR("ASUS AREZ Strix RX Vega 56 O8G" , DetectAsusAuraGPUControllers, AMD_GPU_VEN, AMD_VEGA10_DEV, ASUS_SUB_VEN, ASUS_AREZ_STRIX_VEGA56_08G_GAMING, 0x29);
|
||||
REGISTER_I2C_PCI_DETECTOR("ASUS Vega 64 Strix" , DetectAsusAuraGPUControllers, AMD_GPU_VEN, AMD_VEGA10_DEV, ASUS_SUB_VEN, ASUS_VEGA64_STRIX, 0x29);
|
||||
REGISTER_I2C_PCI_DETECTOR("ASUS RX 5600XT Strix O6G Gaming" , DetectAsusAuraGPUControllers, AMD_GPU_VEN, AMD_NAVI10_DEV, ASUS_SUB_VEN, ASUS_RX5600XT_STRIX_O6G_GAMING, 0x2A);
|
||||
REGISTER_I2C_PCI_DETECTOR("ASUS RX 5700XT Strix Gaming OC" , DetectAsusAuraGPUControllers, AMD_GPU_VEN, AMD_NAVI10_DEV, ASUS_SUB_VEN, ASUS_RX5700XT_STRIX_GAMING_OC, 0x2A);
|
||||
REGISTER_I2C_PCI_DETECTOR("ASUS RX 5700XT Strix 08G Gaming" , DetectAsusAuraGPUControllers, AMD_GPU_VEN, AMD_NAVI10_DEV, ASUS_SUB_VEN, ASUS_RX5700XT_STRIX_O8G_GAMING, 0x2A);
|
||||
REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RX470 O4G Gaming" , DetectAsusAuraGPUControllers, AMD_GPU_VEN, AMD_POLARIS_DEV, ASUS_SUB_VEN, ASUS_RX470_STRIX_O4G_GAMING, 0x29);
|
||||
REGISTER_I2C_PCI_DETECTOR("ASUS RX 6800 TUF Gaming OC" , DetectAsusAuraGPUControllers, AMD_GPU_VEN, AMD_NAVI21_DEV1, ASUS_SUB_VEN, ASUS_RX6800_TUF_GAMING_OC, 0x2A);
|
||||
REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RX480 Gaming OC" , DetectAsusAuraGPUControllers, AMD_GPU_VEN, AMD_POLARIS_DEV, ASUS_SUB_VEN, ASUS_RX480_STRIX_GAMING_OC, 0x29);
|
||||
REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RX560 Gaming" , DetectAsusAuraGPUControllers, AMD_GPU_VEN, AMD_POLARIS11, ASUS_SUB_VEN, ASUS_RX560_STRIX_4G_GAMING, 0x29);
|
||||
REGISTER_I2C_PCI_DETECTOR("ASUS RX 570 Strix O4G Gaming OC" , DetectAsusAuraGPUControllers, AMD_GPU_VEN, AMD_POLARIS_DEV, ASUS_SUB_VEN, ASUS_RX570_STRIX_O4G_GAMING_OC, 0x29);
|
||||
REGISTER_I2C_PCI_DETECTOR("ASUS RX 570 Strix O8G Gaming OC" , DetectAsusAuraGPUControllers, AMD_GPU_VEN, AMD_POLARIS_DEV, ASUS_SUB_VEN, ASUS_RX570_STRIX_O8G_GAMING_OC, 0x29);
|
||||
REGISTER_I2C_PCI_DETECTOR("ASUS RX 580 Strix Gaming OC" , DetectAsusAuraGPUControllers, AMD_GPU_VEN, AMD_POLARIS_DEV, ASUS_SUB_VEN, ASUS_RX580_STRIX_GAMING_OC, 0x29);
|
||||
REGISTER_I2C_PCI_DETECTOR("ASUS RX 580 Strix Gaming TOP" , DetectAsusAuraGPUControllers, AMD_GPU_VEN, AMD_POLARIS_DEV, ASUS_SUB_VEN, ASUS_RX580_STRIX_GAMING_TOP, 0x29);
|
||||
REGISTER_I2C_PCI_DETECTOR("ASUS RX 6900XT TUF Gaming OC" , DetectAsusAuraGPUControllers, AMD_GPU_VEN, AMD_NAVI21_DEV1, ASUS_SUB_VEN, ASUS_TUF_RX6900XT_O16G_GAMING, 0x2A);
|
||||
|
||||
@@ -15,7 +15,6 @@ AuraMainboardController::AuraMainboardController(hid_device* dev_handle, const c
|
||||
unsigned char num_total_mainboard_leds = config_table[0x1B];
|
||||
unsigned char num_rgb_headers = config_table[0x1D];
|
||||
unsigned char num_addressable_headers = config_table[0x02];
|
||||
unsigned char effect_channel = 0;
|
||||
|
||||
if(num_total_mainboard_leds < num_rgb_headers)
|
||||
{
|
||||
@@ -25,18 +24,14 @@ AuraMainboardController::AuraMainboardController(hid_device* dev_handle, const c
|
||||
/*-----------------------------------------------------*\
|
||||
| Add mainboard device |
|
||||
\*-----------------------------------------------------*/
|
||||
if(num_total_mainboard_leds > 0)
|
||||
{
|
||||
device_info.push_back({effect_channel, 0x04, num_total_mainboard_leds, num_rgb_headers, AuraDeviceType::FIXED});
|
||||
effect_channel++;
|
||||
}
|
||||
device_info.push_back({0x00, 0x04, num_total_mainboard_leds, num_rgb_headers, AuraDeviceType::FIXED});
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Add addressable devices |
|
||||
\*-----------------------------------------------------*/
|
||||
for(int i = 0; i < num_addressable_headers; i++)
|
||||
{
|
||||
device_info.push_back({effect_channel, (unsigned char)i, 0x01, 0, AuraDeviceType::ADDRESSABLE});
|
||||
device_info.push_back({0x01, (unsigned char)i, 0x01, 0, AuraDeviceType::ADDRESSABLE});
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -83,19 +83,17 @@ void AuraMonitorController::UpdateLed
|
||||
usb_buf[0x02] = 0xA1;
|
||||
usb_buf[0x03] = 0x80;
|
||||
|
||||
unsigned char offset = (device_pid == AURA_ROG_STRIX_XG279Q_PID) ? 0 : 16;
|
||||
|
||||
usb_buf[0x04] = offset + led * 3;
|
||||
usb_buf[0x04] = 16 + led * 3;
|
||||
usb_buf[0x05] = red;
|
||||
|
||||
hid_send_feature_report(dev, usb_buf, 8);
|
||||
|
||||
usb_buf[0x04] = offset + led * 3 + 1;
|
||||
usb_buf[0x04] = 16 + led * 3 + 1;
|
||||
usb_buf[0x05] = blue;
|
||||
|
||||
hid_send_feature_report(dev, usb_buf, 8);
|
||||
|
||||
usb_buf[0x04] = offset + led * 3 + 2;
|
||||
usb_buf[0x04] = 16 + led * 3 + 2;
|
||||
usb_buf[0x05] = green;
|
||||
|
||||
hid_send_feature_report(dev, usb_buf, 8);
|
||||
|
||||
@@ -15,11 +15,9 @@
|
||||
|
||||
enum
|
||||
{
|
||||
AURA_ROG_STRIX_XG27AQ_PID = 0x198C,
|
||||
AURA_ROG_STRIX_XG27AQM_PID = 0x19BB,
|
||||
AURA_ROG_STRIX_XG279Q_PID = 0x1919,
|
||||
AURA_ROG_STRIX_XG27W_PID = 0x1933,
|
||||
AURA_ROG_PG32UQ_PID = 0x19B9,
|
||||
AURA_ROG_STRIX_XG27AQ_PID = 0x198C,
|
||||
AURA_ROG_STRIX_XG27W_PID = 0x1933,
|
||||
AURA_ROG_PG32UQ_PID = 0x19B9,
|
||||
};
|
||||
|
||||
|
||||
|
||||
@@ -67,17 +67,15 @@ std::string AuraMouseController::GetVersion(bool wireless, int protocol)
|
||||
break;
|
||||
|
||||
case 1:
|
||||
case 2:
|
||||
{
|
||||
char version[9];
|
||||
int wireless_offset = (protocol == 2 ? 14 : 13);
|
||||
int offset = (wireless ? wireless_offset : 4);
|
||||
int offset = (wireless ? 13 : 4);
|
||||
snprintf(version, 9, "%2X.%02X.%02X", usb_buf_out[offset + 2], usb_buf_out[offset + 1], usb_buf_out[offset]);
|
||||
str = std::string(version);
|
||||
}
|
||||
break;
|
||||
|
||||
case 3:
|
||||
case 2:
|
||||
{
|
||||
unsigned char* offset = usb_buf_out + (wireless ? 13 : 4);
|
||||
str = std::string(offset, offset + 4);
|
||||
@@ -85,7 +83,7 @@ std::string AuraMouseController::GetVersion(bool wireless, int protocol)
|
||||
}
|
||||
break;
|
||||
|
||||
case 4:
|
||||
case 3:
|
||||
{
|
||||
char version[16];
|
||||
int offset = (wireless ? 13 : 4);
|
||||
|
||||
@@ -18,17 +18,12 @@
|
||||
#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_GLADIUS_III_PID 0x197B
|
||||
#define AURA_ROG_GLADIUS_III_WIRELESS_USB_PID 0x197D
|
||||
#define AURA_ROG_GLADIUS_III_WIRELESS_2_4_PID 0x197F
|
||||
#define AURA_ROG_GLADIUS_III_WIRELESS_BT_PID 0x1981
|
||||
#define AURA_ROG_CHAKRAM_WIRELESS_PID 0x18E5
|
||||
#define AURA_ROG_CHAKRAM_WIRED_1_PID 0x18E3
|
||||
#define AURA_ROG_CHAKRAM_CORE_PID 0x1958
|
||||
#define AURA_ROG_CHAKRAM_X_USB_PID 0x1A18
|
||||
#define AURA_ROG_CHAKRAM_X_2_4_PID 0x1A1A
|
||||
#define AURA_ROG_SPATHA_X_USB_PID 0x1977
|
||||
#define AURA_ROG_SPATHA_X_2_4_PID 0x1979
|
||||
#define AURA_ROG_PUGIO_PID 0x1846
|
||||
#define AURA_ROG_PUGIO_II_WIRED_PID 0x1906
|
||||
#define AURA_ROG_PUGIO_II_WIRELESS_PID 0x1908
|
||||
@@ -46,15 +41,12 @@
|
||||
#define AURA_TUF_M3_PID 0x1910
|
||||
#define AURA_TUF_M5_PID 0x1898
|
||||
|
||||
#define AURA_ROG_SPATHA_X_DOCK_FAKE_PID 0xFFFF
|
||||
|
||||
enum
|
||||
{
|
||||
AURA_MOUSE_ZONE_LOGO = 0,
|
||||
AURA_MOUSE_ZONE_SCROLL = 1,
|
||||
AURA_MOUSE_ZONE_UNDERGLOW = 2,
|
||||
AURA_MOUSE_ZONE_ALL = 3,
|
||||
AURA_MOUSE_ZONE_DOCK = 4,
|
||||
};
|
||||
|
||||
enum
|
||||
@@ -182,19 +174,6 @@ static std::map<int,mouse_type> aura_mouse_devices =
|
||||
{ AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_BATTERY }
|
||||
}
|
||||
},
|
||||
{
|
||||
AURA_ROG_GLADIUS_III_PID, // ROG Gladius III
|
||||
{
|
||||
255,
|
||||
1,
|
||||
0,
|
||||
64,
|
||||
false,
|
||||
1,
|
||||
{ AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
|
||||
{ AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_WAVE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_COMET, AURA_MOUSE_MODE_BATTERY }
|
||||
}
|
||||
},
|
||||
{
|
||||
AURA_ROG_GLADIUS_III_WIRELESS_USB_PID, // ROG Gladius III Wireless USB
|
||||
{
|
||||
@@ -273,58 +252,6 @@ static std::map<int,mouse_type> aura_mouse_devices =
|
||||
{ AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_REACTIVE }
|
||||
}
|
||||
},
|
||||
{
|
||||
AURA_ROG_CHAKRAM_X_USB_PID, // ROG Chakram X USB
|
||||
{
|
||||
15, // technically until 255, but unusably slow after 15
|
||||
1,
|
||||
0,
|
||||
64,
|
||||
false,
|
||||
2,
|
||||
{ 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_X_2_4_PID, // ROG Chakram X 2.4GHz Dongle
|
||||
{
|
||||
15, // technically until 255, but unusably slow after 15
|
||||
1,
|
||||
0,
|
||||
64,
|
||||
true,
|
||||
2,
|
||||
{ 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_SPATHA_X_USB_PID, // ROG Spatha X USB
|
||||
{
|
||||
15, // technically until 255, but unusably slow after 15
|
||||
1,
|
||||
0,
|
||||
64,
|
||||
false,
|
||||
1,
|
||||
{ AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
|
||||
{ AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_WAVE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_COMET, AURA_MOUSE_MODE_BATTERY }
|
||||
}
|
||||
},
|
||||
{
|
||||
AURA_ROG_SPATHA_X_2_4_PID, // ROG Spatha X 2.4GHz Dock
|
||||
{
|
||||
15, // technically until 255, but unusably slow after 15
|
||||
1,
|
||||
0,
|
||||
64,
|
||||
true,
|
||||
1,
|
||||
{ AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
|
||||
{ AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_WAVE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_COMET, AURA_MOUSE_MODE_BATTERY }
|
||||
}
|
||||
},
|
||||
{
|
||||
AURA_ROG_PUGIO_PID, // ROG Pugio
|
||||
{
|
||||
@@ -372,9 +299,9 @@ static std::map<int,mouse_type> aura_mouse_devices =
|
||||
0,
|
||||
4,
|
||||
false,
|
||||
4,
|
||||
3,
|
||||
{ AURA_MOUSE_ZONE_LOGO },
|
||||
{ AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_REACTIVE }
|
||||
{ AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM }
|
||||
}
|
||||
},
|
||||
{
|
||||
@@ -528,22 +455,9 @@ static std::map<int,mouse_type> aura_mouse_devices =
|
||||
0,
|
||||
4,
|
||||
false,
|
||||
3,
|
||||
2,
|
||||
{ AURA_MOUSE_ZONE_LOGO },
|
||||
{ AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_REACTIVE }
|
||||
}
|
||||
},
|
||||
{
|
||||
AURA_ROG_SPATHA_X_DOCK_FAKE_PID, // Asus ROG Spatha X Dock (only in wireless mode)
|
||||
{
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
100,
|
||||
false,
|
||||
1,
|
||||
{ AURA_MOUSE_ZONE_DOCK },
|
||||
{ AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_NONE, AURA_MOUSE_MODE_BATTERY }
|
||||
}
|
||||
},
|
||||
};
|
||||
|
||||
@@ -55,8 +55,8 @@ std::string AuraMousematController::GetVersion()
|
||||
unsigned char usb_buf_out[65];
|
||||
hid_read(dev, usb_buf_out, 65);
|
||||
|
||||
char version[9];
|
||||
snprintf(version, 9, "%X.%02X.%02X", usb_buf_out[6], usb_buf_out[7], usb_buf_out[8]);
|
||||
char version[5];
|
||||
snprintf(version, 5, "%04X", (usb_buf_out[6] << 8) | usb_buf_out[7]);
|
||||
return std::string(version);
|
||||
}
|
||||
|
||||
@@ -116,7 +116,7 @@ void AuraMousematController::UpdateDevice
|
||||
usb_buf[0x0b + i * 3] = RGBGetGValue(colors[i]);
|
||||
usb_buf[0x0c + i * 3] = RGBGetBValue(colors[i]);
|
||||
}
|
||||
|
||||
|
||||
hid_write(dev, usb_buf, 65);
|
||||
}
|
||||
|
||||
@@ -128,7 +128,7 @@ void AuraMousematController::SaveMode()
|
||||
|
||||
usb_save_buf[0x00] = 0xEE;
|
||||
usb_save_buf[0x01] = 0x50;
|
||||
usb_save_buf[0x02] = 0x03;
|
||||
usb_save_buf[0x02] = 0x55;
|
||||
|
||||
hid_write(dev, usb_save_buf, 65);
|
||||
}
|
||||
|
||||
@@ -17,14 +17,11 @@
|
||||
#include <string.h>
|
||||
#include <cmath>
|
||||
|
||||
AuraTUFKeyboardController::AuraTUFKeyboardController(hid_device* dev_handle, const char* path, uint16_t pid, unsigned short version)
|
||||
AuraTUFKeyboardController::AuraTUFKeyboardController(hid_device* dev_handle, const char* path, uint16_t pid)
|
||||
{
|
||||
dev = dev_handle;
|
||||
location = path;
|
||||
device_pid = pid;
|
||||
rev_version = version;
|
||||
|
||||
is_per_led_keyboard = (pid != AURA_TUF_K1_GAMING_PID && pid != AURA_TUF_K5_GAMING_PID);
|
||||
}
|
||||
|
||||
AuraTUFKeyboardController::~AuraTUFKeyboardController()
|
||||
@@ -54,158 +51,58 @@ std::string AuraTUFKeyboardController::GetSerialString()
|
||||
}
|
||||
|
||||
std::string AuraTUFKeyboardController::GetVersion()
|
||||
{
|
||||
if(device_pid != AURA_ROG_CLAYMORE_PID)
|
||||
{
|
||||
unsigned char usb_buf[65];
|
||||
memset(usb_buf, 0x00, sizeof(usb_buf));
|
||||
|
||||
usb_buf[0x00] = 0x00;
|
||||
usb_buf[0x01] = 0x12;
|
||||
usb_buf[0x02] = 0x00;
|
||||
|
||||
ClearResponses();
|
||||
|
||||
hid_write(dev, usb_buf, 65);
|
||||
|
||||
unsigned char usb_buf_out[65];
|
||||
hid_read(dev, usb_buf_out, 65);
|
||||
|
||||
char version[9];
|
||||
|
||||
switch(device_pid)
|
||||
{
|
||||
case AURA_TUF_K3_GAMING_PID:
|
||||
case AURA_ROG_STRIX_FLARE_II_ANIMATE_PID:
|
||||
snprintf(version, 9, "%02X.%02X.%02X", usb_buf_out[6], usb_buf_out[5], usb_buf_out[4]);
|
||||
break;
|
||||
default:
|
||||
snprintf(version, 9, "%02X.%02X.%02X", usb_buf_out[5], usb_buf_out[6], usb_buf_out[7]);
|
||||
}
|
||||
|
||||
return std::string(version);
|
||||
}
|
||||
else
|
||||
{
|
||||
unsigned char usb_buf[65];
|
||||
memset(usb_buf, 0x00, sizeof(usb_buf));
|
||||
usb_buf[0x00] = 0x00;
|
||||
usb_buf[0x01] = 0x10;
|
||||
usb_buf[0x02] = 0x01;
|
||||
usb_buf[0x03] = 0x00;
|
||||
usb_buf[0x04] = 0x00;
|
||||
usb_buf[0x05] = 0x00; // set to 1 to get firmware version of numpad
|
||||
|
||||
ClearResponses();
|
||||
hid_write(dev, usb_buf, 65);
|
||||
AwaitResponse(20);
|
||||
|
||||
unsigned char usb_buf1[65];
|
||||
memset(usb_buf1, 0x00, sizeof(usb_buf1));
|
||||
usb_buf1[0x00] = 0x00;
|
||||
usb_buf1[0x01] = 0x12;
|
||||
usb_buf1[0x02] = 0x22;
|
||||
|
||||
ClearResponses();
|
||||
hid_write(dev, usb_buf1, 65);
|
||||
|
||||
unsigned char usb_buf_out[65];
|
||||
hid_read(dev, usb_buf_out, 65);
|
||||
|
||||
char version[9];
|
||||
snprintf(version, 9, "%02X.%02X.%02X", usb_buf_out[8], usb_buf_out[9], usb_buf_out[10]);
|
||||
|
||||
return std::string(version);
|
||||
}
|
||||
}
|
||||
|
||||
int AuraTUFKeyboardController::GetLayout()
|
||||
{
|
||||
if(device_pid != AURA_ROG_CLAYMORE_PID)
|
||||
{
|
||||
unsigned char usb_buf[65];
|
||||
memset(usb_buf, 0x00, sizeof(usb_buf));
|
||||
|
||||
usb_buf[0x00] = 0x00;
|
||||
usb_buf[0x01] = 0x12;
|
||||
usb_buf[0x02] = 0x12;
|
||||
|
||||
ClearResponses();
|
||||
hid_write(dev, usb_buf, 65);
|
||||
|
||||
unsigned char usb_buf_out[65];
|
||||
hid_read(dev, usb_buf_out, 65);
|
||||
|
||||
return(usb_buf_out[4] * 100 + usb_buf_out[5]);
|
||||
}
|
||||
else
|
||||
{
|
||||
switch(rev_version >> 0b1100)
|
||||
{
|
||||
case 1:
|
||||
return 117;
|
||||
case 2:
|
||||
return 204;
|
||||
case 3:
|
||||
return 221;
|
||||
case 4:
|
||||
return 117;
|
||||
default:
|
||||
return 117;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/*---------------------------------------------------------*\
|
||||
| only needed for Claymore |
|
||||
\*---------------------------------------------------------*/
|
||||
int AuraTUFKeyboardController::GetNumpadLocation()
|
||||
{
|
||||
unsigned char usb_buf[65];
|
||||
memset(usb_buf, 0x00, sizeof(usb_buf));
|
||||
|
||||
usb_buf[0x00] = 0x00;
|
||||
usb_buf[0x01] = 0x40;
|
||||
usb_buf[0x02] = 0x60;
|
||||
usb_buf[0x01] = 0x12;
|
||||
usb_buf[0x02] = 0x00;
|
||||
|
||||
ClearResponses();
|
||||
hid_write(dev, usb_buf, 65);
|
||||
|
||||
unsigned char usb_buf_out[65];
|
||||
hid_read(dev, usb_buf_out, 65);
|
||||
|
||||
return(usb_buf_out[5] * 2 + usb_buf_out[4]);
|
||||
char version[9];
|
||||
if (device_pid == AURA_TUF_K3_GAMING_PID)
|
||||
{
|
||||
snprintf(version, 9, "%02X.%02X.%02X", usb_buf_out[6], usb_buf_out[5], usb_buf_out[4]);
|
||||
}
|
||||
else
|
||||
{
|
||||
snprintf(version, 9, "%02X.%02X.%02X", usb_buf_out[5], usb_buf_out[6], usb_buf_out[7]);
|
||||
}
|
||||
|
||||
return std::string(version);
|
||||
}
|
||||
|
||||
int AuraTUFKeyboardController::GetLayout()
|
||||
{
|
||||
unsigned char usb_buf[65];
|
||||
memset(usb_buf, 0x00, sizeof(usb_buf));
|
||||
usb_buf[0x00] = 0x00;
|
||||
usb_buf[0x01] = 0x12;
|
||||
usb_buf[0x02] = 0x12;
|
||||
|
||||
hid_write(dev, usb_buf, 65);
|
||||
|
||||
unsigned char usb_buf_out[65];
|
||||
hid_read(dev, usb_buf_out, 65);
|
||||
|
||||
return(usb_buf_out[4] * 100 + usb_buf_out[5]);
|
||||
}
|
||||
|
||||
void AuraTUFKeyboardController::SaveMode()
|
||||
{
|
||||
unsigned char usb_save_buf[65];
|
||||
|
||||
memset(usb_save_buf, 0x00, sizeof(usb_save_buf));
|
||||
|
||||
usb_save_buf[0x00] = 0x00;
|
||||
usb_save_buf[0x01] = 0x50;
|
||||
usb_save_buf[0x02] = 0x55;
|
||||
|
||||
ClearResponses();
|
||||
hid_write(dev, usb_save_buf, 65);
|
||||
AwaitResponse(60);
|
||||
}
|
||||
|
||||
/*---------------------------------------------------------*\
|
||||
| only needed for Claymore |
|
||||
\*---------------------------------------------------------*/
|
||||
void AuraTUFKeyboardController::AllowRemoteControl(unsigned char type)
|
||||
{
|
||||
unsigned char usb_buf[65];
|
||||
memset(usb_buf, 0x00, sizeof(usb_buf));
|
||||
|
||||
usb_buf[0x00] = 0x00;
|
||||
usb_buf[0x01] = 0x41;
|
||||
usb_buf[0x02] = type;
|
||||
|
||||
ClearResponses();
|
||||
hid_write(dev, usb_buf, 65);
|
||||
AwaitResponse(20);
|
||||
}
|
||||
|
||||
void AuraTUFKeyboardController::UpdateSingleLed
|
||||
@@ -220,10 +117,11 @@ void AuraTUFKeyboardController::UpdateSingleLed
|
||||
| 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[1] = 0xc0;
|
||||
usb_buf[2] = 0x81;
|
||||
usb_buf[3] = 0x01;
|
||||
usb_buf[4] = 0x00;
|
||||
@@ -231,306 +129,146 @@ void AuraTUFKeyboardController::UpdateSingleLed
|
||||
/*-----------------------------------------------------*\
|
||||
| Convert LED index |
|
||||
\*-----------------------------------------------------*/
|
||||
usb_buf[5] = led;
|
||||
usb_buf[5] = floor(led/6)*8 + led%6;
|
||||
usb_buf[6] = red;
|
||||
usb_buf[7] = green;
|
||||
usb_buf[8] = blue;
|
||||
|
||||
ClearResponses();
|
||||
hid_write(dev, usb_buf, 65);
|
||||
AwaitResponse(20);
|
||||
}
|
||||
|
||||
void AuraTUFKeyboardController::UpdateLeds
|
||||
(
|
||||
std::vector<led_color> colors
|
||||
std::vector<RGBColor> colors
|
||||
)
|
||||
{
|
||||
int packets = ceil((float) colors.size() / 15);
|
||||
|
||||
for(int i = 0; i < packets; i++)
|
||||
/*-----------------------------------------------------*\
|
||||
| Loop over every column (optimisation needed) |
|
||||
\*-----------------------------------------------------*/
|
||||
for(unsigned int i = 0; i < 192; i += 16)
|
||||
{
|
||||
unsigned char usb_buf[65];
|
||||
unsigned char usb_buf[69];
|
||||
|
||||
memset(usb_buf, 0x00, sizeof(usb_buf));
|
||||
|
||||
int remaining = colors.size() - i * 15;
|
||||
|
||||
int leds = (remaining > 0x0F) ? 0x0F : remaining;
|
||||
|
||||
usb_buf[0] = 0x00;
|
||||
usb_buf[1] = 0xC0;
|
||||
usb_buf[1] = 0xc0;
|
||||
usb_buf[2] = 0x81;
|
||||
usb_buf[3] = leds;
|
||||
usb_buf[3] = (138 - i / 16 * 12);
|
||||
usb_buf[4] = 0x00;
|
||||
|
||||
for(int j = 0; j < leds; j++)
|
||||
for(unsigned int n = 0; n < 6; n++)
|
||||
{
|
||||
usb_buf[j * 4 + 5] = (is_per_led_keyboard) ? colors[i * 15 + j].value : 0x00;
|
||||
usb_buf[j * 4 + 6] = RGBGetRValue(colors[i * 15 + j].color);
|
||||
usb_buf[j * 4 + 7] = RGBGetGValue(colors[i * 15 + j].color);
|
||||
usb_buf[j * 4 + 8] = RGBGetBValue(colors[i * 15 + j].color);
|
||||
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]);
|
||||
}
|
||||
|
||||
ClearResponses();
|
||||
hid_write(dev, usb_buf, 65);
|
||||
AwaitResponse(20);
|
||||
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::UpdateK1Wave
|
||||
(
|
||||
std::vector<RGBColor> colors,
|
||||
unsigned char direction,
|
||||
unsigned char speed,
|
||||
unsigned char brightness
|
||||
)
|
||||
{
|
||||
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] = 0x03;
|
||||
usb_buf[0x04] = 0x00;
|
||||
usb_buf[0x05] = speed;
|
||||
usb_buf[0x06] = brightness;
|
||||
usb_buf[0x07] = 0x00;
|
||||
usb_buf[0x08] = direction;
|
||||
usb_buf[0x09] = 0x00;
|
||||
|
||||
usb_buf[10] = 5;
|
||||
usb_buf[11] = RGBGetRValue(colors[4]);
|
||||
usb_buf[12] = RGBGetGValue(colors[4]);
|
||||
usb_buf[13] = RGBGetBValue(colors[4]);
|
||||
|
||||
ClearResponses();
|
||||
hid_write(dev, usb_buf, 65);
|
||||
AwaitResponse(20);
|
||||
|
||||
for(unsigned int i = 0; i < 4; i ++)
|
||||
{
|
||||
usb_buf[10 + i * 4] = i + 1;
|
||||
usb_buf[11 + i * 4] = RGBGetRValue(colors[i]);
|
||||
usb_buf[12 + i * 4] = RGBGetGValue(colors[i]);
|
||||
usb_buf[13 + i * 4] = RGBGetBValue(colors[i]);
|
||||
}
|
||||
|
||||
ClearResponses();
|
||||
hid_write(dev, usb_buf, 65);
|
||||
AwaitResponse(20);
|
||||
}
|
||||
|
||||
void AuraTUFKeyboardController::UpdateDevice
|
||||
(
|
||||
unsigned char mode,
|
||||
std::vector<RGBColor> colors,
|
||||
unsigned char direction,
|
||||
unsigned char dir,
|
||||
unsigned char color_mode,
|
||||
unsigned char speed,
|
||||
unsigned char brightness
|
||||
)
|
||||
{
|
||||
if(device_pid == AURA_TUF_K1_GAMING_PID && mode == AURA_KEYBOARD_MODE_WAVE)
|
||||
{
|
||||
return UpdateK1Wave(colors, direction, speed, brightness);
|
||||
}
|
||||
|
||||
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] = brightness;
|
||||
usb_buf[0x07] = color_mode;
|
||||
usb_buf[0x08] = dir;
|
||||
usb_buf[0x09] = 0x02;
|
||||
|
||||
if(device_pid != AURA_ROG_CLAYMORE_PID)
|
||||
if(mode == 4 || mode == 5)
|
||||
{
|
||||
usb_buf[0x03] = mode;
|
||||
usb_buf[0x04] = 0x00;
|
||||
usb_buf[0x05] = speed;
|
||||
usb_buf[0x06] = brightness;
|
||||
usb_buf[0x07] = color_mode;
|
||||
usb_buf[0x08] = direction;
|
||||
/*-----------------------------------------------------*\
|
||||
| If mode is Rainbow or Ripple |
|
||||
\*-----------------------------------------------------*/
|
||||
usb_buf[0x0A] = colors.size();
|
||||
|
||||
if(is_per_led_keyboard)
|
||||
/*-----------------------------------------------------*\
|
||||
| Loop over every color given |
|
||||
\*-----------------------------------------------------*/
|
||||
for(unsigned int i = 0; i / 4 < colors.size(); i += 4)
|
||||
{
|
||||
usb_buf[0x09] = 0x02;
|
||||
|
||||
if(mode == AURA_KEYBOARD_MODE_WAVE || mode == AURA_KEYBOARD_MODE_RIPPLE)
|
||||
if(colors[i / 4])
|
||||
{
|
||||
usb_buf[0x0A] = colors.size();
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Loop over every color given |
|
||||
\*-----------------------------------------------------*/
|
||||
for(unsigned int i = 0; i < colors.size(); i ++)
|
||||
{
|
||||
if(colors[i])
|
||||
{
|
||||
usb_buf[11 + i * 4] = 100/(double)colors.size()*(i+1);
|
||||
usb_buf[12 + i * 4] = RGBGetRValue(colors[i]);
|
||||
usb_buf[13 + i * 4] = RGBGetGValue(colors[i]);
|
||||
usb_buf[14 + i * 4] = RGBGetBValue(colors[i]);
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
/*-----------------------------------------------------*\
|
||||
| Loop over Color1, Color2 and Background if there |
|
||||
\*-----------------------------------------------------*/
|
||||
for(unsigned int i = 0; i != colors.size(); i++)
|
||||
{
|
||||
if(colors[i])
|
||||
{
|
||||
usb_buf[10 + i * 3] = RGBGetRValue(colors[i]);
|
||||
usb_buf[11 + i * 3] = RGBGetGValue(colors[i]);
|
||||
usb_buf[12 + i * 3] = RGBGetBValue(colors[i]);
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
/*-----------------------------------------------------------------*\
|
||||
| Only handles K5 Rainbow. |
|
||||
| K1 is filtered out earlier and is executed in `UpdateK1Wave()` |
|
||||
\*-----------------------------------------------------------------*/
|
||||
if(mode == AURA_KEYBOARD_MODE_WAVE)
|
||||
{
|
||||
usb_buf[0x09] = 0x05;
|
||||
|
||||
for(unsigned int i = 0; i < 5; i ++)
|
||||
{
|
||||
usb_buf[10 + i * 4] = i + 1;
|
||||
usb_buf[11 + i * 4] = RGBGetRValue(colors[i]);
|
||||
usb_buf[12 + i * 4] = RGBGetGValue(colors[i]);
|
||||
usb_buf[13 + i * 4] = RGBGetBValue(colors[i]);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
/*-----------------------------------------------------*\
|
||||
| Loop over Color1, Color2 and Background if there |
|
||||
\*-----------------------------------------------------*/
|
||||
for(unsigned int i = 0; i != colors.size(); i++)
|
||||
{
|
||||
if(colors[i])
|
||||
{
|
||||
usb_buf[ 9 + i * 3] = RGBGetRValue(colors[i]);
|
||||
usb_buf[10 + i * 3] = RGBGetGValue(colors[i]);
|
||||
usb_buf[11 + i * 3] = RGBGetBValue(colors[i]);
|
||||
}
|
||||
}
|
||||
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
|
||||
{
|
||||
usb_buf[0x03] = 0x00;
|
||||
usb_buf[0x04] = 0x00;
|
||||
usb_buf[0x05] = mode;
|
||||
usb_buf[0x06] = speed;
|
||||
|
||||
bool random = (color_mode == 1);
|
||||
bool pattern = (color_mode == 2);
|
||||
|
||||
usb_buf[0x07] = random * 128 + pattern * 32 + direction;
|
||||
usb_buf[0x08] = 0xFF; // "byteExt1" unknown usage
|
||||
usb_buf[0x09] = 0xFF; // "byteExt2" unknown usage
|
||||
usb_buf[0x0A] = (mode == 2) ? 0x80 : 0xFF; // "Lightness" (not Brightness)
|
||||
|
||||
if(mode == 7)
|
||||
/*-----------------------------------------------------*\
|
||||
| Loop over Color1, Color2 and Background if there |
|
||||
\*-----------------------------------------------------*/
|
||||
for(unsigned int i = 0; i / 3 != colors.size(); i += 3)
|
||||
{
|
||||
UpdateQuicksandColors(colors);
|
||||
}
|
||||
else
|
||||
{
|
||||
if(mode == 4 && color_mode == 0)
|
||||
if(colors[i / 3])
|
||||
{
|
||||
usb_buf[11] = 0xFF;
|
||||
usb_buf[12] = 0xFF;
|
||||
usb_buf[13] = 0xFF;
|
||||
}
|
||||
|
||||
for(unsigned int i = 0; i < colors.size(); i ++)
|
||||
{
|
||||
if(colors[i])
|
||||
{
|
||||
usb_buf[11 + i * 3] = RGBGetRValue(colors[i]);
|
||||
usb_buf[12 + i * 3] = RGBGetGValue(colors[i]);
|
||||
usb_buf[13 + i * 3] = RGBGetBValue(colors[i]);
|
||||
}
|
||||
usb_buf[10 + i] = RGBGetRValue(colors[i/3]);
|
||||
usb_buf[11 + i] = RGBGetGValue(colors[i/3]);
|
||||
usb_buf[12 + i] = RGBGetBValue(colors[i/3]);
|
||||
}
|
||||
}
|
||||
|
||||
for(int i = 1; i < 5; i++)
|
||||
{
|
||||
usb_buf[5 + i * 12] = 0xFF;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
ClearResponses();
|
||||
/*-----------------------------------------------------*\
|
||||
| Send packet |
|
||||
\*-----------------------------------------------------*/
|
||||
hid_write(dev, usb_buf, 65);
|
||||
AwaitResponse(20);
|
||||
}
|
||||
|
||||
/*---------------------------------------------------------*\
|
||||
| only needed for Claymore |
|
||||
\*---------------------------------------------------------*/
|
||||
void AuraTUFKeyboardController::UpdateQuicksandColors
|
||||
(
|
||||
std::vector<RGBColor> colors
|
||||
)
|
||||
{
|
||||
unsigned char usb_buf[65];
|
||||
memset(usb_buf, 0x00, sizeof(usb_buf));
|
||||
|
||||
usb_buf[0x00] = 0x00;
|
||||
usb_buf[0x01] = 0x51;
|
||||
usb_buf[0x02] = 0x91;
|
||||
|
||||
for(unsigned int i = 0; i < 6; i++)
|
||||
{
|
||||
if(colors[i])
|
||||
{
|
||||
usb_buf[5 + i * 3] = RGBGetRValue(colors[i]);
|
||||
usb_buf[6 + i * 3] = RGBGetGValue(colors[i]);
|
||||
usb_buf[7 + i * 3] = RGBGetBValue(colors[i]);
|
||||
}
|
||||
}
|
||||
|
||||
ClearResponses();
|
||||
hid_write(dev, usb_buf, 65);
|
||||
AwaitResponse(20);
|
||||
}
|
||||
|
||||
/*---------------------------------------------------------*\
|
||||
| only needed for Claymore |
|
||||
\*---------------------------------------------------------*/
|
||||
void AuraTUFKeyboardController::UpdateMode(unsigned char mode)
|
||||
{
|
||||
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;
|
||||
|
||||
ClearResponses();
|
||||
hid_write(dev, usb_buf, 65);
|
||||
AwaitResponse(20);
|
||||
}
|
||||
|
||||
void AuraTUFKeyboardController::AwaitResponse(int ms)
|
||||
void AuraTUFKeyboardController::AwaitResponse()
|
||||
{
|
||||
unsigned char usb_buf_out[65];
|
||||
hid_read_timeout(dev, usb_buf_out, 65, ms);
|
||||
hid_read(dev, usb_buf_out, 65);
|
||||
}
|
||||
|
||||
void AuraTUFKeyboardController::ClearResponses()
|
||||
@@ -539,7 +277,7 @@ void AuraTUFKeyboardController::ClearResponses()
|
||||
unsigned char usb_buf_flush[65];
|
||||
while(result > 0)
|
||||
{
|
||||
result = hid_read_timeout(dev, usb_buf_flush, 65, 0);
|
||||
result = hid_read_timeout(dev, usb_buf_flush, 65, 0);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -16,6 +16,14 @@
|
||||
|
||||
#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,
|
||||
@@ -33,35 +41,22 @@ enum
|
||||
|
||||
enum
|
||||
{
|
||||
AURA_ROG_FALCHION_WIRED_PID = 0x193C,
|
||||
AURA_ROG_FALCHION_WIRELESS_PID = 0x193E,
|
||||
AURA_ROG_STRIX_FLARE_II_ANIMATE_PID = 0x19FC,
|
||||
AURA_TUF_K1_GAMING_PID = 0x1945,
|
||||
AURA_TUF_K3_GAMING_PID = 0x194B,
|
||||
AURA_TUF_K5_GAMING_PID = 0x1899,
|
||||
AURA_TUF_K7_GAMING_PID = 0x18AA,
|
||||
AURA_ROG_CLAYMORE_PID = 0x184D,
|
||||
AURA_TUF_K7_GAMING_PID = 0x18AA,
|
||||
AURA_TUF_K3_GAMING_PID = 0x194B,
|
||||
};
|
||||
|
||||
struct led_color
|
||||
{
|
||||
unsigned int value;
|
||||
RGBColor color;
|
||||
};
|
||||
|
||||
class AuraTUFKeyboardController
|
||||
{
|
||||
public:
|
||||
AuraTUFKeyboardController(hid_device* dev_handle, const char* path, uint16_t pid, unsigned short version);
|
||||
AuraTUFKeyboardController(hid_device* dev_handle, const char* path, uint16_t pid);
|
||||
~AuraTUFKeyboardController();
|
||||
|
||||
std::string GetDeviceLocation();
|
||||
std::string GetSerialString();
|
||||
std::string GetVersion();
|
||||
int GetLayout();
|
||||
int GetNumpadLocation();
|
||||
void SaveMode();
|
||||
void AllowRemoteControl(unsigned char type);
|
||||
|
||||
void UpdateSingleLed
|
||||
(
|
||||
@@ -73,37 +68,25 @@ public:
|
||||
|
||||
void UpdateLeds
|
||||
(
|
||||
std::vector<led_color> colors
|
||||
);
|
||||
|
||||
void UpdateK1Wave
|
||||
(
|
||||
std::vector<RGBColor> colors,
|
||||
unsigned char direction,
|
||||
unsigned char speed,
|
||||
unsigned char brightness
|
||||
std::vector<RGBColor> colors
|
||||
);
|
||||
|
||||
void UpdateDevice
|
||||
(
|
||||
unsigned char mode,
|
||||
std::vector<RGBColor> colors,
|
||||
unsigned char direction,
|
||||
unsigned char dir,
|
||||
unsigned char color_mode,
|
||||
unsigned char speed,
|
||||
unsigned char brightness
|
||||
);
|
||||
void UpdateQuicksandColors(std::vector<RGBColor> colors);
|
||||
void UpdateMode(unsigned char mode);
|
||||
void AwaitResponse(int ms);
|
||||
void AwaitResponse();
|
||||
void ClearResponses();
|
||||
|
||||
uint16_t device_pid;
|
||||
bool is_per_led_keyboard;
|
||||
|
||||
private:
|
||||
hid_device* dev;
|
||||
std::string location;
|
||||
unsigned short rev_version;
|
||||
};
|
||||
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -6,7 +6,6 @@
|
||||
#include "AsusAuraMainboardController.h"
|
||||
#include "AsusAuraMouseController.h"
|
||||
#include "AsusAuraMousematController.h"
|
||||
#include "AsusROGAllyController.h"
|
||||
#include "AsusAuraStrixEvolveController.h"
|
||||
#include "AsusAuraMonitorController.h"
|
||||
#include "AsusAuraRyuoAIOController.h"
|
||||
@@ -17,7 +16,6 @@
|
||||
#include "RGBController_AsusAuraTUFKeyboard.h"
|
||||
#include "RGBController_AsusAuraMouse.h"
|
||||
#include "RGBController_AsusAuraMousemat.h"
|
||||
#include "RGBController_AsusROGAlly.h"
|
||||
#include "RGBController_ROGStrixLC_Controller.h"
|
||||
#include "RGBController_AsusAuraStrixEvolve.h"
|
||||
#include "RGBController_AsusAuraMonitor.h"
|
||||
@@ -46,18 +44,11 @@
|
||||
#define AURA_ROG_FALCHION_WIRELESS_PID 0x193E
|
||||
#define AURA_ROG_STRIX_FLARE_PID 0x1875
|
||||
#define AURA_ROG_STRIX_FLARE_PNK_LTD_PID 0x18CF
|
||||
#define AURA_ROG_STRIX_FLARE_COD_BO4_PID 0x18AF
|
||||
#define AURA_ROG_STRIX_FLARE_II_ANIMATE_PID 0x19FC
|
||||
#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_ROG_STRIX_SCOPE_RX_TKL_DELUXE_PID 0x1A05
|
||||
#define AURA_ROG_STRIX_SCOPE_TKL_PNK_LTD_PID 0x1954
|
||||
#define AURA_ROG_CLAYMORE_PID 0x184D
|
||||
#define AURA_TUF_K1_GAMING_PID 0x1945
|
||||
#define AURA_TUF_K3_GAMING_PID 0x194B
|
||||
#define AURA_TUF_K5_GAMING_PID 0x1899
|
||||
#define AURA_TUF_K7_GAMING_PID 0x18AA
|
||||
#define AURA_TUF_K3_GAMING_PID 0x194B
|
||||
|
||||
/*-----------------------------------------------------------------*\
|
||||
| MICE - defined in AsusAuraMouseDevices.h |
|
||||
@@ -76,8 +67,6 @@
|
||||
\*-----------------------------------------------------------------*/
|
||||
|
||||
#define AURA_ROG_STRIX_XG27AQ_PID 0x198C
|
||||
#define AURA_ROG_STRIX_XG27AQM_PID 0x19BB
|
||||
#define AURA_ROG_STRIX_XG279Q_PID 0x1919
|
||||
#define AURA_ROG_STRIX_XG27W_PID 0x1933
|
||||
#define AURA_ROG_PG32UQ_PID 0x19B9
|
||||
|
||||
@@ -95,7 +84,6 @@
|
||||
#define AURA_TERMINAL_PID 0x1889
|
||||
#define ROG_STRIX_LC120_PID 0x879E
|
||||
#define AURA_RYUO_AIO_PID 0x1887
|
||||
#define ASUS_ROG_ALLY_PID 0x1ABE
|
||||
|
||||
AuraKeyboardMappingLayoutType GetKeyboardMappingLayoutType(int pid)
|
||||
{
|
||||
@@ -103,7 +91,6 @@ AuraKeyboardMappingLayoutType GetKeyboardMappingLayoutType(int pid)
|
||||
{
|
||||
case AURA_ROG_STRIX_FLARE_PID:
|
||||
case AURA_ROG_STRIX_FLARE_PNK_LTD_PID:
|
||||
case AURA_ROG_STRIX_FLARE_COD_BO4_PID:
|
||||
return FLARE_LAYOUT;
|
||||
|
||||
case AURA_ROG_STRIX_SCOPE_PID:
|
||||
@@ -113,10 +100,12 @@ AuraKeyboardMappingLayoutType GetKeyboardMappingLayoutType(int pid)
|
||||
return SCOPE_RX_LAYOUT;
|
||||
|
||||
case AURA_ROG_STRIX_SCOPE_TKL_PID:
|
||||
case AURA_ROG_STRIX_SCOPE_RX_TKL_DELUXE_PID:
|
||||
case AURA_ROG_STRIX_SCOPE_TKL_PNK_LTD_PID:
|
||||
return SCOPE_TKL_LAYOUT;
|
||||
|
||||
case AURA_ROG_FALCHION_WIRED_PID:
|
||||
case AURA_ROG_FALCHION_WIRELESS_PID:
|
||||
return FALCHION_LAYOUT;
|
||||
|
||||
default:
|
||||
return FLARE_LAYOUT;
|
||||
}
|
||||
@@ -195,15 +184,6 @@ void DetectAsusAuraUSBMice(hid_device_info* info, const std::string& name)
|
||||
RGBController_AuraMouse* rgb_controller = new RGBController_AuraMouse(controller);
|
||||
rgb_controller->name = name;
|
||||
ResourceManager::get()->RegisterRGBController(rgb_controller);
|
||||
|
||||
// adding the mouse dock for the ASUS ROG Spatha X
|
||||
if(info->product_id == AURA_ROG_SPATHA_X_2_4_PID)
|
||||
{
|
||||
AuraMouseController* dock_controller = new AuraMouseController(dev, info->path, AURA_ROG_SPATHA_X_DOCK_FAKE_PID);
|
||||
RGBController_AuraMouse* rgb_controller_dock = new RGBController_AuraMouse(dock_controller);
|
||||
rgb_controller_dock->name = "Asus ROG Spatha X Dock";
|
||||
ResourceManager::get()->RegisterRGBController(rgb_controller_dock);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -278,7 +258,7 @@ void DetectAsusAuraTUFUSBKeyboard(hid_device_info* info, const std::string& name
|
||||
|
||||
if(dev)
|
||||
{
|
||||
AuraTUFKeyboardController* controller = new AuraTUFKeyboardController(dev, info->path, info->product_id, info->release_number);
|
||||
AuraTUFKeyboardController* controller = new AuraTUFKeyboardController(dev, info->path, info->product_id);
|
||||
RGBController_AuraTUFKeyboard* rgb_controller = new RGBController_AuraTUFKeyboard(controller);
|
||||
rgb_controller->name = name;
|
||||
ResourceManager::get()->RegisterRGBController(rgb_controller);
|
||||
@@ -298,19 +278,6 @@ void DetectAsusAuraUSBMonitor(hid_device_info* info, const std::string& name)
|
||||
}
|
||||
}
|
||||
|
||||
void DetectAsusROGAlly(hid_device_info* info, const std::string& name)
|
||||
{
|
||||
hid_device* dev = hid_open_path(info->path);
|
||||
|
||||
if(dev)
|
||||
{
|
||||
ROGAllyController* controller = new ROGAllyController(dev, info->path);
|
||||
RGBController_AsusROGAlly* rgb_controller = new RGBController_AsusROGAlly(controller);
|
||||
rgb_controller->name = name;
|
||||
ResourceManager::get()->RegisterRGBController(rgb_controller);
|
||||
}
|
||||
}
|
||||
|
||||
/*-----------------------------------------------------------------*\
|
||||
| MOTHERBOARDS |
|
||||
\*-----------------------------------------------------------------*/
|
||||
@@ -325,22 +292,15 @@ REGISTER_HID_DETECTOR ("ASUS Aura Motherboard", DetectAs
|
||||
/*-----------------------------------------------------------------*\
|
||||
| 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 Flare CoD Black Ops 4 Edition",DetectAsusAuraUSBKeyboards, AURA_USB_VID, AURA_ROG_STRIX_FLARE_COD_BO4_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_IP("ASUS ROG Strix Scope RX TKL Wireless Deluxe", DetectAsusAuraUSBKeyboards, AURA_USB_VID, AURA_ROG_STRIX_SCOPE_RX_TKL_DELUXE_PID, 1, 0xFF00);
|
||||
REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Scope TKL PNK LTD", DetectAsusAuraUSBKeyboards, AURA_USB_VID, AURA_ROG_STRIX_SCOPE_TKL_PNK_LTD_PID, 1, 0xFF00);
|
||||
REGISTER_HID_DETECTOR_IP("ASUS ROG Claymore", DetectAsusAuraTUFUSBKeyboard, AURA_USB_VID, AURA_ROG_CLAYMORE_PID, 1, 0xFF00);
|
||||
REGISTER_HID_DETECTOR_IP("ASUS ROG Falchion (Wired)", DetectAsusAuraTUFUSBKeyboard, AURA_USB_VID, AURA_ROG_FALCHION_WIRED_PID, 1, 0xFF00);
|
||||
REGISTER_HID_DETECTOR_IP("ASUS ROG Falchion (Wireless)", DetectAsusAuraTUFUSBKeyboard, AURA_USB_VID, AURA_ROG_FALCHION_WIRELESS_PID, 1, 0xFF00);
|
||||
REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Flare II Animate", DetectAsusAuraTUFUSBKeyboard, AURA_USB_VID, AURA_ROG_STRIX_FLARE_II_ANIMATE_PID, 1, 0xFF00);
|
||||
REGISTER_HID_DETECTOR_IP("ASUS TUF Gaming K1", DetectAsusAuraTUFUSBKeyboard, AURA_USB_VID, AURA_TUF_K1_GAMING_PID, 2, 0xFF00);
|
||||
REGISTER_HID_DETECTOR_IP("ASUS TUF Gaming K3", DetectAsusAuraTUFUSBKeyboard, AURA_USB_VID, AURA_TUF_K3_GAMING_PID, 1, 0xFF00);
|
||||
REGISTER_HID_DETECTOR_IP("ASUS TUF Gaming K5", DetectAsusAuraTUFUSBKeyboard, AURA_USB_VID, AURA_TUF_K5_GAMING_PID, 2, 0xFF00);
|
||||
REGISTER_HID_DETECTOR_IP("ASUS TUF Gaming K7", DetectAsusAuraTUFUSBKeyboard, AURA_USB_VID, AURA_TUF_K7_GAMING_PID, 1, 0xFF00);
|
||||
REGISTER_HID_DETECTOR_IP("ASUS TUF Gaming K3", DetectAsusAuraTUFUSBKeyboard, AURA_USB_VID, AURA_TUF_K3_GAMING_PID, 1, 0xFF00);
|
||||
|
||||
/*-----------------------------------------------------------------*\
|
||||
| MICE |
|
||||
@@ -352,21 +312,16 @@ REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II Origin PNK LTD", DetectAs
|
||||
REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II Origin COD", DetectAsusAuraUSBMice, AURA_USB_VID, AURA_ROG_GLADIUS_II_ORIGIN_COD_PID, 2, 0xFF01);
|
||||
REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II Wireless", DetectAsusAuraUSBMice, AURA_USB_VID, AURA_ROG_GLADIUS_II_WIRELESS_1_PID, 1, 0xFF13);
|
||||
REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II Wireless", DetectAsusAuraUSBMice, AURA_USB_VID, AURA_ROG_GLADIUS_II_WIRELESS_2_PID, 2, 0xFF01);
|
||||
REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius III", DetectAsusAuraUSBMice, AURA_USB_VID, AURA_ROG_GLADIUS_III_PID, 0, 0xFF01);
|
||||
REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius III Wireless USB", DetectAsusAuraUSBMice, AURA_USB_VID, AURA_ROG_GLADIUS_III_WIRELESS_USB_PID, 0, 0xFF01);
|
||||
REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius III Wireless 2.4Ghz", DetectAsusAuraUSBMice, AURA_USB_VID, AURA_ROG_GLADIUS_III_WIRELESS_2_4_PID, 0, 0xFF01);
|
||||
REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius III Wireless Bluetooth", DetectAsusAuraUSBMice, AURA_USB_VID, AURA_ROG_GLADIUS_III_WIRELESS_BT_PID, 0, 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 Core", DetectAsusAuraUSBMice, AURA_USB_VID, AURA_ROG_CHAKRAM_CORE_PID, 0, 0xFF01);
|
||||
REGISTER_HID_DETECTOR_IP("Asus ROG Chakram X USB", DetectAsusAuraUSBMice, AURA_USB_VID, AURA_ROG_CHAKRAM_X_USB_PID, 0, 0xFF01);
|
||||
REGISTER_HID_DETECTOR_IP("Asus ROG Chakram X 2.4GHz", DetectAsusAuraUSBMice, AURA_USB_VID, AURA_ROG_CHAKRAM_X_2_4_PID, 0, 0xFF01);
|
||||
REGISTER_HID_DETECTOR_IP("Asus ROG Spatha X USB", DetectAsusAuraUSBMice, AURA_USB_VID, AURA_ROG_SPATHA_X_USB_PID, 0, 0xFF01);
|
||||
REGISTER_HID_DETECTOR_IP("Asus ROG Spatha X 2.4GHz", DetectAsusAuraUSBMice, AURA_USB_VID, AURA_ROG_SPATHA_X_2_4_PID, 0, 0xFF01);
|
||||
REGISTER_HID_DETECTOR_IP("ASUS ROG Pugio", DetectAsusAuraUSBMice, AURA_USB_VID, AURA_ROG_PUGIO_PID, 2, 0xFF01);
|
||||
REGISTER_HID_DETECTOR_IP("ASUS ROG Pugio II (Wired)", DetectAsusAuraUSBMice, AURA_USB_VID, AURA_ROG_PUGIO_II_WIRED_PID, 0, 0xFF01);
|
||||
REGISTER_HID_DETECTOR_IP("ASUS ROG Pugio II (Wireless)", DetectAsusAuraUSBMice, AURA_USB_VID, AURA_ROG_PUGIO_II_WIRELESS_PID, 0, 0xFF01);
|
||||
REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Impact", DetectAsusAuraUSBMice, AURA_USB_VID, AURA_ROG_STRIX_IMPACT_PID, 2, 0xFF01);
|
||||
REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Impact", DetectAsusAuraUSBMice, AURA_USB_VID, AURA_ROG_STRIX_IMPACT_PID, 0, 0xFF01);
|
||||
REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Impact II", DetectAsusAuraUSBMice, AURA_USB_VID, AURA_ROG_STRIX_IMPACT_II_PID, 0, 0xFF01);
|
||||
REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Impact II Gundam", DetectAsusAuraUSBMice, AURA_USB_VID, AURA_ROG_STRIX_IMPACT_II_GUNDAM_PID, 0, 0xFF01);
|
||||
REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Impact II Electro Punk", DetectAsusAuraUSBMice, AURA_USB_VID, AURA_ROG_STRIX_IMPACT_II_PUNK_PID, 0, 0xFF01);
|
||||
@@ -392,8 +347,6 @@ REGISTER_HID_DETECTOR_PU("ASUS ROG Balteus Qi", DetectAs
|
||||
| MONITORS |
|
||||
\*-----------------------------------------------------------------*/
|
||||
REGISTER_HID_DETECTOR_PU("ASUS ROG Strix XG27AQ", DetectAsusAuraUSBMonitor, AURA_USB_VID, AURA_ROG_STRIX_XG27AQ_PID, 0xFFA0, 1);
|
||||
REGISTER_HID_DETECTOR_PU("ASUS ROG Strix XG27AQM", DetectAsusAuraUSBMonitor, AURA_USB_VID, AURA_ROG_STRIX_XG27AQM_PID, 0xFFA0, 1);
|
||||
REGISTER_HID_DETECTOR_PU("ASUS ROG Strix XG279Q", DetectAsusAuraUSBMonitor, AURA_USB_VID, AURA_ROG_STRIX_XG279Q_PID, 0xFFA0, 1);
|
||||
REGISTER_HID_DETECTOR_PU("ASUS ROG Strix XG27W", DetectAsusAuraUSBMonitor, AURA_USB_VID, AURA_ROG_STRIX_XG27W_PID, 0xFFA0, 1);
|
||||
REGISTER_HID_DETECTOR_PU("ASUS ROG PG32UQ", DetectAsusAuraUSBMonitor, AURA_USB_VID, AURA_ROG_PG32UQ_PID, 0xFFA0, 1);
|
||||
|
||||
@@ -406,4 +359,3 @@ REGISTER_HID_DETECTOR_PU ("ASUS ROG Ryuo AIO", DetectAs
|
||||
REGISTER_HID_DETECTOR_I ("ASUS ROG Throne", DetectAsusAuraUSBHeadsetStand, AURA_USB_VID, AURA_ROG_THRONE_PID, 0);
|
||||
REGISTER_HID_DETECTOR_I ("ASUS ROG Throne QI", DetectAsusAuraUSBHeadsetStand, AURA_USB_VID, AURA_ROG_THRONE_QI_PID, 0);
|
||||
REGISTER_HID_DETECTOR_I ("ASUS ROG Throne QI GUNDAM", DetectAsusAuraUSBHeadsetStand, AURA_USB_VID, AURA_ROG_THRONE_QI_GUNDAM_PID, 0);
|
||||
REGISTER_HID_DETECTOR_IPU("ASUS ROG Ally", DetectAsusROGAlly, AURA_USB_VID, ASUS_ROG_ALLY_PID, 2, 0xFF31, 0x0076);
|
||||
|
||||
@@ -1,127 +0,0 @@
|
||||
/*-----------------------------------------*\
|
||||
| AsusROGAllyController.cpp |
|
||||
| |
|
||||
| Driver for ASUS ROG Ally lighting |
|
||||
| controller |
|
||||
| |
|
||||
| Adam Honse (CalcProgrammer1) 6/12/2023 |
|
||||
\*-----------------------------------------*/
|
||||
|
||||
#include "AsusROGAllyController.h"
|
||||
#include <cstring>
|
||||
|
||||
ROGAllyController::ROGAllyController(hid_device* dev_handle, const char* path)
|
||||
{
|
||||
dev = dev_handle;
|
||||
location = path;
|
||||
}
|
||||
|
||||
ROGAllyController::~ROGAllyController()
|
||||
{
|
||||
hid_close(dev);
|
||||
}
|
||||
|
||||
std::string ROGAllyController::GetDeviceLocation()
|
||||
{
|
||||
return("HID: " + location);
|
||||
}
|
||||
|
||||
std::string ROGAllyController::GetSerialString()
|
||||
{
|
||||
wchar_t serial_string[128];
|
||||
int ret = hid_get_serial_number_string(dev, serial_string, 128);
|
||||
|
||||
if(ret != 0)
|
||||
{
|
||||
return("");
|
||||
}
|
||||
|
||||
std::wstring return_wstring = serial_string;
|
||||
std::string return_string(return_wstring.begin(), return_wstring.end());
|
||||
|
||||
return(return_string);
|
||||
}
|
||||
|
||||
std::string ROGAllyController::GetVersion()
|
||||
{
|
||||
return("");
|
||||
}
|
||||
|
||||
void ROGAllyController::UpdateLeds
|
||||
(
|
||||
std::vector<RGBColor> colors
|
||||
)
|
||||
{
|
||||
unsigned char usb_buf[64];
|
||||
|
||||
memset(usb_buf, 0x00, sizeof(usb_buf));
|
||||
|
||||
usb_buf[0x00] = 0x5A;
|
||||
usb_buf[0x01] = 0xD1;
|
||||
usb_buf[0x02] = 0x08;
|
||||
usb_buf[0x03] = 0x0C;
|
||||
|
||||
for(unsigned int color_idx = 0; color_idx < colors.size(); color_idx++)
|
||||
{
|
||||
usb_buf[color_idx * 3 + 4] = RGBGetRValue(colors[color_idx]);
|
||||
usb_buf[color_idx * 3 + 5] = RGBGetGValue(colors[color_idx]);
|
||||
usb_buf[color_idx * 3 + 6] = RGBGetBValue(colors[color_idx]);
|
||||
}
|
||||
|
||||
hid_send_feature_report(dev, usb_buf, sizeof(usb_buf));
|
||||
}
|
||||
|
||||
void ROGAllyController::UpdateDevice
|
||||
(
|
||||
unsigned char mode,
|
||||
std::vector<RGBColor> colors,
|
||||
unsigned char speed,
|
||||
unsigned char /*brightness*/,
|
||||
unsigned char direction
|
||||
)
|
||||
{
|
||||
unsigned char usb_buf[64];
|
||||
|
||||
memset(usb_buf, 0x00, sizeof(usb_buf));
|
||||
|
||||
usb_buf[0x00] = 0x5A;
|
||||
usb_buf[0x01] = 0xB3;
|
||||
usb_buf[0x02] = 0x00;
|
||||
usb_buf[0x03] = mode;
|
||||
if(colors.size() > 0)
|
||||
{
|
||||
usb_buf[0x04] = RGBGetRValue(colors[0]);
|
||||
usb_buf[0x05] = RGBGetGValue(colors[0]);
|
||||
usb_buf[0x06] = RGBGetBValue(colors[0]);
|
||||
}
|
||||
usb_buf[0x07] = speed;
|
||||
usb_buf[0x08] = direction;
|
||||
if(colors.size() > 1)
|
||||
{
|
||||
usb_buf[0x0A] = RGBGetRValue(colors[1]);
|
||||
usb_buf[0x0B] = RGBGetGValue(colors[1]);
|
||||
usb_buf[0x0C] = RGBGetBValue(colors[1]);
|
||||
}
|
||||
|
||||
hid_send_feature_report(dev, usb_buf, sizeof(usb_buf));
|
||||
|
||||
memset(usb_buf, 0x00, sizeof(usb_buf));
|
||||
|
||||
usb_buf[0x00] = 0x5A;
|
||||
usb_buf[0x01] = 0xB5;
|
||||
|
||||
hid_send_feature_report(dev, usb_buf, sizeof(usb_buf));
|
||||
}
|
||||
|
||||
void ROGAllyController::SaveMode()
|
||||
{
|
||||
unsigned char usb_buf[64];
|
||||
|
||||
memset(usb_buf, 0x00, sizeof(usb_buf));
|
||||
|
||||
usb_buf[0x00] = 0x5A;
|
||||
usb_buf[0x01] = 0xB4;
|
||||
|
||||
hid_send_feature_report(dev, usb_buf, sizeof(usb_buf));
|
||||
}
|
||||
|
||||
@@ -1,67 +0,0 @@
|
||||
/*-----------------------------------------*\
|
||||
| AsusROGAllyController.h |
|
||||
| |
|
||||
| Definitions and types for ASUS ROG Ally |
|
||||
| lighting controller |
|
||||
| |
|
||||
| Adam Honse (CalcProgrammer1) 6/12/2023 |
|
||||
\*-----------------------------------------*/
|
||||
|
||||
#include "RGBController.h"
|
||||
#include <hidapi/hidapi.h>
|
||||
|
||||
#pragma once
|
||||
|
||||
enum
|
||||
{
|
||||
ROG_ALLY_MODE_STATIC = 0,
|
||||
ROG_ALLY_MODE_BREATHING = 1,
|
||||
ROG_ALLY_MODE_COLOR_CYCLE = 2,
|
||||
ROG_ALLY_MODE_RAINBOW = 3,
|
||||
ROG_ALLY_MODE_STROBING = 10,
|
||||
ROG_ALLY_MODE_DIRECT = 0xFF,
|
||||
};
|
||||
|
||||
enum
|
||||
{
|
||||
ROG_ALLY_SPEED_MIN = 0xE1,
|
||||
ROG_ALLY_SPEED_MED = 0xEB,
|
||||
ROG_ALLY_SPEED_MAX = 0xF5
|
||||
};
|
||||
|
||||
enum
|
||||
{
|
||||
ROG_ALLY_DIRECTION_RIGHT = 0x00,
|
||||
ROG_ALLY_DIRECTION_LEFT = 0x01
|
||||
};
|
||||
|
||||
class ROGAllyController
|
||||
{
|
||||
public:
|
||||
ROGAllyController(hid_device* dev_handle, const char* path);
|
||||
virtual ~ROGAllyController();
|
||||
|
||||
std::string GetDeviceLocation();
|
||||
std::string GetSerialString();
|
||||
std::string GetVersion();
|
||||
|
||||
void UpdateLeds
|
||||
(
|
||||
std::vector<RGBColor> colors
|
||||
);
|
||||
|
||||
void UpdateDevice
|
||||
(
|
||||
unsigned char mode,
|
||||
std::vector<RGBColor> colors,
|
||||
unsigned char speed,
|
||||
unsigned char brightness,
|
||||
unsigned char direction
|
||||
);
|
||||
|
||||
void SaveMode();
|
||||
|
||||
private:
|
||||
hid_device* dev;
|
||||
std::string location;
|
||||
};
|
||||
@@ -44,7 +44,7 @@ static unsigned int falchion_matrix_map[5][16] =
|
||||
{ 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 } };
|
||||
|
||||
static const std::vector<aura_keyboard_led> default_led_names =
|
||||
static const std::vector<led_type> default_led_names =
|
||||
{
|
||||
/* Key Label Index */
|
||||
{ KEY_EN_ESCAPE, 0x00 },
|
||||
@@ -153,7 +153,7 @@ static const std::vector<aura_keyboard_led> default_led_names =
|
||||
{ KEY_EN_NUMPAD_ENTER, 0xB4 },
|
||||
};
|
||||
|
||||
static const std::vector<aura_keyboard_led> default_tkl_led_names =
|
||||
static const std::vector<led_type> default_tkl_led_names =
|
||||
{
|
||||
/* Key Label Index */
|
||||
{ KEY_EN_ESCAPE, 0x00 },
|
||||
@@ -270,7 +270,7 @@ static const std::vector<aura_keyboard_led> default_tkl_led_names =
|
||||
{ "Underglow 26", 0xCE },
|
||||
};
|
||||
|
||||
static const std::vector<aura_keyboard_led> default_65pct_led_names =
|
||||
static const std::vector<led_type> default_65pct_led_names =
|
||||
{
|
||||
/* Key Label Index */
|
||||
{ KEY_EN_ESCAPE, 0x00 },
|
||||
@@ -395,7 +395,7 @@ void RGBController_AuraKeyboard::SetupZones()
|
||||
| Set up zones |
|
||||
\*---------------------------------------------------------*/
|
||||
std::vector<led_zone> led_zones;
|
||||
std::vector<aura_keyboard_led> led_names;
|
||||
std::vector<led_type> led_names;
|
||||
|
||||
switch(layout)
|
||||
{
|
||||
|
||||
@@ -24,7 +24,7 @@ typedef struct
|
||||
{
|
||||
const char* name;
|
||||
unsigned char idx;
|
||||
} aura_keyboard_led;
|
||||
} led_type;
|
||||
|
||||
typedef struct
|
||||
{
|
||||
|
||||
@@ -9,12 +9,11 @@
|
||||
|
||||
#include "RGBController_AsusAuraMouse.h"
|
||||
|
||||
static std::string aura_mouse_zone_names[4]
|
||||
static std::string aura_mouse_zone_names[3]
|
||||
{
|
||||
"Logo",
|
||||
"Scroll Wheel",
|
||||
"Underglow",
|
||||
"Dock"
|
||||
"Underglow"
|
||||
};
|
||||
|
||||
/**------------------------------------------------------------------*\
|
||||
@@ -30,9 +29,9 @@ static std::string aura_mouse_zone_names[4]
|
||||
|
||||
RGBController_AuraMouse::RGBController_AuraMouse(AuraMouseController* controller_ptr)
|
||||
{
|
||||
controller = controller_ptr;
|
||||
controller = controller_ptr;
|
||||
|
||||
pid = controller->device_pid;
|
||||
uint16_t pid = controller->device_pid;
|
||||
|
||||
name = "ASUS Aura Mouse";
|
||||
vendor = "ASUS";
|
||||
@@ -169,6 +168,8 @@ RGBController_AuraMouse::~RGBController_AuraMouse()
|
||||
|
||||
void RGBController_AuraMouse::SetupZones()
|
||||
{
|
||||
uint16_t pid = controller->device_pid;
|
||||
|
||||
for(std::vector<uint8_t>::iterator zone_it = aura_mouse_devices[pid].mouse_zones.begin(); zone_it != aura_mouse_devices[pid].mouse_zones.end(); zone_it++)
|
||||
{
|
||||
zone mouse_zone;
|
||||
@@ -206,9 +207,9 @@ void RGBController_AuraMouse::DeviceUpdateLEDs()
|
||||
}
|
||||
}
|
||||
|
||||
void RGBController_AuraMouse::UpdateZoneLEDs(int /*zone*/)
|
||||
void RGBController_AuraMouse::UpdateZoneLEDs(int zone)
|
||||
{
|
||||
DeviceUpdateLEDs();
|
||||
UpdateSingleLED(zone);
|
||||
}
|
||||
|
||||
void RGBController_AuraMouse::UpdateSingleLED(int led)
|
||||
@@ -239,22 +240,7 @@ void RGBController_AuraMouse::DeviceUpdateMode()
|
||||
blu = RGBGetBValue(modes[active_mode].colors[0]);
|
||||
}
|
||||
|
||||
|
||||
if(pid == AURA_ROG_SPATHA_X_DOCK_FAKE_PID)
|
||||
{
|
||||
controller->SendUpdate(AURA_MOUSE_ZONE_DOCK, modes[active_mode].value, red, grn, blu, modes[active_mode].direction, modes[active_mode].color_mode == MODE_COLORS_RANDOM, modes[active_mode].speed, modes[active_mode].brightness);
|
||||
}
|
||||
else if(pid == AURA_ROG_STRIX_IMPACT_PID)
|
||||
{
|
||||
/*-----------------------------------------------------------------*\
|
||||
| The ROG Impact doesn't accept AURA_MOUSE_ZONE_ALL |
|
||||
\*-----------------------------------------------------------------*/
|
||||
controller->SendUpdate(AURA_MOUSE_ZONE_LOGO, modes[active_mode].value, red, grn, blu, modes[active_mode].direction, modes[active_mode].color_mode == MODE_COLORS_RANDOM, modes[active_mode].speed, modes[active_mode].brightness);
|
||||
}
|
||||
else
|
||||
{
|
||||
controller->SendUpdate(AURA_MOUSE_ZONE_ALL, modes[active_mode].value, red, grn, blu, modes[active_mode].direction, modes[active_mode].color_mode == MODE_COLORS_RANDOM, modes[active_mode].speed, modes[active_mode].brightness);
|
||||
}
|
||||
controller->SendUpdate(AURA_MOUSE_ZONE_ALL, modes[active_mode].value, red, grn, blu, modes[active_mode].direction, modes[active_mode].color_mode == MODE_COLORS_RANDOM, modes[active_mode].speed, modes[active_mode].brightness);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -30,5 +30,4 @@ public:
|
||||
|
||||
private:
|
||||
AuraMouseController* controller;
|
||||
uint16_t pid;
|
||||
};
|
||||
|
||||
@@ -24,364 +24,178 @@
|
||||
|
||||
RGBController_AuraTUFKeyboard::RGBController_AuraTUFKeyboard(AuraTUFKeyboardController* controller_ptr)
|
||||
{
|
||||
controller = controller_ptr;
|
||||
controller = controller_ptr;
|
||||
|
||||
pid = controller->device_pid;
|
||||
name = "ASUS Aura Keyboard";
|
||||
vendor = "ASUS";
|
||||
type = DEVICE_TYPE_KEYBOARD;
|
||||
description = "ASUS Aura Keyboard Device";
|
||||
version = controller->GetVersion();
|
||||
location = controller->GetDeviceLocation();
|
||||
serial = controller->GetSerialString();
|
||||
|
||||
if(pid != AURA_ROG_CLAYMORE_PID)
|
||||
{
|
||||
name = "ASUS Aura Keyboard";
|
||||
vendor = "ASUS";
|
||||
type = DEVICE_TYPE_KEYBOARD;
|
||||
description = "ASUS Aura Keyboard Device";
|
||||
version = controller->GetVersion();
|
||||
location = controller->GetDeviceLocation();
|
||||
serial = controller->GetSerialString();
|
||||
mode Direct;
|
||||
Direct.name = "Direct";
|
||||
Direct.value = AURA_KEYBOARD_MODE_DIRECT;
|
||||
Direct.flags = MODE_FLAG_HAS_PER_LED_COLOR;
|
||||
Direct.color_mode = MODE_COLORS_PER_LED;
|
||||
modes.push_back(Direct);
|
||||
|
||||
unsigned char AURA_KEYBOARD_SPEED_MIN = 0;
|
||||
unsigned char AURA_KEYBOARD_SPEED_MAX = 0;
|
||||
unsigned char AURA_KEYBOARD_SPEED_DEFAULT = 0;
|
||||
mode Static;
|
||||
Static.name = "Static";
|
||||
Static.value = AURA_KEYBOARD_MODE_STATIC;
|
||||
Static.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
|
||||
Static.brightness_min = AURA_KEYBOARD_BRIGHTNESS_MIN;
|
||||
Static.brightness_max = AURA_KEYBOARD_BRIGHTNESS_MAX;
|
||||
Static.brightness = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
|
||||
Static.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Static.colors_min = 1;
|
||||
Static.colors_max = 1;
|
||||
Static.colors.resize(1);
|
||||
modes.push_back(Static);
|
||||
|
||||
switch(pid)
|
||||
{
|
||||
case AURA_TUF_K1_GAMING_PID:
|
||||
AURA_KEYBOARD_SPEED_MIN = 0;
|
||||
AURA_KEYBOARD_SPEED_MAX = 2;
|
||||
AURA_KEYBOARD_SPEED_DEFAULT = 1;
|
||||
break;
|
||||
case AURA_TUF_K3_GAMING_PID:
|
||||
case AURA_TUF_K7_GAMING_PID:
|
||||
AURA_KEYBOARD_SPEED_MIN = 15;
|
||||
AURA_KEYBOARD_SPEED_MAX = 0;
|
||||
AURA_KEYBOARD_SPEED_DEFAULT = 8;
|
||||
break;
|
||||
case AURA_TUF_K5_GAMING_PID:
|
||||
AURA_KEYBOARD_SPEED_MIN = 63;
|
||||
AURA_KEYBOARD_SPEED_MAX = 0;
|
||||
AURA_KEYBOARD_SPEED_DEFAULT = 31;
|
||||
break;
|
||||
case AURA_ROG_FALCHION_WIRED_PID:
|
||||
case AURA_ROG_FALCHION_WIRELESS_PID:
|
||||
case AURA_ROG_STRIX_FLARE_II_ANIMATE_PID:
|
||||
AURA_KEYBOARD_SPEED_MIN = 255;
|
||||
AURA_KEYBOARD_SPEED_MAX = 0;
|
||||
AURA_KEYBOARD_SPEED_DEFAULT = 8;
|
||||
break;
|
||||
default:
|
||||
AURA_KEYBOARD_SPEED_MIN = 15;
|
||||
AURA_KEYBOARD_SPEED_MAX = 0;
|
||||
AURA_KEYBOARD_SPEED_DEFAULT = 8;
|
||||
}
|
||||
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 | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
|
||||
Breathing.speed_min = AURA_KEYBOARD_SPEED_MIN;
|
||||
Breathing.speed_max = AURA_KEYBOARD_SPEED_MAX;
|
||||
Breathing.speed = AURA_KEYBOARD_SPEED_DEFAULT;
|
||||
Breathing.brightness_min = AURA_KEYBOARD_BRIGHTNESS_MIN;
|
||||
Breathing.brightness_max = AURA_KEYBOARD_BRIGHTNESS_MAX;
|
||||
Breathing.brightness = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
|
||||
Breathing.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Breathing.colors_min = 1;
|
||||
Breathing.colors_max = 2;
|
||||
Breathing.colors.resize(1);
|
||||
modes.push_back(Breathing);
|
||||
|
||||
mode 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 Color_Cycle;
|
||||
Color_Cycle.name = "Spectrum Cycle";
|
||||
Color_Cycle.value = AURA_KEYBOARD_MODE_COLOR_CYCLE;
|
||||
Color_Cycle.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
|
||||
Color_Cycle.speed_min = AURA_KEYBOARD_SPEED_MIN;
|
||||
Color_Cycle.speed_max = AURA_KEYBOARD_SPEED_MAX;
|
||||
Color_Cycle.speed = AURA_KEYBOARD_SPEED_DEFAULT;
|
||||
Color_Cycle.brightness_min = AURA_KEYBOARD_BRIGHTNESS_MIN;
|
||||
Color_Cycle.brightness_max = AURA_KEYBOARD_BRIGHTNESS_MAX;
|
||||
Color_Cycle.brightness = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
|
||||
Color_Cycle.color_mode = MODE_COLORS_NONE;
|
||||
modes.push_back(Color_Cycle);
|
||||
|
||||
mode Static;
|
||||
Static.name = "Static";
|
||||
Static.value = AURA_KEYBOARD_MODE_STATIC;
|
||||
Static.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
|
||||
Static.brightness_min = AURA_KEYBOARD_BRIGHTNESS_MIN;
|
||||
Static.brightness_max = AURA_KEYBOARD_BRIGHTNESS_MAX;
|
||||
Static.brightness = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
|
||||
Static.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Static.colors_min = 1;
|
||||
Static.colors_max = 1;
|
||||
Static.colors.resize(1);
|
||||
modes.push_back(Static);
|
||||
mode Wave;
|
||||
Wave.name = "Rainbow Wave";
|
||||
Wave.value = AURA_KEYBOARD_MODE_WAVE;
|
||||
Wave.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_DIRECTION_UD | MODE_FLAG_HAS_DIRECTION_HV | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
|
||||
Wave.speed_min = AURA_KEYBOARD_SPEED_MIN;
|
||||
Wave.speed_max = AURA_KEYBOARD_SPEED_MAX;
|
||||
Wave.speed = AURA_KEYBOARD_SPEED_DEFAULT;
|
||||
Wave.brightness_min = AURA_KEYBOARD_BRIGHTNESS_MIN;
|
||||
Wave.brightness_max = AURA_KEYBOARD_BRIGHTNESS_MAX;
|
||||
Wave.brightness = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
|
||||
Wave.direction = MODE_DIRECTION_LEFT;
|
||||
Wave.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Wave.colors_min = 1;
|
||||
Wave.colors_max = 7;
|
||||
Wave.colors.resize(7);
|
||||
modes.push_back(Wave);
|
||||
|
||||
mode Breathing;
|
||||
Breathing.name = "Breathing";
|
||||
Breathing.value = AURA_KEYBOARD_MODE_BREATHING;
|
||||
Breathing.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
|
||||
if(controller->is_per_led_keyboard) Breathing.flags |= MODE_FLAG_HAS_RANDOM_COLOR;
|
||||
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 | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
|
||||
Ripple.speed_min = AURA_KEYBOARD_SPEED_MIN;
|
||||
Ripple.speed_max = AURA_KEYBOARD_SPEED_MAX;
|
||||
Ripple.speed = AURA_KEYBOARD_SPEED_DEFAULT;
|
||||
Ripple.brightness_min = AURA_KEYBOARD_BRIGHTNESS_MIN;
|
||||
Ripple.brightness_max = AURA_KEYBOARD_BRIGHTNESS_MAX;
|
||||
Ripple.brightness = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
|
||||
Ripple.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Ripple.colors_min = 1;
|
||||
Ripple.colors_max = 8;
|
||||
Ripple.colors.resize(7);
|
||||
modes.push_back(Ripple);
|
||||
|
||||
Breathing.speed_min = AURA_KEYBOARD_SPEED_MIN;
|
||||
Breathing.speed_max = AURA_KEYBOARD_SPEED_MAX;
|
||||
Breathing.speed = AURA_KEYBOARD_SPEED_DEFAULT;
|
||||
Breathing.brightness_min = AURA_KEYBOARD_BRIGHTNESS_MIN;
|
||||
Breathing.brightness_max = AURA_KEYBOARD_BRIGHTNESS_MAX;
|
||||
Breathing.brightness = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
|
||||
Breathing.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Breathing.colors_min = 1;
|
||||
Breathing.colors_max = 2;
|
||||
Breathing.colors.resize(1);
|
||||
modes.push_back(Breathing);
|
||||
mode 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 | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
|
||||
Reactive.speed_min = AURA_KEYBOARD_SPEED_MIN;
|
||||
Reactive.speed_max = AURA_KEYBOARD_SPEED_MAX;
|
||||
Reactive.speed = AURA_KEYBOARD_SPEED_DEFAULT;
|
||||
Reactive.brightness_min = AURA_KEYBOARD_BRIGHTNESS_MIN;
|
||||
Reactive.brightness_max = AURA_KEYBOARD_BRIGHTNESS_MAX;
|
||||
Reactive.brightness = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
|
||||
Reactive.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Reactive.colors_min = 1;
|
||||
Reactive.colors_max = 2;
|
||||
Reactive.colors.resize(1);
|
||||
modes.push_back(Reactive);
|
||||
|
||||
mode Color_Cycle;
|
||||
Color_Cycle.name = "Spectrum Cycle";
|
||||
Color_Cycle.value = AURA_KEYBOARD_MODE_COLOR_CYCLE;
|
||||
Color_Cycle.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
|
||||
Color_Cycle.speed_min = AURA_KEYBOARD_SPEED_MIN;
|
||||
Color_Cycle.speed_max = AURA_KEYBOARD_SPEED_MAX;
|
||||
Color_Cycle.speed = AURA_KEYBOARD_SPEED_DEFAULT;
|
||||
Color_Cycle.brightness_min = AURA_KEYBOARD_BRIGHTNESS_MIN;
|
||||
Color_Cycle.brightness_max = AURA_KEYBOARD_BRIGHTNESS_MAX;
|
||||
Color_Cycle.brightness = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
|
||||
Color_Cycle.color_mode = MODE_COLORS_NONE;
|
||||
modes.push_back(Color_Cycle);
|
||||
mode 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 | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
|
||||
Starry_Night.speed_min = AURA_KEYBOARD_SPEED_MIN;
|
||||
Starry_Night.speed_max = AURA_KEYBOARD_SPEED_MAX;
|
||||
Starry_Night.speed = AURA_KEYBOARD_SPEED_DEFAULT;
|
||||
Starry_Night.brightness_min = AURA_KEYBOARD_BRIGHTNESS_MIN;
|
||||
Starry_Night.brightness_max = AURA_KEYBOARD_BRIGHTNESS_MAX;
|
||||
Starry_Night.brightness = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
|
||||
Starry_Night.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Starry_Night.colors_min = 1;
|
||||
Starry_Night.colors_max = 3;
|
||||
Starry_Night.colors.resize(1);
|
||||
modes.push_back(Starry_Night);
|
||||
|
||||
mode Wave;
|
||||
Wave.name = "Rainbow Wave";
|
||||
Wave.value = AURA_KEYBOARD_MODE_WAVE;
|
||||
Wave.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_DIRECTION_HV | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
|
||||
if(controller->is_per_led_keyboard) Wave.flags |= MODE_FLAG_HAS_DIRECTION_UD;
|
||||
|
||||
Wave.speed_min = AURA_KEYBOARD_SPEED_MIN;
|
||||
Wave.speed_max = AURA_KEYBOARD_SPEED_MAX;
|
||||
Wave.speed = AURA_KEYBOARD_SPEED_DEFAULT;
|
||||
Wave.brightness_min = AURA_KEYBOARD_BRIGHTNESS_MIN;
|
||||
Wave.brightness_max = AURA_KEYBOARD_BRIGHTNESS_MAX;
|
||||
Wave.brightness = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
|
||||
Wave.direction = MODE_DIRECTION_LEFT;
|
||||
Wave.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
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 | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
|
||||
Quicksand.direction = MODE_DIRECTION_DOWN;
|
||||
Quicksand.speed_min = AURA_KEYBOARD_SPEED_MIN;
|
||||
Quicksand.speed_max = AURA_KEYBOARD_SPEED_MAX;
|
||||
Quicksand.speed = AURA_KEYBOARD_SPEED_DEFAULT;
|
||||
Quicksand.brightness_min = AURA_KEYBOARD_BRIGHTNESS_MIN;
|
||||
Quicksand.brightness_max = AURA_KEYBOARD_BRIGHTNESS_MAX;
|
||||
Quicksand.brightness = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
|
||||
Quicksand.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Quicksand.colors_min = 6;
|
||||
Quicksand.colors_max = 6;
|
||||
Quicksand.colors.resize(6);
|
||||
modes.push_back(Quicksand);
|
||||
|
||||
if(!controller->is_per_led_keyboard)
|
||||
{
|
||||
Wave.colors_min = 5;
|
||||
Wave.colors_max = 5;
|
||||
}
|
||||
else
|
||||
{
|
||||
Wave.colors_min = 1;
|
||||
Wave.colors_max = 7;
|
||||
}
|
||||
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 | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
|
||||
Current.speed_min = AURA_KEYBOARD_SPEED_MIN;
|
||||
Current.speed_max = AURA_KEYBOARD_SPEED_MAX;
|
||||
Current.speed = AURA_KEYBOARD_SPEED_DEFAULT;
|
||||
Current.brightness_min = AURA_KEYBOARD_BRIGHTNESS_MIN;
|
||||
Current.brightness_max = AURA_KEYBOARD_BRIGHTNESS_MAX;
|
||||
Current.brightness = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
|
||||
Current.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Current.colors_min = 1;
|
||||
Current.colors_max = 3;
|
||||
Current.colors.resize(1);
|
||||
modes.push_back(Current);
|
||||
|
||||
Wave.colors.resize(Wave.colors_max);
|
||||
modes.push_back(Wave);
|
||||
|
||||
if(controller->is_per_led_keyboard)
|
||||
{
|
||||
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 | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
|
||||
Reactive.speed_min = AURA_KEYBOARD_SPEED_MIN;
|
||||
Reactive.speed_max = AURA_KEYBOARD_SPEED_MAX;
|
||||
Reactive.speed = AURA_KEYBOARD_SPEED_DEFAULT;
|
||||
Reactive.brightness_min = AURA_KEYBOARD_BRIGHTNESS_MIN;
|
||||
Reactive.brightness_max = AURA_KEYBOARD_BRIGHTNESS_MAX;
|
||||
Reactive.brightness = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
|
||||
Reactive.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Reactive.colors_min = 1;
|
||||
Reactive.colors_max = 2;
|
||||
Reactive.colors.resize(1);
|
||||
modes.push_back(Reactive);
|
||||
|
||||
mode 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 | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
|
||||
Ripple.speed_min = AURA_KEYBOARD_SPEED_MIN;
|
||||
Ripple.speed_max = AURA_KEYBOARD_SPEED_MAX;
|
||||
Ripple.speed = AURA_KEYBOARD_SPEED_DEFAULT;
|
||||
Ripple.brightness_min = AURA_KEYBOARD_BRIGHTNESS_MIN;
|
||||
Ripple.brightness_max = AURA_KEYBOARD_BRIGHTNESS_MAX;
|
||||
Ripple.brightness = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
|
||||
Ripple.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Ripple.colors_min = 1;
|
||||
Ripple.colors_max = 8;
|
||||
Ripple.colors.resize(7);
|
||||
modes.push_back(Ripple);
|
||||
|
||||
mode 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 | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
|
||||
Starry_Night.speed_min = AURA_KEYBOARD_SPEED_MIN;
|
||||
Starry_Night.speed_max = AURA_KEYBOARD_SPEED_MAX;
|
||||
Starry_Night.speed = AURA_KEYBOARD_SPEED_DEFAULT;
|
||||
Starry_Night.brightness_min = AURA_KEYBOARD_BRIGHTNESS_MIN;
|
||||
Starry_Night.brightness_max = AURA_KEYBOARD_BRIGHTNESS_MAX;
|
||||
Starry_Night.brightness = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
|
||||
Starry_Night.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Starry_Night.colors_min = 1;
|
||||
Starry_Night.colors_max = 3;
|
||||
Starry_Night.colors.resize(1);
|
||||
modes.push_back(Starry_Night);
|
||||
|
||||
mode Quicksand;
|
||||
Quicksand.name = "Quicksand";
|
||||
Quicksand.value = AURA_KEYBOARD_MODE_QUICKSAND;
|
||||
Quicksand.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_UD | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
|
||||
Quicksand.direction = MODE_DIRECTION_DOWN;
|
||||
Quicksand.speed_min = AURA_KEYBOARD_SPEED_MIN;
|
||||
Quicksand.speed_max = AURA_KEYBOARD_SPEED_MAX;
|
||||
Quicksand.speed = AURA_KEYBOARD_SPEED_DEFAULT;
|
||||
Quicksand.brightness_min = AURA_KEYBOARD_BRIGHTNESS_MIN;
|
||||
Quicksand.brightness_max = AURA_KEYBOARD_BRIGHTNESS_MAX;
|
||||
Quicksand.brightness = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
|
||||
Quicksand.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Quicksand.colors_min = 6;
|
||||
Quicksand.colors_max = 6;
|
||||
Quicksand.colors.resize(6);
|
||||
modes.push_back(Quicksand);
|
||||
|
||||
mode Current;
|
||||
Current.name = "Current";
|
||||
Current.value = AURA_KEYBOARD_MODE_CURRENT;
|
||||
Current.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
|
||||
Current.speed_min = AURA_KEYBOARD_SPEED_MIN;
|
||||
Current.speed_max = AURA_KEYBOARD_SPEED_MAX;
|
||||
Current.speed = AURA_KEYBOARD_SPEED_DEFAULT;
|
||||
Current.brightness_min = AURA_KEYBOARD_BRIGHTNESS_MIN;
|
||||
Current.brightness_max = AURA_KEYBOARD_BRIGHTNESS_MAX;
|
||||
Current.brightness = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
|
||||
Current.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Current.colors_min = 1;
|
||||
Current.colors_max = 3;
|
||||
Current.colors.resize(1);
|
||||
modes.push_back(Current);
|
||||
|
||||
mode Rain_Drop;
|
||||
Rain_Drop.name = "Rain Drop";
|
||||
Rain_Drop.value = AURA_KEYBOARD_MODE_RAIN_DROP;
|
||||
Rain_Drop.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
|
||||
Rain_Drop.speed_min = AURA_KEYBOARD_SPEED_MIN;
|
||||
Rain_Drop.speed_max = AURA_KEYBOARD_SPEED_MAX;
|
||||
Rain_Drop.speed = AURA_KEYBOARD_SPEED_DEFAULT;
|
||||
Rain_Drop.brightness_min = AURA_KEYBOARD_BRIGHTNESS_MIN;
|
||||
Rain_Drop.brightness_max = AURA_KEYBOARD_BRIGHTNESS_MAX;
|
||||
Rain_Drop.brightness = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
|
||||
Rain_Drop.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Rain_Drop.colors_min = 1;
|
||||
Rain_Drop.colors_max = 3;
|
||||
Rain_Drop.colors.resize(1);
|
||||
modes.push_back(Rain_Drop);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
|
||||
name = "ASUS ROG Claymore";
|
||||
vendor = "ASUS";
|
||||
type = DEVICE_TYPE_KEYBOARD;
|
||||
description = "ASUS Aura Keyboard Device";
|
||||
version = controller->GetVersion();
|
||||
location = controller->GetDeviceLocation();
|
||||
serial = controller->GetSerialString();
|
||||
|
||||
mode Direct;
|
||||
Direct.name = "Direct";
|
||||
Direct.value = AURA_KEYBOARD_MODE_DIRECT;
|
||||
Direct.flags = MODE_FLAG_HAS_PER_LED_COLOR;
|
||||
Direct.color_mode = MODE_COLORS_PER_LED;
|
||||
modes.push_back(Direct);
|
||||
|
||||
mode Static;
|
||||
Static.name = "Static";
|
||||
Static.value = AURA_KEYBOARD_MODE_STATIC;
|
||||
Static.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
|
||||
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_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
|
||||
Breathing.speed_min = AURA_CLAYMORE_SPEED_MIN;
|
||||
Breathing.speed_max = AURA_CLAYMORE_SPEED_MAX;
|
||||
Breathing.speed = AURA_CLAYMORE_SPEED_DEFAULT_BREATHING;
|
||||
Breathing.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Breathing.colors_min = 1;
|
||||
Breathing.colors_max = 2;
|
||||
Breathing.colors.resize(2);
|
||||
modes.push_back(Breathing);
|
||||
|
||||
mode Color_Cycle;
|
||||
Color_Cycle.name = "Spectrum Cycle";
|
||||
Color_Cycle.value = AURA_KEYBOARD_MODE_COLOR_CYCLE;
|
||||
Color_Cycle.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
|
||||
Color_Cycle.speed_min = AURA_CLAYMORE_SPEED_MIN;
|
||||
Color_Cycle.speed_max = AURA_CLAYMORE_SPEED_MAX;
|
||||
Color_Cycle.speed = AURA_CLAYMORE_SPEED_DEFAULT_COLOR_CYCLE;
|
||||
Color_Cycle.color_mode = MODE_COLORS_NONE;
|
||||
modes.push_back(Color_Cycle);
|
||||
|
||||
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 | MODE_FLAG_AUTOMATIC_SAVE;
|
||||
Reactive.speed_min = AURA_CLAYMORE_SPEED_MIN;
|
||||
Reactive.speed_max = AURA_CLAYMORE_SPEED_MAX;
|
||||
Reactive.speed = AURA_CLAYMORE_SPEED_DEFAULT_REACTIVE;
|
||||
Reactive.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Reactive.colors_min = 1;
|
||||
Reactive.colors_max = 2;
|
||||
Reactive.colors.resize(2);
|
||||
modes.push_back(Reactive);
|
||||
|
||||
mode Wave;
|
||||
Wave.name = "Rainbow Wave";
|
||||
Wave.value = AURA_KEYBOARD_MODE_WAVE;
|
||||
Wave.flags = MODE_COLORS_NONE | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_DIRECTION_UD | MODE_FLAG_AUTOMATIC_SAVE;
|
||||
Wave.speed_min = AURA_CLAYMORE_SPEED_MIN;
|
||||
Wave.speed_max = AURA_CLAYMORE_SPEED_MAX;
|
||||
Wave.speed = AURA_CLAYMORE_SPEED_DEFAULT_WAVE;
|
||||
Wave.direction = MODE_DIRECTION_LEFT;
|
||||
Wave.color_mode = MODE_COLORS_NONE;
|
||||
modes.push_back(Wave);
|
||||
|
||||
mode Color_Wave;
|
||||
Color_Wave.name = "Color Wave";
|
||||
Color_Wave.value = AURA_KEYBOARD_MODE_WAVE;
|
||||
Color_Wave.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_DIRECTION_UD | MODE_FLAG_AUTOMATIC_SAVE;
|
||||
Color_Wave.speed_min = AURA_CLAYMORE_SPEED_MIN;
|
||||
Color_Wave.speed_max = AURA_CLAYMORE_SPEED_MAX;
|
||||
Color_Wave.speed = AURA_CLAYMORE_SPEED_DEFAULT_WAVE;
|
||||
Color_Wave.direction = MODE_DIRECTION_LEFT;
|
||||
Color_Wave.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Color_Wave.colors_min = 1;
|
||||
Color_Wave.colors_max = 2;
|
||||
Color_Wave.colors.resize(2);
|
||||
modes.push_back(Color_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 | MODE_FLAG_AUTOMATIC_SAVE;
|
||||
Ripple.speed_min = AURA_CLAYMORE_SPEED_MIN;
|
||||
Ripple.speed_max = AURA_CLAYMORE_SPEED_MAX;
|
||||
Ripple.speed = AURA_CLAYMORE_SPEED_DEFAULT_RIPPLE;
|
||||
Ripple.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Ripple.colors_min = 1;
|
||||
Ripple.colors_max = 2;
|
||||
Ripple.colors.resize(2);
|
||||
modes.push_back(Ripple);
|
||||
|
||||
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 | MODE_FLAG_AUTOMATIC_SAVE;
|
||||
Starry_Night.speed_min = AURA_CLAYMORE_SPEED_MIN;
|
||||
Starry_Night.speed_max = AURA_CLAYMORE_SPEED_MAX;
|
||||
Starry_Night.speed = AURA_CLAYMORE_SPEED_DEFAULT_STARRY_NIGHT;
|
||||
Starry_Night.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Starry_Night.colors_min = 1;
|
||||
Starry_Night.colors_max = 2;
|
||||
Starry_Night.colors.resize(2);
|
||||
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_AUTOMATIC_SAVE;
|
||||
Quicksand.direction = MODE_DIRECTION_DOWN;
|
||||
Quicksand.speed_min = AURA_CLAYMORE_SPEED_MIN;
|
||||
Quicksand.speed_max = AURA_CLAYMORE_SPEED_MAX;
|
||||
Quicksand.speed = AURA_CLAYMORE_SPEED_DEFAULT_QUICKSAND;
|
||||
Quicksand.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Quicksand.colors_min = 6;
|
||||
Quicksand.colors_max = 6;
|
||||
Quicksand.colors.resize(6);
|
||||
modes.push_back(Quicksand);
|
||||
}
|
||||
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 | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
|
||||
Rain_Drop.speed_min = AURA_KEYBOARD_SPEED_MIN;
|
||||
Rain_Drop.speed_max = AURA_KEYBOARD_SPEED_MAX;
|
||||
Rain_Drop.speed = AURA_KEYBOARD_SPEED_DEFAULT;
|
||||
Rain_Drop.brightness_min = AURA_KEYBOARD_BRIGHTNESS_MIN;
|
||||
Rain_Drop.brightness_max = AURA_KEYBOARD_BRIGHTNESS_MAX;
|
||||
Rain_Drop.brightness = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
|
||||
Rain_Drop.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Rain_Drop.colors_min = 1;
|
||||
Rain_Drop.colors_max = 3;
|
||||
Rain_Drop.colors.resize(1);
|
||||
modes.push_back(Rain_Drop);
|
||||
|
||||
SetupZones();
|
||||
}
|
||||
@@ -393,56 +207,10 @@ RGBController_AuraTUFKeyboard::~RGBController_AuraTUFKeyboard()
|
||||
|
||||
void RGBController_AuraTUFKeyboard::SetupZones()
|
||||
{
|
||||
std::map<int,layout_info> * keyboard_ptr;
|
||||
int layout = controller->GetLayout();
|
||||
|
||||
switch(pid)
|
||||
if(AsusTUFK7Layouts.find(layout % 100) == AsusTUFK7Layouts.end())
|
||||
{
|
||||
case AURA_TUF_K3_GAMING_PID:
|
||||
case AURA_TUF_K7_GAMING_PID:
|
||||
keyboard_ptr = &AsusTUFK7Layouts;
|
||||
break;
|
||||
case AURA_ROG_STRIX_FLARE_II_ANIMATE_PID:
|
||||
keyboard_ptr = &AsusROGStrixFlareIILayouts;
|
||||
break;
|
||||
case AURA_ROG_FALCHION_WIRED_PID:
|
||||
case AURA_ROG_FALCHION_WIRELESS_PID:
|
||||
keyboard_ptr = &AsusFalchionLayouts;
|
||||
break;
|
||||
case AURA_ROG_CLAYMORE_PID:
|
||||
unsigned char numpad;
|
||||
numpad = controller->GetNumpadLocation();
|
||||
switch(numpad)
|
||||
{
|
||||
case 0:
|
||||
keyboard_ptr = &AsusClaymoreNoNumpadLayouts;
|
||||
break;
|
||||
case 2:
|
||||
keyboard_ptr = &AsusClaymoreNumpadRightLayouts;
|
||||
break;
|
||||
case 3:
|
||||
keyboard_ptr = &AsusClaymoreNumpadLeftLayouts;
|
||||
break;
|
||||
default:
|
||||
keyboard_ptr = &AsusClaymoreNoNumpadLayouts;
|
||||
}
|
||||
break;
|
||||
case AURA_TUF_K1_GAMING_PID:
|
||||
case AURA_TUF_K5_GAMING_PID:
|
||||
keyboard_ptr = &AsusTufK1Layouts;
|
||||
break;
|
||||
default:
|
||||
keyboard_ptr = &AsusTUFK7Layouts;
|
||||
}
|
||||
|
||||
std::map<int,layout_info> & keyboard = *keyboard_ptr;
|
||||
|
||||
unsigned char layout = controller->GetLayout();
|
||||
|
||||
if(keyboard.find(layout % 100) == keyboard.end())
|
||||
{
|
||||
/*---------------------------------------------------------*\
|
||||
| If Layout not found, take uk or us |
|
||||
\*---------------------------------------------------------*/
|
||||
layout = std::floor(layout/100) == 2 ? ASUS_TUF_K7_LAYOUT_UK : ASUS_TUF_K7_LAYOUT_US;
|
||||
}
|
||||
else
|
||||
@@ -450,32 +218,33 @@ void RGBController_AuraTUFKeyboard::SetupZones()
|
||||
layout = layout % 100;
|
||||
}
|
||||
|
||||
zone keyboard_zone;
|
||||
keyboard_zone.name = "Keyboard";
|
||||
keyboard_zone.type = ZONE_TYPE_MATRIX;
|
||||
keyboard_zone.leds_min = keyboard[layout].size;
|
||||
keyboard_zone.leds_max = keyboard[layout].size;
|
||||
keyboard_zone.leds_count = keyboard[layout].size;
|
||||
keyboard_zone.matrix_map = new matrix_map_type;
|
||||
keyboard_zone.matrix_map->height = keyboard[layout].rows;
|
||||
keyboard_zone.matrix_map->width = keyboard[layout].cols;
|
||||
keyboard_zone.matrix_map->map = keyboard[layout].matrix_map;
|
||||
zones.push_back(keyboard_zone);
|
||||
unsigned int total_led_count = 0;
|
||||
|
||||
for(int led_id = 0; led_id < keyboard[layout].size; led_id++)
|
||||
int zone_size = 138;
|
||||
|
||||
zone keyboard;
|
||||
keyboard.name = ZONE_EN_KEYBOARD;
|
||||
keyboard.type = ZONE_TYPE_MATRIX;
|
||||
keyboard.leds_min = zone_size;
|
||||
keyboard.leds_max = zone_size;
|
||||
keyboard.leds_count = zone_size;
|
||||
keyboard.matrix_map = new matrix_map_type;
|
||||
keyboard.matrix_map->height = 6;
|
||||
keyboard.matrix_map->width = 23;
|
||||
keyboard.matrix_map->map = AsusTUFK7Layouts[layout].matrix_map;
|
||||
zones.push_back(keyboard);
|
||||
|
||||
total_led_count += zone_size;
|
||||
|
||||
|
||||
for(unsigned int led_idx = 0; led_idx < total_led_count; led_idx++)
|
||||
{
|
||||
led new_led;
|
||||
new_led.name = keyboard[layout].led_names[led_id].name;
|
||||
new_led.value = keyboard[layout].led_names[led_id].id;
|
||||
new_led.name = AsusTUFK7Layouts[layout].led_names[led_idx];
|
||||
leds.push_back(new_led);
|
||||
}
|
||||
|
||||
SetupColors();
|
||||
|
||||
/*---------------------------------------------------------*\
|
||||
| sends the init packet for the default mode (direct) |
|
||||
\*---------------------------------------------------------*/
|
||||
DeviceUpdateMode();
|
||||
}
|
||||
|
||||
void RGBController_AuraTUFKeyboard::ResizeZone(int /*zone*/, int /*new_size*/)
|
||||
@@ -485,133 +254,86 @@ void RGBController_AuraTUFKeyboard::ResizeZone(int /*zone*/, int /*new_size*/)
|
||||
|
||||
void RGBController_AuraTUFKeyboard::DeviceUpdateLEDs()
|
||||
{
|
||||
std::vector<led_color> led_color_list = {};
|
||||
|
||||
for(size_t i = 0; i < colors.size(); i++)
|
||||
{
|
||||
led_color_list.push_back({ leds[i].value, colors[i] });
|
||||
}
|
||||
|
||||
controller->UpdateLeds(led_color_list);
|
||||
DeviceUpdateMode();
|
||||
}
|
||||
|
||||
void RGBController_AuraTUFKeyboard::UpdateZoneLEDs(int /*zone*/)
|
||||
{
|
||||
DeviceUpdateLEDs();
|
||||
controller->UpdateLeds(colors);
|
||||
}
|
||||
|
||||
void RGBController_AuraTUFKeyboard::UpdateSingleLED(int led)
|
||||
{
|
||||
if(!controller->is_per_led_keyboard)
|
||||
{
|
||||
return DeviceUpdateLEDs();
|
||||
}
|
||||
|
||||
unsigned char red = RGBGetRValue(colors[led]);
|
||||
unsigned char green = RGBGetGValue(colors[led]);
|
||||
unsigned char blue = RGBGetBValue(colors[led]);
|
||||
|
||||
controller->UpdateSingleLed(leds[led].value, red, green, blue);
|
||||
controller->UpdateSingleLed(led, red, green, blue);
|
||||
}
|
||||
|
||||
static const uint8_t direction_map[2][6] =
|
||||
{
|
||||
{ 4, 0, 6, 2, 8, 1 }, // Default directions Left, Right, Up, Down, Horizontal, Vertical
|
||||
{ 0, 4, 6, 2, 0xFF, 0xFF }, // AURA_ROG_CLAYMORE directions Left, Right, Up, Down
|
||||
};
|
||||
|
||||
void RGBController_AuraTUFKeyboard::DeviceUpdateMode()
|
||||
{
|
||||
if(pid == AURA_ROG_CLAYMORE_PID)
|
||||
{
|
||||
controller->AllowRemoteControl(1);
|
||||
}
|
||||
|
||||
unsigned char color_mode = 0;
|
||||
unsigned char direction = 0;
|
||||
unsigned char brightness = 0;
|
||||
unsigned char color_mode;
|
||||
std::vector<RGBColor> mode_colors;
|
||||
|
||||
if(modes[active_mode].value == AURA_KEYBOARD_MODE_DIRECT)
|
||||
{
|
||||
if(pid == AURA_ROG_CLAYMORE_PID) controller->AllowRemoteControl(3);
|
||||
return;
|
||||
};
|
||||
|
||||
if(pid != AURA_ROG_CLAYMORE_PID)
|
||||
{
|
||||
brightness = modes[active_mode].brightness * 25;
|
||||
|
||||
switch(modes[active_mode].value)
|
||||
{
|
||||
case AURA_KEYBOARD_MODE_BREATHING:
|
||||
case AURA_KEYBOARD_MODE_REACTIVE:
|
||||
case AURA_KEYBOARD_MODE_STARRY_NIGHT:
|
||||
case AURA_KEYBOARD_MODE_CURRENT:
|
||||
case AURA_KEYBOARD_MODE_RAIN_DROP:
|
||||
if(!controller->is_per_led_keyboard && modes[active_mode].colors.size() > 1)
|
||||
{
|
||||
color_mode = 1;
|
||||
break;
|
||||
}
|
||||
|
||||
bool color_is_black = (modes[active_mode].colors.size() > 1 && modes[active_mode].colors[1] == 000);
|
||||
|
||||
if(modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC && !color_is_black)
|
||||
{
|
||||
color_mode = 16;
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
if(modes[active_mode].color_mode == MODE_COLORS_RANDOM)
|
||||
{
|
||||
color_mode = 1;
|
||||
}
|
||||
|
||||
if(modes[active_mode].value == AURA_KEYBOARD_MODE_WAVE || modes[active_mode].value == AURA_KEYBOARD_MODE_QUICKSAND)
|
||||
{
|
||||
/*----------------------------------------------------------*\
|
||||
| converting openrgb direction value to keyboard directions |
|
||||
\*----------------------------------------------------------*/
|
||||
direction = direction_map[0][modes[active_mode].direction];
|
||||
}
|
||||
controller->UpdateLeds(colors);
|
||||
}
|
||||
else
|
||||
{
|
||||
if(modes[active_mode].color_mode == MODE_COLORS_RANDOM)
|
||||
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)
|
||||
{
|
||||
color_mode = 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;
|
||||
}
|
||||
|
||||
if(modes[active_mode].value == AURA_KEYBOARD_MODE_WAVE) {
|
||||
if (modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC) color_mode = 2;
|
||||
int direction = 0;
|
||||
|
||||
/*----------------------------------------------------------*\
|
||||
| converting openrgb direction value to keyboard directions |
|
||||
\*----------------------------------------------------------*/
|
||||
direction = direction_map[1][modes[active_mode].direction];
|
||||
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);
|
||||
|
||||
controller->UpdateDevice(modes[active_mode].value, std::vector<RGBColor>(modes[active_mode].colors), direction, color_mode, modes[active_mode].speed, brightness);
|
||||
|
||||
if(pid == AURA_ROG_CLAYMORE_PID)
|
||||
{
|
||||
controller->UpdateMode(modes[active_mode].value);
|
||||
controller->SaveMode();
|
||||
controller->AllowRemoteControl(0);
|
||||
controller->UpdateDevice(modes[active_mode].value, mode_colors, direction, color_mode, (15 - modes[active_mode].speed), modes[active_mode].brightness * 25);
|
||||
}
|
||||
}
|
||||
|
||||
void RGBController_AuraTUFKeyboard::DeviceSaveMode()
|
||||
{
|
||||
/*----------------------------------------------------------*\
|
||||
| not available for Claymore |
|
||||
\*----------------------------------------------------------*/
|
||||
if(pid != AURA_ROG_CLAYMORE_PID)
|
||||
{
|
||||
DeviceUpdateMode();
|
||||
controller->SaveMode();
|
||||
}
|
||||
controller->ClearResponses();
|
||||
DeviceUpdateMode();
|
||||
controller->AwaitResponse();
|
||||
controller->SaveMode();
|
||||
}
|
||||
|
||||
@@ -13,23 +13,12 @@
|
||||
|
||||
enum
|
||||
{
|
||||
AURA_KEYBOARD_SPEED_MIN = 0,
|
||||
AURA_KEYBOARD_SPEED_MAX = 15,
|
||||
AURA_KEYBOARD_SPEED_DEFAULT = 8,
|
||||
AURA_KEYBOARD_BRIGHTNESS_MIN = 0,
|
||||
AURA_KEYBOARD_BRIGHTNESS_MAX = 4,
|
||||
AURA_KEYBOARD_BRIGHTNESS_DEFAULT = 4,
|
||||
};
|
||||
|
||||
enum
|
||||
{
|
||||
AURA_CLAYMORE_SPEED_MIN = 254,
|
||||
AURA_CLAYMORE_SPEED_MAX = 0,
|
||||
AURA_CLAYMORE_SPEED_DEFAULT_STATIC = 0,
|
||||
AURA_CLAYMORE_SPEED_DEFAULT_BREATHING = 107,
|
||||
AURA_CLAYMORE_SPEED_DEFAULT_COLOR_CYCLE = 121,
|
||||
AURA_CLAYMORE_SPEED_DEFAULT_REACTIVE = 56,
|
||||
AURA_CLAYMORE_SPEED_DEFAULT_WAVE = 50,
|
||||
AURA_CLAYMORE_SPEED_DEFAULT_RIPPLE = 108,
|
||||
AURA_CLAYMORE_SPEED_DEFAULT_STARRY_NIGHT = 54,
|
||||
AURA_CLAYMORE_SPEED_DEFAULT_QUICKSAND = 103
|
||||
AURA_KEYBOARD_BRIGHTNESS_DEFAULT = 4
|
||||
};
|
||||
|
||||
class RGBController_AuraTUFKeyboard : public RGBController
|
||||
@@ -51,5 +40,4 @@ public:
|
||||
|
||||
private:
|
||||
AuraTUFKeyboardController* controller;
|
||||
uint16_t pid;
|
||||
};
|
||||
|
||||
@@ -1,196 +0,0 @@
|
||||
/*-----------------------------------------*\
|
||||
| RGBController_AsusROGAlly.cpp |
|
||||
| |
|
||||
| Generic RGB Interface for Asus ROG Ally |
|
||||
| controller driver |
|
||||
| |
|
||||
| Adam Honse (CalcProgrammer1) 6/12/2023 |
|
||||
\*-----------------------------------------*/
|
||||
|
||||
#include "RGBController_AsusROGAlly.h"
|
||||
|
||||
/**------------------------------------------------------------------*\
|
||||
@name Asus ROG Ally
|
||||
@category Gamepad
|
||||
@type USB
|
||||
@save :x:
|
||||
@direct :white_check_mark:
|
||||
@effects :x:
|
||||
@detectors DetectAsusROGAlly
|
||||
@comment
|
||||
\*-------------------------------------------------------------------*/
|
||||
|
||||
RGBController_AsusROGAlly::RGBController_AsusROGAlly(ROGAllyController* controller_ptr)
|
||||
{
|
||||
controller = controller_ptr;
|
||||
|
||||
name = "ASUS ROG Ally";
|
||||
vendor = "ASUS";
|
||||
type = DEVICE_TYPE_GAMEPAD;
|
||||
description = "ASUS ROG Ally Device";
|
||||
version = controller->GetVersion();
|
||||
location = controller->GetDeviceLocation();
|
||||
serial = controller->GetSerialString();
|
||||
|
||||
mode Direct;
|
||||
Direct.name = "Direct";
|
||||
Direct.value = ROG_ALLY_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 = ROG_ALLY_MODE_STATIC;
|
||||
Static.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_MANUAL_SAVE;
|
||||
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 = ROG_ALLY_MODE_BREATHING;
|
||||
Breathing.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_SPEED;
|
||||
Breathing.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Breathing.speed_min = ROG_ALLY_SPEED_MIN;
|
||||
Breathing.speed_max = ROG_ALLY_SPEED_MAX;
|
||||
Breathing.speed = ROG_ALLY_SPEED_MED;
|
||||
Breathing.colors_min = 2;
|
||||
Breathing.colors_max = 2;
|
||||
Breathing.colors.resize(2);
|
||||
modes.push_back(Breathing);
|
||||
|
||||
mode ColorCycle;
|
||||
ColorCycle.name = "Spectrum Cycle";
|
||||
ColorCycle.value = ROG_ALLY_MODE_COLOR_CYCLE;
|
||||
ColorCycle.flags = MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_SPEED;
|
||||
ColorCycle.color_mode = MODE_COLORS_RANDOM;
|
||||
ColorCycle.speed_min = ROG_ALLY_SPEED_MIN;
|
||||
ColorCycle.speed_max = ROG_ALLY_SPEED_MAX;
|
||||
ColorCycle.speed = ROG_ALLY_SPEED_MED;
|
||||
modes.push_back(ColorCycle);
|
||||
|
||||
mode Rainbow;
|
||||
Rainbow.name = "Rainbow Wave";
|
||||
Rainbow.value = ROG_ALLY_MODE_RAINBOW;
|
||||
Rainbow.flags = MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
|
||||
Rainbow.color_mode = MODE_COLORS_RANDOM;
|
||||
Rainbow.speed_min = ROG_ALLY_SPEED_MIN;
|
||||
Rainbow.speed_max = ROG_ALLY_SPEED_MAX;
|
||||
Rainbow.speed = ROG_ALLY_SPEED_MED;
|
||||
modes.push_back(Rainbow);
|
||||
|
||||
mode Strobing;
|
||||
Strobing.name = "Strobing";
|
||||
Strobing.value = ROG_ALLY_MODE_STROBING;
|
||||
Strobing.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_MANUAL_SAVE;
|
||||
Strobing.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Strobing.colors_min = 1;
|
||||
Strobing.colors_max = 1;
|
||||
Strobing.colors.resize(1);
|
||||
modes.push_back(Strobing);
|
||||
|
||||
SetupZones();
|
||||
}
|
||||
|
||||
RGBController_AsusROGAlly::~RGBController_AsusROGAlly()
|
||||
{
|
||||
delete controller;
|
||||
}
|
||||
|
||||
void RGBController_AsusROGAlly::SetupZones()
|
||||
{
|
||||
zone left_stick_zone;
|
||||
|
||||
left_stick_zone.name = "Left Stick";
|
||||
left_stick_zone.type = ZONE_TYPE_SINGLE;
|
||||
left_stick_zone.leds_min = 2;
|
||||
left_stick_zone.leds_max = 2;
|
||||
left_stick_zone.leds_count = 2;
|
||||
left_stick_zone.matrix_map = NULL;
|
||||
|
||||
zones.push_back(left_stick_zone);
|
||||
|
||||
for(unsigned int i = 0; i < 2; i++)
|
||||
{
|
||||
led left_stick_led;
|
||||
|
||||
left_stick_led.name = "Left Stick LED " + std::to_string(i);
|
||||
|
||||
leds.push_back(left_stick_led);
|
||||
}
|
||||
|
||||
zone right_stick_zone;
|
||||
|
||||
right_stick_zone.name = "Right Stick";
|
||||
right_stick_zone.type = ZONE_TYPE_SINGLE;
|
||||
right_stick_zone.leds_min = 2;
|
||||
right_stick_zone.leds_max = 2;
|
||||
right_stick_zone.leds_count = 2;
|
||||
right_stick_zone.matrix_map = NULL;
|
||||
|
||||
zones.push_back(right_stick_zone);
|
||||
|
||||
for(unsigned int i = 0; i < 2; i++)
|
||||
{
|
||||
led right_stick_led;
|
||||
|
||||
right_stick_led.name = "Right Stick LED " + std::to_string(i);
|
||||
|
||||
leds.push_back(right_stick_led);
|
||||
}
|
||||
|
||||
SetupColors();
|
||||
}
|
||||
|
||||
void RGBController_AsusROGAlly::ResizeZone(int /*zone*/, int /*new_size*/)
|
||||
{
|
||||
/*---------------------------------------------------------*\
|
||||
| This device does not support resizing zones |
|
||||
\*---------------------------------------------------------*/
|
||||
}
|
||||
|
||||
void RGBController_AsusROGAlly::DeviceUpdateLEDs()
|
||||
{
|
||||
if(modes[active_mode].value == ROG_ALLY_MODE_DIRECT)
|
||||
{
|
||||
controller->UpdateLeds(std::vector<RGBColor>(colors));
|
||||
}
|
||||
}
|
||||
|
||||
void RGBController_AsusROGAlly::UpdateZoneLEDs(int /*zone*/)
|
||||
{
|
||||
DeviceUpdateLEDs();
|
||||
}
|
||||
|
||||
void RGBController_AsusROGAlly::UpdateSingleLED(int /*led*/)
|
||||
{
|
||||
DeviceUpdateLEDs();
|
||||
}
|
||||
|
||||
void RGBController_AsusROGAlly::DeviceUpdateMode()
|
||||
{
|
||||
if(modes[active_mode].value == ROG_ALLY_MODE_DIRECT)
|
||||
{
|
||||
DeviceUpdateLEDs();
|
||||
}
|
||||
else
|
||||
{
|
||||
unsigned int rog_ally_direction = ROG_ALLY_DIRECTION_RIGHT;
|
||||
|
||||
if((modes[active_mode].flags & MODE_FLAG_HAS_DIRECTION_LR) && (modes[active_mode].direction == MODE_DIRECTION_LEFT))
|
||||
{
|
||||
rog_ally_direction = ROG_ALLY_DIRECTION_LEFT;
|
||||
}
|
||||
|
||||
controller->UpdateDevice(modes[active_mode].value, modes[active_mode].colors, modes[active_mode].speed, modes[active_mode].brightness, rog_ally_direction);
|
||||
}
|
||||
}
|
||||
|
||||
void RGBController_AsusROGAlly::DeviceSaveMode()
|
||||
{
|
||||
DeviceUpdateMode();
|
||||
controller->SaveMode();
|
||||
}
|
||||
@@ -1,34 +0,0 @@
|
||||
/*-----------------------------------------*\
|
||||
| RGBController_AsusROGAlly.cpp |
|
||||
| |
|
||||
| Generic RGB Interface for Asus ROG Ally |
|
||||
| controller driver |
|
||||
| |
|
||||
| Adam Honse (CalcProgrammer1) 6/12/2023 |
|
||||
\*-----------------------------------------*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include "RGBController.h"
|
||||
#include "AsusROGAllyController.h"
|
||||
|
||||
class RGBController_AsusROGAlly : public RGBController
|
||||
{
|
||||
public:
|
||||
RGBController_AsusROGAlly(ROGAllyController* controller_ptr);
|
||||
~RGBController_AsusROGAlly();
|
||||
|
||||
void SetupZones();
|
||||
|
||||
void ResizeZone(int zone, int new_size);
|
||||
|
||||
void DeviceUpdateLEDs();
|
||||
void UpdateZoneLEDs(int zone);
|
||||
void UpdateSingleLED(int led);
|
||||
|
||||
void DeviceUpdateMode();
|
||||
void DeviceSaveMode();
|
||||
|
||||
private:
|
||||
ROGAllyController* controller;
|
||||
};
|
||||
@@ -23,7 +23,7 @@ ROGStrixLC_Controller::ROGStrixLC_Controller(hid_device* dev_handle, const char*
|
||||
|
||||
ROGStrixLC_Controller::~ROGStrixLC_Controller()
|
||||
{
|
||||
// Device will close at AuraUSBController destructor
|
||||
hid_close(dev);
|
||||
}
|
||||
|
||||
std::string ROGStrixLC_Controller::GetLocation()
|
||||
|
||||
@@ -1,198 +0,0 @@
|
||||
/*-----------------------------------------*\
|
||||
| AsusCerberusKeyboardController.cpp |
|
||||
| |
|
||||
| Driver for ASUS Cerberus USB lighting |
|
||||
| controller |
|
||||
| |
|
||||
| Mola19 05/28/2022 |
|
||||
\*-----------------------------------------*/
|
||||
|
||||
#include "AsusCerberusKeyboardController.h"
|
||||
|
||||
#include <cstring>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
#include <math.h>
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <cmath>
|
||||
|
||||
#define ASUS_CERBERUS_KB_PACKET_SIZE 8
|
||||
|
||||
AsusCerberusKeyboardController::AsusCerberusKeyboardController(hid_device* dev_handle, const char* path, unsigned short rev_version)
|
||||
{
|
||||
dev = dev_handle;
|
||||
location = path;
|
||||
version = rev_version;
|
||||
}
|
||||
|
||||
AsusCerberusKeyboardController::~AsusCerberusKeyboardController()
|
||||
{
|
||||
hid_close(dev);
|
||||
}
|
||||
|
||||
std::string AsusCerberusKeyboardController::GetDeviceLocation()
|
||||
{
|
||||
return("HID: " + location);
|
||||
}
|
||||
|
||||
std::string AsusCerberusKeyboardController::GetSerialString()
|
||||
{
|
||||
wchar_t serial_string[128];
|
||||
int ret = hid_get_serial_number_string(dev, serial_string, 128);
|
||||
|
||||
if(ret != 0)
|
||||
{
|
||||
return("");
|
||||
}
|
||||
|
||||
std::wstring return_wstring = serial_string;
|
||||
std::string return_string(return_wstring.begin(), return_wstring.end());
|
||||
|
||||
return(return_string);
|
||||
}
|
||||
|
||||
std::string AsusCerberusKeyboardController::GetVersion()
|
||||
{
|
||||
char versionstr[5];
|
||||
snprintf(versionstr, 5, "%X", version);
|
||||
return(std::string(versionstr));
|
||||
}
|
||||
|
||||
void AsusCerberusKeyboardController::SetProfile
|
||||
(
|
||||
uint8_t profile
|
||||
)
|
||||
{
|
||||
uint8_t usb_buf[ASUS_CERBERUS_KB_PACKET_SIZE];
|
||||
|
||||
memset(usb_buf, 0x00, sizeof(usb_buf));
|
||||
|
||||
usb_buf[0x00] = 0x07;
|
||||
usb_buf[0x01] = 0x03;
|
||||
usb_buf[0x02] = profile;
|
||||
|
||||
hid_send_feature_report(dev, usb_buf, ASUS_CERBERUS_KB_PACKET_SIZE);
|
||||
}
|
||||
|
||||
void AsusCerberusKeyboardController::SetPerLEDColor
|
||||
(
|
||||
uint8_t key,
|
||||
uint8_t red,
|
||||
uint8_t green,
|
||||
uint8_t blue
|
||||
)
|
||||
{
|
||||
uint8_t profile = 1;
|
||||
|
||||
uint8_t usb_buf[ASUS_CERBERUS_KB_PACKET_SIZE];
|
||||
|
||||
memset(usb_buf, 0x00, sizeof(usb_buf));
|
||||
|
||||
usb_buf[0x00] = 0x07;
|
||||
usb_buf[0x01] = 0x0D;
|
||||
usb_buf[0x02] = profile;
|
||||
usb_buf[0x03] = key;
|
||||
usb_buf[0x04] = red;
|
||||
usb_buf[0x05] = green;
|
||||
usb_buf[0x06] = blue;
|
||||
|
||||
hid_send_feature_report(dev, usb_buf, ASUS_CERBERUS_KB_PACKET_SIZE);
|
||||
}
|
||||
|
||||
void AsusCerberusKeyboardController::SendPerLEDColorEnd()
|
||||
{
|
||||
SetPerLEDColor(255, 0, 0, 0);
|
||||
}
|
||||
|
||||
void AsusCerberusKeyboardController::SetPerLEDMode
|
||||
(
|
||||
uint8_t mode
|
||||
)
|
||||
{
|
||||
/*------------------------------------------------------------------------------------------------------*\
|
||||
| this device has 6 different profiles, but there is no way to fetch them from the device, |
|
||||
| hence this device always sends to the first profile until a better solution is implemented in OpenRGB |
|
||||
\*------------------------------------------------------------------------------------------------------*/
|
||||
uint8_t profile = 1;
|
||||
|
||||
/*--------------------------------------------------------------------------------*\
|
||||
| 8 booleans per byte, each boolean controls one key |
|
||||
| 0 = static, 1 = breathing |
|
||||
| since openrgb doesn't support per led modes, either all static or all breathing |
|
||||
\*--------------------------------------------------------------------------------*/
|
||||
|
||||
uint8_t modebyte = (mode == 1) ? 0xFF : 0x00;
|
||||
|
||||
for(int i = 0; i < 4; i++)
|
||||
{
|
||||
uint8_t usb_buf[ASUS_CERBERUS_KB_PACKET_SIZE];
|
||||
|
||||
memset(usb_buf, 0x00, sizeof(usb_buf));
|
||||
|
||||
usb_buf[0x00] = 0x07;
|
||||
usb_buf[0x01] = 0x0E;
|
||||
usb_buf[0x02] = profile;
|
||||
usb_buf[0x03] = i;
|
||||
usb_buf[0x04] = modebyte;
|
||||
usb_buf[0x05] = modebyte;
|
||||
usb_buf[0x06] = modebyte;
|
||||
usb_buf[0x07] = modebyte;
|
||||
|
||||
hid_send_feature_report(dev, usb_buf, ASUS_CERBERUS_KB_PACKET_SIZE);
|
||||
}
|
||||
}
|
||||
|
||||
void AsusCerberusKeyboardController::SetMode
|
||||
(
|
||||
uint8_t mode,
|
||||
uint8_t red,
|
||||
uint8_t green,
|
||||
uint8_t blue,
|
||||
uint8_t direction,
|
||||
uint8_t brightness
|
||||
)
|
||||
{
|
||||
/*------------------------------------------------------------------------------------------------------*\
|
||||
| this device has 6 different profiles, but there is no way to fetch them from the device, |
|
||||
| hence this device always sends to the first profile until a better solution is implemented in OpenRGB |
|
||||
\*------------------------------------------------------------------------------------------------------*/
|
||||
uint8_t profile = 1;
|
||||
|
||||
uint8_t usb_buf_1[ASUS_CERBERUS_KB_PACKET_SIZE];
|
||||
|
||||
memset(usb_buf_1, 0x00, sizeof(usb_buf_1));
|
||||
|
||||
usb_buf_1[0x00] = 0x07;
|
||||
usb_buf_1[0x01] = 0x0A;
|
||||
usb_buf_1[0x02] = profile;
|
||||
usb_buf_1[0x03] = mode;
|
||||
usb_buf_1[0x04] = direction;
|
||||
|
||||
hid_send_feature_report(dev, usb_buf_1, ASUS_CERBERUS_KB_PACKET_SIZE);
|
||||
|
||||
uint8_t usb_buf_2[ASUS_CERBERUS_KB_PACKET_SIZE];
|
||||
|
||||
memset(usb_buf_2, 0x00, sizeof(usb_buf_2));
|
||||
|
||||
usb_buf_2[0x00] = 0x07;
|
||||
usb_buf_2[0x01] = 0x0B;
|
||||
usb_buf_2[0x02] = profile;
|
||||
usb_buf_2[0x03] = mode;
|
||||
usb_buf_2[0x04] = red;
|
||||
usb_buf_2[0x05] = green;
|
||||
usb_buf_2[0x06] = blue;
|
||||
|
||||
hid_send_feature_report(dev, usb_buf_2, ASUS_CERBERUS_KB_PACKET_SIZE);
|
||||
|
||||
uint8_t usb_buf_3[ASUS_CERBERUS_KB_PACKET_SIZE];
|
||||
|
||||
memset(usb_buf_3, 0x00, sizeof(usb_buf_3));
|
||||
|
||||
usb_buf_3[0x00] = 0x07;
|
||||
usb_buf_3[0x01] = 0x0C;
|
||||
usb_buf_3[0x02] = profile;
|
||||
usb_buf_3[0x03] = brightness;
|
||||
|
||||
hid_send_feature_report(dev, usb_buf_3, ASUS_CERBERUS_KB_PACKET_SIZE);
|
||||
}
|
||||
@@ -1,51 +0,0 @@
|
||||
/*-----------------------------------------*\
|
||||
| AsusCerberusKeyboardController.h |
|
||||
| |
|
||||
| Definitions and types for ASUS Cerberus |
|
||||
| USB RGB lighting controller |
|
||||
| |
|
||||
| Mola19 03/03/2021 |
|
||||
\*-----------------------------------------*/
|
||||
|
||||
#include "RGBController.h"
|
||||
|
||||
#include <string>
|
||||
#include <vector>
|
||||
#include <hidapi/hidapi.h>
|
||||
|
||||
#pragma once
|
||||
|
||||
enum
|
||||
{
|
||||
CERBERUS_KEYBOARD_MODE_STATIC = 0,
|
||||
CERBERUS_KEYBOARD_MODE_BREATHING = 1,
|
||||
CERBERUS_KEYBOARD_MODE_REACTIVE = 2,
|
||||
CERBERUS_KEYBOARD_MODE_EXPLOSION = 3,
|
||||
CERBERUS_KEYBOARD_MODE_COLOR_CYCLE = 4,
|
||||
CERBERUS_KEYBOARD_MODE_WAVE = 6,
|
||||
CERBERUS_KEYBOARD_MODE_CUSTOM = 7,
|
||||
};
|
||||
|
||||
|
||||
class AsusCerberusKeyboardController
|
||||
{
|
||||
public:
|
||||
AsusCerberusKeyboardController(hid_device* dev_handle, const char* path, unsigned short rev_version);
|
||||
~AsusCerberusKeyboardController();
|
||||
|
||||
std::string GetDeviceLocation();
|
||||
std::string GetSerialString();
|
||||
std::string GetVersion();
|
||||
|
||||
void SetProfile(uint8_t profile);
|
||||
void SetPerLEDColor(uint8_t key, uint8_t red, uint8_t green, uint8_t blue);
|
||||
void SendPerLEDColorEnd();
|
||||
void SetPerLEDMode(uint8_t mode);
|
||||
void SetMode(uint8_t mode, uint8_t red, uint8_t green, uint8_t blue, uint8_t direction, uint8_t brightness);
|
||||
|
||||
|
||||
private:
|
||||
hid_device* dev;
|
||||
std::string location;
|
||||
unsigned short version;
|
||||
};
|
||||
@@ -1,8 +1,6 @@
|
||||
#include "Detector.h"
|
||||
#include "AsusCerberusKeyboardController.h"
|
||||
#include "AsusStrixClawController.h"
|
||||
#include "RGBController.h"
|
||||
#include "RGBController_AsusCerberusKeyboard.h"
|
||||
#include "RGBController_AsusStrixClaw.h"
|
||||
#include <stdexcept>
|
||||
#include <hidapi/hidapi.h>
|
||||
@@ -10,22 +8,8 @@
|
||||
|
||||
#define ASUS_LEGACY_USB_VID 0x195D
|
||||
|
||||
#define ASUS_CERBERUS_MECH_PID 0x2047
|
||||
#define ASUS_ROG_STRIX_CLAW_PID 0x1016
|
||||
|
||||
void DetectAsusCerberusMech(hid_device_info* info, const std::string& name)
|
||||
{
|
||||
hid_device* dev = hid_open_path(info->path);
|
||||
|
||||
if(dev)
|
||||
{
|
||||
AsusCerberusKeyboardController* controller = new AsusCerberusKeyboardController(dev, info->path, info->release_number);
|
||||
RGBController_AsusCerberusKeyboard* rgb_controller = new RGBController_AsusCerberusKeyboard(controller);
|
||||
rgb_controller->name = name;
|
||||
ResourceManager::get()->RegisterRGBController(rgb_controller);
|
||||
}
|
||||
}
|
||||
|
||||
void DetectAsusStrixClaw(hid_device_info* info, const std::string& name)
|
||||
{
|
||||
hid_device* dev = hid_open_path(info->path);
|
||||
@@ -39,6 +23,4 @@ void DetectAsusStrixClaw(hid_device_info* info, const std::string& name)
|
||||
}
|
||||
}
|
||||
|
||||
REGISTER_HID_DETECTOR_IPU("ASUS Cerberus Mech", DetectAsusCerberusMech, ASUS_LEGACY_USB_VID, ASUS_CERBERUS_MECH_PID, 1, 0xFF01, 1);
|
||||
|
||||
REGISTER_HID_DETECTOR_IPU("ASUS ROG Strix Claw", DetectAsusStrixClaw, ASUS_LEGACY_USB_VID, ASUS_ROG_STRIX_CLAW_PID, 0, 0xFF01, 1);
|
||||
REGISTER_HID_DETECTOR_IPU("ASUS ROG Strix Claw", DetectAsusStrixClaw, ASUS_LEGACY_USB_VID, ASUS_ROG_STRIX_CLAW_PID, 0, 0xFF01, 1);
|
||||
|
||||
@@ -1,391 +0,0 @@
|
||||
/*-----------------------------------------*\
|
||||
| RGBController_AsusCerberusKeyboard.cpp |
|
||||
| |
|
||||
| Generic RGB Interface for Asus Cerberus |
|
||||
| USB controller driver |
|
||||
| |
|
||||
| Mola19 05/28/2022 |
|
||||
\*-----------------------------------------*/
|
||||
|
||||
#include "RGBController_AsusCerberusKeyboard.h"
|
||||
#include <vector>
|
||||
#include <cmath>
|
||||
#include "RGBControllerKeyNames.h"
|
||||
|
||||
/**------------------------------------------------------------------*\
|
||||
@name Asus Cerberus Mech Keyboard
|
||||
@category Keyboard
|
||||
@type USB
|
||||
@save :robot:
|
||||
@direct :x:
|
||||
@effects :white_check_mark:
|
||||
@detectors DetectAsusCerberusMech
|
||||
@comment
|
||||
\*-------------------------------------------------------------------*/
|
||||
|
||||
|
||||
//0xFFFFFFFF indicates an unused entry in matrix
|
||||
#define NA 0xFFFFFFFF
|
||||
|
||||
|
||||
static unsigned int matrix_map[6][24] = {
|
||||
{ 0, NA, 9, 15, 20, 25, NA, 35, 40, 45, 50, 56, 62, 67, 72, NA, 75, 79, 84, NA, NA, NA, NA, NA },
|
||||
{ 1, 6, 10, 16, 21, 26, 30, 36, 41, 46, 51, 57, 63, 68, NA, NA, 76, 80, 85, NA, 88, 93, 97, 102 },
|
||||
{ 2, NA, 11, 17, 22, 27, 31, 37, 42, 47, 52, 58, 64, 69, NA, NA, 77, 81, 86, NA, 89, 94, 98, 103 },
|
||||
{ 3, NA, 12, 18, 23, 28, 32, 38, 43, 48, 53, 59, 65, 70, 73, NA, NA, NA, NA, NA, 90, 95, 99, NA },
|
||||
{ 4, 7, 13, 19, 24, 29, 33, 39, 44, 49, 54, 60, NA, 71, NA, NA, NA, 82, NA, NA, 91, 96, 100, 104 },
|
||||
{ 5, 8, 14, NA, NA, NA, 34, NA, NA, NA, 55, 61, 66, NA, 74, NA, 78, 83, 87, NA, 92, NA, 101, NA }
|
||||
};
|
||||
|
||||
struct led_value
|
||||
{
|
||||
const char* name;
|
||||
uint8_t id;
|
||||
};
|
||||
|
||||
static const std::vector<led_value> led_names =
|
||||
{
|
||||
{ KEY_EN_ESCAPE, 0x0B },
|
||||
{ KEY_EN_BACK_TICK, 0x0E },
|
||||
{ KEY_EN_TAB, 0x09 },
|
||||
{ KEY_EN_CAPS_LOCK, 0x11 },
|
||||
{ KEY_EN_LEFT_SHIFT, 0x79 },
|
||||
{ KEY_EN_LEFT_CONTROL, 0x06 },
|
||||
|
||||
{ KEY_EN_1, 0x0F },
|
||||
{ KEY_EN_ISO_BACK_SLASH, 0x13 },
|
||||
{ KEY_EN_LEFT_WINDOWS, 0x7C },
|
||||
|
||||
{ KEY_EN_F1, 0x16 },
|
||||
{ KEY_EN_2, 0x17 },
|
||||
{ KEY_EN_Q, 0x08 },
|
||||
{ KEY_EN_A, 0x0A },
|
||||
{ KEY_EN_Z, 0x0C },
|
||||
{ KEY_EN_LEFT_ALT, 0x4B },
|
||||
|
||||
{ KEY_EN_F2, 0x1E },
|
||||
{ KEY_EN_3, 0x1F },
|
||||
{ KEY_EN_W, 0x10 },
|
||||
{ KEY_EN_S, 0x12 },
|
||||
{ KEY_EN_X, 0x14 },
|
||||
|
||||
{ KEY_EN_F3, 0x19 },
|
||||
{ KEY_EN_4, 0x27 },
|
||||
{ KEY_EN_E, 0x18 },
|
||||
{ KEY_EN_D, 0x1A },
|
||||
{ KEY_EN_C, 0x1C },
|
||||
|
||||
{ KEY_EN_F4, 0x1B },
|
||||
{ KEY_EN_5, 0x26 },
|
||||
{ KEY_EN_R, 0x20 },
|
||||
{ KEY_EN_F, 0x22 },
|
||||
{ KEY_EN_V, 0x24 },
|
||||
|
||||
{ KEY_EN_6, 0x2E },
|
||||
{ KEY_EN_T, 0x21 },
|
||||
{ KEY_EN_G, 0x23 },
|
||||
{ KEY_EN_B, 0x25 },
|
||||
{ KEY_EN_SPACE, 0x5B },
|
||||
|
||||
{ KEY_EN_F5, 0x07 },
|
||||
{ KEY_EN_7, 0x2F },
|
||||
{ KEY_EN_Y, 0x29 },
|
||||
{ KEY_EN_H, 0x2B },
|
||||
{ KEY_EN_N, 0x2D },
|
||||
|
||||
{ KEY_EN_F6, 0x33 },
|
||||
{ KEY_EN_8, 0x37 },
|
||||
{ KEY_EN_U, 0x28 },
|
||||
{ KEY_EN_J, 0x2A },
|
||||
{ KEY_EN_M, 0x2C },
|
||||
|
||||
{ KEY_EN_F7, 0x39 },
|
||||
{ KEY_EN_9, 0x3F },
|
||||
{ KEY_EN_I, 0x30 },
|
||||
{ KEY_EN_K, 0x32 },
|
||||
{ KEY_EN_COMMA, 0x34 },
|
||||
|
||||
{ KEY_EN_F8, 0x3E },
|
||||
{ KEY_EN_0, 0x47 },
|
||||
{ KEY_EN_O, 0x38 },
|
||||
{ KEY_EN_L, 0x3A },
|
||||
{ KEY_EN_PERIOD, 0x3C },
|
||||
{ KEY_EN_RIGHT_ALT, 0x4D },
|
||||
|
||||
{ KEY_EN_F9, 0x56 },
|
||||
{ KEY_EN_MINUS, 0x46 },
|
||||
{ KEY_EN_P, 0x40 },
|
||||
{ KEY_EN_SEMICOLON, 0x42 },
|
||||
{ KEY_EN_FORWARD_SLASH, 0x45 },
|
||||
{ KEY_EN_RIGHT_FUNCTION, 0x7D },
|
||||
|
||||
{ KEY_EN_F10, 0x57 },
|
||||
{ KEY_EN_EQUALS, 0x36 },
|
||||
{ KEY_EN_LEFT_BRACKET, 0x41 },
|
||||
{ KEY_EN_QUOTE, 0x43 },
|
||||
{ KEY_EN_MENU, 0x3D },
|
||||
|
||||
{ KEY_EN_F11, 0x53 },
|
||||
{ KEY_EN_BACKSPACE, 0x51 },
|
||||
{ KEY_EN_RIGHT_BRACKET, 0x31 },
|
||||
{ KEY_EN_POUND, 0x44 },
|
||||
{ KEY_EN_RIGHT_SHIFT, 0x7A },
|
||||
|
||||
{ KEY_EN_F12, 0x55 },
|
||||
{ KEY_EN_ISO_ENTER, 0x54 },
|
||||
{ KEY_EN_RIGHT_CONTROL, 0x04 },
|
||||
{ KEY_EN_PRINT_SCREEN, 0x4F },
|
||||
|
||||
{ KEY_EN_INSERT, 0x66 },
|
||||
{ KEY_EN_DELETE, 0x5E },
|
||||
{ KEY_EN_LEFT_ARROW, 0x75 },
|
||||
|
||||
{ KEY_EN_SCROLL_LOCK, 0x48 },
|
||||
{ KEY_EN_HOME, 0x76 },
|
||||
{ KEY_EN_END, 0x77 },
|
||||
{ KEY_EN_UP_ARROW, 0x73 },
|
||||
{ KEY_EN_DOWN_ARROW, 0x5D },
|
||||
|
||||
{ KEY_EN_PAUSE_BREAK, 0x00 },
|
||||
{ KEY_EN_PAGE_UP, 0x6E },
|
||||
{ KEY_EN_PAGE_DOWN, 0x6F },
|
||||
{ KEY_EN_RIGHT_ARROW, 0x65 },
|
||||
|
||||
{ KEY_EN_NUMPAD_LOCK, 0x5C },
|
||||
{ KEY_EN_NUMPAD_7, 0x58 },
|
||||
{ KEY_EN_NUMPAD_4, 0x59 },
|
||||
{ KEY_EN_NUMPAD_1, 0x5A },
|
||||
{ KEY_EN_NUMPAD_0, 0x63 },
|
||||
|
||||
{ KEY_EN_NUMPAD_DIVIDE, 0x64 },
|
||||
{ KEY_EN_NUMPAD_8, 0x60 },
|
||||
{ KEY_EN_NUMPAD_5, 0x61 },
|
||||
{ KEY_EN_NUMPAD_2, 0x62 },
|
||||
|
||||
{ KEY_EN_NUMPAD_TIMES, 0x6C },
|
||||
{ KEY_EN_NUMPAD_9, 0x68 },
|
||||
{ KEY_EN_NUMPAD_6, 0x69 },
|
||||
{ KEY_EN_NUMPAD_3, 0x6A },
|
||||
{ KEY_EN_NUMPAD_PERIOD, 0x6B },
|
||||
|
||||
{ KEY_EN_NUMPAD_MINUS, 0x6D },
|
||||
{ KEY_EN_NUMPAD_PLUS, 0x70 },
|
||||
{ KEY_EN_NUMPAD_ENTER, 0x72 }
|
||||
};
|
||||
|
||||
RGBController_AsusCerberusKeyboard::RGBController_AsusCerberusKeyboard(AsusCerberusKeyboardController* controller_ptr)
|
||||
{
|
||||
controller = controller_ptr;
|
||||
|
||||
/*------------------------------------------------------------------------------------------------------*\
|
||||
| this device has 6 different profiles, but there is no way to fetch them from the device, |
|
||||
| hence this device always sends to the first profile until a better solution is implemented in OpenRGB |
|
||||
\*------------------------------------------------------------------------------------------------------*/
|
||||
|
||||
controller->SetProfile(1);
|
||||
|
||||
name = "ASUS Cerberus Keyboard";
|
||||
vendor = "ASUS";
|
||||
type = DEVICE_TYPE_KEYBOARD;
|
||||
description = "ASUS Cerberus Keyboard Device";
|
||||
location = controller->GetDeviceLocation();
|
||||
serial = controller->GetSerialString();
|
||||
version = controller->GetVersion();
|
||||
|
||||
mode Custom;
|
||||
Custom.name = "Custom";
|
||||
Custom.value = CERBERUS_KEYBOARD_MODE_STATIC;
|
||||
Custom.flags = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
|
||||
Custom.brightness_min = CERBERUS_MECH_BRIGHTNESS_MIN;
|
||||
Custom.brightness_max = CERBERUS_MECH_BRIGHTNESS_MAX;
|
||||
Custom.brightness = CERBERUS_MECH_BRIGHTNESS_DEFAULT;
|
||||
Custom.color_mode = MODE_COLORS_PER_LED;
|
||||
modes.push_back(Custom);
|
||||
|
||||
mode Static;
|
||||
Static.name = "Static";
|
||||
Static.value = CERBERUS_KEYBOARD_MODE_STATIC;
|
||||
Static.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
|
||||
Static.brightness_min = CERBERUS_MECH_BRIGHTNESS_MIN;
|
||||
Static.brightness_max = CERBERUS_MECH_BRIGHTNESS_MAX;
|
||||
Static.brightness = CERBERUS_MECH_BRIGHTNESS_DEFAULT;
|
||||
Static.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Static.colors_min = 1;
|
||||
Static.colors_max = 1;
|
||||
Static.colors.resize(1);
|
||||
modes.push_back(Static);
|
||||
|
||||
mode Breathing;
|
||||
Breathing.name = "Breathing";
|
||||
Breathing.value = CERBERUS_KEYBOARD_MODE_BREATHING;
|
||||
Breathing.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
|
||||
Breathing.brightness_min = CERBERUS_MECH_BRIGHTNESS_MIN;
|
||||
Breathing.brightness_max = CERBERUS_MECH_BRIGHTNESS_MAX;
|
||||
Breathing.brightness = CERBERUS_MECH_BRIGHTNESS_DEFAULT;
|
||||
Breathing.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Breathing.colors_min = 1;
|
||||
Breathing.colors_max = 1;
|
||||
Breathing.colors.resize(1);
|
||||
modes.push_back(Breathing);
|
||||
|
||||
mode Reactive;
|
||||
Reactive.name = "Reactive";
|
||||
Reactive.value = CERBERUS_KEYBOARD_MODE_REACTIVE;
|
||||
Reactive.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
|
||||
Reactive.brightness_min = CERBERUS_MECH_BRIGHTNESS_MIN;
|
||||
Reactive.brightness_max = CERBERUS_MECH_BRIGHTNESS_MAX;
|
||||
Reactive.brightness = CERBERUS_MECH_BRIGHTNESS_DEFAULT;
|
||||
Reactive.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Reactive.colors_min = 1;
|
||||
Reactive.colors_max = 1;
|
||||
Reactive.colors.resize(1);
|
||||
modes.push_back(Reactive);
|
||||
|
||||
mode Explosion;
|
||||
Explosion.name = "Explosion";
|
||||
Explosion.value = CERBERUS_KEYBOARD_MODE_EXPLOSION;
|
||||
Explosion.flags = MODE_FLAG_HAS_DIRECTION_HV | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
|
||||
Explosion.brightness_min = CERBERUS_MECH_BRIGHTNESS_MIN;
|
||||
Explosion.brightness_max = CERBERUS_MECH_BRIGHTNESS_MAX;
|
||||
Explosion.brightness = CERBERUS_MECH_BRIGHTNESS_DEFAULT;
|
||||
Explosion.direction = MODE_DIRECTION_VERTICAL;
|
||||
Explosion.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Explosion.colors_min = 1;
|
||||
Explosion.colors_max = 1;
|
||||
Explosion.colors.resize(1);
|
||||
modes.push_back(Explosion);
|
||||
|
||||
mode Color_Cycle;
|
||||
Color_Cycle.name = "Spectrum Cycle";
|
||||
Color_Cycle.value = CERBERUS_KEYBOARD_MODE_COLOR_CYCLE;
|
||||
Color_Cycle.flags = MODE_FLAG_HAS_DIRECTION_HV | MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
|
||||
Color_Cycle.brightness_min = CERBERUS_MECH_BRIGHTNESS_MIN;
|
||||
Color_Cycle.brightness_max = CERBERUS_MECH_BRIGHTNESS_MAX;
|
||||
Color_Cycle.brightness = CERBERUS_MECH_BRIGHTNESS_DEFAULT;
|
||||
Color_Cycle.direction = MODE_DIRECTION_HORIZONTAL;
|
||||
Color_Cycle.color_mode = MODE_COLORS_NONE;
|
||||
modes.push_back(Color_Cycle);
|
||||
|
||||
mode Wave;
|
||||
Wave.name = "Rainbow Wave";
|
||||
Wave.value = CERBERUS_KEYBOARD_MODE_WAVE;
|
||||
Wave.flags = MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
|
||||
Wave.brightness_min = CERBERUS_MECH_BRIGHTNESS_MIN;
|
||||
Wave.brightness_max = CERBERUS_MECH_BRIGHTNESS_MAX;
|
||||
Wave.brightness = CERBERUS_MECH_BRIGHTNESS_DEFAULT;
|
||||
Wave.direction = MODE_DIRECTION_LEFT;
|
||||
Wave.color_mode = MODE_COLORS_NONE;
|
||||
modes.push_back(Wave);
|
||||
|
||||
SetupZones();
|
||||
}
|
||||
|
||||
RGBController_AsusCerberusKeyboard::~RGBController_AsusCerberusKeyboard()
|
||||
{
|
||||
delete controller;
|
||||
}
|
||||
|
||||
void RGBController_AsusCerberusKeyboard::SetupZones()
|
||||
{
|
||||
int zone_size = 105;
|
||||
|
||||
zone keyboard;
|
||||
keyboard.name = "Keyboard";
|
||||
keyboard.type = ZONE_TYPE_MATRIX;
|
||||
keyboard.leds_min = zone_size;
|
||||
keyboard.leds_max = zone_size;
|
||||
keyboard.leds_count = zone_size;
|
||||
keyboard.matrix_map = new matrix_map_type;
|
||||
keyboard.matrix_map->height = 6;
|
||||
keyboard.matrix_map->width = 24;
|
||||
keyboard.matrix_map->map = *matrix_map;
|
||||
zones.push_back(keyboard);
|
||||
|
||||
for(int led_id = 0; led_id < zone_size; led_id++)
|
||||
{
|
||||
led new_led;
|
||||
new_led.name = led_names[led_id].name;
|
||||
new_led.value = led_names[led_id].id;
|
||||
|
||||
leds.push_back(new_led);
|
||||
}
|
||||
|
||||
SetupColors();
|
||||
}
|
||||
|
||||
void RGBController_AsusCerberusKeyboard::ResizeZone(int /*zone*/, int /*new_size*/)
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
void RGBController_AsusCerberusKeyboard::DeviceUpdateLEDs()
|
||||
{
|
||||
for(unsigned int i = 0; i < colors.size(); i++)
|
||||
{
|
||||
uint8_t red = RGBGetRValue(colors[i]);
|
||||
uint8_t green = RGBGetGValue(colors[i]);
|
||||
uint8_t blue = RGBGetBValue(colors[i]);
|
||||
|
||||
controller->SetPerLEDColor(led_names[i].id, red, green, blue);
|
||||
}
|
||||
controller->SendPerLEDColorEnd();
|
||||
}
|
||||
|
||||
void RGBController_AsusCerberusKeyboard::UpdateZoneLEDs(int /*zone*/)
|
||||
{
|
||||
DeviceUpdateLEDs();
|
||||
}
|
||||
|
||||
void RGBController_AsusCerberusKeyboard::UpdateSingleLED(int led)
|
||||
{
|
||||
uint8_t red = RGBGetRValue(colors[led]);
|
||||
uint8_t green = RGBGetGValue(colors[led]);
|
||||
uint8_t blue = RGBGetBValue(colors[led]);
|
||||
|
||||
|
||||
controller->SetPerLEDColor(led_names[led].id, red, green, blue);
|
||||
controller->SendPerLEDColorEnd();
|
||||
}
|
||||
|
||||
void RGBController_AsusCerberusKeyboard::DeviceUpdateMode()
|
||||
{
|
||||
uint8_t direction = 0;
|
||||
uint8_t red = 0;
|
||||
uint8_t green = 0;
|
||||
uint8_t blue = 0;
|
||||
|
||||
uint8_t mode = modes[active_mode].value;
|
||||
|
||||
|
||||
if(modes[active_mode].color_mode == MODE_COLORS_PER_LED)
|
||||
{
|
||||
mode = CERBERUS_KEYBOARD_MODE_CUSTOM;
|
||||
direction = 1;
|
||||
|
||||
controller->SetPerLEDMode(modes[active_mode].value);
|
||||
}
|
||||
|
||||
switch(modes[active_mode].value)
|
||||
{
|
||||
case CERBERUS_KEYBOARD_MODE_EXPLOSION:
|
||||
direction = (modes[active_mode].direction == MODE_DIRECTION_HORIZONTAL) ? 1 : 0;
|
||||
break;
|
||||
|
||||
case CERBERUS_KEYBOARD_MODE_COLOR_CYCLE:
|
||||
direction = (modes[active_mode].direction == MODE_DIRECTION_HORIZONTAL) ? 0 : 1;
|
||||
break;
|
||||
|
||||
case CERBERUS_KEYBOARD_MODE_WAVE:
|
||||
direction = modes[active_mode].direction;
|
||||
break;
|
||||
}
|
||||
|
||||
if(modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC)
|
||||
{
|
||||
red = RGBGetRValue(modes[active_mode].colors[0]);
|
||||
green = RGBGetGValue(modes[active_mode].colors[0]);
|
||||
blue = RGBGetBValue(modes[active_mode].colors[0]);
|
||||
}
|
||||
|
||||
controller->SetMode(mode, red, green, blue, direction, modes[active_mode].brightness);
|
||||
}
|
||||
@@ -1,39 +0,0 @@
|
||||
/*-----------------------------------------*\
|
||||
| RGBController_AsusCerberusKeyboard.h |
|
||||
| |
|
||||
| Generic RGB Interface for Asus Cerberus |
|
||||
| USB controller driver |
|
||||
| |
|
||||
| Mola19 03/03/2021 |
|
||||
\*-----------------------------------------*/
|
||||
|
||||
#pragma once
|
||||
#include "RGBController.h"
|
||||
#include "AsusCerberusKeyboardController.h"
|
||||
|
||||
enum
|
||||
{
|
||||
CERBERUS_MECH_BRIGHTNESS_MIN = 0,
|
||||
CERBERUS_MECH_BRIGHTNESS_MAX = 4,
|
||||
CERBERUS_MECH_BRIGHTNESS_DEFAULT = 4
|
||||
};
|
||||
|
||||
class RGBController_AsusCerberusKeyboard : public RGBController
|
||||
{
|
||||
public:
|
||||
RGBController_AsusCerberusKeyboard(AsusCerberusKeyboardController* controller_ptr);
|
||||
~RGBController_AsusCerberusKeyboard();
|
||||
|
||||
void SetupZones();
|
||||
|
||||
void ResizeZone(int zone, int new_size);
|
||||
|
||||
void DeviceUpdateLEDs();
|
||||
void UpdateZoneLEDs(int zone);
|
||||
void UpdateSingleLED(int led);
|
||||
|
||||
void DeviceUpdateMode();
|
||||
|
||||
private:
|
||||
AsusCerberusKeyboardController* controller;
|
||||
};
|
||||
@@ -1,330 +0,0 @@
|
||||
#ifdef _WIN32
|
||||
|
||||
#include "AsusTUFLaptopController.h"
|
||||
|
||||
#include <Objbase.h>
|
||||
#include <setupapi.h>
|
||||
#include <comdef.h>
|
||||
#include <Wbemidl.h>
|
||||
|
||||
#include <cstdint>
|
||||
#include <cstring>
|
||||
#include <cstdio>
|
||||
|
||||
static bool coInitialized = 0;
|
||||
|
||||
static GUID CLSID_GUID_DEVCLASS_SYSTEM = { 0x4D36E97D, 0xE325, 0x11CE, {0xBF, 0xC1, 0x08, 0x00, 0x2B, 0xE1, 0x03, 0x18 } };
|
||||
|
||||
int AsusTUFLaptopController::checkWMIType()
|
||||
{
|
||||
int n;
|
||||
int v6;
|
||||
int result = 0;
|
||||
struct _SP_DEVINFO_DATA DeviceInfoData;
|
||||
const int bufsize = 260;
|
||||
wchar_t PropertyBuffer[bufsize];
|
||||
|
||||
HDEVINFO devinfo = SetupDiGetClassDevsW(&CLSID_GUID_DEVCLASS_SYSTEM, 0, 0, 2u);
|
||||
if ( devinfo == HDEVINFO(-1) )
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
n = 0;
|
||||
DeviceInfoData.cbSize = sizeof(DeviceInfoData);
|
||||
|
||||
while ( SetupDiEnumDeviceInfo(devinfo, n, &DeviceInfoData) ) // Invalid buffer
|
||||
{
|
||||
if ( SetupDiGetDeviceRegistryPropertyW(devinfo,
|
||||
&DeviceInfoData,
|
||||
SPDRP_ENUMERATOR_NAME,
|
||||
NULL,
|
||||
PBYTE(PropertyBuffer),
|
||||
sizeof(PropertyBuffer),
|
||||
0) )
|
||||
{
|
||||
// If we found property "ACPI"
|
||||
if(!wcscmp(PropertyBuffer, L"ACPI"))
|
||||
{
|
||||
memset(PropertyBuffer, 0, sizeof(PropertyBuffer));
|
||||
if ( SetupDiGetDeviceInstanceIdW(devinfo, &DeviceInfoData, PropertyBuffer, bufsize, 0) )
|
||||
{
|
||||
_wcsupr_s(PropertyBuffer, bufsize);
|
||||
if(wcsstr(PropertyBuffer, L"ACPI\\ATK0100"))
|
||||
{
|
||||
result = 1;
|
||||
break;
|
||||
}
|
||||
if(!wcscmp(PropertyBuffer, L"ACPI\\PNP0C14\\ATK"))
|
||||
{
|
||||
result = 2;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
++n;
|
||||
}
|
||||
SetupDiDestroyDeviceInfoList(devinfo);
|
||||
return result;
|
||||
}
|
||||
|
||||
AsusTUFLaptopController::AsusTUFLaptopController()
|
||||
{
|
||||
hDevice = CreateFileW(L"\\\\.\\ATKACPI", 0xC0000000, 3u, 0, 3u, 0, 0);
|
||||
}
|
||||
|
||||
AsusTUFLaptopController* AsusTUFLaptopController::checkAndCreate()
|
||||
{
|
||||
// This might cause issues when coInitialize() is used in multiple places
|
||||
HRESULT init = CoInitializeEx(0, COINIT_APARTMENTTHREADED);
|
||||
if ( init < 0 && init != 0x80010106 )
|
||||
return 0;
|
||||
coInitialized = 1;
|
||||
|
||||
int type = checkWMIType();
|
||||
if ( type == 2 )
|
||||
{
|
||||
AsusTUFLaptopController* controller = new AsusTUFLaptopController();
|
||||
if(controller->hDevice != HANDLE(-1))
|
||||
{
|
||||
return controller;
|
||||
}
|
||||
delete controller;
|
||||
}
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
AsusTUFLaptopController::~AsusTUFLaptopController()
|
||||
{
|
||||
if ( hDevice && hDevice != HANDLE(-1) )
|
||||
{
|
||||
CloseHandle(hDevice);
|
||||
hDevice = 0;
|
||||
}
|
||||
// This might cause issues when coInitialize() is used in multiple places
|
||||
if ( coInitialized )
|
||||
{
|
||||
CoUninitialize();
|
||||
coInitialized = 0;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
bool AsusTUFLaptopController::deviceIoControlWrapper(const void *dataIn, int commandIndex, int dataSizeIn, void *dataOut, int *dataSizeOut)
|
||||
{
|
||||
size_t BytesReturned;
|
||||
const int bufsize = 1024;
|
||||
char outBuffer[bufsize];
|
||||
|
||||
LPDWORD inBuffer = LPDWORD(malloc(dataSizeIn + 8));
|
||||
inBuffer[0] = commandIndex;
|
||||
inBuffer[1] = dataSizeIn;
|
||||
memmove(inBuffer + 2, dataIn, dataSizeIn);
|
||||
memset(outBuffer, 0, bufsize);
|
||||
BytesReturned = 0;
|
||||
bool result = DeviceIoControl(
|
||||
hDevice,
|
||||
0x22240Cu,
|
||||
inBuffer,
|
||||
dataSizeIn + 8,
|
||||
outBuffer,
|
||||
bufsize,
|
||||
LPDWORD(&BytesReturned),
|
||||
0);
|
||||
if ( result )
|
||||
{
|
||||
if ( *dataSizeOut < BytesReturned )
|
||||
{
|
||||
BytesReturned = *dataSizeOut;
|
||||
}
|
||||
memmove(dataOut, outBuffer, BytesReturned);
|
||||
}
|
||||
free(inBuffer);
|
||||
return result;
|
||||
}
|
||||
|
||||
bool AsusTUFLaptopController::deviceControl(int a1, int a2)
|
||||
{
|
||||
if ( hDevice && hDevice != HANDLE(-1) )
|
||||
{
|
||||
int data[2];
|
||||
data[0] = a1;
|
||||
data[1] = a2;
|
||||
int result;
|
||||
int outBufSize = 4;
|
||||
if ( deviceIoControlWrapper(&data, 1398162756, 8, &result, &outBufSize) )
|
||||
{
|
||||
if(outBufSize < 4)
|
||||
{
|
||||
result = 0;
|
||||
}
|
||||
if ( result == 1 )
|
||||
{
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
bool AsusTUFLaptopController::deviceControl(int a1, int a2, int a3)
|
||||
{
|
||||
unsigned int data[3];
|
||||
data[0] = a1;
|
||||
data[1] = a2;
|
||||
data[2] = a3;
|
||||
int outBuf;
|
||||
int outBufSize = 4;
|
||||
|
||||
if ( hDevice && hDevice != HANDLE(-1) )
|
||||
{
|
||||
if ( deviceIoControlWrapper(data, 0x53564544, 12, &outBuf, &outBufSize) )
|
||||
{
|
||||
if(outBufSize < 4)
|
||||
{
|
||||
outBuf = 0;
|
||||
}
|
||||
if ( outBuf == 1 )
|
||||
{
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
bool AsusTUFLaptopController::getStatus(int a1, int *out)
|
||||
{
|
||||
int status;
|
||||
int statusSize = 4;
|
||||
|
||||
if ( !hDevice || hDevice == HANDLE(-1) || (!deviceIoControlWrapper(&a1, 1398035268, 4, &status, &statusSize)) )
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
if(statusSize < 4)
|
||||
{
|
||||
status = 0;
|
||||
}
|
||||
*out = status;
|
||||
return 1;
|
||||
}
|
||||
|
||||
bool AsusTUFLaptopController::getStatusExtended(int a1, int a2, int *status1, int *status2, int* status3)
|
||||
{
|
||||
int commandData[2];
|
||||
commandData[0] = a1;
|
||||
commandData[1] = a2;
|
||||
int statusBuffer[3];
|
||||
int statusSize = 12;
|
||||
|
||||
if ( hDevice && hDevice != HANDLE(-1)
|
||||
&& deviceIoControlWrapper(commandData, 1398035268, 8, statusBuffer, &statusSize) )
|
||||
{
|
||||
*status1 = statusBuffer[0];
|
||||
*status2 = statusBuffer[1];
|
||||
*status3 = statusBuffer[2];
|
||||
return 1;
|
||||
}
|
||||
else
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
void AsusTUFLaptopController::setMode(unsigned char red,
|
||||
unsigned char green,
|
||||
unsigned char blue,
|
||||
unsigned char mode,
|
||||
unsigned char speed,
|
||||
bool save)
|
||||
{
|
||||
|
||||
/*--------------------------------------------------------*\
|
||||
| Use switch case since our speed values are magic numbers |
|
||||
| Default to Medium/Normal speed |
|
||||
\*--------------------------------------------------------*/
|
||||
unsigned char speed_val;
|
||||
|
||||
switch(speed)
|
||||
{
|
||||
case(1):
|
||||
speed_val = ASUS_WMI_KEYBOARD_SPEED_SLOW;
|
||||
break;
|
||||
default:
|
||||
case(2):
|
||||
speed_val = ASUS_WMI_KEYBOARD_SPEED_NORMAL;
|
||||
break;
|
||||
case(3):
|
||||
speed_val = ASUS_WMI_KEYBOARD_SPEED_FAST;
|
||||
break;
|
||||
}
|
||||
|
||||
|
||||
/*----------------------------------------------------------*\
|
||||
| We need to use a magic value to save to firmware in order |
|
||||
| To persist reboots. Save is normal op with different magic |
|
||||
\*---------------------------------------------------------*/
|
||||
unsigned char save_val = ASUS_WMI_KEYBOARD_MAGIC_USE;
|
||||
|
||||
if (save)
|
||||
{
|
||||
save_val = ASUS_WMI_KEYBOARD_MAGIC_SAVE;
|
||||
}
|
||||
|
||||
// B3 is store value
|
||||
unsigned int high = save_val | (mode<<8) | (red<<16) | (green<<24);
|
||||
unsigned int low = blue | (speed_val<<8);
|
||||
|
||||
deviceControl(ASUS_WMI_DEVID_TUF_RGB_MODE, high, low);
|
||||
|
||||
}
|
||||
|
||||
unsigned char AsusTUFLaptopController::getBrightness()
|
||||
{
|
||||
int backlight_state = 0;
|
||||
getStatus(ASUS_WMI_DEVID_KBD_BACKLIGHT, &backlight_state);
|
||||
|
||||
/*----------------------------------------------*\
|
||||
| Only lowest two bits indicate brightness level |
|
||||
\*----------------------------------------------*/
|
||||
return backlight_state & 0x7F;
|
||||
}
|
||||
|
||||
void AsusTUFLaptopController::setBrightness(unsigned char brightness)
|
||||
{
|
||||
/*-----------------------------------------------------*\
|
||||
| Only calls in this format persistently set brightness |
|
||||
\*-----------------------------------------------------*/
|
||||
int ctrl_param = 0x80 | (brightness & 0x7F);
|
||||
deviceControl(ASUS_WMI_DEVID_KBD_BACKLIGHT, ctrl_param);
|
||||
}
|
||||
|
||||
/*-----------------------------------------------------------*\
|
||||
| These settings will not persist a reboot unless save is set |
|
||||
\*-----------------------------------------------------------*/
|
||||
void AsusTUFLaptopController::setPowerState(bool boot,
|
||||
bool awake,
|
||||
bool sleep,
|
||||
bool shutdown,
|
||||
bool save)
|
||||
{
|
||||
unsigned int state = 0xBD;
|
||||
|
||||
if (boot) state = state | ASUS_WMI_KEYBOARD_POWER_BOOT;
|
||||
if (awake) state = state | ASUS_WMI_KEYBOARD_POWER_AWAKE;
|
||||
if (sleep) state = state | ASUS_WMI_KEYBOARD_POWER_SLEEP;
|
||||
if (shutdown) state = state | ASUS_WMI_KEYBOARD_POWER_SHUTDOWN;
|
||||
|
||||
if (save) state = state | ASUS_WMI_KEYBOARD_POWER_SAVE;
|
||||
|
||||
deviceControl(ASUS_WMI_DEVID_TUF_RGB_STATE, state);
|
||||
}
|
||||
|
||||
void AsusTUFLaptopController::setFanMode(int mode)
|
||||
{
|
||||
deviceControl(ASUS_WMI_DEVID_FAN_BOOST_MODE, mode);
|
||||
}
|
||||
|
||||
|
||||
#endif
|
||||
@@ -1,82 +0,0 @@
|
||||
#ifndef ASUSTUFLAPTOPCONTROLLER_H
|
||||
#define ASUSTUFLAPTOPCONTROLLER_H
|
||||
|
||||
#ifdef _WIN32
|
||||
|
||||
#include <windows.h>
|
||||
|
||||
#define ASUS_WMI_DEVID_KBD_BACKLIGHT 0x00050021
|
||||
#define ASUS_WMI_DEVID_TUF_RGB_MODE 0x00100056
|
||||
#define ASUS_WMI_DEVID_TUF_RGB_STATE 0x00100057
|
||||
|
||||
#define ASUS_WMI_DEVID_FAN_BOOST_MODE 0x00110018
|
||||
#define ASUS_WMI_DEVID_THROTTLE_THERMAL_POLICY 0x00120075
|
||||
|
||||
#define ASUS_WMI_KEYBOARD_SPEED_SLOW 0xE1
|
||||
#define ASUS_WMI_KEYBOARD_SPEED_NORMAL 0xEB
|
||||
#define ASUS_WMI_KEYBOARD_SPEED_FAST 0xF5
|
||||
|
||||
#define ASUS_WMI_KEYBOARD_SPEED_MIN 1
|
||||
#define ASUS_WMI_KEYBOARD_SPEED_MAX 3
|
||||
|
||||
#define ASUS_WMI_KEYBOARD_MODE_STATIC 0x00
|
||||
#define ASUS_WMI_KEYBOARD_MODE_BREATHING 0x01
|
||||
#define ASUS_WMI_KEYBOARD_MODE_COLORCYCLE 0x02
|
||||
#define ASUS_WMI_KEYBOARD_MODE_STROBING 0x0A
|
||||
|
||||
#define ASUS_WMI_KEYBOARD_BRIGHTNESS_MIN 0
|
||||
#define ASUS_WMI_KEYBOARD_BRIGHTNESS_MAX 3
|
||||
|
||||
#define ASUS_WMI_KEYBOARD_MAGIC_USE 0xB3
|
||||
#define ASUS_WMI_KEYBOARD_MAGIC_SAVE 0xB4
|
||||
|
||||
#define ASUS_WMI_KEYBOARD_POWER_BOOT 0x03<<16
|
||||
#define ASUS_WMI_KEYBOARD_POWER_AWAKE 0x0C<<16
|
||||
#define ASUS_WMI_KEYBOARD_POWER_SLEEP 0x30<<16
|
||||
#define ASUS_WMI_KEYBOARD_POWER_SHUTDOWN 0xC0<<16
|
||||
|
||||
#define ASUS_WMI_KEYBOARD_POWER_SAVE 0x01<<8
|
||||
|
||||
#define ASUS_WMI_FAN_SPEED_NORMAL 0
|
||||
#define ASUS_WMI_FAN_SPEED_TURBO 1
|
||||
#define ASUS_WMI_FAN_SPEED_SILENT 2
|
||||
|
||||
class AsusTUFLaptopController
|
||||
{
|
||||
private:
|
||||
HANDLE hDevice;
|
||||
static int checkWMIType();
|
||||
AsusTUFLaptopController();
|
||||
|
||||
bool deviceIoControlWrapper(const void *dataIn, int commandIndex, int dataSizeIn, void *dataOut, int *dataSizeOut);
|
||||
bool deviceControl(int a1, int a2);
|
||||
bool deviceControl(int a1, int a2, int a3);
|
||||
bool getStatus(int a1, int *out);
|
||||
bool getStatusExtended(int a1, int a2, int *status1, int *status2, int* status3);
|
||||
|
||||
public:
|
||||
static AsusTUFLaptopController * checkAndCreate();
|
||||
~AsusTUFLaptopController();
|
||||
|
||||
void setMode(unsigned char red,
|
||||
unsigned char green,
|
||||
unsigned char blue,
|
||||
unsigned char mode,
|
||||
unsigned char speed,
|
||||
bool save);
|
||||
|
||||
unsigned char getBrightness();
|
||||
void setBrightness(unsigned char brightness);
|
||||
|
||||
void setPowerState(bool boot,
|
||||
bool awake,
|
||||
bool sleep,
|
||||
bool shutdown,
|
||||
bool save);
|
||||
|
||||
void setFanMode(int mode);
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
#endif // ASUSTUFLAPTOPCONTROLLER_H
|
||||
@@ -1,51 +0,0 @@
|
||||
#include "AsusTUFLaptopLinuxController.h"
|
||||
|
||||
#include <string>
|
||||
|
||||
void AsusTUFLaptopLinuxController::SendUpdate
|
||||
(
|
||||
unsigned char mode,
|
||||
unsigned char speed,
|
||||
unsigned char save,
|
||||
unsigned char red,
|
||||
unsigned char green,
|
||||
unsigned char blue
|
||||
)
|
||||
{
|
||||
std::string s = "";
|
||||
s.append(ASUS_KBD_BACKLIGHT_BASE_PATH);
|
||||
s.append(ASUS_KBD_BACKLIGHT_MODE_PATH);
|
||||
FILE *controller = fopen(s.c_str(), "w");
|
||||
|
||||
s = "";
|
||||
s.append(std::to_string(save));
|
||||
s.append(" ");
|
||||
s.append(std::to_string(mode));
|
||||
s.append(" ");
|
||||
s.append(std::to_string(red));
|
||||
s.append(" ");
|
||||
s.append(std::to_string(green));
|
||||
s.append(" ");
|
||||
s.append(std::to_string(blue));
|
||||
s.append(" ");
|
||||
s.append(std::to_string(speed));
|
||||
|
||||
fputs(s.c_str(), controller);
|
||||
|
||||
fclose(controller);
|
||||
}
|
||||
|
||||
void AsusTUFLaptopLinuxController::SendBrightness
|
||||
(
|
||||
unsigned char brightness
|
||||
)
|
||||
{
|
||||
std::string s = "";
|
||||
s.append(ASUS_KBD_BACKLIGHT_BASE_PATH);
|
||||
s.append(ASUS_KBD_BACKLIGHT_BRIGHTNESS_PATH);
|
||||
FILE *controller = fopen(s.c_str(), "w");
|
||||
|
||||
fputs(std::to_string(brightness).c_str(), controller);
|
||||
|
||||
fclose(controller);
|
||||
}
|
||||
@@ -1,37 +0,0 @@
|
||||
#ifndef ASUSTUFLAPTOPLINUXCONTROLLER_H
|
||||
#define ASUSTUFLAPTOPLINUXCONTROLLER_H
|
||||
|
||||
#include "RGBController.h"
|
||||
|
||||
#define ASUS_KBD_BACKLIGHT_BRIGHTNESS_MIN 0
|
||||
#define ASUS_KBD_BACKLIGHT_BRIGHTNESS_MAX 3
|
||||
#define ASUS_KBD_BACKLIGHT_BRIGHTNESS 3
|
||||
|
||||
#define ASUS_KBD_BACKLIGHT_SPEED_MIN 0
|
||||
#define ASUS_KBD_BACKLIGHT_SPEED_MAX 2
|
||||
#define ASUS_KBD_BACKLIGHT_SPEED 1
|
||||
|
||||
#define ASUS_KBD_BACKLIGHT_BASE_PATH "/sys/devices/platform/asus-nb-wmi/leds/asus::kbd_backlight"
|
||||
#define ASUS_KBD_BACKLIGHT_MODE_PATH "/kbd_rgb_mode"
|
||||
#define ASUS_KBD_BACKLIGHT_BRIGHTNESS_PATH "/brightness"
|
||||
|
||||
class AsusTUFLaptopLinuxController
|
||||
{
|
||||
public:
|
||||
void SendBrightness
|
||||
(
|
||||
unsigned char brightness
|
||||
);
|
||||
|
||||
void SendUpdate
|
||||
(
|
||||
unsigned char mode,
|
||||
unsigned char speed,
|
||||
unsigned char save,
|
||||
unsigned char red,
|
||||
unsigned char green,
|
||||
unsigned char blue
|
||||
);
|
||||
};
|
||||
|
||||
#endif // ASUSTUFLAPTOPLINUXCONTROLLER_H
|
||||
@@ -1,28 +0,0 @@
|
||||
#include "RGBController_AsusTUFLaptopLinux.h"
|
||||
#include "AsusTUFLaptopLinuxController.h"
|
||||
|
||||
#include <string>
|
||||
#include "Detector.h"
|
||||
#include <unistd.h>
|
||||
|
||||
static void DetectAsusTUFLaptopLinuxControllers()
|
||||
{
|
||||
/*-------------------------------------------------------------------------------------*\
|
||||
| If /sys/devices/platform/asus-nb-wmi/leds/asus::kbd_backlight/kbd_rgb_mode exists, |
|
||||
| the kernel support TUF Laptop keyboard LED controlling. |
|
||||
\*-------------------------------------------------------------------------------------*/
|
||||
|
||||
std::string s = "";
|
||||
s.append(ASUS_KBD_BACKLIGHT_BASE_PATH);
|
||||
s.append(ASUS_KBD_BACKLIGHT_MODE_PATH);
|
||||
|
||||
if(!access(s.c_str(), F_OK))
|
||||
{
|
||||
AsusTUFLaptopLinuxController* controller = new AsusTUFLaptopLinuxController();
|
||||
RGBController_AsusTUFLaptopLinux* rgb_controller = new RGBController_AsusTUFLaptopLinux(controller);
|
||||
ResourceManager::get()->RegisterRGBController(rgb_controller);
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
REGISTER_DETECTOR("ASUS TUF Laptop", DetectAsusTUFLaptopLinuxControllers);
|
||||
@@ -1,13 +1,13 @@
|
||||
#ifdef _WIN32
|
||||
|
||||
#include "AsusTUFLaptopController.h"
|
||||
#include "RGBController_AsusTUFLaptopWMI.h"
|
||||
|
||||
#include "acpiwmi.h"
|
||||
#include "Detector.h"
|
||||
#include "wmi.h"
|
||||
#include <string>
|
||||
|
||||
static void DetectAsusTUFLaptopWMIControllers()
|
||||
static void DetectAsusTUFLaptopWMIControllers(std::vector<RGBController*>&)
|
||||
{
|
||||
// Try to retrieve ProductID / Device name from WMI; Possibly can be rewritten to use wmi.cpp
|
||||
// IF you encounter false detection ( e.g. if your laptop keyboard backlight uses USB interface
|
||||
@@ -29,21 +29,19 @@ static void DetectAsusTUFLaptopWMIControllers()
|
||||
return;
|
||||
}
|
||||
std::string& name = systemProduct[0]["Name"];
|
||||
|
||||
if(name.find("TUF Gaming") == name.npos)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
AsusTUFLaptopController* controller = AsusTUFLaptopController::checkAndCreate();
|
||||
if(controller)
|
||||
if(AsWMI_Open())
|
||||
{
|
||||
RGBController* new_controller = new RGBController_AsusTUFLaptopWMI(controller);
|
||||
|
||||
RGBController* new_controller = new RGBController_AsusTUFLaptopWMI();
|
||||
ResourceManager::get()->RegisterRGBController(new_controller);
|
||||
// Success! No more if's
|
||||
}
|
||||
} /* DetectAsusTUFLaptopWMIControllers() */
|
||||
} /* DetectFaustusControllers() */
|
||||
|
||||
REGISTER_DETECTOR("ASUS TUF Laptop", DetectAsusTUFLaptopWMIControllers);
|
||||
REGISTER_DETECTOR("TUF Laptop WMI", DetectAsusTUFLaptopWMIControllers);
|
||||
|
||||
#endif
|
||||
|
||||
@@ -1,150 +0,0 @@
|
||||
#include "RGBController_AsusTUFLaptopLinux.h"
|
||||
|
||||
/**------------------------------------------------------------------*\
|
||||
@name Asus TUF Laptop Linux WMI
|
||||
@category Keyboard
|
||||
@type File Stream
|
||||
@save :x:
|
||||
@direct :white_check_mark:
|
||||
@effects :white_check_mark:
|
||||
@detectors DetectAsusTUFLaptopLinuxControllers
|
||||
@comment Tested on ASUS TUF Gaming A15 2022
|
||||
PLEASE UPDATE YOUR KERNEL TO A VERSION NEWER THAN 6.1.0
|
||||
|
||||
Every devices supported by asus-wmi would work technically.
|
||||
\*-------------------------------------------------------------------*/
|
||||
|
||||
RGBController_AsusTUFLaptopLinux::RGBController_AsusTUFLaptopLinux(AsusTUFLaptopLinuxController* controller_ptr)
|
||||
{
|
||||
controller = controller_ptr;
|
||||
|
||||
name = "ASUS TUF Keyboard";
|
||||
vendor = "ASUS";
|
||||
type = DEVICE_TYPE_KEYBOARD;
|
||||
description = "Asus TUF Device";
|
||||
location = ASUS_KBD_BACKLIGHT_BASE_PATH;
|
||||
|
||||
mode Direct;
|
||||
Direct.name = "Direct";
|
||||
Direct.value = 4;
|
||||
Direct.flags = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
|
||||
Direct.brightness_min = ASUS_KBD_BACKLIGHT_BRIGHTNESS_MIN;
|
||||
Direct.brightness_max = ASUS_KBD_BACKLIGHT_BRIGHTNESS_MAX;
|
||||
Direct.brightness = ASUS_KBD_BACKLIGHT_BRIGHTNESS;
|
||||
Direct.color_mode = MODE_COLORS_PER_LED;
|
||||
modes.push_back(Direct);
|
||||
|
||||
mode Static;
|
||||
Static.name = "Static";
|
||||
Static.value = 0;
|
||||
Static.flags = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
|
||||
Static.brightness_min = ASUS_KBD_BACKLIGHT_BRIGHTNESS_MIN;
|
||||
Static.brightness_max = ASUS_KBD_BACKLIGHT_BRIGHTNESS_MAX;
|
||||
Static.brightness = ASUS_KBD_BACKLIGHT_BRIGHTNESS;
|
||||
Static.color_mode = MODE_COLORS_PER_LED;
|
||||
modes.push_back(Static);
|
||||
|
||||
mode Breathing;
|
||||
Breathing.name = "Breathing";
|
||||
Breathing.value = 1;
|
||||
Breathing.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
|
||||
Breathing.speed_min = ASUS_KBD_BACKLIGHT_SPEED_MIN;
|
||||
Breathing.speed_max = ASUS_KBD_BACKLIGHT_SPEED_MAX;
|
||||
Breathing.brightness_min = ASUS_KBD_BACKLIGHT_BRIGHTNESS_MIN;
|
||||
Breathing.brightness_max = ASUS_KBD_BACKLIGHT_BRIGHTNESS_MAX;
|
||||
Breathing.brightness = ASUS_KBD_BACKLIGHT_BRIGHTNESS;
|
||||
Breathing.color_mode = MODE_COLORS_PER_LED;
|
||||
Breathing.speed = ASUS_KBD_BACKLIGHT_SPEED;
|
||||
modes.push_back(Breathing);
|
||||
|
||||
mode Cycle;
|
||||
Cycle.name = "Spectrum Cycle";
|
||||
Cycle.value = 2;
|
||||
Cycle.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
|
||||
Cycle.speed_min = ASUS_KBD_BACKLIGHT_SPEED_MIN;
|
||||
Cycle.speed_max = ASUS_KBD_BACKLIGHT_SPEED_MAX;
|
||||
Cycle.brightness_min = ASUS_KBD_BACKLIGHT_BRIGHTNESS_MIN;
|
||||
Cycle.brightness_max = ASUS_KBD_BACKLIGHT_BRIGHTNESS_MAX;
|
||||
Cycle.brightness = ASUS_KBD_BACKLIGHT_BRIGHTNESS;
|
||||
Cycle.color_mode = MODE_COLORS_NONE;
|
||||
Cycle.speed = ASUS_KBD_BACKLIGHT_SPEED;
|
||||
modes.push_back(Cycle);
|
||||
|
||||
mode Flashing;
|
||||
Flashing.name = "Flashing";
|
||||
Flashing.value = 0x0A;
|
||||
Flashing.flags = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
|
||||
Flashing.brightness_min = ASUS_KBD_BACKLIGHT_BRIGHTNESS_MIN;
|
||||
Flashing.brightness_max = ASUS_KBD_BACKLIGHT_BRIGHTNESS_MAX;
|
||||
Flashing.brightness = ASUS_KBD_BACKLIGHT_BRIGHTNESS;
|
||||
Flashing.color_mode = MODE_COLORS_PER_LED;
|
||||
modes.push_back(Flashing);
|
||||
|
||||
SetupZones();
|
||||
}
|
||||
|
||||
void RGBController_AsusTUFLaptopLinux::SetupZones()
|
||||
{
|
||||
/*---------------------------------------------------------*\
|
||||
| Set up zone |
|
||||
\*---------------------------------------------------------*/
|
||||
zones.resize(1);
|
||||
zones[0].type = ZONE_TYPE_SINGLE;
|
||||
zones[0].name = "Keyboard Backlight zone";
|
||||
zones[0].leds_min = 1;
|
||||
zones[0].leds_max = 1;
|
||||
zones[0].leds_count = 1;
|
||||
zones[0].matrix_map = NULL;
|
||||
|
||||
/*---------------------------------------------------------*\
|
||||
| Set up LED |
|
||||
\*---------------------------------------------------------*/
|
||||
leds.resize(1);
|
||||
leds[0].name = "Keyboard Backlight LED";
|
||||
|
||||
SetupColors();
|
||||
}
|
||||
|
||||
void RGBController_AsusTUFLaptopLinux::ResizeZone(int /*zone*/, int /*new_size*/)
|
||||
{
|
||||
/*---------------------------------------------------------*\
|
||||
| This device does not support resizing zones |
|
||||
\*---------------------------------------------------------*/
|
||||
}
|
||||
|
||||
void RGBController_AsusTUFLaptopLinux::DeviceUpdateLEDs()
|
||||
{
|
||||
uint8_t red = RGBGetRValue(colors[0]);
|
||||
uint8_t green = RGBGetGValue(colors[0]);
|
||||
uint8_t blue = RGBGetBValue(colors[0]);
|
||||
uint8_t speed = 0;
|
||||
uint8_t mode = modes[active_mode].value;
|
||||
uint8_t save = 1;
|
||||
if(mode == 4)
|
||||
{
|
||||
mode = 0;
|
||||
save = 0;
|
||||
}
|
||||
if(mode == 1 || mode == 2)
|
||||
{
|
||||
speed = modes[active_mode].speed;
|
||||
}
|
||||
|
||||
controller->SendUpdate(mode, speed, save, red, green, blue);
|
||||
controller->SendBrightness(modes[active_mode].brightness);
|
||||
}
|
||||
|
||||
void RGBController_AsusTUFLaptopLinux::UpdateZoneLEDs(int /*zone*/)
|
||||
{
|
||||
DeviceUpdateLEDs();
|
||||
}
|
||||
|
||||
void RGBController_AsusTUFLaptopLinux::UpdateSingleLED(int /*led*/)
|
||||
{
|
||||
DeviceUpdateLEDs();
|
||||
}
|
||||
|
||||
void RGBController_AsusTUFLaptopLinux::DeviceUpdateMode()
|
||||
{
|
||||
DeviceUpdateLEDs();
|
||||
}
|
||||
@@ -1,27 +0,0 @@
|
||||
#ifndef RGBCONTROLLER_ASUSTUFLAPTOPLINUX_H
|
||||
#define RGBCONTROLLER_ASUSTUFLAPTOPLINUX_H
|
||||
|
||||
#include "RGBController.h"
|
||||
#include "AsusTUFLaptopLinuxController.h"
|
||||
|
||||
|
||||
class RGBController_AsusTUFLaptopLinux : public RGBController
|
||||
{
|
||||
public:
|
||||
RGBController_AsusTUFLaptopLinux(AsusTUFLaptopLinuxController* controller_ptr);
|
||||
|
||||
void SetupZones() override;
|
||||
|
||||
void ResizeZone(int zone, int new_size) override;
|
||||
|
||||
void DeviceUpdateLEDs() override;
|
||||
void UpdateZoneLEDs(int zone) override;
|
||||
void UpdateSingleLED(int led) override;
|
||||
|
||||
void DeviceUpdateMode() override;
|
||||
|
||||
private:
|
||||
AsusTUFLaptopLinuxController* controller;
|
||||
};
|
||||
|
||||
#endif // RGBCONTROLLER_ASUSTUFLAPTOPLINUX_H
|
||||
@@ -2,6 +2,12 @@
|
||||
|
||||
#include "RGBController_AsusTUFLaptopWMI.h"
|
||||
|
||||
#include "acpiwmi.h"
|
||||
#include "ResourceManager.h"
|
||||
#include "Detector.h"
|
||||
#include "wmi.h"
|
||||
#include <string>
|
||||
|
||||
using namespace std::chrono_literals;
|
||||
|
||||
/**------------------------------------------------------------------*\
|
||||
@@ -15,91 +21,72 @@ using namespace std::chrono_literals;
|
||||
@comment
|
||||
\*-------------------------------------------------------------------*/
|
||||
|
||||
RGBController_AsusTUFLaptopWMI::RGBController_AsusTUFLaptopWMI(AsusTUFLaptopController* controller_ptr)
|
||||
RGBController_AsusTUFLaptopWMI::RGBController_AsusTUFLaptopWMI()
|
||||
{
|
||||
name = "ASUS TUF Keyboard";
|
||||
vendor = "ASUS";
|
||||
type = DEVICE_TYPE_KEYBOARD;
|
||||
description = "WMI Device";
|
||||
location = "\\\\.\\ATKACPI";
|
||||
name = "ASUS TUF Keyboard";
|
||||
vendor = "ASUS";
|
||||
type = DEVICE_TYPE_KEYBOARD;
|
||||
description = "WMI Device";
|
||||
location = "\\\\.\\ATKACPI";
|
||||
|
||||
mode Static;
|
||||
Static.name = "Static";
|
||||
Static.value = ASUS_WMI_KEYBOARD_MODE_STATIC;
|
||||
Static.flags = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
|
||||
Static.color_mode = MODE_COLORS_PER_LED;
|
||||
Static.brightness_max = ASUS_WMI_KEYBOARD_BRIGHTNESS_MAX;
|
||||
Static.brightness_min = ASUS_WMI_KEYBOARD_BRIGHTNESS_MIN;
|
||||
Static.brightness = ASUS_WMI_KEYBOARD_BRIGHTNESS_MAX;
|
||||
modes.push_back(Static);
|
||||
modes.resize(5);
|
||||
modes[0].name = "Direct";
|
||||
modes[0].value = 4;
|
||||
modes[0].flags = MODE_FLAG_HAS_PER_LED_COLOR;
|
||||
modes[0].color_mode = MODE_COLORS_PER_LED;
|
||||
|
||||
mode Breathing;
|
||||
Breathing.name = "Breathing";
|
||||
Breathing.value = ASUS_WMI_KEYBOARD_MODE_BREATHING;
|
||||
Breathing.flags = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
|
||||
Breathing.color_mode = MODE_COLORS_PER_LED;
|
||||
Breathing.speed_min = ASUS_WMI_KEYBOARD_SPEED_MIN;
|
||||
Breathing.speed_max = ASUS_WMI_KEYBOARD_SPEED_MAX;
|
||||
Breathing.speed = 2;
|
||||
Breathing.brightness_max = ASUS_WMI_KEYBOARD_BRIGHTNESS_MAX;
|
||||
Breathing.brightness_min = ASUS_WMI_KEYBOARD_BRIGHTNESS_MIN;
|
||||
Breathing.brightness = ASUS_WMI_KEYBOARD_BRIGHTNESS_MAX;
|
||||
modes.push_back(Breathing);
|
||||
modes[1].name = "Static";
|
||||
modes[1].value = 0;
|
||||
modes[1].flags = MODE_FLAG_HAS_PER_LED_COLOR;
|
||||
modes[1].color_mode = MODE_COLORS_PER_LED;
|
||||
|
||||
mode ColorCycle;
|
||||
ColorCycle.name = "Color Cycle";
|
||||
ColorCycle.value = ASUS_WMI_KEYBOARD_MODE_COLORCYCLE;
|
||||
ColorCycle.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
|
||||
ColorCycle.color_mode = MODE_COLORS_NONE;
|
||||
ColorCycle.speed_min = ASUS_WMI_KEYBOARD_SPEED_MIN;
|
||||
ColorCycle.speed_max = ASUS_WMI_KEYBOARD_SPEED_MAX;
|
||||
ColorCycle.speed = 2;
|
||||
ColorCycle.brightness_max = ASUS_WMI_KEYBOARD_BRIGHTNESS_MAX;
|
||||
ColorCycle.brightness_min = ASUS_WMI_KEYBOARD_BRIGHTNESS_MIN;
|
||||
ColorCycle.brightness = ASUS_WMI_KEYBOARD_BRIGHTNESS_MAX;
|
||||
modes.push_back(ColorCycle);
|
||||
modes[2].name = "Breathing";
|
||||
modes[2].value = 1;
|
||||
modes[2].flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
|
||||
modes[2].speed_min = 0;
|
||||
modes[2].speed_max = 2;
|
||||
modes[2].color_mode = MODE_COLORS_PER_LED;
|
||||
modes[2].speed = 1;
|
||||
|
||||
mode Strobing;
|
||||
Strobing.name = "Strobing";
|
||||
Strobing.value = ASUS_WMI_KEYBOARD_MODE_STROBING;
|
||||
Strobing.flags = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
|
||||
Strobing.color_mode = MODE_COLORS_PER_LED;
|
||||
Strobing.brightness_max = ASUS_WMI_KEYBOARD_BRIGHTNESS_MAX;
|
||||
Strobing.brightness_min = ASUS_WMI_KEYBOARD_BRIGHTNESS_MIN;
|
||||
Strobing.brightness = ASUS_WMI_KEYBOARD_BRIGHTNESS_MAX;
|
||||
modes.push_back(Strobing);
|
||||
modes[3].name = "Color Cycle";
|
||||
modes[3].value = 2;
|
||||
modes[3].flags = MODE_FLAG_HAS_SPEED;
|
||||
modes[3].speed_min = 0;
|
||||
modes[3].speed_max = 2;
|
||||
modes[3].color_mode = MODE_COLORS_NONE;
|
||||
modes[3].speed = 1;
|
||||
|
||||
modes[4].name = "Strobe";
|
||||
modes[4].value = 0x0A;
|
||||
modes[4].flags = MODE_FLAG_HAS_PER_LED_COLOR;
|
||||
modes[4].color_mode = MODE_COLORS_PER_LED;
|
||||
|
||||
SetupZones();
|
||||
|
||||
controller = controller_ptr;
|
||||
|
||||
ReadConfiguration();
|
||||
}
|
||||
|
||||
RGBController_AsusTUFLaptopWMI::~RGBController_AsusTUFLaptopWMI()
|
||||
{
|
||||
delete controller;
|
||||
AsWMI_Close();
|
||||
}
|
||||
|
||||
void RGBController_AsusTUFLaptopWMI::SetupZones()
|
||||
{
|
||||
/*---------------------------------------------------------*\
|
||||
| Device only has one zone and one led |
|
||||
| Set up zone |
|
||||
\*---------------------------------------------------------*/
|
||||
zone* new_zone = new zone();
|
||||
led* new_led = new led();
|
||||
zones.resize(1);
|
||||
zones[0].type = ZONE_TYPE_SINGLE;
|
||||
zones[0].name = "Keyboard Backlight zone";
|
||||
zones[0].leds_min = 1;
|
||||
zones[0].leds_max = 1;
|
||||
zones[0].leds_count = 1;
|
||||
zones[0].matrix_map = NULL;
|
||||
|
||||
new_zone->type = ZONE_TYPE_SINGLE;
|
||||
new_zone->name = "Keyboard Backlight zone";
|
||||
new_zone->leds_min = 1;
|
||||
new_zone->leds_max = 1;
|
||||
new_zone->leds_count = 1;
|
||||
new_zone->matrix_map = NULL;
|
||||
|
||||
new_led->name = "Keyboard Backlight LED";
|
||||
|
||||
zones.push_back(*new_zone);
|
||||
leds.push_back(*new_led);
|
||||
/*---------------------------------------------------------*\
|
||||
| Set up LED |
|
||||
\*---------------------------------------------------------*/
|
||||
leds.resize(1);
|
||||
leds[0].name = "Keyboard Backlight LED";
|
||||
|
||||
SetupColors();
|
||||
}
|
||||
@@ -111,66 +98,52 @@ void RGBController_AsusTUFLaptopWMI::ResizeZone(int /*zone*/, int /*new_size*/)
|
||||
\*---------------------------------------------------------*/
|
||||
}
|
||||
|
||||
/*---------------------------------------------------------*\
|
||||
| Break this function off since we have to call save in the |
|
||||
same operation as doing everything else. |
|
||||
\*---------------------------------------------------------*/
|
||||
void RGBController_AsusTUFLaptopWMI::ControllerSetMode(bool save)
|
||||
{
|
||||
unsigned char red = RGBGetRValue(colors[0]);
|
||||
unsigned char green = RGBGetGValue(colors[0]);
|
||||
unsigned char blue = RGBGetBValue(colors[0]);
|
||||
|
||||
unsigned char mode = (unsigned char)modes[(unsigned int)active_mode].value;
|
||||
|
||||
/*------------------------------------------------------------*\
|
||||
| Use speed only if the mode supports it. Otherwise set normal |
|
||||
\*------------------------------------------------------------*/
|
||||
unsigned char speed = ASUS_WMI_KEYBOARD_SPEED_NORMAL;
|
||||
|
||||
if (modes[(unsigned int)active_mode].flags & MODE_FLAG_HAS_SPEED)
|
||||
{
|
||||
speed = (unsigned char)modes[(unsigned int)active_mode].speed;
|
||||
}
|
||||
|
||||
controller->setMode(red, green, blue, mode, speed, save);
|
||||
}
|
||||
|
||||
void RGBController_AsusTUFLaptopWMI::DeviceUpdateLEDs()
|
||||
{
|
||||
ControllerSetMode(false);
|
||||
uint8_t red = RGBGetRValue(colors[0]);
|
||||
uint8_t green = RGBGetGValue(colors[0]);
|
||||
uint8_t blue = RGBGetBValue(colors[0]);
|
||||
uint8_t speed_byte = 0;
|
||||
uint8_t mode = modes[active_mode].value;
|
||||
uint8_t inv = 0;
|
||||
if(mode == 4)
|
||||
{
|
||||
mode = 1;
|
||||
inv = 4; // Any invalid mode, i.e. anything other than 0, 1, 2 and 10
|
||||
}
|
||||
if(mode == 1 || mode == 2)
|
||||
{
|
||||
switch(modes[active_mode].speed)
|
||||
{
|
||||
case 0: speed_byte = 0xE1; break;
|
||||
case 1: speed_byte = 0xEB; break;
|
||||
case 2: speed_byte = 0xF5; break;
|
||||
}
|
||||
}
|
||||
int high = ((mode | ((red | (green << 8)) << 8)) << 8) | 0xB3;
|
||||
int low = blue | (speed_byte << 8);
|
||||
AsWMI_NB_DeviceControl_2arg(0x100056, high, low);
|
||||
if(inv)
|
||||
{
|
||||
//std::this_thread::sleep_for(10ms);
|
||||
high = ((inv | ((red | (green << 8)) << 8)) << 8) | 0xB3;
|
||||
AsWMI_NB_DeviceControl_2arg(0x100056, high, low);
|
||||
}
|
||||
}
|
||||
|
||||
void RGBController_AsusTUFLaptopWMI::UpdateZoneLEDs(int /*zone*/)
|
||||
{
|
||||
ControllerSetMode(false);
|
||||
DeviceUpdateLEDs();
|
||||
}
|
||||
|
||||
void RGBController_AsusTUFLaptopWMI::UpdateSingleLED(int /*led*/)
|
||||
{
|
||||
ControllerSetMode(false);
|
||||
DeviceUpdateLEDs();
|
||||
}
|
||||
|
||||
void RGBController_AsusTUFLaptopWMI::DeviceUpdateMode()
|
||||
{
|
||||
if (modes[(unsigned int)active_mode].flags & MODE_FLAG_HAS_BRIGHTNESS)
|
||||
{
|
||||
controller->setBrightness((unsigned char)modes[(unsigned int)active_mode].brightness);
|
||||
}
|
||||
ControllerSetMode(false);
|
||||
}
|
||||
|
||||
void RGBController_AsusTUFLaptopWMI::ReadConfiguration()
|
||||
{
|
||||
if (modes[(unsigned int)active_mode].flags & MODE_FLAG_HAS_BRIGHTNESS)
|
||||
{
|
||||
modes[(unsigned int)active_mode].brightness = controller->getBrightness();
|
||||
}
|
||||
}
|
||||
|
||||
void RGBController_AsusTUFLaptopWMI::DeviceSaveMode()
|
||||
{
|
||||
ControllerSetMode(true);
|
||||
DeviceUpdateLEDs();
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
@@ -1,35 +1,27 @@
|
||||
#ifdef _WIN32
|
||||
|
||||
#ifndef RGBCONTROLLER_ASUSTUFLAPTOPWMI_H
|
||||
#define RGBCONTROLLER_ASUSTUFLAPTOPWMI_H
|
||||
|
||||
#include "AsusTUFLaptopController.h"
|
||||
#ifdef _WIN32
|
||||
|
||||
#include "RGBController.h"
|
||||
|
||||
class RGBController_AsusTUFLaptopWMI : public RGBController
|
||||
{
|
||||
public:
|
||||
RGBController_AsusTUFLaptopWMI(AsusTUFLaptopController* controller_ptr);
|
||||
RGBController_AsusTUFLaptopWMI();
|
||||
virtual ~RGBController_AsusTUFLaptopWMI();
|
||||
|
||||
void SetupZones();
|
||||
void SetupZones() override;
|
||||
|
||||
void ResizeZone(int zone, int new_size);
|
||||
void ResizeZone(int zone, int new_size) override;
|
||||
|
||||
void DeviceUpdateLEDs();
|
||||
void UpdateZoneLEDs(int zone);
|
||||
void UpdateSingleLED(int led);
|
||||
void DeviceUpdateLEDs() override;
|
||||
void UpdateZoneLEDs(int zone) override;
|
||||
void UpdateSingleLED(int led) override;
|
||||
|
||||
void DeviceUpdateMode();
|
||||
void DeviceSaveMode();
|
||||
|
||||
private:
|
||||
AsusTUFLaptopController* controller;
|
||||
|
||||
void ReadConfiguration();
|
||||
void ControllerSetMode(bool save);
|
||||
void DeviceUpdateMode() override;
|
||||
};
|
||||
|
||||
#endif // RGBCONTROLLER_ASUSTUFLAPTOPWMI_H
|
||||
#endif
|
||||
|
||||
#endif // _WIN32
|
||||
#endif // RGBCONTROLLER_ASUSTUFLAPTOPWMI_H
|
||||
|
||||
@@ -19,7 +19,7 @@
|
||||
* *
|
||||
\******************************************************************************************/
|
||||
|
||||
void DetectBlinkyTapeControllers()
|
||||
void DetectBlinkyTapeControllers(std::vector<RGBController*> &rgb_controllers)
|
||||
{
|
||||
std::vector<std::string *> device_locations = find_usb_serial_port(BLINKINLABS_VID, BLINKYTAPE_PID);
|
||||
|
||||
@@ -29,7 +29,7 @@ void DetectBlinkyTapeControllers()
|
||||
controller->Initialize(*device_locations[device_idx]);
|
||||
|
||||
RGBController_BlinkyTape* rgb_controller = new RGBController_BlinkyTape(controller);
|
||||
ResourceManager::get()->RegisterRGBController(rgb_controller);
|
||||
rgb_controllers.push_back(rgb_controller);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -1,262 +0,0 @@
|
||||
/*-----------------------------------------*\
|
||||
| CherryKeyboardController.cpp |
|
||||
| |
|
||||
| Driver for Cherry RGB keyboard lighting |
|
||||
| controller |
|
||||
| |
|
||||
| Sebastian Kraus 12/25/2021 |
|
||||
\*-----------------------------------------*/
|
||||
|
||||
#include "CherryKeyboardController.h"
|
||||
|
||||
#include <cstring>
|
||||
|
||||
CherryKeyboardController::CherryKeyboardController(hid_device* dev_handle, const char* path)
|
||||
{
|
||||
dev = dev_handle;
|
||||
location = path;
|
||||
}
|
||||
|
||||
CherryKeyboardController::~CherryKeyboardController()
|
||||
{
|
||||
hid_close(dev);
|
||||
}
|
||||
|
||||
std::string CherryKeyboardController::GetDeviceLocation()
|
||||
{
|
||||
return("HID: " + location);
|
||||
}
|
||||
|
||||
std::string CherryKeyboardController::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 CherryKeyboardController::SetKeyboardColors
|
||||
(
|
||||
unsigned char * color_data,
|
||||
unsigned int size
|
||||
)
|
||||
{
|
||||
unsigned int packet_size = 0;
|
||||
unsigned int packet_offset = 0;
|
||||
|
||||
while(size > 0)
|
||||
{
|
||||
if(size >= CHERRY_KB_MAX_PACKET_SIZE)
|
||||
{
|
||||
packet_size = CHERRY_KB_MAX_PACKET_SIZE;
|
||||
}
|
||||
else
|
||||
{
|
||||
packet_size = size;
|
||||
}
|
||||
|
||||
SendKeyboardData
|
||||
(
|
||||
&color_data[packet_offset],
|
||||
packet_size,
|
||||
packet_offset
|
||||
);
|
||||
|
||||
size -= packet_size;
|
||||
packet_offset += packet_size;
|
||||
}
|
||||
}
|
||||
|
||||
void CherryKeyboardController::SendKeyboardMode
|
||||
(
|
||||
unsigned char mode
|
||||
)
|
||||
{
|
||||
SendKeyboardParameter(CHERRY_KB_PARAMETER_MODE, 1, &mode);
|
||||
}
|
||||
|
||||
void CherryKeyboardController::SendKeyboardModeEx
|
||||
(
|
||||
unsigned char mode,
|
||||
unsigned char brightness,
|
||||
unsigned char speed,
|
||||
unsigned char direction,
|
||||
unsigned char random_flag,
|
||||
unsigned char red,
|
||||
unsigned char green,
|
||||
unsigned char blue
|
||||
)
|
||||
{
|
||||
unsigned char parameter_data[8];
|
||||
|
||||
parameter_data[0] = mode;
|
||||
parameter_data[1] = brightness;
|
||||
parameter_data[2] = speed;
|
||||
parameter_data[3] = direction;
|
||||
parameter_data[4] = random_flag;
|
||||
parameter_data[5] = red;
|
||||
parameter_data[6] = green;
|
||||
parameter_data[7] = blue;
|
||||
|
||||
SendKeyboardParameter(0, 8, parameter_data);
|
||||
}
|
||||
|
||||
/*-------------------------------------------------------------------------------------------------*\
|
||||
| Private packet sending functions. |
|
||||
\*-------------------------------------------------------------------------------------------------*/
|
||||
|
||||
void CherryKeyboardController::ComputeChecksum
|
||||
(
|
||||
char usb_buf[CHERRY_KB_PACKET_SIZE]
|
||||
)
|
||||
{
|
||||
unsigned short checksum = 0;
|
||||
|
||||
for(unsigned int byte_idx = 0x03; byte_idx < CHERRY_KB_PACKET_SIZE; byte_idx++)
|
||||
{
|
||||
checksum += usb_buf[byte_idx];
|
||||
}
|
||||
|
||||
usb_buf[0x01] = checksum & 0xFF;
|
||||
usb_buf[0x02] = checksum >> 8;
|
||||
}
|
||||
|
||||
void CherryKeyboardController::SendKeyboardBegin()
|
||||
{
|
||||
unsigned char usb_buf[CHERRY_KB_PACKET_SIZE];
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Zero out buffer |
|
||||
\*-----------------------------------------------------*/
|
||||
memset(usb_buf, 0x00, sizeof(usb_buf));
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Set up Keyboard Begin (0x01) packet |
|
||||
| Note: Not computing checksum as packet contents are |
|
||||
| fixed |
|
||||
\*-----------------------------------------------------*/
|
||||
usb_buf[0x00] = 0x04;
|
||||
usb_buf[0x01] = CHERRY_KB_COMMAND_BEGIN;
|
||||
usb_buf[0x02] = 0x00;
|
||||
usb_buf[0x03] = CHERRY_KB_COMMAND_BEGIN;
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Send packet |
|
||||
\*-----------------------------------------------------*/
|
||||
hid_write(dev, usb_buf, CHERRY_KB_PACKET_SIZE);
|
||||
hid_read(dev, usb_buf, CHERRY_KB_PACKET_SIZE);
|
||||
}
|
||||
|
||||
void CherryKeyboardController::SendKeyboardEnd()
|
||||
{
|
||||
char usb_buf[CHERRY_KB_PACKET_SIZE];
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Zero out buffer |
|
||||
\*-----------------------------------------------------*/
|
||||
memset(usb_buf, 0x00, sizeof(usb_buf));
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Set up Keyboard End (0x02) packet |
|
||||
| Note: Not computing checksum as packet contents are |
|
||||
| fixed |
|
||||
\*-----------------------------------------------------*/
|
||||
usb_buf[0x00] = 0x04;
|
||||
usb_buf[0x01] = CHERRY_KB_COMMAND_END;
|
||||
usb_buf[0x02] = 0x00;
|
||||
usb_buf[0x03] = CHERRY_KB_COMMAND_END;
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Send packet |
|
||||
\*-----------------------------------------------------*/
|
||||
hid_write(dev, (unsigned char *)usb_buf, CHERRY_KB_PACKET_SIZE);
|
||||
hid_read(dev, (unsigned char *)usb_buf, CHERRY_KB_PACKET_SIZE);
|
||||
}
|
||||
|
||||
void CherryKeyboardController::SendKeyboardData
|
||||
(
|
||||
unsigned char * data,
|
||||
unsigned char data_size,
|
||||
unsigned short data_offset
|
||||
)
|
||||
{
|
||||
char usb_buf[CHERRY_KB_PACKET_SIZE];
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Zero out buffer |
|
||||
\*-----------------------------------------------------*/
|
||||
memset(usb_buf, 0x00, sizeof(usb_buf));
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Set up Keyboard Color Data (0x0B) packet |
|
||||
\*-----------------------------------------------------*/
|
||||
usb_buf[0x00] = 0x04;
|
||||
usb_buf[0x03] = CHERRY_KB_COMMAND_WRITE_CUSTOM_COLOR_DATA;
|
||||
|
||||
usb_buf[0x04] = data_size;
|
||||
usb_buf[0x05] = data_offset & 0x00FF;
|
||||
usb_buf[0x06] = data_offset >> 8;
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Copy in data bytes |
|
||||
\*-----------------------------------------------------*/
|
||||
memcpy(&usb_buf[0x08], data, data_size);
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Compute Checksum |
|
||||
\*-----------------------------------------------------*/
|
||||
ComputeChecksum(usb_buf);
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Send packet |
|
||||
\*-----------------------------------------------------*/
|
||||
hid_write(dev, (unsigned char *)usb_buf, CHERRY_KB_PACKET_SIZE);
|
||||
hid_read(dev, (unsigned char *)usb_buf, CHERRY_KB_PACKET_SIZE);
|
||||
}
|
||||
|
||||
void CherryKeyboardController::SendKeyboardParameter
|
||||
(
|
||||
unsigned char parameter,
|
||||
unsigned char parameter_size,
|
||||
unsigned char* parameter_data
|
||||
)
|
||||
{
|
||||
char usb_buf[CHERRY_KB_PACKET_SIZE];
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Zero out buffer |
|
||||
\*-----------------------------------------------------*/
|
||||
memset(usb_buf, 0x00, sizeof(usb_buf));
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Set up Keyboard Parameter (0x06) packet |
|
||||
\*-----------------------------------------------------*/
|
||||
usb_buf[0x00] = 0x04;
|
||||
usb_buf[0x03] = CHERRY_KB_COMMAND_SET_PARAMETER;
|
||||
usb_buf[0x04] = parameter_size;
|
||||
usb_buf[0x05] = parameter;
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Copy in data bytes |
|
||||
\*-----------------------------------------------------*/
|
||||
memcpy(&usb_buf[0x09], parameter_data, parameter_size);
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Compute Checksum |
|
||||
\*-----------------------------------------------------*/
|
||||
ComputeChecksum(usb_buf);
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Send packet |
|
||||
\*-----------------------------------------------------*/
|
||||
hid_write(dev, (unsigned char *)usb_buf, CHERRY_KB_PACKET_SIZE);
|
||||
hid_read(dev, (unsigned char *)usb_buf, CHERRY_KB_PACKET_SIZE);
|
||||
}
|
||||
@@ -1,150 +0,0 @@
|
||||
/*-----------------------------------------*\
|
||||
| CherryKeyboardController.h |
|
||||
| |
|
||||
| Definitions and types for Cherry RGB |
|
||||
| keyboard lighting controller |
|
||||
| |
|
||||
| Sebastian Kraus 12/25/2021 |
|
||||
\*-----------------------------------------*/
|
||||
|
||||
#include "RGBController.h"
|
||||
|
||||
#include <string>
|
||||
#include <hidapi/hidapi.h>
|
||||
|
||||
#pragma once
|
||||
|
||||
#define CHERRY_KB_PACKET_SIZE 64
|
||||
#define CHERRY_KB_MAX_PACKET_SIZE ( 0x36 )/* max packet size for color*/
|
||||
/* update packets */
|
||||
enum
|
||||
{
|
||||
CHERRY_KB_COMMAND_BEGIN = 0x01, /* Begin packet command */
|
||||
CHERRY_KB_COMMAND_END = 0x02, /* End packet command */
|
||||
CHERRY_KB_COMMAND_SET_PARAMETER = 0x06, /* Set parameter command */
|
||||
CHERRY_KB_COMMAND_READ_CUSTOM_COLOR_DATA = 0x1B, /* Read custom color data */
|
||||
CHERRY_KB_COMMAND_WRITE_CUSTOM_COLOR_DATA = 0x0B, /* Write custom color data */
|
||||
};
|
||||
|
||||
enum
|
||||
{
|
||||
CHERRY_KB_PARAMETER_MODE = 0x00, /* Mode parameter */
|
||||
CHERRY_KB_PARAMETER_BRIGHTNESS = 0x01, /* Brightness parameter */
|
||||
CHERRY_KB_PARAMETER_SPEED = 0x02, /* Speed parameter */
|
||||
CHERRY_KB_PARAMETER_DIRECTION = 0x03, /* Direction parameter */
|
||||
CHERRY_KB_PARAMETER_RANDOM_COLOR_FLAG = 0x04, /* Random color parameter */
|
||||
CHERRY_KB_PARAMETER_MODE_COLOR = 0x05, /* Mode color (RGB) */
|
||||
CHERRY_KB_PARAMETER_POLLING_RATE = 0x0F, /* Polling rate */
|
||||
CHERRY_KB_PARAMETER_SURMOUNT_MODE_COLOR = 0x11, /* Surmount mode color */
|
||||
};
|
||||
|
||||
enum
|
||||
{
|
||||
CHERRY_KB_MODE_WAVE = 0x00,
|
||||
CHERRY_KB_MODE_SPECTRUM = 0x01,
|
||||
CHERRY_KB_MODE_BREATHING = 0x02,
|
||||
CHERRY_KB_MODE_STATIC = 0x03,
|
||||
CHERRY_KB_MODE_RADAR = 0x04,
|
||||
CHERRY_KB_MODE_VORTEX = 0x05,
|
||||
CHERRY_KB_MODE_FIRE = 0x06,
|
||||
CHERRY_KB_MODE_STARS = 0x07,
|
||||
CHERRY_KB_MODE_CUSTOM = 0x08,
|
||||
CHERRY_KB_MODE_ROLLING = 0x0A,
|
||||
CHERRY_KB_MODE_RAIN = 0x0B,
|
||||
CHERRY_KB_MODE_CURVE = 0x0C,
|
||||
CHERRY_KB_MODE_WAVE_MID = 0x0E,
|
||||
CHERRY_KB_MODE_SCAN = 0x0F,
|
||||
CHERRY_KB_MODE_RADIATION = 0x12,
|
||||
CHERRY_KB_MODE_RIPPLES = 0x13,
|
||||
CHERRY_KB_MODE_SINGLE_KEY = 0x15,
|
||||
|
||||
};
|
||||
|
||||
enum
|
||||
{
|
||||
CHERRY_KB_BRIGHTNESS_LOWEST = 0x00, /* Lowest brightness (off) */
|
||||
CHERRY_KB_BRIGHTNESS_HIGHEST = 0x04, /* Highest brightness */
|
||||
};
|
||||
|
||||
enum
|
||||
{
|
||||
CHERRY_KB_SPEED_SLOWEST = 0x04, /* Slowest speed setting */
|
||||
CHERRY_KB_SPEED_NORMAL = 0x02, /* Normal speed setting */
|
||||
CHERRY_KB_SPEED_FASTEST = 0x00, /* Fastest speed setting */
|
||||
};
|
||||
|
||||
enum
|
||||
{
|
||||
CHERRY_KB_SURMOUNT_MODE_COLOR_RED = 0x01, /* Red surmount color */
|
||||
CHERRY_KB_SURMOUNT_MODE_COLOR_YELLOW = 0x02, /* Yellow surmount color */
|
||||
CHERRY_KB_SURMOUNT_MODE_COLOR_GREEN = 0x03, /* Green surmount color */
|
||||
CHERRY_KB_SURMOUNT_MODE_COLOR_BLUE = 0x04, /* Blue surmount color */
|
||||
};
|
||||
|
||||
enum
|
||||
{
|
||||
CHERRY_KB_POLLING_RATE_125HZ = 0x00, /* 125Hz polling rate */
|
||||
CHERRY_KB_POLLING_RATE_250HZ = 0x01, /* 250Hz polling rate */
|
||||
CHERRY_KB_POLLING_RATE_500HZ = 0x02, /* 500Hz polling rate */
|
||||
CHERRY_KB_POLLING_RATE_1000HZ = 0x03, /* 1000Hz polling rate */
|
||||
};
|
||||
|
||||
class CherryKeyboardController
|
||||
{
|
||||
public:
|
||||
CherryKeyboardController(hid_device* dev_handle, const char* path);
|
||||
~CherryKeyboardController();
|
||||
|
||||
std::string GetDeviceLocation();
|
||||
std::string GetSerialString();
|
||||
|
||||
void SetKeyboardColors
|
||||
(
|
||||
unsigned char * color_data,
|
||||
unsigned int size
|
||||
);
|
||||
|
||||
void SendKeyboardBegin();
|
||||
|
||||
void SendKeyboardMode
|
||||
(
|
||||
unsigned char mode
|
||||
);
|
||||
|
||||
void SendKeyboardModeEx
|
||||
(
|
||||
unsigned char mode,
|
||||
unsigned char brightness,
|
||||
unsigned char speed,
|
||||
unsigned char direction,
|
||||
unsigned char random_flag,
|
||||
unsigned char red,
|
||||
unsigned char green,
|
||||
unsigned char blue
|
||||
);
|
||||
|
||||
void SendKeyboardData
|
||||
(
|
||||
unsigned char * data,
|
||||
unsigned char data_size,
|
||||
unsigned short data_offset
|
||||
);
|
||||
|
||||
void SendKeyboardEnd();
|
||||
|
||||
private:
|
||||
hid_device* dev;
|
||||
std::string location;
|
||||
|
||||
void ComputeChecksum
|
||||
(
|
||||
char usb_buf[CHERRY_KB_PACKET_SIZE]
|
||||
);
|
||||
|
||||
void SendKeyboardParameter
|
||||
(
|
||||
unsigned char parameter,
|
||||
unsigned char parameter_size,
|
||||
unsigned char* parameter_data
|
||||
);
|
||||
};
|
||||
@@ -1,80 +0,0 @@
|
||||
#include "Detector.h"
|
||||
#include "CherryKeyboardController.h"
|
||||
#include "RGBController.h"
|
||||
#include "RGBController_CherryKeyboard.h"
|
||||
#include <vector>
|
||||
#include <hidapi/hidapi.h>
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Keyboard product IDs |
|
||||
\*-----------------------------------------------------*/
|
||||
#define CHERRY_KEYBOARD_VID 0x046A
|
||||
#define CHERRY_KEYBOARD_USAGE_PAGE 0xFF1C
|
||||
#define MX_BOARD_3_0S_FL_NBL_PID 0x0077
|
||||
#define MX_BOARD_3_0S_FL_RGB_PID 0x0079
|
||||
#define MX_BOARD_3_0S_FL_RGB_KOR_PID 0x0083
|
||||
#define MX_1_0_FL_BL_PID 0x00AB
|
||||
#define MX_BOARD_1_0_TKL_RGB_PID 0x00AC
|
||||
#define MX_BOARD_8_0_TKL_RGB_PID 0x00B7
|
||||
#define MX_BOARD_10_0_FL_RGB_PID 0x00BB
|
||||
#define G80_3000_TKL_NBL_PID 0x00C3
|
||||
#define MX_BOARD_2_0S_FL_RGB_PID 0x00C4
|
||||
#define G80_3000_TKL_RGB_PID 0x00C5
|
||||
#define MV_BOARD_3_0FL_RGB_PID 0x00C7
|
||||
#define CCF_MX_8_0_TKL_BL_PID 0x00C9
|
||||
#define CCF_MX_1_0_TKL_BL_PID 0x00CA
|
||||
#define CCF_MX_1_0_TKL_NBL_PID 0x00CB
|
||||
#define G30_3000_TKL_NBL_KOR_PID 0x00CD
|
||||
#define MX_BOARD_2_0S_FL_NBL_PID 0x00CE
|
||||
#define MX_1_0_FL_NBL_PID 0x00D2
|
||||
#define MX_1_0_FL_RGB_PID 0x00D3
|
||||
#define G80_3000N_TKL_RGB_PID 0x00DD
|
||||
#define G30_3000N_FL_RGB_PID 0x00DE
|
||||
#define MX_BOARD_10_0N_FL_RGB_PID 0x00DF
|
||||
#define MX_BOARD_2_0S_FL_RGB_DE_PID 0x01A6
|
||||
|
||||
/******************************************************************************************\
|
||||
* *
|
||||
* DetectCherryKeyboards *
|
||||
* *
|
||||
* Tests the USB address to see if an Cherry RGB Keyboard controller exists there. *
|
||||
* *
|
||||
\******************************************************************************************/
|
||||
|
||||
void DetectCherryKeyboards(hid_device_info* info, const std::string& name)
|
||||
{
|
||||
hid_device* dev = hid_open_path(info->path);
|
||||
if( dev )
|
||||
{
|
||||
CherryKeyboardController* controller = new CherryKeyboardController(dev, info->path);
|
||||
RGBController_CherryKeyboard* rgb_controller = new RGBController_CherryKeyboard(controller);
|
||||
rgb_controller->name = name;
|
||||
ResourceManager::get()->RegisterRGBController(rgb_controller);
|
||||
}
|
||||
}
|
||||
|
||||
/*---------------------------------------------------------------------------------------------------------------------------------------------*\
|
||||
| Keyboards |
|
||||
\*---------------------------------------------------------------------------------------------------------------------------------------------*/
|
||||
REGISTER_HID_DETECTOR_IP("Cherry Keyboard MX BOARD 3.0S FL NBL", DetectCherryKeyboards, CHERRY_KEYBOARD_VID, MX_BOARD_3_0S_FL_NBL_PID , 1, CHERRY_KEYBOARD_USAGE_PAGE);
|
||||
REGISTER_HID_DETECTOR_IP("Cherry Keyboard MX BOARD 3.0S FL RGB", DetectCherryKeyboards, CHERRY_KEYBOARD_VID, MX_BOARD_3_0S_FL_RGB_PID , 1, CHERRY_KEYBOARD_USAGE_PAGE);
|
||||
REGISTER_HID_DETECTOR_IP("Cherry Keyboard MX BOARD 3.0S FL RGB KOREAN", DetectCherryKeyboards, CHERRY_KEYBOARD_VID, MX_BOARD_3_0S_FL_RGB_KOR_PID, 1, CHERRY_KEYBOARD_USAGE_PAGE);
|
||||
REGISTER_HID_DETECTOR_IP("Cherry Keyboard MX 1.0 FL BL", DetectCherryKeyboards, CHERRY_KEYBOARD_VID, MX_1_0_FL_BL_PID , 1, CHERRY_KEYBOARD_USAGE_PAGE);
|
||||
REGISTER_HID_DETECTOR_IP("Cherry Keyboard MX BOARD 1.0 TKL RGB", DetectCherryKeyboards, CHERRY_KEYBOARD_VID, MX_BOARD_1_0_TKL_RGB_PID , 1, CHERRY_KEYBOARD_USAGE_PAGE);
|
||||
REGISTER_HID_DETECTOR_IP("Cherry Keyboard MX BOARD 8.0 TKL RGB", DetectCherryKeyboards, CHERRY_KEYBOARD_VID, MX_BOARD_8_0_TKL_RGB_PID , 1, CHERRY_KEYBOARD_USAGE_PAGE);
|
||||
REGISTER_HID_DETECTOR_IP("Cherry Keyboard MX BOARD 10.0 FL RGB", DetectCherryKeyboards, CHERRY_KEYBOARD_VID, MX_BOARD_10_0_FL_RGB_PID , 1, CHERRY_KEYBOARD_USAGE_PAGE);
|
||||
REGISTER_HID_DETECTOR_IP("Cherry Keyboard G80-3000 TKL NBL", DetectCherryKeyboards, CHERRY_KEYBOARD_VID, G80_3000_TKL_NBL_PID , 1, CHERRY_KEYBOARD_USAGE_PAGE);
|
||||
REGISTER_HID_DETECTOR_IP("Cherry Keyboard MX BOARD 2.0S FL RGB", DetectCherryKeyboards, CHERRY_KEYBOARD_VID, MX_BOARD_2_0S_FL_RGB_PID , 1, CHERRY_KEYBOARD_USAGE_PAGE);
|
||||
REGISTER_HID_DETECTOR_IP("Cherry Keyboard G80-3000 TKL RGB", DetectCherryKeyboards, CHERRY_KEYBOARD_VID, G80_3000_TKL_RGB_PID , 1, CHERRY_KEYBOARD_USAGE_PAGE);
|
||||
REGISTER_HID_DETECTOR_IP("Cherry Keyboard MV BOARD 3.0 FL RGB", DetectCherryKeyboards, CHERRY_KEYBOARD_VID, MV_BOARD_3_0FL_RGB_PID , 1, CHERRY_KEYBOARD_USAGE_PAGE);
|
||||
REGISTER_HID_DETECTOR_IP("Cherry Keyboard CCF MX 8.0 TKL BL", DetectCherryKeyboards, CHERRY_KEYBOARD_VID, CCF_MX_8_0_TKL_BL_PID , 1, CHERRY_KEYBOARD_USAGE_PAGE);
|
||||
REGISTER_HID_DETECTOR_IP("Cherry Keyboard CCF MX 1.0 TKL BL", DetectCherryKeyboards, CHERRY_KEYBOARD_VID, CCF_MX_1_0_TKL_BL_PID , 1, CHERRY_KEYBOARD_USAGE_PAGE);
|
||||
REGISTER_HID_DETECTOR_IP("Cherry Keyboard CCF MX 1.0 TKL NBL", DetectCherryKeyboards, CHERRY_KEYBOARD_VID, CCF_MX_1_0_TKL_NBL_PID , 1, CHERRY_KEYBOARD_USAGE_PAGE);
|
||||
REGISTER_HID_DETECTOR_IP("Cherry Keyboard G80-3000 TKL NBL KOREAN", DetectCherryKeyboards, CHERRY_KEYBOARD_VID, G30_3000_TKL_NBL_KOR_PID , 1, CHERRY_KEYBOARD_USAGE_PAGE);
|
||||
REGISTER_HID_DETECTOR_IP("Cherry Keyboard MX BOARD 2.0S FL NBL", DetectCherryKeyboards, CHERRY_KEYBOARD_VID, MX_BOARD_2_0S_FL_NBL_PID , 1, CHERRY_KEYBOARD_USAGE_PAGE);
|
||||
REGISTER_HID_DETECTOR_IP("Cherry Keyboard MX 1.0 FL NBL", DetectCherryKeyboards, CHERRY_KEYBOARD_VID, MX_1_0_FL_NBL_PID , 1, CHERRY_KEYBOARD_USAGE_PAGE);
|
||||
REGISTER_HID_DETECTOR_IP("Cherry Keyboard MX 1.0 FL RGB", DetectCherryKeyboards, CHERRY_KEYBOARD_VID, MX_1_0_FL_RGB_PID , 1, CHERRY_KEYBOARD_USAGE_PAGE);
|
||||
REGISTER_HID_DETECTOR_IP("Cherry Keyboard G80-3000N TKL RGB", DetectCherryKeyboards, CHERRY_KEYBOARD_VID, G80_3000N_TKL_RGB_PID , 1, CHERRY_KEYBOARD_USAGE_PAGE);
|
||||
REGISTER_HID_DETECTOR_IP("Cherry Keyboard G80-3000N FL RGB", DetectCherryKeyboards, CHERRY_KEYBOARD_VID, G30_3000N_FL_RGB_PID , 1, CHERRY_KEYBOARD_USAGE_PAGE);
|
||||
REGISTER_HID_DETECTOR_IP("Cherry Keyboard MX BOARD 10.0N FL RGB", DetectCherryKeyboards, CHERRY_KEYBOARD_VID, MX_BOARD_10_0N_FL_RGB_PID , 1, CHERRY_KEYBOARD_USAGE_PAGE);
|
||||
REGISTER_HID_DETECTOR_IP("Cherry Keyboard MX BOARD 2.0S FL RGB DE", DetectCherryKeyboards, CHERRY_KEYBOARD_VID, MX_BOARD_2_0S_FL_RGB_DE_PID , 1, CHERRY_KEYBOARD_USAGE_PAGE);
|
||||
@@ -1,358 +0,0 @@
|
||||
/*-----------------------------------------*\
|
||||
| RGBController_CherryKeyboard.cpp |
|
||||
| |
|
||||
| Generic RGB Interface for Cherry RGB |
|
||||
| Keyboard |
|
||||
| |
|
||||
| Sebastian Kraus 12/25/2021 |
|
||||
\*-----------------------------------------*/
|
||||
|
||||
#include "RGBController_CherryKeyboard.h"
|
||||
|
||||
//0xFFFFFFFF indicates an unused entry in matrix
|
||||
#define NA 0xFFFFFFFF
|
||||
|
||||
static unsigned int matrix_map[6][23] =
|
||||
{ { 0, NA, 12, 18, 24, 30, 36, 42, 48, 54, 60, 66, 72, 78, 84, 90, 96, NA, NA, NA, NA, NA, NA },
|
||||
{ 1, 7, 13, 19, 25, 31, 37, 43, 49, 55, 61, 67, 73, 79, 85, 91, 97, NA, NA, NA, NA, NA, NA },
|
||||
{ 2, 8, 14, 20, 26, 32, 38, 44, 50, 56, 62, 68, 74, NA, 86, 92, 98, NA, NA, NA, NA, NA, NA },
|
||||
{ 3, 9, 15, 21, 27, 33, 39, 45, 51, 57, 63, 69, 75, 81, NA, NA, NA, NA, NA, NA, NA, NA, NA },
|
||||
{ 4, 10, 16, 22, 28, 34, 40, 46, 52, 58, 64, 70, NA, 82, NA, 94, NA, NA, NA, NA, NA, NA, NA },
|
||||
{ 5, 11, 17, NA, NA, NA, 41, NA, NA, NA, 65, 71, 77, 83, 89, 95, 101, NA, NA, NA, NA, NA, NA } };
|
||||
|
||||
/**------------------------------------------------------------------*\
|
||||
@name Cherry Keyboard
|
||||
@category Keyboard
|
||||
@type USB
|
||||
@save :robot:
|
||||
@direct :rotating_light:
|
||||
@effects :white_check_mark:
|
||||
@detectors DetectCherryKeyboards
|
||||
@comment
|
||||
\*-------------------------------------------------------------------*/
|
||||
|
||||
RGBController_CherryKeyboard::RGBController_CherryKeyboard(CherryKeyboardController* controller_ptr)
|
||||
{
|
||||
controller = controller_ptr;
|
||||
|
||||
name = "Cherry Keyboard Device";
|
||||
vendor = "Cherry";
|
||||
type = DEVICE_TYPE_KEYBOARD;
|
||||
description = "Cherry Keyboard Device";
|
||||
location = controller->GetDeviceLocation();
|
||||
serial = controller->GetSerialString();
|
||||
|
||||
mode Custom;
|
||||
Custom.name = "Custom";
|
||||
Custom.value = CHERRY_KB_MODE_CUSTOM;
|
||||
Custom.flags = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
|
||||
Custom.color_mode = MODE_COLORS_PER_LED;
|
||||
modes.push_back(Custom);
|
||||
|
||||
mode Wave;
|
||||
Wave.name = "Wave";
|
||||
Wave.value = CHERRY_KB_MODE_WAVE;
|
||||
Wave.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
|
||||
Wave.speed_min = CHERRY_KB_SPEED_SLOWEST;
|
||||
Wave.speed_max = CHERRY_KB_SPEED_FASTEST;
|
||||
Wave.speed = CHERRY_KB_SPEED_NORMAL;
|
||||
Wave.colors_min = 1;
|
||||
Wave.colors_max = 1;
|
||||
Wave.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Wave.colors.resize(1);
|
||||
modes.push_back(Wave);
|
||||
|
||||
mode Spectrum;
|
||||
Spectrum.name = "Spectrum";
|
||||
Spectrum.value = CHERRY_KB_MODE_SPECTRUM;
|
||||
Spectrum.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
|
||||
Spectrum.speed_min = CHERRY_KB_SPEED_SLOWEST;
|
||||
Spectrum.speed_max = CHERRY_KB_SPEED_FASTEST;
|
||||
Spectrum.speed = CHERRY_KB_SPEED_NORMAL;
|
||||
Spectrum.color_mode = MODE_COLORS_NONE;
|
||||
Spectrum.colors.resize(1);
|
||||
modes.push_back(Spectrum);
|
||||
|
||||
mode Breathing;
|
||||
Breathing.name = "Breathing";
|
||||
Breathing.value = CHERRY_KB_MODE_BREATHING;
|
||||
Breathing.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
|
||||
Breathing.speed_min = CHERRY_KB_SPEED_SLOWEST;
|
||||
Breathing.speed_max = CHERRY_KB_SPEED_FASTEST;
|
||||
Breathing.speed = CHERRY_KB_SPEED_NORMAL;
|
||||
Breathing.colors_min = 1;
|
||||
Breathing.colors_max = 1;
|
||||
Breathing.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Breathing.colors.resize(1);
|
||||
modes.push_back(Breathing);
|
||||
|
||||
mode Static;
|
||||
Static.name = "Static";
|
||||
Static.value = CHERRY_KB_MODE_STATIC;
|
||||
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;
|
||||
Static.colors.resize(1);
|
||||
modes.push_back(Static);
|
||||
|
||||
mode Radar;
|
||||
Radar.name = "Radar";
|
||||
Radar.value = CHERRY_KB_MODE_RADAR;
|
||||
Radar.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
|
||||
Radar.speed_min = CHERRY_KB_SPEED_SLOWEST;
|
||||
Radar.speed_max = CHERRY_KB_SPEED_FASTEST;
|
||||
Radar.speed = CHERRY_KB_SPEED_NORMAL;
|
||||
Radar.colors_min = 1;
|
||||
Radar.colors_max = 1;
|
||||
Radar.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Radar.colors.resize(1);
|
||||
modes.push_back(Radar);
|
||||
|
||||
mode Vortex;
|
||||
Vortex.name = "Vortex";
|
||||
Vortex.value = CHERRY_KB_MODE_VORTEX;
|
||||
Vortex.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
|
||||
Vortex.speed_min = CHERRY_KB_SPEED_SLOWEST;
|
||||
Vortex.speed_max = CHERRY_KB_SPEED_FASTEST;
|
||||
Vortex.speed = CHERRY_KB_SPEED_NORMAL;
|
||||
Vortex.colors_min = 1;
|
||||
Vortex.colors_max = 1;
|
||||
Vortex.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Vortex.colors.resize(1);
|
||||
modes.push_back(Vortex);
|
||||
|
||||
mode Fire;
|
||||
Fire.name = "Fire";
|
||||
Fire.value = CHERRY_KB_MODE_FIRE;
|
||||
Fire.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
|
||||
Fire.speed_min = CHERRY_KB_SPEED_SLOWEST;
|
||||
Fire.speed_max = CHERRY_KB_SPEED_FASTEST;
|
||||
Fire.speed = CHERRY_KB_SPEED_NORMAL;
|
||||
Fire.colors_min = 1;
|
||||
Fire.colors_max = 1;
|
||||
Fire.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Fire.colors.resize(1);
|
||||
modes.push_back(Fire);
|
||||
|
||||
mode Stars;
|
||||
Stars.name = "Stars";
|
||||
Stars.value = CHERRY_KB_MODE_STARS;
|
||||
Stars.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
|
||||
Stars.speed_min = CHERRY_KB_SPEED_SLOWEST;
|
||||
Stars.speed_max = CHERRY_KB_SPEED_FASTEST;
|
||||
Stars.speed = CHERRY_KB_SPEED_NORMAL;
|
||||
Stars.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Stars.colors.resize(1);
|
||||
modes.push_back(Stars);
|
||||
|
||||
mode Rain;
|
||||
Rain.name = "Rain";
|
||||
Rain.value = CHERRY_KB_MODE_RAIN;
|
||||
Rain.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
|
||||
Rain.speed_min = CHERRY_KB_SPEED_SLOWEST;
|
||||
Rain.speed_max = CHERRY_KB_SPEED_FASTEST;
|
||||
Rain.speed = CHERRY_KB_SPEED_NORMAL;
|
||||
Rain.colors_min = 1;
|
||||
Rain.colors_max = 1;
|
||||
Rain.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Rain.colors.resize(1);
|
||||
modes.push_back(Rain);
|
||||
|
||||
mode Rolling;
|
||||
Rolling.name = "Rolling";
|
||||
Rolling.value = CHERRY_KB_MODE_ROLLING;
|
||||
Rolling.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
|
||||
Rolling.speed_min = CHERRY_KB_SPEED_SLOWEST;
|
||||
Rolling.speed_max = CHERRY_KB_SPEED_FASTEST;
|
||||
Rolling.speed = CHERRY_KB_SPEED_NORMAL;
|
||||
Rolling.color_mode = MODE_COLORS_NONE;
|
||||
modes.push_back(Rolling);
|
||||
|
||||
mode Curve;
|
||||
Curve.name = "Curve";
|
||||
Curve.value = CHERRY_KB_MODE_CURVE;
|
||||
Curve.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
|
||||
Curve.speed_min = CHERRY_KB_SPEED_SLOWEST;
|
||||
Curve.speed_max = CHERRY_KB_SPEED_FASTEST;
|
||||
Curve.speed = CHERRY_KB_SPEED_NORMAL;
|
||||
Curve.colors_min = 1;
|
||||
Curve.colors_max = 1;
|
||||
Curve.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Curve.colors.resize(1);
|
||||
modes.push_back(Curve);
|
||||
|
||||
mode WaveMid;
|
||||
WaveMid.name = "Wave Mid";
|
||||
WaveMid.value = CHERRY_KB_MODE_WAVE_MID;
|
||||
WaveMid.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
|
||||
WaveMid.speed_min = CHERRY_KB_SPEED_SLOWEST;
|
||||
WaveMid.speed_max = CHERRY_KB_SPEED_FASTEST;
|
||||
WaveMid.speed = CHERRY_KB_SPEED_NORMAL;
|
||||
WaveMid.color_mode = MODE_COLORS_NONE;
|
||||
WaveMid.colors.resize(1);
|
||||
modes.push_back(WaveMid);
|
||||
|
||||
mode Scan;
|
||||
Scan.name = "Scan";
|
||||
Scan.value = CHERRY_KB_MODE_SCAN;
|
||||
Scan.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
|
||||
Scan.colors_min = 1;
|
||||
Scan.colors_max = 1;
|
||||
Scan.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Scan.colors.resize(1);
|
||||
modes.push_back(Scan);
|
||||
|
||||
mode Radiation;
|
||||
Radiation.name = "Radiation";
|
||||
Radiation.value = CHERRY_KB_MODE_RADIATION;
|
||||
Radiation.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
|
||||
Radiation.speed_min = CHERRY_KB_SPEED_SLOWEST;
|
||||
Radiation.speed_max = CHERRY_KB_SPEED_FASTEST;
|
||||
Radiation.speed = CHERRY_KB_SPEED_NORMAL;
|
||||
Radiation.colors_min = 1;
|
||||
Radiation.colors_max = 1;
|
||||
Radiation.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Radiation.colors.resize(1);
|
||||
modes.push_back(Radiation);
|
||||
|
||||
mode Ripples;
|
||||
Ripples.name = "Ripples";
|
||||
Ripples.value = CHERRY_KB_MODE_RIPPLES;
|
||||
Ripples.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
|
||||
Ripples.speed_min = CHERRY_KB_SPEED_SLOWEST;
|
||||
Ripples.speed_max = CHERRY_KB_SPEED_FASTEST;
|
||||
Ripples.speed = CHERRY_KB_SPEED_NORMAL;
|
||||
Ripples.colors_min = 1;
|
||||
Ripples.colors_max = 1;
|
||||
Ripples.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Ripples.colors.resize(1);
|
||||
modes.push_back(Ripples);
|
||||
|
||||
mode SingleKey;
|
||||
SingleKey.name = "Single Key";
|
||||
SingleKey.value = CHERRY_KB_MODE_SINGLE_KEY;
|
||||
SingleKey.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
|
||||
SingleKey.speed_min = CHERRY_KB_SPEED_SLOWEST;
|
||||
SingleKey.speed_max = CHERRY_KB_SPEED_FASTEST;
|
||||
SingleKey.speed = CHERRY_KB_SPEED_NORMAL;
|
||||
SingleKey.colors_min = 1;
|
||||
SingleKey.colors_max = 1;
|
||||
SingleKey.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
SingleKey.colors.resize(1);
|
||||
modes.push_back(SingleKey);
|
||||
|
||||
SetupZones();
|
||||
}
|
||||
|
||||
RGBController_CherryKeyboard::~RGBController_CherryKeyboard()
|
||||
{
|
||||
/*---------------------------------------------------------*\
|
||||
| Delete the matrix map |
|
||||
\*---------------------------------------------------------*/
|
||||
for(unsigned int zone_index = 0; zone_index < zones.size(); zone_index++)
|
||||
{
|
||||
if(zones[zone_index].matrix_map != NULL)
|
||||
{
|
||||
delete zones[zone_index].matrix_map;
|
||||
}
|
||||
}
|
||||
|
||||
delete controller;
|
||||
}
|
||||
|
||||
void RGBController_CherryKeyboard::SetupZones()
|
||||
{
|
||||
zone new_zone;
|
||||
|
||||
new_zone.name = "Keyboard";
|
||||
new_zone.type = ZONE_TYPE_MATRIX;
|
||||
new_zone.leds_min = 126;
|
||||
new_zone.leds_max = 126;
|
||||
new_zone.leds_count = 126;
|
||||
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);
|
||||
|
||||
for(int led_idx = 0; led_idx < 126; led_idx++)
|
||||
{
|
||||
led new_led;
|
||||
|
||||
new_led.name = "Keyboard LED ";
|
||||
new_led.name.append(std::to_string(led_idx));
|
||||
|
||||
leds.push_back(new_led);
|
||||
}
|
||||
|
||||
SetupColors();
|
||||
}
|
||||
|
||||
void RGBController_CherryKeyboard::ResizeZone(int /*zone*/, int /*new_size*/)
|
||||
{
|
||||
/*---------------------------------------------------------*\
|
||||
| This device does not support resizing zones |
|
||||
\*---------------------------------------------------------*/
|
||||
}
|
||||
|
||||
void RGBController_CherryKeyboard::DeviceUpdateLEDs()
|
||||
{
|
||||
unsigned char color_data[7*CHERRY_KB_MAX_PACKET_SIZE];
|
||||
|
||||
for(int led_idx = 0; led_idx < 126; led_idx++)
|
||||
{
|
||||
color_data[(3 * led_idx) + 0] = RGBGetRValue(colors[led_idx]);
|
||||
color_data[(3 * led_idx) + 1] = RGBGetGValue(colors[led_idx]);
|
||||
color_data[(3 * led_idx) + 2] = RGBGetBValue(colors[led_idx]);
|
||||
}
|
||||
|
||||
controller->SetKeyboardColors
|
||||
(
|
||||
color_data,
|
||||
CHERRY_KB_MAX_PACKET_SIZE * 7
|
||||
);
|
||||
}
|
||||
|
||||
void RGBController_CherryKeyboard::UpdateZoneLEDs(int /*zone*/)
|
||||
{
|
||||
DeviceUpdateLEDs();
|
||||
}
|
||||
|
||||
void RGBController_CherryKeyboard::UpdateSingleLED(int /*led*/)
|
||||
{
|
||||
DeviceUpdateLEDs();
|
||||
}
|
||||
|
||||
void RGBController_CherryKeyboard::SetCustomMode()
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
void RGBController_CherryKeyboard::DeviceUpdateMode()
|
||||
{
|
||||
unsigned char red = 0x00;
|
||||
unsigned char grn = 0x00;
|
||||
unsigned char blu = 0x00;
|
||||
unsigned char random = (modes[active_mode].color_mode == MODE_COLORS_RANDOM);
|
||||
|
||||
if(modes[active_mode].colors.size() > 0)
|
||||
{
|
||||
red = RGBGetRValue(modes[active_mode].colors[0]);
|
||||
grn = RGBGetGValue(modes[active_mode].colors[0]);
|
||||
blu = RGBGetBValue(modes[active_mode].colors[0]);
|
||||
}
|
||||
|
||||
controller->SendKeyboardModeEx
|
||||
(
|
||||
modes[active_mode].value,
|
||||
CHERRY_KB_BRIGHTNESS_HIGHEST,
|
||||
modes[active_mode].speed,
|
||||
0,
|
||||
random,
|
||||
red,
|
||||
grn,
|
||||
blu
|
||||
);
|
||||
}
|
||||
@@ -1,33 +0,0 @@
|
||||
/*-----------------------------------------*\
|
||||
| RGBController_CherryKeyboard.h |
|
||||
| |
|
||||
| Generic RGB Interface for Cherry RGB |
|
||||
| Keyboard |
|
||||
| |
|
||||
| Sebastian Kraus 12/25/2021 |
|
||||
\*-----------------------------------------*/
|
||||
|
||||
#pragma once
|
||||
#include "RGBController.h"
|
||||
#include "CherryKeyboardController.h"
|
||||
|
||||
class RGBController_CherryKeyboard : public RGBController
|
||||
{
|
||||
public:
|
||||
RGBController_CherryKeyboard(CherryKeyboardController* controller_ptr);
|
||||
~RGBController_CherryKeyboard();
|
||||
|
||||
void SetupZones();
|
||||
|
||||
void ResizeZone(int zone, int new_size);
|
||||
|
||||
void DeviceUpdateLEDs();
|
||||
void UpdateZoneLEDs(int zone);
|
||||
void UpdateSingleLED(int led);
|
||||
|
||||
void SetCustomMode();
|
||||
void DeviceUpdateMode();
|
||||
|
||||
private:
|
||||
CherryKeyboardController* controller;
|
||||
};
|
||||
@@ -1,44 +0,0 @@
|
||||
#include "ColorfulGPUController.h"
|
||||
#include <cstring>
|
||||
|
||||
ColorfulGPUController::ColorfulGPUController(i2c_smbus_interface* bus, colorful_gpu_dev_id dev)
|
||||
{
|
||||
this->bus = bus;
|
||||
this->dev = dev;
|
||||
}
|
||||
|
||||
ColorfulGPUController::~ColorfulGPUController()
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
std::string ColorfulGPUController::GetDeviceLocation()
|
||||
{
|
||||
std::string return_string(bus->device_name);
|
||||
char addr[5];
|
||||
snprintf(addr, 5, "0x%02X", dev);
|
||||
return_string.append(", address ");
|
||||
return_string.append(addr);
|
||||
return("I2C: " + return_string);
|
||||
}
|
||||
|
||||
void ColorfulGPUController::SetDirect(RGBColor color)
|
||||
{
|
||||
uint8_t r = RGBGetRValue(color);
|
||||
uint8_t g = RGBGetGValue(color);
|
||||
uint8_t b = RGBGetBValue(color);
|
||||
|
||||
uint8_t data_pkt[COLORFUL_PACKET_LENGTH] = { 0xAA, 0xEF, 0x12, 0x03, 0x01, 0xFF, r, g, b};
|
||||
|
||||
int crc = 0;
|
||||
|
||||
for (int i = 0; i < COLORFUL_PACKET_LENGTH - 2; ++i)
|
||||
{
|
||||
crc += data_pkt[i];
|
||||
}
|
||||
|
||||
data_pkt[COLORFUL_PACKET_LENGTH - 2] = crc & 0xFF;
|
||||
data_pkt[COLORFUL_PACKET_LENGTH - 1] = crc >> 8;
|
||||
|
||||
bus->i2c_write_block(dev, COLORFUL_PACKET_LENGTH, data_pkt);
|
||||
}
|
||||
@@ -1,24 +0,0 @@
|
||||
#include <string>
|
||||
#include "i2c_smbus.h"
|
||||
#include "RGBController.h"
|
||||
|
||||
#pragma once
|
||||
|
||||
typedef unsigned char colorful_gpu_dev_id;
|
||||
|
||||
#define COLORFUL_PACKET_LENGTH 11
|
||||
|
||||
class ColorfulGPUController
|
||||
{
|
||||
public:
|
||||
ColorfulGPUController(i2c_smbus_interface* bus, colorful_gpu_dev_id dev);
|
||||
~ColorfulGPUController();
|
||||
|
||||
std::string GetDeviceLocation();
|
||||
void SetDirect(RGBColor color);
|
||||
|
||||
|
||||
private:
|
||||
i2c_smbus_interface * bus;
|
||||
colorful_gpu_dev_id dev;
|
||||
};
|
||||
@@ -1,54 +0,0 @@
|
||||
#include "Detector.h"
|
||||
#include "ColorfulGPUController.h"
|
||||
#include "RGBController.h"
|
||||
#include "RGBController_ColorfulGPU.h"
|
||||
#include "i2c_smbus.h"
|
||||
#include "pci_ids.h"
|
||||
#include <vector>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
bool TestForColorfulGPU(i2c_smbus_interface* bus, uint8_t i2c_addr)
|
||||
{
|
||||
int pktsz;
|
||||
const int read_sz = 0x40;
|
||||
const int write_sz = 6;
|
||||
|
||||
uint8_t data_pkt[write_sz] = { 0xAA, 0xEF, 0x81, 0x02, 0x1C, 0x02};
|
||||
bus->i2c_write_block(i2c_addr, write_sz, data_pkt);
|
||||
|
||||
uint8_t read_pkt[read_sz] = {};
|
||||
pktsz = read_sz;
|
||||
|
||||
int res = bus->i2c_read_block(i2c_addr, &pktsz, read_pkt);
|
||||
|
||||
return res == 0 && (read_pkt[0] == 0xAA && read_pkt[1] == 0xEF && read_pkt[2] == 0x81);
|
||||
}
|
||||
|
||||
void DetectColorfulGPUControllers(i2c_smbus_interface* bus, uint8_t i2c_addr, const std::string& name)
|
||||
{
|
||||
if(TestForColorfulGPU(bus, i2c_addr))
|
||||
{
|
||||
ColorfulGPUController* controller = new ColorfulGPUController(bus, i2c_addr);
|
||||
RGBController_ColorfulGPU* rgb_controller = new RGBController_ColorfulGPU(controller);
|
||||
rgb_controller->name = name;
|
||||
|
||||
ResourceManager::get()->RegisterRGBController(rgb_controller);
|
||||
}
|
||||
}
|
||||
|
||||
REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3060 Advanced OC 12G L-V", DetectColorfulGPUControllers, NVIDIA_VEN, NVIDIA_RTX3060_LHR_DEV, COLORFUL_SUB_VEN, COLORFUL_IGAME_RTX_3060_ADVANCED_OC_12G_LV, 0x61);
|
||||
REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3060 Ultra W OC 12G L-V", DetectColorfulGPUControllers, NVIDIA_VEN, NVIDIA_RTX3060_LHR_DEV, COLORFUL_SUB_VEN, COLORFUL_IGAME_RTX_3060_ULTRAW_OC_12G, 0x61);
|
||||
REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3060 Ultra W OC 12G L-V", DetectColorfulGPUControllers, NVIDIA_VEN, NVIDIA_RTX3060_LHR_DEV, COLORFUL_SUB_VEN, COLORFUL_IGAME_RTX_3060_ULTRAW_OC_12G_2, 0x61);
|
||||
REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3060 Ti Ultra W OC LHR-V", DetectColorfulGPUControllers, NVIDIA_VEN, NVIDIA_RTX3060TI_LHR_DEV, COLORFUL_SUB_VEN, COLORFUL_IGAME_RTX_3060_ULTRAW_OC_12G_2, 0x61);
|
||||
REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3060 Ti Advanced OC-V", DetectColorfulGPUControllers, NVIDIA_VEN, NVIDIA_RTX3060TI_LHR_DEV, COLORFUL_SUB_VEN, COLORFUL_IGAME_RTX_3070_ADVANCED_OCV, 0x61);
|
||||
REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3060 Ti Advanced OC-V", DetectColorfulGPUControllers, NVIDIA_VEN, NVIDIA_RTX3060TI_LHR_DEV, COLORFUL_SUB_VEN, COLORFUL_IGAME_RTX_3060_TI_ADVANCED_OC, 0x61);
|
||||
REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3070 Advanced OC-V", DetectColorfulGPUControllers, NVIDIA_VEN, NVIDIA_RTX3070_DEV, COLORFUL_SUB_VEN, COLORFUL_IGAME_RTX_3070_ADVANCED_OCV, 0x61);
|
||||
REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3070 Advanced OC-V", DetectColorfulGPUControllers, NVIDIA_VEN, NVIDIA_RTX3070_DEV, COLORFUL_SUB_VEN, COLORFUL_IGAME_RTX_3070_ADVANCED_OCV2, 0x61);
|
||||
REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3070 Ultra W OC-V", DetectColorfulGPUControllers, NVIDIA_VEN, NVIDIA_RTX3070_DEV, COLORFUL_SUB_VEN, COLORFUL_IGAME_RTX_3070_ULTRAW_OC, 0x61);
|
||||
REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3070 Ultra W OC LHR", DetectColorfulGPUControllers, NVIDIA_VEN, NVIDIA_RTX3070_LHR_DEV, COLORFUL_SUB_VEN, COLORFUL_IGAME_RTX_3070_ULTRAW_OC, 0x61);
|
||||
REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3070 Ti Ultra W OC LHR", DetectColorfulGPUControllers, NVIDIA_VEN, NVIDIA_RTX3070TI_DEV, COLORFUL_SUB_VEN, COLORFUL_IGAME_RTX_3070_TI_ULTRAW_OC, 0x61);
|
||||
REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3070 Ti Advanced OC-V", DetectColorfulGPUControllers, NVIDIA_VEN, NVIDIA_RTX3070TI_DEV, COLORFUL_SUB_VEN, COLORFUL_IGAME_RTX_3070_TI_ADVANCED_OCV2, 0x61);
|
||||
REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 3080 Ti Advanced OC-V", DetectColorfulGPUControllers, NVIDIA_VEN, NVIDIA_RTX3080TI_DEV, COLORFUL_SUB_VEN, COLORFUL_IGAME_RTX_3080_TI_ADVANCED_OCV2, 0x61);
|
||||
REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 4070 Ti Advanced OC-V", DetectColorfulGPUControllers, NVIDIA_VEN, NVIDIA_RTX4070TI_DEV, COLORFUL_SUB_VEN, COLORFUL_IGAME_RTX_4070_TI_ADVANCED_OCV, 0x61);
|
||||
REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 4080 Ultra W OC-V", DetectColorfulGPUControllers, NVIDIA_VEN, NVIDIA_RTX4080_DEV, COLORFUL_SUB_VEN, COLORFUL_IGAME_RTX_4080_ULTRAW_OCV2, 0x61);
|
||||
@@ -1,82 +0,0 @@
|
||||
#include "RGBController_ColorfulGPU.h"
|
||||
#include <array>
|
||||
|
||||
/**------------------------------------------------------------------*\
|
||||
@name Colorful GPU
|
||||
@category GPU
|
||||
@type I2C
|
||||
@save :x:
|
||||
@direct :white_check_mark:
|
||||
@effects :x:
|
||||
@detectors DetectColorfulGPUControllers
|
||||
@comment This card only supports direct mode
|
||||
\*-------------------------------------------------------------------*/
|
||||
|
||||
RGBController_ColorfulGPU::RGBController_ColorfulGPU(ColorfulGPUController * colorful_gpu_ptr)
|
||||
{
|
||||
controller = colorful_gpu_ptr;
|
||||
name = "Colorful GPU Device";
|
||||
vendor = "Colorful";
|
||||
type = DEVICE_TYPE_GPU;
|
||||
description = name;
|
||||
location = controller->GetDeviceLocation();
|
||||
|
||||
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_ColorfulGPU::~RGBController_ColorfulGPU()
|
||||
{
|
||||
delete controller;
|
||||
}
|
||||
|
||||
void RGBController_ColorfulGPU::SetupZones()
|
||||
{
|
||||
zone new_zone;
|
||||
|
||||
new_zone.name = "GPU";
|
||||
new_zone.type = ZONE_TYPE_LINEAR;
|
||||
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);
|
||||
|
||||
leds.resize(new_zone.leds_count);
|
||||
leds[0].name = "GPU LED";
|
||||
|
||||
SetupColors();
|
||||
}
|
||||
|
||||
void RGBController_ColorfulGPU::ResizeZone(int /*zone*/, int /*new_size*/)
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
void RGBController_ColorfulGPU::DeviceUpdateLEDs()
|
||||
{
|
||||
controller->SetDirect(colors[0]);
|
||||
}
|
||||
|
||||
void RGBController_ColorfulGPU::UpdateZoneLEDs(int /*zone*/)
|
||||
{
|
||||
DeviceUpdateLEDs();
|
||||
}
|
||||
|
||||
void RGBController_ColorfulGPU::UpdateSingleLED(int /*led*/)
|
||||
{
|
||||
DeviceUpdateLEDs();
|
||||
}
|
||||
|
||||
void RGBController_ColorfulGPU::DeviceUpdateMode()
|
||||
{
|
||||
DeviceUpdateLEDs();
|
||||
}
|
||||
@@ -1,26 +0,0 @@
|
||||
#pragma once
|
||||
|
||||
#include "RGBController.h"
|
||||
#include "ColorfulGPUController.h"
|
||||
|
||||
class RGBController_ColorfulGPU : public RGBController
|
||||
{
|
||||
public:
|
||||
RGBController_ColorfulGPU(ColorfulGPUController* colorful_gpu_ptr);
|
||||
~RGBController_ColorfulGPU();
|
||||
|
||||
void SetupZones();
|
||||
void ResizeZone(int zone, int new_size);
|
||||
|
||||
void DeviceUpdateLEDs();
|
||||
void UpdateZoneLEDs(int zone);
|
||||
void UpdateSingleLED(int led);
|
||||
|
||||
void DeviceUpdateMode();
|
||||
|
||||
private:
|
||||
ColorfulGPUController* controller;
|
||||
|
||||
};
|
||||
|
||||
|
||||
@@ -1,144 +0,0 @@
|
||||
#include "ColorfulTuringGPUController.h"
|
||||
#include <cstring>
|
||||
|
||||
ColorfulTuringGPUController::ColorfulTuringGPUController(i2c_smbus_interface* bus, colorful_gpu_dev_id dev)
|
||||
{
|
||||
this->bus = bus;
|
||||
this->dev = dev;
|
||||
}
|
||||
|
||||
ColorfulTuringGPUController::~ColorfulTuringGPUController()
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
std::string ColorfulTuringGPUController::GetDeviceLocation()
|
||||
{
|
||||
std::string return_string(bus->device_name);
|
||||
char addr[5];
|
||||
snprintf(addr, 5, "0x%02X", dev);
|
||||
return_string.append(", address ");
|
||||
return_string.append(addr);
|
||||
return("I2C: " + return_string);
|
||||
}
|
||||
|
||||
int ColorfulTuringGPUController::GetMode()
|
||||
{
|
||||
uint8_t data_pkt[COLORFUL_MODE_PACKET_LENGTH];
|
||||
int size = COLORFUL_MODE_PACKET_LENGTH;
|
||||
bus->i2c_read_block(dev, &size, data_pkt);
|
||||
|
||||
int mode = data_pkt[2]<<16 | data_pkt[3]<<8 | data_pkt[4];
|
||||
|
||||
return mode;
|
||||
}
|
||||
|
||||
RGBColor ColorfulTuringGPUController::GetColor()
|
||||
{
|
||||
uint8_t data_pkt[COLORFUL_MODE_PACKET_LENGTH];
|
||||
int size = COLORFUL_MODE_PACKET_LENGTH;
|
||||
bus->i2c_read_block(dev, &size, data_pkt);
|
||||
|
||||
RGBColor color = ToRGBColor(data_pkt[5], data_pkt[6], data_pkt[7]);
|
||||
|
||||
return color;
|
||||
}
|
||||
|
||||
void ColorfulTuringGPUController::SetStateDisplay(RGBColor color)
|
||||
{
|
||||
uint8_t r = RGBGetRValue(color);
|
||||
uint8_t g = RGBGetGValue(color);
|
||||
uint8_t b = RGBGetBValue(color);
|
||||
uint8_t data_pkt[COLORFUL_COLOR_PACKET_LENGTH] = { 0x08, 0x01, 0x32, 0x04, r, g, b};
|
||||
|
||||
int crc = 1;
|
||||
|
||||
for(int i = 0; i < COLORFUL_COLOR_PACKET_LENGTH - 1; ++i)
|
||||
{
|
||||
crc += data_pkt[i];
|
||||
}
|
||||
crc &= 0xFF;
|
||||
crc = 256-crc;
|
||||
|
||||
data_pkt[COLORFUL_COLOR_PACKET_LENGTH - 1] = crc & 0xFF;
|
||||
|
||||
bus->i2c_write_block(dev, COLORFUL_COLOR_PACKET_LENGTH, data_pkt);
|
||||
}
|
||||
|
||||
void ColorfulTuringGPUController::SetDirect(RGBColor color)
|
||||
{
|
||||
uint8_t r = RGBGetRValue(color);
|
||||
uint8_t g = RGBGetGValue(color);
|
||||
uint8_t b = RGBGetBValue(color);
|
||||
uint8_t data_pkt[COLORFUL_COLOR_PACKET_LENGTH] = { 0x88, 0x02, 0x32, 0x02, r, g, b};
|
||||
|
||||
int crc = 1;
|
||||
|
||||
for(int i = 0; i < COLORFUL_COLOR_PACKET_LENGTH - 1; ++i)
|
||||
{
|
||||
crc += data_pkt[i];
|
||||
}
|
||||
crc &= 0xFF;
|
||||
crc = 256-crc;
|
||||
|
||||
data_pkt[COLORFUL_COLOR_PACKET_LENGTH - 1] = crc & 0xFF;
|
||||
|
||||
bus->i2c_write_block(dev, COLORFUL_COLOR_PACKET_LENGTH, data_pkt);
|
||||
}
|
||||
|
||||
void ColorfulTuringGPUController::SetBreathing(RGBColor color)
|
||||
{
|
||||
uint8_t r = RGBGetRValue(color);
|
||||
uint8_t g = RGBGetGValue(color);
|
||||
uint8_t b = RGBGetBValue(color);
|
||||
uint8_t data_pkt[COLORFUL_COLOR_PACKET_LENGTH] = { 0x88, 0x01, 0x32, 0x02, r, g, b};
|
||||
|
||||
int crc = 1;
|
||||
|
||||
for(int i = 0; i < COLORFUL_COLOR_PACKET_LENGTH - 1; ++i)
|
||||
{
|
||||
crc += data_pkt[i];
|
||||
}
|
||||
crc &= 0xFF;
|
||||
crc = 256-crc;
|
||||
|
||||
data_pkt[COLORFUL_COLOR_PACKET_LENGTH - 1] = crc & 0xFF;
|
||||
|
||||
bus->i2c_write_block(dev, COLORFUL_COLOR_PACKET_LENGTH, data_pkt);
|
||||
}
|
||||
|
||||
void ColorfulTuringGPUController::SetOff()
|
||||
{
|
||||
uint8_t data_pkt[COLORFUL_NON_COLOR_PACKET_LENGTH] = { 0x85, 0x00, 0x00, 0x0A };
|
||||
|
||||
int crc = 1;
|
||||
|
||||
for(int i = 0; i < COLORFUL_NON_COLOR_PACKET_LENGTH - 1; ++i)
|
||||
{
|
||||
crc += data_pkt[i];
|
||||
}
|
||||
crc &= 0xFF;
|
||||
crc = 256-crc;
|
||||
|
||||
data_pkt[COLORFUL_NON_COLOR_PACKET_LENGTH - 1] = crc & 0xFF;
|
||||
|
||||
bus->i2c_write_block(dev, COLORFUL_NON_COLOR_PACKET_LENGTH, data_pkt);
|
||||
}
|
||||
|
||||
void ColorfulTuringGPUController::SetRainbow()
|
||||
{
|
||||
uint8_t data_pkt[COLORFUL_NON_COLOR_PACKET_LENGTH] = { 0x85, 0x04, 0x32, 0x02 };
|
||||
|
||||
int crc = 1;
|
||||
|
||||
for(int i = 0; i < COLORFUL_NON_COLOR_PACKET_LENGTH - 1; ++i)
|
||||
{
|
||||
crc += data_pkt[i];
|
||||
}
|
||||
crc &= 0xFF;
|
||||
crc = 256-crc;
|
||||
|
||||
data_pkt[COLORFUL_NON_COLOR_PACKET_LENGTH - 1] = crc & 0xFF;
|
||||
|
||||
bus->i2c_write_block(dev, COLORFUL_NON_COLOR_PACKET_LENGTH, data_pkt);
|
||||
}
|
||||
@@ -1,41 +0,0 @@
|
||||
#include <string>
|
||||
#include "i2c_smbus.h"
|
||||
#include "RGBController.h"
|
||||
|
||||
#pragma once
|
||||
|
||||
typedef unsigned char colorful_gpu_dev_id;
|
||||
|
||||
#define COLORFUL_COLOR_PACKET_LENGTH 8
|
||||
#define COLORFUL_NON_COLOR_PACKET_LENGTH 5
|
||||
#define COLORFUL_MODE_PACKET_LENGTH 0x1B
|
||||
|
||||
enum
|
||||
{
|
||||
COLORFUL_TURING_GPU_RGB_MODE_STATE_DISPLAY = 0x013204,
|
||||
COLORFUL_TURING_GPU_RGB_MODE_OFF = 0x00000A,
|
||||
COLORFUL_TURING_GPU_RGB_MODE_STATIC = 0x023202,
|
||||
COLORFUL_TURING_GPU_RGB_MODE_RAINBOW = 0x043202,
|
||||
COLORFUL_TURING_GPU_RGB_MODE_BREATHING = 0x013202,
|
||||
};
|
||||
|
||||
class ColorfulTuringGPUController
|
||||
{
|
||||
public:
|
||||
ColorfulTuringGPUController(i2c_smbus_interface* bus, colorful_gpu_dev_id dev);
|
||||
~ColorfulTuringGPUController();
|
||||
|
||||
std::string GetDeviceLocation();
|
||||
int GetMode();
|
||||
RGBColor GetColor();
|
||||
void SetDirect(RGBColor color);
|
||||
void SetStateDisplay(RGBColor color);
|
||||
void SetBreathing(RGBColor color);
|
||||
void SetOff();
|
||||
void SetRainbow();
|
||||
|
||||
|
||||
private:
|
||||
i2c_smbus_interface * bus;
|
||||
colorful_gpu_dev_id dev;
|
||||
};
|
||||
@@ -1,23 +0,0 @@
|
||||
#include "Detector.h"
|
||||
#include "ColorfulTuringGPUController.h"
|
||||
#include "RGBController.h"
|
||||
#include "RGBController_ColorfulTuringGPU.h"
|
||||
#include "i2c_smbus.h"
|
||||
#include "pci_ids.h"
|
||||
#include <vector>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
void DetectColorfulTuringGPUControllers(i2c_smbus_interface* bus, uint8_t i2c_addr, const std::string& name)
|
||||
{
|
||||
if(bus->port_id == 1)
|
||||
{
|
||||
ColorfulTuringGPUController* controller = new ColorfulTuringGPUController(bus, i2c_addr);
|
||||
RGBController_ColorfulTuringGPU* rgb_controller = new RGBController_ColorfulTuringGPU(controller);
|
||||
rgb_controller->name = name;
|
||||
|
||||
ResourceManager::get()->RegisterRGBController(rgb_controller);
|
||||
}
|
||||
}
|
||||
|
||||
REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 2070 SUPER Advanced OC-V", DetectColorfulTuringGPUControllers, NVIDIA_VEN, NVIDIA_RTX2070S_OC_DEV, COLORFUL_SUB_VEN, COLORFUL_IGAME_RTX_2070_SUPER_ADVANCED_OCV, 0x50);
|
||||
@@ -1,145 +0,0 @@
|
||||
#include "RGBController_ColorfulTuringGPU.h"
|
||||
#include <array>
|
||||
|
||||
/**------------------------------------------------------------------*\
|
||||
@name Colorful GPU
|
||||
@category GPU
|
||||
@type I2C
|
||||
@save :x:
|
||||
@direct :white_check_mark:
|
||||
@effects :white_check_mark:
|
||||
@detectors DetectColorfulTuringGPUControllers
|
||||
@comment This card supports off, direct, rainbow and pulse mode.
|
||||
\*-------------------------------------------------------------------*/
|
||||
|
||||
RGBController_ColorfulTuringGPU::RGBController_ColorfulTuringGPU(ColorfulTuringGPUController * colorful_gpu_ptr)
|
||||
{
|
||||
controller = colorful_gpu_ptr;
|
||||
name = "Colorful GPU Device";
|
||||
vendor = "Colorful";
|
||||
type = DEVICE_TYPE_GPU;
|
||||
description = name;
|
||||
location = controller->GetDeviceLocation();
|
||||
|
||||
mode Off;
|
||||
Off.name = "Off";
|
||||
Off.value = COLORFUL_TURING_GPU_RGB_MODE_OFF;
|
||||
Off.flags = 0;
|
||||
Off.color_mode = MODE_COLORS_NONE;
|
||||
modes.push_back(Off);
|
||||
|
||||
mode Direct;
|
||||
Direct.name = "Direct";
|
||||
Direct.value = COLORFUL_TURING_GPU_RGB_MODE_STATIC;
|
||||
Direct.flags = MODE_FLAG_HAS_PER_LED_COLOR;
|
||||
Direct.color_mode = MODE_COLORS_PER_LED;
|
||||
modes.push_back(Direct);
|
||||
|
||||
mode StateDisplay;
|
||||
StateDisplay.name = "State Display";
|
||||
StateDisplay.value = COLORFUL_TURING_GPU_RGB_MODE_STATE_DISPLAY;
|
||||
StateDisplay.flags = MODE_FLAG_HAS_PER_LED_COLOR;
|
||||
StateDisplay.color_mode = MODE_COLORS_PER_LED;
|
||||
modes.push_back(StateDisplay);
|
||||
|
||||
mode Rainbow;
|
||||
Rainbow.name = "Spectrum Cycle";
|
||||
Rainbow.value = COLORFUL_TURING_GPU_RGB_MODE_RAINBOW;
|
||||
Rainbow.color_mode = MODE_COLORS_NONE;
|
||||
modes.push_back(Rainbow);
|
||||
|
||||
mode Breathing;
|
||||
Breathing.name = "Breathing";
|
||||
Breathing.value = COLORFUL_TURING_GPU_RGB_MODE_BREATHING;
|
||||
Breathing.flags = MODE_FLAG_HAS_PER_LED_COLOR;
|
||||
Breathing.color_mode = MODE_COLORS_PER_LED;
|
||||
modes.push_back(Breathing);
|
||||
|
||||
SetupZones();
|
||||
|
||||
// Initialize active mode
|
||||
active_mode = getModeIndex(controller->GetMode());
|
||||
colors[0] = controller->GetColor();
|
||||
|
||||
}
|
||||
|
||||
RGBController_ColorfulTuringGPU::~RGBController_ColorfulTuringGPU()
|
||||
{
|
||||
delete controller;
|
||||
}
|
||||
|
||||
int RGBController_ColorfulTuringGPU::getModeIndex(int mode_value)
|
||||
{
|
||||
for(std::size_t mode_index = 0; mode_index < modes.size(); mode_index++)
|
||||
{
|
||||
if (modes[mode_index].value == mode_value)
|
||||
{
|
||||
return mode_index;
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
void RGBController_ColorfulTuringGPU::SetupZones()
|
||||
{
|
||||
zone new_zone;
|
||||
|
||||
new_zone.name = "GPU";
|
||||
new_zone.type = ZONE_TYPE_LINEAR;
|
||||
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);
|
||||
|
||||
leds.resize(new_zone.leds_count);
|
||||
leds[0].name = "GPU LED";
|
||||
|
||||
SetupColors();
|
||||
}
|
||||
|
||||
void RGBController_ColorfulTuringGPU::ResizeZone(int /*zone*/, int /*new_size*/)
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
void RGBController_ColorfulTuringGPU::DeviceUpdateLEDs()
|
||||
{
|
||||
switch(modes[active_mode].value)
|
||||
{
|
||||
case COLORFUL_TURING_GPU_RGB_MODE_BREATHING:
|
||||
controller->SetBreathing(colors[0]);
|
||||
break;
|
||||
case COLORFUL_TURING_GPU_RGB_MODE_OFF:
|
||||
controller->SetOff();
|
||||
break;
|
||||
case COLORFUL_TURING_GPU_RGB_MODE_RAINBOW:
|
||||
controller->SetRainbow();
|
||||
break;
|
||||
case COLORFUL_TURING_GPU_RGB_MODE_STATE_DISPLAY:
|
||||
controller->SetStateDisplay(colors[0]);
|
||||
break;
|
||||
case COLORFUL_TURING_GPU_RGB_MODE_STATIC:
|
||||
controller->SetDirect(colors[0]);
|
||||
break;
|
||||
default:
|
||||
controller->SetDirect(colors[0]);
|
||||
}
|
||||
}
|
||||
|
||||
void RGBController_ColorfulTuringGPU::UpdateZoneLEDs(int /*zone*/)
|
||||
{
|
||||
DeviceUpdateLEDs();
|
||||
}
|
||||
|
||||
void RGBController_ColorfulTuringGPU::UpdateSingleLED(int /*led*/)
|
||||
{
|
||||
DeviceUpdateLEDs();
|
||||
}
|
||||
|
||||
void RGBController_ColorfulTuringGPU::DeviceUpdateMode()
|
||||
{
|
||||
DeviceUpdateLEDs();
|
||||
}
|
||||
@@ -1,25 +0,0 @@
|
||||
#pragma once
|
||||
|
||||
#include "RGBController.h"
|
||||
#include "ColorfulTuringGPUController.h"
|
||||
|
||||
class RGBController_ColorfulTuringGPU : public RGBController
|
||||
{
|
||||
public:
|
||||
RGBController_ColorfulTuringGPU(ColorfulTuringGPUController* colorful_gpu_ptr);
|
||||
~RGBController_ColorfulTuringGPU();
|
||||
|
||||
void SetupZones();
|
||||
void ResizeZone(int zone, int new_size);
|
||||
void DeviceUpdateLEDs();
|
||||
void UpdateZoneLEDs(int zone);
|
||||
void UpdateSingleLED(int led);
|
||||
void DeviceUpdateMode();
|
||||
|
||||
private:
|
||||
ColorfulTuringGPUController* controller;
|
||||
int getModeIndex(int mode_value);
|
||||
|
||||
};
|
||||
|
||||
|
||||
@@ -44,7 +44,6 @@
|
||||
\*-----------------------------------------------------*/
|
||||
#define COOLERMASTER_ARGB_PID 0x1011
|
||||
#define COOLERMASTER_ARGB_GEN2_A1_PID 0x0173
|
||||
#define COOLERMASTER_ARGB_GEN2_A1_V2_PID 0x01C9
|
||||
#define COOLERMASTER_SMALL_ARGB_PID 0x1000
|
||||
#define COOLERMASTER_RGB_PID 0x004F
|
||||
|
||||
@@ -94,7 +93,7 @@ void DetectCoolerMasterARGB(hid_device_info* info, const std::string&)
|
||||
}
|
||||
}
|
||||
|
||||
void DetectCoolerMasterARGBGen2A1(hid_device_info* info, const std::string& name)
|
||||
void DetectCoolerMasterARGBGen2A1(hid_device_info* info, const std::string&)
|
||||
{
|
||||
hid_device* dev = hid_open_path(info->path);
|
||||
|
||||
@@ -102,7 +101,7 @@ void DetectCoolerMasterARGBGen2A1(hid_device_info* info, const std::string& name
|
||||
{
|
||||
CMARGBGen2A1controller* controller = new CMARGBGen2A1controller(dev, *info);
|
||||
RGBController_CMARGBGen2A1Controller* rgb_controller = new RGBController_CMARGBGen2A1Controller(controller);
|
||||
rgb_controller->name = name;
|
||||
// Constructor sets the name
|
||||
ResourceManager::get()->RegisterRGBController(rgb_controller);
|
||||
}
|
||||
}
|
||||
@@ -213,7 +212,7 @@ void DetectCoolerMasterSmallARGB(hid_device_info* info, const std::string&)
|
||||
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 MK750", DetectCoolerMasterKeyboards, COOLERMASTER_VID, COOLERMASTER_MASTERKEYS_MK750_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);
|
||||
|
||||
@@ -222,7 +221,6 @@ REGISTER_HID_DETECTOR_IPU("Cooler Master SK650", DetectCooler
|
||||
\*-----------------------------------------------------*/
|
||||
REGISTER_HID_DETECTOR_IPU("Cooler Master ARGB", DetectCoolerMasterARGB, COOLERMASTER_VID, COOLERMASTER_ARGB_PID, 0, 0xFF00, 1);
|
||||
REGISTER_HID_DETECTOR_IPU("Cooler Master ARGB Gen 2 A1", DetectCoolerMasterARGBGen2A1, COOLERMASTER_VID, COOLERMASTER_ARGB_GEN2_A1_PID, 1, 0xFF01, 1);
|
||||
REGISTER_HID_DETECTOR_IPU("Cooler Master ARGB Gen 2 A1 V2", DetectCoolerMasterARGBGen2A1, COOLERMASTER_VID, COOLERMASTER_ARGB_GEN2_A1_V2_PID, 1, 0xFF01, 1);
|
||||
REGISTER_HID_DETECTOR_IPU("Cooler Master RGB", DetectCoolerMasterRGB, COOLERMASTER_VID, COOLERMASTER_RGB_PID, 1, 0xFF00, 1);
|
||||
REGISTER_HID_DETECTOR_IPU("Cooler Master Small ARGB", DetectCoolerMasterSmallARGB, COOLERMASTER_VID, COOLERMASTER_SMALL_ARGB_PID, 0, 0xFF00, 1);
|
||||
|
||||
|
||||
@@ -14,7 +14,7 @@
|
||||
|
||||
using namespace std::chrono_literals;
|
||||
|
||||
CorsairCommanderCoreController::CorsairCommanderCoreController(hid_device* dev_handle, const char* path, int pid)
|
||||
CorsairCommanderCoreController::CorsairCommanderCoreController(hid_device* dev_handle, const char* path)
|
||||
{
|
||||
dev = dev_handle;
|
||||
location = path;
|
||||
@@ -22,7 +22,6 @@ CorsairCommanderCoreController::CorsairCommanderCoreController(hid_device* dev_h
|
||||
controller_ready = 0;
|
||||
packet_size = CORSAIR_COMMANDER_CORE_PACKET_SIZE_V2;
|
||||
command_res_size = packet_size - 4;
|
||||
this->pid = pid;
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Initialize controller |
|
||||
@@ -63,15 +62,11 @@ void CorsairCommanderCoreController::InitController()
|
||||
version[2] = res[2];
|
||||
delete[] res;
|
||||
|
||||
if (pid == 0x0C1C && version[0] == 1)
|
||||
if(version[0] == 1)
|
||||
{
|
||||
packet_size = CORSAIR_COMMANDER_CORE_PACKET_SIZE_V1;
|
||||
command_res_size = packet_size - 4;
|
||||
}
|
||||
else if (pid == 0x0C32)
|
||||
{
|
||||
packet_size = CORSAIR_COMMANDER_CORE_PACKET_SIZE_V3;
|
||||
}
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Wake up device |
|
||||
|
||||
@@ -17,8 +17,6 @@
|
||||
|
||||
#define CORSAIR_COMMANDER_CORE_PACKET_SIZE_V1 1025 // First bit is the report bit
|
||||
#define CORSAIR_COMMANDER_CORE_PACKET_SIZE_V2 97 // First bit is the report bit
|
||||
#define CORSAIR_COMMANDER_CORE_PACKET_SIZE_V3 65 // First bit is the report bit
|
||||
|
||||
#define CORSAIR_COMMANDER_CORE_RGB_DATA_LENGTH 699
|
||||
#define CORSAIR_QL_FAN_ZONE_OFFSET 102
|
||||
#define CORSAIR_COMMANDER_CORE_NUM_CHANNELS 6
|
||||
@@ -31,7 +29,7 @@ enum
|
||||
class CorsairCommanderCoreController
|
||||
{
|
||||
public:
|
||||
CorsairCommanderCoreController(hid_device* dev_handle, const char* path, int pid);
|
||||
CorsairCommanderCoreController(hid_device* dev_handle, const char* path);
|
||||
~CorsairCommanderCoreController();
|
||||
|
||||
std::string GetFirmwareString();
|
||||
@@ -57,7 +55,6 @@ private:
|
||||
unsigned short int version[3] = {0, 0, 0};
|
||||
int packet_size;
|
||||
int command_res_size;
|
||||
int pid;
|
||||
std::chrono::time_point<std::chrono::steady_clock> last_commit_time;
|
||||
|
||||
void SendCommand(unsigned char command[2], unsigned char data[], unsigned short int data_len, unsigned char res[]);
|
||||
|
||||
@@ -14,7 +14,6 @@
|
||||
| Commander Core product IDs |
|
||||
\*-----------------------------------------------------*/
|
||||
#define CORSAIR_COMMANDER_CORE_PID 0x0C1C
|
||||
#define CORSAIR_COMMANDER_CORE2_PID 0x0C32
|
||||
|
||||
/******************************************************************************************\
|
||||
* *
|
||||
@@ -30,7 +29,7 @@ void DetectCorsairCapellixHIDControllers(hid_device_info* info, const std::strin
|
||||
|
||||
if(dev)
|
||||
{
|
||||
CorsairCommanderCoreController* controller = new CorsairCommanderCoreController(dev, info->path, info->product_id);
|
||||
CorsairCommanderCoreController* controller = new CorsairCommanderCoreController(dev, info->path);
|
||||
RGBController_CorsairCommanderCore* rgb_controller = new RGBController_CorsairCommanderCore(controller);
|
||||
|
||||
rgb_controller->name = name;
|
||||
@@ -39,5 +38,4 @@ void DetectCorsairCapellixHIDControllers(hid_device_info* info, const std::strin
|
||||
}
|
||||
}
|
||||
|
||||
REGISTER_HID_DETECTOR_IPU("Corsair Commander Core", DetectCorsairCapellixHIDControllers, CORSAIR_VID, CORSAIR_COMMANDER_CORE_PID, 0x00, 0xFF42, 0x01);
|
||||
REGISTER_HID_DETECTOR_IPU("Corsair Commander Core", DetectCorsairCapellixHIDControllers, CORSAIR_VID, CORSAIR_COMMANDER_CORE2_PID, 0x00, 0xFF42, 0x01);
|
||||
REGISTER_HID_DETECTOR_IPU("Corsair Commander Core", DetectCorsairCapellixHIDControllers, CORSAIR_VID, CORSAIR_COMMANDER_CORE_PID, 0x00, 0xFF42, 0x01);
|
||||
|
||||
+8
-8
@@ -13,22 +13,22 @@
|
||||
|
||||
using namespace std::chrono_literals;
|
||||
|
||||
CorsairDominatorPlatinumController::CorsairDominatorPlatinumController(i2c_smbus_interface *bus, corsair_dev_id dev, unsigned int leds_count)
|
||||
CorsairDominatorPlatinumController::CorsairDominatorPlatinumController(i2c_smbus_interface *bus, corsair_dev_id dev)
|
||||
{
|
||||
this->bus = bus;
|
||||
this->dev = dev;
|
||||
this->leds_count = leds_count;
|
||||
this->bus = bus;
|
||||
this->dev = dev;
|
||||
|
||||
led_data[0] = 0xc;
|
||||
}
|
||||
|
||||
CorsairDominatorPlatinumController::~CorsairDominatorPlatinumController()
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
unsigned int CorsairDominatorPlatinumController::GetLEDCount()
|
||||
std::string CorsairDominatorPlatinumController::GetDeviceName()
|
||||
{
|
||||
return leds_count;
|
||||
return "Corsair Dominator Platinum RGB";
|
||||
}
|
||||
|
||||
std::string CorsairDominatorPlatinumController::GetDeviceLocation()
|
||||
@@ -48,7 +48,7 @@ void CorsairDominatorPlatinumController::SetAllColors
|
||||
unsigned char blue
|
||||
)
|
||||
{
|
||||
for(unsigned int led = 0; led < leds_count; led++)
|
||||
for(unsigned int led = 0; led < CORSAIR_PLAT_LED_COUNT; led++)
|
||||
{
|
||||
SetLEDColor(led, red, green, blue);
|
||||
}
|
||||
@@ -62,7 +62,7 @@ void CorsairDominatorPlatinumController::SetLEDColor
|
||||
unsigned char blue
|
||||
)
|
||||
{
|
||||
if(led >= leds_count)
|
||||
if(led >= CORSAIR_PLAT_LED_COUNT)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
@@ -10,31 +10,35 @@
|
||||
|
||||
#include <string>
|
||||
#include "i2c_smbus.h"
|
||||
#define CORSAIR_DOMINATOR_PLATINUM_DATA_SIZE 38
|
||||
|
||||
#pragma once
|
||||
|
||||
typedef unsigned char corsair_dev_id;
|
||||
|
||||
#define CORSAIR_DOMINATOR_PLATINUM_NAME "Corsair Dominator Platinum"
|
||||
|
||||
class CorsairDominatorPlatinumController
|
||||
{
|
||||
public:
|
||||
CorsairDominatorPlatinumController(i2c_smbus_interface *bus, corsair_dev_id dev, unsigned int leds_count);
|
||||
CorsairDominatorPlatinumController(i2c_smbus_interface *bus, corsair_dev_id dev);
|
||||
~CorsairDominatorPlatinumController();
|
||||
|
||||
std::string GetDeviceName();
|
||||
std::string GetDeviceLocation();
|
||||
unsigned int GetLEDCount();
|
||||
|
||||
size_t GetLEDCount() { return CORSAIR_PLAT_LED_COUNT; }
|
||||
void SetAllColors(unsigned char red, unsigned char green, unsigned char blue);
|
||||
void SetLEDColor(unsigned int led, unsigned char red, unsigned char green, unsigned char blue);
|
||||
void ApplyColors();
|
||||
bool WaitReady();
|
||||
|
||||
private:
|
||||
unsigned char led_data[CORSAIR_DOMINATOR_PLATINUM_DATA_SIZE];
|
||||
static constexpr size_t CORSAIR_PLAT_LED_COUNT = 12;
|
||||
|
||||
unsigned char led_data[CORSAIR_PLAT_LED_COUNT * 3 + 2];
|
||||
|
||||
i2c_smbus_interface* bus;
|
||||
corsair_dev_id dev;
|
||||
unsigned int leds_count;
|
||||
|
||||
static unsigned char crc8(unsigned char init, unsigned char poly, unsigned char *data, unsigned char len);
|
||||
};
|
||||
|
||||
+6
-86
@@ -2,51 +2,15 @@
|
||||
#include "CorsairDominatorPlatinumController.h"
|
||||
#include "RGBController.h"
|
||||
#include "RGBController_CorsairDominatorPlatinum.h"
|
||||
#include "SettingsManager.h"
|
||||
#include "LogManager.h"
|
||||
|
||||
#include "i2c_smbus.h"
|
||||
#include "pci_ids.h"
|
||||
#include "LogManager.h"
|
||||
#include <vector>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
using namespace std::chrono_literals;
|
||||
|
||||
json corsair_dominator_models =
|
||||
{
|
||||
{
|
||||
"CMT",
|
||||
{
|
||||
{"name", "Corsair Dominator Platinum"},
|
||||
{"leds", 12}
|
||||
}
|
||||
},
|
||||
{
|
||||
"CMH",
|
||||
{
|
||||
{"name", "Corsair Vengeance Pro SL"},
|
||||
{"leds", 10}
|
||||
}
|
||||
},
|
||||
{
|
||||
"CMN",
|
||||
{
|
||||
{"name", "Corsair Vengeance RGB RT"},
|
||||
{"leds", 10}
|
||||
}
|
||||
},
|
||||
{
|
||||
"CMG",
|
||||
{
|
||||
{"name", "Corsair Vengeance RGB RS"},
|
||||
{"leds", 6}
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
#define CORSAIR_DOMINATOR_PLATINUM_NAME "Corsair Dominator Platinum"
|
||||
|
||||
bool TestForCorsairDominatorPlatinumController(i2c_smbus_interface *bus, unsigned char address)
|
||||
{
|
||||
int res = bus->i2c_smbus_write_quick(address, I2C_SMBUS_WRITE);
|
||||
@@ -91,65 +55,21 @@ bool TestForCorsairDominatorPlatinumController(i2c_smbus_interface *bus, unsigne
|
||||
|
||||
void DetectCorsairDominatorPlatinumControllers(std::vector<i2c_smbus_interface *> &busses)
|
||||
{
|
||||
SettingsManager* settings_manager = ResourceManager::get()->GetSettingsManager();
|
||||
|
||||
json corsair_dominator_settings = settings_manager->GetSettings("CorsairDominatorSettings");
|
||||
|
||||
if(!corsair_dominator_settings.contains("model"))
|
||||
{
|
||||
// Set default value
|
||||
corsair_dominator_settings["model"] = "CMT";
|
||||
settings_manager->SetSettings("CorsairDominatorSettings", corsair_dominator_settings);
|
||||
settings_manager->SaveSettings();
|
||||
}
|
||||
|
||||
std::string model = corsair_dominator_settings["model"];
|
||||
|
||||
for(unsigned int bus = 0; bus < busses.size(); bus++)
|
||||
{
|
||||
IF_DRAM_SMBUS(busses[bus]->pci_vendor, busses[bus]->pci_device)
|
||||
{
|
||||
LOG_DEBUG("[%s] Testing bus %d", CORSAIR_DOMINATOR_PLATINUM_NAME, bus);
|
||||
|
||||
std::vector<unsigned char> addresses;
|
||||
|
||||
for(unsigned char addr = 0x58; addr <= 0x5F; addr++)
|
||||
{
|
||||
addresses.push_back(addr);
|
||||
}
|
||||
|
||||
for(unsigned char addr = 0x18; addr <= 0x1F; addr++)
|
||||
{
|
||||
addresses.push_back(addr);
|
||||
}
|
||||
|
||||
for(unsigned char addr : addresses)
|
||||
{
|
||||
if(TestForCorsairDominatorPlatinumController(busses[bus], addr))
|
||||
{
|
||||
unsigned int leds;
|
||||
std::string name;
|
||||
|
||||
if(corsair_dominator_models.contains(model))
|
||||
{
|
||||
leds = corsair_dominator_models[model]["leds"];
|
||||
name = corsair_dominator_models[model]["name"];
|
||||
}
|
||||
else
|
||||
{
|
||||
leds = corsair_dominator_models["CMT"]["leds"];
|
||||
name = corsair_dominator_models["CMT"]["name"];
|
||||
}
|
||||
|
||||
LOG_DEBUG("[%s] Model: %s, Leds: %d", CORSAIR_DOMINATOR_PLATINUM_NAME, name.c_str(), leds);
|
||||
|
||||
CorsairDominatorPlatinumController* controller = new CorsairDominatorPlatinumController(busses[bus], addr, leds);
|
||||
RGBController_CorsairDominatorPlatinum* rgbcontroller = new RGBController_CorsairDominatorPlatinum(controller);
|
||||
rgbcontroller->name = name;
|
||||
|
||||
ResourceManager::get()->RegisterRGBController(rgbcontroller);
|
||||
CorsairDominatorPlatinumController* new_controller = new CorsairDominatorPlatinumController(busses[bus], addr);
|
||||
RGBController_CorsairDominatorPlatinum* new_rgbcontroller = new RGBController_CorsairDominatorPlatinum(new_controller);
|
||||
|
||||
ResourceManager::get()->RegisterRGBController(new_rgbcontroller);
|
||||
}
|
||||
|
||||
std::this_thread::sleep_for(10ms);
|
||||
}
|
||||
}
|
||||
@@ -160,4 +80,4 @@ void DetectCorsairDominatorPlatinumControllers(std::vector<i2c_smbus_interface *
|
||||
}
|
||||
} /* DetectCorsairDominatorPlatinumControllers() */
|
||||
|
||||
REGISTER_I2C_DETECTOR(CORSAIR_DOMINATOR_PLATINUM_NAME, DetectCorsairDominatorPlatinumControllers);
|
||||
REGISTER_I2C_DETECTOR("Corsair Dominator Platinum", DetectCorsairDominatorPlatinumControllers);
|
||||
|
||||
+7
-6
@@ -23,9 +23,10 @@ RGBController_CorsairDominatorPlatinum::RGBController_CorsairDominatorPlatinum(C
|
||||
{
|
||||
controller = controller_ptr;
|
||||
|
||||
name = controller->GetDeviceName();
|
||||
vendor = "Corsair";
|
||||
type = DEVICE_TYPE_DRAM;
|
||||
description = "Corsair RAM RGB Device";
|
||||
description = "Corsair Dominator Platinum RGB Device";
|
||||
location = controller->GetDeviceLocation();
|
||||
|
||||
mode Direct;
|
||||
@@ -54,7 +55,7 @@ void RGBController_CorsairDominatorPlatinum::SetupZones()
|
||||
| Set up zone |
|
||||
\*---------------------------------------------------------*/
|
||||
zone new_zone;
|
||||
new_zone.name = "Corsair RAM Zone";
|
||||
new_zone.name = "Corsair Platinum Zone";
|
||||
new_zone.type = ZONE_TYPE_LINEAR;
|
||||
new_zone.leds_min = controller->GetLEDCount();
|
||||
new_zone.leds_max = controller->GetLEDCount();
|
||||
@@ -67,10 +68,10 @@ void RGBController_CorsairDominatorPlatinum::SetupZones()
|
||||
\*---------------------------------------------------------*/
|
||||
for(std::size_t led_idx = 0; led_idx < zones[0].leds_count; led_idx++)
|
||||
{
|
||||
led new_led;
|
||||
new_led.name = "Corsair RAM LED ";
|
||||
new_led.name.append(std::to_string(led_idx));
|
||||
leds.push_back(new_led);
|
||||
led *new_led = new led();
|
||||
new_led->name = "Corsair Platinum LED ";
|
||||
new_led->name.append(std::to_string(led_idx));
|
||||
leds.push_back(*new_led);
|
||||
}
|
||||
|
||||
SetupColors();
|
||||
|
||||
@@ -1,91 +0,0 @@
|
||||
/*-----------------------------------------*\
|
||||
| CorsairHydro2Controller.cpp |
|
||||
| |
|
||||
| Controller for Corsair H100i v2 |
|
||||
| |
|
||||
| Tim Demand (tim.dmd) 1/10/2023 |
|
||||
\*-----------------------------------------*/
|
||||
|
||||
#include "CorsairHydro2Controller.h"
|
||||
#include <cstring>
|
||||
#include <iomanip>
|
||||
#include <sstream>
|
||||
|
||||
CorsairHydro2Controller::CorsairHydro2Controller(libusb_device_handle* dev_handle)
|
||||
{
|
||||
dev = dev_handle;
|
||||
|
||||
libusb_device_descriptor descriptor;
|
||||
libusb_get_device_descriptor(libusb_get_device(dev_handle), &descriptor);
|
||||
|
||||
std::stringstream location_stream;
|
||||
location_stream << std::hex << std::setfill('0') << std::setw(4) << descriptor.idVendor << ":" << std::hex << std::setfill('0') << std::setw(4) << descriptor.idProduct;
|
||||
location = location_stream.str();
|
||||
|
||||
SendInit();
|
||||
}
|
||||
|
||||
CorsairHydro2Controller::~CorsairHydro2Controller()
|
||||
{
|
||||
if(dev)
|
||||
{
|
||||
libusb_close(dev);
|
||||
}
|
||||
}
|
||||
|
||||
std::string CorsairHydro2Controller::GetLocation()
|
||||
{
|
||||
return("USB: " + location);
|
||||
}
|
||||
|
||||
void CorsairHydro2Controller::SetLED(std::vector<RGBColor>& colors)
|
||||
{
|
||||
unsigned char usb_buf[32];
|
||||
memset(usb_buf, 0, sizeof(usb_buf));
|
||||
int actual;
|
||||
|
||||
unsigned char led_enable = 0x01;
|
||||
|
||||
unsigned char rr = RGBGetRValue(colors[0]);
|
||||
unsigned char gg = RGBGetBValue(colors[0]);
|
||||
unsigned char bb = RGBGetGValue(colors[0]);
|
||||
|
||||
if((rr + gg + bb) == 0)
|
||||
{
|
||||
led_enable = 0x00; // needed because leds won't turn off completely if color is 00 00 00
|
||||
}
|
||||
|
||||
usb_buf[0] = 0x10;
|
||||
usb_buf[1] = rr;
|
||||
usb_buf[2] = bb;
|
||||
usb_buf[3] = gg;
|
||||
usb_buf[4] = 0x00;
|
||||
usb_buf[5] = 0xFF;
|
||||
usb_buf[6] = 0xFF;
|
||||
usb_buf[7] = 0xFF;
|
||||
usb_buf[8] = 0xFF;
|
||||
usb_buf[9] = 0xFF;
|
||||
usb_buf[10] = 0x00;
|
||||
usb_buf[11] = 0x0A;
|
||||
usb_buf[12] = 0x05;
|
||||
usb_buf[13] = led_enable;
|
||||
usb_buf[14] = 0x00;
|
||||
usb_buf[15] = 0x00;
|
||||
usb_buf[16] = 0x00;
|
||||
usb_buf[17] = 0x00;
|
||||
usb_buf[18] = 0x01;
|
||||
|
||||
libusb_bulk_transfer(dev, 0x02, usb_buf, 19, &actual, 1000);
|
||||
libusb_bulk_transfer(dev, 0x82, usb_buf, 32, &actual, 1000);
|
||||
if(actual != 32) SendInit(); // reinitialization after sleep
|
||||
}
|
||||
|
||||
void CorsairHydro2Controller::SendInit()
|
||||
{
|
||||
libusb_reset_device(dev); // needed for reinitialization after sleep
|
||||
|
||||
libusb_control_transfer(dev, 0x40, 0, 0xffff, 0x0000, NULL, 0, 0);
|
||||
libusb_control_transfer(dev, 0x40, 2, 0x0002, 0x0000, NULL, 0, 0);
|
||||
libusb_control_transfer(dev, 0x40, 1, 0x0002, 0x0000, NULL, 0, 0);
|
||||
libusb_control_transfer(dev, 0x40, 4, 0x0002, 0x0000, NULL, 0, 0);
|
||||
}
|
||||
@@ -1,35 +0,0 @@
|
||||
/*-----------------------------------------*\
|
||||
| CorsairHydro2Controller.h |
|
||||
| |
|
||||
| Controller for Corsair H100i v2 |
|
||||
| |
|
||||
| Tim Demand (tim.dmd) 1/10/2023 |
|
||||
\*-----------------------------------------*/
|
||||
|
||||
#include "RGBController.h"
|
||||
#include <vector>
|
||||
#ifdef __FreeBSD__
|
||||
#include <libusb.h>
|
||||
#else
|
||||
#include <libusb-1.0/libusb.h>
|
||||
#endif
|
||||
|
||||
#pragma once
|
||||
|
||||
class CorsairHydro2Controller
|
||||
{
|
||||
public:
|
||||
CorsairHydro2Controller(libusb_device_handle* dev_handle);
|
||||
~CorsairHydro2Controller();
|
||||
|
||||
std::string GetLocation();
|
||||
|
||||
void SetLED(std::vector<RGBColor>& colors);
|
||||
|
||||
private:
|
||||
libusb_device_handle* dev;
|
||||
std::string firmware_version;
|
||||
std::string location;
|
||||
|
||||
void SendInit();
|
||||
};
|
||||
@@ -1,51 +0,0 @@
|
||||
/*-----------------------------------------*\
|
||||
| CorsairHydro2ControllerDetect.cpp |
|
||||
| |
|
||||
| Detector for Corsair H100i v2 |
|
||||
| |
|
||||
| Tim Demand (tim.dmd) 1/10/2023 |
|
||||
\*-----------------------------------------*/
|
||||
|
||||
#include "Detector.h"
|
||||
#include "CorsairHydro2Controller.h"
|
||||
#include "RGBController.h"
|
||||
#include "RGBController_CorsairHydro2.h"
|
||||
#include <vector>
|
||||
#ifdef __FreeBSD__
|
||||
#include <libusb.h>
|
||||
#else
|
||||
#include <libusb-1.0/libusb.h>
|
||||
#endif
|
||||
|
||||
#define CORSAIR_VID 0x1B1C
|
||||
#define H100I_V2_PID 0x0C09
|
||||
|
||||
void DetectCorsairHydro2Controllers()
|
||||
{
|
||||
libusb_init(NULL);
|
||||
|
||||
#ifdef _WIN32
|
||||
libusb_set_option(NULL, LIBUSB_OPTION_USE_USBDK);
|
||||
#endif
|
||||
|
||||
libusb_device_handle* dev = libusb_open_device_with_vid_pid(NULL, CORSAIR_VID, H100I_V2_PID);
|
||||
|
||||
if(dev)
|
||||
{
|
||||
libusb_detach_kernel_driver(dev, 0);
|
||||
libusb_claim_interface(dev, 0);
|
||||
|
||||
CorsairHydro2Controller* controller = new CorsairHydro2Controller(dev);
|
||||
RGBController_CorsairHydro2* rgb_controller = new RGBController_CorsairHydro2(controller);
|
||||
rgb_controller->name = "Corsair H100i v2";
|
||||
|
||||
ResourceManager::get()->RegisterRGBController(rgb_controller);
|
||||
}
|
||||
}
|
||||
|
||||
REGISTER_DETECTOR("Corsair H100i v2", DetectCorsairHydro2Controllers);
|
||||
/*---------------------------------------------------------------------------------------------------------*\
|
||||
| Entries for dynamic UDEV rules |
|
||||
| |
|
||||
| DUMMY_DEVICE_DETECTOR("Corsair H100i v2", DetectCorsairHydro2Controllers, 0x1B1C, 0x0C09 ) |
|
||||
\*---------------------------------------------------------------------------------------------------------*/
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user