Compare commits
2
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
 Adam Honse
|
0083d45103 | ||
|
Adam Honse
|
a67430cf04 |
+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
|
||||
|
||||
|
||||
+1
-13
@@ -109,7 +109,6 @@ 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
|
||||
@@ -138,7 +137,6 @@ 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
|
||||
@@ -167,7 +165,6 @@ 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
|
||||
@@ -196,7 +193,6 @@ 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
|
||||
@@ -225,7 +221,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 +249,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 +278,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 +310,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
|
||||
@@ -570,8 +562,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:
|
||||
@@ -648,8 +638,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
|
||||
|
||||
#-----------------------------------------------------------------------#
|
||||
|
||||
@@ -74,6 +74,7 @@ CODEOWNERS @Calcprogrammer1
|
||||
/Controllers/NZXTHue2Controller/
|
||||
/Controllers/NZXTHuePlusController/
|
||||
/Controllers/NZXTKrakenController/
|
||||
/Controllers/OpenRazerController/
|
||||
/Controllers/PNYGPUController/
|
||||
/Controllers/PatriotViperController/
|
||||
/Controllers/PhilipsHueController/
|
||||
|
||||
@@ -3,6 +3,7 @@
|
||||
\*-----------------------------------------------------*/
|
||||
#include <hidapi/hidapi.h>
|
||||
#include "Detector.h"
|
||||
#include "LogManager.h"
|
||||
#include "RGBController.h"
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
@@ -30,5 +31,4 @@ void DetectA4TechMouseControllers(hid_device_info* info, const std::string& name
|
||||
}
|
||||
|
||||
REGISTER_HID_DETECTOR_IPU("Bloody W60 Pro", DetectA4TechMouseControllers, A4_TECH_VID, BLOODY_W60_PRO_PID, 2, 0xFF33, 0x0529);
|
||||
REGISTER_HID_DETECTOR_IPU("Bloody W90 Max", DetectA4TechMouseControllers, A4_TECH_VID, BLOODY_W90_MAX_PID, 2, 0xFF33, 0x053D);
|
||||
REGISTER_HID_DETECTOR_IPU("Bloody MP 50RS", DetectA4TechMouseControllers, A4_TECH_VID, BLOODY_MP_50RS_PID, 2, 0xFFF2, 0x6009);
|
||||
|
||||
@@ -8,7 +8,6 @@
|
||||
\*---------------------------------------------------------------------*/
|
||||
|
||||
#include "BloodyMouseController.h"
|
||||
#include "LogManager.h"
|
||||
|
||||
BloodyMouseController::BloodyMouseController(hid_device* dev_handle, const char* path, uint16_t product_id)
|
||||
{
|
||||
|
||||
@@ -9,6 +9,7 @@
|
||||
|
||||
#include <string>
|
||||
#include <hidapi/hidapi.h>
|
||||
#include "LogManager.h"
|
||||
#include "RGBController.h"
|
||||
|
||||
#pragma once
|
||||
@@ -17,7 +18,6 @@
|
||||
| Mouse product IDs |
|
||||
\*-----------------------------------------------------*/
|
||||
#define BLOODY_W60_PRO_PID 0x37EA
|
||||
#define BLOODY_W90_MAX_PID 0x3666
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Mousemat product IDs |
|
||||
|
||||
@@ -25,19 +25,6 @@ static const mouse_layout w60_pro
|
||||
}
|
||||
};
|
||||
|
||||
static const mouse_layout w90_max
|
||||
{
|
||||
{
|
||||
"Scroll Wheel", { 14 }
|
||||
},
|
||||
{
|
||||
"Logo", { 7 }
|
||||
},
|
||||
{
|
||||
"Rear", { 13, 12, 11, 10, 9, 8, 6, 5, 4, 3, 2, 1, 0 }
|
||||
}
|
||||
};
|
||||
|
||||
static const mouse_layout mp_50rs
|
||||
{
|
||||
{
|
||||
@@ -69,6 +56,7 @@ RGBController_BloodyMouse::RGBController_BloodyMouse(BloodyMouseController *cont
|
||||
type = DEVICE_TYPE_MOUSE;
|
||||
}
|
||||
|
||||
name = "BloodyMouse";
|
||||
vendor = "Bloody";
|
||||
description = "Controller compatible with the Bloody W60 Pro and MP 50RS";
|
||||
serial = controller->GetSerial();
|
||||
@@ -101,15 +89,11 @@ void RGBController_BloodyMouse::SetupZones()
|
||||
| Select layout from PID |
|
||||
\*-------------------------------------------------*/
|
||||
mouse_layout layout;
|
||||
|
||||
switch(controller->GetPid())
|
||||
{
|
||||
case BLOODY_W60_PRO_PID:
|
||||
layout = w60_pro;
|
||||
break;
|
||||
case BLOODY_W90_MAX_PID:
|
||||
layout = w90_max;
|
||||
break;
|
||||
case BLOODY_MP_50RS_PID:
|
||||
layout = mp_50rs;
|
||||
break;
|
||||
|
||||
@@ -9,6 +9,7 @@
|
||||
|
||||
#pragma once
|
||||
#include <vector>
|
||||
#include "LogManager.h"
|
||||
#include "RGBController.h"
|
||||
#include "BloodyMouseController.h"
|
||||
|
||||
|
||||
@@ -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;
|
||||
};
|
||||
@@ -12,7 +12,6 @@
|
||||
|
||||
#include "RGBController.h"
|
||||
#include "ResourceManager.h"
|
||||
#include "SettingsManager.h"
|
||||
#include "ASRockPolychromeUSBController.h"
|
||||
#include "dependencies/dmiinfo.h"
|
||||
|
||||
@@ -77,7 +76,7 @@ std::string PolychromeUSBController::GetSerialString()
|
||||
{
|
||||
return("");
|
||||
}
|
||||
|
||||
|
||||
std::wstring return_wstring = serial_string;
|
||||
std::string return_string(return_wstring.begin(), return_wstring.end());
|
||||
|
||||
@@ -214,13 +213,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,7 +234,7 @@ 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)
|
||||
@@ -263,7 +262,7 @@ void PolychromeUSBController::WriteZone
|
||||
|
||||
void PolychromeUSBController::WriteAllZones
|
||||
(
|
||||
const std::vector<PolychromeZoneInfo>& /*zones_info*/,
|
||||
const std::vector<PolychromeZoneInfo>& zones_info,
|
||||
const std::vector<zone>& zones
|
||||
)
|
||||
{
|
||||
@@ -435,7 +434,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,7 +446,7 @@ 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];
|
||||
|
||||
@@ -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 |
|
||||
|
||||
@@ -15,7 +15,6 @@
|
||||
#include <chrono>
|
||||
#include <algorithm>
|
||||
#include <sstream>
|
||||
#include "LogManager.h"
|
||||
|
||||
typedef uint32_t alienware_platform_id;
|
||||
|
||||
@@ -25,10 +24,8 @@ typedef uint32_t alienware_platform_id;
|
||||
\*---------------------------------------------------------*/
|
||||
static const std::map<alienware_platform_id, uint8_t> zone_quirks_table =
|
||||
{
|
||||
{ 0x0C01, 4 }, // Dell G5 SE 5505
|
||||
{ 0x0A01, 16 }, // Dell G7 15 7500
|
||||
{ 0x0E03, 4 } // Dell G15 5511
|
||||
|
||||
{ 0x0C01, 4 }, // Dell G5 SE 5505
|
||||
{ 0x0A01, 16 } // Dell G7 15 7500
|
||||
};
|
||||
|
||||
/*---------------------------------------------------------*\
|
||||
@@ -42,8 +39,7 @@ static const std::map<alienware_platform_id, std::vector<const char*>> zone_name
|
||||
"Light Bar 1", "Light Bar 2", "Light Bar 3",
|
||||
"Light Bar 4", "Light Bar 5", "Light Bar 6",
|
||||
"Light Bar 7", "Light Bar 8", "Light Bar 9",
|
||||
"Light Bar 10", "Light Bar 11", "Light Bar 12" } },
|
||||
{ 0x0E03, { "Left", "Middle", "Right", "Numpad" } }
|
||||
"Light Bar 10", "Light Bar 11", "Light Bar 12" } }
|
||||
};
|
||||
|
||||
static void SendHIDReport(hid_device *dev, const unsigned char* usb_buf, size_t usb_buf_size)
|
||||
@@ -117,13 +113,10 @@ AlienwareController::AlienwareController(hid_device* dev_handle, const hid_devic
|
||||
|
||||
if(zone_names_table.count(platform_id))
|
||||
{
|
||||
LOG_INFO("[%s] Known platform: %8X, Number of zones: %d", ALIENWARE_CONTROLLER_NAME, platform_id, number_of_zones);
|
||||
zone_names = zone_names_table.at(platform_id);
|
||||
}
|
||||
else
|
||||
{
|
||||
LOG_WARNING("[%s] Unknown platform: %8X, Number of zones: %d", ALIENWARE_CONTROLLER_NAME, platform_id, number_of_zones);
|
||||
|
||||
/*-------------------------------------------------*\
|
||||
| If this is an unknown controller, set the name of |
|
||||
| all regions to "Unknown" |
|
||||
|
||||
@@ -19,7 +19,7 @@
|
||||
|
||||
#define ALIENWARE_REPORT_SIZE 33
|
||||
#define HIDAPI_ALIENWARE_REPORT_SIZE (ALIENWARE_REPORT_SIZE + 1)
|
||||
#define ALIENWARE_CONTROLLER_NAME "AlienWare Controller"
|
||||
|
||||
enum
|
||||
{
|
||||
ALIENWARE_COMMAND_REPORT = 0x20, /* Set report type to get */
|
||||
|
||||
@@ -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 },
|
||||
|
||||
@@ -9,7 +9,6 @@
|
||||
#define ANNE_PRO_2_PID_2 0x8009
|
||||
#define ANNE_PRO_2_PID_3 0xA292
|
||||
#define ANNE_PRO_2_PID_4 0xA293
|
||||
#define ANNE_PRO_2_PID_5 0xA297
|
||||
|
||||
/******************************************************************************************\
|
||||
* *
|
||||
@@ -35,4 +34,3 @@ REGISTER_HID_DETECTOR_I("Anne Pro 2", DetectAnnePro2Controllers, ANNE_PRO_2_VID,
|
||||
REGISTER_HID_DETECTOR_I("Anne Pro 2", DetectAnnePro2Controllers, ANNE_PRO_2_VID, ANNE_PRO_2_PID_2, 1);
|
||||
REGISTER_HID_DETECTOR_I("Anne Pro 2", DetectAnnePro2Controllers, ANNE_PRO_2_VID, ANNE_PRO_2_PID_3, 1);
|
||||
REGISTER_HID_DETECTOR_I("Anne Pro 2", DetectAnnePro2Controllers, ANNE_PRO_2_VID, ANNE_PRO_2_PID_4, 1);
|
||||
REGISTER_HID_DETECTOR_I("Anne Pro 2", DetectAnnePro2Controllers, ANNE_PRO_2_VID, ANNE_PRO_2_PID_5, 1);
|
||||
|
||||
@@ -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 },
|
||||
|
||||
@@ -1,155 +0,0 @@
|
||||
/*-----------------------------------------*\
|
||||
| ArcticController.h |
|
||||
| |
|
||||
| Controller Interface for Arctic devices |
|
||||
| |
|
||||
| Armin Wolf (Wer-Wolf) 01/09/2023 |
|
||||
\*-----------------------------------------*/
|
||||
|
||||
#include "ArcticController.h"
|
||||
#include <cstring>
|
||||
|
||||
using namespace std::chrono_literals;
|
||||
|
||||
#define ARCTIC_COMMAND_SET_RGB 0x00
|
||||
#define ARCTIC_COMMAND_IDENTIFY 0x5C
|
||||
|
||||
#define ARCTIC_RESPONSE_BUFFER_LENGTH 15
|
||||
#define ARCTIC_RESPONSE_COMMAND_OFFSET 0
|
||||
#define ARCTIC_RESPONSE_DATA_OFFSET 1
|
||||
#define ARCTIC_RESPONSE_DATA_LENGTH 12
|
||||
#define ARCTIC_RESPONSE_XOR_CSUM_OFFSET 13
|
||||
#define ARCTIC_RESPONSE_ADD_CSUM_OFFSET 14
|
||||
|
||||
#define ARCTIC_COMMAND_BUFFER_LENGTH(payload_size) (sizeof(header) + 1 + payload_size)
|
||||
#define ARCTIC_COMMAND_COMMAND_OFFSET (sizeof(header))
|
||||
#define ARCTIC_COMMAND_PAYLOAD_OFFSET (sizeof(header) + 1)
|
||||
|
||||
const unsigned char header[] =
|
||||
{
|
||||
0x01,
|
||||
0x02,
|
||||
0x03,
|
||||
0xFF,
|
||||
0x05,
|
||||
0xFF,
|
||||
0x02,
|
||||
0x03
|
||||
};
|
||||
|
||||
const unsigned char identify_payload[] =
|
||||
{
|
||||
0x01,
|
||||
0xFE,
|
||||
0x01,
|
||||
0xFE
|
||||
};
|
||||
|
||||
ArcticController::ArcticController(const std::string &portname)
|
||||
: serialport(portname.c_str(), 250000, SERIAL_PORT_PARITY_NONE, SERIAL_PORT_SIZE_8, SERIAL_PORT_STOP_BITS_2, false)
|
||||
{
|
||||
port_name = portname;
|
||||
serialport.serial_set_dtr(true);
|
||||
}
|
||||
|
||||
ArcticController::~ArcticController()
|
||||
{
|
||||
serialport.serial_set_dtr(false);
|
||||
}
|
||||
|
||||
static void FormatCommandBuffer(char *buffer, char command)
|
||||
{
|
||||
std::memcpy(buffer, header, sizeof(header));
|
||||
buffer[ARCTIC_COMMAND_COMMAND_OFFSET] = command;
|
||||
}
|
||||
|
||||
void ArcticController::SetChannels(std::vector<RGBColor> colors)
|
||||
{
|
||||
char* buffer = new char[ARCTIC_COMMAND_BUFFER_LENGTH(colors.size() * 3)];
|
||||
|
||||
FormatCommandBuffer(buffer, ARCTIC_COMMAND_SET_RGB);
|
||||
|
||||
for(unsigned int channel = 0; channel < colors.size(); channel++)
|
||||
{
|
||||
const unsigned int offset = ARCTIC_COMMAND_PAYLOAD_OFFSET + channel * 3;
|
||||
|
||||
buffer[offset + 0x00] = std::min<unsigned int>(254, RGBGetRValue(colors[channel]));
|
||||
buffer[offset + 0x01] = std::min<unsigned int>(254, RGBGetGValue(colors[channel]));
|
||||
buffer[offset + 0x02] = std::min<unsigned int>(254, RGBGetBValue(colors[channel]));
|
||||
}
|
||||
|
||||
serialport.serial_write(buffer, sizeof(buffer));
|
||||
|
||||
delete[] buffer;
|
||||
}
|
||||
|
||||
static char XORChecksum(char *data, int length)
|
||||
{
|
||||
char sum = 0;
|
||||
|
||||
for(int i = 0; i < length; i++)
|
||||
{
|
||||
sum ^= data[i];
|
||||
}
|
||||
|
||||
return sum;
|
||||
}
|
||||
|
||||
static char AddChecksum(char *data, int length)
|
||||
{
|
||||
char sum = 0;
|
||||
|
||||
for(int i = 0; i < length; i++)
|
||||
{
|
||||
sum = (char)(sum + data[i]);
|
||||
}
|
||||
|
||||
return sum;
|
||||
}
|
||||
|
||||
bool ArcticController::IsPresent()
|
||||
{
|
||||
char buffer[ARCTIC_COMMAND_BUFFER_LENGTH(sizeof(identify_payload))];
|
||||
char response[ARCTIC_RESPONSE_BUFFER_LENGTH];
|
||||
int ret;
|
||||
|
||||
FormatCommandBuffer(buffer, ARCTIC_COMMAND_IDENTIFY);
|
||||
std::memcpy(buffer + ARCTIC_COMMAND_PAYLOAD_OFFSET, identify_payload, sizeof(identify_payload));
|
||||
|
||||
serialport.serial_flush_rx();
|
||||
ret = serialport.serial_write(buffer, sizeof(buffer));
|
||||
if(ret != sizeof(buffer))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
std::this_thread::sleep_for(100ms);
|
||||
|
||||
ret = serialport.serial_read(response, sizeof(response));
|
||||
if(ret != sizeof(response))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
if(response[ARCTIC_RESPONSE_COMMAND_OFFSET] != ARCTIC_COMMAND_IDENTIFY)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
if(response[ARCTIC_RESPONSE_XOR_CSUM_OFFSET] != XORChecksum(&response[ARCTIC_RESPONSE_DATA_OFFSET], ARCTIC_RESPONSE_DATA_LENGTH))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
if(response[ARCTIC_RESPONSE_ADD_CSUM_OFFSET] != AddChecksum(&response[ARCTIC_RESPONSE_DATA_OFFSET], ARCTIC_RESPONSE_DATA_LENGTH))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
std::string ArcticController::GetLocation()
|
||||
{
|
||||
return port_name;
|
||||
}
|
||||
@@ -1,29 +0,0 @@
|
||||
/*-----------------------------------------*\
|
||||
| ArcticController.h |
|
||||
| |
|
||||
| Controller Interface for Arctic devices |
|
||||
| |
|
||||
| Armin Wolf (Wer-Wolf) 01/09/2023 |
|
||||
\*-----------------------------------------*/
|
||||
|
||||
#pragma once
|
||||
#include <algorithm>
|
||||
|
||||
#include "RGBController.h"
|
||||
#include "serial_port.h"
|
||||
|
||||
class ArcticController
|
||||
{
|
||||
public:
|
||||
ArcticController(const std::string &portname);
|
||||
~ArcticController();
|
||||
|
||||
void SetChannels(std::vector<RGBColor> colors);
|
||||
bool IsPresent();
|
||||
|
||||
std::string GetLocation();
|
||||
|
||||
private:
|
||||
std::string port_name;
|
||||
serial_port serialport;
|
||||
};
|
||||
@@ -1,48 +0,0 @@
|
||||
/*-----------------------------------------*\
|
||||
| ArcticControllerDetect.cpp |
|
||||
| |
|
||||
| Detect Arctic RGB controllers |
|
||||
| |
|
||||
| Armin Wolf (Wer-Wolf) 01/09/2023 |
|
||||
\*-----------------------------------------*/
|
||||
|
||||
#include "Detector.h"
|
||||
#include "ArcticController.h"
|
||||
#include "RGBController.h"
|
||||
#include "RGBController_Arctic.h"
|
||||
#include "find_usb_serial_port.h"
|
||||
#include <vector>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
#define CH341_VID 0x1A86
|
||||
#define CH341_PID 0x7523
|
||||
|
||||
void DetectArcticControllers()
|
||||
{
|
||||
std::vector<std::string *> ports = find_usb_serial_port(CH341_VID, CH341_PID);
|
||||
|
||||
for(unsigned int device = 0; device < ports.size(); device++)
|
||||
{
|
||||
ArcticController *controller = new ArcticController(*ports[device]);
|
||||
|
||||
if(controller->IsPresent())
|
||||
{
|
||||
RGBController_Arctic *rgb_controller = new RGBController_Arctic(controller);
|
||||
ResourceManager::get()->RegisterRGBController(rgb_controller);
|
||||
}
|
||||
else
|
||||
{
|
||||
delete controller;
|
||||
}
|
||||
|
||||
delete ports[device];
|
||||
}
|
||||
}
|
||||
|
||||
REGISTER_DETECTOR("Arctic RGB controller", DetectArcticControllers);
|
||||
/*---------------------------------------------------------------------------------------------------------*\
|
||||
| Entries for dynamic UDEV rules |
|
||||
| |
|
||||
| DUMMY_DEVICE_DETECTOR("Arctic RGB controller", DetectArcticControllers, 0x1a86, 0x7523 ) |
|
||||
\*---------------------------------------------------------------------------------------------------------*/
|
||||
@@ -1,131 +0,0 @@
|
||||
/*-----------------------------------------*\
|
||||
| RGBController_Arctic.h |
|
||||
| |
|
||||
| Generic RGB Interface for Arctic devices |
|
||||
| |
|
||||
| Armin Wolf (Wer-Wolf) 01/09/2023 |
|
||||
\*-----------------------------------------*/
|
||||
|
||||
#include "RGBController_Arctic.h"
|
||||
#include <math.h>
|
||||
|
||||
using namespace std::chrono_literals;
|
||||
|
||||
#define ARCTIC_NUM_CHANNELS 4
|
||||
#define ARCTIC_SLEEP_THRESHOLD 100ms
|
||||
#define ARCTIC_KEEPALIVE_PERIOD 500ms /* Device requires at least 1s */
|
||||
|
||||
/**------------------------------------------------------------------*\
|
||||
@name Arctic RGB Controller Devices
|
||||
@category LEDStrip
|
||||
@type Serial
|
||||
@save :x:
|
||||
@direct :white_check_mark:
|
||||
@effects :x:
|
||||
@detectors DetectArcticControllers
|
||||
@comment
|
||||
\*-------------------------------------------------------------------*/
|
||||
|
||||
RGBController_Arctic::RGBController_Arctic(ArcticController* controller_ptr)
|
||||
{
|
||||
controller = controller_ptr;
|
||||
|
||||
name = "Arctic RGB Controller";
|
||||
vendor = "Arctic";
|
||||
description = "Arctic 4-Channel RGB Controller";
|
||||
location = controller->GetLocation();
|
||||
type = DEVICE_TYPE_LEDSTRIP;
|
||||
|
||||
mode DirectMode;
|
||||
DirectMode.name = "Direct";
|
||||
DirectMode.value = 0;
|
||||
DirectMode.flags = MODE_FLAG_HAS_PER_LED_COLOR;
|
||||
DirectMode.color_mode = MODE_COLORS_PER_LED;
|
||||
|
||||
modes.push_back(DirectMode);
|
||||
|
||||
SetupZones();
|
||||
|
||||
keepalive_thread_run = true;
|
||||
keepalive_thread = std::thread(&RGBController_Arctic::KeepaliveThreadFunction, this);
|
||||
}
|
||||
|
||||
RGBController_Arctic::~RGBController_Arctic()
|
||||
{
|
||||
keepalive_thread_run = false;
|
||||
keepalive_thread.join();
|
||||
delete controller;
|
||||
}
|
||||
|
||||
void RGBController_Arctic::SetupZones()
|
||||
{
|
||||
for(int channel = 0; channel < ARCTIC_NUM_CHANNELS; channel++)
|
||||
{
|
||||
zone LedZone;
|
||||
LedZone.name = "LED Strip " + std::to_string(channel);
|
||||
LedZone.type = ZONE_TYPE_SINGLE;
|
||||
LedZone.leds_count = 1;
|
||||
LedZone.leds_min = 1;
|
||||
LedZone.leds_max = 1;
|
||||
LedZone.matrix_map = nullptr;
|
||||
|
||||
led Led;
|
||||
Led.name = LedZone.name + " LED";
|
||||
Led.value = channel;
|
||||
|
||||
zones.push_back(LedZone);
|
||||
leds.push_back(Led);
|
||||
}
|
||||
|
||||
SetupColors();
|
||||
}
|
||||
|
||||
void RGBController_Arctic::ResizeZone(int /* zone */, int /* new_size */)
|
||||
{
|
||||
/*---------------------------------------------------------*\
|
||||
| This device does not support resizing zones |
|
||||
\*---------------------------------------------------------*/
|
||||
}
|
||||
|
||||
void RGBController_Arctic::DeviceUpdateLEDs()
|
||||
{
|
||||
last_update_time = std::chrono::steady_clock::now();
|
||||
|
||||
controller->SetChannels(colors);
|
||||
}
|
||||
|
||||
void RGBController_Arctic::UpdateZoneLEDs(int /* zone */)
|
||||
{
|
||||
DeviceUpdateLEDs();
|
||||
}
|
||||
|
||||
void RGBController_Arctic::UpdateSingleLED(int /* led */)
|
||||
{
|
||||
DeviceUpdateLEDs();
|
||||
}
|
||||
|
||||
void RGBController_Arctic::DeviceUpdateMode()
|
||||
{
|
||||
/*---------------------------------------------------------*\
|
||||
| This device does not support mode updates |
|
||||
\*---------------------------------------------------------*/
|
||||
}
|
||||
|
||||
void RGBController_Arctic::KeepaliveThreadFunction()
|
||||
{
|
||||
std::chrono::nanoseconds sleep_time;
|
||||
|
||||
while(keepalive_thread_run.load())
|
||||
{
|
||||
sleep_time = ARCTIC_KEEPALIVE_PERIOD - (std::chrono::steady_clock::now() - last_update_time);
|
||||
if(sleep_time <= ARCTIC_SLEEP_THRESHOLD)
|
||||
{
|
||||
UpdateLEDs(); // Already protected thru a device update thread
|
||||
std::this_thread::sleep_for(ARCTIC_KEEPALIVE_PERIOD);
|
||||
}
|
||||
else
|
||||
{
|
||||
std::this_thread::sleep_for(sleep_time);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -55,4 +55,3 @@ REGISTER_HID_DETECTOR ("ASUS Aura Core", DetectAsusAuraCoreContro
|
||||
REGISTER_HID_DETECTOR ("ASUS Aura Core", DetectAsusAuraCoreControllers, AURA_CORE_VID, 0x1866);
|
||||
REGISTER_HID_DETECTOR ("ASUS Aura Core", DetectAsusAuraCoreControllers, AURA_CORE_VID, 0x1869);
|
||||
REGISTER_HID_DETECTOR_PU("ASUS ROG Strix SCAR 15", DetectAsusAuraCoreLaptopControllers, AURA_CORE_VID, AURA_STRIX_SCAR_15_PID, 0xFF31, 0x79);
|
||||
REGISTER_HID_DETECTOR_PU("ASUS ROG Strix SCAR 17", DetectAsusAuraCoreLaptopControllers, AURA_CORE_VID, 0x1866, 0xFF31, 0x79);
|
||||
|
||||
@@ -9,8 +9,6 @@
|
||||
|
||||
#include "AsusAuraCoreLaptopController.h"
|
||||
|
||||
#include "SettingsManager.h"
|
||||
|
||||
static uint8_t packet_map[ASUSAURACORELAPTOP_KEYCOUNT +
|
||||
ASUSAURACORELAPTOP_LIGHTBARCOUNT +
|
||||
ASUSAURACORELAPTOP_LIDCOUNT ] =
|
||||
|
||||
@@ -13,6 +13,7 @@
|
||||
#include "LogManager.h"
|
||||
#include "RGBController.h"
|
||||
#include "ResourceManager.h"
|
||||
#include "SettingsManager.h"
|
||||
#include "RGBControllerKeyNames.h"
|
||||
|
||||
#pragma once
|
||||
|
||||
@@ -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);
|
||||
}
|
||||
|
||||
|
||||
@@ -131,6 +131,5 @@ REGISTER_I2C_PCI_DETECTOR("ASUS ROG STRIX RX470 O4G Gaming" , DetectAs
|
||||
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);
|
||||
|
||||
@@ -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});
|
||||
}
|
||||
}
|
||||
|
||||
@@ -86,24 +81,11 @@ void AuraMainboardController::SetMode
|
||||
unsigned char grn,
|
||||
unsigned char blu
|
||||
)
|
||||
{
|
||||
SetMode(channel, mode, red, grn, blu, false);
|
||||
}
|
||||
|
||||
void AuraMainboardController::SetMode
|
||||
(
|
||||
unsigned char channel,
|
||||
unsigned char mode,
|
||||
unsigned char red,
|
||||
unsigned char grn,
|
||||
unsigned char blu,
|
||||
bool shutdown_effect
|
||||
)
|
||||
{
|
||||
this->mode = mode;
|
||||
RGBColor color = ToRGBColor(red, grn, blu);
|
||||
|
||||
SendEffect(device_info[channel].effect_channel, mode, shutdown_effect);
|
||||
SendEffect(device_info[channel].effect_channel, mode);
|
||||
if(mode == AURA_MODE_DIRECT)
|
||||
{
|
||||
return;
|
||||
@@ -129,8 +111,7 @@ void AuraMainboardController::SetMode
|
||||
channel,
|
||||
start_led,
|
||||
device_info[channel].num_leds,
|
||||
led_data,
|
||||
shutdown_effect
|
||||
led_data
|
||||
);
|
||||
}
|
||||
|
||||
@@ -142,8 +123,7 @@ unsigned short AuraMainboardController::GetMask(int start, int size)
|
||||
void AuraMainboardController::SendEffect
|
||||
(
|
||||
unsigned char channel,
|
||||
unsigned char mode,
|
||||
bool shutdown_effect
|
||||
unsigned char mode
|
||||
)
|
||||
{
|
||||
unsigned char usb_buf[65];
|
||||
@@ -160,7 +140,7 @@ void AuraMainboardController::SendEffect
|
||||
usb_buf[0x01] = AURA_MAINBOARD_CONTROL_MODE_EFFECT;
|
||||
usb_buf[0x02] = channel;
|
||||
usb_buf[0x03] = 0x00;
|
||||
usb_buf[0x04] = shutdown_effect ? 0x01 : 0x00;
|
||||
usb_buf[0x04] = 0x00;
|
||||
usb_buf[0x05] = mode;
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
@@ -174,8 +154,7 @@ void AuraMainboardController::SendColor
|
||||
unsigned char /*channel*/,
|
||||
unsigned char start_led,
|
||||
unsigned char led_count,
|
||||
unsigned char* led_data,
|
||||
bool shutdown_effect
|
||||
unsigned char* led_data
|
||||
)
|
||||
{
|
||||
unsigned short mask = GetMask(start_led, led_count);
|
||||
@@ -193,7 +172,7 @@ void AuraMainboardController::SendColor
|
||||
usb_buf[0x01] = AURA_MAINBOARD_CONTROL_MODE_EFFECT_COLOR;
|
||||
usb_buf[0x02] = mask >> 8;
|
||||
usb_buf[0x03] = mask & 0xff;
|
||||
usb_buf[0x04] = shutdown_effect ? 0x01 : 0x00;
|
||||
usb_buf[0x04] = 0x00;
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Copy in color data bytes |
|
||||
|
||||
@@ -44,28 +44,15 @@ public:
|
||||
unsigned char blu
|
||||
);
|
||||
|
||||
void SetMode
|
||||
(
|
||||
unsigned char channel,
|
||||
unsigned char mode,
|
||||
unsigned char red,
|
||||
unsigned char grn,
|
||||
unsigned char blu,
|
||||
bool shutdown_effect
|
||||
);
|
||||
|
||||
void SendCommit();
|
||||
|
||||
private:
|
||||
unsigned int mode;
|
||||
|
||||
unsigned short GetMask(int start, int size);
|
||||
|
||||
|
||||
void SendEffect
|
||||
(
|
||||
unsigned char channel,
|
||||
unsigned char mode,
|
||||
bool shutdown_effect
|
||||
unsigned char mode
|
||||
);
|
||||
|
||||
void SendColor
|
||||
@@ -73,7 +60,8 @@ private:
|
||||
unsigned char channel,
|
||||
unsigned char start_led,
|
||||
unsigned char led_count,
|
||||
unsigned char* led_data,
|
||||
bool shutdown_effect
|
||||
unsigned char* led_data
|
||||
);
|
||||
|
||||
void SendCommit();
|
||||
};
|
||||
|
||||
@@ -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,
|
||||
};
|
||||
|
||||
|
||||
|
||||
@@ -27,9 +27,6 @@
|
||||
#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_SPATHA_X_DOCK_PID 0x1979
|
||||
#define AURA_ROG_PUGIO_PID 0x1846
|
||||
#define AURA_ROG_PUGIO_II_WIRED_PID 0x1906
|
||||
#define AURA_ROG_PUGIO_II_WIRELESS_PID 0x1908
|
||||
@@ -47,15 +44,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
|
||||
@@ -189,7 +183,7 @@ static std::map<int,mouse_type> aura_mouse_devices =
|
||||
255,
|
||||
1,
|
||||
0,
|
||||
100,
|
||||
64,
|
||||
false,
|
||||
1,
|
||||
{ AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
|
||||
@@ -202,7 +196,7 @@ static std::map<int,mouse_type> aura_mouse_devices =
|
||||
255,
|
||||
1,
|
||||
0,
|
||||
100,
|
||||
64,
|
||||
false,
|
||||
1,
|
||||
{ AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
|
||||
@@ -215,7 +209,7 @@ static std::map<int,mouse_type> aura_mouse_devices =
|
||||
255,
|
||||
1,
|
||||
0,
|
||||
100,
|
||||
64,
|
||||
true,
|
||||
1,
|
||||
{ AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
|
||||
@@ -228,7 +222,7 @@ static std::map<int,mouse_type> aura_mouse_devices =
|
||||
255,
|
||||
1,
|
||||
0,
|
||||
100,
|
||||
64,
|
||||
true,
|
||||
1,
|
||||
{ AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
|
||||
@@ -277,12 +271,12 @@ static std::map<int,mouse_type> aura_mouse_devices =
|
||||
{
|
||||
AURA_ROG_CHAKRAM_X_USB_PID, // ROG Chakram X USB
|
||||
{
|
||||
15, // technically until 255, but unusably slow after 15
|
||||
1,
|
||||
0,
|
||||
100,
|
||||
0,
|
||||
0,
|
||||
4,
|
||||
false,
|
||||
2,
|
||||
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 }
|
||||
}
|
||||
@@ -290,42 +284,16 @@ static std::map<int,mouse_type> aura_mouse_devices =
|
||||
{
|
||||
AURA_ROG_CHAKRAM_X_2_4_PID, // ROG Chakram X 2.4GHz Dongle
|
||||
{
|
||||
15, // technically until 255, but unusably slow after 15
|
||||
255,
|
||||
1,
|
||||
0,
|
||||
100,
|
||||
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,
|
||||
100,
|
||||
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,
|
||||
100,
|
||||
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
|
||||
{
|
||||
@@ -375,7 +343,7 @@ static std::map<int,mouse_type> aura_mouse_devices =
|
||||
false,
|
||||
4,
|
||||
{ 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 }
|
||||
}
|
||||
},
|
||||
{
|
||||
@@ -534,17 +502,4 @@ 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_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,12 @@
|
||||
#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, unsigned short rev_version)
|
||||
{
|
||||
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);
|
||||
version = rev_version;
|
||||
}
|
||||
|
||||
AuraTUFKeyboardController::~AuraTUFKeyboardController()
|
||||
@@ -37,26 +35,6 @@ std::string AuraTUFKeyboardController::GetDeviceLocation()
|
||||
return("HID: " + location);
|
||||
}
|
||||
|
||||
std::string clean_serial(const std::wstring& wstr)
|
||||
{
|
||||
// Skip non-ASCII, trailing garbage in serial numbers. Required by the
|
||||
// Scope II 96, whose original firmware outputs garbage, which even differs
|
||||
// after computer reboots and therefore breaks OpenRGB profile matching.
|
||||
std::string result;
|
||||
for(auto c : wstr)
|
||||
{
|
||||
// Forbid control chars and anything above final printable low-ASCII.
|
||||
if(c < 32 || c > 126)
|
||||
{
|
||||
break;
|
||||
}
|
||||
|
||||
result += c;
|
||||
}
|
||||
|
||||
return(result);
|
||||
}
|
||||
|
||||
std::string AuraTUFKeyboardController::GetSerialString()
|
||||
{
|
||||
wchar_t serial_string[128];
|
||||
@@ -67,8 +45,8 @@ std::string AuraTUFKeyboardController::GetSerialString()
|
||||
return("");
|
||||
}
|
||||
|
||||
std::wstring serial_wstring = serial_string;
|
||||
std::string return_string = clean_serial(serial_wstring);
|
||||
std::wstring return_wstring = serial_string;
|
||||
std::string return_string(return_wstring.begin(), return_wstring.end());
|
||||
|
||||
return(return_string);
|
||||
}
|
||||
@@ -92,16 +70,13 @@ std::string AuraTUFKeyboardController::GetVersion()
|
||||
hid_read(dev, usb_buf_out, 65);
|
||||
|
||||
char version[9];
|
||||
|
||||
switch(device_pid)
|
||||
if(device_pid == AURA_TUF_K3_GAMING_PID)
|
||||
{
|
||||
case AURA_TUF_K3_GAMING_PID:
|
||||
case AURA_ROG_STRIX_FLARE_II_ANIMATE_PID:
|
||||
case AURA_ROG_STRIX_SCOPE_II_96_WIRELESS_USB_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]);
|
||||
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);
|
||||
@@ -161,7 +136,13 @@ int AuraTUFKeyboardController::GetLayout()
|
||||
}
|
||||
else
|
||||
{
|
||||
switch(rev_version >> 0b1100)
|
||||
char layout[4];
|
||||
|
||||
snprintf(layout, 4, "%X", version);
|
||||
|
||||
int layoutnum = std::stoi(std::string(layout, 1));
|
||||
|
||||
switch(layoutnum)
|
||||
{
|
||||
case 1:
|
||||
return 117;
|
||||
@@ -286,63 +267,17 @@ void AuraTUFKeyboardController::UpdateLeds
|
||||
|
||||
for(int j = 0; j < leds; j++)
|
||||
{
|
||||
usb_buf[j * 4 + 5] = (is_per_led_keyboard) ? colors[i * 15 + j].value : 0x00;
|
||||
usb_buf[j * 4 + 5] = colors[i * 15 + j].value;
|
||||
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);
|
||||
}
|
||||
|
||||
ClearResponses();
|
||||
hid_write(dev, usb_buf, 65);
|
||||
AwaitResponse(20);
|
||||
}
|
||||
}
|
||||
|
||||
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,
|
||||
@@ -353,11 +288,6 @@ void AuraTUFKeyboardController::UpdateDevice
|
||||
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));
|
||||
|
||||
@@ -373,79 +303,41 @@ void AuraTUFKeyboardController::UpdateDevice
|
||||
usb_buf[0x06] = brightness;
|
||||
usb_buf[0x07] = color_mode;
|
||||
usb_buf[0x08] = direction;
|
||||
usb_buf[0x09] = 0x02;
|
||||
|
||||
if(is_per_led_keyboard)
|
||||
if(mode == AURA_KEYBOARD_MODE_WAVE || mode == AURA_KEYBOARD_MODE_RIPPLE)
|
||||
{
|
||||
usb_buf[0x09] = 0x02;
|
||||
usb_buf[0x0A] = colors.size();
|
||||
|
||||
if(mode == AURA_KEYBOARD_MODE_WAVE || mode == AURA_KEYBOARD_MODE_RIPPLE)
|
||||
/*-----------------------------------------------------*\
|
||||
| Loop over every color given |
|
||||
\*-----------------------------------------------------*/
|
||||
for(unsigned int i = 0; i < colors.size(); i ++)
|
||||
{
|
||||
usb_buf[0x0A] = colors.size();
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Loop over every color given |
|
||||
\*-----------------------------------------------------*/
|
||||
for(unsigned int i = 0; i < colors.size(); i ++)
|
||||
if(colors[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]);
|
||||
}
|
||||
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)
|
||||
/*-----------------------------------------------------*\
|
||||
| Loop over Color1, Color2 and Background if there |
|
||||
\*-----------------------------------------------------*/
|
||||
for(unsigned int i = 0; i != colors.size(); i++)
|
||||
{
|
||||
usb_buf[0x09] = 0x05;
|
||||
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]);
|
||||
}
|
||||
}
|
||||
|
||||
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]);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
|
||||
@@ -33,20 +33,11 @@ enum
|
||||
|
||||
enum
|
||||
{
|
||||
AURA_ROG_STRIX_FLARE_PID = 0x1875,
|
||||
AURA_ROG_STRIX_FLARE_PNK_LTD_PID = 0x18CF,
|
||||
AURA_ROG_STRIX_FLARE_COD_BO4_PID = 0x18AF,
|
||||
AURA_ROG_FALCHION_WIRED_PID = 0x193C,
|
||||
AURA_ROG_FALCHION_WIRELESS_PID = 0x193E,
|
||||
AURA_ROG_STRIX_SCOPE_PID = 0x18F8,
|
||||
AURA_ROG_STRIX_SCOPE_RX_PID = 0x1951,
|
||||
AURA_ROG_STRIX_SCOPE_II_96_WIRELESS_USB_PID = 0x1AAE,
|
||||
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_ROG_FALCHION_WIRED_PID = 0x193C,
|
||||
AURA_ROG_FALCHION_WIRELESS_PID = 0x193E,
|
||||
AURA_TUF_K7_GAMING_PID = 0x18AA,
|
||||
AURA_TUF_K3_GAMING_PID = 0x194B,
|
||||
AURA_ROG_CLAYMORE_PID = 0x184D,
|
||||
};
|
||||
|
||||
struct led_color
|
||||
@@ -58,7 +49,7 @@ struct led_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, unsigned short rev_version);
|
||||
~AuraTUFKeyboardController();
|
||||
|
||||
std::string GetDeviceLocation();
|
||||
@@ -82,19 +73,11 @@ public:
|
||||
std::vector<led_color> colors
|
||||
);
|
||||
|
||||
void UpdateK1Wave
|
||||
(
|
||||
std::vector<RGBColor> colors,
|
||||
unsigned char direction,
|
||||
unsigned char speed,
|
||||
unsigned char brightness
|
||||
);
|
||||
|
||||
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
|
||||
@@ -105,11 +88,10 @@ public:
|
||||
void ClearResponses();
|
||||
|
||||
uint16_t device_pid;
|
||||
bool is_per_led_keyboard;
|
||||
|
||||
private:
|
||||
hid_device* dev;
|
||||
std::string location;
|
||||
unsigned short rev_version;
|
||||
unsigned short 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"
|
||||
@@ -15,10 +14,8 @@
|
||||
#include "RGBController_AsusAuraHeadsetStand.h"
|
||||
#include "RGBController_AsusAuraKeyboard.h"
|
||||
#include "RGBController_AsusAuraTUFKeyboard.h"
|
||||
#include "RGBController_AsusAuraMainboard.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"
|
||||
@@ -27,82 +24,80 @@
|
||||
#include <hidapi/hidapi.h>
|
||||
#include "dependencies/dmiinfo.h"
|
||||
|
||||
#define AURA_USB_VID 0x0B05
|
||||
#define AURA_USB_VID 0x0B05
|
||||
|
||||
/*-----------------------------------------------------------------*\
|
||||
| MOTHERBOARDS |
|
||||
\*-----------------------------------------------------------------*/
|
||||
#define AURA_ADDRESSABLE_1_PID 0x1867
|
||||
#define AURA_ADDRESSABLE_2_PID 0x1872
|
||||
#define AURA_ADDRESSABLE_3_PID 0x18A3
|
||||
#define AURA_ADDRESSABLE_4_PID 0x18A5
|
||||
#define AURA_MOTHERBOARD_1_PID 0x18F3
|
||||
#define AURA_MOTHERBOARD_2_PID 0x1939
|
||||
#define AURA_MOTHERBOARD_3_PID 0x19AF
|
||||
#define AURA_ADDRESSABLE_1_PID 0x1867
|
||||
#define AURA_ADDRESSABLE_2_PID 0x1872
|
||||
#define AURA_ADDRESSABLE_3_PID 0x18A3
|
||||
#define AURA_ADDRESSABLE_4_PID 0x18A5
|
||||
#define AURA_MOTHERBOARD_1_PID 0x18F3
|
||||
#define AURA_MOTHERBOARD_2_PID 0x1939
|
||||
#define AURA_MOTHERBOARD_3_PID 0x19AF
|
||||
|
||||
/*-----------------------------------------------------------------*\
|
||||
| KEYBOARDS |
|
||||
\*-----------------------------------------------------------------*/
|
||||
#define AURA_ROG_FALCHION_WIRED_PID 0x193C
|
||||
#define AURA_ROG_FALCHION_WIRELESS_PID 0x193E
|
||||
#define AURA_ROG_STRIX_FLARE_PID 0x1875
|
||||
#define AURA_ROG_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_STRIX_SCOPE_II_96_WIRELESS_USB_PID 0x1AAE
|
||||
#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_ROG_FALCHION_WIRED_PID 0x193C
|
||||
#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_SCOPE_PID 0x18F8
|
||||
#define AURA_ROG_STRIX_SCOPE_RX_PID 0x1951
|
||||
#define AURA_ROG_STRIX_SCOPE_TKL_PID 0x190C
|
||||
#define AURA_ROG_STRIX_SCOPE_TKL_PNK_LTD_PID 0x1954
|
||||
#define AURA_ROG_CLAYMORE_PID 0x184D
|
||||
#define AURA_TUF_K7_GAMING_PID 0x18AA
|
||||
#define AURA_TUF_K3_GAMING_PID 0x194B
|
||||
|
||||
/*-----------------------------------------------------------------*\
|
||||
| MICE - defined in AsusAuraMouseDevices.h |
|
||||
\*-----------------------------------------------------------------*/
|
||||
|
||||
#define AURA_ROG_STRIX_EVOLVE_PID 0x185B
|
||||
#define AURA_ROG_STRIX_EVOLVE_PID 0x185B
|
||||
|
||||
/*-----------------------------------------------------------------*\
|
||||
| MOUSEMATS |
|
||||
\*-----------------------------------------------------------------*/
|
||||
#define AURA_ROG_BALTEUS_PID 0x1891
|
||||
#define AURA_ROG_BALTEUS_QI_PID 0x1890
|
||||
#define AURA_ROG_BALTEUS_PID 0x1891
|
||||
#define AURA_ROG_BALTEUS_QI_PID 0x1890
|
||||
|
||||
/*-----------------------------------------------------------------*\
|
||||
| MONITORS |
|
||||
\*-----------------------------------------------------------------*/
|
||||
|
||||
#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
|
||||
#define AURA_ROG_STRIX_XG27AQ_PID 0x198C
|
||||
#define AURA_ROG_STRIX_XG27AQM_PID 0x19BB
|
||||
#define AURA_ROG_STRIX_XG27W_PID 0x1933
|
||||
#define AURA_ROG_PG32UQ_PID 0x19B9
|
||||
|
||||
/*-----------------------------------------------------------------*\
|
||||
| HEADSETSTANDS |
|
||||
\*-----------------------------------------------------------------*/
|
||||
|
||||
#define AURA_ROG_THRONE_PID 0x18D9
|
||||
#define AURA_ROG_THRONE_QI_PID 0x18C5
|
||||
#define AURA_ROG_THRONE_QI_GUNDAM_PID 0x1994
|
||||
#define AURA_ROG_THRONE_PID 0x18D9
|
||||
#define AURA_ROG_THRONE_QI_PID 0x18C5
|
||||
#define AURA_ROG_THRONE_QI_GUNDAM_PID 0x1994
|
||||
|
||||
/*-----------------------------------------------------------------*\
|
||||
| OTHER |
|
||||
\*-----------------------------------------------------------------*/
|
||||
#define AURA_TERMINAL_PID 0x1889
|
||||
#define ROG_STRIX_LC120_PID 0x879E
|
||||
#define AURA_RYUO_AIO_PID 0x1887
|
||||
#define ASUS_ROG_ALLY_PID 0x1ABE
|
||||
#define AURA_TERMINAL_PID 0x1889
|
||||
#define ROG_STRIX_LC120_PID 0x879E
|
||||
#define AURA_RYUO_AIO_PID 0x1887
|
||||
|
||||
AuraKeyboardMappingLayoutType GetKeyboardMappingLayoutType(int pid)
|
||||
{
|
||||
switch(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:
|
||||
return SCOPE_LAYOUT;
|
||||
|
||||
@@ -110,7 +105,6 @@ 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;
|
||||
|
||||
@@ -156,7 +150,7 @@ void DetectAsusAuraUSBMotherboards(hid_device_info* info, const std::string& /*n
|
||||
{
|
||||
DMIInfo dmi;
|
||||
AuraMainboardController* controller = new AuraMainboardController(dev, info->path);
|
||||
RGBController_AuraMainboard* rgb_controller = new RGBController_AuraMainboard(controller);
|
||||
RGBController_AuraUSB* rgb_controller = new RGBController_AuraUSB(controller);
|
||||
rgb_controller->name = "ASUS " + dmi.getMainboard();
|
||||
ResourceManager::get()->RegisterRGBController(rgb_controller);
|
||||
}
|
||||
@@ -188,8 +182,7 @@ void DetectAsusAuraUSBMice(hid_device_info* info, const std::string& name)
|
||||
|
||||
if(dev)
|
||||
{
|
||||
uint16_t pid = (name == "Asus ROG Spatha X Dock") ? AURA_ROG_SPATHA_X_DOCK_FAKE_PID : info->product_id;
|
||||
AuraMouseController* controller = new AuraMouseController(dev, info->path, pid);
|
||||
AuraMouseController* controller = new AuraMouseController(dev, info->path, info->product_id);
|
||||
RGBController_AuraMouse* rgb_controller = new RGBController_AuraMouse(controller);
|
||||
rgb_controller->name = name;
|
||||
ResourceManager::get()->RegisterRGBController(rgb_controller);
|
||||
@@ -287,19 +280,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 |
|
||||
\*-----------------------------------------------------------------*/
|
||||
@@ -314,23 +294,18 @@ REGISTER_HID_DETECTOR ("ASUS Aura Motherboard", DetectAs
|
||||
/*-----------------------------------------------------------------*\
|
||||
| KEYBOARDS |
|
||||
\*-----------------------------------------------------------------*/
|
||||
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 Strix Flare", DetectAsusAuraTUFUSBKeyboard, AURA_USB_VID, AURA_ROG_STRIX_FLARE_PID, 1, 0xFF00);
|
||||
REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Flare PNK LTD", DetectAsusAuraTUFUSBKeyboard, 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",DetectAsusAuraTUFUSBKeyboard, AURA_USB_VID, AURA_ROG_STRIX_FLARE_COD_BO4_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 ROG Strix Scope", DetectAsusAuraTUFUSBKeyboard, AURA_USB_VID, AURA_ROG_STRIX_SCOPE_PID, 1, 0xFF00);
|
||||
REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Scope RX", DetectAsusAuraTUFUSBKeyboard, AURA_USB_VID, AURA_ROG_STRIX_SCOPE_RX_PID, 1, 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 ROG Strix Scope II 96 Wireless USB", DetectAsusAuraTUFUSBKeyboard, AURA_USB_VID, AURA_ROG_STRIX_SCOPE_II_96_WIRELESS_USB_PID, 1, 0xFF00);
|
||||
REGISTER_HID_DETECTOR_IP("ASUS TUF Gaming K3", DetectAsusAuraTUFUSBKeyboard, AURA_USB_VID, AURA_TUF_K3_GAMING_PID, 1, 0xFF00);
|
||||
|
||||
/*-----------------------------------------------------------------*\
|
||||
| MICE |
|
||||
@@ -351,13 +326,10 @@ REGISTER_HID_DETECTOR_IP("Asus ROG Chakram (Wired)", DetectAs
|
||||
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 Spatha X Dock", DetectAsusAuraUSBMice, AURA_USB_VID, AURA_ROG_SPATHA_X_DOCK_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);
|
||||
@@ -384,7 +356,6 @@ REGISTER_HID_DETECTOR_PU("ASUS ROG Balteus Qi", DetectAs
|
||||
\*-----------------------------------------------------------------*/
|
||||
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);
|
||||
|
||||
@@ -397,4 +368,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
|
||||
{
|
||||
|
||||
@@ -1,78 +0,0 @@
|
||||
/*-----------------------------------------*\
|
||||
| RGBController_AsusAuraMainboard.cpp |
|
||||
| |
|
||||
| RGB controller for Asus Aura USB |
|
||||
| mainboards |
|
||||
| |
|
||||
| rytypete 8/30/2023 |
|
||||
| based on RGBController_AsusAuraUSB.cpp |
|
||||
| code |
|
||||
\*-----------------------------------------*/
|
||||
|
||||
#include "RGBController_AsusAuraMainboard.h"
|
||||
|
||||
/**------------------------------------------------------------------*\
|
||||
@name Asus Aura USB Mainboard
|
||||
@category Motherboard
|
||||
@type USB
|
||||
@save :white_check_mark:
|
||||
@direct :white_check_mark:
|
||||
@effects :white_check_mark:
|
||||
@detectors DetectAsusAuraUSBMotherboards
|
||||
@comment The Asus Aura USB Mainboard controller applies to most
|
||||
AMD and Intel mainboards from the x570 chipset onwards.
|
||||
\*-------------------------------------------------------------------*/
|
||||
|
||||
RGBController_AuraMainboard::RGBController_AuraMainboard(AuraMainboardController* controller_ptr) :
|
||||
RGBController_AuraUSB(controller_ptr)
|
||||
{
|
||||
name = "ASUS Aura USB Mainboard";
|
||||
description = "ASUS Aura USB Mainboard Device";
|
||||
|
||||
/*-------------------------------------------------------*\
|
||||
| Add manual save flag to all modes except direct mode |
|
||||
\*-------------------------------------------------------*/
|
||||
for(unsigned int mode_idx = 0; mode_idx < modes.size(); mode_idx++)
|
||||
{
|
||||
mode Mode = modes[mode_idx];
|
||||
if(Mode.value != AURA_MODE_DIRECT)
|
||||
{
|
||||
Mode.flags |= MODE_FLAG_MANUAL_SAVE;
|
||||
modes[mode_idx] = Mode;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void RGBController_AuraMainboard::DeviceUpdateShutdownEffect()
|
||||
{
|
||||
unsigned char red = 0;
|
||||
unsigned char grn = 0;
|
||||
unsigned char blu = 0;
|
||||
|
||||
if(modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC)
|
||||
{
|
||||
red = RGBGetRValue(modes[active_mode].colors[0]);
|
||||
grn = RGBGetGValue(modes[active_mode].colors[0]);
|
||||
blu = RGBGetBValue(modes[active_mode].colors[0]);
|
||||
}
|
||||
|
||||
for(unsigned int zone_idx = 0; zone_idx < zones.size(); zone_idx++)
|
||||
{
|
||||
AuraDeviceInfo device_info = controller->GetAuraDevices()[zone_idx];
|
||||
|
||||
/*---------------------------------------------------*\
|
||||
| Shutdown effect only works with onboard lighting |
|
||||
\*---------------------------------------------------*/
|
||||
if(device_info.device_type == AuraDeviceType::FIXED && zones[zone_idx].leds_count > 0)
|
||||
{
|
||||
((AuraMainboardController*) controller)->SetMode(zone_idx, modes[active_mode].value, red, grn, blu, true);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void RGBController_AuraMainboard::DeviceSaveMode()
|
||||
{
|
||||
DeviceUpdateMode();
|
||||
DeviceUpdateShutdownEffect();
|
||||
((AuraMainboardController*) controller)->SendCommit();
|
||||
}
|
||||
@@ -1,25 +0,0 @@
|
||||
/*-----------------------------------------*\
|
||||
| RGBController_AsusAuraMainboard.h |
|
||||
| |
|
||||
| RGB controller for Asus Aura USB |
|
||||
| mainboards |
|
||||
| |
|
||||
| rytypete 8/30/2023 |
|
||||
| based on RGBController_AsusAuraUSB.h |
|
||||
| code |
|
||||
\*-----------------------------------------*/
|
||||
|
||||
#pragma once
|
||||
#include "RGBController_AsusAuraUSB.h"
|
||||
#include "AsusAuraMainboardController.h"
|
||||
|
||||
class RGBController_AuraMainboard : public RGBController_AuraUSB
|
||||
{
|
||||
public:
|
||||
RGBController_AuraMainboard(AuraMainboardController* controller_ptr);
|
||||
|
||||
void DeviceSaveMode();
|
||||
|
||||
private:
|
||||
void DeviceUpdateShutdownEffect();
|
||||
};
|
||||
@@ -9,13 +9,11 @@
|
||||
|
||||
#include "RGBController_AsusAuraMouse.h"
|
||||
|
||||
static std::string aura_mouse_zone_names[5]
|
||||
static std::string aura_mouse_zone_names[3]
|
||||
{
|
||||
"Logo",
|
||||
"Scroll Wheel",
|
||||
"Underglow",
|
||||
"All",
|
||||
"Dock"
|
||||
"Underglow"
|
||||
};
|
||||
|
||||
/**------------------------------------------------------------------*\
|
||||
@@ -207,7 +205,7 @@ void RGBController_AuraMouse::DeviceUpdateLEDs()
|
||||
}
|
||||
}
|
||||
|
||||
void RGBController_AuraMouse::UpdateZoneLEDs(int /*zone*/)
|
||||
void RGBController_AuraMouse::UpdateZoneLEDs(int zone)
|
||||
{
|
||||
DeviceUpdateLEDs();
|
||||
}
|
||||
@@ -240,22 +238,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);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -28,6 +28,8 @@ RGBController_AuraTUFKeyboard::RGBController_AuraTUFKeyboard(AuraTUFKeyboardCont
|
||||
|
||||
pid = controller->device_pid;
|
||||
|
||||
const unsigned char AURA_KEYBOARD_SPEED_MIN = (pid == AURA_ROG_FALCHION_WIRED_PID || pid == AURA_ROG_FALCHION_WIRELESS_PID) ? 255 : 15;
|
||||
|
||||
if(pid != AURA_ROG_CLAYMORE_PID)
|
||||
{
|
||||
name = "ASUS Aura Keyboard";
|
||||
@@ -38,43 +40,6 @@ RGBController_AuraTUFKeyboard::RGBController_AuraTUFKeyboard(AuraTUFKeyboardCont
|
||||
location = controller->GetDeviceLocation();
|
||||
serial = controller->GetSerialString();
|
||||
|
||||
unsigned char AURA_KEYBOARD_SPEED_MIN = 0;
|
||||
unsigned char AURA_KEYBOARD_SPEED_MAX = 0;
|
||||
unsigned char AURA_KEYBOARD_SPEED_DEFAULT = 0;
|
||||
|
||||
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_ROG_STRIX_FLARE_PID:
|
||||
case AURA_ROG_STRIX_FLARE_PNK_LTD_PID:
|
||||
case AURA_ROG_STRIX_FLARE_COD_BO4_PID:
|
||||
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_ROG_FALCHION_WIRED_PID:
|
||||
case AURA_ROG_FALCHION_WIRELESS_PID:
|
||||
case AURA_ROG_STRIX_FLARE_II_ANIMATE_PID:
|
||||
case AURA_ROG_STRIX_SCOPE_RX_PID:
|
||||
case AURA_ROG_STRIX_SCOPE_PID:
|
||||
case AURA_ROG_STRIX_SCOPE_II_96_WIRELESS_USB_PID:
|
||||
case AURA_TUF_K5_GAMING_PID:
|
||||
AURA_KEYBOARD_SPEED_MIN = 255;
|
||||
AURA_KEYBOARD_SPEED_MAX = 0;
|
||||
AURA_KEYBOARD_SPEED_DEFAULT = 30;
|
||||
break;
|
||||
default:
|
||||
AURA_KEYBOARD_SPEED_MIN = 15;
|
||||
AURA_KEYBOARD_SPEED_MAX = 0;
|
||||
AURA_KEYBOARD_SPEED_DEFAULT = 8;
|
||||
}
|
||||
|
||||
mode Direct;
|
||||
Direct.name = "Direct";
|
||||
Direct.value = AURA_KEYBOARD_MODE_DIRECT;
|
||||
@@ -98,9 +63,7 @@ RGBController_AuraTUFKeyboard::RGBController_AuraTUFKeyboard(AuraTUFKeyboardCont
|
||||
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;
|
||||
|
||||
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;
|
||||
@@ -129,9 +92,7 @@ RGBController_AuraTUFKeyboard::RGBController_AuraTUFKeyboard(AuraTUFKeyboardCont
|
||||
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.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;
|
||||
@@ -140,120 +101,107 @@ RGBController_AuraTUFKeyboard::RGBController_AuraTUFKeyboard(AuraTUFKeyboardCont
|
||||
Wave.brightness = AURA_KEYBOARD_BRIGHTNESS_DEFAULT;
|
||||
Wave.direction = MODE_DIRECTION_LEFT;
|
||||
Wave.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
|
||||
if(!controller->is_per_led_keyboard)
|
||||
{
|
||||
Wave.colors_min = 5;
|
||||
Wave.colors_max = 5;
|
||||
}
|
||||
else
|
||||
{
|
||||
Wave.colors_min = 1;
|
||||
Wave.colors_max = 7;
|
||||
}
|
||||
|
||||
Wave.colors.resize(Wave.colors_max);
|
||||
Wave.colors_min = 1;
|
||||
Wave.colors_max = 7;
|
||||
Wave.colors.resize(7);
|
||||
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 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 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 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 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 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 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);
|
||||
}
|
||||
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
|
||||
{
|
||||
@@ -395,29 +343,15 @@ RGBController_AuraTUFKeyboard::~RGBController_AuraTUFKeyboard()
|
||||
|
||||
void RGBController_AuraTUFKeyboard::SetupZones()
|
||||
{
|
||||
unsigned char layout = controller->GetLayout();
|
||||
|
||||
std::map<int,layout_info> * keyboard_ptr;
|
||||
|
||||
switch(pid)
|
||||
{
|
||||
case AURA_ROG_STRIX_FLARE_PID:
|
||||
case AURA_ROG_STRIX_FLARE_PNK_LTD_PID:
|
||||
case AURA_ROG_STRIX_FLARE_COD_BO4_PID:
|
||||
keyboard_ptr = &AsusROGStrixFlareLayouts;
|
||||
break;
|
||||
case AURA_TUF_K3_GAMING_PID:
|
||||
case AURA_TUF_K7_GAMING_PID:
|
||||
keyboard_ptr = &AsusTUFK7Layouts;
|
||||
break;
|
||||
case AURA_ROG_STRIX_SCOPE_PID:
|
||||
case AURA_ROG_STRIX_SCOPE_RX_PID:
|
||||
keyboard_ptr = &AsusROGStrixScopeLayouts;
|
||||
break;
|
||||
case AURA_ROG_STRIX_SCOPE_II_96_WIRELESS_USB_PID:
|
||||
keyboard_ptr = &AsusROGStrixScopeII96WirelessLayouts;
|
||||
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;
|
||||
@@ -440,18 +374,12 @@ void RGBController_AuraTUFKeyboard::SetupZones()
|
||||
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())
|
||||
{
|
||||
/*---------------------------------------------------------*\
|
||||
@@ -501,7 +429,7 @@ void RGBController_AuraTUFKeyboard::DeviceUpdateLEDs()
|
||||
{
|
||||
std::vector<led_color> led_color_list = {};
|
||||
|
||||
for(size_t i = 0; i < colors.size(); i++)
|
||||
for(int i = 0; i < colors.size(); i++)
|
||||
{
|
||||
led_color_list.push_back({ leds[i].value, colors[i] });
|
||||
}
|
||||
@@ -516,11 +444,6 @@ void RGBController_AuraTUFKeyboard::UpdateZoneLEDs(int /*zone*/)
|
||||
|
||||
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]);
|
||||
@@ -562,12 +485,6 @@ void RGBController_AuraTUFKeyboard::DeviceUpdateMode()
|
||||
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)
|
||||
@@ -582,7 +499,7 @@ void RGBController_AuraTUFKeyboard::DeviceUpdateMode()
|
||||
color_mode = 1;
|
||||
}
|
||||
|
||||
if(modes[active_mode].value == AURA_KEYBOARD_MODE_WAVE || modes[active_mode].value == AURA_KEYBOARD_MODE_QUICKSAND)
|
||||
if(modes[active_mode].value == AURA_KEYBOARD_MODE_WAVE)
|
||||
{
|
||||
/*----------------------------------------------------------*\
|
||||
| converting openrgb direction value to keyboard directions |
|
||||
@@ -607,7 +524,6 @@ void RGBController_AuraTUFKeyboard::DeviceUpdateMode()
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
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)
|
||||
|
||||
@@ -13,6 +13,8 @@
|
||||
|
||||
enum
|
||||
{
|
||||
AURA_KEYBOARD_SPEED_MAX = 0,
|
||||
AURA_KEYBOARD_SPEED_DEFAULT = 8,
|
||||
AURA_KEYBOARD_BRIGHTNESS_MIN = 0,
|
||||
AURA_KEYBOARD_BRIGHTNESS_MAX = 4,
|
||||
AURA_KEYBOARD_BRIGHTNESS_DEFAULT = 4,
|
||||
@@ -20,16 +22,17 @@ enum
|
||||
|
||||
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_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,
|
||||
|
||||
};
|
||||
|
||||
class RGBController_AuraTUFKeyboard : public RGBController
|
||||
|
||||
@@ -16,9 +16,9 @@
|
||||
@save :x:
|
||||
@direct :white_check_mark:
|
||||
@effects :white_check_mark:
|
||||
@detectors DetectAsusAuraUSBTerminal,DetectAsusAuraUSBAddressable
|
||||
@detectors DetectAsusAuraUSBTerminal,DetectAsusAuraUSBAddressable,DetectAsusAuraUSBMotherboards
|
||||
@comment The Asus Aura USB controller applies to most AMD and
|
||||
Intel mainboards from the x470 and z390 chipset generations.
|
||||
Intel mainboards from the x470 and z390 chipsets onwards.
|
||||
\*-------------------------------------------------------------------*/
|
||||
|
||||
RGBController_AuraUSB::RGBController_AuraUSB(AuraUSBController* controller_ptr) :
|
||||
|
||||
@@ -29,10 +29,8 @@ public:
|
||||
|
||||
void DeviceUpdateMode();
|
||||
|
||||
protected:
|
||||
AuraUSBController* controller;
|
||||
|
||||
private:
|
||||
AuraUSBController* controller;
|
||||
std::vector<unsigned int> leds_channel;
|
||||
std::vector<unsigned int> zones_channel;
|
||||
bool initializedMode;
|
||||
|
||||
@@ -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 :white_check_mark:
|
||||
@direct :white_check_mark:
|
||||
@effects :white_check_mark:
|
||||
@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()
|
||||
|
||||
@@ -55,8 +55,8 @@ std::string AsusCerberusKeyboardController::GetSerialString()
|
||||
std::string AsusCerberusKeyboardController::GetVersion()
|
||||
{
|
||||
char versionstr[5];
|
||||
snprintf(versionstr, 5, "%X", version);
|
||||
return(std::string(versionstr));
|
||||
snprintf(versionstr, 3, "%X", version);
|
||||
return(std::string(versionstr, 3));
|
||||
}
|
||||
|
||||
void AsusCerberusKeyboardController::SetProfile
|
||||
|
||||
@@ -1,20 +1,16 @@
|
||||
#include "Detector.h"
|
||||
#include "AsusCerberusKeyboardController.h"
|
||||
#include "AsusSagarisKeyboardController.h"
|
||||
#include "AsusStrixClawController.h"
|
||||
#include "RGBController.h"
|
||||
#include "RGBController_AsusCerberusKeyboard.h"
|
||||
#include "RGBController_AsusSagarisKeyboard.h"
|
||||
#include "RGBController_AsusStrixClaw.h"
|
||||
#include <stdexcept>
|
||||
#include <hidapi/hidapi.h>
|
||||
#include "dependencies/dmiinfo.h"
|
||||
|
||||
#define ASUS_LEGACY_USB_VID 0x195D
|
||||
#define ASUS_USB_VID 0x0B05
|
||||
|
||||
#define ASUS_CERBERUS_MECH_PID 0x2047
|
||||
#define ASUS_SAGARIS_GK1100_PID 0x1835
|
||||
#define ASUS_ROG_STRIX_CLAW_PID 0x1016
|
||||
|
||||
void DetectAsusCerberusMech(hid_device_info* info, const std::string& name)
|
||||
@@ -30,19 +26,6 @@ void DetectAsusCerberusMech(hid_device_info* info, const std::string& name)
|
||||
}
|
||||
}
|
||||
|
||||
void DetectAsusSagarisKeyboard(hid_device_info* info, const std::string& name)
|
||||
{
|
||||
hid_device* dev = hid_open_path(info->path);
|
||||
|
||||
if(dev)
|
||||
{
|
||||
AsusSagarisKeyboardController* controller = new AsusSagarisKeyboardController(dev, info->path, info->release_number);
|
||||
RGBController_AsusSagarisKeyboard* rgb_controller = new RGBController_AsusSagarisKeyboard(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);
|
||||
@@ -57,6 +40,5 @@ 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 Sagaris GK1100", DetectAsusSagarisKeyboard, ASUS_USB_VID, ASUS_SAGARIS_GK1100_PID, 1, 0xFF02, 2);
|
||||
|
||||
REGISTER_HID_DETECTOR_IPU("ASUS ROG Strix Claw", DetectAsusStrixClaw, ASUS_LEGACY_USB_VID, ASUS_ROG_STRIX_CLAW_PID, 0, 0xFF01, 1);
|
||||
@@ -1,197 +0,0 @@
|
||||
/*-----------------------------------------*\
|
||||
| AsusSagarisKeyboardController.cpp |
|
||||
| |
|
||||
| Driver for ASUS Sagaris USB lighting |
|
||||
| controller |
|
||||
| |
|
||||
| Mola19 08/20/2023 |
|
||||
\*-----------------------------------------*/
|
||||
|
||||
#include "AsusSagarisKeyboardController.h"
|
||||
|
||||
#include <cstring>
|
||||
#include <string>
|
||||
#include <math.h>
|
||||
#include <vector>
|
||||
#include <string.h>
|
||||
|
||||
#include "LogManager.h"
|
||||
|
||||
#define ASUS_SAGARIS_KB_PACKET_SIZE 65
|
||||
|
||||
AsusSagarisKeyboardController::AsusSagarisKeyboardController(hid_device* dev_handle, const char* path, unsigned short rev_version)
|
||||
{
|
||||
dev = dev_handle;
|
||||
location = path;
|
||||
version = rev_version;
|
||||
}
|
||||
|
||||
AsusSagarisKeyboardController::~AsusSagarisKeyboardController()
|
||||
{
|
||||
hid_close(dev);
|
||||
}
|
||||
|
||||
std::string AsusSagarisKeyboardController::GetVersion()
|
||||
{
|
||||
return std::to_string((int) floor(version / 0x100)) + "." + std::to_string(version % 0x100);
|
||||
}
|
||||
|
||||
std::string AsusSagarisKeyboardController::GetDeviceLocation()
|
||||
{
|
||||
return("HID: " + location);
|
||||
}
|
||||
|
||||
std::string AsusSagarisKeyboardController::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);
|
||||
}
|
||||
|
||||
sagaris_mode AsusSagarisKeyboardController::GetMode()
|
||||
{
|
||||
ClearResponses();
|
||||
|
||||
uint8_t usb_buf_out[ASUS_SAGARIS_KB_PACKET_SIZE];
|
||||
memset(usb_buf_out, 0x00, sizeof(usb_buf_out));
|
||||
|
||||
usb_buf_out[0x00] = 0x06;
|
||||
usb_buf_out[0x01] = 0x0B;
|
||||
usb_buf_out[0x02] = 0x03;
|
||||
|
||||
hid_write(dev, usb_buf_out, ASUS_SAGARIS_KB_PACKET_SIZE);
|
||||
|
||||
unsigned char usb_buf_in[ASUS_SAGARIS_KB_PACKET_SIZE];
|
||||
memset(usb_buf_in, 0x00, sizeof(usb_buf_in));
|
||||
int return_length = hid_read_timeout(dev, usb_buf_in, ASUS_SAGARIS_KB_PACKET_SIZE, 100);
|
||||
|
||||
if(return_length == -1)
|
||||
{
|
||||
LOG_DEBUG("[Asus Sagaris GK1100]: Could not fetch mode");
|
||||
sagaris_mode default_mode;
|
||||
default_mode.mode = SAGARIS_KEYBOARD_MODE_STATIC;
|
||||
default_mode.brightness = SAGARIS_KEYBOARD_BRIGHTNESS_DEFAULT;
|
||||
default_mode.speed = 0;
|
||||
default_mode.colorIndex = 0;
|
||||
|
||||
return default_mode;
|
||||
}
|
||||
|
||||
sagaris_mode current_mode;
|
||||
current_mode.mode = usb_buf_in[3];
|
||||
current_mode.brightness = usb_buf_in[4];
|
||||
current_mode.speed = usb_buf_in[5];
|
||||
current_mode.colorIndex = usb_buf_in[6];
|
||||
|
||||
return current_mode;
|
||||
}
|
||||
|
||||
std::vector<RGBColor> AsusSagarisKeyboardController::GetColors()
|
||||
{
|
||||
ClearResponses();
|
||||
|
||||
uint8_t usb_buf_out[ASUS_SAGARIS_KB_PACKET_SIZE];
|
||||
memset(usb_buf_out, 0x00, sizeof(usb_buf_out));
|
||||
|
||||
usb_buf_out[0x00] = 0x06;
|
||||
usb_buf_out[0x01] = 0x0B;
|
||||
usb_buf_out[0x02] = 0x05;
|
||||
|
||||
hid_write(dev, usb_buf_out, ASUS_SAGARIS_KB_PACKET_SIZE);
|
||||
|
||||
std::vector<RGBColor> colors;
|
||||
colors.resize(7);
|
||||
|
||||
for(int i = 0; i < 7; i++)
|
||||
{
|
||||
unsigned char usb_buf_in[ASUS_SAGARIS_KB_PACKET_SIZE];
|
||||
memset(usb_buf_in, 0x00, sizeof(usb_buf_in));
|
||||
int return_length = hid_read_timeout(dev, usb_buf_in, ASUS_SAGARIS_KB_PACKET_SIZE, 100);
|
||||
|
||||
if(return_length == -1)
|
||||
{
|
||||
LOG_DEBUG("[Asus Sagaris GK1100]: Could not fetch color %i", i);
|
||||
colors[i] = ToRGBColor(0, 0, 0);
|
||||
continue;
|
||||
}
|
||||
|
||||
colors[i] = ToRGBColor(usb_buf_in[4] * 16, usb_buf_in[5] * 16, usb_buf_in[6] * 16);
|
||||
}
|
||||
|
||||
return colors;
|
||||
}
|
||||
|
||||
void AsusSagarisKeyboardController::SetColor
|
||||
(
|
||||
uint8_t index,
|
||||
uint8_t red,
|
||||
uint8_t green,
|
||||
uint8_t blue
|
||||
)
|
||||
{
|
||||
uint8_t usb_buf[ASUS_SAGARIS_KB_PACKET_SIZE];
|
||||
|
||||
memset(usb_buf, 0x00, sizeof(usb_buf));
|
||||
|
||||
usb_buf[0x00] = 0x06;
|
||||
usb_buf[0x01] = 0x0B;
|
||||
usb_buf[0x02] = 0x04;
|
||||
usb_buf[0x03] = 0x00;
|
||||
usb_buf[0x04] = index;
|
||||
usb_buf[0x05] = red;
|
||||
usb_buf[0x06] = green;
|
||||
usb_buf[0x07] = blue;
|
||||
|
||||
hid_write(dev, usb_buf, ASUS_SAGARIS_KB_PACKET_SIZE);
|
||||
}
|
||||
|
||||
void AsusSagarisKeyboardController::SetMode
|
||||
(
|
||||
uint8_t mode,
|
||||
uint8_t brightness,
|
||||
uint8_t speed,
|
||||
uint8_t colorIndex
|
||||
)
|
||||
{
|
||||
ClearResponses();
|
||||
|
||||
uint8_t usb_buf[ASUS_SAGARIS_KB_PACKET_SIZE];
|
||||
memset(usb_buf, 0x00, sizeof(usb_buf));
|
||||
|
||||
usb_buf[0x00] = 0x06;
|
||||
usb_buf[0x01] = 0x0B;
|
||||
usb_buf[0x02] = 0x01;
|
||||
usb_buf[0x03] = mode;
|
||||
usb_buf[0x04] = brightness;
|
||||
usb_buf[0x05] = speed;
|
||||
usb_buf[0x06] = colorIndex;
|
||||
|
||||
hid_write(dev, usb_buf, ASUS_SAGARIS_KB_PACKET_SIZE);
|
||||
|
||||
AwaitResponse(20);
|
||||
}
|
||||
|
||||
void AsusSagarisKeyboardController::AwaitResponse(int ms)
|
||||
{
|
||||
unsigned char usb_buf[ASUS_SAGARIS_KB_PACKET_SIZE];
|
||||
hid_read_timeout(dev, usb_buf, ASUS_SAGARIS_KB_PACKET_SIZE, ms);
|
||||
}
|
||||
|
||||
void AsusSagarisKeyboardController::ClearResponses()
|
||||
{
|
||||
int result = 1;
|
||||
unsigned char usb_buf_flush[65];
|
||||
while(result > 0)
|
||||
{
|
||||
result = hid_read_timeout(dev, usb_buf_flush, 65, 0);
|
||||
}
|
||||
}
|
||||
@@ -1,76 +0,0 @@
|
||||
/*-----------------------------------------*\
|
||||
| AsusSagarisKeyboardController.h |
|
||||
| |
|
||||
| Definitions and types for ASUS Sagaris |
|
||||
| USB RGB lighting controller |
|
||||
| |
|
||||
| Mola19 08/20/2023 |
|
||||
\*-----------------------------------------*/
|
||||
|
||||
#include "RGBController.h"
|
||||
|
||||
#include <string>
|
||||
#include <vector>
|
||||
#include <hidapi/hidapi.h>
|
||||
|
||||
#pragma once
|
||||
|
||||
enum
|
||||
{
|
||||
SAGARIS_KEYBOARD_MODE_OFF = 0,
|
||||
SAGARIS_KEYBOARD_MODE_STATIC = 1,
|
||||
SAGARIS_KEYBOARD_MODE_SPRIAL = 2,
|
||||
SAGARIS_KEYBOARD_MODE_CUSTOM = 3,
|
||||
SAGARIS_KEYBOARD_MODE_BREATHING = 4,
|
||||
SAGARIS_KEYBOARD_MODE_REACTIVE = 5,
|
||||
SAGARIS_KEYBOARD_MODE_STARRY_NIGHT = 6,
|
||||
SAGARIS_KEYBOARD_MODE_LASER = 7,
|
||||
};
|
||||
|
||||
enum
|
||||
{
|
||||
SAGARIS_KEYBOARD_BRIGHTNESS_MIN = 0,
|
||||
SAGARIS_KEYBOARD_BRIGHTNESS_MAX = 3,
|
||||
SAGARIS_KEYBOARD_BRIGHTNESS_DEFAULT = 3
|
||||
};
|
||||
|
||||
enum
|
||||
{
|
||||
SAGARIS_KEYBOARD_SPEED_MIN = 0,
|
||||
SAGARIS_KEYBOARD_SPEED_MAX = 3,
|
||||
SAGARIS_KEYBOARD_SPEED_DEFAULT = 2
|
||||
};
|
||||
|
||||
typedef struct
|
||||
{
|
||||
uint8_t mode;
|
||||
uint8_t brightness;
|
||||
uint8_t speed;
|
||||
uint8_t colorIndex;
|
||||
} sagaris_mode;
|
||||
|
||||
|
||||
class AsusSagarisKeyboardController
|
||||
{
|
||||
public:
|
||||
AsusSagarisKeyboardController(hid_device* dev_handle, const char* path, unsigned short rev_version);
|
||||
~AsusSagarisKeyboardController();
|
||||
|
||||
std::string GetVersion();
|
||||
std::string GetDeviceLocation();
|
||||
std::string GetSerialString();
|
||||
|
||||
sagaris_mode GetMode();
|
||||
std::vector<RGBColor> GetColors();
|
||||
|
||||
void SetMode(uint8_t mode, uint8_t brightness, uint8_t speed, uint8_t colorIndex);
|
||||
void SetColor(uint8_t index, uint8_t red, uint8_t green, uint8_t blue);
|
||||
|
||||
void AwaitResponse(int ms);
|
||||
void ClearResponses();
|
||||
|
||||
private:
|
||||
hid_device* dev;
|
||||
std::string location;
|
||||
unsigned short version;
|
||||
};
|
||||
@@ -1,246 +0,0 @@
|
||||
/*-----------------------------------------*\
|
||||
| RGBController_AsusSagarisKeyboard.cpp |
|
||||
| |
|
||||
| Generic RGB Interface for Asus Sagaris |
|
||||
| USB controller driver |
|
||||
| |
|
||||
| Mola19 08/20/2023 |
|
||||
\*-----------------------------------------*/
|
||||
|
||||
#include "RGBController_AsusSagarisKeyboard.h"
|
||||
#include <vector>
|
||||
|
||||
/**------------------------------------------------------------------*\
|
||||
@name Asus Sagaris Keyboard
|
||||
@category Keyboard
|
||||
@type USB
|
||||
@save :robot:
|
||||
@direct :x:
|
||||
@effects :white_check_mark:
|
||||
@detectors DetectAsusSagarisKeyboard
|
||||
@comment Missing controls for modifier keys, as they have independent lighting
|
||||
\*-------------------------------------------------------------------*/
|
||||
|
||||
#include <iostream>
|
||||
|
||||
RGBController_AsusSagarisKeyboard::RGBController_AsusSagarisKeyboard(AsusSagarisKeyboardController* controller_ptr)
|
||||
{
|
||||
controller = controller_ptr;
|
||||
|
||||
name = "ASUS Sagaris Keyboard";
|
||||
vendor = "ASUS";
|
||||
type = DEVICE_TYPE_KEYBOARD;
|
||||
description = "ASUS Sagaris Keyboard Device";
|
||||
version = controller->GetVersion();
|
||||
location = controller->GetDeviceLocation();
|
||||
serial = controller->GetSerialString();
|
||||
|
||||
mode Off;
|
||||
Off.name = "Off";
|
||||
Off.value = SAGARIS_KEYBOARD_MODE_OFF;
|
||||
Off.flags = MODE_FLAG_AUTOMATIC_SAVE;
|
||||
Off.color_mode = MODE_COLORS_NONE;
|
||||
modes.push_back(Off);
|
||||
|
||||
mode Static;
|
||||
Static.name = "Static";
|
||||
Static.value = SAGARIS_KEYBOARD_MODE_STATIC;
|
||||
Static.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
|
||||
Static.brightness_min = SAGARIS_KEYBOARD_BRIGHTNESS_MIN;
|
||||
Static.brightness_max = SAGARIS_KEYBOARD_BRIGHTNESS_MAX;
|
||||
Static.brightness = SAGARIS_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 Spiral;
|
||||
Spiral.name = "Spiral";
|
||||
Spiral.value = SAGARIS_KEYBOARD_MODE_SPRIAL;
|
||||
Spiral.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
|
||||
Spiral.brightness_min = SAGARIS_KEYBOARD_BRIGHTNESS_MIN;
|
||||
Spiral.brightness_max = SAGARIS_KEYBOARD_BRIGHTNESS_MAX;
|
||||
Spiral.brightness = SAGARIS_KEYBOARD_BRIGHTNESS_DEFAULT;
|
||||
Spiral.speed_min = SAGARIS_KEYBOARD_SPEED_MIN;
|
||||
Spiral.speed_max = SAGARIS_KEYBOARD_SPEED_MAX;
|
||||
Spiral.speed = SAGARIS_KEYBOARD_SPEED_DEFAULT;
|
||||
Spiral.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Spiral.colors_min = 7;
|
||||
Spiral.colors_max = 7;
|
||||
Spiral.colors.resize(7);
|
||||
modes.push_back(Spiral);
|
||||
|
||||
mode Custom;
|
||||
Custom.name = "Custom";
|
||||
Custom.value = SAGARIS_KEYBOARD_MODE_CUSTOM;
|
||||
Custom.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
|
||||
Custom.brightness_min = SAGARIS_KEYBOARD_BRIGHTNESS_MIN;
|
||||
Custom.brightness_max = SAGARIS_KEYBOARD_BRIGHTNESS_MAX;
|
||||
Custom.brightness = SAGARIS_KEYBOARD_BRIGHTNESS_DEFAULT;
|
||||
Custom.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Custom.colors_min = 7;
|
||||
Custom.colors_max = 7;
|
||||
Custom.colors.resize(7);
|
||||
modes.push_back(Custom);
|
||||
|
||||
mode Breathing;
|
||||
Breathing.name = "Breathing";
|
||||
Breathing.value = SAGARIS_KEYBOARD_MODE_BREATHING;
|
||||
Breathing.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_SPEED;
|
||||
Breathing.speed_min = SAGARIS_KEYBOARD_BRIGHTNESS_MIN;
|
||||
Breathing.speed_max = SAGARIS_KEYBOARD_BRIGHTNESS_MAX;
|
||||
Breathing.speed = SAGARIS_KEYBOARD_BRIGHTNESS_DEFAULT;
|
||||
Breathing.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Breathing.colors_min = 7;
|
||||
Breathing.colors_max = 7;
|
||||
Breathing.colors.resize(7);
|
||||
modes.push_back(Breathing);
|
||||
|
||||
mode Reactive;
|
||||
Reactive.name = "Reactive";
|
||||
Reactive.value = SAGARIS_KEYBOARD_MODE_REACTIVE;
|
||||
Reactive.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
|
||||
Reactive.brightness_min = SAGARIS_KEYBOARD_BRIGHTNESS_MIN;
|
||||
Reactive.brightness_max = SAGARIS_KEYBOARD_BRIGHTNESS_MAX;
|
||||
Reactive.brightness = SAGARIS_KEYBOARD_BRIGHTNESS_DEFAULT;
|
||||
Reactive.speed_min = SAGARIS_KEYBOARD_SPEED_MIN;
|
||||
Reactive.speed_max = SAGARIS_KEYBOARD_SPEED_MAX;
|
||||
Reactive.speed = SAGARIS_KEYBOARD_SPEED_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 Starry_Night;
|
||||
Starry_Night.name = "Starry Night";
|
||||
Starry_Night.value = SAGARIS_KEYBOARD_MODE_STARRY_NIGHT;
|
||||
Starry_Night.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
|
||||
Starry_Night.brightness_min = SAGARIS_KEYBOARD_SPEED_MIN;
|
||||
Starry_Night.brightness_max = SAGARIS_KEYBOARD_SPEED_MAX;
|
||||
Starry_Night.brightness = SAGARIS_KEYBOARD_SPEED_DEFAULT;
|
||||
Starry_Night.speed_min = SAGARIS_KEYBOARD_BRIGHTNESS_MIN;
|
||||
Starry_Night.speed_max = SAGARIS_KEYBOARD_BRIGHTNESS_MAX;
|
||||
Starry_Night.speed = SAGARIS_KEYBOARD_BRIGHTNESS_DEFAULT;
|
||||
Starry_Night.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Starry_Night.colors_min = 7;
|
||||
Starry_Night.colors_max = 7;
|
||||
Starry_Night.colors.resize(7);
|
||||
modes.push_back(Starry_Night);
|
||||
|
||||
mode Laser;
|
||||
Laser.name = "Laser";
|
||||
Laser.value = SAGARIS_KEYBOARD_MODE_LASER;
|
||||
Laser.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
|
||||
Laser.brightness_min = SAGARIS_KEYBOARD_SPEED_MIN;
|
||||
Laser.brightness_max = SAGARIS_KEYBOARD_SPEED_MAX;
|
||||
Laser.brightness = SAGARIS_KEYBOARD_SPEED_DEFAULT;
|
||||
Laser.speed_min = SAGARIS_KEYBOARD_BRIGHTNESS_MIN;
|
||||
Laser.speed_max = SAGARIS_KEYBOARD_BRIGHTNESS_MAX;
|
||||
Laser.speed = SAGARIS_KEYBOARD_BRIGHTNESS_DEFAULT;
|
||||
Laser.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Laser.colors_min = 7;
|
||||
Laser.colors_max = 7;
|
||||
Laser.colors.resize(7);
|
||||
modes.push_back(Laser);
|
||||
|
||||
SetupZones();
|
||||
|
||||
sagaris_mode current_mode = controller->GetMode();
|
||||
|
||||
active_mode = current_mode.mode;
|
||||
last_mode = current_mode.mode;
|
||||
modes[active_mode].brightness = current_mode.brightness;
|
||||
modes[active_mode].speed = current_mode.speed;
|
||||
|
||||
current_colors = controller->GetColors();
|
||||
|
||||
for(int i = 0; i < modes[active_mode].colors.size(); i++)
|
||||
{
|
||||
modes[active_mode].colors[i] = current_colors[i];
|
||||
}
|
||||
}
|
||||
|
||||
RGBController_AsusSagarisKeyboard::~RGBController_AsusSagarisKeyboard()
|
||||
{
|
||||
delete controller;
|
||||
}
|
||||
|
||||
void RGBController_AsusSagarisKeyboard::SetupZones()
|
||||
{
|
||||
zone keyboard;
|
||||
keyboard.name = "Keyboard";
|
||||
keyboard.type = ZONE_TYPE_SINGLE;
|
||||
keyboard.leds_min = 1;
|
||||
keyboard.leds_max = 1;
|
||||
keyboard.leds_count = 1;
|
||||
keyboard.matrix_map = nullptr;
|
||||
|
||||
SetupColors();
|
||||
}
|
||||
|
||||
void RGBController_AsusSagarisKeyboard::ResizeZone(int /*zone*/, int /*new_size*/)
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
void RGBController_AsusSagarisKeyboard::DeviceUpdateLEDs()
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
void RGBController_AsusSagarisKeyboard::UpdateZoneLEDs(int /*zone*/)
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
void RGBController_AsusSagarisKeyboard::UpdateSingleLED(int led)
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
void RGBController_AsusSagarisKeyboard::DeviceUpdateMode()
|
||||
{
|
||||
if(last_mode != active_mode)
|
||||
{
|
||||
last_mode = active_mode;
|
||||
for(int i = 0; i < modes[active_mode].colors.size(); i++)
|
||||
{
|
||||
modes[active_mode].colors[i] = current_colors[i];
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
for(int i = 0; i < modes[active_mode].colors.size(); i++)
|
||||
{
|
||||
current_colors[i] = modes[active_mode].colors[i];
|
||||
}
|
||||
|
||||
for(int i = 0; i < modes[active_mode].colors.size(); i++)
|
||||
{
|
||||
/*-----------------------------------------*\
|
||||
| This device uses 4bit colorValues (0-16) |
|
||||
\*-----------------------------------------*/
|
||||
uint8_t red = RGBGetRValue(modes[active_mode].colors[i]) / 16;
|
||||
uint8_t green = RGBGetGValue(modes[active_mode].colors[i]) / 16;
|
||||
uint8_t blue = RGBGetBValue(modes[active_mode].colors[i]) / 16;
|
||||
|
||||
controller->SetColor(i, red, green, blue);
|
||||
}
|
||||
}
|
||||
|
||||
/*------------------------------------------------------------------------------------------------------*\
|
||||
| This device uses a global color storage for 7 colors, |
|
||||
| each time a mode is selected, it is specified which color is chosen (some use all). |
|
||||
| As OpenRGB doesn't support selecting the color index, color 1 is used for single color modes. |
|
||||
\*------------------------------------------------------------------------------------------------------*/
|
||||
|
||||
uint8_t colorIndex = 0;
|
||||
|
||||
uint8_t mode = modes[active_mode].value;
|
||||
|
||||
if(mode == SAGARIS_KEYBOARD_MODE_STARRY_NIGHT) colorIndex = 7;
|
||||
|
||||
controller->SetMode(mode, modes[active_mode].brightness, modes[active_mode].speed, colorIndex);
|
||||
}
|
||||
@@ -1,34 +0,0 @@
|
||||
/*-----------------------------------------*\
|
||||
| RGBController_AsusSagarisKeyboard.h |
|
||||
| |
|
||||
| Generic RGB Interface for Asus Sagaris |
|
||||
| USB controller driver |
|
||||
| |
|
||||
| Mola19 08/20/2023 |
|
||||
\*-----------------------------------------*/
|
||||
|
||||
#pragma once
|
||||
#include "RGBController.h"
|
||||
#include "AsusSagarisKeyboardController.h"
|
||||
|
||||
class RGBController_AsusSagarisKeyboard : public RGBController
|
||||
{
|
||||
public:
|
||||
RGBController_AsusSagarisKeyboard(AsusSagarisKeyboardController* controller_ptr);
|
||||
~RGBController_AsusSagarisKeyboard();
|
||||
|
||||
void SetupZones();
|
||||
|
||||
void ResizeZone(int zone, int new_size);
|
||||
|
||||
void DeviceUpdateLEDs();
|
||||
void UpdateZoneLEDs(int zone);
|
||||
void UpdateSingleLED(int led);
|
||||
|
||||
void DeviceUpdateMode();
|
||||
|
||||
private:
|
||||
AsusSagarisKeyboardController* controller;
|
||||
std::vector<RGBColor> current_colors;
|
||||
uint8_t last_mode;
|
||||
};
|
||||
@@ -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,8 +1,8 @@
|
||||
#ifdef _WIN32
|
||||
|
||||
#include "AsusTUFLaptopController.h"
|
||||
#include "RGBController_AsusTUFLaptopWMI.h"
|
||||
|
||||
#include "acpiwmi.h"
|
||||
#include "Detector.h"
|
||||
#include "wmi.h"
|
||||
#include <string>
|
||||
@@ -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
|
||||
|
||||
@@ -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
|
||||
|
||||
+1
-1
@@ -25,4 +25,4 @@ static void DetectAsusTUFLaptopLinuxControllers()
|
||||
return;
|
||||
}
|
||||
|
||||
REGISTER_DETECTOR("ASUS TUF Laptop", DetectAsusTUFLaptopLinuxControllers);
|
||||
REGISTER_DETECTOR("ASUS TUF Laptop Linux WMI", DetectAsusTUFLaptopLinuxControllers);
|
||||
@@ -2,6 +2,7 @@
|
||||
#include "BlinkyTapeController.h"
|
||||
#include "RGBController.h"
|
||||
#include "RGBController_BlinkyTape.h"
|
||||
#include "SettingsManager.h"
|
||||
#include "find_usb_serial_port.h"
|
||||
#include <vector>
|
||||
#include <stdio.h>
|
||||
|
||||
@@ -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,5 +1,4 @@
|
||||
#include "Detector.h"
|
||||
#include "LogManager.h"
|
||||
#include "ColorfulGPUController.h"
|
||||
#include "RGBController.h"
|
||||
#include "RGBController_ColorfulGPU.h"
|
||||
@@ -23,9 +22,7 @@ bool TestForColorfulGPU(i2c_smbus_interface* bus, uint8_t i2c_addr)
|
||||
|
||||
int res = bus->i2c_read_block(i2c_addr, &pktsz, read_pkt);
|
||||
|
||||
LOG_DEBUG("[ColorfulGPUController] Handshake: res: %d. Expected 0xAA, 0xEF, 0x81. Received: 0x%02X, 0x%02X, 0x%02X.", res, read_pkt[0], read_pkt[1], read_pkt[2]);
|
||||
|
||||
return res >= 0 && (read_pkt[0] == 0xAA && read_pkt[1] == 0xEF && read_pkt[2] == 0x81);
|
||||
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)
|
||||
@@ -40,20 +37,10 @@ void DetectColorfulGPUControllers(i2c_smbus_interface* bus, uint8_t i2c_addr, co
|
||||
}
|
||||
}
|
||||
|
||||
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);
|
||||
REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 4090 Advanced OC-V", DetectColorfulGPUControllers, NVIDIA_VEN, NVIDIA_RTX4090_DEV, COLORFUL_SUB_VEN, COLORFUL_IGAME_RTX_4090_ADVANCED_OCV, 0x61);
|
||||
REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 4090 Advanced OC-V", DetectColorfulGPUControllers, NVIDIA_VEN, NVIDIA_RTX4090_DEV, COLORFUL_SUB_VEN, COLORFUL_IGAME_RTX_4090_ADVANCED_OCV2, 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 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 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 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 4080 Ultra W OC-V", DetectColorfulGPUControllers, NVIDIA_VEN, NVIDIA_RTX4080_DEV, COLORFUL_SUB_VEN, COLORFUL_IGAME_RTX_4080_ULTRAW_OCV2, 0x61);
|
||||
|
||||
@@ -1,151 +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, bool save)
|
||||
{
|
||||
uint8_t r = RGBGetRValue(color);
|
||||
uint8_t g = RGBGetGValue(color);
|
||||
uint8_t b = RGBGetBValue(color);
|
||||
uint8_t data_pkt[COLORFUL_COLOR_PACKET_LENGTH] = { 0x08, 0x0, 0x20, 0x10, r, g, b};
|
||||
if(save)
|
||||
{
|
||||
data_pkt[0] = 0x88;
|
||||
data_pkt[1] = 0x02;
|
||||
data_pkt[2] = 0x32;
|
||||
data_pkt[3] = 0x02;
|
||||
}
|
||||
|
||||
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, bool save);
|
||||
void SetStateDisplay(RGBColor color);
|
||||
void SetBreathing(RGBColor color);
|
||||
void SetOff();
|
||||
void SetRainbow();
|
||||
|
||||
|
||||
private:
|
||||
i2c_smbus_interface * bus;
|
||||
colorful_gpu_dev_id dev;
|
||||
};
|
||||
@@ -1,24 +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);
|
||||
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_OCV2, 0x50);
|
||||
@@ -1,157 +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 | MODE_FLAG_MANUAL_SAVE;
|
||||
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_SINGLE;
|
||||
new_zone.leds_min = 1;
|
||||
new_zone.leds_max = 1;
|
||||
new_zone.leds_count = 1;
|
||||
new_zone.matrix_map = nullptr;
|
||||
|
||||
zones.emplace_back(new_zone);
|
||||
|
||||
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], false);
|
||||
break;
|
||||
default:
|
||||
controller->SetDirect(colors[0], false);
|
||||
}
|
||||
}
|
||||
|
||||
void RGBController_ColorfulTuringGPU::UpdateZoneLEDs(int /*zone*/)
|
||||
{
|
||||
DeviceUpdateLEDs();
|
||||
}
|
||||
|
||||
void RGBController_ColorfulTuringGPU::UpdateSingleLED(int /*led*/)
|
||||
{
|
||||
DeviceUpdateLEDs();
|
||||
}
|
||||
|
||||
void RGBController_ColorfulTuringGPU::DeviceUpdateMode()
|
||||
{
|
||||
DeviceUpdateLEDs();
|
||||
}
|
||||
|
||||
void RGBController_ColorfulTuringGPU::DeviceSaveMode()
|
||||
{
|
||||
switch(modes[active_mode].value)
|
||||
{
|
||||
case COLORFUL_TURING_GPU_RGB_MODE_STATIC:
|
||||
controller->SetDirect(colors[0], true);
|
||||
break;
|
||||
default:
|
||||
DeviceUpdateLEDs();
|
||||
}
|
||||
}
|
||||
@@ -1,26 +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();
|
||||
void DeviceSaveMode();
|
||||
|
||||
private:
|
||||
ColorfulTuringGPUController* controller;
|
||||
int getModeIndex(int mode_value);
|
||||
|
||||
};
|
||||
|
||||
|
||||
@@ -36,10 +36,7 @@ CMARGBController::CMARGBController(hid_device* dev_handle, char *_path, unsigned
|
||||
|
||||
CMARGBController::~CMARGBController()
|
||||
{
|
||||
if(mutex_ptr.use_count() <= 1)
|
||||
{
|
||||
hid_close(dev);
|
||||
}
|
||||
hid_close(dev);
|
||||
}
|
||||
|
||||
void CMARGBController::GetStatus()
|
||||
|
||||
@@ -1,8 +1,10 @@
|
||||
/*-------------------------------------------------------------------*\
|
||||
| CMMKController.cpp |
|
||||
| |
|
||||
| Lukas N (chmod222) 28th Jun 2020 |
|
||||
| Tam D (too.manyhobbies) 25th Apr 2021 |
|
||||
| Driver for Coolermaster MasterKeys Keyboards |
|
||||
| |
|
||||
| Lukas N (chmod222) 28th Jun 2020 |
|
||||
| Tam D (too.manyhobbies) 25th Apr 2021 |
|
||||
| |
|
||||
\*-------------------------------------------------------------------*/
|
||||
|
||||
@@ -27,128 +29,28 @@ CMMKController::CMMKController(hid_device* dev, hid_device_info* dev_info)
|
||||
|
||||
char buf[32] = {0};
|
||||
cmmk_get_firmware_version(&cmmk_handle, buf, 32);
|
||||
firmware_version = std::string(buf);
|
||||
|
||||
/*--------------------------------------------------------------*\
|
||||
| Adjust the row count for keyboards without the front light bar |
|
||||
| Adjust the column count for TKL keyboards (i.e. x30 vs x50) |
|
||||
\*--------------------------------------------------------------*/
|
||||
enum cmmk_product_type kb_type = cmmk_get_device_model(&cmmk_handle);
|
||||
|
||||
row_count = (kb_type == CMMK_PRODUCT_MASTERKEYS_MK750) ? CMMK_ROWS_MAX : CMMK_ROWS_MAX - 1;
|
||||
switch(kb_type)
|
||||
{
|
||||
case CMMK_PRODUCT_MASTERKEYS_PRO_S:
|
||||
case CMMK_PRODUCT_MASTERKEYS_SK630:
|
||||
kb_size = KEYBOARD_SIZE_TKL;
|
||||
row_count = CMMK_ROWS_MAX - 1;
|
||||
column_count = CMMK_COLS_MAX - 4;
|
||||
break;
|
||||
|
||||
case CMMK_PRODUCT_MASTERKEYS_PRO_L:
|
||||
case CMMK_PRODUCT_MASTERKEYS_SK650:
|
||||
kb_size = KEYBOARD_SIZE_FULL;
|
||||
row_count = CMMK_ROWS_MAX - 1;
|
||||
column_count = CMMK_COLS_MAX;
|
||||
break;
|
||||
|
||||
case CMMK_PRODUCT_MASTERKEYS_MK750:
|
||||
case CMMK_PRODUCT_MASTERKEYS_SK650:
|
||||
default:
|
||||
kb_size = KEYBOARD_SIZE_FULL;
|
||||
row_count = CMMK_ROWS_MAX;
|
||||
column_count = CMMK_COLS_MAX;
|
||||
}
|
||||
|
||||
/*--------------------------------------------------------------*\
|
||||
| Detect the keyboard version and set the appropriate layout. |
|
||||
\*--------------------------------------------------------------*/
|
||||
|
||||
switch(firmware_version[0])
|
||||
{
|
||||
case '1':
|
||||
kb_layout_type = KEYBOARD_LAYOUT_ANSI_QWERTY;
|
||||
break;
|
||||
|
||||
/*--------------------------------------------------------------*\
|
||||
| In case we need to handle different versions in the future. |
|
||||
\*--------------------------------------------------------------*/
|
||||
default:
|
||||
kb_layout_type = KEYBOARD_LAYOUT_ISO_QWERTY;
|
||||
break;
|
||||
}
|
||||
|
||||
/*--------------------------------------------------------------*\
|
||||
| Populate key offsets. |
|
||||
\*--------------------------------------------------------------*/
|
||||
keyboard_layout* kb_layout;
|
||||
if(KEYBOARD_LAYOUT_ANSI_QWERTY == kb_layout_type)
|
||||
{
|
||||
switch (kb_type)
|
||||
{
|
||||
case CMMK_PRODUCT_MASTERKEYS_PRO_L:
|
||||
kb_layout = &layout_ansi_pro_l;
|
||||
break;
|
||||
case CMMK_PRODUCT_MASTERKEYS_PRO_S:
|
||||
kb_layout = &layout_ansi_pro_s;
|
||||
break;
|
||||
case CMMK_PRODUCT_MASTERKEYS_MK750:
|
||||
kb_layout = &layout_ansi_mk750;
|
||||
break;
|
||||
case CMMK_PRODUCT_MASTERKEYS_SK630:
|
||||
kb_layout = &layout_ansi_sk630;
|
||||
break;
|
||||
case CMMK_PRODUCT_MASTERKEYS_SK650:
|
||||
kb_layout = &layout_ansi_sk650;
|
||||
break;
|
||||
|
||||
default:
|
||||
kb_layout = 0;
|
||||
break;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
switch (kb_type)
|
||||
{
|
||||
case CMMK_PRODUCT_MASTERKEYS_PRO_L:
|
||||
kb_layout = &layout_iso_pro_l;
|
||||
break;
|
||||
case CMMK_PRODUCT_MASTERKEYS_PRO_S:
|
||||
kb_layout = &layout_iso_pro_s;
|
||||
break;
|
||||
case CMMK_PRODUCT_MASTERKEYS_MK750:
|
||||
kb_layout = &layout_iso_mk750;
|
||||
break;
|
||||
case CMMK_PRODUCT_MASTERKEYS_SK630:
|
||||
kb_layout = &layout_iso_sk630;
|
||||
break;
|
||||
case CMMK_PRODUCT_MASTERKEYS_SK650:
|
||||
kb_layout = &layout_iso_sk650;
|
||||
break;
|
||||
|
||||
default:
|
||||
kb_layout = 0;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
std::vector<int> keys_fn, keys_main, keys_num, keys_extra;
|
||||
|
||||
memset(&kb_transform, -1, row_count*column_count);
|
||||
|
||||
int key_idx = 0;
|
||||
if(kb_layout)
|
||||
{
|
||||
for(int row = 0; row < row_count; row++)
|
||||
{
|
||||
for(int col = 0; col < column_count; col++)
|
||||
{
|
||||
int val = (*kb_layout)[row][col];
|
||||
|
||||
if (-1 != val)
|
||||
{
|
||||
kb_offsets.ansi.push_back(val);
|
||||
kb_transform[row][col] = key_idx;
|
||||
key_idx++;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
firmware_version = buf;
|
||||
}
|
||||
|
||||
CMMKController::~CMMKController()
|
||||
@@ -186,26 +88,6 @@ uint8_t CMMKController::GetColumnCount()
|
||||
return column_count;
|
||||
}
|
||||
|
||||
KEYBOARD_LAYOUT CMMKController::GetLayout()
|
||||
{
|
||||
return kb_layout_type;
|
||||
}
|
||||
|
||||
keyboard_layout * CMMKController::GetTransform()
|
||||
{
|
||||
return &kb_transform;
|
||||
}
|
||||
|
||||
KEYBOARD_SIZE CMMKController::GetSize()
|
||||
{
|
||||
return kb_size;
|
||||
}
|
||||
|
||||
layout_values CMMKController::GetLayoutValues()
|
||||
{
|
||||
return kb_offsets;
|
||||
}
|
||||
|
||||
void CMMKController::SetFirmwareControl()
|
||||
{
|
||||
ActivateMode(CMMK_FIRMWARE);
|
||||
@@ -264,31 +146,31 @@ void CMMKController::SetMode(cmmk_effect_wave eff)
|
||||
void CMMKController::SetMode(cmmk_effect_ripple eff)
|
||||
{
|
||||
ActivateEffect(CMMK_EFFECT_RIPPLE);
|
||||
cmmk_set_effect_ripple(&cmmk_handle, &eff);
|
||||
cmmk_set_effect_ripple(&cmmk_handle, &eff);
|
||||
}
|
||||
|
||||
void CMMKController::SetMode(cmmk_effect_cross eff)
|
||||
{
|
||||
ActivateEffect(CMMK_EFFECT_CROSS);
|
||||
cmmk_set_effect_cross(&cmmk_handle, &eff);
|
||||
cmmk_set_effect_cross(&cmmk_handle, &eff);
|
||||
}
|
||||
|
||||
void CMMKController::SetMode(cmmk_effect_raindrops eff)
|
||||
{
|
||||
ActivateEffect(CMMK_EFFECT_RAINDROPS);
|
||||
cmmk_set_effect_raindrops(&cmmk_handle, &eff);
|
||||
cmmk_set_effect_raindrops(&cmmk_handle, &eff);
|
||||
}
|
||||
|
||||
void CMMKController::SetMode(cmmk_effect_stars eff)
|
||||
{
|
||||
ActivateEffect(CMMK_EFFECT_STARS);
|
||||
cmmk_set_effect_stars(&cmmk_handle, &eff);
|
||||
cmmk_set_effect_stars(&cmmk_handle, &eff);
|
||||
}
|
||||
|
||||
void CMMKController::SetMode(cmmk_effect_snake eff)
|
||||
{
|
||||
ActivateEffect(CMMK_EFFECT_SNAKE);
|
||||
cmmk_set_effect_snake(&cmmk_handle, &eff);
|
||||
cmmk_set_effect_snake(&cmmk_handle, &eff);
|
||||
}
|
||||
|
||||
bool CMMKController::PositionValid(int y, int x)
|
||||
|
||||
@@ -7,31 +7,10 @@
|
||||
| |
|
||||
\*-------------------------------------------------------------------*/
|
||||
|
||||
#include <cstring>
|
||||
#include <KeyboardLayoutManager.h>
|
||||
#include <string>
|
||||
#include <hidapi/hidapi.h>
|
||||
#include <libcmmk/libcmmk.h>
|
||||
|
||||
typedef int16_t keyboard_layout[CMMK_ROWS_MAX][CMMK_COLS_MAX];
|
||||
|
||||
/*---------------------------------------------------------*\
|
||||
| i'm not thrilled with the include path, but this will |
|
||||
| work for now. fixing this would need to happen in libcmmk |
|
||||
\*---------------------------------------------------------*/
|
||||
#pragma GCC push
|
||||
#pragma GCC diagnostic ignored "-Wunused-variable"
|
||||
#include <ansi/pro_s.h>
|
||||
#include <ansi/pro_l.h>
|
||||
#include <ansi/mk750.h>
|
||||
#include <ansi/sk630.h>
|
||||
#include <ansi/sk650.h>
|
||||
#include <iso/pro_s.h>
|
||||
#include <iso/pro_l.h>
|
||||
#include <iso/mk750.h>
|
||||
#include <iso/sk630.h>
|
||||
#include <iso/sk650.h>
|
||||
#pragma GCC pop
|
||||
|
||||
#pragma once
|
||||
|
||||
class CMMKController
|
||||
@@ -40,17 +19,12 @@ public:
|
||||
CMMKController(hid_device* dev_handle, hid_device_info* dev_info);
|
||||
~CMMKController();
|
||||
|
||||
std::string GetDeviceName();
|
||||
std::string GetDeviceVendor();
|
||||
std::string GetLocation();
|
||||
std::string GetFirmwareVersion();
|
||||
uint8_t GetRowCount();
|
||||
uint8_t GetColumnCount();
|
||||
|
||||
KEYBOARD_LAYOUT GetLayout();
|
||||
KEYBOARD_SIZE GetSize();
|
||||
layout_values GetLayoutValues();
|
||||
keyboard_layout* GetTransform();
|
||||
std::string GetDeviceName();
|
||||
std::string GetDeviceVendor();
|
||||
std::string GetLocation();
|
||||
std::string GetFirmwareVersion();
|
||||
uint8_t GetRowCount();
|
||||
uint8_t GetColumnCount();
|
||||
|
||||
void SetFirmwareControl();
|
||||
void SetManualControl();
|
||||
@@ -83,13 +57,6 @@ private:
|
||||
std::string vendor_name;
|
||||
std::string location;
|
||||
std::string firmware_version;
|
||||
|
||||
KEYBOARD_SIZE kb_size;
|
||||
KEYBOARD_LAYOUT kb_layout_type;
|
||||
layout_values kb_offsets;
|
||||
keyboard_layout kb_transform;
|
||||
keyboard_layout* kb_layout;
|
||||
|
||||
uint8_t row_count;
|
||||
uint8_t column_count;
|
||||
|
||||
|
||||
@@ -1,204 +0,0 @@
|
||||
/*-------------------------------------------------------------------*\
|
||||
| CMMonitorController.cpp |
|
||||
| |
|
||||
| Driver for Coolermaster Gaming Monitor |
|
||||
| |
|
||||
| morg (Morgan Guimard) 9/18/2023 |
|
||||
| |
|
||||
\*-------------------------------------------------------------------*/
|
||||
|
||||
#include "CMMonitorController.h"
|
||||
#include <cstring>
|
||||
|
||||
using namespace std::chrono_literals;
|
||||
|
||||
CMMonitorController::CMMonitorController(hid_device* dev_handle, const hid_device_info& info)
|
||||
{
|
||||
dev = dev_handle;
|
||||
location = info.path;
|
||||
|
||||
wchar_t serial_string[128];
|
||||
int ret = hid_get_serial_number_string(dev, serial_string, 128);
|
||||
|
||||
if(ret != 0)
|
||||
{
|
||||
serial_number = "";
|
||||
}
|
||||
else
|
||||
{
|
||||
std::wstring return_wstring = serial_string;
|
||||
serial_number = std::string(return_wstring.begin(), return_wstring.end());
|
||||
}
|
||||
}
|
||||
|
||||
CMMonitorController::~CMMonitorController()
|
||||
{
|
||||
hid_close(dev);
|
||||
}
|
||||
|
||||
std::string CMMonitorController::GetDeviceLocation()
|
||||
{
|
||||
return("HID: " + location);
|
||||
}
|
||||
|
||||
std::string CMMonitorController::GetSerialString()
|
||||
{
|
||||
return(serial_number);
|
||||
}
|
||||
|
||||
void CMMonitorController::SetMode(uint8_t mode_value, const RGBColor& color, uint8_t speed, uint8_t brightness)
|
||||
{
|
||||
if(software_mode_enabled)
|
||||
{
|
||||
SetSoftwareModeEnabled(false);
|
||||
}
|
||||
|
||||
uint8_t usb_buf[CM_MONITOR_PACKET_LENGTH];
|
||||
memset(usb_buf, 0x00, CM_MONITOR_PACKET_LENGTH);
|
||||
|
||||
usb_buf[1] = 0x80;
|
||||
usb_buf[2] = (mode_value == CM_MONITOR_OFF_MODE) ? 0x0F : 0x0B;
|
||||
usb_buf[3] = 0x02;
|
||||
usb_buf[4] = 0x02;
|
||||
usb_buf[5] = mode_value;
|
||||
usb_buf[6] = (mode_value == CM_MONITOR_OFF_MODE) ? 0x00 : 0x08;
|
||||
usb_buf[7] = speed;
|
||||
usb_buf[8] = brightness;
|
||||
usb_buf[9] = RGBGetRValue(color);
|
||||
usb_buf[10] = RGBGetGValue(color);
|
||||
usb_buf[11] = RGBGetBValue(color);
|
||||
|
||||
hid_write(dev, usb_buf, CM_MONITOR_PACKET_LENGTH);
|
||||
}
|
||||
|
||||
void CMMonitorController::SetCustomMode(const std::vector<RGBColor>& colors, uint8_t brightnesss)
|
||||
{
|
||||
if(software_mode_enabled)
|
||||
{
|
||||
SetSoftwareModeEnabled(false);
|
||||
}
|
||||
|
||||
/*---------------------------------------------------------*\
|
||||
| Creates the color buffer |
|
||||
\*---------------------------------------------------------*/
|
||||
uint8_t color_data[CM_MONITOR_COLOR_DATA_LENGTH];
|
||||
memset(color_data, 0x00, CM_MONITOR_COLOR_DATA_LENGTH);
|
||||
|
||||
uint8_t offset = 0;
|
||||
|
||||
for(const RGBColor& color: colors)
|
||||
{
|
||||
color_data[offset++] = RGBGetRValue(color);
|
||||
color_data[offset++] = RGBGetGValue(color);
|
||||
color_data[offset++] = RGBGetBValue(color);
|
||||
}
|
||||
|
||||
/*---------------------------------------------------------*\
|
||||
| Sends the 7 sequence packets |
|
||||
\*---------------------------------------------------------*/
|
||||
uint8_t usb_buf[CM_MONITOR_PACKET_LENGTH];
|
||||
|
||||
offset = 0;
|
||||
|
||||
for(unsigned int i = 0; i < 7; i++)
|
||||
{
|
||||
memset(usb_buf, 0x00, CM_MONITOR_PACKET_LENGTH);
|
||||
|
||||
usb_buf[1] = i < 6 ? i : 0x86;
|
||||
|
||||
/*---------------------------------------------------------*\
|
||||
| First packet contains static data |
|
||||
\*---------------------------------------------------------*/
|
||||
if(i == 0)
|
||||
{
|
||||
usb_buf[2] = 0x10;
|
||||
usb_buf[3] = 0x02;
|
||||
usb_buf[4] = 0x02;
|
||||
usb_buf[5] = 0x80;
|
||||
usb_buf[6] = brightnesss;
|
||||
|
||||
memcpy(&usb_buf[7], &color_data[offset], CM_MONITOR_PACKET_LENGTH - 7);
|
||||
offset += CM_MONITOR_PACKET_LENGTH - 7;
|
||||
}
|
||||
else
|
||||
{
|
||||
memcpy(&usb_buf[2], &color_data[offset], CM_MONITOR_PACKET_LENGTH - 2);
|
||||
offset += (CM_MONITOR_PACKET_LENGTH - 2);
|
||||
}
|
||||
|
||||
hid_write(dev, usb_buf, CM_MONITOR_PACKET_LENGTH);
|
||||
}
|
||||
}
|
||||
|
||||
void CMMonitorController::SendDirect(const std::vector<RGBColor>& colors)
|
||||
{
|
||||
if(!software_mode_enabled)
|
||||
{
|
||||
SetSoftwareModeEnabled(true);
|
||||
}
|
||||
|
||||
/*---------------------------------------------------------*\
|
||||
| Creates the color buffer |
|
||||
\*---------------------------------------------------------*/
|
||||
uint8_t color_data[CM_MONITOR_COLOR_DATA_LENGTH];
|
||||
memset(color_data, 0x00, CM_MONITOR_COLOR_DATA_LENGTH);
|
||||
|
||||
unsigned int offset = 0;
|
||||
|
||||
for(const RGBColor& color: colors)
|
||||
{
|
||||
color_data[offset++] = RGBGetRValue(color);
|
||||
color_data[offset++] = RGBGetGValue(color);
|
||||
color_data[offset++] = RGBGetBValue(color);
|
||||
}
|
||||
|
||||
/*---------------------------------------------------------*\
|
||||
| Sends the 7 sequence packets |
|
||||
\*---------------------------------------------------------*/
|
||||
uint8_t usb_buf[CM_MONITOR_PACKET_LENGTH];
|
||||
|
||||
offset = 0;
|
||||
|
||||
for(unsigned int i = 0; i < 7; i++)
|
||||
{
|
||||
memset(usb_buf, 0x00, CM_MONITOR_PACKET_LENGTH);
|
||||
|
||||
usb_buf[1] = i < 6 ? i : 0x86;
|
||||
|
||||
if(i == 0)
|
||||
{
|
||||
usb_buf[2] = 0x07;
|
||||
usb_buf[3] = 0x02;
|
||||
usb_buf[4] = 0x02;
|
||||
usb_buf[5] = 0x01;
|
||||
usb_buf[6] = 0x80;
|
||||
|
||||
memcpy(&usb_buf[7], &color_data[offset], CM_MONITOR_PACKET_LENGTH - 7);
|
||||
offset += CM_MONITOR_PACKET_LENGTH - 7;
|
||||
}
|
||||
else
|
||||
{
|
||||
memcpy(&usb_buf[2], &color_data[offset], CM_MONITOR_PACKET_LENGTH - 2);
|
||||
offset += (CM_MONITOR_PACKET_LENGTH - 2);
|
||||
}
|
||||
|
||||
hid_write(dev, usb_buf, CM_MONITOR_PACKET_LENGTH);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
void CMMonitorController::SetSoftwareModeEnabled(bool value)
|
||||
{
|
||||
uint8_t usb_buf[CM_MONITOR_PACKET_LENGTH];
|
||||
memset(usb_buf, 0x00, CM_MONITOR_PACKET_LENGTH);
|
||||
|
||||
usb_buf[1] = 0x80;
|
||||
usb_buf[2] = 0x07;
|
||||
usb_buf[3] = 0x02;
|
||||
usb_buf[4] = 0x02;
|
||||
usb_buf[6] = value;
|
||||
|
||||
hid_write(dev, usb_buf, CM_MONITOR_PACKET_LENGTH);
|
||||
|
||||
software_mode_enabled = value;
|
||||
}
|
||||
@@ -1,56 +0,0 @@
|
||||
/*-------------------------------------------------------------------*\
|
||||
| CMMonitorController.cpp |
|
||||
| |
|
||||
| Driver for Coolermaster Gaming Monitor |
|
||||
| |
|
||||
| morg (Morgan Guimard) 9/18/2023 |
|
||||
| |
|
||||
\*-------------------------------------------------------------------*/
|
||||
|
||||
#include "RGBController.h"
|
||||
#include <string>
|
||||
#include <hidapi/hidapi.h>
|
||||
|
||||
#pragma once
|
||||
|
||||
#define CM_MONITOR_PACKET_LENGTH 65
|
||||
#define CM_MONITOR_COLOR_DATA_LENGTH 436
|
||||
|
||||
enum
|
||||
{
|
||||
CM_MONITOR_DIRECT_MODE = 0xFF,
|
||||
CM_MONITOR_CUSTOM_MODE = 0xFE,
|
||||
CM_MONITOR_SPECTRUM_MODE = 0x00,
|
||||
CM_MONITOR_RELOAD_MODE = 0x01,
|
||||
CM_MONITOR_RECOIL_MODE = 0x02,
|
||||
CM_MONITOR_BREATHING_MODE = 0x03,
|
||||
CM_MONITOR_REFILL_MODE = 0x04,
|
||||
CM_MONITOR_OFF_MODE = 0x06
|
||||
};
|
||||
|
||||
enum
|
||||
{
|
||||
CM_MONITOR_BRIGHTNESS_MAX = 0xFF,
|
||||
CM_MONITOR_BRIGHTNESS_MIN = 0x00,
|
||||
CM_MONITOR_SPEED_MAX = 0x04,
|
||||
CM_MONITOR_SPEED_MIN = 0x00,
|
||||
};
|
||||
|
||||
class CMMonitorController
|
||||
{
|
||||
public:
|
||||
CMMonitorController(hid_device* dev_handle, const hid_device_info& info);
|
||||
~CMMonitorController();
|
||||
|
||||
std::string GetSerialString();
|
||||
std::string GetDeviceLocation();
|
||||
void SendDirect(const std::vector<RGBColor>& colors);
|
||||
void SetMode(uint8_t mode_value, const RGBColor& color, uint8_t speed, uint8_t brightness);
|
||||
void SetCustomMode(const std::vector<RGBColor>& colors, uint8_t brightnesss);
|
||||
private:
|
||||
std::string serial_number;
|
||||
std::string location;
|
||||
hid_device* dev;
|
||||
bool software_mode_enabled = false;
|
||||
void SetSoftwareModeEnabled(bool value);
|
||||
};
|
||||
@@ -18,7 +18,7 @@
|
||||
#include "RGBController_CMRGBController.h"
|
||||
#include "RGBController_CMR6000Controller.h"
|
||||
#include "RGBController_CMMKController.h"
|
||||
#include "RGBController_CMMonitorController.h"
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Coolermaster USB vendor ID |
|
||||
\*-----------------------------------------------------*/
|
||||
@@ -64,11 +64,6 @@
|
||||
#define COOLERMASTER_MP750_L_PID 0x0107
|
||||
#define COOLERMASTER_MP750_MEDIUM_PID 0x0105
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Coolermaster Monitors |
|
||||
\*-----------------------------------------------------*/
|
||||
#define COOLERMASTER_GM27_FQS_PID 0x01BB
|
||||
|
||||
/******************************************************************************************\
|
||||
* *
|
||||
* DetectCoolerMasterControllers *
|
||||
@@ -212,19 +207,6 @@ void DetectCoolerMasterSmallARGB(hid_device_info* info, const std::string&)
|
||||
}
|
||||
}
|
||||
|
||||
void DetectCoolerMasterMonitor(hid_device_info* info, const std::string& name)
|
||||
{
|
||||
hid_device* dev = hid_open_path(info->path);
|
||||
|
||||
if(dev)
|
||||
{
|
||||
CMMonitorController* controller = new CMMonitorController(dev, *info);
|
||||
RGBController_CMMonitorController* rgb_controller = new RGBController_CMMonitorController(controller);
|
||||
rgb_controller->name = name;
|
||||
ResourceManager::get()->RegisterRGBController(rgb_controller);
|
||||
}
|
||||
}
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Coolermaster Keyboards |
|
||||
\*-----------------------------------------------------*/
|
||||
@@ -266,8 +248,3 @@ REGISTER_HID_DETECTOR_PU ("Cooler Master MP750 Medium", DetectCooler
|
||||
\*-----------------------------------------------------*/
|
||||
REGISTER_HID_DETECTOR_I ("Cooler Master Radeon 6000 GPU", DetectCoolerMasterGPU, COOLERMASTER_VID, COOLERMASTER_RADEON_6000_PID, 1 );
|
||||
REGISTER_HID_DETECTOR_I ("Cooler Master Radeon 6900 GPU", DetectCoolerMasterGPU, COOLERMASTER_VID, COOLERMASTER_RADEON_6900_PID, 1 );
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Coolermaster Monitors |
|
||||
\*-----------------------------------------------------*/
|
||||
REGISTER_HID_DETECTOR_IPU("Cooler Master GM27-FQS ARGB Monitor", DetectCoolerMasterMonitor, COOLERMASTER_VID, COOLERMASTER_GM27_FQS_PID, 0, 0xFF00, 1);
|
||||
|
||||
@@ -34,6 +34,7 @@ using namespace std::chrono_literals;
|
||||
RGBController_CMMKController::RGBController_CMMKController(CMMKController* controller_ptr)
|
||||
{
|
||||
controller = controller_ptr;
|
||||
|
||||
name = controller->GetDeviceName();
|
||||
vendor = controller->GetDeviceVendor();
|
||||
type = DEVICE_TYPE_KEYBOARD;
|
||||
@@ -186,48 +187,68 @@ RGBController_CMMKController::~RGBController_CMMKController()
|
||||
delete controller;
|
||||
}
|
||||
|
||||
void RGBController_CMMKController::SetupZones()
|
||||
void RGBController_CMMKController::SetupMatrixMap()
|
||||
{
|
||||
/*---------------------------------------------------------*\
|
||||
| Create the keyboard zone usiung Keyboard Layout Manager |
|
||||
\*---------------------------------------------------------*/
|
||||
zone new_zone;
|
||||
new_zone.name = ZONE_EN_KEYBOARD;
|
||||
new_zone.type = ZONE_TYPE_MATRIX;
|
||||
|
||||
layoutManager = new KeyboardLayoutManager(controller->GetLayout(), controller->GetSize(), controller->GetLayoutValues());
|
||||
|
||||
matrix_map_type * new_map = new matrix_map_type;
|
||||
new_zone.matrix_map = new_map;
|
||||
new_zone.matrix_map->height = layoutManager->GetRowCount();
|
||||
new_zone.matrix_map->width = layoutManager->GetColumnCount();
|
||||
|
||||
new_zone.matrix_map->map = new unsigned int[new_map->height * new_map->width];
|
||||
new_zone.leds_count = layoutManager->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 |
|
||||
\*---------------------------------------------------------*/
|
||||
layoutManager->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++)
|
||||
for(int y = 0; y < CMMK_ROWS_MAX; y++)
|
||||
{
|
||||
led new_led;
|
||||
|
||||
new_led.name = layoutManager->GetKeyNameAt(led_idx);
|
||||
new_led.value = layoutManager->GetKeyValueAt(led_idx);
|
||||
leds.push_back(new_led);
|
||||
for(int x = 0; x < CMMK_COLS_MAX; x++)
|
||||
{
|
||||
matrix_map[y][x] = 0xFFFFFFFF;
|
||||
}
|
||||
}
|
||||
|
||||
zones.push_back(new_zone);
|
||||
for(size_t i = 0; i < leds.size(); i++)
|
||||
{
|
||||
led& l = leds[i];
|
||||
|
||||
int y = (l.value & 0xFF00) >> 8;
|
||||
int x = (l.value & 0xFF);
|
||||
|
||||
matrix_map[y][x] = i;
|
||||
}
|
||||
}
|
||||
|
||||
void RGBController_CMMKController::SetupZones()
|
||||
{
|
||||
uint8_t row_count = controller->GetRowCount();
|
||||
uint8_t column_count = controller->GetColumnCount();
|
||||
|
||||
for(int y = 0; y < row_count; y++)
|
||||
{
|
||||
for(int x = 0; x < column_count; x++)
|
||||
{
|
||||
if(!controller->PositionValid(y, x))
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
std::stringstream namestrm;
|
||||
|
||||
led key;
|
||||
|
||||
namestrm << "Key @ Row " << (y + 1) << ", Column" << (x + 1);
|
||||
|
||||
key.name = namestrm.str();
|
||||
key.value = (y & 0xFF) << 8 | (x & 0xFF);
|
||||
|
||||
leds.push_back(key);
|
||||
}
|
||||
}
|
||||
|
||||
zone KeyboardZone;
|
||||
KeyboardZone.name = "Keyboard";
|
||||
KeyboardZone.type = ZONE_TYPE_MATRIX;
|
||||
KeyboardZone.leds_min = leds.size();
|
||||
KeyboardZone.leds_max = leds.size();
|
||||
KeyboardZone.leds_count = leds.size();
|
||||
KeyboardZone.matrix_map = new matrix_map_type;
|
||||
KeyboardZone.matrix_map->height = row_count;
|
||||
KeyboardZone.matrix_map->width = column_count;
|
||||
KeyboardZone.matrix_map->map = (unsigned int *)&matrix_map;
|
||||
|
||||
zones.push_back(KeyboardZone);
|
||||
|
||||
SetupMatrixMap();
|
||||
SetupColors();
|
||||
}
|
||||
|
||||
@@ -269,40 +290,32 @@ enum cmmk_wave_direction map_to_cmmk_dir(int input)
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void RGBController_CMMKController::copy_buffers(std::vector<RGBColor> &in_colors, struct cmmk_color_matrix& mat, std::atomic<bool>& dirty)
|
||||
void copy_buffers(led* buf, RGBColor* colbuf, size_t n, struct cmmk_color_matrix& mat, std::atomic<bool>& dirty)
|
||||
{
|
||||
dirty.store(false);
|
||||
|
||||
keyboard_layout * transform = controller->GetTransform();
|
||||
|
||||
if(0 == transform)
|
||||
for(size_t i = 0; i < n; i++)
|
||||
{
|
||||
return;
|
||||
}
|
||||
led const& selected_led = buf[i];
|
||||
|
||||
for(int row = 0; row < controller->GetRowCount(); row++)
|
||||
{
|
||||
for(int col = 0; col < controller->GetColumnCount(); col++)
|
||||
int y = (selected_led.value & 0xFF00) >> 8;
|
||||
int x = selected_led.value & 0xFF;
|
||||
|
||||
struct rgb col = map_to_cmmk_rgb(colbuf[i]);
|
||||
struct rgb ecol = mat.data[y][x];
|
||||
|
||||
if(ecol.R != col.R || ecol.G != col.G || ecol.B != col.B)
|
||||
{
|
||||
int key_idx = (*transform)[row][col];
|
||||
|
||||
if(-1 == key_idx)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
struct rgb color = map_to_cmmk_rgb(in_colors[key_idx]);
|
||||
|
||||
dirty.store(true);
|
||||
mat.data[row][col] = color;
|
||||
|
||||
mat.data[y][x] = col;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void RGBController_CMMKController::DeviceUpdateLEDs()
|
||||
{
|
||||
copy_buffers(colors, current_matrix, dirty);
|
||||
copy_buffers(leds.data(), colors.data(), leds.size(), current_matrix, dirty);
|
||||
|
||||
if(force_update.load() || dirty.load())
|
||||
{
|
||||
@@ -314,47 +327,29 @@ void RGBController_CMMKController::DeviceUpdateLEDs()
|
||||
|
||||
void RGBController_CMMKController::UpdateZoneLEDs(int zone_idx)
|
||||
{
|
||||
/*---------------------------------------------------------*\
|
||||
| This device only supports a single zone, as a result we |
|
||||
| update all LEDs. |
|
||||
\*---------------------------------------------------------*/
|
||||
DeviceUpdateLEDs();
|
||||
}
|
||||
zone& z = zones[zone_idx];
|
||||
|
||||
void RGBController_CMMKController::UpdateSingleLED(int led_idx, RGBColor color)
|
||||
{
|
||||
keyboard_layout * transform = controller->GetTransform();
|
||||
led selected_led = leds[led_idx];
|
||||
copy_buffers(z.leds, z.colors, z.leds_count, current_matrix, dirty);
|
||||
|
||||
if(0 == transform)
|
||||
if(force_update.load() || dirty.load())
|
||||
{
|
||||
return;
|
||||
controller->SetAll(current_matrix);
|
||||
|
||||
force_update.store(false);
|
||||
}
|
||||
|
||||
// this is really expensive
|
||||
for(int row = 0; row < controller->GetRowCount(); row++)
|
||||
{
|
||||
for(int col = 0; col < controller->GetColumnCount(); col++)
|
||||
{
|
||||
int val = (*transform)[row][col];
|
||||
|
||||
if(val != (int)selected_led.value)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
controller->SetSingle(row, col, map_to_cmmk_rgb(color));
|
||||
dirty.store(false);
|
||||
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
void RGBController_CMMKController::UpdateSingleLED(int led_idx)
|
||||
{
|
||||
UpdateSingleLED(led_idx, colors[led_idx]);
|
||||
led& selected_led = leds[led_idx];
|
||||
|
||||
int y = (selected_led.value & 0xFF00) >> 8;
|
||||
int x = selected_led.value & 0xFF;
|
||||
|
||||
current_matrix.data[y][x] = map_to_cmmk_rgb(colors[led_idx]);
|
||||
|
||||
controller->SetSingle(y, x, map_to_cmmk_rgb(colors[led_idx]));
|
||||
dirty.store(false);
|
||||
}
|
||||
|
||||
void RGBController_CMMKController::SetCustomMode()
|
||||
|
||||
@@ -1,46 +1,42 @@
|
||||
/*-------------------------------------------------------------------*\
|
||||
| RGBController_CMMKController.h |
|
||||
| |
|
||||
| Driver for Coolermaster MasterKeys keyboards |
|
||||
| |
|
||||
| Lukas N (chmod222) 28th Jun 2020 |
|
||||
| Tam D (too.manyhobbies) 25th Apr 2021 |
|
||||
| |
|
||||
\*-------------------------------------------------------------------*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <cstring>
|
||||
#include "RGBController.h"
|
||||
#include "CMMKController.h"
|
||||
#include "RGBControllerKeyNames.h"
|
||||
#include "KeyboardLayoutManager.h"
|
||||
|
||||
class RGBController_CMMKController : public RGBController
|
||||
{
|
||||
public:
|
||||
RGBController_CMMKController(CMMKController* controller_ptr);
|
||||
~RGBController_CMMKController();
|
||||
|
||||
void SetupZones();
|
||||
void ResizeZone(int zone, int new_size);
|
||||
|
||||
void DeviceUpdateLEDs();
|
||||
void UpdateSingleLED(int led, RGBColor color);
|
||||
void UpdateSingleLED(int led);
|
||||
void UpdateZoneLEDs(int zone_idx);
|
||||
|
||||
void SetCustomMode();
|
||||
void DeviceUpdateMode();
|
||||
|
||||
private:
|
||||
void copy_buffers(std::vector<RGBColor> &in_colors, struct cmmk_color_matrix& mat, std::atomic<bool>& dirty);
|
||||
|
||||
CMMKController* controller;
|
||||
KeyboardLayoutManager* layoutManager;
|
||||
|
||||
struct cmmk_color_matrix current_matrix;
|
||||
|
||||
std::atomic<bool> dirty;
|
||||
std::atomic<bool> force_update;
|
||||
};
|
||||
/*-------------------------------------------------------------------*\
|
||||
| RGBController_CMMKController.h |
|
||||
| |
|
||||
| Driver for Coolermaster MasterKeys keyboards |
|
||||
| |
|
||||
| Lukas N (chmod222) 28th Jun 2020 |
|
||||
| Tam D (too.manyhobbies) 25th Apr 2021 |
|
||||
| |
|
||||
\*-------------------------------------------------------------------*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include "RGBController.h"
|
||||
#include "CMMKController.h"
|
||||
|
||||
class RGBController_CMMKController : public RGBController
|
||||
{
|
||||
public:
|
||||
RGBController_CMMKController(CMMKController* controller_ptr);
|
||||
~RGBController_CMMKController();
|
||||
|
||||
void SetupZones();
|
||||
void ResizeZone(int zone, int new_size);
|
||||
|
||||
void DeviceUpdateLEDs();
|
||||
void UpdateZoneLEDs(int zone);
|
||||
void UpdateSingleLED(int led);
|
||||
|
||||
void SetCustomMode();
|
||||
void DeviceUpdateMode();
|
||||
|
||||
private:
|
||||
void SetupMatrixMap();
|
||||
|
||||
CMMKController* controller;
|
||||
|
||||
int matrix_map[CMMK_ROWS_MAX][CMMK_COLS_MAX];
|
||||
struct cmmk_color_matrix current_matrix;
|
||||
|
||||
std::atomic<bool> dirty;
|
||||
std::atomic<bool> force_update;
|
||||
};
|
||||
|
||||
@@ -1,225 +0,0 @@
|
||||
/*-------------------------------------------------------------------*\
|
||||
| RGBController_CMMonitorController.cpp |
|
||||
| |
|
||||
| Driver for Coolermaster Gaming Monitor USB Controller |
|
||||
| |
|
||||
| morg (Morgan Guimard) 9/18/2023 |
|
||||
| |
|
||||
\*-------------------------------------------------------------------*/
|
||||
|
||||
#include "RGBController_CMMonitorController.h"
|
||||
|
||||
#include <thread>
|
||||
#include <chrono>
|
||||
|
||||
/**------------------------------------------------------------------*\
|
||||
@name Coolermaster Gaming Monitor
|
||||
@category LEDStrip
|
||||
@type USB
|
||||
@save :robot:
|
||||
@direct :white_check_mark:
|
||||
@effects :white_check_mark:
|
||||
@detectors DetectCoolerMasterMonitor
|
||||
@comment
|
||||
\*-------------------------------------------------------------------*/
|
||||
|
||||
RGBController_CMMonitorController::RGBController_CMMonitorController(CMMonitorController* controller_ptr)
|
||||
{
|
||||
controller = controller_ptr;
|
||||
name = "CoolerMaster LED Controller A1";
|
||||
vendor = "CoolerMaster";
|
||||
type = DEVICE_TYPE_LEDSTRIP;
|
||||
description = name;
|
||||
location = controller->GetDeviceLocation();
|
||||
serial = controller->GetSerialString();
|
||||
version = "";
|
||||
|
||||
mode Direct;
|
||||
Direct.name = "Direct";
|
||||
Direct.value = CM_MONITOR_DIRECT_MODE;
|
||||
Direct.flags = MODE_FLAG_HAS_PER_LED_COLOR;
|
||||
Direct.color_mode = MODE_COLORS_PER_LED;
|
||||
modes.push_back(Direct);
|
||||
|
||||
mode Spectrum;
|
||||
Spectrum.name = "Spectrum cycle";
|
||||
Spectrum.value = CM_MONITOR_SPECTRUM_MODE;
|
||||
Spectrum.flags = MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
|
||||
Spectrum.color_mode = MODE_COLORS_NONE;
|
||||
Spectrum.speed_min = CM_MONITOR_SPEED_MIN;
|
||||
Spectrum.speed_max = CM_MONITOR_SPEED_MAX;
|
||||
Spectrum.speed = CM_MONITOR_SPEED_MAX/2;
|
||||
Spectrum.brightness_min = CM_MONITOR_BRIGHTNESS_MIN;
|
||||
Spectrum.brightness_max = CM_MONITOR_BRIGHTNESS_MAX;
|
||||
Spectrum.brightness = CM_MONITOR_BRIGHTNESS_MAX;
|
||||
modes.push_back(Spectrum);
|
||||
|
||||
mode Reload;
|
||||
Reload.name = "Reload";
|
||||
Reload.value = CM_MONITOR_RELOAD_MODE;
|
||||
Reload.flags = MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
|
||||
Reload.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Reload.colors_min = 1;
|
||||
Reload.colors_max = 1;
|
||||
Reload.colors.resize(1);
|
||||
Reload.speed_min = CM_MONITOR_SPEED_MIN;
|
||||
Reload.speed_max = CM_MONITOR_SPEED_MAX;
|
||||
Reload.speed = CM_MONITOR_SPEED_MAX/2;
|
||||
Reload.brightness_min = CM_MONITOR_BRIGHTNESS_MIN;
|
||||
Reload.brightness_max = CM_MONITOR_BRIGHTNESS_MAX;
|
||||
Reload.brightness = CM_MONITOR_BRIGHTNESS_MAX;
|
||||
modes.push_back(Reload);
|
||||
|
||||
mode Recoil;
|
||||
Recoil.name = "Recoil";
|
||||
Recoil.value = CM_MONITOR_RECOIL_MODE;
|
||||
Recoil.flags = MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
|
||||
Recoil.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Recoil.colors_min = 1;
|
||||
Recoil.colors_max = 1;
|
||||
Recoil.colors.resize(1);
|
||||
Recoil.speed_min = CM_MONITOR_SPEED_MIN;
|
||||
Recoil.speed_max = CM_MONITOR_SPEED_MAX;
|
||||
Recoil.speed = CM_MONITOR_SPEED_MAX/2;
|
||||
Recoil.brightness_min = CM_MONITOR_BRIGHTNESS_MIN;
|
||||
Recoil.brightness_max = CM_MONITOR_BRIGHTNESS_MAX;
|
||||
Recoil.brightness = CM_MONITOR_BRIGHTNESS_MAX;
|
||||
modes.push_back(Recoil);
|
||||
|
||||
mode Breathing;
|
||||
Breathing.name = "Breathing";
|
||||
Breathing.value = CM_MONITOR_BREATHING_MODE;
|
||||
Breathing.flags = MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
|
||||
Breathing.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Breathing.colors_min = 1;
|
||||
Breathing.colors_max = 1;
|
||||
Breathing.colors.resize(1);
|
||||
Breathing.speed_min = CM_MONITOR_SPEED_MIN;
|
||||
Breathing.speed_max = CM_MONITOR_SPEED_MAX;
|
||||
Breathing.speed = CM_MONITOR_SPEED_MAX/2;
|
||||
Breathing.brightness_min = CM_MONITOR_BRIGHTNESS_MIN;
|
||||
Breathing.brightness_max = CM_MONITOR_BRIGHTNESS_MAX;
|
||||
Breathing.brightness = CM_MONITOR_BRIGHTNESS_MAX;
|
||||
modes.push_back(Breathing);
|
||||
|
||||
mode Refill;
|
||||
Refill.name = "Refill";
|
||||
Refill.value = CM_MONITOR_REFILL_MODE;
|
||||
Refill.flags = MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
|
||||
Refill.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Refill.colors_min = 1;
|
||||
Refill.colors_max = 1;
|
||||
Refill.colors.resize(1);
|
||||
Refill.speed_min = CM_MONITOR_SPEED_MIN;
|
||||
Refill.speed_max = CM_MONITOR_SPEED_MAX;
|
||||
Refill.speed = CM_MONITOR_SPEED_MAX/2;
|
||||
Refill.brightness_min = CM_MONITOR_BRIGHTNESS_MIN;
|
||||
Refill.brightness_max = CM_MONITOR_BRIGHTNESS_MAX;
|
||||
Refill.brightness = CM_MONITOR_BRIGHTNESS_MAX;
|
||||
modes.push_back(Refill);
|
||||
|
||||
mode Custom;
|
||||
Custom.name = "Custom";
|
||||
Custom.value = CM_MONITOR_CUSTOM_MODE;
|
||||
Custom.flags = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
|
||||
Custom.color_mode = MODE_COLORS_PER_LED;
|
||||
Custom.brightness_min = CM_MONITOR_BRIGHTNESS_MIN;
|
||||
Custom.brightness_max = CM_MONITOR_BRIGHTNESS_MAX;
|
||||
Custom.brightness = CM_MONITOR_BRIGHTNESS_MAX;
|
||||
modes.push_back(Custom);
|
||||
|
||||
mode Off;
|
||||
Off.name = "Off";
|
||||
Off.value = CM_MONITOR_SPECTRUM_MODE;
|
||||
Off.flags = MODE_FLAG_AUTOMATIC_SAVE;
|
||||
Off.color_mode = MODE_COLORS_NONE;
|
||||
modes.push_back(Off);
|
||||
|
||||
SetupZones();
|
||||
}
|
||||
|
||||
RGBController_CMMonitorController::~RGBController_CMMonitorController()
|
||||
{
|
||||
delete controller;
|
||||
}
|
||||
|
||||
void RGBController_CMMonitorController::SetupZones()
|
||||
{
|
||||
zone z;
|
||||
|
||||
z.name = "Monitor";
|
||||
z.type = ZONE_TYPE_LINEAR;
|
||||
z.leds_min = 47;
|
||||
z.leds_max = 47;
|
||||
z.leds_count = 47;
|
||||
z.matrix_map = NULL;
|
||||
|
||||
zones.push_back(z);
|
||||
|
||||
for(unsigned int i = 0; i < 47; i++)
|
||||
{
|
||||
led l;
|
||||
l.name = std::to_string(i + 1);
|
||||
l.value = i;
|
||||
leds.push_back(l);
|
||||
}
|
||||
|
||||
SetupColors();
|
||||
}
|
||||
|
||||
void RGBController_CMMonitorController::ResizeZone(int /*zone*/, int /*new_size*/)
|
||||
{
|
||||
/*---------------------------------------------------------*\
|
||||
| This device does not support resizing zones |
|
||||
\*---------------------------------------------------------*/
|
||||
}
|
||||
|
||||
void RGBController_CMMonitorController::DeviceUpdateLEDs()
|
||||
{
|
||||
if(modes[active_mode].value == CM_MONITOR_DIRECT_MODE)
|
||||
{
|
||||
controller->SendDirect(colors);
|
||||
}
|
||||
else if(modes[active_mode].value == CM_MONITOR_CUSTOM_MODE)
|
||||
{
|
||||
controller->SetCustomMode(colors, modes[active_mode].brightness);
|
||||
}
|
||||
}
|
||||
|
||||
void RGBController_CMMonitorController::UpdateZoneLEDs(int /*zone*/)
|
||||
{
|
||||
DeviceUpdateLEDs();
|
||||
}
|
||||
|
||||
void RGBController_CMMonitorController::UpdateSingleLED(int /*led*/)
|
||||
{
|
||||
DeviceUpdateLEDs();
|
||||
}
|
||||
|
||||
void RGBController_CMMonitorController::SetCustomMode()
|
||||
{
|
||||
active_mode = 0;
|
||||
}
|
||||
|
||||
void RGBController_CMMonitorController::DeviceUpdateMode()
|
||||
{
|
||||
switch(modes[active_mode].value)
|
||||
{
|
||||
case CM_MONITOR_OFF_MODE:
|
||||
case CM_MONITOR_SPECTRUM_MODE:
|
||||
controller->SetMode(modes[active_mode].value, 0, modes[active_mode].speed, modes[active_mode].brightness);
|
||||
break;
|
||||
|
||||
case CM_MONITOR_RELOAD_MODE:
|
||||
case CM_MONITOR_RECOIL_MODE:
|
||||
case CM_MONITOR_BREATHING_MODE:
|
||||
case CM_MONITOR_REFILL_MODE:
|
||||
controller->SetMode(modes[active_mode].value, modes[active_mode].colors[0], modes[active_mode].speed, modes[active_mode].brightness);
|
||||
break;
|
||||
|
||||
case CM_MONITOR_CUSTOM_MODE:
|
||||
DeviceUpdateLEDs();
|
||||
break;
|
||||
default: break;
|
||||
}
|
||||
}
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user