Skip to content

Commit 8852f3f

Browse files
Mola19CalcProgrammer1
Mola19
authored and
CalcProgrammer1
committed
Added support for ASUS TUF Gaming K7
 * Always sends save command when changing modes, this should be reworked to be optional in a future commit Commit amended for code style by Adam Honse <calcprogrammer1@gmail.com>
1 parent ba3aae8 commit 8852f3f

6 files changed

+820
-0
lines changed

‎Controllers/AsusAuraUSBController/AsusAuraTUFKeyboardController.cpp

+218
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,218 @@
1+
/*-----------------------------------------*\
2+
| AsusAuraTUFKeyboardController.cpp |
3+
| |
4+
| Driver for ASUS Aura RGB USB |
5+
| lighting controller |
6+
| |
7+
| Mola19 03/03/2021 |
8+
\*-----------------------------------------*/
9+
10+
#include "AsusAuraTUFKeyboardController.h"
11+
12+
#include <cstring>
13+
#include <string>
14+
#include <vector>
15+
#include <math.h>
16+
#include <stdio.h>
17+
#include <string.h>
18+
#include <iostream>
19+
20+
AuraTUFKeyboardController::AuraTUFKeyboardController(hid_device* dev_handle, const char* path)
21+
{
22+
dev = dev_handle;
23+
location = path;
24+
}
25+
26+
AuraTUFKeyboardController::~AuraTUFKeyboardController()
27+
{
28+
hid_close(dev);
29+
}
30+
31+
std::string AuraTUFKeyboardController::GetDeviceLocation()
32+
{
33+
return("HID: " + location);
34+
}
35+
36+
std::string AuraTUFKeyboardController::GetSerialString()
37+
{
38+
wchar_t serial_string[128];
39+
hid_get_serial_number_string(dev, serial_string, 128);
40+
41+
std::wstring return_wstring = serial_string;
42+
std::string return_string(return_wstring.begin(), return_wstring.end());
43+
44+
return(return_string);
45+
}
46+
47+
void AuraTUFKeyboardController::UpdateSingleLed
48+
(
49+
int led,
50+
unsigned char red,
51+
unsigned char green,
52+
unsigned char blue
53+
)
54+
{
55+
/*-----------------------------------------------------*\
56+
| Set up message packet for single LED |
57+
\*-----------------------------------------------------*/
58+
unsigned char usb_buf[65];
59+
60+
memset(usb_buf, 0x00, sizeof(usb_buf));
61+
62+
usb_buf[0] = 0x00;
63+
usb_buf[1] = 0xc0;
64+
usb_buf[2] = 0x81;
65+
usb_buf[3] = 0x01;
66+
usb_buf[4] = 0x00;
67+
68+
/*-----------------------------------------------------*\
69+
| Convert LED index |
70+
\*-----------------------------------------------------*/
71+
usb_buf[5] = floor(led/6)*8 + led%6;
72+
usb_buf[6] = red;
73+
usb_buf[7] = green;
74+
usb_buf[8] = blue;
75+
76+
hid_write(dev, usb_buf, 65);
77+
}
78+
79+
void AuraTUFKeyboardController::UpdateLeds
80+
(
81+
std::vector<RGBColor> colors
82+
)
83+
{
84+
/*-----------------------------------------------------*\
85+
| Loop over every column (optimisation needed) |
86+
\*-----------------------------------------------------*/
87+
for(unsigned int i = 0; i < 192; i += 16)
88+
{
89+
unsigned char usb_buf[69];
90+
91+
memset(usb_buf, 0x00, sizeof(usb_buf));
92+
93+
usb_buf[0] = 0x00;
94+
usb_buf[1] = 0xc0;
95+
usb_buf[2] = 0x81;
96+
usb_buf[3] = (138 - i / 16 * 12);
97+
usb_buf[4] = 0x00;
98+
99+
for(unsigned int n = 0; n < 6; n++)
100+
{
101+
usb_buf[n * 4 + 5] = i + n;
102+
usb_buf[n * 4 + 6] = RGBGetRValue(colors[i/16*12+n]);
103+
usb_buf[n * 4 + 7] = RGBGetGValue(colors[i/16*12+n]);
104+
usb_buf[n * 4 + 8] = RGBGetBValue(colors[i/16*12+n]);
105+
}
106+
107+
for(unsigned int n = 6; n < 8; n++)
108+
{
109+
usb_buf[n * 4 + 5] = i + n;
110+
usb_buf[n * 4 + 6] = 0;
111+
usb_buf[n * 4 + 7] = 0;
112+
usb_buf[n * 4 + 8] = 0;
113+
}
114+
115+
if(i != 176)
116+
{
117+
for(unsigned int n = 8; n < 14; n++)
118+
{
119+
usb_buf[n * 4 + 5] = i + n;
120+
usb_buf[n * 4 + 6] = RGBGetRValue(colors[i/16*12+n-2]);
121+
usb_buf[n * 4 + 7] = RGBGetGValue(colors[i/16*12+n-2]);
122+
usb_buf[n * 4 + 8] = RGBGetBValue(colors[i/16*12+n-2]);
123+
}
124+
125+
for(unsigned int n = 14; n < 16; n++)
126+
{
127+
usb_buf[n * 4 + 5] = i + n;
128+
usb_buf[n * 4 + 6] = 0;
129+
usb_buf[n * 4 + 7] = 0;
130+
usb_buf[n * 4 + 8] = 0;
131+
}
132+
}
133+
134+
hid_write(dev, usb_buf, 69);
135+
}
136+
}
137+
138+
void AuraTUFKeyboardController::UpdateDevice
139+
(
140+
unsigned char mode,
141+
std::vector<RGBColor> colors,
142+
unsigned char dir,
143+
unsigned char color_mode,
144+
unsigned char speed
145+
)
146+
{
147+
unsigned char usb_buf[65];
148+
149+
memset(usb_buf, 0x00, sizeof(usb_buf));
150+
151+
usb_buf[0x00] = 0x00;
152+
usb_buf[0x01] = 0x51;
153+
usb_buf[0x02] = 0x2C;
154+
usb_buf[0x03] = mode;
155+
usb_buf[0x04] = 0x00;
156+
usb_buf[0x05] = speed;
157+
usb_buf[0x06] = 0x64;
158+
usb_buf[0x07] = color_mode;
159+
usb_buf[0x08] = dir;
160+
usb_buf[0x09] = 0x02;
161+
162+
if(mode == 4 || mode == 5)
163+
{
164+
/*-----------------------------------------------------*\
165+
| If mode is Rainbow or Ripple |
166+
\*-----------------------------------------------------*/
167+
usb_buf[0x0A] = colors.size();
168+
169+
/*-----------------------------------------------------*\
170+
| Loop over every color given |
171+
\*-----------------------------------------------------*/
172+
for(unsigned int i = 0; i / 4 < colors.size(); i += 4)
173+
{
174+
if(colors[i / 4])
175+
{
176+
usb_buf[11 + i] = 100/(double)colors.size()*(i/4+1);
177+
usb_buf[12 + i] = RGBGetRValue(colors[i/4]);
178+
usb_buf[13 + i] = RGBGetGValue(colors[i/4]);
179+
usb_buf[14 + i] = RGBGetBValue(colors[i/4]);
180+
}
181+
}
182+
}
183+
else
184+
{
185+
/*-----------------------------------------------------*\
186+
| Loop over Color1, Color2 and Background if there |
187+
\*-----------------------------------------------------*/
188+
for(unsigned int i = 0; i / 3 != colors.size(); i += 3)
189+
{
190+
if(colors[i / 3])
191+
{
192+
usb_buf[10 + i] = RGBGetRValue(colors[i/3]);
193+
usb_buf[11 + i] = RGBGetGValue(colors[i/3]);
194+
usb_buf[12 + i] = RGBGetBValue(colors[i/3]);
195+
}
196+
}
197+
198+
}
199+
200+
/*-----------------------------------------------------*\
201+
| Send packet |
202+
\*-----------------------------------------------------*/
203+
hid_write(dev, usb_buf, 65);
204+
205+
/*-----------------------------------------------------*\
206+
| Set up and send packet save Packet |
207+
\*-----------------------------------------------------*/
208+
unsigned char usb_save_buf[65];
209+
210+
memset(usb_save_buf, 0x00, sizeof(usb_save_buf));
211+
212+
usb_save_buf[0x00] = 0x00;
213+
usb_save_buf[0x01] = 0x50;
214+
usb_save_buf[0x02] = 0x55;
215+
216+
hid_write(dev, usb_save_buf, 65);
217+
}
218+

‎Controllers/AsusAuraUSBController/AsusAuraTUFKeyboardController.h

+76
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,76 @@
1+
/*-----------------------------------------*\
2+
| AsusAuraTUFKeyboardController.h |
3+
| |
4+
| Definitions and types for ASUS Aura |
5+
| USB RGB lighting controller |
6+
| |
7+
| Mola19 03/03/2021 |
8+
\*-----------------------------------------*/
9+
10+
#include "RGBController.h"
11+
12+
#include <string>
13+
#include <vector>
14+
#include <hidapi/hidapi.h>
15+
16+
#pragma once
17+
18+
enum
19+
{
20+
AURA_KEYBOARD_ZONE_LOGO = 0,
21+
AURA_KEYBOARD_ZONE_SCROLL = 1,
22+
AURA_KEYBOARD_ZONE_UNDERGLOW = 2,
23+
AURA_KEYBOARD_ZONE_ALL = 3,
24+
};
25+
26+
enum
27+
{
28+
AURA_KEYBOARD_MODE_STATIC = 0,
29+
AURA_KEYBOARD_MODE_BREATHING = 1,
30+
AURA_KEYBOARD_MODE_COLOR_CYCLE = 2,
31+
AURA_KEYBOARD_MODE_REACTIVE = 3,
32+
AURA_KEYBOARD_MODE_WAVE = 4,
33+
AURA_KEYBOARD_MODE_RIPPLE = 5,
34+
AURA_KEYBOARD_MODE_STARRY_NIGHT = 6,
35+
AURA_KEYBOARD_MODE_QUICKSAND = 7,
36+
AURA_KEYBOARD_MODE_CURRENT = 8,
37+
AURA_KEYBOARD_MODE_RAIN_DROP = 9,
38+
AURA_KEYBOARD_MODE_DIRECT = 15,
39+
};
40+
41+
class AuraTUFKeyboardController
42+
{
43+
public:
44+
AuraTUFKeyboardController(hid_device* dev_handle, const char* path);
45+
~AuraTUFKeyboardController();
46+
47+
std::string GetDeviceLocation();
48+
std::string GetSerialString();
49+
50+
void UpdateSingleLed
51+
(
52+
int led,
53+
unsigned char red,
54+
unsigned char green,
55+
unsigned char blue
56+
);
57+
58+
void UpdateLeds
59+
(
60+
std::vector<RGBColor> colors
61+
);
62+
63+
void UpdateDevice
64+
(
65+
unsigned char mode,
66+
std::vector<RGBColor> colors,
67+
unsigned char dir,
68+
unsigned char color_mode,
69+
unsigned char speed
70+
);
71+
72+
private:
73+
hid_device* dev;
74+
std::string location;
75+
};
76+

‎Controllers/AsusAuraUSBController/AsusAuraUSBControllerDetect.cpp

+19
Original file line numberDiff line numberDiff line change
@@ -2,12 +2,14 @@
22
#include "AsusAuraAddressableController.h"
33
#include "AsusAuraHeadsetStandController.h"
44
#include "AsusAuraKeyboardController.h"
5+
#include "AsusAuraTUFKeyboardController.h"
56
#include "AsusAuraMainboardController.h"
67
#include "AsusAuraMouseController.h"
78
#include "RGBController.h"
89
#include "RGBController_AsusAuraUSB.h"
910
#include "RGBController_AsusAuraHeadsetStand.h"
1011
#include "RGBController_AsusAuraKeyboard.h"
12+
#include "RGBController_AsusAuraTUFKeyboard.h"
1113
#include "RGBController_AsusAuraMouse.h"
1214
#include <stdexcept>
1315
#include <hidapi/hidapi.h>
@@ -33,6 +35,7 @@
3335
#define AURA_ROG_CHAKRAM_WIRED_1_PID 0x18E3
3436
#define AURA_ROG_CHAKRAM_WIRED_2_PID 0x1958
3537
#define AURA_ROG_THRONE_QI_PID 0x18C5
38+
#define AURA_TUF_K7_GAMING_PID 0x18AA
3639

3740
void DetectAsusAuraUSBTerminal(hid_device_info* info, const std::string& name)
3841
{
@@ -117,6 +120,18 @@ void DetectAsusAuraUSBHeadsetStand(hid_device_info* info, const std::string& nam
117120
}
118121
}
119122

123+
void DetectAsusAuraTUFUSBKeyboard(hid_device_info* info, const std::string& name)
124+
{
125+
hid_device* dev = hid_open_path(info->path);
126+
if(dev)
127+
{
128+
AuraTUFKeyboardController* controller = new AuraTUFKeyboardController(dev, info->path);
129+
RGBController_AuraTUFKeyboard* rgb_controller = new RGBController_AuraTUFKeyboard(controller);
130+
rgb_controller->name = name;
131+
ResourceManager::get()->RegisterRGBController(rgb_controller);
132+
}
133+
}
134+
120135
REGISTER_HID_DETECTOR ("ASUS ROG AURA Terminal", DetectAsusAuraUSBTerminal, AURA_USB_VID, AURA_TERMINAL_PID);
121136
REGISTER_HID_DETECTOR ("ASUS Aura Addressable", DetectAsusAuraUSBAddressable, AURA_USB_VID, AURA_ADDRESSABLE_1_PID);
122137
REGISTER_HID_DETECTOR ("ASUS Aura Addressable", DetectAsusAuraUSBAddressable, AURA_USB_VID, AURA_ADDRESSABLE_2_PID);
@@ -135,4 +150,8 @@ REGISTER_HID_DETECTOR_IP("Asus ROG Chakram (Wired)", DetectAsusAuraUS
135150
REGISTER_HID_DETECTOR_IP("Asus ROG Chakram (Wired)", DetectAsusAuraUSBMice, AURA_USB_VID, AURA_ROG_CHAKRAM_WIRED_2_PID, 0, 0xFF01);
136151
REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Flare", DetectAsusAuraUSBKeyboards, AURA_USB_VID, AURA_ROG_STRIX_FLARE_PID, 1, 0xFF00);
137152
REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Flare PNK LTD", DetectAsusAuraUSBKeyboards, AURA_USB_VID, AURA_ROG_STRIX_FLARE_PNK_LTD_PID, 1, 0xFF00);
153+
REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Scope", DetectAsusAuraUSBKeyboards, AURA_USB_VID, AURA_ROG_STRIX_SCOPE_PID, 1, 0xFF00);
154+
REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Scope RX", DetectAsusAuraUSBKeyboards, AURA_USB_VID, AURA_ROG_STRIX_SCOPE_RX_PID, 1, 0xFF00);
155+
REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Scope TKL", DetectAsusAuraUSBKeyboards, AURA_USB_VID, AURA_ROG_STRIX_SCOPE_TKL_PID, 1, 0xFF00);
138156
REGISTER_HID_DETECTOR_I ("ASUS ROG Throne QI", DetectAsusAuraUSBHeadsetStand, AURA_USB_VID, AURA_ROG_THRONE_QI_PID, 0);
157+
REGISTER_HID_DETECTOR_I ("ASUS TUF Gaming K7", DetectAsusAuraTUFUSBKeyboard, AURA_USB_VID, AURA_TUF_K7_GAMING_PID, 1);

0 commit comments

Comments
 (0)