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
|
||||
|
||||
#-----------------------------------------------------------------------#
|
||||
|
||||
@@ -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 |
|
||||
|
||||
@@ -1,75 +0,0 @@
|
||||
/*---------------------------------------------------------*\
|
||||
| AcerMonitorController.cpp |
|
||||
| |
|
||||
| Driver for 2020/2021 Acer monitors with rear RGB strips. |
|
||||
| |
|
||||
| Shenghao Yang ([email protected]), 30/12/2021 |
|
||||
| Amended for code style by Adam Honse, 3/13/2022 |
|
||||
\*---------------------------------------------------------*/
|
||||
|
||||
#include "AcerMonitorController.h"
|
||||
#include <cstring>
|
||||
|
||||
AcerMonitorController::AcerMonitorController(hid_device* dev_handle, const char* path)
|
||||
{
|
||||
dev = dev_handle;
|
||||
location = path;
|
||||
}
|
||||
|
||||
AcerMonitorController::~AcerMonitorController()
|
||||
{
|
||||
hid_close(dev);
|
||||
}
|
||||
|
||||
std::string AcerMonitorController::GetDeviceLocation()
|
||||
{
|
||||
return("HID: " + location);
|
||||
}
|
||||
|
||||
std::string AcerMonitorController::GetSerialString()
|
||||
{
|
||||
wchar_t serial_string[128];
|
||||
int ret = hid_get_serial_number_string(dev, serial_string, 128);
|
||||
|
||||
if(ret != 0)
|
||||
{
|
||||
return("");
|
||||
}
|
||||
|
||||
std::wstring return_wstring = serial_string;
|
||||
std::string return_string(return_wstring.begin(), return_wstring.end());
|
||||
|
||||
return(return_string);
|
||||
}
|
||||
|
||||
void AcerMonitorController::SetColors(RGBColor *colors, std::size_t num_leds)
|
||||
{
|
||||
char usb_buf[374];
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Zero out buffer |
|
||||
\*-----------------------------------------------------*/
|
||||
memset(usb_buf, 0x00, sizeof(usb_buf));
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Fill in Set Colors packet |
|
||||
\*-----------------------------------------------------*/
|
||||
usb_buf[ACER_MONITOR_OFFSET_REPORT_TYPE] = ACER_MONITOR_REPORT_TYPE;
|
||||
usb_buf[ACER_MONITOR_OFFSET_MAGIC_0] = ACER_MONITOR_MAGIC_0;
|
||||
usb_buf[ACER_MONITOR_OFFSET_MAGIC_1] = ACER_MONITOR_MAGIC_1;
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Fill in color data |
|
||||
\*-----------------------------------------------------*/
|
||||
for(unsigned int color_idx = 0; color_idx < num_leds; color_idx++)
|
||||
{
|
||||
usb_buf[ACER_MONITOR_OFFSET_RGB_DATA + 0 + (color_idx * 3)] = RGBGetRValue(colors[color_idx]);
|
||||
usb_buf[ACER_MONITOR_OFFSET_RGB_DATA + 1 + (color_idx * 3)] = RGBGetGValue(colors[color_idx]);
|
||||
usb_buf[ACER_MONITOR_OFFSET_RGB_DATA + 2 + (color_idx * 3)] = RGBGetBValue(colors[color_idx]);
|
||||
}
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Send packet |
|
||||
\*-----------------------------------------------------*/
|
||||
hid_write(dev, (unsigned char *)usb_buf, 374);
|
||||
}
|
||||
@@ -1,48 +0,0 @@
|
||||
/*---------------------------------------------------------*\
|
||||
| AcerMonitorController.h |
|
||||
| |
|
||||
| Driver for 2020/2021 Acer monitors with rear RGB strips. |
|
||||
| |
|
||||
| Shenghao Yang ([email protected]), 30/12/2021 |
|
||||
| Amended for code style by Adam Honse, 3/13/2022 |
|
||||
\*---------------------------------------------------------*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <RGBController.h>
|
||||
#include <hidapi/hidapi.h>
|
||||
|
||||
enum
|
||||
{
|
||||
ACER_MONITOR_OFFSET_REPORT_TYPE = 0x00, /* Offset of report type field in packet */
|
||||
ACER_MONITOR_OFFSET_MAGIC_0 = 0x01, /* Offset of magic 0 field in packet */
|
||||
ACER_MONITOR_OFFSET_MAGIC_1 = 0x02, /* Offset of magic 1 field in packet */
|
||||
ACER_MONITOR_OFFSET_PAD_0 = 0x03, /* Offset of pad 0 field in packet */
|
||||
ACER_MONITOR_OFFSET_NUM_LEDS = 0x04, /* Offset of number of LEDs field in packet */
|
||||
ACER_MONITOR_OFFSET_STRIP_INDEX = 0x05, /* Offset of strip index field in packet */
|
||||
ACER_MONITOR_OFFSET_PAD_1 = 0x06, /* Offset of pad 1 field in packet */
|
||||
ACER_MONITOR_OFFSET_RGB_DATA = 0x0E, /* Offset of RGB data field in packet */
|
||||
};
|
||||
|
||||
enum
|
||||
{
|
||||
ACER_MONITOR_REPORT_TYPE = 0x2A, /* Value of report type field in packet */
|
||||
ACER_MONITOR_MAGIC_0 = 0x0C, /* Value of magic 0 field in packet */
|
||||
ACER_MONITOR_MAGIC_1 = 0x02, /* Value of magic 1 field in packet */
|
||||
};
|
||||
|
||||
class AcerMonitorController
|
||||
{
|
||||
public:
|
||||
AcerMonitorController(hid_device* dev_handle, const char* path);
|
||||
~AcerMonitorController();
|
||||
|
||||
std::string GetDeviceLocation();
|
||||
std::string GetSerialString();
|
||||
|
||||
void SetColors(RGBColor *colors, std::size_t num_leds);
|
||||
|
||||
private:
|
||||
hid_device* dev;
|
||||
std::string location;
|
||||
};
|
||||
@@ -1,50 +0,0 @@
|
||||
/*---------------------------------------------------------*\
|
||||
| AcerMonitorControllerDetect.cpp |
|
||||
| |
|
||||
| Controller detection for 2020/2021 Acer monitors |
|
||||
| with rear RGB strips. |
|
||||
| |
|
||||
| Shenghao Yang ([email protected]), 30/12/2021 |
|
||||
| Amended for code style by Adam Honse, 3/13/2022 |
|
||||
\*---------------------------------------------------------*/
|
||||
|
||||
#include "Detector.h"
|
||||
#include "AcerMonitorController.h"
|
||||
#include "RGBController_AcerMonitor.h"
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Acer vendor ID |
|
||||
\*-----------------------------------------------------*/
|
||||
#define ACER_VID 0x042E
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Acer monitor product IDs |
|
||||
\*-----------------------------------------------------*/
|
||||
#define ACER_XB323QK_NV_PID 0xAC0B
|
||||
#define ACER_XB273U_NV_PID 0xAC0C
|
||||
#define ACER_X25_PID 0xAC0D
|
||||
|
||||
/*---------------------------------------------------------*\
|
||||
| DetectAcerMonitorControllers |
|
||||
| |
|
||||
| Detects Acer monitor controllers. |
|
||||
| |
|
||||
| info: HID device information. |
|
||||
\*---------------------------------------------------------*/
|
||||
void DetectAcerMonitorControllers(hid_device_info* info, const std::string& name)
|
||||
{
|
||||
hid_device* dev = hid_open_path(info->path);
|
||||
|
||||
if(dev)
|
||||
{
|
||||
AcerMonitorController* controller = new AcerMonitorController(dev, info->path);
|
||||
RGBController_AcerMonitor* rgb_controller = new RGBController_AcerMonitor(controller);
|
||||
rgb_controller->name = name;
|
||||
|
||||
ResourceManager::get()->RegisterRGBController(rgb_controller);
|
||||
}
|
||||
}
|
||||
|
||||
REGISTER_HID_DETECTOR("Acer XB323QK NV", DetectAcerMonitorControllers, ACER_VID, ACER_XB323QK_NV_PID);
|
||||
REGISTER_HID_DETECTOR("Acer XB273U NV", DetectAcerMonitorControllers, ACER_VID, ACER_XB273U_NV_PID );
|
||||
REGISTER_HID_DETECTOR("Acer X25", DetectAcerMonitorControllers, ACER_VID, ACER_X25_PID );
|
||||
@@ -1,111 +0,0 @@
|
||||
/*---------------------------------------------------------*\
|
||||
| RGBController_AcerMonitor.cpp |
|
||||
| |
|
||||
| RGBController interface implementation for 2020/2021 |
|
||||
| Acer monitors with rear RGB strips. |
|
||||
| |
|
||||
| Shenghao Yang ([email protected]), 30/12/2021 |
|
||||
| Amended for code style by Adam Honse, 3/13/2022 |
|
||||
\*---------------------------------------------------------*/
|
||||
|
||||
#include "RGBController_AcerMonitor.h"
|
||||
|
||||
RGBController_AcerMonitor::RGBController_AcerMonitor(AcerMonitorController* controller_ptr)
|
||||
{
|
||||
controller = controller_ptr;
|
||||
vendor = "Acer";
|
||||
type = DEVICE_TYPE_LEDSTRIP;
|
||||
description = "Acer Monitor Device";
|
||||
location = controller->GetDeviceLocation();
|
||||
serial = controller->GetSerialString();
|
||||
|
||||
mode Direct;
|
||||
Direct.name = "Direct";
|
||||
Direct.value = 0;
|
||||
Direct.flags = MODE_FLAG_HAS_PER_LED_COLOR;
|
||||
Direct.color_mode = MODE_COLORS_PER_LED;
|
||||
modes.push_back(Direct);
|
||||
|
||||
SetupZones();
|
||||
}
|
||||
|
||||
RGBController_AcerMonitor::~RGBController_AcerMonitor()
|
||||
{
|
||||
delete controller;
|
||||
}
|
||||
|
||||
void RGBController_AcerMonitor::SetupZones()
|
||||
{
|
||||
zones.clear();
|
||||
leds.clear();
|
||||
|
||||
// for(const auto *const *pz{ctrl->monitor->zones}; *pz; ++pz)
|
||||
// {
|
||||
// const Zone *z{*pz};
|
||||
// zone led_zone;
|
||||
|
||||
// led_zone.leds_count = z->leds;
|
||||
// led_zone.leds_max = led_zone.leds_count;
|
||||
// led_zone.leds_min = led_zone.leds_count;
|
||||
// led_zone.name = z->name;
|
||||
// led_zone.type = z->type;
|
||||
// led_zone.matrix_map = z->mmap;
|
||||
|
||||
// for (std::size_t i{}; i < z->leds; ++i)
|
||||
// {
|
||||
// led new_led{};
|
||||
|
||||
// new_led.name = led_zone.name + " LED ";
|
||||
// if (led_zone.leds_count > 1)
|
||||
// new_led.name.append(std::to_string(i + 1));
|
||||
|
||||
// leds.emplace_back(new_led);
|
||||
// }
|
||||
|
||||
// zones.emplace_back(led_zone);
|
||||
// }
|
||||
|
||||
SetupColors();
|
||||
}
|
||||
|
||||
void RGBController_AcerMonitor::ResizeZone(int, int)
|
||||
{
|
||||
/*---------------------------------------------------------*\
|
||||
| This device does not support resizing zones |
|
||||
\*---------------------------------------------------------*/
|
||||
}
|
||||
|
||||
void RGBController_AcerMonitor::DeviceUpdateLEDs()
|
||||
{
|
||||
// for (std::size_t i{}; i < zones.size(); ++i)
|
||||
// UpdateZoneLEDs(i);
|
||||
}
|
||||
|
||||
void RGBController_AcerMonitor::UpdateZoneLEDs(int zone)
|
||||
{
|
||||
//controller->SetLEDs(zone, zones[zone].colors);
|
||||
}
|
||||
|
||||
void RGBController_AcerMonitor::UpdateSingleLED(int led)
|
||||
{
|
||||
// /*-----------------------------------------------------*\
|
||||
// | Find the zone that the LED exists in. |
|
||||
// \*-----------------------------------------------------*/
|
||||
// std::size_t total{};
|
||||
// int zone{};
|
||||
// while (static_cast<std::size_t>(led) >= total)
|
||||
// total += zones[zone++].leds_count;
|
||||
|
||||
// --zone;
|
||||
// ctrl->SetLEDs(zone, zones[zone].colors);
|
||||
}
|
||||
|
||||
void RGBController_AcerMonitor::SetCustomMode()
|
||||
{
|
||||
active_mode = 0;
|
||||
}
|
||||
|
||||
void RGBController_AcerMonitor::DeviceUpdateMode()
|
||||
{
|
||||
|
||||
}
|
||||
@@ -1,35 +0,0 @@
|
||||
/*---------------------------------------------------------*\
|
||||
| RGBController_AcerMonitor.h |
|
||||
| |
|
||||
| RGBController interface implementation for 2020/2021 |
|
||||
| Acer monitors with rear RGB strips. |
|
||||
| |
|
||||
| Shenghao Yang ([email protected]), 30/12/2021 |
|
||||
| Amended for code style by Adam Honse, 3/13/2022 |
|
||||
\*---------------------------------------------------------*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include "RGBController.h"
|
||||
#include "AcerMonitorController.h"
|
||||
|
||||
class RGBController_AcerMonitor : public RGBController
|
||||
{
|
||||
public:
|
||||
RGBController_AcerMonitor(AcerMonitorController* controller_ptr);
|
||||
~RGBController_AcerMonitor();
|
||||
|
||||
void SetupZones();
|
||||
|
||||
void ResizeZone(int zone, int new_size);
|
||||
|
||||
void DeviceUpdateLEDs();
|
||||
void UpdateZoneLEDs(int zone);
|
||||
void UpdateSingleLED(int led);
|
||||
|
||||
void SetCustomMode();
|
||||
void DeviceUpdateMode();
|
||||
|
||||
private:
|
||||
AcerMonitorController* controller;
|
||||
};
|
||||
@@ -45,9 +45,9 @@ typedef struct
|
||||
const char * name;
|
||||
const unsigned char zone;
|
||||
const unsigned char idx;
|
||||
} aw510k_led_type;
|
||||
} led_type;
|
||||
|
||||
static const aw510k_led_type led_names[] =
|
||||
static const led_type led_names[] =
|
||||
{
|
||||
/* Key Label Zone, Index */
|
||||
{ KEY_EN_ESCAPE, ALIENWARE_AW510K_ZONE_DIRECT_KEYBOARD, 0xB0 },
|
||||
|
||||
@@ -40,9 +40,9 @@ typedef struct
|
||||
{
|
||||
const char * name;
|
||||
const unsigned char idx;
|
||||
} annepro2_led_type;
|
||||
} led_type;
|
||||
|
||||
static const annepro2_led_type led_names[] =
|
||||
static const led_type led_names[] =
|
||||
{
|
||||
/* Key Label Index */
|
||||
{ KEY_EN_ESCAPE, 0 },
|
||||
|
||||
@@ -9,8 +9,6 @@
|
||||
|
||||
#include "AsusAuraCoreLaptopController.h"
|
||||
|
||||
#include "SettingsManager.h"
|
||||
|
||||
static uint8_t packet_map[ASUSAURACORELAPTOP_KEYCOUNT +
|
||||
ASUSAURACORELAPTOP_LIGHTBARCOUNT +
|
||||
ASUSAURACORELAPTOP_LIDCOUNT ] =
|
||||
|
||||
@@ -406,8 +406,6 @@ void RGBController_AsusAuraCoreLaptop::Init_Controller()
|
||||
lightbar.leds_min = ASUSAURACORELAPTOP_LIGHTBARCOUNT;
|
||||
lightbar.leds_max = ASUSAURACORELAPTOP_LIGHTBARCOUNT;
|
||||
lightbar.leds_count = ASUSAURACORELAPTOP_LIGHTBARCOUNT;
|
||||
lightbar.matrix_map = NULL;
|
||||
|
||||
zones.push_back(lightbar);
|
||||
|
||||
zone lid;
|
||||
@@ -416,8 +414,6 @@ void RGBController_AsusAuraCoreLaptop::Init_Controller()
|
||||
lid.leds_min = ASUSAURACORELAPTOP_LIDCOUNT;
|
||||
lid.leds_max = ASUSAURACORELAPTOP_LIDCOUNT;
|
||||
lid.leds_count = ASUSAURACORELAPTOP_LIDCOUNT;
|
||||
lid.matrix_map = NULL;
|
||||
|
||||
zones.push_back(lid);
|
||||
}
|
||||
|
||||
|
||||
@@ -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});
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -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,8 +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_PUGIO_PID 0x1846
|
||||
#define AURA_ROG_PUGIO_II_WIRED_PID 0x1906
|
||||
#define AURA_ROG_PUGIO_II_WIRELESS_PID 0x1908
|
||||
@@ -46,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
|
||||
@@ -276,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,
|
||||
64,
|
||||
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 }
|
||||
}
|
||||
@@ -289,7 +284,7 @@ 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,
|
||||
64,
|
||||
@@ -299,32 +294,6 @@ static std::map<int,mouse_type> aura_mouse_devices =
|
||||
{ AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_WAVE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_COMET, AURA_MOUSE_MODE_BATTERY }
|
||||
}
|
||||
},
|
||||
{
|
||||
AURA_ROG_SPATHA_X_USB_PID, // ROG Spatha X USB
|
||||
{
|
||||
15, // technically until 255, but unusably slow after 15
|
||||
1,
|
||||
0,
|
||||
64,
|
||||
false,
|
||||
1,
|
||||
{ AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
|
||||
{ AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_WAVE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_COMET, AURA_MOUSE_MODE_BATTERY }
|
||||
}
|
||||
},
|
||||
{
|
||||
AURA_ROG_SPATHA_X_2_4_PID, // ROG Spatha X 2.4GHz Dock
|
||||
{
|
||||
15, // technically until 255, but unusably slow after 15
|
||||
1,
|
||||
0,
|
||||
64,
|
||||
true,
|
||||
1,
|
||||
{ AURA_MOUSE_ZONE_LOGO, AURA_MOUSE_ZONE_SCROLL, AURA_MOUSE_ZONE_UNDERGLOW },
|
||||
{ AURA_MOUSE_MODE_STATIC, AURA_MOUSE_MODE_BREATHING, AURA_MOUSE_MODE_SPECTRUM, AURA_MOUSE_MODE_WAVE, AURA_MOUSE_MODE_REACTIVE, AURA_MOUSE_MODE_COMET, AURA_MOUSE_MODE_BATTERY }
|
||||
}
|
||||
},
|
||||
{
|
||||
AURA_ROG_PUGIO_PID, // ROG Pugio
|
||||
{
|
||||
@@ -374,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 }
|
||||
}
|
||||
},
|
||||
{
|
||||
@@ -533,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()
|
||||
@@ -72,15 +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:
|
||||
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);
|
||||
@@ -140,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;
|
||||
@@ -265,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,
|
||||
@@ -332,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));
|
||||
|
||||
@@ -352,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,14 +33,11 @@ enum
|
||||
|
||||
enum
|
||||
{
|
||||
AURA_ROG_FALCHION_WIRED_PID = 0x193C,
|
||||
AURA_ROG_FALCHION_WIRELESS_PID = 0x193E,
|
||||
AURA_ROG_STRIX_FLARE_II_ANIMATE_PID = 0x19FC,
|
||||
AURA_TUF_K1_GAMING_PID = 0x1945,
|
||||
AURA_TUF_K3_GAMING_PID = 0x194B,
|
||||
AURA_TUF_K5_GAMING_PID = 0x1899,
|
||||
AURA_TUF_K7_GAMING_PID = 0x18AA,
|
||||
AURA_ROG_CLAYMORE_PID = 0x184D,
|
||||
AURA_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
|
||||
@@ -52,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();
|
||||
@@ -76,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
|
||||
@@ -99,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;
|
||||
};
|
||||
|
||||
|
||||
@@ -60,8 +60,7 @@ struct layout_info
|
||||
std::vector<led_value> led_names;
|
||||
};
|
||||
|
||||
static unsigned int ASUS_TUF_K7_LAYOUT_KEYS_US[6][24] =
|
||||
{
|
||||
static unsigned int ASUS_TUF_K7_LAYOUT_KEYS_US[6][24] = {
|
||||
{ 0, NA, 8, 14, 19, 24, NA, 34, 39, 44, 49, 55, 61, 66, 70, NA, 74, 78, 83, NA, NA, NA, NA, NA },
|
||||
{ 1, 6, 9, 15, 20, 25, 29, 35, 40, 45, 50, 56, 62, 67, NA, NA, 75, 79, 84, NA, 87, 92, 96, 101 },
|
||||
{ 2, NA, 10, 16, 21, 26, 30, 36, 41, 46, 51, 57, 63, 68, 71, NA, 76, 80, 85, NA, 88, 93, 97, 102 },
|
||||
@@ -71,8 +70,7 @@ static unsigned int ASUS_TUF_K7_LAYOUT_KEYS_US[6][24] =
|
||||
};
|
||||
|
||||
|
||||
static unsigned int ASUS_TUF_K7_LAYOUT_KEYS_UK[6][24] =
|
||||
{
|
||||
static unsigned int ASUS_TUF_K7_LAYOUT_KEYS_UK[6][24] = {
|
||||
{ 0, NA, 9, 15, 20, 25, NA, 35, 40, 45, 50, 56, 62, 67, 72, NA, 75, 79, 84, NA, NA, NA, NA, NA },
|
||||
{ 1, 6, 10, 16, 21, 26, 30, 36, 41, 46, 51, 57, 63, 68, NA, NA, 76, 80, 85, NA, 88, 93, 97, 102 },
|
||||
{ 2, NA, 11, 17, 22, 27, 31, 37, 42, 47, 52, 58, 64, 69, NA, NA, 77, 81, 86, NA, 89, 94, 98, 103 },
|
||||
@@ -81,30 +79,7 @@ static unsigned int ASUS_TUF_K7_LAYOUT_KEYS_UK[6][24] =
|
||||
{ 5, 8, 14, NA, NA, NA, 34, NA, NA, NA, 55, 61, 66, NA, 74, NA, 78, 83, 87, NA, 92, NA, 101, NA }
|
||||
};
|
||||
|
||||
static unsigned int ASUS_ROG_STRIX_FLARE_II_LAYOUT_KEYS_US[7][30] =
|
||||
{
|
||||
{ 0, NA, 8, 14, 19, 24, NA, 34, 39, 44, 49, 55, 61, 66, 70, NA, NA, NA, NA, 74, 78, 83, NA, NA, NA, NA, NA, NA, NA, NA },
|
||||
{ 1, 6, 9, 15, 20, 25, 29, 35, 40, 45, 50, 56, 62, 67, NA, NA, NA, NA, NA, 75, 79, 84, NA, NA, NA, NA, 87, 92, 96, 101 },
|
||||
{ 2, NA, 10, 16, 21, 26, 30, 36, 41, 46, 51, 57, 63, 68, 71, NA, NA, NA, NA, 76, 80, 85, NA, NA, NA, NA, 88, 93, 97, 102 },
|
||||
{ 3, NA, 11, 17, 22, 27, 31, 37, 42, 47, 52, 58, 64, NA, 72, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, 89, 94, 98, NA },
|
||||
{ 4, NA, 12, 18, 23, 28, 32, 38, 43, 48, 53, 59, NA, 69, NA, NA, NA, NA, NA, NA, 81, NA, NA, NA, NA, NA, 90, 95, 99, 103 },
|
||||
{ 5, 7, 13, NA, NA, NA, 33, NA, NA, NA, 54, 60, 65, NA, 73, NA, NA, NA, NA, 77, 82, 86, NA, NA, NA, NA, 91, NA, 100, NA },
|
||||
{ 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133 }
|
||||
};
|
||||
|
||||
static unsigned int ASUS_ROG_STRIX_FLARE_II_LAYOUT_KEYS_UK[7][30] =
|
||||
{
|
||||
{ 0, NA, 9, 15, 20, 25, NA, 35, 40, 45, 50, 56, 62, 67, 72, NA, NA, NA, NA, 75, 79, 84, NA, NA, NA, NA, NA, NA, NA, NA },
|
||||
{ 1, 6, 10, 16, 21, 26, 30, 36, 41, 46, 51, 57, 63, 68, NA, NA, NA, NA, NA, 76, 80, 85, NA, NA, NA, NA, 88, 93, 97, 102 },
|
||||
{ 2, NA, 11, 17, 22, 27, 31, 37, 42, 47, 52, 58, 64, 69, NA, NA, NA, NA, NA, 77, 81, 86, NA, NA, NA, NA, 89, 94, 98, 103 },
|
||||
{ 3, NA, 12, 18, 23, 28, 32, 38, 43, 48, 53, 59, 65, 70, 73, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, 90, 95, 99, NA },
|
||||
{ 4, 7, 13, 19, 24, 29, 33, 39, 44, 49, 54, 60, NA, 71, NA, NA, NA, NA, NA, NA, 82, NA, NA, NA, NA, NA, 91, 96, 100, 104 },
|
||||
{ 5, 8, 14, NA, NA, NA, 34, NA, NA, NA, 55, 61, 66, NA, 74, NA, NA, NA, NA, 78, 83, 87, NA, NA, NA, NA, 92, NA, 101, NA },
|
||||
{ 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134 }
|
||||
};
|
||||
|
||||
static unsigned int ASUS_FALCHION_LAYOUT_KEYS_US[5][16] =
|
||||
{
|
||||
static unsigned int ASUS_FALCHION_LAYOUT_KEYS_US[5][16] = {
|
||||
{ 0, 5, 7, 12, 16, 20, 24, 29, 33, 37, 41, 46, 51, 56, NA, 63 },
|
||||
{ 1, NA, 8, 13, 17, 21, 25, 30, 34, 38, 42, 47, 52, 57, 59, 64 },
|
||||
{ 2, NA, 9, 14, 18, 22, 26, 31, 35, 39, 43, 48, 53, NA, 60, 65 },
|
||||
@@ -112,8 +87,7 @@ static unsigned int ASUS_FALCHION_LAYOUT_KEYS_US[5][16] =
|
||||
{ 4, 6, 11, NA, NA, NA, 28, NA, NA, NA, 45, 50, 55, 58, 62, 67 }
|
||||
};
|
||||
|
||||
static unsigned int ASUS_FALCHION_LAYOUT_KEYS_UK[5][16] =
|
||||
{
|
||||
static unsigned int ASUS_FALCHION_LAYOUT_KEYS_UK[5][16] = {
|
||||
{ 0, 5, 8, 13, 17, 21, 25, 30, 34, 38, 42, 47, 52, 57, NA, 64 },
|
||||
{ 1, NA, 9, 14, 18, 22, 26, 31, 35, 39, 43, 48, 53, 58, 61, 65 },
|
||||
{ 2, NA, 10, 15, 19, 23, 27, 32, 36, 40, 44, 49, 54, 59, NA, 66 },
|
||||
@@ -121,8 +95,7 @@ static unsigned int ASUS_FALCHION_LAYOUT_KEYS_UK[5][16] =
|
||||
{ 4, 7, 12, NA, NA, NA, 29, NA, NA, NA, 46, 51, 56, 60, 63, 68 }
|
||||
};
|
||||
|
||||
static unsigned int ASUS_CLAYMORE_NO_NUMPAD_LAYOUT_KEYS_US[7][19] =
|
||||
{
|
||||
static unsigned int ASUS_CLAYMORE_NO_NUMPAD_LAYOUT_KEYS_US[7][19] = {
|
||||
{ 0, NA, 8, 14, 19, 24, NA, 34, 39, 45, 50, 56, 62, 67, 71, NA, 75, 79, 84 },
|
||||
{ 1, 6, 9, 15, 20, 25, 29, 35, 40, 46, 51, 57, 63, 68, NA, NA, 76, 80, 85 },
|
||||
{ 2, NA, 10, 16, 21, 26, 30, 36, 41, 47, 52, 58, 64, 69, 72, NA, 77, 81, 86 },
|
||||
@@ -132,8 +105,7 @@ static unsigned int ASUS_CLAYMORE_NO_NUMPAD_LAYOUT_KEYS_US[7][19] =
|
||||
{ NA, NA, NA, NA, NA, NA, NA, NA, 44, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA }
|
||||
};
|
||||
|
||||
static unsigned int ASUS_CLAYMORE_NO_NUMPAD_LAYOUT_KEYS_UK[7][19] =
|
||||
{
|
||||
static unsigned int ASUS_CLAYMORE_NO_NUMPAD_LAYOUT_KEYS_UK[7][19] = {
|
||||
{ 0, NA, 9, 15, 20, 25, NA, 35, 40, 46, 51, 57, 63, 68, 73, NA, 76, 80, 85 },
|
||||
{ 1, 6, 10, 16, 21, 26, 30, 36, 41, 47, 52, 58, 64, 69, NA, NA, 77, 81, 86 },
|
||||
{ 2, NA, 11, 17, 22, 27, 31, 37, 42, 48, 53, 59, 65, 70, NA, NA, 78, 82, 87 },
|
||||
@@ -143,8 +115,7 @@ static unsigned int ASUS_CLAYMORE_NO_NUMPAD_LAYOUT_KEYS_UK[7][19] =
|
||||
{ NA, NA, NA, NA, NA, NA, NA, NA, 45, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA }
|
||||
};
|
||||
|
||||
static unsigned int ASUS_CLAYMORE_NUMPAD_RIGHT_LAYOUT_KEYS_US[7][24] =
|
||||
{
|
||||
static unsigned int ASUS_CLAYMORE_NUMPAD_RIGHT_LAYOUT_KEYS_US[7][24] = {
|
||||
{ 0, NA, 8, 14, 19, 24, NA, 34, 39, 45, 50, 56, 62, 67, 71, NA, 75, 79, 84, NA, NA, NA, NA, NA },
|
||||
{ 1, 6, 9, 15, 20, 25, 29, 35, 40, 46, 51, 57, 63, 68, NA, NA, 76, 80, 85, NA, 88, 93, 97, 102 },
|
||||
{ 2, NA, 10, 16, 21, 26, 30, 36, 41, 47, 52, 58, 64, 69, 72, NA, 77, 81, 86, NA, 89, 94, 98, 103 },
|
||||
@@ -154,8 +125,7 @@ static unsigned int ASUS_CLAYMORE_NUMPAD_RIGHT_LAYOUT_KEYS_US[7][24] =
|
||||
{ NA, NA, NA, NA, NA, NA, NA, NA, 44, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA }
|
||||
};
|
||||
|
||||
static unsigned int ASUS_CLAYMORE_NUMPAD_RIGHT_LAYOUT_KEYS_UK[7][24] =
|
||||
{
|
||||
static unsigned int ASUS_CLAYMORE_NUMPAD_RIGHT_LAYOUT_KEYS_UK[7][24] = {
|
||||
{ 0, NA, 9, 15, 20, 25, NA, 35, 40, 46, 51, 57, 63, 68, 73, NA, 76, 80, 85, NA, NA, NA, NA, NA },
|
||||
{ 1, 6, 10, 16, 21, 26, 30, 36, 41, 47, 52, 58, 64, 69, NA, NA, 77, 81, 86, NA, 89, 94, 98, 103 },
|
||||
{ 2, NA, 11, 17, 22, 27, 31, 37, 42, 48, 53, 59, 65, 70, NA, NA, 78, 82, 87, NA, 90, 95, 99, 104 },
|
||||
@@ -165,8 +135,7 @@ static unsigned int ASUS_CLAYMORE_NUMPAD_RIGHT_LAYOUT_KEYS_UK[7][24] =
|
||||
{ NA, NA, NA, NA, NA, NA, NA, NA, 45, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA }
|
||||
};
|
||||
|
||||
static unsigned int ASUS_CLAYMORE_NUMPAD_LEFT_LAYOUT_KEYS_US[7][24] =
|
||||
{
|
||||
static unsigned int ASUS_CLAYMORE_NUMPAD_LEFT_LAYOUT_KEYS_US[7][24] = {
|
||||
{ NA, NA, NA, NA, NA, 17, NA, 25, 31, 36, 41, NA, 51, 56, 62, 67, 73, 79, 84, 88, NA, 92, 96, 101 },
|
||||
{ 0, 5, 9, 14, NA, 18, 23, 26, 32, 37, 42, 46, 52, 57, 63, 68, 74, 80, 85, NA, NA, 93, 97, 102 },
|
||||
{ 1, 6, 10, 15, NA, 19, NA, 27, 33, 38, 43, 47, 53, 58, 64, 69, 75, 81, 86, 89, NA, 94, 98, 103 },
|
||||
@@ -176,8 +145,7 @@ static unsigned int ASUS_CLAYMORE_NUMPAD_LEFT_LAYOUT_KEYS_US[7][24] =
|
||||
{ NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, 61, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA }
|
||||
};
|
||||
|
||||
static unsigned int ASUS_CLAYMORE_NUMPAD_LEFT_LAYOUT_KEYS_UK[7][24] =
|
||||
{
|
||||
static unsigned int ASUS_CLAYMORE_NUMPAD_LEFT_LAYOUT_KEYS_UK[7][24] = {
|
||||
{ NA, NA, NA, NA, NA, 17, NA, 26, 32, 37, 42, NA, 52, 57, 63, 68, 74, 80, 85, 90, NA, 93, 97, 102 },
|
||||
{ 0, 5, 9, 14, NA, 18, 23, 27, 33, 38, 43, 47, 53, 58, 64, 69, 75, 81, 86, NA, NA, 94, 98, 103 },
|
||||
{ 1, 6, 10, 15, NA, 19, NA, 28, 34, 39, 44, 48, 54, 59, 65, 70, 76, 82, 87, NA, NA, 95, 99, 104 },
|
||||
@@ -187,11 +155,6 @@ static unsigned int ASUS_CLAYMORE_NUMPAD_LEFT_LAYOUT_KEYS_UK[7][24] =
|
||||
{ NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, 62, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA }
|
||||
};
|
||||
|
||||
static unsigned int ASUS_TUF_K1_LAYOUT_KEYS[1][5] =
|
||||
{
|
||||
{ 0, 1, 2, 3, 4 },
|
||||
};
|
||||
|
||||
static std::map<int,layout_info> AsusTUFK7Layouts =
|
||||
{
|
||||
{
|
||||
@@ -469,345 +432,6 @@ static std::map<int,layout_info> AsusTUFK7Layouts =
|
||||
},
|
||||
};
|
||||
|
||||
static std::map<int,layout_info> AsusROGStrixFlareIILayouts =
|
||||
{
|
||||
{
|
||||
ASUS_TUF_K7_LAYOUT_UK,
|
||||
{
|
||||
*ASUS_ROG_STRIX_FLARE_II_LAYOUT_KEYS_UK,
|
||||
135,
|
||||
7,
|
||||
30,
|
||||
{
|
||||
{ KEY_EN_ESCAPE, 0x00 },
|
||||
{ KEY_EN_BACK_TICK, 0x01 },
|
||||
{ KEY_EN_TAB, 0x02 },
|
||||
{ KEY_EN_CAPS_LOCK, 0x03 },
|
||||
{ KEY_EN_LEFT_SHIFT, 0x04 },
|
||||
{ KEY_EN_LEFT_CONTROL, 0x05 },
|
||||
|
||||
{ KEY_EN_1, 0x11 },
|
||||
{ KEY_EN_ISO_BACK_SLASH, 0x0C },
|
||||
{ KEY_EN_LEFT_WINDOWS, 0x15 },
|
||||
|
||||
{ KEY_EN_F1, 0x18 },
|
||||
{ KEY_EN_2, 0x19 },
|
||||
{ KEY_EN_Q, 0x12 },
|
||||
{ KEY_EN_A, 0x13 },
|
||||
{ KEY_EN_Z, 0x14 },
|
||||
{ KEY_EN_LEFT_ALT, 0x1D },
|
||||
|
||||
{ KEY_EN_F2, 0x20 },
|
||||
{ KEY_EN_3, 0x21 },
|
||||
{ KEY_EN_W, 0x1A },
|
||||
{ KEY_EN_S, 0x1B },
|
||||
{ KEY_EN_X, 0x1C },
|
||||
|
||||
{ KEY_EN_F3, 0x28 },
|
||||
{ KEY_EN_4, 0x29 },
|
||||
{ KEY_EN_E, 0x22 },
|
||||
{ KEY_EN_D, 0x23 },
|
||||
{ KEY_EN_C, 0x24 },
|
||||
|
||||
{ KEY_EN_F4, 0x30 },
|
||||
{ KEY_EN_5, 0x31 },
|
||||
{ KEY_EN_R, 0x2A },
|
||||
{ KEY_EN_F, 0x2B },
|
||||
{ KEY_EN_V, 0x2C },
|
||||
|
||||
{ KEY_EN_6, 0x39 },
|
||||
{ KEY_EN_T, 0x32 },
|
||||
{ KEY_EN_G, 0x33 },
|
||||
{ KEY_EN_B, 0x34 },
|
||||
{ KEY_EN_SPACE, 0x35 },
|
||||
|
||||
{ KEY_EN_F5, 0x40 },
|
||||
{ KEY_EN_7, 0x41 },
|
||||
{ KEY_EN_Y, 0x3A },
|
||||
{ KEY_EN_H, 0x3B },
|
||||
{ KEY_EN_N, 0x3C },
|
||||
|
||||
{ KEY_EN_F6, 0x48 },
|
||||
{ KEY_EN_8, 0x49 },
|
||||
{ KEY_EN_U, 0x42 },
|
||||
{ KEY_EN_J, 0x43 },
|
||||
{ KEY_EN_M, 0x44 },
|
||||
|
||||
{ KEY_EN_F7, 0x50 },
|
||||
{ KEY_EN_9, 0x51 },
|
||||
{ KEY_EN_I, 0x4A },
|
||||
{ KEY_EN_K, 0x4B },
|
||||
{ KEY_EN_COMMA, 0x4C },
|
||||
|
||||
{ KEY_EN_F8, 0x58 },
|
||||
{ KEY_EN_0, 0x59 },
|
||||
{ KEY_EN_O, 0x52 },
|
||||
{ KEY_EN_L, 0x53 },
|
||||
{ KEY_EN_PERIOD, 0x54 },
|
||||
{ KEY_EN_RIGHT_ALT, 0x4D },
|
||||
|
||||
{ KEY_EN_F9, 0x60 },
|
||||
{ KEY_EN_MINUS, 0x61 },
|
||||
{ KEY_EN_P, 0x5A },
|
||||
{ KEY_EN_SEMICOLON, 0x5B },
|
||||
{ KEY_EN_FORWARD_SLASH, 0x5C },
|
||||
{ KEY_EN_RIGHT_FUNCTION, 0x5D },
|
||||
|
||||
{ KEY_EN_F10, 0x68 },
|
||||
{ KEY_EN_EQUALS, 0x69 },
|
||||
{ KEY_EN_LEFT_BRACKET, 0x62 },
|
||||
{ KEY_EN_QUOTE, 0x63 },
|
||||
{ KEY_EN_MENU, 0x65 },
|
||||
|
||||
{ KEY_EN_F11, 0x70 },
|
||||
{ KEY_EN_BACKSPACE, 0x79 },
|
||||
{ KEY_EN_RIGHT_BRACKET, 0x6A },
|
||||
{ KEY_EN_POUND, 0x6B },
|
||||
{ KEY_EN_RIGHT_SHIFT, 0x7C },
|
||||
|
||||
{ KEY_EN_F12, 0x78 },
|
||||
{ KEY_EN_ISO_ENTER, 0x7B },
|
||||
{ KEY_EN_RIGHT_CONTROL, 0x7D },
|
||||
|
||||
{ KEY_EN_PRINT_SCREEN, 0x80 },
|
||||
{ KEY_EN_INSERT, 0x81 },
|
||||
{ KEY_EN_DELETE, 0x82 },
|
||||
{ KEY_EN_LEFT_ARROW, 0x85 },
|
||||
|
||||
{ KEY_EN_SCROLL_LOCK, 0x88 },
|
||||
{ KEY_EN_HOME, 0x89 },
|
||||
{ KEY_EN_END, 0x8A },
|
||||
{ KEY_EN_UP_ARROW, 0x8C },
|
||||
{ KEY_EN_DOWN_ARROW, 0x8D },
|
||||
|
||||
{ KEY_EN_PAUSE_BREAK, 0x90 },
|
||||
{ KEY_EN_PAGE_UP, 0x91 },
|
||||
{ KEY_EN_PAGE_DOWN, 0x92 },
|
||||
{ KEY_EN_RIGHT_ARROW, 0x95 },
|
||||
|
||||
{ KEY_EN_NUMPAD_LOCK, 0x99 },
|
||||
{ KEY_EN_NUMPAD_7, 0x9A },
|
||||
{ KEY_EN_NUMPAD_4, 0x9B },
|
||||
{ KEY_EN_NUMPAD_1, 0x9C },
|
||||
{ KEY_EN_NUMPAD_0, 0x9D },
|
||||
|
||||
{ KEY_EN_NUMPAD_DIVIDE, 0xA1 },
|
||||
{ KEY_EN_NUMPAD_8, 0xA2 },
|
||||
{ KEY_EN_NUMPAD_5, 0xA3 },
|
||||
{ KEY_EN_NUMPAD_2, 0xA4 },
|
||||
|
||||
{ KEY_EN_NUMPAD_TIMES, 0xA9 },
|
||||
{ KEY_EN_NUMPAD_9, 0xAA },
|
||||
{ KEY_EN_NUMPAD_6, 0xAB },
|
||||
{ KEY_EN_NUMPAD_3, 0xAC },
|
||||
{ KEY_EN_NUMPAD_PERIOD, 0xAD },
|
||||
|
||||
{ KEY_EN_NUMPAD_MINUS, 0xB1 },
|
||||
{ KEY_EN_NUMPAD_PLUS, 0xB2 },
|
||||
{ KEY_EN_NUMPAD_ENTER, 0xB4 },
|
||||
|
||||
{ "Underglow LED 1", 0x06 },
|
||||
{ "Underglow LED 2", 0x0E },
|
||||
{ "Underglow LED 3", 0x16 },
|
||||
{ "Underglow LED 4", 0x1E },
|
||||
{ "Underglow LED 5", 0x26 },
|
||||
{ "Underglow LED 6", 0x2E },
|
||||
{ "Underglow LED 7", 0x36 },
|
||||
{ "Underglow LED 8", 0x3E },
|
||||
{ "Underglow LED 9", 0x46 },
|
||||
{ "Underglow LED 10", 0x4E },
|
||||
{ "Underglow LED 11", 0x56 },
|
||||
{ "Underglow LED 12", 0x5E },
|
||||
{ "Underglow LED 13", 0x66 },
|
||||
{ "Underglow LED 14", 0x6E },
|
||||
{ "Underglow LED 15", 0x76 },
|
||||
{ "Underglow LED 16", 0x7E },
|
||||
{ "Underglow LED 17", 0x86 },
|
||||
{ "Underglow LED 18", 0x8E },
|
||||
{ "Underglow LED 19", 0x96 },
|
||||
{ "Underglow LED 20", 0x9E },
|
||||
{ "Underglow LED 21", 0xA6 },
|
||||
{ "Underglow LED 22", 0xAE },
|
||||
{ "Underglow LED 23", 0xB6 },
|
||||
{ "Underglow LED 24", 0xBE },
|
||||
{ "Underglow LED 25", 0xC6 },
|
||||
{ "Underglow LED 26", 0xCE },
|
||||
{ "Underglow LED 27", 0xD6 },
|
||||
{ "Underglow LED 28", 0xDE },
|
||||
{ "Underglow LED 29", 0xE6 },
|
||||
{ "Underglow LED 30", 0xEE },
|
||||
}
|
||||
}
|
||||
},
|
||||
{
|
||||
ASUS_TUF_K7_LAYOUT_US,
|
||||
{
|
||||
*ASUS_ROG_STRIX_FLARE_II_LAYOUT_KEYS_US,
|
||||
134,
|
||||
7,
|
||||
30,
|
||||
{
|
||||
{ KEY_EN_ESCAPE, 0x00 },
|
||||
{ KEY_EN_BACK_TICK, 0x01 },
|
||||
{ KEY_EN_TAB, 0x02 },
|
||||
{ KEY_EN_CAPS_LOCK, 0x03 },
|
||||
{ KEY_EN_LEFT_SHIFT, 0x04 },
|
||||
{ KEY_EN_LEFT_CONTROL, 0x05 },
|
||||
|
||||
{ KEY_EN_1, 0x11 },
|
||||
{ KEY_EN_LEFT_WINDOWS, 0x15 },
|
||||
|
||||
{ KEY_EN_F1, 0x18 },
|
||||
{ KEY_EN_2, 0x19 },
|
||||
{ KEY_EN_Q, 0x12 },
|
||||
{ KEY_EN_A, 0x13 },
|
||||
{ KEY_EN_Z, 0x14 },
|
||||
{ KEY_EN_LEFT_ALT, 0x1D },
|
||||
|
||||
{ KEY_EN_F2, 0x20 },
|
||||
{ KEY_EN_3, 0x21 },
|
||||
{ KEY_EN_W, 0x1A },
|
||||
{ KEY_EN_S, 0x1B },
|
||||
{ KEY_EN_X, 0x1C },
|
||||
|
||||
{ KEY_EN_F3, 0x28 },
|
||||
{ KEY_EN_4, 0x29 },
|
||||
{ KEY_EN_E, 0x22 },
|
||||
{ KEY_EN_D, 0x23 },
|
||||
{ KEY_EN_C, 0x24 },
|
||||
|
||||
{ KEY_EN_F4, 0x30 },
|
||||
{ KEY_EN_5, 0x31 },
|
||||
{ KEY_EN_R, 0x2A },
|
||||
{ KEY_EN_F, 0x2B },
|
||||
{ KEY_EN_V, 0x2C },
|
||||
|
||||
{ KEY_EN_6, 0x39 },
|
||||
{ KEY_EN_T, 0x32 },
|
||||
{ KEY_EN_G, 0x33 },
|
||||
{ KEY_EN_B, 0x34 },
|
||||
{ KEY_EN_SPACE, 0x35 },
|
||||
|
||||
{ KEY_EN_F5, 0x40 },
|
||||
{ KEY_EN_7, 0x41 },
|
||||
{ KEY_EN_Y, 0x3A },
|
||||
{ KEY_EN_H, 0x3B },
|
||||
{ KEY_EN_N, 0x3C },
|
||||
|
||||
{ KEY_EN_F6, 0x48 },
|
||||
{ KEY_EN_8, 0x49 },
|
||||
{ KEY_EN_U, 0x42 },
|
||||
{ KEY_EN_J, 0x43 },
|
||||
{ KEY_EN_M, 0x44 },
|
||||
|
||||
{ KEY_EN_F7, 0x50 },
|
||||
{ KEY_EN_9, 0x51 },
|
||||
{ KEY_EN_I, 0x4A },
|
||||
{ KEY_EN_K, 0x4B },
|
||||
{ KEY_EN_COMMA, 0x4C },
|
||||
|
||||
{ KEY_EN_F8, 0x58 },
|
||||
{ KEY_EN_0, 0x59 },
|
||||
{ KEY_EN_O, 0x52 },
|
||||
{ KEY_EN_L, 0x53 },
|
||||
{ KEY_EN_PERIOD, 0x54 },
|
||||
{ KEY_EN_RIGHT_ALT, 0x4D },
|
||||
|
||||
{ KEY_EN_F9, 0x60 },
|
||||
{ KEY_EN_MINUS, 0x61 },
|
||||
{ KEY_EN_P, 0x5A },
|
||||
{ KEY_EN_SEMICOLON, 0x5B },
|
||||
{ KEY_EN_FORWARD_SLASH, 0x5C },
|
||||
{ KEY_EN_RIGHT_FUNCTION, 0x5D },
|
||||
|
||||
{ KEY_EN_F10, 0x68 },
|
||||
{ KEY_EN_EQUALS, 0x69 },
|
||||
{ KEY_EN_LEFT_BRACKET, 0x62 },
|
||||
{ KEY_EN_QUOTE, 0x63 },
|
||||
{ KEY_EN_MENU, 0x65 },
|
||||
|
||||
{ KEY_EN_F11, 0x70 },
|
||||
{ KEY_EN_BACKSPACE, 0x79 },
|
||||
{ KEY_EN_RIGHT_BRACKET, 0x6A },
|
||||
{ KEY_EN_RIGHT_SHIFT, 0x7C },
|
||||
|
||||
{ KEY_EN_F12, 0x78 },
|
||||
{ KEY_EN_ANSI_BACK_SLASH, 0x7A },
|
||||
{ KEY_EN_ANSI_ENTER, 0x7B },
|
||||
{ KEY_EN_RIGHT_CONTROL, 0x7D },
|
||||
|
||||
{ KEY_EN_PRINT_SCREEN, 0x80 },
|
||||
{ KEY_EN_INSERT, 0x81 },
|
||||
{ KEY_EN_DELETE, 0x82 },
|
||||
{ KEY_EN_LEFT_ARROW, 0x85 },
|
||||
|
||||
{ KEY_EN_SCROLL_LOCK, 0x88 },
|
||||
{ KEY_EN_HOME, 0x89 },
|
||||
{ KEY_EN_END, 0x8A },
|
||||
{ KEY_EN_UP_ARROW, 0x8C },
|
||||
{ KEY_EN_DOWN_ARROW, 0x8D },
|
||||
|
||||
{ KEY_EN_PAUSE_BREAK, 0x90 },
|
||||
{ KEY_EN_PAGE_UP, 0x91 },
|
||||
{ KEY_EN_PAGE_DOWN, 0x92 },
|
||||
{ KEY_EN_RIGHT_ARROW, 0x95 },
|
||||
|
||||
{ KEY_EN_NUMPAD_LOCK, 0x99 },
|
||||
{ KEY_EN_NUMPAD_7, 0x9A },
|
||||
{ KEY_EN_NUMPAD_4, 0x9B },
|
||||
{ KEY_EN_NUMPAD_1, 0x9C },
|
||||
{ KEY_EN_NUMPAD_0, 0x9D },
|
||||
|
||||
{ KEY_EN_NUMPAD_DIVIDE, 0xA1 },
|
||||
{ KEY_EN_NUMPAD_8, 0xA2 },
|
||||
{ KEY_EN_NUMPAD_5, 0xA3 },
|
||||
{ KEY_EN_NUMPAD_2, 0xA4 },
|
||||
|
||||
{ KEY_EN_NUMPAD_TIMES, 0xA9 },
|
||||
{ KEY_EN_NUMPAD_9, 0xAA },
|
||||
{ KEY_EN_NUMPAD_6, 0xAB },
|
||||
{ KEY_EN_NUMPAD_3, 0xAC },
|
||||
{ KEY_EN_NUMPAD_PERIOD, 0xAD },
|
||||
|
||||
{ KEY_EN_NUMPAD_MINUS, 0xB1 },
|
||||
{ KEY_EN_NUMPAD_PLUS, 0xB2 },
|
||||
{ KEY_EN_NUMPAD_ENTER, 0xB4 },
|
||||
|
||||
{ "Underglow LED 1", 0x06 },
|
||||
{ "Underglow LED 2", 0x0E },
|
||||
{ "Underglow LED 3", 0x16 },
|
||||
{ "Underglow LED 4", 0x1E },
|
||||
{ "Underglow LED 5", 0x26 },
|
||||
{ "Underglow LED 6", 0x2E },
|
||||
{ "Underglow LED 7", 0x36 },
|
||||
{ "Underglow LED 8", 0x3E },
|
||||
{ "Underglow LED 9", 0x46 },
|
||||
{ "Underglow LED 10", 0x4E },
|
||||
{ "Underglow LED 11", 0x56 },
|
||||
{ "Underglow LED 12", 0x5E },
|
||||
{ "Underglow LED 13", 0x66 },
|
||||
{ "Underglow LED 14", 0x6E },
|
||||
{ "Underglow LED 15", 0x76 },
|
||||
{ "Underglow LED 16", 0x7E },
|
||||
{ "Underglow LED 17", 0x86 },
|
||||
{ "Underglow LED 18", 0x8E },
|
||||
{ "Underglow LED 19", 0x96 },
|
||||
{ "Underglow LED 20", 0x9E },
|
||||
{ "Underglow LED 21", 0xA6 },
|
||||
{ "Underglow LED 22", 0xAE },
|
||||
{ "Underglow LED 23", 0xB6 },
|
||||
{ "Underglow LED 24", 0xBE },
|
||||
{ "Underglow LED 25", 0xC6 },
|
||||
{ "Underglow LED 26", 0xCE },
|
||||
{ "Underglow LED 27", 0xD6 },
|
||||
{ "Underglow LED 28", 0xDE },
|
||||
{ "Underglow LED 29", 0xE6 },
|
||||
{ "Underglow LED 30", 0xEE },
|
||||
}
|
||||
}
|
||||
},
|
||||
};
|
||||
|
||||
static std::map<int,layout_info> AsusFalchionLayouts =
|
||||
{
|
||||
{
|
||||
@@ -1678,39 +1302,3 @@ static std::map<int,layout_info> AsusClaymoreNumpadLeftLayouts =
|
||||
}
|
||||
},
|
||||
};
|
||||
|
||||
static std::map<int,layout_info> AsusTufK1Layouts =
|
||||
{
|
||||
{
|
||||
ASUS_TUF_K7_LAYOUT_UK,
|
||||
{
|
||||
*ASUS_TUF_K1_LAYOUT_KEYS,
|
||||
5,
|
||||
1,
|
||||
5,
|
||||
{
|
||||
{ "Keyboard LED 1", 0x00 },
|
||||
{ "Keyboard LED 2", 0x01 },
|
||||
{ "Keyboard LED 3", 0x02 },
|
||||
{ "Keyboard LED 4", 0x03 },
|
||||
{ "Keyboard LED 5", 0x04 },
|
||||
}
|
||||
}
|
||||
},
|
||||
{
|
||||
ASUS_TUF_K7_LAYOUT_US,
|
||||
{
|
||||
*ASUS_TUF_K1_LAYOUT_KEYS,
|
||||
5,
|
||||
1,
|
||||
5,
|
||||
{
|
||||
{ "Keyboard LED 1", 0x00 },
|
||||
{ "Keyboard LED 2", 0x01 },
|
||||
{ "Keyboard LED 3", 0x02 },
|
||||
{ "Keyboard LED 4", 0x03 },
|
||||
{ "Keyboard LED 5", 0x04 },
|
||||
}
|
||||
}
|
||||
},
|
||||
};
|
||||
|
||||
@@ -6,7 +6,6 @@
|
||||
#include "AsusAuraMainboardController.h"
|
||||
#include "AsusAuraMouseController.h"
|
||||
#include "AsusAuraMousematController.h"
|
||||
#include "AsusROGAllyController.h"
|
||||
#include "AsusAuraStrixEvolveController.h"
|
||||
#include "AsusAuraMonitorController.h"
|
||||
#include "AsusAuraRyuoAIOController.h"
|
||||
@@ -17,7 +16,6 @@
|
||||
#include "RGBController_AsusAuraTUFKeyboard.h"
|
||||
#include "RGBController_AsusAuraMouse.h"
|
||||
#include "RGBController_AsusAuraMousemat.h"
|
||||
#include "RGBController_AsusROGAlly.h"
|
||||
#include "RGBController_ROGStrixLC_Controller.h"
|
||||
#include "RGBController_AsusAuraStrixEvolve.h"
|
||||
#include "RGBController_AsusAuraMonitor.h"
|
||||
@@ -47,17 +45,13 @@
|
||||
#define AURA_ROG_STRIX_FLARE_PID 0x1875
|
||||
#define AURA_ROG_STRIX_FLARE_PNK_LTD_PID 0x18CF
|
||||
#define AURA_ROG_STRIX_FLARE_COD_BO4_PID 0x18AF
|
||||
#define AURA_ROG_STRIX_FLARE_II_ANIMATE_PID 0x19FC
|
||||
#define AURA_ROG_STRIX_SCOPE_PID 0x18F8
|
||||
#define AURA_ROG_STRIX_SCOPE_RX_PID 0x1951
|
||||
#define AURA_ROG_STRIX_SCOPE_TKL_PID 0x190C
|
||||
#define AURA_ROG_STRIX_SCOPE_RX_TKL_DELUXE_PID 0x1A05
|
||||
#define AURA_ROG_STRIX_SCOPE_TKL_PNK_LTD_PID 0x1954
|
||||
#define AURA_ROG_CLAYMORE_PID 0x184D
|
||||
#define AURA_TUF_K1_GAMING_PID 0x1945
|
||||
#define AURA_TUF_K3_GAMING_PID 0x194B
|
||||
#define AURA_TUF_K5_GAMING_PID 0x1899
|
||||
#define AURA_TUF_K7_GAMING_PID 0x18AA
|
||||
#define AURA_TUF_K3_GAMING_PID 0x194B
|
||||
|
||||
/*-----------------------------------------------------------------*\
|
||||
| MICE - defined in AsusAuraMouseDevices.h |
|
||||
@@ -77,7 +71,6 @@
|
||||
|
||||
#define AURA_ROG_STRIX_XG27AQ_PID 0x198C
|
||||
#define AURA_ROG_STRIX_XG27AQM_PID 0x19BB
|
||||
#define AURA_ROG_STRIX_XG279Q_PID 0x1919
|
||||
#define AURA_ROG_STRIX_XG27W_PID 0x1933
|
||||
#define AURA_ROG_PG32UQ_PID 0x19B9
|
||||
|
||||
@@ -95,7 +88,6 @@
|
||||
#define AURA_TERMINAL_PID 0x1889
|
||||
#define ROG_STRIX_LC120_PID 0x879E
|
||||
#define AURA_RYUO_AIO_PID 0x1887
|
||||
#define ASUS_ROG_ALLY_PID 0x1ABE
|
||||
|
||||
AuraKeyboardMappingLayoutType GetKeyboardMappingLayoutType(int pid)
|
||||
{
|
||||
@@ -113,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;
|
||||
|
||||
@@ -195,15 +186,6 @@ void DetectAsusAuraUSBMice(hid_device_info* info, const std::string& name)
|
||||
RGBController_AuraMouse* rgb_controller = new RGBController_AuraMouse(controller);
|
||||
rgb_controller->name = name;
|
||||
ResourceManager::get()->RegisterRGBController(rgb_controller);
|
||||
|
||||
// adding the mouse dock for the ASUS ROG Spatha X
|
||||
if(info->product_id == AURA_ROG_SPATHA_X_2_4_PID)
|
||||
{
|
||||
AuraMouseController* dock_controller = new AuraMouseController(dev, info->path, AURA_ROG_SPATHA_X_DOCK_FAKE_PID);
|
||||
RGBController_AuraMouse* rgb_controller_dock = new RGBController_AuraMouse(dock_controller);
|
||||
rgb_controller_dock->name = "Asus ROG Spatha X Dock";
|
||||
ResourceManager::get()->RegisterRGBController(rgb_controller_dock);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -298,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 |
|
||||
\*-----------------------------------------------------------------*/
|
||||
@@ -331,16 +300,12 @@ REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Flare CoD Black Ops 4 Edition",DetectAs
|
||||
REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Scope", DetectAsusAuraUSBKeyboards, AURA_USB_VID, AURA_ROG_STRIX_SCOPE_PID, 1, 0xFF00);
|
||||
REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Scope RX", DetectAsusAuraUSBKeyboards, AURA_USB_VID, AURA_ROG_STRIX_SCOPE_RX_PID, 1, 0xFF00);
|
||||
REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Scope TKL", DetectAsusAuraUSBKeyboards, AURA_USB_VID, AURA_ROG_STRIX_SCOPE_TKL_PID, 1, 0xFF00);
|
||||
REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Scope RX TKL Wireless Deluxe", DetectAsusAuraUSBKeyboards, AURA_USB_VID, AURA_ROG_STRIX_SCOPE_RX_TKL_DELUXE_PID, 1, 0xFF00);
|
||||
REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Scope TKL PNK LTD", DetectAsusAuraUSBKeyboards, AURA_USB_VID, AURA_ROG_STRIX_SCOPE_TKL_PNK_LTD_PID, 1, 0xFF00);
|
||||
REGISTER_HID_DETECTOR_IP("ASUS ROG Claymore", DetectAsusAuraTUFUSBKeyboard, AURA_USB_VID, AURA_ROG_CLAYMORE_PID, 1, 0xFF00);
|
||||
REGISTER_HID_DETECTOR_IP("ASUS ROG Falchion (Wired)", DetectAsusAuraTUFUSBKeyboard, AURA_USB_VID, AURA_ROG_FALCHION_WIRED_PID, 1, 0xFF00);
|
||||
REGISTER_HID_DETECTOR_IP("ASUS ROG Falchion (Wireless)", DetectAsusAuraTUFUSBKeyboard, AURA_USB_VID, AURA_ROG_FALCHION_WIRELESS_PID, 1, 0xFF00);
|
||||
REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Flare II Animate", DetectAsusAuraTUFUSBKeyboard, AURA_USB_VID, AURA_ROG_STRIX_FLARE_II_ANIMATE_PID, 1, 0xFF00);
|
||||
REGISTER_HID_DETECTOR_IP("ASUS TUF Gaming K1", DetectAsusAuraTUFUSBKeyboard, AURA_USB_VID, AURA_TUF_K1_GAMING_PID, 2, 0xFF00);
|
||||
REGISTER_HID_DETECTOR_IP("ASUS TUF Gaming K3", DetectAsusAuraTUFUSBKeyboard, AURA_USB_VID, AURA_TUF_K3_GAMING_PID, 1, 0xFF00);
|
||||
REGISTER_HID_DETECTOR_IP("ASUS TUF Gaming K5", DetectAsusAuraTUFUSBKeyboard, AURA_USB_VID, AURA_TUF_K5_GAMING_PID, 2, 0xFF00);
|
||||
REGISTER_HID_DETECTOR_IP("ASUS TUF Gaming K7", DetectAsusAuraTUFUSBKeyboard, AURA_USB_VID, AURA_TUF_K7_GAMING_PID, 1, 0xFF00);
|
||||
REGISTER_HID_DETECTOR_IP("ASUS TUF Gaming K3", DetectAsusAuraTUFUSBKeyboard, AURA_USB_VID, AURA_TUF_K3_GAMING_PID, 1, 0xFF00);
|
||||
|
||||
/*-----------------------------------------------------------------*\
|
||||
| MICE |
|
||||
@@ -361,12 +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 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);
|
||||
@@ -393,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);
|
||||
|
||||
@@ -406,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
|
||||
{
|
||||
|
||||
@@ -9,12 +9,11 @@
|
||||
|
||||
#include "RGBController_AsusAuraMouse.h"
|
||||
|
||||
static std::string aura_mouse_zone_names[4]
|
||||
static std::string aura_mouse_zone_names[3]
|
||||
{
|
||||
"Logo",
|
||||
"Scroll Wheel",
|
||||
"Underglow",
|
||||
"Dock"
|
||||
"Underglow"
|
||||
};
|
||||
|
||||
/**------------------------------------------------------------------*\
|
||||
@@ -206,7 +205,7 @@ void RGBController_AuraMouse::DeviceUpdateLEDs()
|
||||
}
|
||||
}
|
||||
|
||||
void RGBController_AuraMouse::UpdateZoneLEDs(int /*zone*/)
|
||||
void RGBController_AuraMouse::UpdateZoneLEDs(int zone)
|
||||
{
|
||||
DeviceUpdateLEDs();
|
||||
}
|
||||
@@ -239,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,41 +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_TUF_K3_GAMING_PID:
|
||||
case AURA_TUF_K7_GAMING_PID:
|
||||
AURA_KEYBOARD_SPEED_MIN = 15;
|
||||
AURA_KEYBOARD_SPEED_MAX = 0;
|
||||
AURA_KEYBOARD_SPEED_DEFAULT = 8;
|
||||
break;
|
||||
case AURA_TUF_K5_GAMING_PID:
|
||||
AURA_KEYBOARD_SPEED_MIN = 63;
|
||||
AURA_KEYBOARD_SPEED_MAX = 0;
|
||||
AURA_KEYBOARD_SPEED_DEFAULT = 31;
|
||||
break;
|
||||
case AURA_ROG_FALCHION_WIRED_PID:
|
||||
case AURA_ROG_FALCHION_WIRELESS_PID:
|
||||
case AURA_ROG_STRIX_FLARE_II_ANIMATE_PID:
|
||||
AURA_KEYBOARD_SPEED_MIN = 255;
|
||||
AURA_KEYBOARD_SPEED_MAX = 0;
|
||||
AURA_KEYBOARD_SPEED_DEFAULT = 8;
|
||||
break;
|
||||
default:
|
||||
AURA_KEYBOARD_SPEED_MIN = 15;
|
||||
AURA_KEYBOARD_SPEED_MAX = 0;
|
||||
AURA_KEYBOARD_SPEED_DEFAULT = 8;
|
||||
}
|
||||
|
||||
mode Direct;
|
||||
Direct.name = "Direct";
|
||||
Direct.value = AURA_KEYBOARD_MODE_DIRECT;
|
||||
@@ -96,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;
|
||||
@@ -127,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;
|
||||
@@ -138,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
|
||||
{
|
||||
@@ -393,17 +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_TUF_K3_GAMING_PID:
|
||||
case AURA_TUF_K7_GAMING_PID:
|
||||
keyboard_ptr = &AsusTUFK7Layouts;
|
||||
break;
|
||||
case AURA_ROG_STRIX_FLARE_II_ANIMATE_PID:
|
||||
keyboard_ptr = &AsusROGStrixFlareIILayouts;
|
||||
break;
|
||||
case AURA_ROG_FALCHION_WIRED_PID:
|
||||
case AURA_ROG_FALCHION_WIRELESS_PID:
|
||||
keyboard_ptr = &AsusFalchionLayouts;
|
||||
@@ -426,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())
|
||||
{
|
||||
/*---------------------------------------------------------*\
|
||||
@@ -487,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] });
|
||||
}
|
||||
@@ -502,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]);
|
||||
@@ -548,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)
|
||||
@@ -568,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 |
|
||||
@@ -593,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
|
||||
|
||||
@@ -1,196 +0,0 @@
|
||||
/*-----------------------------------------*\
|
||||
| RGBController_AsusROGAlly.cpp |
|
||||
| |
|
||||
| Generic RGB Interface for Asus ROG Ally |
|
||||
| controller driver |
|
||||
| |
|
||||
| Adam Honse (CalcProgrammer1) 6/12/2023 |
|
||||
\*-----------------------------------------*/
|
||||
|
||||
#include "RGBController_AsusROGAlly.h"
|
||||
|
||||
/**------------------------------------------------------------------*\
|
||||
@name Asus ROG Ally
|
||||
@category Gamepad
|
||||
@type USB
|
||||
@save :x:
|
||||
@direct :white_check_mark:
|
||||
@effects :x:
|
||||
@detectors DetectAsusROGAlly
|
||||
@comment
|
||||
\*-------------------------------------------------------------------*/
|
||||
|
||||
RGBController_AsusROGAlly::RGBController_AsusROGAlly(ROGAllyController* controller_ptr)
|
||||
{
|
||||
controller = controller_ptr;
|
||||
|
||||
name = "ASUS ROG Ally";
|
||||
vendor = "ASUS";
|
||||
type = DEVICE_TYPE_GAMEPAD;
|
||||
description = "ASUS ROG Ally Device";
|
||||
version = controller->GetVersion();
|
||||
location = controller->GetDeviceLocation();
|
||||
serial = controller->GetSerialString();
|
||||
|
||||
mode Direct;
|
||||
Direct.name = "Direct";
|
||||
Direct.value = ROG_ALLY_MODE_DIRECT;
|
||||
Direct.flags = MODE_FLAG_HAS_PER_LED_COLOR;
|
||||
Direct.color_mode = MODE_COLORS_PER_LED;
|
||||
modes.push_back(Direct);
|
||||
|
||||
mode Static;
|
||||
Static.name = "Static";
|
||||
Static.value = ROG_ALLY_MODE_STATIC;
|
||||
Static.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_MANUAL_SAVE;
|
||||
Static.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Static.colors_min = 1;
|
||||
Static.colors_max = 1;
|
||||
Static.colors.resize(1);
|
||||
modes.push_back(Static);
|
||||
|
||||
mode Breathing;
|
||||
Breathing.name = "Breathing";
|
||||
Breathing.value = ROG_ALLY_MODE_BREATHING;
|
||||
Breathing.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_SPEED;
|
||||
Breathing.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Breathing.speed_min = ROG_ALLY_SPEED_MIN;
|
||||
Breathing.speed_max = ROG_ALLY_SPEED_MAX;
|
||||
Breathing.speed = ROG_ALLY_SPEED_MED;
|
||||
Breathing.colors_min = 2;
|
||||
Breathing.colors_max = 2;
|
||||
Breathing.colors.resize(2);
|
||||
modes.push_back(Breathing);
|
||||
|
||||
mode ColorCycle;
|
||||
ColorCycle.name = "Spectrum Cycle";
|
||||
ColorCycle.value = ROG_ALLY_MODE_COLOR_CYCLE;
|
||||
ColorCycle.flags = MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_SPEED;
|
||||
ColorCycle.color_mode = MODE_COLORS_RANDOM;
|
||||
ColorCycle.speed_min = ROG_ALLY_SPEED_MIN;
|
||||
ColorCycle.speed_max = ROG_ALLY_SPEED_MAX;
|
||||
ColorCycle.speed = ROG_ALLY_SPEED_MED;
|
||||
modes.push_back(ColorCycle);
|
||||
|
||||
mode Rainbow;
|
||||
Rainbow.name = "Rainbow Wave";
|
||||
Rainbow.value = ROG_ALLY_MODE_RAINBOW;
|
||||
Rainbow.flags = MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
|
||||
Rainbow.color_mode = MODE_COLORS_RANDOM;
|
||||
Rainbow.speed_min = ROG_ALLY_SPEED_MIN;
|
||||
Rainbow.speed_max = ROG_ALLY_SPEED_MAX;
|
||||
Rainbow.speed = ROG_ALLY_SPEED_MED;
|
||||
modes.push_back(Rainbow);
|
||||
|
||||
mode Strobing;
|
||||
Strobing.name = "Strobing";
|
||||
Strobing.value = ROG_ALLY_MODE_STROBING;
|
||||
Strobing.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_MANUAL_SAVE;
|
||||
Strobing.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Strobing.colors_min = 1;
|
||||
Strobing.colors_max = 1;
|
||||
Strobing.colors.resize(1);
|
||||
modes.push_back(Strobing);
|
||||
|
||||
SetupZones();
|
||||
}
|
||||
|
||||
RGBController_AsusROGAlly::~RGBController_AsusROGAlly()
|
||||
{
|
||||
delete controller;
|
||||
}
|
||||
|
||||
void RGBController_AsusROGAlly::SetupZones()
|
||||
{
|
||||
zone left_stick_zone;
|
||||
|
||||
left_stick_zone.name = "Left Stick";
|
||||
left_stick_zone.type = ZONE_TYPE_SINGLE;
|
||||
left_stick_zone.leds_min = 2;
|
||||
left_stick_zone.leds_max = 2;
|
||||
left_stick_zone.leds_count = 2;
|
||||
left_stick_zone.matrix_map = NULL;
|
||||
|
||||
zones.push_back(left_stick_zone);
|
||||
|
||||
for(unsigned int i = 0; i < 2; i++)
|
||||
{
|
||||
led left_stick_led;
|
||||
|
||||
left_stick_led.name = "Left Stick LED " + std::to_string(i);
|
||||
|
||||
leds.push_back(left_stick_led);
|
||||
}
|
||||
|
||||
zone right_stick_zone;
|
||||
|
||||
right_stick_zone.name = "Right Stick";
|
||||
right_stick_zone.type = ZONE_TYPE_SINGLE;
|
||||
right_stick_zone.leds_min = 2;
|
||||
right_stick_zone.leds_max = 2;
|
||||
right_stick_zone.leds_count = 2;
|
||||
right_stick_zone.matrix_map = NULL;
|
||||
|
||||
zones.push_back(right_stick_zone);
|
||||
|
||||
for(unsigned int i = 0; i < 2; i++)
|
||||
{
|
||||
led right_stick_led;
|
||||
|
||||
right_stick_led.name = "Right Stick LED " + std::to_string(i);
|
||||
|
||||
leds.push_back(right_stick_led);
|
||||
}
|
||||
|
||||
SetupColors();
|
||||
}
|
||||
|
||||
void RGBController_AsusROGAlly::ResizeZone(int /*zone*/, int /*new_size*/)
|
||||
{
|
||||
/*---------------------------------------------------------*\
|
||||
| This device does not support resizing zones |
|
||||
\*---------------------------------------------------------*/
|
||||
}
|
||||
|
||||
void RGBController_AsusROGAlly::DeviceUpdateLEDs()
|
||||
{
|
||||
if(modes[active_mode].value == ROG_ALLY_MODE_DIRECT)
|
||||
{
|
||||
controller->UpdateLeds(std::vector<RGBColor>(colors));
|
||||
}
|
||||
}
|
||||
|
||||
void RGBController_AsusROGAlly::UpdateZoneLEDs(int /*zone*/)
|
||||
{
|
||||
DeviceUpdateLEDs();
|
||||
}
|
||||
|
||||
void RGBController_AsusROGAlly::UpdateSingleLED(int /*led*/)
|
||||
{
|
||||
DeviceUpdateLEDs();
|
||||
}
|
||||
|
||||
void RGBController_AsusROGAlly::DeviceUpdateMode()
|
||||
{
|
||||
if(modes[active_mode].value == ROG_ALLY_MODE_DIRECT)
|
||||
{
|
||||
DeviceUpdateLEDs();
|
||||
}
|
||||
else
|
||||
{
|
||||
unsigned int rog_ally_direction = ROG_ALLY_DIRECTION_RIGHT;
|
||||
|
||||
if((modes[active_mode].flags & MODE_FLAG_HAS_DIRECTION_LR) && (modes[active_mode].direction == MODE_DIRECTION_LEFT))
|
||||
{
|
||||
rog_ally_direction = ROG_ALLY_DIRECTION_LEFT;
|
||||
}
|
||||
|
||||
controller->UpdateDevice(modes[active_mode].value, modes[active_mode].colors, modes[active_mode].speed, modes[active_mode].brightness, rog_ally_direction);
|
||||
}
|
||||
}
|
||||
|
||||
void RGBController_AsusROGAlly::DeviceSaveMode()
|
||||
{
|
||||
DeviceUpdateMode();
|
||||
controller->SaveMode();
|
||||
}
|
||||
@@ -1,34 +0,0 @@
|
||||
/*-----------------------------------------*\
|
||||
| RGBController_AsusROGAlly.cpp |
|
||||
| |
|
||||
| Generic RGB Interface for Asus ROG Ally |
|
||||
| controller driver |
|
||||
| |
|
||||
| Adam Honse (CalcProgrammer1) 6/12/2023 |
|
||||
\*-----------------------------------------*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include "RGBController.h"
|
||||
#include "AsusROGAllyController.h"
|
||||
|
||||
class RGBController_AsusROGAlly : public RGBController
|
||||
{
|
||||
public:
|
||||
RGBController_AsusROGAlly(ROGAllyController* controller_ptr);
|
||||
~RGBController_AsusROGAlly();
|
||||
|
||||
void SetupZones();
|
||||
|
||||
void ResizeZone(int zone, int new_size);
|
||||
|
||||
void DeviceUpdateLEDs();
|
||||
void UpdateZoneLEDs(int zone);
|
||||
void UpdateSingleLED(int led);
|
||||
|
||||
void DeviceUpdateMode();
|
||||
void DeviceSaveMode();
|
||||
|
||||
private:
|
||||
ROGAllyController* controller;
|
||||
};
|
||||
@@ -23,7 +23,7 @@ ROGStrixLC_Controller::ROGStrixLC_Controller(hid_device* dev_handle, const char*
|
||||
|
||||
ROGStrixLC_Controller::~ROGStrixLC_Controller()
|
||||
{
|
||||
// Device will close at AuraUSBController destructor
|
||||
hid_close(dev);
|
||||
}
|
||||
|
||||
std::string ROGStrixLC_Controller::GetLocation()
|
||||
|
||||
@@ -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,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);
|
||||
@@ -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;
|
||||
};
|
||||
@@ -37,18 +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 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,144 +0,0 @@
|
||||
#include "ColorfulTuringGPUController.h"
|
||||
#include <cstring>
|
||||
|
||||
ColorfulTuringGPUController::ColorfulTuringGPUController(i2c_smbus_interface* bus, colorful_gpu_dev_id dev)
|
||||
{
|
||||
this->bus = bus;
|
||||
this->dev = dev;
|
||||
}
|
||||
|
||||
ColorfulTuringGPUController::~ColorfulTuringGPUController()
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
std::string ColorfulTuringGPUController::GetDeviceLocation()
|
||||
{
|
||||
std::string return_string(bus->device_name);
|
||||
char addr[5];
|
||||
snprintf(addr, 5, "0x%02X", dev);
|
||||
return_string.append(", address ");
|
||||
return_string.append(addr);
|
||||
return("I2C: " + return_string);
|
||||
}
|
||||
|
||||
int ColorfulTuringGPUController::GetMode()
|
||||
{
|
||||
uint8_t data_pkt[COLORFUL_MODE_PACKET_LENGTH];
|
||||
int size = COLORFUL_MODE_PACKET_LENGTH;
|
||||
bus->i2c_read_block(dev, &size, data_pkt);
|
||||
|
||||
int mode = data_pkt[2]<<16 | data_pkt[3]<<8 | data_pkt[4];
|
||||
|
||||
return mode;
|
||||
}
|
||||
|
||||
RGBColor ColorfulTuringGPUController::GetColor()
|
||||
{
|
||||
uint8_t data_pkt[COLORFUL_MODE_PACKET_LENGTH];
|
||||
int size = COLORFUL_MODE_PACKET_LENGTH;
|
||||
bus->i2c_read_block(dev, &size, data_pkt);
|
||||
|
||||
RGBColor color = ToRGBColor(data_pkt[5], data_pkt[6], data_pkt[7]);
|
||||
|
||||
return color;
|
||||
}
|
||||
|
||||
void ColorfulTuringGPUController::SetStateDisplay(RGBColor color)
|
||||
{
|
||||
uint8_t r = RGBGetRValue(color);
|
||||
uint8_t g = RGBGetGValue(color);
|
||||
uint8_t b = RGBGetBValue(color);
|
||||
uint8_t data_pkt[COLORFUL_COLOR_PACKET_LENGTH] = { 0x08, 0x01, 0x32, 0x04, r, g, b};
|
||||
|
||||
int crc = 1;
|
||||
|
||||
for(int i = 0; i < COLORFUL_COLOR_PACKET_LENGTH - 1; ++i)
|
||||
{
|
||||
crc += data_pkt[i];
|
||||
}
|
||||
crc &= 0xFF;
|
||||
crc = 256-crc;
|
||||
|
||||
data_pkt[COLORFUL_COLOR_PACKET_LENGTH - 1] = crc & 0xFF;
|
||||
|
||||
bus->i2c_write_block(dev, COLORFUL_COLOR_PACKET_LENGTH, data_pkt);
|
||||
}
|
||||
|
||||
void ColorfulTuringGPUController::SetDirect(RGBColor color)
|
||||
{
|
||||
uint8_t r = RGBGetRValue(color);
|
||||
uint8_t g = RGBGetGValue(color);
|
||||
uint8_t b = RGBGetBValue(color);
|
||||
uint8_t data_pkt[COLORFUL_COLOR_PACKET_LENGTH] = { 0x88, 0x02, 0x32, 0x02, r, g, b};
|
||||
|
||||
int crc = 1;
|
||||
|
||||
for(int i = 0; i < COLORFUL_COLOR_PACKET_LENGTH - 1; ++i)
|
||||
{
|
||||
crc += data_pkt[i];
|
||||
}
|
||||
crc &= 0xFF;
|
||||
crc = 256-crc;
|
||||
|
||||
data_pkt[COLORFUL_COLOR_PACKET_LENGTH - 1] = crc & 0xFF;
|
||||
|
||||
bus->i2c_write_block(dev, COLORFUL_COLOR_PACKET_LENGTH, data_pkt);
|
||||
}
|
||||
|
||||
void ColorfulTuringGPUController::SetBreathing(RGBColor color)
|
||||
{
|
||||
uint8_t r = RGBGetRValue(color);
|
||||
uint8_t g = RGBGetGValue(color);
|
||||
uint8_t b = RGBGetBValue(color);
|
||||
uint8_t data_pkt[COLORFUL_COLOR_PACKET_LENGTH] = { 0x88, 0x01, 0x32, 0x02, r, g, b};
|
||||
|
||||
int crc = 1;
|
||||
|
||||
for(int i = 0; i < COLORFUL_COLOR_PACKET_LENGTH - 1; ++i)
|
||||
{
|
||||
crc += data_pkt[i];
|
||||
}
|
||||
crc &= 0xFF;
|
||||
crc = 256-crc;
|
||||
|
||||
data_pkt[COLORFUL_COLOR_PACKET_LENGTH - 1] = crc & 0xFF;
|
||||
|
||||
bus->i2c_write_block(dev, COLORFUL_COLOR_PACKET_LENGTH, data_pkt);
|
||||
}
|
||||
|
||||
void ColorfulTuringGPUController::SetOff()
|
||||
{
|
||||
uint8_t data_pkt[COLORFUL_NON_COLOR_PACKET_LENGTH] = { 0x85, 0x00, 0x00, 0x0A };
|
||||
|
||||
int crc = 1;
|
||||
|
||||
for(int i = 0; i < COLORFUL_NON_COLOR_PACKET_LENGTH - 1; ++i)
|
||||
{
|
||||
crc += data_pkt[i];
|
||||
}
|
||||
crc &= 0xFF;
|
||||
crc = 256-crc;
|
||||
|
||||
data_pkt[COLORFUL_NON_COLOR_PACKET_LENGTH - 1] = crc & 0xFF;
|
||||
|
||||
bus->i2c_write_block(dev, COLORFUL_NON_COLOR_PACKET_LENGTH, data_pkt);
|
||||
}
|
||||
|
||||
void ColorfulTuringGPUController::SetRainbow()
|
||||
{
|
||||
uint8_t data_pkt[COLORFUL_NON_COLOR_PACKET_LENGTH] = { 0x85, 0x04, 0x32, 0x02 };
|
||||
|
||||
int crc = 1;
|
||||
|
||||
for(int i = 0; i < COLORFUL_NON_COLOR_PACKET_LENGTH - 1; ++i)
|
||||
{
|
||||
crc += data_pkt[i];
|
||||
}
|
||||
crc &= 0xFF;
|
||||
crc = 256-crc;
|
||||
|
||||
data_pkt[COLORFUL_NON_COLOR_PACKET_LENGTH - 1] = crc & 0xFF;
|
||||
|
||||
bus->i2c_write_block(dev, COLORFUL_NON_COLOR_PACKET_LENGTH, data_pkt);
|
||||
}
|
||||
@@ -1,41 +0,0 @@
|
||||
#include <string>
|
||||
#include "i2c_smbus.h"
|
||||
#include "RGBController.h"
|
||||
|
||||
#pragma once
|
||||
|
||||
typedef unsigned char colorful_gpu_dev_id;
|
||||
|
||||
#define COLORFUL_COLOR_PACKET_LENGTH 8
|
||||
#define COLORFUL_NON_COLOR_PACKET_LENGTH 5
|
||||
#define COLORFUL_MODE_PACKET_LENGTH 0x1B
|
||||
|
||||
enum
|
||||
{
|
||||
COLORFUL_TURING_GPU_RGB_MODE_STATE_DISPLAY = 0x013204,
|
||||
COLORFUL_TURING_GPU_RGB_MODE_OFF = 0x00000A,
|
||||
COLORFUL_TURING_GPU_RGB_MODE_STATIC = 0x023202,
|
||||
COLORFUL_TURING_GPU_RGB_MODE_RAINBOW = 0x043202,
|
||||
COLORFUL_TURING_GPU_RGB_MODE_BREATHING = 0x013202,
|
||||
};
|
||||
|
||||
class ColorfulTuringGPUController
|
||||
{
|
||||
public:
|
||||
ColorfulTuringGPUController(i2c_smbus_interface* bus, colorful_gpu_dev_id dev);
|
||||
~ColorfulTuringGPUController();
|
||||
|
||||
std::string GetDeviceLocation();
|
||||
int GetMode();
|
||||
RGBColor GetColor();
|
||||
void SetDirect(RGBColor color);
|
||||
void SetStateDisplay(RGBColor color);
|
||||
void SetBreathing(RGBColor color);
|
||||
void SetOff();
|
||||
void SetRainbow();
|
||||
|
||||
|
||||
private:
|
||||
i2c_smbus_interface * bus;
|
||||
colorful_gpu_dev_id dev;
|
||||
};
|
||||
@@ -1,23 +0,0 @@
|
||||
#include "Detector.h"
|
||||
#include "ColorfulTuringGPUController.h"
|
||||
#include "RGBController.h"
|
||||
#include "RGBController_ColorfulTuringGPU.h"
|
||||
#include "i2c_smbus.h"
|
||||
#include "pci_ids.h"
|
||||
#include <vector>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
void DetectColorfulTuringGPUControllers(i2c_smbus_interface* bus, uint8_t i2c_addr, const std::string& name)
|
||||
{
|
||||
if(bus->port_id == 1)
|
||||
{
|
||||
ColorfulTuringGPUController* controller = new ColorfulTuringGPUController(bus, i2c_addr);
|
||||
RGBController_ColorfulTuringGPU* rgb_controller = new RGBController_ColorfulTuringGPU(controller);
|
||||
rgb_controller->name = name;
|
||||
|
||||
ResourceManager::get()->RegisterRGBController(rgb_controller);
|
||||
}
|
||||
}
|
||||
|
||||
REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 2070 SUPER Advanced OC-V", DetectColorfulTuringGPUControllers, NVIDIA_VEN, NVIDIA_RTX2070S_OC_DEV, COLORFUL_SUB_VEN, COLORFUL_IGAME_RTX_2070_SUPER_ADVANCED_OCV, 0x50);
|
||||
@@ -1,145 +0,0 @@
|
||||
#include "RGBController_ColorfulTuringGPU.h"
|
||||
#include <array>
|
||||
|
||||
/**------------------------------------------------------------------*\
|
||||
@name Colorful GPU
|
||||
@category GPU
|
||||
@type I2C
|
||||
@save :x:
|
||||
@direct :white_check_mark:
|
||||
@effects :white_check_mark:
|
||||
@detectors DetectColorfulTuringGPUControllers
|
||||
@comment This card supports off, direct, rainbow and pulse mode.
|
||||
\*-------------------------------------------------------------------*/
|
||||
|
||||
RGBController_ColorfulTuringGPU::RGBController_ColorfulTuringGPU(ColorfulTuringGPUController * colorful_gpu_ptr)
|
||||
{
|
||||
controller = colorful_gpu_ptr;
|
||||
name = "Colorful GPU Device";
|
||||
vendor = "Colorful";
|
||||
type = DEVICE_TYPE_GPU;
|
||||
description = name;
|
||||
location = controller->GetDeviceLocation();
|
||||
|
||||
mode Off;
|
||||
Off.name = "Off";
|
||||
Off.value = COLORFUL_TURING_GPU_RGB_MODE_OFF;
|
||||
Off.flags = 0;
|
||||
Off.color_mode = MODE_COLORS_NONE;
|
||||
modes.push_back(Off);
|
||||
|
||||
mode Direct;
|
||||
Direct.name = "Direct";
|
||||
Direct.value = COLORFUL_TURING_GPU_RGB_MODE_STATIC;
|
||||
Direct.flags = MODE_FLAG_HAS_PER_LED_COLOR;
|
||||
Direct.color_mode = MODE_COLORS_PER_LED;
|
||||
modes.push_back(Direct);
|
||||
|
||||
mode StateDisplay;
|
||||
StateDisplay.name = "State Display";
|
||||
StateDisplay.value = COLORFUL_TURING_GPU_RGB_MODE_STATE_DISPLAY;
|
||||
StateDisplay.flags = MODE_FLAG_HAS_PER_LED_COLOR;
|
||||
StateDisplay.color_mode = MODE_COLORS_PER_LED;
|
||||
modes.push_back(StateDisplay);
|
||||
|
||||
mode Rainbow;
|
||||
Rainbow.name = "Spectrum Cycle";
|
||||
Rainbow.value = COLORFUL_TURING_GPU_RGB_MODE_RAINBOW;
|
||||
Rainbow.color_mode = MODE_COLORS_NONE;
|
||||
modes.push_back(Rainbow);
|
||||
|
||||
mode Breathing;
|
||||
Breathing.name = "Breathing";
|
||||
Breathing.value = COLORFUL_TURING_GPU_RGB_MODE_BREATHING;
|
||||
Breathing.flags = MODE_FLAG_HAS_PER_LED_COLOR;
|
||||
Breathing.color_mode = MODE_COLORS_PER_LED;
|
||||
modes.push_back(Breathing);
|
||||
|
||||
SetupZones();
|
||||
|
||||
// Initialize active mode
|
||||
active_mode = getModeIndex(controller->GetMode());
|
||||
colors[0] = controller->GetColor();
|
||||
|
||||
}
|
||||
|
||||
RGBController_ColorfulTuringGPU::~RGBController_ColorfulTuringGPU()
|
||||
{
|
||||
delete controller;
|
||||
}
|
||||
|
||||
int RGBController_ColorfulTuringGPU::getModeIndex(int mode_value)
|
||||
{
|
||||
for(std::size_t mode_index = 0; mode_index < modes.size(); mode_index++)
|
||||
{
|
||||
if (modes[mode_index].value == mode_value)
|
||||
{
|
||||
return mode_index;
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
void RGBController_ColorfulTuringGPU::SetupZones()
|
||||
{
|
||||
zone new_zone;
|
||||
|
||||
new_zone.name = "GPU";
|
||||
new_zone.type = ZONE_TYPE_LINEAR;
|
||||
new_zone.leds_min = 1;
|
||||
new_zone.leds_max = 1;
|
||||
new_zone.leds_count = 1;
|
||||
new_zone.matrix_map = nullptr;
|
||||
|
||||
zones.emplace_back(new_zone);
|
||||
|
||||
leds.resize(new_zone.leds_count);
|
||||
leds[0].name = "GPU LED";
|
||||
|
||||
SetupColors();
|
||||
}
|
||||
|
||||
void RGBController_ColorfulTuringGPU::ResizeZone(int /*zone*/, int /*new_size*/)
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
void RGBController_ColorfulTuringGPU::DeviceUpdateLEDs()
|
||||
{
|
||||
switch(modes[active_mode].value)
|
||||
{
|
||||
case COLORFUL_TURING_GPU_RGB_MODE_BREATHING:
|
||||
controller->SetBreathing(colors[0]);
|
||||
break;
|
||||
case COLORFUL_TURING_GPU_RGB_MODE_OFF:
|
||||
controller->SetOff();
|
||||
break;
|
||||
case COLORFUL_TURING_GPU_RGB_MODE_RAINBOW:
|
||||
controller->SetRainbow();
|
||||
break;
|
||||
case COLORFUL_TURING_GPU_RGB_MODE_STATE_DISPLAY:
|
||||
controller->SetStateDisplay(colors[0]);
|
||||
break;
|
||||
case COLORFUL_TURING_GPU_RGB_MODE_STATIC:
|
||||
controller->SetDirect(colors[0]);
|
||||
break;
|
||||
default:
|
||||
controller->SetDirect(colors[0]);
|
||||
}
|
||||
}
|
||||
|
||||
void RGBController_ColorfulTuringGPU::UpdateZoneLEDs(int /*zone*/)
|
||||
{
|
||||
DeviceUpdateLEDs();
|
||||
}
|
||||
|
||||
void RGBController_ColorfulTuringGPU::UpdateSingleLED(int /*led*/)
|
||||
{
|
||||
DeviceUpdateLEDs();
|
||||
}
|
||||
|
||||
void RGBController_ColorfulTuringGPU::DeviceUpdateMode()
|
||||
{
|
||||
DeviceUpdateLEDs();
|
||||
}
|
||||
@@ -1,25 +0,0 @@
|
||||
#pragma once
|
||||
|
||||
#include "RGBController.h"
|
||||
#include "ColorfulTuringGPUController.h"
|
||||
|
||||
class RGBController_ColorfulTuringGPU : public RGBController
|
||||
{
|
||||
public:
|
||||
RGBController_ColorfulTuringGPU(ColorfulTuringGPUController* colorful_gpu_ptr);
|
||||
~RGBController_ColorfulTuringGPU();
|
||||
|
||||
void SetupZones();
|
||||
void ResizeZone(int zone, int new_size);
|
||||
void DeviceUpdateLEDs();
|
||||
void UpdateZoneLEDs(int zone);
|
||||
void UpdateSingleLED(int led);
|
||||
void DeviceUpdateMode();
|
||||
|
||||
private:
|
||||
ColorfulTuringGPUController* controller;
|
||||
int getModeIndex(int mode_value);
|
||||
|
||||
};
|
||||
|
||||
|
||||
@@ -14,7 +14,7 @@
|
||||
|
||||
using namespace std::chrono_literals;
|
||||
|
||||
CorsairCommanderCoreController::CorsairCommanderCoreController(hid_device* dev_handle, const char* path, int pid)
|
||||
CorsairCommanderCoreController::CorsairCommanderCoreController(hid_device* dev_handle, const char* path)
|
||||
{
|
||||
dev = dev_handle;
|
||||
location = path;
|
||||
@@ -22,7 +22,6 @@ CorsairCommanderCoreController::CorsairCommanderCoreController(hid_device* dev_h
|
||||
controller_ready = 0;
|
||||
packet_size = CORSAIR_COMMANDER_CORE_PACKET_SIZE_V2;
|
||||
command_res_size = packet_size - 4;
|
||||
this->pid = pid;
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Initialize controller |
|
||||
@@ -63,15 +62,11 @@ void CorsairCommanderCoreController::InitController()
|
||||
version[2] = res[2];
|
||||
delete[] res;
|
||||
|
||||
if (pid == 0x0C1C && version[0] == 1)
|
||||
if(version[0] == 1)
|
||||
{
|
||||
packet_size = CORSAIR_COMMANDER_CORE_PACKET_SIZE_V1;
|
||||
command_res_size = packet_size - 4;
|
||||
}
|
||||
else if (pid == 0x0C32)
|
||||
{
|
||||
packet_size = CORSAIR_COMMANDER_CORE_PACKET_SIZE_V3;
|
||||
}
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Wake up device |
|
||||
|
||||
@@ -17,8 +17,6 @@
|
||||
|
||||
#define CORSAIR_COMMANDER_CORE_PACKET_SIZE_V1 1025 // First bit is the report bit
|
||||
#define CORSAIR_COMMANDER_CORE_PACKET_SIZE_V2 97 // First bit is the report bit
|
||||
#define CORSAIR_COMMANDER_CORE_PACKET_SIZE_V3 65 // First bit is the report bit
|
||||
|
||||
#define CORSAIR_COMMANDER_CORE_RGB_DATA_LENGTH 699
|
||||
#define CORSAIR_QL_FAN_ZONE_OFFSET 102
|
||||
#define CORSAIR_COMMANDER_CORE_NUM_CHANNELS 6
|
||||
@@ -31,7 +29,7 @@ enum
|
||||
class CorsairCommanderCoreController
|
||||
{
|
||||
public:
|
||||
CorsairCommanderCoreController(hid_device* dev_handle, const char* path, int pid);
|
||||
CorsairCommanderCoreController(hid_device* dev_handle, const char* path);
|
||||
~CorsairCommanderCoreController();
|
||||
|
||||
std::string GetFirmwareString();
|
||||
@@ -57,7 +55,6 @@ private:
|
||||
unsigned short int version[3] = {0, 0, 0};
|
||||
int packet_size;
|
||||
int command_res_size;
|
||||
int pid;
|
||||
std::chrono::time_point<std::chrono::steady_clock> last_commit_time;
|
||||
|
||||
void SendCommand(unsigned char command[2], unsigned char data[], unsigned short int data_len, unsigned char res[]);
|
||||
|
||||
@@ -14,7 +14,6 @@
|
||||
| Commander Core product IDs |
|
||||
\*-----------------------------------------------------*/
|
||||
#define CORSAIR_COMMANDER_CORE_PID 0x0C1C
|
||||
#define CORSAIR_COMMANDER_CORE2_PID 0x0C32
|
||||
|
||||
/******************************************************************************************\
|
||||
* *
|
||||
@@ -30,7 +29,7 @@ void DetectCorsairCapellixHIDControllers(hid_device_info* info, const std::strin
|
||||
|
||||
if(dev)
|
||||
{
|
||||
CorsairCommanderCoreController* controller = new CorsairCommanderCoreController(dev, info->path, info->product_id);
|
||||
CorsairCommanderCoreController* controller = new CorsairCommanderCoreController(dev, info->path);
|
||||
RGBController_CorsairCommanderCore* rgb_controller = new RGBController_CorsairCommanderCore(controller);
|
||||
|
||||
rgb_controller->name = name;
|
||||
@@ -39,5 +38,4 @@ void DetectCorsairCapellixHIDControllers(hid_device_info* info, const std::strin
|
||||
}
|
||||
}
|
||||
|
||||
REGISTER_HID_DETECTOR_IPU("Corsair Commander Core", DetectCorsairCapellixHIDControllers, CORSAIR_VID, CORSAIR_COMMANDER_CORE_PID, 0x00, 0xFF42, 0x01);
|
||||
REGISTER_HID_DETECTOR_IPU("Corsair Commander Core", DetectCorsairCapellixHIDControllers, CORSAIR_VID, CORSAIR_COMMANDER_CORE2_PID, 0x00, 0xFF42, 0x01);
|
||||
REGISTER_HID_DETECTOR_IPU("Corsair Commander Core", DetectCorsairCapellixHIDControllers, CORSAIR_VID, CORSAIR_COMMANDER_CORE_PID, 0x00, 0xFF42, 0x01);
|
||||
|
||||
+8
-8
@@ -13,22 +13,22 @@
|
||||
|
||||
using namespace std::chrono_literals;
|
||||
|
||||
CorsairDominatorPlatinumController::CorsairDominatorPlatinumController(i2c_smbus_interface *bus, corsair_dev_id dev, unsigned int leds_count)
|
||||
CorsairDominatorPlatinumController::CorsairDominatorPlatinumController(i2c_smbus_interface *bus, corsair_dev_id dev)
|
||||
{
|
||||
this->bus = bus;
|
||||
this->dev = dev;
|
||||
this->leds_count = leds_count;
|
||||
this->bus = bus;
|
||||
this->dev = dev;
|
||||
|
||||
led_data[0] = 0xc;
|
||||
}
|
||||
|
||||
CorsairDominatorPlatinumController::~CorsairDominatorPlatinumController()
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
unsigned int CorsairDominatorPlatinumController::GetLEDCount()
|
||||
std::string CorsairDominatorPlatinumController::GetDeviceName()
|
||||
{
|
||||
return leds_count;
|
||||
return "Corsair Dominator Platinum RGB";
|
||||
}
|
||||
|
||||
std::string CorsairDominatorPlatinumController::GetDeviceLocation()
|
||||
@@ -48,7 +48,7 @@ void CorsairDominatorPlatinumController::SetAllColors
|
||||
unsigned char blue
|
||||
)
|
||||
{
|
||||
for(unsigned int led = 0; led < leds_count; led++)
|
||||
for(unsigned int led = 0; led < CORSAIR_PLAT_LED_COUNT; led++)
|
||||
{
|
||||
SetLEDColor(led, red, green, blue);
|
||||
}
|
||||
@@ -62,7 +62,7 @@ void CorsairDominatorPlatinumController::SetLEDColor
|
||||
unsigned char blue
|
||||
)
|
||||
{
|
||||
if(led >= leds_count)
|
||||
if(led >= CORSAIR_PLAT_LED_COUNT)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
@@ -10,31 +10,35 @@
|
||||
|
||||
#include <string>
|
||||
#include "i2c_smbus.h"
|
||||
#define CORSAIR_DOMINATOR_PLATINUM_DATA_SIZE 38
|
||||
|
||||
#pragma once
|
||||
|
||||
typedef unsigned char corsair_dev_id;
|
||||
|
||||
#define CORSAIR_DOMINATOR_PLATINUM_NAME "Corsair Dominator Platinum"
|
||||
|
||||
class CorsairDominatorPlatinumController
|
||||
{
|
||||
public:
|
||||
CorsairDominatorPlatinumController(i2c_smbus_interface *bus, corsair_dev_id dev, unsigned int leds_count);
|
||||
CorsairDominatorPlatinumController(i2c_smbus_interface *bus, corsair_dev_id dev);
|
||||
~CorsairDominatorPlatinumController();
|
||||
|
||||
std::string GetDeviceName();
|
||||
std::string GetDeviceLocation();
|
||||
unsigned int GetLEDCount();
|
||||
|
||||
size_t GetLEDCount() { return CORSAIR_PLAT_LED_COUNT; }
|
||||
void SetAllColors(unsigned char red, unsigned char green, unsigned char blue);
|
||||
void SetLEDColor(unsigned int led, unsigned char red, unsigned char green, unsigned char blue);
|
||||
void ApplyColors();
|
||||
bool WaitReady();
|
||||
|
||||
private:
|
||||
unsigned char led_data[CORSAIR_DOMINATOR_PLATINUM_DATA_SIZE];
|
||||
static constexpr size_t CORSAIR_PLAT_LED_COUNT = 12;
|
||||
|
||||
unsigned char led_data[CORSAIR_PLAT_LED_COUNT * 3 + 2];
|
||||
|
||||
i2c_smbus_interface* bus;
|
||||
corsair_dev_id dev;
|
||||
unsigned int leds_count;
|
||||
|
||||
static unsigned char crc8(unsigned char init, unsigned char poly, unsigned char *data, unsigned char len);
|
||||
};
|
||||
|
||||
+17
-86
@@ -2,51 +2,15 @@
|
||||
#include "CorsairDominatorPlatinumController.h"
|
||||
#include "RGBController.h"
|
||||
#include "RGBController_CorsairDominatorPlatinum.h"
|
||||
#include "SettingsManager.h"
|
||||
#include "LogManager.h"
|
||||
|
||||
#include "i2c_smbus.h"
|
||||
#include "pci_ids.h"
|
||||
#include "LogManager.h"
|
||||
#include <vector>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
using namespace std::chrono_literals;
|
||||
|
||||
json corsair_dominator_models =
|
||||
{
|
||||
{
|
||||
"CMT",
|
||||
{
|
||||
{"name", "Corsair Dominator Platinum"},
|
||||
{"leds", 12}
|
||||
}
|
||||
},
|
||||
{
|
||||
"CMH",
|
||||
{
|
||||
{"name", "Corsair Vengeance Pro SL"},
|
||||
{"leds", 10}
|
||||
}
|
||||
},
|
||||
{
|
||||
"CMN",
|
||||
{
|
||||
{"name", "Corsair Vengeance RGB RT"},
|
||||
{"leds", 10}
|
||||
}
|
||||
},
|
||||
{
|
||||
"CMG",
|
||||
{
|
||||
{"name", "Corsair Vengeance RGB RS"},
|
||||
{"leds", 6}
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
#define CORSAIR_DOMINATOR_PLATINUM_NAME "Corsair Dominator Platinum"
|
||||
|
||||
bool TestForCorsairDominatorPlatinumController(i2c_smbus_interface *bus, unsigned char address)
|
||||
{
|
||||
int res = bus->i2c_smbus_write_quick(address, I2C_SMBUS_WRITE);
|
||||
@@ -91,65 +55,32 @@ bool TestForCorsairDominatorPlatinumController(i2c_smbus_interface *bus, unsigne
|
||||
|
||||
void DetectCorsairDominatorPlatinumControllers(std::vector<i2c_smbus_interface *> &busses)
|
||||
{
|
||||
SettingsManager* settings_manager = ResourceManager::get()->GetSettingsManager();
|
||||
|
||||
json corsair_dominator_settings = settings_manager->GetSettings("CorsairDominatorSettings");
|
||||
|
||||
if(!corsair_dominator_settings.contains("model"))
|
||||
{
|
||||
// Set default value
|
||||
corsair_dominator_settings["model"] = "CMT";
|
||||
settings_manager->SetSettings("CorsairDominatorSettings", corsair_dominator_settings);
|
||||
settings_manager->SaveSettings();
|
||||
}
|
||||
|
||||
std::string model = corsair_dominator_settings["model"];
|
||||
|
||||
for(unsigned int bus = 0; bus < busses.size(); bus++)
|
||||
{
|
||||
IF_DRAM_SMBUS(busses[bus]->pci_vendor, busses[bus]->pci_device)
|
||||
{
|
||||
LOG_DEBUG("[%s] Testing bus %d", CORSAIR_DOMINATOR_PLATINUM_NAME, bus);
|
||||
|
||||
std::vector<unsigned char> addresses;
|
||||
|
||||
for(unsigned char addr = 0x58; addr <= 0x5F; addr++)
|
||||
{
|
||||
addresses.push_back(addr);
|
||||
}
|
||||
|
||||
for(unsigned char addr = 0x18; addr <= 0x1F; addr++)
|
||||
{
|
||||
addresses.push_back(addr);
|
||||
}
|
||||
|
||||
for(unsigned char addr : addresses)
|
||||
{
|
||||
if(TestForCorsairDominatorPlatinumController(busses[bus], addr))
|
||||
{
|
||||
unsigned int leds;
|
||||
std::string name;
|
||||
|
||||
if(corsair_dominator_models.contains(model))
|
||||
{
|
||||
leds = corsair_dominator_models[model]["leds"];
|
||||
name = corsair_dominator_models[model]["name"];
|
||||
}
|
||||
else
|
||||
{
|
||||
leds = corsair_dominator_models["CMT"]["leds"];
|
||||
name = corsair_dominator_models["CMT"]["name"];
|
||||
}
|
||||
|
||||
LOG_DEBUG("[%s] Model: %s, Leds: %d", CORSAIR_DOMINATOR_PLATINUM_NAME, name.c_str(), leds);
|
||||
|
||||
CorsairDominatorPlatinumController* controller = new CorsairDominatorPlatinumController(busses[bus], addr, leds);
|
||||
RGBController_CorsairDominatorPlatinum* rgbcontroller = new RGBController_CorsairDominatorPlatinum(controller);
|
||||
rgbcontroller->name = name;
|
||||
|
||||
ResourceManager::get()->RegisterRGBController(rgbcontroller);
|
||||
CorsairDominatorPlatinumController* new_controller = new CorsairDominatorPlatinumController(busses[bus], addr);
|
||||
RGBController_CorsairDominatorPlatinum* new_rgbcontroller = new RGBController_CorsairDominatorPlatinum(new_controller);
|
||||
|
||||
ResourceManager::get()->RegisterRGBController(new_rgbcontroller);
|
||||
}
|
||||
std::this_thread::sleep_for(10ms);
|
||||
}
|
||||
for(unsigned char addr = 0x18; addr <= 0x1F; addr++)
|
||||
{
|
||||
if(TestForCorsairDominatorPlatinumController(busses[bus], addr))
|
||||
{
|
||||
CorsairDominatorPlatinumController* new_controller = new CorsairDominatorPlatinumController(busses[bus], addr);
|
||||
RGBController_CorsairDominatorPlatinum* new_rgbcontroller = new RGBController_CorsairDominatorPlatinum(new_controller);
|
||||
|
||||
ResourceManager::get()->RegisterRGBController(new_rgbcontroller);
|
||||
}
|
||||
|
||||
std::this_thread::sleep_for(10ms);
|
||||
}
|
||||
}
|
||||
@@ -160,4 +91,4 @@ void DetectCorsairDominatorPlatinumControllers(std::vector<i2c_smbus_interface *
|
||||
}
|
||||
} /* DetectCorsairDominatorPlatinumControllers() */
|
||||
|
||||
REGISTER_I2C_DETECTOR(CORSAIR_DOMINATOR_PLATINUM_NAME, DetectCorsairDominatorPlatinumControllers);
|
||||
REGISTER_I2C_DETECTOR("Corsair Dominator Platinum", DetectCorsairDominatorPlatinumControllers);
|
||||
|
||||
+7
-6
@@ -23,9 +23,10 @@ RGBController_CorsairDominatorPlatinum::RGBController_CorsairDominatorPlatinum(C
|
||||
{
|
||||
controller = controller_ptr;
|
||||
|
||||
name = controller->GetDeviceName();
|
||||
vendor = "Corsair";
|
||||
type = DEVICE_TYPE_DRAM;
|
||||
description = "Corsair RAM RGB Device";
|
||||
description = "Corsair Dominator Platinum RGB Device";
|
||||
location = controller->GetDeviceLocation();
|
||||
|
||||
mode Direct;
|
||||
@@ -54,7 +55,7 @@ void RGBController_CorsairDominatorPlatinum::SetupZones()
|
||||
| Set up zone |
|
||||
\*---------------------------------------------------------*/
|
||||
zone new_zone;
|
||||
new_zone.name = "Corsair RAM Zone";
|
||||
new_zone.name = "Corsair Platinum Zone";
|
||||
new_zone.type = ZONE_TYPE_LINEAR;
|
||||
new_zone.leds_min = controller->GetLEDCount();
|
||||
new_zone.leds_max = controller->GetLEDCount();
|
||||
@@ -67,10 +68,10 @@ void RGBController_CorsairDominatorPlatinum::SetupZones()
|
||||
\*---------------------------------------------------------*/
|
||||
for(std::size_t led_idx = 0; led_idx < zones[0].leds_count; led_idx++)
|
||||
{
|
||||
led new_led;
|
||||
new_led.name = "Corsair RAM LED ";
|
||||
new_led.name.append(std::to_string(led_idx));
|
||||
leds.push_back(new_led);
|
||||
led *new_led = new led();
|
||||
new_led->name = "Corsair Platinum LED ";
|
||||
new_led->name.append(std::to_string(led_idx));
|
||||
leds.push_back(*new_led);
|
||||
}
|
||||
|
||||
SetupColors();
|
||||
|
||||
@@ -9,8 +9,6 @@
|
||||
|
||||
#include "CorsairPeripheralV2Controller.h"
|
||||
|
||||
using namespace std::chrono_literals;
|
||||
|
||||
CorsairPeripheralV2Controller::CorsairPeripheralV2Controller(hid_device* dev_handle, const char* path, std::string /*name*/, uint16_t pid)
|
||||
{
|
||||
const uint8_t sz = HID_MAX_STR;
|
||||
@@ -35,29 +33,14 @@ CorsairPeripheralV2Controller::CorsairPeripheralV2Controller(hid_device* dev_han
|
||||
| Set device ID |
|
||||
\*---------------------------------------------------------*/
|
||||
device_index = i;
|
||||
write_cmd = CORSAIR_V2_WRITE_ID + corsair_v2_device_list[device_index]->wireless;
|
||||
}
|
||||
}
|
||||
|
||||
/*---------------------------------------------------------*\
|
||||
| NB: If the device is not found in the device list |
|
||||
| then wireless mode may not work reliably |
|
||||
\*---------------------------------------------------------*/
|
||||
bool wireless = corsair_v2_device_list[device_index]->wireless;
|
||||
if(wireless)
|
||||
{
|
||||
write_cmd = CORSAIR_V2_WRITE_WIRELESS_ID;
|
||||
}
|
||||
LOG_DEBUG("[%s] Setting write CMD to %02X for %s mode", device_name.c_str(),
|
||||
write_cmd, (wireless) ? "wireless" : "wired" );
|
||||
|
||||
/*---------------------------------------------------------*\
|
||||
| Get VID |
|
||||
| Possibly is Wireless connected? |
|
||||
\*---------------------------------------------------------*/
|
||||
GetAddress(0x11);
|
||||
/*---------------------------------------------------------*\
|
||||
| Get PID |
|
||||
\*---------------------------------------------------------*/
|
||||
GetAddress(0x12);
|
||||
}
|
||||
|
||||
CorsairPeripheralV2Controller::~CorsairPeripheralV2Controller()
|
||||
@@ -119,7 +102,6 @@ void CorsairPeripheralV2Controller::SetRenderMode(corsair_v2_device_mode mode)
|
||||
buffer[5] = mode;
|
||||
|
||||
hid_write(dev, buffer, CORSAIR_V2_WRITE_SIZE);
|
||||
hid_read_timeout(dev, buffer, CORSAIR_V2_WRITE_SIZE, CORSAIR_V2_TIMEOUT);
|
||||
}
|
||||
|
||||
void CorsairPeripheralV2Controller::LightingControl(uint8_t opt1, uint8_t opt2)
|
||||
@@ -139,7 +121,6 @@ void CorsairPeripheralV2Controller::LightingControl(uint8_t opt1, uint8_t opt2)
|
||||
buffer[5] = 0x00;
|
||||
|
||||
hid_write(dev, buffer, CORSAIR_V2_WRITE_SIZE);
|
||||
hid_read_timeout(dev, buffer, CORSAIR_V2_WRITE_SIZE, CORSAIR_V2_TIMEOUT);
|
||||
|
||||
/*---------------------------------------------------------*\
|
||||
| Open a RGB lighting handle |
|
||||
@@ -150,15 +131,9 @@ void CorsairPeripheralV2Controller::LightingControl(uint8_t opt1, uint8_t opt2)
|
||||
buffer[5] = opt2;
|
||||
|
||||
hid_write(dev, buffer, CORSAIR_V2_WRITE_SIZE);
|
||||
hid_read_timeout(dev, buffer, CORSAIR_V2_WRITE_SIZE, CORSAIR_V2_TIMEOUT);
|
||||
}
|
||||
|
||||
unsigned int CorsairPeripheralV2Controller::GetKeyboardLayout()
|
||||
{
|
||||
return GetAddress(0x41);
|
||||
}
|
||||
|
||||
unsigned int CorsairPeripheralV2Controller::GetAddress(uint8_t address)
|
||||
void CorsairPeripheralV2Controller::GetAddress(uint8_t address)
|
||||
{
|
||||
uint8_t buffer[CORSAIR_V2_WRITE_SIZE];
|
||||
uint8_t read[CORSAIR_V2_WRITE_SIZE];
|
||||
@@ -171,20 +146,10 @@ unsigned int CorsairPeripheralV2Controller::GetAddress(uint8_t address)
|
||||
buffer[3] = address;
|
||||
|
||||
hid_write(dev, buffer, CORSAIR_V2_WRITE_SIZE);
|
||||
hid_read_timeout(dev, read, CORSAIR_V2_WRITE_SIZE, CORSAIR_V2_TIMEOUT);
|
||||
hid_read(dev, read, CORSAIR_V2_WRITE_SIZE);
|
||||
|
||||
unsigned int temp = (unsigned int)(read[6] << 24 | read[5] << 16 | read[4] << 8 | read[3]);
|
||||
LOG_DEBUG("[%s] GetAddress %02X - %02X %02X - %02X %02X %02X %02X %02X %02X %02X %02X", device_name.c_str(),
|
||||
address, read[0], read[1], read[2], read[3], read[4], read[5], read[6], read[7], read[8], read[9]);
|
||||
|
||||
uint8_t result = read[2];
|
||||
if(result > 0)
|
||||
{
|
||||
LOG_DEBUG("[%s] An error occurred! Get Address %02X failed - %d %s", device_name.c_str(),
|
||||
address, result, (result == 5) ? "unsupported" : "");
|
||||
return -1;
|
||||
}
|
||||
return temp;
|
||||
}
|
||||
|
||||
void CorsairPeripheralV2Controller::StartTransaction(uint8_t opt1)
|
||||
@@ -199,7 +164,6 @@ void CorsairPeripheralV2Controller::StartTransaction(uint8_t opt1)
|
||||
buffer[4] = 0x01;
|
||||
|
||||
hid_write(dev, buffer, CORSAIR_V2_WRITE_SIZE);
|
||||
hid_read_timeout(dev, buffer, CORSAIR_V2_WRITE_SIZE, CORSAIR_V2_TIMEOUT);
|
||||
}
|
||||
|
||||
void CorsairPeripheralV2Controller::StopTransaction(uint8_t opt1)
|
||||
@@ -214,7 +178,6 @@ void CorsairPeripheralV2Controller::StopTransaction(uint8_t opt1)
|
||||
buffer[4] = opt1;
|
||||
|
||||
hid_write(dev, buffer, CORSAIR_V2_WRITE_SIZE);
|
||||
hid_read_timeout(dev, buffer, CORSAIR_V2_WRITE_SIZE, CORSAIR_V2_TIMEOUT);
|
||||
}
|
||||
|
||||
void CorsairPeripheralV2Controller::SetLEDs(uint8_t *data, uint16_t data_size)
|
||||
@@ -248,7 +211,6 @@ void CorsairPeripheralV2Controller::SetLEDs(uint8_t *data, uint16_t data_size)
|
||||
memcpy(&buffer[offset1], &data[0], copy_bytes);
|
||||
|
||||
hid_write(dev, buffer, CORSAIR_V2_WRITE_SIZE);
|
||||
hid_read_timeout(dev, buffer, CORSAIR_V2_WRITE_SIZE, CORSAIR_V2_TIMEOUT_SHORT);
|
||||
|
||||
remaining -= copy_bytes;
|
||||
buffer[2] = CORSAIR_V2_CMD_BLK_WN;
|
||||
@@ -269,7 +231,6 @@ void CorsairPeripheralV2Controller::SetLEDs(uint8_t *data, uint16_t data_size)
|
||||
memcpy(&buffer[offset2], &data[index], copy_bytes);
|
||||
|
||||
hid_write(dev, buffer, CORSAIR_V2_WRITE_SIZE);
|
||||
hid_read_timeout(dev, buffer, CORSAIR_V2_WRITE_SIZE, CORSAIR_V2_TIMEOUT_SHORT);
|
||||
|
||||
remaining -= copy_bytes;
|
||||
}
|
||||
|
||||
@@ -16,51 +16,48 @@
|
||||
#include "RGBController.h"
|
||||
#include "CorsairPeripheralV2Devices.h"
|
||||
|
||||
#define NA 0xFFFFFFFF
|
||||
#define HID_MAX_STR 255
|
||||
#define NA 0xFFFFFFFF
|
||||
#define HID_MAX_STR 255
|
||||
|
||||
#define CORSAIR_V2_TIMEOUT 50
|
||||
#define CORSAIR_V2_TIMEOUT_SHORT 3
|
||||
#define CORSAIR_V2_VALUE_MODE 3
|
||||
#define CORSAIR_V2_WRITE_WIRED_ID 8
|
||||
#define CORSAIR_V2_WRITE_WIRELESS_ID 9
|
||||
#define CORSAIR_V2_WRITE_SIZE 65
|
||||
#define CORSAIR_V2_WRITE_ID 8
|
||||
#define CORSAIR_V2_VALUE_MODE 3
|
||||
#define CORSAIR_V2_WRITE_SIZE 65
|
||||
|
||||
#define CORSAIR_V2_BRIGHTNESS_MIN 0
|
||||
#define CORSAIR_V2_BRIGHTNESS_MAX 0xFF
|
||||
#define CORSAIR_V2_BRIGHTNESS_MIN 0
|
||||
#define CORSAIR_V2_BRIGHTNESS_MAX 0xFF
|
||||
|
||||
enum corsair_v2_cmd
|
||||
{
|
||||
CORSAIR_V2_CMD_SET = 0x01, /* Command for setting values */
|
||||
CORSAIR_V2_CMD_GET = 0x02, /* Command for getting values */
|
||||
CORSAIR_V2_CMD_STOP_TX = 0x05, /* Finish Transaction */
|
||||
CORSAIR_V2_CMD_BLK_W1 = 0x06, /* Block write packet 1 */
|
||||
CORSAIR_V2_CMD_BLK_WN = 0x07, /* Block write remaining packets */
|
||||
CORSAIR_V2_CMD_START_TX = 0x0D, /* Start Transaction */
|
||||
CORSAIR_V2_CMD_SET = 0x01, /* Command for setting values */
|
||||
CORSAIR_V2_CMD_GET = 0x02, /* Command for getting values */
|
||||
CORSAIR_V2_CMD_STOP_TX = 0x05, /* Finish Transaction */
|
||||
CORSAIR_V2_CMD_BLK_W1 = 0x06, /* Block write packet 1 */
|
||||
CORSAIR_V2_CMD_BLK_WN = 0x07, /* Block write remaining packets */
|
||||
CORSAIR_V2_CMD_START_TX = 0x0D, /* Start Transaction */
|
||||
};
|
||||
|
||||
enum corsair_v2_mode
|
||||
{
|
||||
CORSAIR_V2_MODE_DIRECT = 0x0012,
|
||||
CORSAIR_V2_MODE_STATIC = 0x207E,
|
||||
CORSAIR_V2_MODE_FLASHING = 0xAD4F,
|
||||
CORSAIR_V2_MODE_BREATHING = 0xA5FA,
|
||||
CORSAIR_V2_MODE_SPECTRUM = 0x7BFF,
|
||||
CORSAIR_V2_MODE_RAINBOW = 0xB94C,
|
||||
CORSAIR_V2_MODE_RAIN = 0xA07E,
|
||||
CORSAIR_V2_MODE_SPIRAL = 0xAB87,
|
||||
CORSAIR_V2_MODE_WATERCOLOR = 0x0022,
|
||||
CORSAIR_V2_MODE_REACTIVE = 0xB1F9,
|
||||
CORSAIR_V2_MODE_RIPPLE = 0x09A2,
|
||||
CORSAIR_V2_MODE_VISOR = 0x90C0
|
||||
CORSAIR_V2_MODE_DIRECT = 0x0000,
|
||||
CORSAIR_V2_MODE_STATIC = 0x207E,
|
||||
CORSAIR_V2_MODE_FLASHING = 0xAD4F,
|
||||
CORSAIR_V2_MODE_BREATHING = 0xA5FA,
|
||||
CORSAIR_V2_MODE_SPECTRUM = 0x7BFF,
|
||||
CORSAIR_V2_MODE_RAINBOW = 0xB94C,
|
||||
CORSAIR_V2_MODE_RAIN = 0xA07E,
|
||||
CORSAIR_V2_MODE_SPIRAL = 0xAB87,
|
||||
CORSAIR_V2_MODE_WATERCOLOR = 0x0022,
|
||||
CORSAIR_V2_MODE_REACTIVE = 0xB1F9,
|
||||
CORSAIR_V2_MODE_RIPPLE = 0x09A2,
|
||||
CORSAIR_V2_MODE_VISOR = 0x90C0
|
||||
};
|
||||
|
||||
enum corsair_v2_color
|
||||
{
|
||||
CORSAIR_V2_COLOR_NONE = 0x00,
|
||||
CORSAIR_V2_COLOR_SPECIFIC = 0x01,
|
||||
CORSAIR_V2_COLOR_RANDOM = 0x02,
|
||||
CORSAIR_V2_COLOR_UNKNOWN = 0x03
|
||||
CORSAIR_V2_COLOR_NONE = 0x00,
|
||||
CORSAIR_V2_COLOR_SPECIFIC = 0x01,
|
||||
CORSAIR_V2_COLOR_RANDOM = 0x02,
|
||||
CORSAIR_V2_COLOR_UNKNOWN = 0x03
|
||||
};
|
||||
|
||||
|
||||
@@ -75,7 +72,6 @@ public:
|
||||
std::string GetName();
|
||||
std::string GetSerialString();
|
||||
const corsair_v2_device* GetDeviceData();
|
||||
unsigned int GetKeyboardLayout();
|
||||
|
||||
void SetRenderMode(corsair_v2_device_mode mode);
|
||||
void LightingControl(uint8_t opt1, uint8_t opt2);
|
||||
@@ -84,19 +80,16 @@ public:
|
||||
uint8_t direction, uint8_t brightness, std::vector<RGBColor> colors);
|
||||
|
||||
virtual void SetLedsDirect(std::vector<RGBColor *> colors) = 0;
|
||||
|
||||
protected:
|
||||
uint16_t device_index;
|
||||
std::string device_name;
|
||||
|
||||
private:
|
||||
unsigned int GetAddress(uint8_t address);
|
||||
void GetAddress(uint8_t address);
|
||||
void StartTransaction(uint8_t opt1);
|
||||
void StopTransaction(uint8_t opt1);
|
||||
|
||||
hid_device* dev;
|
||||
|
||||
uint8_t write_cmd = CORSAIR_V2_WRITE_WIRED_ID;
|
||||
uint8_t write_cmd;
|
||||
uint16_t device_index;
|
||||
std::string firmware_version;
|
||||
std::string location;
|
||||
std::string device_name;
|
||||
};
|
||||
|
||||
@@ -10,7 +10,6 @@
|
||||
| Corsair Peripheral specific includes |
|
||||
\*-----------------------------------------------------*/
|
||||
#include "CorsairPeripheralV2Devices.h"
|
||||
#include "RGBController_CorsairV2Hardware.h"
|
||||
#include "RGBController_CorsairV2Software.h"
|
||||
|
||||
#define CORSAIR_PERIPHERAL_CONTROLLER_NAME "Corsair V2 Peripheral"
|
||||
@@ -20,19 +19,6 @@
|
||||
\*-----------------------------------------------------*/
|
||||
#define CORSAIR_VID 0x1B1C
|
||||
|
||||
void DetectCorsairV2HardwareControllers(hid_device_info* info, const std::string& name)
|
||||
{
|
||||
hid_device* dev = hid_open_path(info->path);
|
||||
|
||||
if(dev)
|
||||
{
|
||||
CorsairPeripheralV2HWController* controller = new CorsairPeripheralV2HWController(dev, info->path, name, info->product_id);
|
||||
RGBController_CorsairV2HW* rgb_controller = new RGBController_CorsairV2HW(controller);
|
||||
rgb_controller->name = name;
|
||||
ResourceManager::get()->RegisterRGBController(rgb_controller);
|
||||
}
|
||||
} /* DetectCorsairV2SoftwareControllers() */
|
||||
|
||||
void DetectCorsairV2SoftwareControllers(hid_device_info* info, const std::string& name)
|
||||
{
|
||||
hid_device* dev = hid_open_path(info->path);
|
||||
@@ -50,18 +36,11 @@ void DetectCorsairV2SoftwareControllers(hid_device_info* info, const std::string
|
||||
/*-----------------------------------------------------------------------------------------------------*\
|
||||
| Keyboards |
|
||||
\*-----------------------------------------------------------------------------------------------------*/
|
||||
REGISTER_HID_DETECTOR_IP("Corsair K55 RGB PRO", DetectCorsairV2SoftwareControllers, CORSAIR_VID, CORSAIR_K55_RGB_PRO_PID, 1, 0xFF42);
|
||||
REGISTER_HID_DETECTOR_IP("Corsair K60 RGB PRO", DetectCorsairV2SoftwareControllers, CORSAIR_VID, CORSAIR_K60_RGB_PRO_PID, 1, 0xFF42);
|
||||
REGISTER_HID_DETECTOR_IP("Corsair K60 RGB PRO Low Profile", DetectCorsairV2SoftwareControllers, CORSAIR_VID, CORSAIR_K60_RGB_PRO_LP_PID, 1, 0xFF42);
|
||||
|
||||
/*-----------------------------------------------------------------------------------------------------*\
|
||||
| Mice |
|
||||
\*-----------------------------------------------------------------------------------------------------*/
|
||||
REGISTER_HID_DETECTOR_IP("Corsair Ironclaw Wireless", DetectCorsairV2SoftwareControllers, CORSAIR_VID, CORSAIR_IRONCLAW_WIRELESS_PID, 1, 0xFF42);
|
||||
REGISTER_HID_DETECTOR_IP("Corsair Ironclaw Wireless (Wired)", DetectCorsairV2SoftwareControllers, CORSAIR_VID, CORSAIR_IRONCLAW_WIRELESS_WIRED_PID, 1, 0xFF42);
|
||||
REGISTER_HID_DETECTOR_IP("Corsair M55 RGB PRO", DetectCorsairV2SoftwareControllers, CORSAIR_VID, CORSAIR_M55_RGB_PRO_PID, 1, 0xFF42);
|
||||
REGISTER_HID_DETECTOR_IP("Corsair K55 RGB PRO", DetectCorsairV2SoftwareControllers, CORSAIR_VID, CORSAIR_K55_RGB_PRO_PID, 1, 0xFF42);
|
||||
REGISTER_HID_DETECTOR_IP("Corsair K60 RGB PRO", DetectCorsairV2SoftwareControllers, CORSAIR_VID, CORSAIR_K60_RGB_PRO_PID, 1, 0xFF42);
|
||||
REGISTER_HID_DETECTOR_IP("Corsair K60 RGB PRO Low Profile", DetectCorsairV2SoftwareControllers, CORSAIR_VID, CORSAIR_K60_RGB_PRO_LP_PID, 1, 0xFF42);
|
||||
|
||||
/*-----------------------------------------------------------------------------------------------------*\
|
||||
| Mousemat |
|
||||
\*-----------------------------------------------------------------------------------------------------*/
|
||||
REGISTER_HID_DETECTOR_IP("Corsair MM700", DetectCorsairV2SoftwareControllers, CORSAIR_VID, CORSAIR_MM700_PID, 1, 0xFF42);
|
||||
REGISTER_HID_DETECTOR_IP("Corsair MM700", DetectCorsairV2SoftwareControllers, CORSAIR_VID, CORSAIR_MM700_PID, 1, 0xFF42);
|
||||
|
||||
@@ -1,147 +1,127 @@
|
||||
#include "CorsairPeripheralV2Devices.h"
|
||||
|
||||
/*-------------------------------------------------------------------------*\
|
||||
| Corsair Key Values |
|
||||
\*-------------------------------------------------------------------------*/
|
||||
|
||||
std::vector<unsigned int> corsair_full_size_values =
|
||||
{
|
||||
/* ESC F1 F2 F3 F4 F5 F6 F7 F8 F9 F10 F11 F12 PRSC SCLK PSBK */
|
||||
41, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72,
|
||||
/* BKTK 1 2 3 4 5 6 7 8 9 0 - = BSPC INS HOME PGUP NMLK NMDV NMTM NMMI */
|
||||
53, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 45, 46, 42, 73, 74, 75, 83, 84, 85, 86,
|
||||
/* TAB Q W E R T Y U I O P [ ] \ DEL END PGDN NM7 NM8 NM9 NMPL */
|
||||
43, 20, 26, 8, 21, 23, 28, 24, 12, 18, 19, 47, 48, 49, 76, 77, 78, 95, 96, 97, 87,
|
||||
/* CPLK A S D F G H J K L ; " ENTR NM4 NM5 NM6 */
|
||||
57, 4, 22, 7, 9, 10, 11, 13, 14, 15, 51, 52, 40, 92, 93, 94,
|
||||
/* LSFT Z X C V B N M , . / RSFT ARWU NM1 NM2 NM3 NMER */
|
||||
106, 29, 27, 6, 25, 5, 17, 16, 54, 55, 56, 110, 82, 89, 90, 91, 88,
|
||||
/* LCTL LWIN LALT SPC RALT RFNC RMNU RCTL ARWR ARWD ARWR NM0 NMPD */
|
||||
105, 108, 107, 44, 111, 122, 101, 109, 80, 81, 79, 98, 99,
|
||||
};
|
||||
|
||||
/*-------------------------------------------------------------------------*\
|
||||
| KEYMAPS |
|
||||
\*-------------------------------------------------------------------------*/
|
||||
keyboard_keymap_overlay_values corsair_K60_layout
|
||||
#define K60_KEYMAP_SIZE (sizeof(K60_keymap) / sizeof(K60_keymap[0]))
|
||||
|
||||
static const corsair_v2_led K60_keymap[] =
|
||||
{
|
||||
KEYBOARD_SIZE::KEYBOARD_SIZE_FULL,
|
||||
{
|
||||
corsair_full_size_values,
|
||||
{
|
||||
{
|
||||
KEYBOARD_LAYOUT_ISO_QWERTY,
|
||||
{
|
||||
/*---------------------------------------------------------------------------------------------------------*\
|
||||
| Edit Keys |
|
||||
| Zone, Row, Column, Value, Key, OpCode, |
|
||||
\*---------------------------------------------------------------------------------------------------------*/
|
||||
{ 0, 3, 12, 50, KEY_EN_POUND, KEYBOARD_OPCODE_SWAP_ONLY, },
|
||||
{ 0, 4, 1, 100, KEY_EN_ISO_BACK_SLASH, KEYBOARD_OPCODE_SWAP_ONLY, },
|
||||
}
|
||||
},
|
||||
/* Add more regional layout fixes here */
|
||||
}
|
||||
},
|
||||
{
|
||||
/*---------------------------------------------------------------------------------------------------------*\
|
||||
| Edit Keys |
|
||||
| Zone, Row, Column, Value, Key, OpCode, |
|
||||
\*---------------------------------------------------------------------------------------------------------*/
|
||||
}
|
||||
/*---------------------------------------------------------------------*\
|
||||
| Zone, Row, Column, Index, Name |
|
||||
\*---------------------------------------------------------------------*/
|
||||
{ 0, 0, 0, 41, KEY_EN_ESCAPE },
|
||||
{ 0, 0, 2, 58, KEY_EN_F1 },
|
||||
{ 0, 0, 3, 59, KEY_EN_F2 },
|
||||
{ 0, 0, 4, 60, KEY_EN_F3 },
|
||||
{ 0, 0, 5, 61, KEY_EN_F4 },
|
||||
{ 0, 0, 6, 62, KEY_EN_F5 },
|
||||
{ 0, 0, 7, 63, KEY_EN_F6 },
|
||||
{ 0, 0, 8, 64, KEY_EN_F7 },
|
||||
{ 0, 0, 9, 65, KEY_EN_F8 },
|
||||
{ 0, 0, 10, 66, KEY_EN_F9 },
|
||||
{ 0, 0, 11, 67, KEY_EN_F10 },
|
||||
{ 0, 0, 12, 68, KEY_EN_F11 },
|
||||
{ 0, 0, 13, 69, KEY_EN_F12 },
|
||||
{ 0, 0, 14, 70, KEY_EN_PRINT_SCREEN },
|
||||
{ 0, 0, 15, 71, KEY_EN_SCROLL_LOCK },
|
||||
{ 0, 0, 16, 72, KEY_EN_PAUSE_BREAK },
|
||||
{ 0, 1, 0, 53, KEY_EN_BACK_TICK },
|
||||
{ 0, 1, 1, 30, KEY_EN_1 },
|
||||
{ 0, 1, 2, 31, KEY_EN_2 },
|
||||
{ 0, 1, 3, 32, KEY_EN_3 },
|
||||
{ 0, 1, 4, 33, KEY_EN_4 },
|
||||
{ 0, 1, 5, 34, KEY_EN_5 },
|
||||
{ 0, 1, 6, 35, KEY_EN_6 },
|
||||
{ 0, 1, 7, 36, KEY_EN_7 },
|
||||
{ 0, 1, 8, 37, KEY_EN_8 },
|
||||
{ 0, 1, 9, 38, KEY_EN_9 },
|
||||
{ 0, 1, 10, 39, KEY_EN_0 },
|
||||
{ 0, 1, 11, 45, KEY_EN_MINUS },
|
||||
{ 0, 1, 12, 46, KEY_EN_EQUALS },
|
||||
{ 0, 1, 13, 42, KEY_EN_BACKSPACE },
|
||||
{ 0, 1, 14, 73, KEY_EN_INSERT },
|
||||
{ 0, 1, 15, 74, KEY_EN_HOME },
|
||||
{ 0, 1, 16, 75, KEY_EN_PAGE_UP },
|
||||
{ 0, 1, 17, 83, KEY_EN_NUMPAD_LOCK },
|
||||
{ 0, 1, 18, 84, KEY_EN_NUMPAD_DIVIDE },
|
||||
{ 0, 1, 19, 85, KEY_EN_NUMPAD_TIMES },
|
||||
{ 0, 1, 20, 86, KEY_EN_NUMPAD_MINUS },
|
||||
{ 0, 2, 0, 43, KEY_EN_TAB },
|
||||
{ 0, 2, 1, 20, KEY_EN_Q },
|
||||
{ 0, 2, 2, 26, KEY_EN_W },
|
||||
{ 0, 2, 3, 8, KEY_EN_E },
|
||||
{ 0, 2, 4, 21, KEY_EN_R },
|
||||
{ 0, 2, 5, 23, KEY_EN_T },
|
||||
{ 0, 2, 6, 28, KEY_EN_Y },
|
||||
{ 0, 2, 7, 24, KEY_EN_U },
|
||||
{ 0, 2, 8, 12, KEY_EN_I },
|
||||
{ 0, 2, 9, 18, KEY_EN_O },
|
||||
{ 0, 2, 10, 19, KEY_EN_P },
|
||||
{ 0, 2, 11, 47, KEY_EN_LEFT_BRACKET },
|
||||
{ 0, 2, 12, 48, KEY_EN_RIGHT_BRACKET },
|
||||
{ 0, 2, 13, 49, KEY_EN_ANSI_BACK_SLASH },
|
||||
{ 0, 2, 14, 76, KEY_EN_DELETE },
|
||||
{ 0, 2, 15, 77, KEY_EN_END },
|
||||
{ 0, 2, 16, 78, KEY_EN_PAGE_DOWN },
|
||||
{ 0, 2, 17, 95, KEY_EN_NUMPAD_7 },
|
||||
{ 0, 2, 18, 96, KEY_EN_NUMPAD_8 },
|
||||
{ 0, 2, 19, 97, KEY_EN_NUMPAD_9 },
|
||||
{ 0, 2, 20, 87, KEY_EN_NUMPAD_PLUS },
|
||||
{ 0, 3, 0, 57, KEY_EN_CAPS_LOCK },
|
||||
{ 0, 3, 1, 4, KEY_EN_A },
|
||||
{ 0, 3, 2, 22, KEY_EN_S },
|
||||
{ 0, 3, 3, 7, KEY_EN_D },
|
||||
{ 0, 3, 4, 9, KEY_EN_F },
|
||||
{ 0, 3, 5, 10, KEY_EN_G },
|
||||
{ 0, 3, 6, 11, KEY_EN_H },
|
||||
{ 0, 3, 7, 13, KEY_EN_J },
|
||||
{ 0, 3, 8, 14, KEY_EN_K },
|
||||
{ 0, 3, 9, 15, KEY_EN_L },
|
||||
{ 0, 3, 10, 51, KEY_EN_SEMICOLON },
|
||||
{ 0, 3, 11, 52, KEY_EN_QUOTE },
|
||||
{ 0, 3, 12, 50, KEY_EN_POUND },
|
||||
{ 0, 3, 13, 40, KEY_EN_ANSI_ENTER },
|
||||
{ 0, 3, 17, 92, KEY_EN_NUMPAD_4 },
|
||||
{ 0, 3, 18, 93, KEY_EN_NUMPAD_5 },
|
||||
{ 0, 3, 19, 94, KEY_EN_NUMPAD_6 },
|
||||
{ 0, 4, 0, 106, KEY_EN_LEFT_SHIFT },
|
||||
{ 0, 4, 1, 100, KEY_EN_ISO_BACK_SLASH },
|
||||
{ 0, 4, 2, 29, KEY_EN_Z },
|
||||
{ 0, 4, 3, 27, KEY_EN_X },
|
||||
{ 0, 4, 4, 6, KEY_EN_C },
|
||||
{ 0, 4, 5, 25, KEY_EN_V },
|
||||
{ 0, 4, 6, 5, KEY_EN_B },
|
||||
{ 0, 4, 7, 17, KEY_EN_N },
|
||||
{ 0, 4, 8, 16, KEY_EN_M },
|
||||
{ 0, 4, 9, 54, KEY_EN_COMMA },
|
||||
{ 0, 4, 10, 55, KEY_EN_PERIOD },
|
||||
{ 0, 4, 11, 56, KEY_EN_FORWARD_SLASH },
|
||||
{ 0, 4, 13, 110, KEY_EN_RIGHT_SHIFT },
|
||||
{ 0, 4, 15, 82, KEY_EN_UP_ARROW },
|
||||
{ 0, 4, 17, 89, KEY_EN_NUMPAD_1 },
|
||||
{ 0, 4, 18, 90, KEY_EN_NUMPAD_2 },
|
||||
{ 0, 4, 19, 91, KEY_EN_NUMPAD_3 },
|
||||
{ 0, 4, 20, 88, KEY_EN_NUMPAD_ENTER },
|
||||
{ 0, 5, 0, 105, KEY_EN_LEFT_CONTROL },
|
||||
{ 0, 5, 1, 108, KEY_EN_LEFT_WINDOWS },
|
||||
{ 0, 5, 2, 107, KEY_EN_LEFT_ALT },
|
||||
{ 0, 5, 6, 44, KEY_EN_SPACE },
|
||||
{ 0, 5, 10, 111, KEY_EN_RIGHT_ALT },
|
||||
{ 0, 5, 11, 122, KEY_EN_RIGHT_FUNCTION },
|
||||
{ 0, 5, 12, 101, KEY_EN_MENU },
|
||||
{ 0, 5, 13, 109, KEY_EN_RIGHT_CONTROL },
|
||||
{ 0, 5, 14, 80, KEY_EN_LEFT_ARROW },
|
||||
{ 0, 5, 15, 81, KEY_EN_DOWN_ARROW },
|
||||
{ 0, 5, 16, 79, KEY_EN_RIGHT_ARROW },
|
||||
{ 0, 5, 18, 98, KEY_EN_NUMPAD_0 },
|
||||
{ 0, 5, 19, 99, KEY_EN_NUMPAD_PERIOD },
|
||||
};
|
||||
|
||||
/*-------------------------------------------------------------------------*\
|
||||
| CORSAIR DEVICES |
|
||||
\*-------------------------------------------------------------------------*/
|
||||
|
||||
/*-------------------------------------------------------------*\
|
||||
| Corsair Ironclaw Wireless 1B1C:1B66 |
|
||||
| Corsair Ironclaw Wireless (Wired) 1B1C:1B4C |
|
||||
| |
|
||||
| Zone "Logo" |
|
||||
| Single |
|
||||
| |
|
||||
| Zone "Scroll Wheel" |
|
||||
| Single |
|
||||
| |
|
||||
| Zone "Buttons" |
|
||||
| Single |
|
||||
| |
|
||||
| Zone "Side" |
|
||||
| Linear |
|
||||
| 1 Row, 3 Columns |
|
||||
\*-------------------------------------------------------------*/
|
||||
static const corsair_v2_zone ironclaw_logo_zone =
|
||||
{
|
||||
"Logo",
|
||||
ZONE_TYPE_SINGLE,
|
||||
1,
|
||||
1
|
||||
};
|
||||
|
||||
static const corsair_v2_zone ironclaw_scroll_zone =
|
||||
{
|
||||
"Scroll Wheel",
|
||||
ZONE_TYPE_SINGLE,
|
||||
1,
|
||||
1
|
||||
};
|
||||
|
||||
static const corsair_v2_zone ironclaw_button_zone =
|
||||
{
|
||||
"Buttons",
|
||||
ZONE_TYPE_SINGLE,
|
||||
1,
|
||||
1
|
||||
};
|
||||
|
||||
static const corsair_v2_zone ironclaw_side_zone =
|
||||
{
|
||||
"Side Zone",
|
||||
ZONE_TYPE_LINEAR,
|
||||
1,
|
||||
3
|
||||
};
|
||||
|
||||
static const corsair_v2_device ironclaw_wired_device =
|
||||
{
|
||||
CORSAIR_IRONCLAW_WIRELESS_WIRED_PID,
|
||||
false,
|
||||
DEVICE_TYPE_MOUSE,
|
||||
CORSAIR_V2_TYPE_SW_COLOUR_BLOCK,
|
||||
1,
|
||||
6,
|
||||
{
|
||||
&ironclaw_logo_zone,
|
||||
&ironclaw_scroll_zone,
|
||||
&ironclaw_button_zone,
|
||||
&ironclaw_side_zone,
|
||||
nullptr,
|
||||
nullptr
|
||||
},
|
||||
nullptr
|
||||
};
|
||||
|
||||
static const corsair_v2_device ironclaw_wireless_device =
|
||||
{
|
||||
CORSAIR_IRONCLAW_WIRELESS_PID,
|
||||
true,
|
||||
DEVICE_TYPE_MOUSE,
|
||||
CORSAIR_V2_TYPE_SW_COLOUR_BLOCK,
|
||||
1,
|
||||
6,
|
||||
{
|
||||
&ironclaw_logo_zone,
|
||||
&ironclaw_scroll_zone,
|
||||
&ironclaw_button_zone,
|
||||
&ironclaw_side_zone,
|
||||
nullptr,
|
||||
nullptr
|
||||
},
|
||||
nullptr
|
||||
};
|
||||
|
||||
/*-------------------------------------------------------------*\
|
||||
| Corsair K55 RGB Pro 1B1C:1BA4 |
|
||||
| |
|
||||
@@ -162,7 +142,7 @@ static const corsair_v2_device k55_rgb_pro_device =
|
||||
CORSAIR_K55_RGB_PRO_PID,
|
||||
false,
|
||||
DEVICE_TYPE_KEYBOARD,
|
||||
CORSAIR_V2_TYPE_SW_COLOUR_BLOCK,
|
||||
CORSAIR_V2_MODE_SW,
|
||||
1,
|
||||
6,
|
||||
{
|
||||
@@ -173,7 +153,8 @@ static const corsair_v2_device k55_rgb_pro_device =
|
||||
nullptr,
|
||||
nullptr
|
||||
},
|
||||
nullptr
|
||||
nullptr,
|
||||
0
|
||||
};
|
||||
|
||||
/*-------------------------------------------------------------*\
|
||||
@@ -196,7 +177,7 @@ static const corsair_v2_device k60_rgb_pro_device =
|
||||
CORSAIR_K60_RGB_PRO_PID,
|
||||
false,
|
||||
DEVICE_TYPE_KEYBOARD,
|
||||
CORSAIR_V2_TYPE_SW_COLOUR_BLOCK,
|
||||
CORSAIR_V2_MODE_SW,
|
||||
6,
|
||||
21,
|
||||
{
|
||||
@@ -207,7 +188,8 @@ static const corsair_v2_device k60_rgb_pro_device =
|
||||
nullptr,
|
||||
nullptr
|
||||
},
|
||||
&corsair_K60_layout
|
||||
K60_keymap,
|
||||
K60_KEYMAP_SIZE
|
||||
};
|
||||
|
||||
/*-------------------------------------------------------------*\
|
||||
@@ -230,7 +212,7 @@ static const corsair_v2_device k60_rgb_pro_lp_device =
|
||||
CORSAIR_K60_RGB_PRO_LP_PID,
|
||||
false,
|
||||
DEVICE_TYPE_KEYBOARD,
|
||||
CORSAIR_V2_TYPE_SW_COLOUR_BLOCK,
|
||||
CORSAIR_V2_MODE_SW,
|
||||
6,
|
||||
21,
|
||||
{
|
||||
@@ -241,52 +223,8 @@ static const corsair_v2_device k60_rgb_pro_lp_device =
|
||||
nullptr,
|
||||
nullptr
|
||||
},
|
||||
&corsair_K60_layout
|
||||
};
|
||||
|
||||
/*-------------------------------------------------------------*\
|
||||
| Corsair M55 1B1C:1B70 |
|
||||
| |
|
||||
| Zone "Logo" |
|
||||
| Single |
|
||||
| |
|
||||
| Zone "Edge" |
|
||||
| Linear |
|
||||
| 1 Row, 2 Columns |
|
||||
\*-------------------------------------------------------------*/
|
||||
static const corsair_v2_zone m55_mid_zone =
|
||||
{
|
||||
"Middle Button",
|
||||
ZONE_TYPE_SINGLE,
|
||||
1,
|
||||
1
|
||||
};
|
||||
|
||||
static const corsair_v2_zone m55_logo_zone =
|
||||
{
|
||||
"Logo",
|
||||
ZONE_TYPE_SINGLE,
|
||||
1,
|
||||
1
|
||||
};
|
||||
|
||||
static const corsair_v2_device m55_device =
|
||||
{
|
||||
CORSAIR_M55_RGB_PRO_PID,
|
||||
false,
|
||||
DEVICE_TYPE_MOUSE,
|
||||
CORSAIR_V2_TYPE_SW_COLOUR_BLOCK,
|
||||
1,
|
||||
2,
|
||||
{
|
||||
&m55_mid_zone,
|
||||
&m55_logo_zone,
|
||||
nullptr,
|
||||
nullptr,
|
||||
nullptr,
|
||||
nullptr
|
||||
},
|
||||
nullptr
|
||||
K60_keymap,
|
||||
K60_KEYMAP_SIZE
|
||||
};
|
||||
|
||||
/*-------------------------------------------------------------*\
|
||||
@@ -328,7 +266,7 @@ static const corsair_v2_device mm700_device =
|
||||
CORSAIR_MM700_PID,
|
||||
false,
|
||||
DEVICE_TYPE_MOUSEMAT,
|
||||
CORSAIR_V2_TYPE_SW_COLOUR_BLOCK,
|
||||
CORSAIR_V2_MODE_SW,
|
||||
1,
|
||||
3,
|
||||
{
|
||||
@@ -339,7 +277,8 @@ static const corsair_v2_device mm700_device =
|
||||
nullptr,
|
||||
nullptr
|
||||
},
|
||||
nullptr
|
||||
nullptr,
|
||||
0
|
||||
};
|
||||
|
||||
/*-------------------------------------------------------------------------*\
|
||||
@@ -354,13 +293,6 @@ const corsair_v2_device* corsair_v2_device_list_data[] =
|
||||
&k60_rgb_pro_device,
|
||||
&k60_rgb_pro_lp_device,
|
||||
|
||||
/*-----------------------------------------------------------------*\
|
||||
| MICE |
|
||||
\*-----------------------------------------------------------------*/
|
||||
&ironclaw_wired_device,
|
||||
&ironclaw_wireless_device,
|
||||
&m55_device,
|
||||
|
||||
/*-----------------------------------------------------------------*\
|
||||
| MOUSEMATS |
|
||||
\*-----------------------------------------------------------------*/
|
||||
|
||||
@@ -3,59 +3,43 @@
|
||||
#include <string>
|
||||
#include "RGBController.h"
|
||||
#include "RGBControllerKeyNames.h"
|
||||
#include "KeyboardLayoutManager.h"
|
||||
|
||||
#define CORSAIR_ZONES_MAX 6
|
||||
#define CORSAIR_ZONES_MAX 6
|
||||
|
||||
enum corsair_v2_device_mode
|
||||
{
|
||||
CORSAIR_V2_MODE_HW = 0x01, /* Hardware RGB mode */
|
||||
CORSAIR_V2_MODE_SW = 0x02, /* Software RGB mode */
|
||||
};
|
||||
|
||||
enum corsair_v2_supports
|
||||
{
|
||||
CORSAIR_V2_TYPE_SW_COLOUR_BLOCK = 1,
|
||||
CORSAIR_V2_TYPE_HW_COLOUR_BLOCK = 2,
|
||||
CORSAIR_V2_TYPE_SW_TRIPLETS = 3,
|
||||
CORSAIR_V2_TYPE_HW_TRIPLETS = 4,
|
||||
};
|
||||
|
||||
enum corsair_v2_kb_layout
|
||||
{
|
||||
CORSAIR_V2_KB_LAYOUT_ANSI = 0x01, /* US ANSI Layout */
|
||||
CORSAIR_V2_KB_LAYOUT_ISO = 0x02, /* EURO ISO Layout */
|
||||
CORSAIR_V2_KB_LAYOUT_ABNT = 0x03, /* Brazilian Layout */
|
||||
CORSAIR_V2_KB_LAYOUT_JIS = 0x04, /* Japanese Layout */
|
||||
CORSAIR_V2_MODE_HW = 0x01, /* Hardware RGB mode */
|
||||
CORSAIR_V2_MODE_SW = 0x02, /* Software RGB mode */
|
||||
};
|
||||
|
||||
typedef struct
|
||||
{
|
||||
std::string name;
|
||||
zone_type type;
|
||||
uint8_t rows;
|
||||
uint8_t cols;
|
||||
std::string name;
|
||||
zone_type type;
|
||||
uint8_t rows;
|
||||
uint8_t cols;
|
||||
} corsair_v2_zone;
|
||||
|
||||
typedef struct
|
||||
{
|
||||
uint8_t zone;
|
||||
uint8_t row;
|
||||
uint8_t col;
|
||||
uint8_t index;
|
||||
const char* name;
|
||||
uint8_t zone;
|
||||
uint8_t row;
|
||||
uint8_t col;
|
||||
uint8_t index;
|
||||
const char* name;
|
||||
} corsair_v2_led;
|
||||
|
||||
typedef struct
|
||||
{
|
||||
uint16_t pid;
|
||||
bool wireless;
|
||||
device_type type;
|
||||
corsair_v2_supports protocol;
|
||||
uint8_t rows;
|
||||
uint8_t cols;
|
||||
const corsair_v2_zone* zones[CORSAIR_ZONES_MAX];
|
||||
keyboard_keymap_overlay_values* layout_new;
|
||||
uint16_t pid;
|
||||
bool wireless;
|
||||
device_type type;
|
||||
uint8_t supports;
|
||||
uint8_t rows;
|
||||
uint8_t cols;
|
||||
const corsair_v2_zone* zones[CORSAIR_ZONES_MAX];
|
||||
const corsair_v2_led* layout;
|
||||
uint16_t layout_size;
|
||||
} corsair_v2_device;
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
@@ -65,13 +49,6 @@ typedef struct
|
||||
#define CORSAIR_K60_RGB_PRO_PID 0x1BA0
|
||||
#define CORSAIR_K60_RGB_PRO_LP_PID 0x1BAD
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Corsair V2 Protocol Mice |
|
||||
\*-----------------------------------------------------*/
|
||||
#define CORSAIR_IRONCLAW_WIRELESS_PID 0x1BA6
|
||||
#define CORSAIR_IRONCLAW_WIRELESS_WIRED_PID 0x1B4C
|
||||
#define CORSAIR_M55_RGB_PRO_PID 0x1B70
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Corsair V2 Protocol Mousemats |
|
||||
\*-----------------------------------------------------*/
|
||||
|
||||
@@ -1,89 +0,0 @@
|
||||
/*---------------------------------------------------------------------*\
|
||||
| CorsairPeripheralV2HardwareController.cpp |
|
||||
| |
|
||||
| Driver for the newer Corsair peripherals that use the '08' |
|
||||
| based USB protocol and support hardware lighting modes. |
|
||||
| |
|
||||
| Chris M (Dr_No) 07 Dec 2022 |
|
||||
\*---------------------------------------------------------------------*/
|
||||
|
||||
#include "LogManager.h"
|
||||
#include "CorsairPeripheralV2HardwareController.h"
|
||||
|
||||
CorsairPeripheralV2HWController::CorsairPeripheralV2HWController(hid_device* dev_handle, const char* path, std::string name, uint16_t pid) : CorsairPeripheralV2Controller(dev_handle, path, name, pid)
|
||||
{
|
||||
SetRenderMode(CORSAIR_V2_MODE_SW);
|
||||
LightingControl(0x5F, 0x00);
|
||||
}
|
||||
|
||||
CorsairPeripheralV2HWController::~CorsairPeripheralV2HWController()
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
void CorsairPeripheralV2HWController::SetLedsDirect(std::vector<RGBColor *>colors)
|
||||
{
|
||||
switch(corsair_v2_device_list[device_index]->protocol)
|
||||
{
|
||||
case CORSAIR_V2_TYPE_HW_TRIPLETS:
|
||||
SetLedsDirectTriplets(colors);
|
||||
break;
|
||||
case CORSAIR_V2_TYPE_HW_COLOUR_BLOCK:
|
||||
SetLedsDirectColourBlocks(colors);
|
||||
break;
|
||||
default:
|
||||
LOG_ERROR("[%s] Error setting Direct mode: Device supportes returned %i", device_name.c_str(),
|
||||
corsair_v2_device_list[device_index]->protocol);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
void CorsairPeripheralV2HWController::SetLedsDirectColourBlocks(std::vector<RGBColor *>colors)
|
||||
{
|
||||
uint16_t count = colors.size();
|
||||
uint16_t green = count + CORSAIR_V2HW_DATA_OFFSET;
|
||||
uint16_t blue = (count * 2) + CORSAIR_V2HW_DATA_OFFSET;
|
||||
uint16_t length = (count * 3) + CORSAIR_V2HW_DATA_OFFSET;
|
||||
uint8_t* buffer = new uint8_t[length];
|
||||
|
||||
memset(buffer, 0, length);
|
||||
|
||||
buffer[0] = CORSAIR_V2_MODE_DIRECT & 0xFF;
|
||||
buffer[1] = CORSAIR_V2_MODE_DIRECT >> 8;
|
||||
for(std::size_t i = 0; i < count; i++)
|
||||
{
|
||||
RGBColor color = *colors[i];
|
||||
std::size_t idx = i + CORSAIR_V2HW_DATA_OFFSET;
|
||||
|
||||
buffer[idx] = RGBGetRValue(color);
|
||||
buffer[idx + green] = RGBGetGValue(color);
|
||||
buffer[idx + blue] = RGBGetBValue(color);
|
||||
}
|
||||
|
||||
SetLEDs(buffer, length);
|
||||
delete[] buffer;
|
||||
}
|
||||
|
||||
void CorsairPeripheralV2HWController::SetLedsDirectTriplets(std::vector<RGBColor *>colors)
|
||||
{
|
||||
uint16_t count = colors.size();
|
||||
uint16_t length = (count * 3) + CORSAIR_V2HW_DATA_OFFSET;
|
||||
uint8_t* buffer = new uint8_t[length];
|
||||
|
||||
memset(buffer, 0, length);
|
||||
|
||||
buffer[0] = CORSAIR_V2_MODE_DIRECT & 0xFF;
|
||||
buffer[1] = CORSAIR_V2_MODE_DIRECT >> 8;
|
||||
for(std::size_t i = 0; i < count; i++)
|
||||
{
|
||||
RGBColor color = *colors[i];
|
||||
std::size_t idx = (i * 3) + CORSAIR_V2HW_DATA_OFFSET;
|
||||
|
||||
buffer[idx] = RGBGetRValue(color);
|
||||
buffer[idx + 1] = RGBGetGValue(color);
|
||||
buffer[idx + 2] = RGBGetBValue(color);
|
||||
}
|
||||
|
||||
SetLEDs(buffer, length);
|
||||
delete[] buffer;
|
||||
}
|
||||
@@ -1,32 +0,0 @@
|
||||
/*---------------------------------------------------------------------*\
|
||||
| CorsairPeripheralV2HardwareController.h |
|
||||
| |
|
||||
| Driver for the newer Corsair peripherals that use the '08' |
|
||||
| based USB protocol and support hardware lighting modes. |
|
||||
| |
|
||||
| Chris M (Dr_No) 07 Dec 2022 |
|
||||
\*---------------------------------------------------------------------*/
|
||||
#pragma once
|
||||
|
||||
#include "RGBController.h"
|
||||
#include "CorsairPeripheralV2Controller.h"
|
||||
|
||||
#include <string>
|
||||
#include <hidapi/hidapi.h>
|
||||
|
||||
#undef CORSAIR_V2_WRITE_SIZE
|
||||
#define CORSAIR_V2_WRITE_SIZE 1025
|
||||
#define CORSAIR_V2HW_DATA_OFFSET 2
|
||||
|
||||
class CorsairPeripheralV2HWController : public CorsairPeripheralV2Controller
|
||||
{
|
||||
public:
|
||||
CorsairPeripheralV2HWController(hid_device* dev_handle, const char* path, std::string name, uint16_t pid);
|
||||
~CorsairPeripheralV2HWController();
|
||||
|
||||
void SetLedsDirect(std::vector<RGBColor *> colors);
|
||||
|
||||
private:
|
||||
void SetLedsDirectColourBlocks(std::vector<RGBColor *> colors);
|
||||
void SetLedsDirectTriplets(std::vector<RGBColor *> colors);
|
||||
};
|
||||
@@ -1,268 +0,0 @@
|
||||
/*---------------------------------------------------------------------*\
|
||||
| RGBController_CorsairV2HardwareController.cpp |
|
||||
| |
|
||||
| Driver for the newer Corsair peripherals that use the '08' |
|
||||
| based USB protocol and support hardware lighting modes. |
|
||||
| |
|
||||
| Chris M (Dr_No) 10 Dec 2022 |
|
||||
\*---------------------------------------------------------------------*/
|
||||
#include "LogManager.h"
|
||||
#include "RGBController_CorsairV2Hardware.h"
|
||||
|
||||
using namespace std::chrono_literals;
|
||||
|
||||
/**------------------------------------------------------------------*\
|
||||
@name Corsair Peripherals V2 Hardware
|
||||
@category Keyboard
|
||||
@type USB
|
||||
@save :robot:
|
||||
@direct :white_check_mark:
|
||||
@effects :white_check_mark:
|
||||
@detectors DetectCorsairV2HardwareControllers
|
||||
@comment
|
||||
\*-------------------------------------------------------------------*/
|
||||
|
||||
RGBController_CorsairV2HW::RGBController_CorsairV2HW(CorsairPeripheralV2Controller *controller_ptr)
|
||||
{
|
||||
controller = controller_ptr;
|
||||
const corsair_v2_device* corsair = controller->GetDeviceData();
|
||||
|
||||
vendor = "Corsair";
|
||||
description = controller->GetName();
|
||||
type = corsair->type;
|
||||
version = controller->GetFirmwareString();
|
||||
location = controller->GetDeviceLocation();
|
||||
serial = controller->GetSerialString();
|
||||
|
||||
mode Direct;
|
||||
Direct.name = "Direct";
|
||||
Direct.value = CORSAIR_V2_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 = CORSAIR_V2_MODE_STATIC;
|
||||
Static.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
|
||||
Static.colors_min = 1;
|
||||
Static.colors_max = 1;
|
||||
Static.colors.resize(Static.colors_max);
|
||||
Static.brightness_min = CORSAIR_V2_BRIGHTNESS_MIN;
|
||||
Static.brightness_max = CORSAIR_V2_BRIGHTNESS_MAX;
|
||||
Static.brightness = CORSAIR_V2_BRIGHTNESS_MAX;
|
||||
Static.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
modes.push_back(Static);
|
||||
|
||||
SetupZones();
|
||||
/*-----------------------------------------------------*\
|
||||
| The Corsair K55 RGB PRO requires a packet within |
|
||||
| 1 minutes of sending the lighting change in order |
|
||||
| to not revert back into rainbow mode. Start a thread |
|
||||
| to continuously send a keepalive packet every 50 sec |
|
||||
\*-----------------------------------------------------*/
|
||||
keepalive_thread_run = true;
|
||||
keepalive_thread = new std::thread(&RGBController_CorsairV2HW::KeepaliveThread, this);
|
||||
}
|
||||
|
||||
RGBController_CorsairV2HW::~RGBController_CorsairV2HW()
|
||||
{
|
||||
/*-----------------------------------------------------*\
|
||||
| Close keepalive thread |
|
||||
\*-----------------------------------------------------*/
|
||||
keepalive_thread_run = false;
|
||||
keepalive_thread->join();
|
||||
delete keepalive_thread;
|
||||
|
||||
/*---------------------------------------------------------*\
|
||||
| Delete the matrix map |
|
||||
\*---------------------------------------------------------*/
|
||||
for(unsigned int zone_index = 0; zone_index < zones.size(); zone_index++)
|
||||
{
|
||||
if(zones[zone_index].type == ZONE_TYPE_MATRIX)
|
||||
{
|
||||
delete zones[zone_index].matrix_map;
|
||||
}
|
||||
}
|
||||
|
||||
delete controller;
|
||||
}
|
||||
|
||||
void RGBController_CorsairV2HW::SetupZones()
|
||||
{
|
||||
std::string physical_size;
|
||||
KEYBOARD_LAYOUT new_layout;
|
||||
unsigned int max_led_value = 0;
|
||||
const corsair_v2_device* corsair = controller->GetDeviceData();
|
||||
unsigned int layout = controller->GetKeyboardLayout();
|
||||
|
||||
switch(layout)
|
||||
{
|
||||
case CORSAIR_V2_KB_LAYOUT_ISO:
|
||||
new_layout = KEYBOARD_LAYOUT_ISO_QWERTY;
|
||||
break;
|
||||
|
||||
case CORSAIR_V2_KB_LAYOUT_JIS:
|
||||
new_layout = KEYBOARD_LAYOUT_JIS;
|
||||
break;
|
||||
|
||||
case CORSAIR_V2_KB_LAYOUT_ANSI:
|
||||
case CORSAIR_V2_KB_LAYOUT_ABNT:
|
||||
default:
|
||||
new_layout = KEYBOARD_LAYOUT_ANSI_QWERTY;
|
||||
break;
|
||||
}
|
||||
|
||||
/*---------------------------------------------------------*\
|
||||
| Fill in zones from the device data |
|
||||
\*---------------------------------------------------------*/
|
||||
for(size_t i = 0; i < CORSAIR_ZONES_MAX; i++)
|
||||
{
|
||||
if(corsair->zones[i] == NULL)
|
||||
{
|
||||
break;
|
||||
}
|
||||
else
|
||||
{
|
||||
zone new_zone;
|
||||
|
||||
new_zone.name = corsair->zones[i]->name;
|
||||
new_zone.type = corsair->zones[i]->type;
|
||||
|
||||
if(new_zone.type == ZONE_TYPE_MATRIX)
|
||||
{
|
||||
KeyboardLayoutManager new_kb(new_layout, corsair->layout_new->base_size, corsair->layout_new->key_values);
|
||||
|
||||
matrix_map_type * new_map = new matrix_map_type;
|
||||
new_zone.matrix_map = new_map;
|
||||
|
||||
new_map->height = corsair->zones[i]->rows;
|
||||
new_map->width = corsair->zones[i]->cols;
|
||||
new_map->map = new unsigned int[new_map->height * new_map->width];
|
||||
|
||||
if(corsair->layout_new->base_size != KEYBOARD_SIZE_EMPTY)
|
||||
{
|
||||
/*---------------------------------------------------------*\
|
||||
| Minor adjustments to keyboard layout |
|
||||
\*---------------------------------------------------------*/
|
||||
new_zone.leds_count = new_kb.GetKeyCount();
|
||||
keyboard_keymap_overlay_values* temp = corsair->layout_new;
|
||||
new_kb.ChangeKeys(*temp);
|
||||
|
||||
/*---------------------------------------------------------*\
|
||||
| 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);
|
||||
max_led_value = std::max(max_led_value, new_led.value);
|
||||
leds.push_back(new_led);
|
||||
}
|
||||
}
|
||||
|
||||
/*---------------------------------------------------------*\
|
||||
| Add 1 the max_led_value to account for the 0th index |
|
||||
\*---------------------------------------------------------*/
|
||||
max_led_value++;
|
||||
}
|
||||
else
|
||||
{
|
||||
new_zone.leds_count = corsair->zones[i]->rows * corsair->zones[i]->cols;
|
||||
new_zone.matrix_map = NULL;
|
||||
|
||||
/*---------------------------------------------------------*\
|
||||
| Create LEDs for the Linear / Single zone |
|
||||
\*---------------------------------------------------------*/
|
||||
for(size_t led_idx = 0; led_idx < new_zone.leds_count; led_idx++)
|
||||
{
|
||||
led new_led;
|
||||
|
||||
new_led.name = new_zone.name + " ";
|
||||
new_led.name.append(std::to_string( led_idx ));
|
||||
new_led.value = leds.size();
|
||||
|
||||
leds.push_back(new_led);
|
||||
}
|
||||
|
||||
max_led_value = std::max(max_led_value, (unsigned int)leds.size());
|
||||
}
|
||||
|
||||
LOG_DEBUG("[%s] Creating a %s zone: %s with %d LEDs", name.c_str(),
|
||||
((new_zone.type == ZONE_TYPE_MATRIX) ? "matrix": "linear"),
|
||||
new_zone.name.c_str(), new_zone.leds_count);
|
||||
new_zone.leds_min = new_zone.leds_count;
|
||||
new_zone.leds_max = new_zone.leds_count;
|
||||
zones.push_back(new_zone);
|
||||
}
|
||||
}
|
||||
|
||||
SetupColors();
|
||||
|
||||
/*---------------------------------------------------------*\
|
||||
| Create a buffer map of pointers which contains the |
|
||||
| layout order of colors the device expects. |
|
||||
\*---------------------------------------------------------*/
|
||||
for(size_t led_idx = 0; led_idx < max_led_value; led_idx++)
|
||||
{
|
||||
buffer_map.push_back(&null_color);
|
||||
}
|
||||
|
||||
for(size_t led_idx = 0; led_idx < leds.size(); led_idx++)
|
||||
{
|
||||
buffer_map[leds[led_idx].value] = &colors[led_idx];
|
||||
}
|
||||
}
|
||||
|
||||
void RGBController_CorsairV2HW::ResizeZone(int /*zone*/, int /*new_size*/)
|
||||
{
|
||||
/*---------------------------------------------------------*\
|
||||
| This device does not support resizing zones |
|
||||
\*---------------------------------------------------------*/
|
||||
}
|
||||
|
||||
void RGBController_CorsairV2HW::DeviceUpdateLEDs()
|
||||
{
|
||||
last_update_time = std::chrono::steady_clock::now();
|
||||
|
||||
controller->SetLedsDirect(buffer_map);
|
||||
}
|
||||
|
||||
void RGBController_CorsairV2HW::UpdateZoneLEDs(int /*zone*/)
|
||||
{
|
||||
controller->SetLedsDirect(buffer_map);
|
||||
}
|
||||
|
||||
void RGBController_CorsairV2HW::UpdateSingleLED(int /*led*/)
|
||||
{
|
||||
controller->SetLedsDirect(buffer_map);
|
||||
}
|
||||
|
||||
void RGBController_CorsairV2HW::DeviceUpdateMode()
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
void RGBController_CorsairV2HW::KeepaliveThread()
|
||||
{
|
||||
while(keepalive_thread_run.load())
|
||||
{
|
||||
if(active_mode == 0)
|
||||
{
|
||||
if((std::chrono::steady_clock::now() - last_update_time) > std::chrono::milliseconds(50000))
|
||||
{
|
||||
DeviceUpdateLEDs();
|
||||
}
|
||||
}
|
||||
std::this_thread::sleep_for(30000ms);
|
||||
}
|
||||
}
|
||||
@@ -1,42 +0,0 @@
|
||||
/*---------------------------------------------------------------------*\
|
||||
| RGBController_CorsairV2HardwareController.h |
|
||||
| |
|
||||
| Driver for the newer Corsair peripherals that use the '08' |
|
||||
| based USB protocol and support hardware lighting modes. |
|
||||
| |
|
||||
| Chris M (Dr_No) 10 Dec 2022 |
|
||||
\*---------------------------------------------------------------------*/
|
||||
#pragma once
|
||||
|
||||
#include "RGBController.h"
|
||||
#include "CorsairPeripheralV2Controller.h"
|
||||
#include "CorsairPeripheralV2HardwareController.h"
|
||||
|
||||
class RGBController_CorsairV2HW : public RGBController
|
||||
{
|
||||
public:
|
||||
RGBController_CorsairV2HW(CorsairPeripheralV2Controller* controller_ptr);
|
||||
~RGBController_CorsairV2HW();
|
||||
|
||||
void SetupZones();
|
||||
void ResizeZone(int zone, int new_size);
|
||||
|
||||
void DeviceUpdateLEDs();
|
||||
void UpdateZoneLEDs(int zone);
|
||||
void UpdateSingleLED(int led);
|
||||
|
||||
void DeviceUpdateMode();
|
||||
void KeepaliveThread();
|
||||
|
||||
private:
|
||||
CorsairPeripheralV2Controller* controller;
|
||||
|
||||
RGBColor null_color = 0;
|
||||
std::vector<RGBColor *> buffer_map;
|
||||
|
||||
std::thread* keepalive_thread;
|
||||
std::atomic<bool> keepalive_thread_run;
|
||||
std::chrono::time_point
|
||||
<std::chrono::steady_clock> last_update_time;
|
||||
|
||||
};
|
||||
@@ -13,7 +13,7 @@
|
||||
using namespace std::chrono_literals;
|
||||
|
||||
/**------------------------------------------------------------------*\
|
||||
@name Corsair Peripherals V2 Software
|
||||
@name Corsair K55 RGB Pro
|
||||
@category Keyboard
|
||||
@type USB
|
||||
@save :x:
|
||||
@@ -35,7 +35,7 @@ RGBController_CorsairV2SW::RGBController_CorsairV2SW(CorsairPeripheralV2Controll
|
||||
location = controller->GetDeviceLocation();
|
||||
serial = controller->GetSerialString();
|
||||
|
||||
if(corsair->protocol & CORSAIR_V2_TYPE_SW_COLOUR_BLOCK)
|
||||
if(corsair->supports & CORSAIR_V2_MODE_SW)
|
||||
{
|
||||
mode Direct;
|
||||
Direct.name = "Direct";
|
||||
@@ -43,7 +43,10 @@ RGBController_CorsairV2SW::RGBController_CorsairV2SW(CorsairPeripheralV2Controll
|
||||
Direct.flags = MODE_FLAG_HAS_PER_LED_COLOR;
|
||||
Direct.color_mode = MODE_COLORS_PER_LED;
|
||||
modes.push_back(Direct);
|
||||
}
|
||||
|
||||
if(corsair->supports & CORSAIR_V2_MODE_HW)
|
||||
{
|
||||
mode Static;
|
||||
Static.name = "Static";
|
||||
Static.value = CORSAIR_V2_MODE_STATIC;
|
||||
@@ -94,28 +97,8 @@ RGBController_CorsairV2SW::~RGBController_CorsairV2SW()
|
||||
|
||||
void RGBController_CorsairV2SW::SetupZones()
|
||||
{
|
||||
std::string physical_size;
|
||||
KEYBOARD_LAYOUT new_layout;
|
||||
unsigned int max_led_value = 0;
|
||||
const corsair_v2_device* corsair = controller->GetDeviceData();
|
||||
unsigned int layout = controller->GetKeyboardLayout();
|
||||
|
||||
switch(layout)
|
||||
{
|
||||
case CORSAIR_V2_KB_LAYOUT_ISO:
|
||||
new_layout = KEYBOARD_LAYOUT_ISO_QWERTY;
|
||||
break;
|
||||
|
||||
case CORSAIR_V2_KB_LAYOUT_JIS:
|
||||
new_layout = KEYBOARD_LAYOUT_JIS;
|
||||
break;
|
||||
|
||||
case CORSAIR_V2_KB_LAYOUT_ANSI:
|
||||
case CORSAIR_V2_KB_LAYOUT_ABNT:
|
||||
default:
|
||||
new_layout = KEYBOARD_LAYOUT_ANSI_QWERTY;
|
||||
break;
|
||||
}
|
||||
|
||||
/*---------------------------------------------------------*\
|
||||
| Fill in zones from the device data |
|
||||
@@ -135,45 +118,44 @@ void RGBController_CorsairV2SW::SetupZones()
|
||||
|
||||
if(new_zone.type == ZONE_TYPE_MATRIX)
|
||||
{
|
||||
KeyboardLayoutManager new_kb(new_layout, corsair->layout_new->base_size, corsair->layout_new->key_values);
|
||||
|
||||
new_zone.leds_count = corsair->layout_size;
|
||||
matrix_map_type * new_map = new matrix_map_type;
|
||||
new_zone.matrix_map = new_map;
|
||||
|
||||
new_map->height = corsair->zones[i]->rows;
|
||||
new_map->width = corsair->zones[i]->cols;
|
||||
new_map->map = new unsigned int[new_map->height * new_map->width];
|
||||
|
||||
if(corsair->layout_new->base_size != KEYBOARD_SIZE_EMPTY)
|
||||
new_map->map = new unsigned int[new_map->height * new_map->width];
|
||||
|
||||
/*---------------------------------------------------------*\
|
||||
| Create an empty matrix |
|
||||
\*---------------------------------------------------------*/
|
||||
for(unsigned int y = 0; y < new_map->height; y++)
|
||||
{
|
||||
/*---------------------------------------------------------*\
|
||||
| Minor adjustments to keyboard layout |
|
||||
\*---------------------------------------------------------*/
|
||||
new_zone.leds_count = new_kb.GetKeyCount();
|
||||
keyboard_keymap_overlay_values* temp = corsair->layout_new;
|
||||
new_kb.ChangeKeys(*temp);
|
||||
|
||||
/*---------------------------------------------------------*\
|
||||
| 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++)
|
||||
for(unsigned int x = 0; x < new_map->width; x++)
|
||||
{
|
||||
led new_led;
|
||||
|
||||
new_led.name = new_kb.GetKeyNameAt(led_idx);
|
||||
new_led.value = new_kb.GetKeyValueAt(led_idx);
|
||||
max_led_value = std::max(max_led_value, new_led.value);
|
||||
leds.push_back(new_led);
|
||||
new_map->map[(y * new_map->width) + x] = NA;
|
||||
}
|
||||
}
|
||||
|
||||
/*---------------------------------------------------------*\
|
||||
| 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 = corsair->layout[led_idx].name;
|
||||
new_led.value = corsair->layout[led_idx].index;
|
||||
max_led_value = std::max(max_led_value, new_led.value);
|
||||
leds.push_back(new_led);
|
||||
|
||||
uint8_t layout_index = (corsair->layout[led_idx].row * new_map->width)
|
||||
+ corsair->layout[led_idx].col;
|
||||
new_map->map[layout_index] = led_idx;
|
||||
}
|
||||
|
||||
/*---------------------------------------------------------*\
|
||||
| Add 1 the max_led_value to account for the 0th index |
|
||||
\*---------------------------------------------------------*/
|
||||
@@ -267,6 +249,6 @@ void RGBController_CorsairV2SW::KeepaliveThread()
|
||||
DeviceUpdateLEDs();
|
||||
}
|
||||
}
|
||||
std::this_thread::sleep_for(30000ms);
|
||||
std::this_thread::sleep_for(3000ms);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -10,7 +10,6 @@
|
||||
|
||||
#include "RGBController.h"
|
||||
#include "CorsairPeripheralV2Controller.h"
|
||||
#include "CorsairPeripheralV2HardwareController.h"
|
||||
#include "CorsairPeripheralV2SoftwareController.h"
|
||||
|
||||
class RGBController_CorsairV2SW : public RGBController
|
||||
|
||||
@@ -197,7 +197,6 @@ void RGBController_Crucial::DeviceUpdateMode()
|
||||
if(modes[active_mode].value == 0xFFFF)
|
||||
{
|
||||
controller->SetMode(CRUCIAL_MODE_STATIC);
|
||||
controller->SetAllColorsEffect(&colors[0]);
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
@@ -1,234 +0,0 @@
|
||||
/*---------------------------------------------------------*\
|
||||
| Processing Code for Cryorig H7 Quad Lumi |
|
||||
| |
|
||||
| Adam Honse ([email protected]), 4/15/2023 |
|
||||
\*---------------------------------------------------------*/
|
||||
|
||||
#include "CryorigH7QuadLumiController.h"
|
||||
#include "LogManager.h"
|
||||
|
||||
#include <fstream>
|
||||
#include <iostream>
|
||||
#include <string>
|
||||
#include <cstring>
|
||||
|
||||
CryorigH7QuadLumiController::CryorigH7QuadLumiController(hid_device* dev_handle, const char* path)
|
||||
{
|
||||
dev = dev_handle;
|
||||
location = path;
|
||||
|
||||
SendFirmwareRequest();
|
||||
}
|
||||
|
||||
CryorigH7QuadLumiController::~CryorigH7QuadLumiController()
|
||||
{
|
||||
hid_close(dev);
|
||||
}
|
||||
|
||||
std::string CryorigH7QuadLumiController::GetLocation()
|
||||
{
|
||||
return("HID: " + location);
|
||||
}
|
||||
|
||||
std::string CryorigH7QuadLumiController::GetFirmwareVersion()
|
||||
{
|
||||
return(firmware_version);
|
||||
}
|
||||
|
||||
std::string CryorigH7QuadLumiController::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 CryorigH7QuadLumiController::SetChannelEffect
|
||||
(
|
||||
unsigned char channel,
|
||||
unsigned char mode,
|
||||
unsigned char speed,
|
||||
bool direction,
|
||||
RGBColor * colors,
|
||||
unsigned int num_colors
|
||||
)
|
||||
{
|
||||
unsigned char color_data[120];
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| If mode requires no colors, send packet |
|
||||
\*-----------------------------------------------------*/
|
||||
if(num_colors == 0)
|
||||
{
|
||||
/*-----------------------------------------------------*\
|
||||
| Send mode without color data |
|
||||
\*-----------------------------------------------------*/
|
||||
SendPacket(channel, mode, direction, 0, speed, 0, NULL);
|
||||
}
|
||||
/*-----------------------------------------------------*\
|
||||
| If mode requires indexed colors, send color index |
|
||||
| packets for each mode color |
|
||||
\*-----------------------------------------------------*/
|
||||
else if(num_colors <= 8)
|
||||
{
|
||||
for(std::size_t color_idx = 0; color_idx < num_colors; color_idx++)
|
||||
{
|
||||
/*-----------------------------------------------------*\
|
||||
| Fill in color data (5 entries per color) |
|
||||
\*-----------------------------------------------------*/
|
||||
for (std::size_t idx = 0; idx < 40; idx++)
|
||||
{
|
||||
int pixel_idx = idx * 3;
|
||||
RGBColor color = colors[color_idx];
|
||||
color_data[pixel_idx + 0x00] = RGBGetGValue(color);
|
||||
color_data[pixel_idx + 0x01] = RGBGetRValue(color);
|
||||
color_data[pixel_idx + 0x02] = RGBGetBValue(color);
|
||||
}
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Send mode and color data |
|
||||
\*-----------------------------------------------------*/
|
||||
SendPacket(channel, mode, direction, color_idx, speed, 5, &color_data[0]);
|
||||
}
|
||||
}
|
||||
/*-----------------------------------------------------*\
|
||||
| If mode requires per-LED colors, fill colors array |
|
||||
\*-----------------------------------------------------*/
|
||||
else
|
||||
{
|
||||
/*-----------------------------------------------------*\
|
||||
| Fill in color data (up to 40 colors) |
|
||||
\*-----------------------------------------------------*/
|
||||
for (std::size_t idx = 0; idx < num_colors; idx++)
|
||||
{
|
||||
int pixel_idx = idx * 3;
|
||||
RGBColor color = colors[idx];
|
||||
color_data[pixel_idx + 0x00] = RGBGetGValue(color);
|
||||
color_data[pixel_idx + 0x01] = RGBGetRValue(color);
|
||||
color_data[pixel_idx + 0x02] = RGBGetBValue(color);
|
||||
}
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Send mode and color data |
|
||||
\*-----------------------------------------------------*/
|
||||
SendPacket(channel, mode, direction, 0, speed, num_colors, &color_data[0]);
|
||||
}
|
||||
}
|
||||
|
||||
void CryorigH7QuadLumiController::SetChannelLEDs
|
||||
(
|
||||
unsigned char channel,
|
||||
RGBColor * colors,
|
||||
unsigned int num_colors
|
||||
)
|
||||
{
|
||||
unsigned char color_data[120];
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Fill in color data (up to 40 colors) |
|
||||
\*-----------------------------------------------------*/
|
||||
for (std::size_t idx = 0; idx < num_colors; idx++)
|
||||
{
|
||||
int pixel_idx = idx * 3;
|
||||
RGBColor color = colors[idx];
|
||||
color_data[pixel_idx + 0x00] = RGBGetGValue(color);
|
||||
color_data[pixel_idx + 0x01] = RGBGetRValue(color);
|
||||
color_data[pixel_idx + 0x02] = RGBGetBValue(color);
|
||||
}
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Send color data |
|
||||
\*-----------------------------------------------------*/
|
||||
SendPacket(channel, CRYORIG_H7_QUAD_LUMI_MODE_FIXED, false, 0, 0, num_colors, &color_data[0]);
|
||||
}
|
||||
|
||||
/*-------------------------------------------------------------------------------------------------*\
|
||||
| Private packet sending functions. |
|
||||
\*-------------------------------------------------------------------------------------------------*/
|
||||
|
||||
void CryorigH7QuadLumiController::SendPacket
|
||||
(
|
||||
unsigned char channel,
|
||||
unsigned char mode,
|
||||
bool direction,
|
||||
unsigned char color_idx,
|
||||
unsigned char speed,
|
||||
unsigned char color_count,
|
||||
unsigned char* color_data
|
||||
)
|
||||
{
|
||||
unsigned char usb_buf[65];
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Zero out buffer |
|
||||
\*-----------------------------------------------------*/
|
||||
memset(usb_buf, 0x00, sizeof(usb_buf));
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Set up RGB packet |
|
||||
\*-----------------------------------------------------*/
|
||||
usb_buf[0x00] = 0x02;
|
||||
usb_buf[0x01] = 0x4C;
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Set channel and direction in RGB packet |
|
||||
\*-----------------------------------------------------*/
|
||||
usb_buf[0x02] = (channel + 1) | (direction ? (1 << 4) : 0);
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Set mode in RGB packet |
|
||||
\*-----------------------------------------------------*/
|
||||
usb_buf[0x03] = mode;
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Set color index and speed in RGB packet |
|
||||
\*-----------------------------------------------------*/
|
||||
usb_buf[0x04] = ( color_idx << 5 ) | speed;
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Copy in color data bytes |
|
||||
\*-----------------------------------------------------*/
|
||||
memcpy(&usb_buf[0x05 + (channel * 15)], color_data, color_count * 3);
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Send packet |
|
||||
\*-----------------------------------------------------*/
|
||||
hid_write(dev, usb_buf, 65);
|
||||
}
|
||||
|
||||
void CryorigH7QuadLumiController::SendFirmwareRequest()
|
||||
{
|
||||
unsigned char usb_buf[17];
|
||||
unsigned int ret_val = 0;
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Zero out buffer |
|
||||
\*-----------------------------------------------------*/
|
||||
memset(usb_buf, 0x00, sizeof(usb_buf));
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Set up Firmware Request packet |
|
||||
\*-----------------------------------------------------*/
|
||||
usb_buf[0x00] = 0x02;
|
||||
usb_buf[0x01] = 0x5C;
|
||||
|
||||
hid_write(dev, usb_buf, 65);
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Receive packets until 0x11 0x01 is received |
|
||||
\*-----------------------------------------------------*/
|
||||
do
|
||||
{
|
||||
ret_val = hid_read(dev, usb_buf, sizeof(usb_buf));
|
||||
} while( (ret_val != 17) );
|
||||
|
||||
snprintf(firmware_version, 16, "%u.%u", usb_buf[0x0D], usb_buf[0x0E]);
|
||||
}
|
||||
@@ -1,88 +0,0 @@
|
||||
/*---------------------------------------------------------*\
|
||||
| Definitions for Cryorig H7 Quad Lumi |
|
||||
| |
|
||||
| Adam Honse ([email protected]), 4/15/2023 |
|
||||
\*---------------------------------------------------------*/
|
||||
|
||||
#include "RGBController.h"
|
||||
#include <string>
|
||||
#include <vector>
|
||||
#include <hidapi/hidapi.h>
|
||||
|
||||
#pragma once
|
||||
|
||||
enum
|
||||
{
|
||||
CRYORIG_H7_QUAD_LUMI_CHANNEL_ALL = 0x00, /* All channels */
|
||||
CRYORIG_H7_QUAD_LUMI_CHANNEL_1 = 0x01, /* Channel 1 */
|
||||
CRYORIG_H7_QUAD_LUMI_CHANNEL_2 = 0x02, /* Channel 2 */
|
||||
CRYORIG_H7_QUAD_LUMI_NUM_CHANNELS = 0x02 /* Number of channels */
|
||||
};
|
||||
|
||||
enum
|
||||
{
|
||||
CRYORIG_H7_QUAD_LUMI_SPEED_SLOWEST = 0x00, /* Slowest speed */
|
||||
CRYORIG_H7_QUAD_LUMI_SPEED_SLOW = 0x01, /* Slow speed */
|
||||
CRYORIG_H7_QUAD_LUMI_SPEED_NORMAL = 0x02, /* Normal speed */
|
||||
CRYORIG_H7_QUAD_LUMI_SPEED_FAST = 0x03, /* Fast speed */
|
||||
CRYORIG_H7_QUAD_LUMI_SPEED_FASTEST = 0x04, /* Fastest speed */
|
||||
};
|
||||
|
||||
enum
|
||||
{
|
||||
CRYORIG_H7_QUAD_LUMI_MODE_FIXED = 0x00, /* Fixed colors mode */
|
||||
CRYORIG_H7_QUAD_LUMI_MODE_FADING = 0x01, /* Fading mode */
|
||||
CRYORIG_H7_QUAD_LUMI_MODE_SPECTRUM = 0x02, /* Spectrum cycle mode */
|
||||
CRYORIG_H7_QUAD_LUMI_MODE_MARQUEE = 0x03, /* Marquee mode */
|
||||
CRYORIG_H7_QUAD_LUMI_MODE_COVER_MARQUEE = 0x04, /* Cover marquee mode */
|
||||
CRYORIG_H7_QUAD_LUMI_MODE_ALTERNATING = 0x05, /* Alternating mode */
|
||||
CRYORIG_H7_QUAD_LUMI_MODE_BREATHING = 0x06, /* Breathing mode */
|
||||
CRYORIG_H7_QUAD_LUMI_MODE_PULSING = 0x07, /* Pulsing mode */
|
||||
};
|
||||
|
||||
class CryorigH7QuadLumiController
|
||||
{
|
||||
public:
|
||||
CryorigH7QuadLumiController(hid_device* dev_handle, const char* path);
|
||||
~CryorigH7QuadLumiController();
|
||||
|
||||
std::string GetFirmwareVersion();
|
||||
std::string GetLocation();
|
||||
std::string GetSerialString();
|
||||
|
||||
void SetChannelEffect
|
||||
(
|
||||
unsigned char channel,
|
||||
unsigned char mode,
|
||||
unsigned char speed,
|
||||
bool direction,
|
||||
RGBColor * colors,
|
||||
unsigned int num_colors
|
||||
);
|
||||
|
||||
void SetChannelLEDs
|
||||
(
|
||||
unsigned char channel,
|
||||
RGBColor * colors,
|
||||
unsigned int num_colors
|
||||
);
|
||||
|
||||
private:
|
||||
hid_device* dev;
|
||||
|
||||
char firmware_version[16];
|
||||
std::string location;
|
||||
|
||||
void SendPacket
|
||||
(
|
||||
unsigned char channel,
|
||||
unsigned char mode,
|
||||
bool direction,
|
||||
unsigned char color_idx,
|
||||
unsigned char speed,
|
||||
unsigned char color_count,
|
||||
unsigned char* color_data
|
||||
);
|
||||
|
||||
void SendFirmwareRequest();
|
||||
};
|
||||
@@ -1,27 +0,0 @@
|
||||
#include "Detector.h"
|
||||
#include "CryorigH7QuadLumiController.h"
|
||||
#include "RGBController.h"
|
||||
#include "RGBController_CryorigH7QuadLumi.h"
|
||||
#include <hidapi/hidapi.h>
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| CRYORIG/NZXT USB IDs |
|
||||
\*-----------------------------------------------------*/
|
||||
#define NZXT_VID 0x1E71
|
||||
#define CRYORIG_H7_QUAD_LUMI_PID 0x1712
|
||||
|
||||
static void DetectCryorigH7QuadLumi(hid_device_info* info, const std::string& name)
|
||||
{
|
||||
hid_device* dev = hid_open_path(info->path);
|
||||
|
||||
if(dev)
|
||||
{
|
||||
CryorigH7QuadLumiController* controller = new CryorigH7QuadLumiController(dev, info->path);
|
||||
RGBController_CryorigH7QuadLumi* rgb_controller = new RGBController_CryorigH7QuadLumi(controller);
|
||||
rgb_controller->name = name;
|
||||
|
||||
ResourceManager::get()->RegisterRGBController(rgb_controller);
|
||||
}
|
||||
}
|
||||
|
||||
REGISTER_HID_DETECTOR("CRYORIG H7 Quad Lumi", DetectCryorigH7QuadLumi, NZXT_VID, CRYORIG_H7_QUAD_LUMI_PID);
|
||||
@@ -1,247 +0,0 @@
|
||||
/*-----------------------------------------*\
|
||||
| RGBController_CryorigH7QuadLumi.cpp |
|
||||
| |
|
||||
| Generic RGB Interface for Cryorig H7 |
|
||||
| Quad Lumi |
|
||||
| |
|
||||
| Adam Honse (CalcProgrammer1) 4/15/2023 |
|
||||
\*-----------------------------------------*/
|
||||
|
||||
#include "RGBController_CryorigH7QuadLumi.h"
|
||||
|
||||
/**------------------------------------------------------------------*\
|
||||
@name Cryorig H7 Quad Lumi
|
||||
@category Cooler
|
||||
@type USB
|
||||
@save :x:
|
||||
@direct :white_check_mark:
|
||||
@effects :white_check_mark:
|
||||
@detectors DetectCryorigH7QuadLumi
|
||||
@comment
|
||||
\*-------------------------------------------------------------------*/
|
||||
|
||||
RGBController_CryorigH7QuadLumi::RGBController_CryorigH7QuadLumi(CryorigH7QuadLumiController* controller_ptr)
|
||||
{
|
||||
controller = controller_ptr;
|
||||
|
||||
name = "CRYORIG H7 Quad Lumi";
|
||||
vendor = "CRYORIG";
|
||||
type = DEVICE_TYPE_COOLER;
|
||||
description = "CRYORIG H7 Quad Lumi Device";
|
||||
version = controller->GetFirmwareVersion();
|
||||
location = controller->GetLocation();
|
||||
serial = controller->GetSerialString();
|
||||
|
||||
mode Direct;
|
||||
Direct.name = "Direct";
|
||||
Direct.value = CRYORIG_H7_QUAD_LUMI_MODE_FIXED;
|
||||
Direct.flags = MODE_FLAG_HAS_PER_LED_COLOR;
|
||||
Direct.color_mode = MODE_COLORS_PER_LED;
|
||||
modes.push_back(Direct);
|
||||
|
||||
mode Fading;
|
||||
Fading.name = "Fading";
|
||||
Fading.value = CRYORIG_H7_QUAD_LUMI_MODE_FADING;
|
||||
Fading.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
|
||||
Fading.speed_min = CRYORIG_H7_QUAD_LUMI_SPEED_SLOWEST;
|
||||
Fading.speed_max = CRYORIG_H7_QUAD_LUMI_SPEED_FASTEST;
|
||||
Fading.colors_min = 1;
|
||||
Fading.colors_max = 8;
|
||||
Fading.speed = CRYORIG_H7_QUAD_LUMI_SPEED_NORMAL;
|
||||
Fading.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Fading.colors.resize(2);
|
||||
modes.push_back(Fading);
|
||||
|
||||
mode SpectrumCycle;
|
||||
SpectrumCycle.name = "Rainbow Wave";
|
||||
SpectrumCycle.value = CRYORIG_H7_QUAD_LUMI_MODE_SPECTRUM;
|
||||
SpectrumCycle.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
|
||||
SpectrumCycle.speed_min = CRYORIG_H7_QUAD_LUMI_SPEED_SLOWEST;
|
||||
SpectrumCycle.speed_max = CRYORIG_H7_QUAD_LUMI_SPEED_FASTEST;
|
||||
SpectrumCycle.speed = CRYORIG_H7_QUAD_LUMI_SPEED_NORMAL;
|
||||
SpectrumCycle.direction = MODE_DIRECTION_RIGHT;
|
||||
SpectrumCycle.color_mode = MODE_COLORS_NONE;
|
||||
modes.push_back(SpectrumCycle);
|
||||
|
||||
mode Marquee;
|
||||
Marquee.name = "Marquee";
|
||||
Marquee.value = CRYORIG_H7_QUAD_LUMI_MODE_MARQUEE;
|
||||
Marquee.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
|
||||
Marquee.speed_min = CRYORIG_H7_QUAD_LUMI_SPEED_SLOWEST;
|
||||
Marquee.speed_max = CRYORIG_H7_QUAD_LUMI_SPEED_FASTEST;
|
||||
Marquee.colors_min = 1;
|
||||
Marquee.colors_max = 1;
|
||||
Marquee.speed = CRYORIG_H7_QUAD_LUMI_SPEED_NORMAL;
|
||||
Marquee.direction = MODE_DIRECTION_RIGHT;
|
||||
Marquee.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Marquee.colors.resize(1);
|
||||
modes.push_back(Marquee);
|
||||
|
||||
mode CoverMarquee;
|
||||
CoverMarquee.name = "Cover Marquee";
|
||||
CoverMarquee.value = CRYORIG_H7_QUAD_LUMI_MODE_COVER_MARQUEE;
|
||||
CoverMarquee.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
|
||||
CoverMarquee.speed_min = CRYORIG_H7_QUAD_LUMI_SPEED_SLOWEST;
|
||||
CoverMarquee.speed_max = CRYORIG_H7_QUAD_LUMI_SPEED_FASTEST;
|
||||
CoverMarquee.colors_min = 1;
|
||||
CoverMarquee.colors_max = 8;
|
||||
CoverMarquee.speed = CRYORIG_H7_QUAD_LUMI_SPEED_NORMAL;
|
||||
CoverMarquee.direction = MODE_DIRECTION_RIGHT;
|
||||
CoverMarquee.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
CoverMarquee.colors.resize(2);
|
||||
modes.push_back(CoverMarquee);
|
||||
|
||||
mode Alternating;
|
||||
Alternating.name = "Alternating";
|
||||
Alternating.value = CRYORIG_H7_QUAD_LUMI_MODE_ALTERNATING;
|
||||
Alternating.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
|
||||
Alternating.speed_min = CRYORIG_H7_QUAD_LUMI_SPEED_SLOWEST;
|
||||
Alternating.speed_max = CRYORIG_H7_QUAD_LUMI_SPEED_FASTEST;
|
||||
Alternating.colors_min = 1;
|
||||
Alternating.colors_max = 2;
|
||||
Alternating.speed = CRYORIG_H7_QUAD_LUMI_SPEED_NORMAL;
|
||||
Alternating.direction = MODE_DIRECTION_RIGHT;
|
||||
Alternating.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Alternating.colors.resize(2);
|
||||
modes.push_back(Alternating);
|
||||
|
||||
mode Pulsing;
|
||||
Pulsing.name = "Pulsing";
|
||||
Pulsing.value = CRYORIG_H7_QUAD_LUMI_MODE_PULSING;
|
||||
Pulsing.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
|
||||
Pulsing.speed_min = CRYORIG_H7_QUAD_LUMI_SPEED_SLOWEST;
|
||||
Pulsing.speed_max = CRYORIG_H7_QUAD_LUMI_SPEED_FASTEST;
|
||||
Pulsing.colors_min = 1;
|
||||
Pulsing.colors_max = 8;
|
||||
Pulsing.speed = CRYORIG_H7_QUAD_LUMI_SPEED_NORMAL;
|
||||
Pulsing.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Pulsing.colors.resize(2) ;
|
||||
modes.push_back(Pulsing);
|
||||
|
||||
mode Breathing;
|
||||
Breathing.name = "Breathing";
|
||||
Breathing.value = CRYORIG_H7_QUAD_LUMI_MODE_BREATHING;
|
||||
Breathing.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_PER_LED_COLOR;
|
||||
Breathing.speed_min = CRYORIG_H7_QUAD_LUMI_SPEED_SLOWEST;
|
||||
Breathing.speed_max = CRYORIG_H7_QUAD_LUMI_SPEED_FASTEST;
|
||||
Breathing.colors_min = 1;
|
||||
Breathing.colors_max = 8;
|
||||
Breathing.speed = CRYORIG_H7_QUAD_LUMI_SPEED_NORMAL;
|
||||
Breathing.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Breathing.colors.resize(2);
|
||||
modes.push_back(Breathing);
|
||||
|
||||
SetupZones();
|
||||
}
|
||||
|
||||
RGBController_CryorigH7QuadLumi::~RGBController_CryorigH7QuadLumi()
|
||||
{
|
||||
delete controller;
|
||||
}
|
||||
|
||||
void RGBController_CryorigH7QuadLumi::SetupZones()
|
||||
{
|
||||
const char* zone_names[] = { "Logo", "Underglow" };
|
||||
|
||||
/*-------------------------------------------------*\
|
||||
| Set up zones |
|
||||
\*-------------------------------------------------*/
|
||||
for(unsigned int zone_idx = 0; zone_idx < 2; zone_idx++)
|
||||
{
|
||||
zone* new_zone = new zone;
|
||||
|
||||
new_zone->name = zone_names[zone_idx];
|
||||
new_zone->type = ZONE_TYPE_LINEAR;
|
||||
new_zone->leds_min = 5;
|
||||
new_zone->leds_max = 5;
|
||||
new_zone->leds_count = 5;
|
||||
new_zone->matrix_map = NULL;
|
||||
|
||||
zones.push_back(*new_zone);
|
||||
}
|
||||
|
||||
/*-------------------------------------------------*\
|
||||
| Set up LEDs |
|
||||
\*-------------------------------------------------*/
|
||||
for(unsigned int zone_idx = 0; zone_idx < zones.size(); zone_idx++)
|
||||
{
|
||||
for(unsigned int led_idx = 0; led_idx < zones[zone_idx].leds_count; led_idx++)
|
||||
{
|
||||
led new_led;
|
||||
new_led.name = zone_names[zone_idx];
|
||||
new_led.name.append(", LED ");
|
||||
new_led.name.append(std::to_string(led_idx + 1));
|
||||
new_led.value = zone_idx;
|
||||
|
||||
leds.push_back(new_led);
|
||||
}
|
||||
}
|
||||
|
||||
SetupColors();
|
||||
}
|
||||
|
||||
void RGBController_CryorigH7QuadLumi::ResizeZone(int /*zone*/, int /*new_size*/)
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
void RGBController_CryorigH7QuadLumi::DeviceUpdateLEDs()
|
||||
{
|
||||
for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
|
||||
{
|
||||
controller->SetChannelLEDs(zone_idx, zones[zone_idx].colors, zones[zone_idx].leds_count);
|
||||
}
|
||||
}
|
||||
|
||||
void RGBController_CryorigH7QuadLumi::UpdateZoneLEDs(int zone)
|
||||
{
|
||||
controller->SetChannelLEDs(zone, zones[zone].colors, zones[zone].leds_count);
|
||||
}
|
||||
|
||||
void RGBController_CryorigH7QuadLumi::UpdateSingleLED(int led)
|
||||
{
|
||||
unsigned int zone_idx = leds[led].value;
|
||||
|
||||
controller->SetChannelLEDs(zone_idx, zones[zone_idx].colors, zones[zone_idx].leds_count);
|
||||
}
|
||||
|
||||
void RGBController_CryorigH7QuadLumi::SetCustomMode()
|
||||
{
|
||||
active_mode = 0;
|
||||
}
|
||||
|
||||
void RGBController_CryorigH7QuadLumi::DeviceUpdateMode()
|
||||
{
|
||||
if(modes[active_mode].value == CRYORIG_H7_QUAD_LUMI_MODE_FIXED)
|
||||
{
|
||||
DeviceUpdateLEDs();
|
||||
}
|
||||
else
|
||||
{
|
||||
for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
|
||||
{
|
||||
RGBColor* colors = NULL;
|
||||
bool direction = false;
|
||||
|
||||
if(modes[active_mode].direction == MODE_DIRECTION_LEFT)
|
||||
{
|
||||
direction = true;
|
||||
}
|
||||
|
||||
if(modes[active_mode].colors.size() > 0)
|
||||
{
|
||||
colors = &modes[active_mode].colors[0];
|
||||
}
|
||||
|
||||
controller->SetChannelEffect
|
||||
(
|
||||
zone_idx,
|
||||
modes[active_mode].value,
|
||||
modes[active_mode].speed,
|
||||
direction,
|
||||
colors,
|
||||
modes[active_mode].colors.size()
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,35 +0,0 @@
|
||||
/*-----------------------------------------*\
|
||||
| RGBController_CryorigH7QuadLumi.h |
|
||||
| |
|
||||
| Generic RGB Interface for Cryorig H7 |
|
||||
| Quad Lumi |
|
||||
| |
|
||||
| Adam Honse (CalcProgrammer1) 4/15/2023 |
|
||||
\*-----------------------------------------*/
|
||||
|
||||
#pragma once
|
||||
#include "RGBController.h"
|
||||
#include "CryorigH7QuadLumiController.h"
|
||||
|
||||
class RGBController_CryorigH7QuadLumi : public RGBController
|
||||
{
|
||||
public:
|
||||
RGBController_CryorigH7QuadLumi(CryorigH7QuadLumiController* controller_ptr);
|
||||
~RGBController_CryorigH7QuadLumi();
|
||||
|
||||
void SetupZones();
|
||||
|
||||
void ResizeZone(int zone, int new_size);
|
||||
|
||||
void DeviceUpdateLEDs();
|
||||
void UpdateZoneLEDs(int zone);
|
||||
void UpdateSingleLED(int led);
|
||||
|
||||
void SetCustomMode();
|
||||
void DeviceUpdateMode();
|
||||
|
||||
private:
|
||||
CryorigH7QuadLumiController* controller;
|
||||
std::vector<unsigned int> leds_channel;
|
||||
std::vector<unsigned int> zones_channel;
|
||||
};
|
||||
@@ -1,142 +0,0 @@
|
||||
#include "Detector.h"
|
||||
#include "RGBController.h"
|
||||
#include "RGBController_DMX.h"
|
||||
#include "SettingsManager.h"
|
||||
#include <vector>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
#include <fcntl.h>
|
||||
#include <string.h>
|
||||
#include <fstream>
|
||||
#include <iostream>
|
||||
#include <string>
|
||||
|
||||
/******************************************************************************************\
|
||||
* *
|
||||
* DetectDMXControllers *
|
||||
* *
|
||||
* Detect devices supported by the DMX driver *
|
||||
* *
|
||||
\******************************************************************************************/
|
||||
|
||||
void DetectDMXControllers()
|
||||
{
|
||||
json dmx_settings;
|
||||
|
||||
std::vector<std::vector<DMXDevice>> device_lists;
|
||||
DMXDevice dev;
|
||||
|
||||
/*-------------------------------------------------*\
|
||||
| Get DMX settings from settings manager |
|
||||
\*-------------------------------------------------*/
|
||||
dmx_settings = ResourceManager::get()->GetSettingsManager()->GetSettings("DMXDevices");
|
||||
|
||||
/*-------------------------------------------------*\
|
||||
| If the DMX settings contains devices, process |
|
||||
\*-------------------------------------------------*/
|
||||
if(dmx_settings.contains("devices"))
|
||||
{
|
||||
for(unsigned int device_idx = 0; device_idx < dmx_settings["devices"].size(); device_idx++)
|
||||
{
|
||||
/*-------------------------------------------------*\
|
||||
| Clear DMX device data |
|
||||
\*-------------------------------------------------*/
|
||||
dev.name = "";
|
||||
dev.keepalive_time = 0;
|
||||
|
||||
if(dmx_settings["devices"][device_idx].contains("name"))
|
||||
{
|
||||
dev.name = dmx_settings["devices"][device_idx]["name"];
|
||||
}
|
||||
|
||||
if(dmx_settings["devices"][device_idx].contains("port"))
|
||||
{
|
||||
dev.port = dmx_settings["devices"][device_idx]["port"];
|
||||
}
|
||||
|
||||
if(dmx_settings["devices"][device_idx].contains("keepalive_time"))
|
||||
{
|
||||
dev.keepalive_time = dmx_settings["devices"][device_idx]["keepalive_time"];
|
||||
}
|
||||
|
||||
if(dmx_settings["devices"][device_idx].contains("red_channel"))
|
||||
{
|
||||
dev.red_channel = dmx_settings["devices"][device_idx]["red_channel"];
|
||||
}
|
||||
|
||||
if(dmx_settings["devices"][device_idx].contains("green_channel"))
|
||||
{
|
||||
dev.green_channel = dmx_settings["devices"][device_idx]["green_channel"];
|
||||
}
|
||||
|
||||
if(dmx_settings["devices"][device_idx].contains("blue_channel"))
|
||||
{
|
||||
dev.blue_channel = dmx_settings["devices"][device_idx]["blue_channel"];
|
||||
}
|
||||
|
||||
if(dmx_settings["devices"][device_idx].contains("brightness_channel"))
|
||||
{
|
||||
dev.brightness_channel = dmx_settings["devices"][device_idx]["brightness_channel"];
|
||||
}
|
||||
|
||||
/*---------------------------------------------------------*\
|
||||
| Determine whether to create a new list or add this device |
|
||||
| to an existing list. A device is added to an existing |
|
||||
| list if both devices share one or more universes for the |
|
||||
| same output destination |
|
||||
\*---------------------------------------------------------*/
|
||||
bool device_added_to_existing_list = false;
|
||||
|
||||
/*---------------------------------------------------------*\
|
||||
| Track grouping for all controllers. |
|
||||
\*---------------------------------------------------------*/
|
||||
for(unsigned int list_idx = 0; list_idx < device_lists.size(); list_idx++)
|
||||
{
|
||||
for(unsigned int device_idx = 0; device_idx < device_lists[list_idx].size(); device_idx++)
|
||||
{
|
||||
/*---------------------------------------------------------*\
|
||||
| Check if the port used by this new device is the same as |
|
||||
| in the existing device. If so, add the new device to the |
|
||||
| existing list. |
|
||||
\*---------------------------------------------------------*/
|
||||
if(1)
|
||||
{
|
||||
device_lists[list_idx].push_back(dev);
|
||||
device_added_to_existing_list = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if(device_added_to_existing_list)
|
||||
{
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
/*---------------------------------------------------------*\
|
||||
| If the device did not overlap with existing devices, |
|
||||
| create a new list for it |
|
||||
\*---------------------------------------------------------*/
|
||||
if(!device_added_to_existing_list)
|
||||
{
|
||||
std::vector<DMXDevice> new_list;
|
||||
|
||||
new_list.push_back(dev);
|
||||
|
||||
device_lists.push_back(new_list);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
for(unsigned int list_idx = 0; list_idx < device_lists.size(); list_idx++)
|
||||
{
|
||||
RGBController_DMX* rgb_controller;
|
||||
rgb_controller = new RGBController_DMX(device_lists[list_idx]);
|
||||
ResourceManager::get()->RegisterRGBController(rgb_controller);
|
||||
}
|
||||
}
|
||||
|
||||
} /* DetectDMXControllers() */
|
||||
|
||||
REGISTER_DETECTOR("DMX", DetectDMXControllers);
|
||||
@@ -1,231 +0,0 @@
|
||||
/*-----------------------------------------*\
|
||||
| RGBController_DMX.cpp |
|
||||
| |
|
||||
| Generic RGB Interface for OpenAuraSDK |
|
||||
| DMX interface |
|
||||
| |
|
||||
| Adam Honse (CalcProgrammer1) 4/30/2023 |
|
||||
\*-----------------------------------------*/
|
||||
|
||||
#include "RGBController_DMX.h"
|
||||
#include <math.h>
|
||||
|
||||
#include "LogManager.h"
|
||||
|
||||
using namespace std::chrono_literals;
|
||||
|
||||
/**------------------------------------------------------------------*\
|
||||
@name DMX Devices
|
||||
@category LEDStrip
|
||||
@type Serial
|
||||
@save :x:
|
||||
@direct :white_check_mark:
|
||||
@effects :x:
|
||||
@detectors DetectDMXControllers
|
||||
@comment
|
||||
\*-------------------------------------------------------------------*/
|
||||
|
||||
RGBController_DMX::RGBController_DMX(std::vector<DMXDevice> device_list)
|
||||
{
|
||||
devices = device_list;
|
||||
|
||||
name = "DMX Device Group";
|
||||
type = DEVICE_TYPE_LEDSTRIP;
|
||||
description = "DMX Device";
|
||||
location = "DMX: " + devices[0].port;
|
||||
|
||||
/*-----------------------------------------*\
|
||||
| If this controller only represents a |
|
||||
| single device, use the device name for the|
|
||||
| controller name |
|
||||
\*-----------------------------------------*/
|
||||
if(devices.size() == 1)
|
||||
{
|
||||
name = devices[0].name;
|
||||
}
|
||||
|
||||
/*-----------------------------------------*\
|
||||
| Open OpenDMX port |
|
||||
\*-----------------------------------------*/
|
||||
port = new serial_port(devices[0].port.c_str(), 250000, SERIAL_PORT_PARITY_NONE, SERIAL_PORT_SIZE_8, SERIAL_PORT_STOP_BITS_2, false);
|
||||
|
||||
/*-----------------------------------------*\
|
||||
| Clear the RTS signal, which enables the |
|
||||
| OpenDMX RS-485 drive enable |
|
||||
\*-----------------------------------------*/
|
||||
port->serial_set_rts(false);
|
||||
|
||||
/*-----------------------------------------*\
|
||||
| Set up modes |
|
||||
\*-----------------------------------------*/
|
||||
mode Direct;
|
||||
Direct.name = "Direct";
|
||||
Direct.value = 0;
|
||||
Direct.flags = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
|
||||
Direct.color_mode = MODE_COLORS_PER_LED;
|
||||
Direct.brightness = 255;
|
||||
Direct.brightness_min = 0;
|
||||
Direct.brightness_max = 255;
|
||||
modes.push_back(Direct);
|
||||
|
||||
keepalive_delay = 0ms;
|
||||
|
||||
SetupZones();
|
||||
|
||||
for (std::size_t device_idx = 0; device_idx < devices.size(); device_idx++)
|
||||
{
|
||||
/*-----------------------------------------*\
|
||||
| Update keepalive delay |
|
||||
\*-----------------------------------------*/
|
||||
if(devices[device_idx].keepalive_time > 0)
|
||||
{
|
||||
if(keepalive_delay.count() == 0 || keepalive_delay.count() > devices[device_idx].keepalive_time)
|
||||
{
|
||||
keepalive_delay = std::chrono::milliseconds(devices[device_idx].keepalive_time);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if(keepalive_delay.count() > 0)
|
||||
{
|
||||
keepalive_thread_run = 1;
|
||||
keepalive_thread = new std::thread(&RGBController_DMX::KeepaliveThreadFunction, this);
|
||||
}
|
||||
else
|
||||
{
|
||||
keepalive_thread_run = 0;
|
||||
keepalive_thread = nullptr;
|
||||
}
|
||||
}
|
||||
|
||||
RGBController_DMX::~RGBController_DMX()
|
||||
{
|
||||
if(keepalive_thread != nullptr)
|
||||
{
|
||||
keepalive_thread_run = 0;
|
||||
keepalive_thread->join();
|
||||
delete keepalive_thread;
|
||||
}
|
||||
|
||||
/*---------------------------------------------------------*\
|
||||
| Delete the matrix map |
|
||||
\*---------------------------------------------------------*/
|
||||
for(unsigned int zone_index = 0; zone_index < zones.size(); zone_index++)
|
||||
{
|
||||
if(zones[zone_index].matrix_map != NULL)
|
||||
{
|
||||
if(zones[zone_index].matrix_map->map != NULL)
|
||||
{
|
||||
delete zones[zone_index].matrix_map->map;
|
||||
}
|
||||
|
||||
delete zones[zone_index].matrix_map;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void RGBController_DMX::SetupZones()
|
||||
{
|
||||
/*-----------------------------------------*\
|
||||
| Add Zones |
|
||||
\*-----------------------------------------*/
|
||||
for(std::size_t zone_idx = 0; zone_idx < devices.size(); zone_idx++)
|
||||
{
|
||||
zone led_zone;
|
||||
led_zone.name = devices[zone_idx].name;
|
||||
led_zone.type = ZONE_TYPE_SINGLE;
|
||||
led_zone.leds_min = 1;
|
||||
led_zone.leds_max = 1;
|
||||
led_zone.leds_count = 1;
|
||||
led_zone.matrix_map = NULL;
|
||||
|
||||
zones.push_back(led_zone);
|
||||
}
|
||||
|
||||
/*-----------------------------------------*\
|
||||
| Add LEDs |
|
||||
\*-----------------------------------------*/
|
||||
for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
|
||||
{
|
||||
for(std::size_t led_idx = 0; led_idx < zones[zone_idx].leds_count; led_idx++)
|
||||
{
|
||||
led new_led;
|
||||
|
||||
new_led.name = zones[zone_idx].name + " LED ";
|
||||
new_led.name.append(std::to_string(led_idx));
|
||||
|
||||
leds.push_back(new_led);
|
||||
}
|
||||
}
|
||||
|
||||
SetupColors();
|
||||
}
|
||||
|
||||
void RGBController_DMX::ResizeZone(int /*zone*/, int /*new_size*/)
|
||||
{
|
||||
/*---------------------------------------------------------*\
|
||||
| This device does not support resizing zones |
|
||||
\*---------------------------------------------------------*/
|
||||
}
|
||||
|
||||
void RGBController_DMX::DeviceUpdateLEDs()
|
||||
{
|
||||
last_update_time = std::chrono::steady_clock::now();
|
||||
|
||||
unsigned char dmx_data[513];
|
||||
|
||||
memset(dmx_data, 0, sizeof(dmx_data));
|
||||
|
||||
for(unsigned int device_idx = 0; device_idx < devices.size(); device_idx++)
|
||||
{
|
||||
if(devices[device_idx].brightness_channel > 0)
|
||||
{
|
||||
dmx_data[devices[device_idx].brightness_channel] = modes[0].brightness;
|
||||
}
|
||||
|
||||
if(devices[device_idx].red_channel > 0)
|
||||
{
|
||||
dmx_data[devices[device_idx].red_channel] = RGBGetRValue(colors[device_idx]);
|
||||
}
|
||||
|
||||
if(devices[device_idx].green_channel > 0)
|
||||
{
|
||||
dmx_data[devices[device_idx].green_channel] = RGBGetGValue(colors[device_idx]);
|
||||
}
|
||||
|
||||
if(devices[device_idx].blue_channel > 0)
|
||||
{
|
||||
dmx_data[devices[device_idx].blue_channel] = RGBGetBValue(colors[device_idx]);
|
||||
}
|
||||
}
|
||||
|
||||
port->serial_break();
|
||||
port->serial_write((char*)&dmx_data, sizeof(dmx_data));
|
||||
}
|
||||
|
||||
void RGBController_DMX::UpdateZoneLEDs(int /*zone*/)
|
||||
{
|
||||
DeviceUpdateLEDs();
|
||||
}
|
||||
|
||||
void RGBController_DMX::UpdateSingleLED(int /*led*/)
|
||||
{
|
||||
DeviceUpdateLEDs();
|
||||
}
|
||||
|
||||
void RGBController_DMX::DeviceUpdateMode()
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
void RGBController_DMX::KeepaliveThreadFunction()
|
||||
{
|
||||
while(keepalive_thread_run.load())
|
||||
{
|
||||
if((std::chrono::steady_clock::now() - last_update_time) > ( keepalive_delay * 0.95f ) )
|
||||
{
|
||||
UpdateLEDs();
|
||||
}
|
||||
std::this_thread::sleep_for(keepalive_delay / 2);
|
||||
}
|
||||
}
|
||||
@@ -1,52 +0,0 @@
|
||||
/*-----------------------------------------*\
|
||||
| RGBController_DMX.h |
|
||||
| |
|
||||
| Generic RGB Interface for OpenAuraSDK |
|
||||
| DMX interface |
|
||||
| |
|
||||
| Adam Honse (CalcProgrammer1) 4/30/2023 |
|
||||
\*-----------------------------------------*/
|
||||
|
||||
#pragma once
|
||||
#include "RGBController.h"
|
||||
#include "serial_port.h"
|
||||
#include <chrono>
|
||||
#include <thread>
|
||||
|
||||
struct DMXDevice
|
||||
{
|
||||
std::string name;
|
||||
std::string port;
|
||||
unsigned int keepalive_time;
|
||||
unsigned int red_channel;
|
||||
unsigned int green_channel;
|
||||
unsigned int blue_channel;
|
||||
unsigned int brightness_channel;
|
||||
};
|
||||
|
||||
class RGBController_DMX : public RGBController
|
||||
{
|
||||
public:
|
||||
RGBController_DMX(std::vector<DMXDevice> device_list);
|
||||
~RGBController_DMX();
|
||||
|
||||
void SetupZones();
|
||||
|
||||
void ResizeZone(int zone, int new_size);
|
||||
|
||||
void DeviceUpdateLEDs();
|
||||
void UpdateZoneLEDs(int zone);
|
||||
void UpdateSingleLED(int led);
|
||||
|
||||
void DeviceUpdateMode();
|
||||
|
||||
void KeepaliveThreadFunction();
|
||||
|
||||
private:
|
||||
std::vector<DMXDevice> devices;
|
||||
serial_port * port;
|
||||
std::thread * keepalive_thread;
|
||||
std::atomic<bool> keepalive_thread_run;
|
||||
std::chrono::milliseconds keepalive_delay;
|
||||
std::chrono::time_point<std::chrono::steady_clock> last_update_time;
|
||||
};
|
||||
@@ -3,7 +3,6 @@
|
||||
#include "RGBController_Debug.h"
|
||||
#include "RGBController_Dummy.h"
|
||||
#include "RGBControllerKeyNames.h"
|
||||
#include "KeyboardLayoutManager.h"
|
||||
#include "SettingsManager.h"
|
||||
#include <vector>
|
||||
#include <stdio.h>
|
||||
@@ -19,11 +18,181 @@
|
||||
//0xFFFFFFFF indicates an unused entry in matrix
|
||||
#define NA 0xFFFFFFFF
|
||||
|
||||
static unsigned int debug_keyboard_matrix_map[6][23] =
|
||||
{ { 0, NA, 16, 30, 44, 54, NA, 65, 75, 84, 95, NA, 8, 23, 38, 6, 22, 36, 49, NA, NA, NA, NA },
|
||||
{ 1, 17, 31, 45, 55, 66, 76, 85, 96, 9, 24, NA, 39, 7, 37, NA, 60, 70, 80, 52, 63, 73, 82 },
|
||||
{ 2, NA, 18, 32, 46, 56, NA, 67, 77, 86, 97, 10, 25, 40, 90, 101, 50, 61, 71, 51, 62, 72, 93 },
|
||||
{ 3, NA, 19, 33, 47, 57, NA, 68, 78, 87, 98, 11, 26, 41, 28, 14, NA, NA, NA, 92, 103, 53, NA },
|
||||
{ 4, 20, 34, 48, 58, 69, NA, 79, NA, 88, 99, 12, 27, 42, 81, NA, NA, 102, NA, 64, 74, 83, 104 },
|
||||
{ 5, 21, 35, NA, NA, NA, NA, 59, NA, NA, NA, NA, 89, 100, 13, 91, 15, 29, 43, 94, NA, 105, NA } };
|
||||
|
||||
static unsigned int dummy_keyboard_underglow_map[3][10] =
|
||||
{ { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 },
|
||||
{ 10, 11, 12, 13, 14, 15, 16, 17, 18, 19 },
|
||||
{ 20, 21, 22, 23, 24, 25, 26, 27, 28, 29 } };
|
||||
|
||||
static const char *led_names[] =
|
||||
{
|
||||
KEY_EN_ESCAPE,
|
||||
KEY_EN_BACK_TICK,
|
||||
KEY_EN_TAB,
|
||||
KEY_EN_CAPS_LOCK,
|
||||
KEY_EN_LEFT_SHIFT,
|
||||
KEY_EN_LEFT_CONTROL,
|
||||
KEY_EN_F12,
|
||||
KEY_EN_EQUALS,
|
||||
KEY_EN_F9,
|
||||
KEY_EN_9,
|
||||
KEY_EN_O,
|
||||
KEY_EN_L,
|
||||
KEY_EN_COMMA,
|
||||
KEY_EN_MENU,
|
||||
KEY_EN_ISO_ENTER,
|
||||
KEY_EN_LEFT_ARROW,
|
||||
KEY_EN_F1,
|
||||
KEY_EN_1,
|
||||
KEY_EN_Q,
|
||||
KEY_EN_A,
|
||||
KEY_EN_ISO_BACK_SLASH,
|
||||
KEY_EN_LEFT_WINDOWS,
|
||||
KEY_EN_PRINT_SCREEN,
|
||||
KEY_EN_F10,
|
||||
KEY_EN_0,
|
||||
KEY_EN_P,
|
||||
KEY_EN_SEMICOLON,
|
||||
KEY_EN_PERIOD,
|
||||
KEY_EN_ANSI_ENTER,
|
||||
KEY_EN_DOWN_ARROW,
|
||||
KEY_EN_F2,
|
||||
KEY_EN_2,
|
||||
KEY_EN_W,
|
||||
KEY_EN_S,
|
||||
KEY_EN_Z,
|
||||
KEY_EN_LEFT_ALT,
|
||||
KEY_EN_SCROLL_LOCK,
|
||||
KEY_EN_BACKSPACE,
|
||||
KEY_EN_F11,
|
||||
KEY_EN_MINUS,
|
||||
KEY_EN_LEFT_BRACKET,
|
||||
KEY_EN_QUOTE,
|
||||
KEY_EN_FORWARD_SLASH,
|
||||
KEY_EN_RIGHT_ARROW,
|
||||
KEY_EN_F3,
|
||||
KEY_EN_3,
|
||||
KEY_EN_E,
|
||||
KEY_EN_D,
|
||||
KEY_EN_X,
|
||||
KEY_EN_PAUSE_BREAK,
|
||||
KEY_EN_DELETE,
|
||||
KEY_EN_NUMPAD_7,
|
||||
KEY_EN_NUMPAD_LOCK,
|
||||
KEY_EN_NUMPAD_6,
|
||||
KEY_EN_F4,
|
||||
KEY_EN_4,
|
||||
KEY_EN_R,
|
||||
KEY_EN_F,
|
||||
KEY_EN_C,
|
||||
KEY_EN_SPACE,
|
||||
KEY_EN_INSERT,
|
||||
KEY_EN_END,
|
||||
KEY_EN_NUMPAD_8,
|
||||
KEY_EN_NUMPAD_DIVIDE,
|
||||
KEY_EN_NUMPAD_1,
|
||||
KEY_EN_F5,
|
||||
KEY_EN_5,
|
||||
KEY_EN_T,
|
||||
KEY_EN_G,
|
||||
KEY_EN_V,
|
||||
KEY_EN_HOME,
|
||||
KEY_EN_PAGE_DOWN,
|
||||
KEY_EN_NUMPAD_9,
|
||||
KEY_EN_NUMPAD_TIMES,
|
||||
KEY_EN_NUMPAD_2,
|
||||
KEY_EN_F6,
|
||||
KEY_EN_6,
|
||||
KEY_EN_Y,
|
||||
KEY_EN_H,
|
||||
KEY_EN_B,
|
||||
KEY_EN_PAGE_UP,
|
||||
KEY_EN_RIGHT_SHIFT,
|
||||
KEY_EN_NUMPAD_MINUS,
|
||||
KEY_EN_NUMPAD_3,
|
||||
KEY_EN_F7,
|
||||
KEY_EN_7,
|
||||
KEY_EN_U,
|
||||
KEY_EN_J,
|
||||
KEY_EN_N,
|
||||
KEY_EN_RIGHT_ALT,
|
||||
KEY_EN_RIGHT_BRACKET,
|
||||
KEY_EN_RIGHT_CONTROL,
|
||||
KEY_EN_NUMPAD_4,
|
||||
KEY_EN_NUMPAD_PLUS,
|
||||
KEY_EN_NUMPAD_0,
|
||||
KEY_EN_F8,
|
||||
KEY_EN_8,
|
||||
KEY_EN_I,
|
||||
KEY_EN_K,
|
||||
KEY_EN_M,
|
||||
KEY_EN_RIGHT_WINDOWS,
|
||||
KEY_EN_ANSI_BACK_SLASH,
|
||||
KEY_EN_UP_ARROW,
|
||||
KEY_EN_NUMPAD_5,
|
||||
KEY_EN_NUMPAD_ENTER,
|
||||
KEY_EN_NUMPAD_PERIOD,
|
||||
"RGB Strip 1",
|
||||
"RGB Strip 2",
|
||||
"RGB Strip 3",
|
||||
"RGB Strip 4",
|
||||
"RGB Strip 5",
|
||||
"RGB Strip 6",
|
||||
"RGB Strip 7",
|
||||
"RGB Strip 8",
|
||||
"RGB Strip 9",
|
||||
"RGB Strip 10",
|
||||
"RGB Strip 11",
|
||||
"RGB Strip 12",
|
||||
"RGB Strip 13",
|
||||
"RGB Strip 14",
|
||||
"RGB Strip 15",
|
||||
"RGB Strip 16",
|
||||
"RGB Strip 17",
|
||||
"RGB Strip 18",
|
||||
KEY_EN_MEDIA_PREVIOUS,
|
||||
KEY_EN_MEDIA_PLAY_PAUSE,
|
||||
KEY_EN_MEDIA_NEXT,
|
||||
KEY_EN_MEDIA_MUTE,
|
||||
"Underglow LED 1",
|
||||
"Underglow LED 2",
|
||||
"Underglow LED 3",
|
||||
"Underglow LED 4",
|
||||
"Underglow LED 5",
|
||||
"Underglow LED 6",
|
||||
"Underglow LED 7",
|
||||
"Underglow LED 8",
|
||||
"Underglow LED 9",
|
||||
"Underglow LED 10",
|
||||
"Underglow LED 11",
|
||||
"Underglow LED 12",
|
||||
"Underglow LED 13",
|
||||
"Underglow LED 14",
|
||||
"Underglow LED 15",
|
||||
"Underglow LED 16",
|
||||
"Underglow LED 17",
|
||||
"Underglow LED 18",
|
||||
"Underglow LED 19",
|
||||
"Underglow LED 20",
|
||||
"Underglow LED 21",
|
||||
"Underglow LED 22",
|
||||
"Underglow LED 23",
|
||||
"Underglow LED 24",
|
||||
"Underglow LED 25",
|
||||
"Underglow LED 26",
|
||||
"Underglow LED 27",
|
||||
"Underglow LED 28",
|
||||
"Underglow LED 29",
|
||||
"Underglow LED 30"
|
||||
};
|
||||
|
||||
/******************************************************************************************\
|
||||
* *
|
||||
* DetectDebugControllers *
|
||||
@@ -285,72 +454,14 @@ void DetectDebugControllers()
|
||||
}
|
||||
else if(type == "keyboard")
|
||||
{
|
||||
json json_kbd = debug_settings["devices"][device_idx];
|
||||
KEYBOARD_LAYOUT layout = KEYBOARD_LAYOUT::KEYBOARD_LAYOUT_ANSI_QWERTY;
|
||||
KEYBOARD_SIZE size = KEYBOARD_SIZE::KEYBOARD_SIZE_FULL;
|
||||
|
||||
if(json_kbd.contains("layout"))
|
||||
{
|
||||
layout = json_kbd["layout"];
|
||||
}
|
||||
|
||||
if(json_kbd.contains("size"))
|
||||
{
|
||||
size = json_kbd["size"];
|
||||
}
|
||||
|
||||
/*---------------------------------------------------------*\
|
||||
| Create a dummy Keyboard |
|
||||
\*---------------------------------------------------------*/
|
||||
RGBController_Dummy* dummy_keyboard = new RGBController_Dummy();
|
||||
KeyboardLayoutManager new_kb(layout, size);
|
||||
|
||||
/*---------------------------------------------------------*\
|
||||
| Check for custom key inserts and swaps |
|
||||
\*---------------------------------------------------------*/
|
||||
std::vector<keyboard_led> change;
|
||||
|
||||
if(json_kbd.contains("insert"))
|
||||
{
|
||||
|
||||
for(size_t i = 0; i < json_kbd["insert"].size(); i++)
|
||||
{
|
||||
keyboard_led* key = new keyboard_led;
|
||||
|
||||
key->zone = json_kbd["insert"][i]["Zone"];
|
||||
key->row = json_kbd["insert"][i]["Row"];
|
||||
key->col = json_kbd["insert"][i]["Col"];
|
||||
key->value = json_kbd["insert"][i]["Val"];
|
||||
key->name = json_kbd["insert"][i]["Name"].get_ref<const std::string&>().c_str();
|
||||
key->opcode = KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT;
|
||||
|
||||
change.push_back(*key);
|
||||
}
|
||||
}
|
||||
|
||||
if(json_kbd.contains("swap"))
|
||||
{
|
||||
for(size_t i = 0; i < json_kbd["swap"].size(); i++)
|
||||
{
|
||||
keyboard_led* key = new keyboard_led;
|
||||
|
||||
key->zone = json_kbd["swap"][i]["Zone"];
|
||||
key->row = json_kbd["swap"][i]["Row"];
|
||||
key->col = json_kbd["swap"][i]["Col"];
|
||||
key->value = json_kbd["swap"][i]["Val"];
|
||||
key->name = json_kbd["swap"][i]["Name"].get_ref<const std::string&>().c_str();
|
||||
key->opcode = KEYBOARD_OPCODE_SWAP_ONLY;
|
||||
|
||||
change.push_back(*key);
|
||||
}
|
||||
}
|
||||
|
||||
new_kb.ChangeKeys(change);
|
||||
|
||||
dummy_keyboard->name = new_kb.GetName();
|
||||
dummy_keyboard->name = "Debug Keyboard";
|
||||
dummy_keyboard->type = DEVICE_TYPE_KEYBOARD;
|
||||
dummy_keyboard->description = dummy_keyboard->name;
|
||||
dummy_keyboard->description.append(" Debug Keyboard");
|
||||
dummy_keyboard->description = "Debug Keyboard Device";
|
||||
dummy_keyboard->location = "Debug Keyboard Location";
|
||||
dummy_keyboard->version = "Debug Keyboard Version";
|
||||
dummy_keyboard->serial = "Debug Keyboard Serial";
|
||||
@@ -374,88 +485,52 @@ void DetectDebugControllers()
|
||||
|
||||
dummy_keyboard_matrix_zone.name = "Keyboard Matrix Zone";
|
||||
dummy_keyboard_matrix_zone.type = ZONE_TYPE_MATRIX;
|
||||
dummy_keyboard_matrix_zone.leds_min = new_kb.GetKeyCount();
|
||||
dummy_keyboard_matrix_zone.leds_max = new_kb.GetKeyCount();
|
||||
dummy_keyboard_matrix_zone.leds_count = new_kb.GetKeyCount();
|
||||
dummy_keyboard_matrix_zone.leds_min = 106;
|
||||
dummy_keyboard_matrix_zone.leds_max = 106;
|
||||
dummy_keyboard_matrix_zone.leds_count = 106;
|
||||
dummy_keyboard_matrix_zone.matrix_map = new matrix_map_type;
|
||||
dummy_keyboard_matrix_zone.matrix_map->height = new_kb.GetRowCount();
|
||||
dummy_keyboard_matrix_zone.matrix_map->width = new_kb.GetColumnCount();
|
||||
dummy_keyboard_matrix_zone.matrix_map->map = new unsigned int[dummy_keyboard_matrix_zone.matrix_map->height
|
||||
* dummy_keyboard_matrix_zone.matrix_map->width];
|
||||
new_kb.GetKeyMap(dummy_keyboard_matrix_zone.matrix_map->map, KEYBOARD_MAP_FILL_TYPE_COUNT);
|
||||
dummy_keyboard_matrix_zone.matrix_map->height = 6;
|
||||
dummy_keyboard_matrix_zone.matrix_map->width = 23;
|
||||
dummy_keyboard_matrix_zone.matrix_map->map = (unsigned int*)&debug_keyboard_matrix_map;
|
||||
|
||||
dummy_keyboard->zones.push_back(dummy_keyboard_matrix_zone);
|
||||
|
||||
for(std::size_t led_idx = 0; led_idx < dummy_keyboard_matrix_zone.leds_count; led_idx++)
|
||||
{
|
||||
led dummy_keyboard_led;
|
||||
dummy_keyboard_led.name = new_kb.GetKeyNameAt(led_idx);
|
||||
dummy_keyboard->leds.push_back(dummy_keyboard_led);
|
||||
}
|
||||
|
||||
/*-----------------------------------------------------------------*\
|
||||
| Add another matrix zone so that is can resemble a huntsman elite |
|
||||
\*-----------------------------------------------------------------*/
|
||||
bool underglow = true;
|
||||
if(json_kbd.contains("underglow"))
|
||||
{
|
||||
underglow = json_kbd["underglow"];
|
||||
}
|
||||
zone dummy_keyboard_underglow_matrix_zone;
|
||||
|
||||
if(underglow)
|
||||
{
|
||||
zone dummy_keyboard_underglow_matrix_zone;
|
||||
dummy_keyboard_underglow_matrix_zone.name = "Underglow";
|
||||
dummy_keyboard_underglow_matrix_zone.type = ZONE_TYPE_MATRIX;
|
||||
dummy_keyboard_underglow_matrix_zone.leds_min = 30;
|
||||
dummy_keyboard_underglow_matrix_zone.leds_max = 30;
|
||||
dummy_keyboard_underglow_matrix_zone.leds_count = 30;
|
||||
dummy_keyboard_underglow_matrix_zone.matrix_map = new matrix_map_type;
|
||||
dummy_keyboard_underglow_matrix_zone.matrix_map->height = 3;
|
||||
dummy_keyboard_underglow_matrix_zone.matrix_map->width = 10;
|
||||
dummy_keyboard_underglow_matrix_zone.matrix_map->map = (unsigned int*)&dummy_keyboard_underglow_map;
|
||||
|
||||
dummy_keyboard_underglow_matrix_zone.name = "Underglow";
|
||||
dummy_keyboard_underglow_matrix_zone.type = ZONE_TYPE_MATRIX;
|
||||
dummy_keyboard_underglow_matrix_zone.leds_min = 30;
|
||||
dummy_keyboard_underglow_matrix_zone.leds_max = 30;
|
||||
dummy_keyboard_underglow_matrix_zone.leds_count = 30;
|
||||
dummy_keyboard_underglow_matrix_zone.matrix_map = new matrix_map_type;
|
||||
dummy_keyboard_underglow_matrix_zone.matrix_map->height = 3;
|
||||
dummy_keyboard_underglow_matrix_zone.matrix_map->width = 10;
|
||||
dummy_keyboard_underglow_matrix_zone.matrix_map->map = (unsigned int*)&dummy_keyboard_underglow_map;
|
||||
|
||||
dummy_keyboard->zones.push_back(dummy_keyboard_underglow_matrix_zone);
|
||||
|
||||
for(std::size_t led_idx = 0; led_idx < dummy_keyboard_underglow_matrix_zone.leds_count; led_idx++)
|
||||
{
|
||||
led dummy_keyboard_led;
|
||||
dummy_keyboard_led.name = dummy_keyboard_underglow_matrix_zone.name + " LED ";
|
||||
dummy_keyboard_led.name.append(std::to_string(led_idx));
|
||||
dummy_keyboard->leds.push_back(dummy_keyboard_led);
|
||||
}
|
||||
}
|
||||
dummy_keyboard->zones.push_back(dummy_keyboard_underglow_matrix_zone);
|
||||
|
||||
/*---------------------------------------------------------*\
|
||||
| Create a linear zone for the dummy Keyboard |
|
||||
| Create a linear zone for the dummy GPU |
|
||||
\*---------------------------------------------------------*/
|
||||
bool linear = true;
|
||||
if(json_kbd.contains("linear"))
|
||||
zone dummy_keyboard_linear_zone;
|
||||
|
||||
dummy_keyboard_linear_zone.name = "Linear Zone";
|
||||
dummy_keyboard_linear_zone.type = ZONE_TYPE_LINEAR;
|
||||
dummy_keyboard_linear_zone.leds_min = 18;
|
||||
dummy_keyboard_linear_zone.leds_max = 18;
|
||||
dummy_keyboard_linear_zone.leds_count = 18;
|
||||
dummy_keyboard_linear_zone.matrix_map = NULL;
|
||||
|
||||
dummy_keyboard->zones.push_back(dummy_keyboard_linear_zone);
|
||||
|
||||
for(std::size_t led_idx = 0; led_idx < 154; led_idx++)
|
||||
{
|
||||
linear = json_kbd["linear"];
|
||||
}
|
||||
|
||||
if(linear)
|
||||
{
|
||||
zone dummy_keyboard_linear_zone;
|
||||
|
||||
dummy_keyboard_linear_zone.name = "Linear Zone";
|
||||
dummy_keyboard_linear_zone.type = ZONE_TYPE_LINEAR;
|
||||
dummy_keyboard_linear_zone.leds_min = 18;
|
||||
dummy_keyboard_linear_zone.leds_max = 18;
|
||||
dummy_keyboard_linear_zone.leds_count = 18;
|
||||
dummy_keyboard_linear_zone.matrix_map = NULL;
|
||||
|
||||
dummy_keyboard->zones.push_back(dummy_keyboard_linear_zone);
|
||||
|
||||
for(std::size_t led_idx = 0; led_idx < dummy_keyboard_linear_zone.leds_count; led_idx++)
|
||||
{
|
||||
led dummy_keyboard_led;
|
||||
dummy_keyboard_led.name = "RGB Strip ";
|
||||
dummy_keyboard_led.name.append(std::to_string(led_idx));
|
||||
dummy_keyboard->leds.push_back(dummy_keyboard_led);
|
||||
}
|
||||
led dummy_keyboard_led;
|
||||
dummy_keyboard_led.name = led_names[led_idx];
|
||||
dummy_keyboard->leds.push_back(dummy_keyboard_led);
|
||||
}
|
||||
|
||||
dummy_keyboard->SetupColors();
|
||||
|
||||
@@ -31,9 +31,8 @@ static const char* ene_channels[] = /* ENE channel strings
|
||||
|
||||
ENESMBusController::ENESMBusController(ENESMBusInterface* interface, ene_dev_id dev)
|
||||
{
|
||||
this->interface = interface;
|
||||
this->dev = dev;
|
||||
supports_mode_14 = false;
|
||||
this->interface = interface;
|
||||
this->dev = dev;
|
||||
|
||||
UpdateDeviceName();
|
||||
|
||||
@@ -94,17 +93,6 @@ ENESMBusController::ENESMBusController(ENESMBusInterface* interface, ene_dev_id
|
||||
direct_reg = ENE_REG_COLORS_DIRECT_V2;
|
||||
effect_reg = ENE_REG_COLORS_EFFECT_V2;
|
||||
channel_cfg = ENE_CONFIG_CHANNEL_V1;
|
||||
|
||||
// Check for Mode 14 support, only known to exist on modules where the
|
||||
// DRAM 3 zone ID exists
|
||||
for(std::size_t cfg_zone_idx = 0; cfg_zone_idx < ENE_NUM_ZONES; cfg_zone_idx++)
|
||||
{
|
||||
if(config_table[channel_cfg + cfg_zone_idx] == (unsigned char)ENE_LED_CHANNEL_DRAM_3)
|
||||
{
|
||||
supports_mode_14 = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
// AUMA0-E6K5-0106 - Second generation motherboard controller
|
||||
else if (strcmp(device_name, "AUMA0-E6K5-0106") == 0)
|
||||
@@ -144,28 +132,6 @@ ENESMBusController::ENESMBusController(ENESMBusInterface* interface, ene_dev_id
|
||||
// Read LED count from configuration table
|
||||
led_count = config_table[ENE_CONFIG_LED_COUNT_0107];
|
||||
}
|
||||
// AUMA0-E6K5-1110 - Third generation GPU controller?
|
||||
// found an ASUS ROG Strix 4080 OC, seems to be equal to AUMA0-E6K5-0107
|
||||
else if (strcmp(device_name, "AUMA0-E6K5-1110") == 0)
|
||||
{
|
||||
direct_reg = ENE_REG_COLORS_DIRECT_V2;
|
||||
effect_reg = ENE_REG_COLORS_EFFECT_V2;
|
||||
channel_cfg = ENE_CONFIG_CHANNEL_V2;
|
||||
|
||||
// Read LED count from configuration table
|
||||
led_count = config_table[ENE_CONFIG_LED_COUNT_1110];
|
||||
}
|
||||
// AUMA0-E6K5-1107 - Second generation GPU controller
|
||||
// Found on ASUS TUF 4070 TI OC, seems to be equal to AUMA0-E6K5-0107
|
||||
else if (strcmp(device_name, "AUMA0-E6K5-1107") == 0)
|
||||
{
|
||||
direct_reg = ENE_REG_COLORS_DIRECT_V2;
|
||||
effect_reg = ENE_REG_COLORS_EFFECT_V2;
|
||||
channel_cfg = ENE_CONFIG_CHANNEL_V2;
|
||||
|
||||
// Read LED count from configuration table
|
||||
led_count = config_table[ENE_CONFIG_LED_COUNT_0107];
|
||||
}
|
||||
// Assume first generation controller if string does not match
|
||||
else
|
||||
{
|
||||
@@ -197,11 +163,14 @@ std::string ENESMBusController::GetDeviceLocation()
|
||||
return(return_string);
|
||||
}
|
||||
|
||||
const char * ENESMBusController::GetChannelName(unsigned int cfg_zone)
|
||||
unsigned char ENESMBusController::GetChannel(unsigned int led)
|
||||
{
|
||||
LOG_TRACE("[%s] Config table for zone %02d: %02d", device_name, cfg_zone, config_table[channel_cfg + cfg_zone]);
|
||||
return(config_table[channel_cfg + led]);
|
||||
}
|
||||
|
||||
switch(config_table[channel_cfg + cfg_zone])
|
||||
const char * ENESMBusController::GetChannelName(unsigned int led)
|
||||
{
|
||||
switch (config_table[channel_cfg + led])
|
||||
{
|
||||
case (unsigned char)ENE_LED_CHANNEL_AUDIO:
|
||||
return(ene_channels[0]);
|
||||
@@ -225,7 +194,6 @@ const char * ENESMBusController::GetChannelName(unsigned int cfg_zone)
|
||||
|
||||
case (unsigned char)ENE_LED_CHANNEL_DRAM:
|
||||
case (unsigned char)ENE_LED_CHANNEL_DRAM_2:
|
||||
case (unsigned char)ENE_LED_CHANNEL_DRAM_3:
|
||||
return(ene_channels[5]);
|
||||
break;
|
||||
|
||||
@@ -251,10 +219,9 @@ const char * ENESMBusController::GetChannelName(unsigned int cfg_zone)
|
||||
}
|
||||
}
|
||||
|
||||
unsigned int ENESMBusController::GetLEDCount(unsigned int cfg_zone)
|
||||
unsigned int ENESMBusController::GetLEDCount()
|
||||
{
|
||||
LOG_TRACE("[%s] LED Count for zone %02d: %02d", device_name, cfg_zone, config_table[0x03 + cfg_zone]);
|
||||
return(config_table[0x03 + cfg_zone]);
|
||||
return(led_count);
|
||||
}
|
||||
|
||||
unsigned char ENESMBusController::GetLEDRed(unsigned int led)
|
||||
@@ -383,11 +350,6 @@ void ENESMBusController::SetMode(unsigned char mode, unsigned char speed, unsign
|
||||
ENERegisterWrite(ENE_REG_APPLY, ENE_APPLY_VAL);
|
||||
}
|
||||
|
||||
bool ENESMBusController::SupportsMode14()
|
||||
{
|
||||
return(supports_mode_14);
|
||||
}
|
||||
|
||||
void ENESMBusController::UpdateDeviceName()
|
||||
{
|
||||
for (int i = 0; i < 16; i++)
|
||||
|
||||
@@ -18,7 +18,7 @@
|
||||
|
||||
#define ENE_APPLY_VAL 0x01 /* Value for Apply Changes Register */
|
||||
#define ENE_SAVE_VAL 0xAA /* Value for Save Changes */
|
||||
#define ENE_NUM_ZONES 8 /* Number of ENE config table zones */
|
||||
|
||||
enum
|
||||
{
|
||||
ENE_REG_DEVICE_NAME = 0x1000, /* Device String 16 bytes */
|
||||
@@ -53,7 +53,6 @@ enum
|
||||
ENE_MODE_SPECTRUM_CYCLE_WAVE = 11, /* Wave effect mode */
|
||||
ENE_MODE_CHASE_RAINBOW_PULSE = 12, /* Chase with Rainbow Pulse effect mode*/
|
||||
ENE_MODE_RANDOM_FLICKER = 13, /* Random flicker effect mode */
|
||||
ENE_MODE_DOUBLE_FADE = 14, /* Rainbow fade to dual color */
|
||||
ENE_NUMBER_MODES /* Number of Aura modes */
|
||||
};
|
||||
|
||||
@@ -75,7 +74,6 @@ enum
|
||||
enum
|
||||
{
|
||||
ENE_LED_CHANNEL_DRAM_2 = 0x05, /* DRAM LED channel */
|
||||
ENE_LED_CHANNEL_DRAM_3 = 0x0E, /* DRAM LED channel */
|
||||
ENE_LED_CHANNEL_CENTER_START = 0x82, /* Center zone first LED channel */
|
||||
ENE_LED_CHANNEL_CENTER = 0x83, /* Center zone LED channel */
|
||||
ENE_LED_CHANNEL_AUDIO = 0x84, /* Audio zone LED channel */
|
||||
@@ -92,7 +90,6 @@ enum
|
||||
{
|
||||
ENE_CONFIG_LED_COUNT = 0x02, /* LED Count configuration offset */
|
||||
ENE_CONFIG_LED_COUNT_0107 = 0x03, /* LED Count configuration offset */
|
||||
ENE_CONFIG_LED_COUNT_1110 = 0x03, /* LED Count configuration offset */
|
||||
ENE_CONFIG_CHANNEL_V1 = 0x13, /* LED Channel configuration offset */
|
||||
ENE_CONFIG_CHANNEL_V2 = 0x1B, /* LED Channel V2 configuration offset */
|
||||
};
|
||||
@@ -105,8 +102,9 @@ public:
|
||||
|
||||
std::string GetDeviceName();
|
||||
std::string GetDeviceLocation();
|
||||
const char* GetChannelName(unsigned int cfg_zone);
|
||||
unsigned int GetLEDCount(unsigned int cfg_zone);
|
||||
unsigned char GetChannel(unsigned int led);
|
||||
const char* GetChannelName(unsigned int led);
|
||||
unsigned int GetLEDCount();
|
||||
unsigned char GetLEDRed(unsigned int led);
|
||||
unsigned char GetLEDGreen(unsigned int led);
|
||||
unsigned char GetLEDBlue(unsigned int led);
|
||||
@@ -120,7 +118,6 @@ public:
|
||||
void SetLEDColorDirect(unsigned int led, unsigned char red, unsigned char green, unsigned char blue);
|
||||
void SetLEDColorEffect(unsigned int led, unsigned char red, unsigned char green, unsigned char blue);
|
||||
void SetMode(unsigned char mode, unsigned char speed, unsigned char direction);
|
||||
bool SupportsMode14();
|
||||
|
||||
void UpdateDeviceName();
|
||||
|
||||
@@ -137,5 +134,5 @@ private:
|
||||
unsigned char channel_cfg;
|
||||
ENESMBusInterface* interface;
|
||||
ene_dev_id dev;
|
||||
bool supports_mode_14;
|
||||
|
||||
};
|
||||
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user