jalr/OpenRGB
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Add Keychron keyboards support - Closes #1790

Browse source
This commit is contained in:
morg 2022-03-07 01:17:09 +00:00 • committed by Adam Honse
parent ae1c73497a
commit ae84bcb862
6 changed files with 1150 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

298
Controllers/KeychronKeyboardController/KeychronKeyboardController.cpp Normal file
View file

@ -0,0 +1,298 @@
/*-----------------------------------------*\
| KeychronKeyboardController.cpp |
| |
| Driver for Keychron Keyboard lighting |
| controller |
| |
| Guimard Morgan (morg) 2/20/2022 |
\*-----------------------------------------*/
#include "KeychronKeyboardController.h"
#include <string.h>
using namespace std::chrono_literals;
KeychronKeyboardController::KeychronKeyboardController(hid_device* dev_handle, const hid_device_info& info)
{
dev = dev_handle;
version = "";
location = info.path;
wchar_t serial_string[128];
int ret = hid_get_serial_number_string(dev, serial_string, 128);
if(ret != 0)
{
serial_number = "";
}
else
{
std::wstring return_wstring = serial_string;
serial_number = std::string(return_wstring.begin(), return_wstring.end());
}
}
KeychronKeyboardController::~KeychronKeyboardController()
{
hid_close(dev);
}
std::string KeychronKeyboardController::GetDeviceLocation()
{
return("HID: " + location);
}
std::string KeychronKeyboardController::GetSerialString()
{
return(serial_number);
}
std::string KeychronKeyboardController::GetFirmwareVersion()
{
return(version);
}
void KeychronKeyboardController:: SetLedSequencePositions(std::vector<unsigned int> positions)
{
led_sequence_positions = positions;
}
void KeychronKeyboardController::SetMode(std::vector<mode> modes, int active_mode, std::vector<RGBColor> colors)
{
/*-----------------------------------------*\
| Turn customization on/off |
| Custom mode needs to turn it on |
\*-----------------------------------------*/
SetCustomization(modes[active_mode].value == CUSTOM_MODE_VALUE);
/*-----------------------------------------*\
| Tells the device we're about to send the |
| pages (18 pages) |
\*-----------------------------------------*/
StartEffectPage();
unsigned char usb_buf[PACKET_DATA_LENGTH];
/*-----------------------------------------*\
| Configure the modes |
| LED Effect Page structure: |
| |
| OK.. this was from the original PDF |
| which appears to not be exact/up to date |
|-------------------------------------------|
| [0] Specialeffects mode1-32 |
| [1] colorFull color: 0x00 Monochrome:0x01 |
| [2] R Color ratio 0x00-0xFF |
| [3] G Color Ratio0x00-0xFF |
| [4] B Colour ratio0x00-0xFF |
| full color is 0,invalid |
| [5] dynamicdirection |
| left to right: 0x00 |
| right to left: 0x01 |
| down to up: 0x02 |
| up to down: 0x03 |
| [6] brightnesscontrol 0x00-0x0F |
| 0x0F brightest |
| [7] Periodiccontrol0x00-0x0F |
| 0x0F longest cycle |
| [8:13] Reserved |
| [14] Checkcode_L0xAA |
| [15] Checkcode_H0x55 |
|-------------------------------------------|
| Fixes: |
| color mode is 8th byte |
| brightness is 9th byte |
| speed is 10th byte |
| direction is 11th byte |
\*-----------------------------------------*/
unsigned char selected_mode[EFFECT_PAGE_LENGTH];
for(unsigned int i = 0; i < 5; i++) // 5 packets
{
memset(usb_buf, 0x00, PACKET_DATA_LENGTH);
for(unsigned int j = 0; j < 4; j++) // of 4 effects
{
const mode& m = modes[1 + j + i * 4]; // skip 1 first mode (Custom)
int offset = j * EFFECT_PAGE_LENGTH;
usb_buf[offset + 0] = m.value; // mode value
if(m.flags & MODE_FLAG_HAS_MODE_SPECIFIC_COLOR)
{
usb_buf[offset + 1] = RGBGetRValue(m.colors[0]);
usb_buf[offset + 2] = RGBGetGValue(m.colors[0]);
usb_buf[offset + 3] = RGBGetBValue(m.colors[0]);
}
usb_buf[offset + 8] = m.color_mode == MODE_COLORS_RANDOM; // random switch
usb_buf[offset + 9] = m.brightness;
usb_buf[offset + 10] = m.speed;
usb_buf[offset + 11] = m.direction;
usb_buf[offset + 14] = EFFECT_PAGE_CHECK_CODE_L;
usb_buf[offset + 15] = EFFECT_PAGE_CHECK_CODE_H;
/*-----------------------------------------*\
| Backup active mode values for later use |
| Custom and off share the same mode value |
\*-----------------------------------------*/
if(m.value == modes[active_mode].value || (m.value == LIGHTS_OFF_MODE_VALUE && modes[active_mode].value == CUSTOM_MODE_VALUE))
{
usb_buf[offset + 9] = modes[active_mode].brightness;
for(unsigned int x = 0; x < EFFECT_PAGE_LENGTH; x++)
{
selected_mode[x] = usb_buf[offset+x];
}
}
}
Send(usb_buf); // Sends the packet
}
// packets count sent: 5
/*-----------------------------------------*\
| 3 times an empty packet - guess why... |
\*-----------------------------------------*/
for(unsigned int i = 0; i < 3; i++)
{
memset(usb_buf, 0x00, PACKET_DATA_LENGTH);
Send(usb_buf);
}
// packets count sent: 8
/*-----------------------------------------*\
| Customization stuff |
| 9 times * 16 blocks 80 RR GG BB |
\*-----------------------------------------*/
unsigned char color_buf[COLOR_BUF_SIZE];
memset(color_buf, 0x00, COLOR_BUF_SIZE);
for(unsigned int i = 0; i < COLOR_BUF_SIZE; i += 4)
{
color_buf[i] = 0x80;
}
for(unsigned int c = 0; c < colors.size(); c++)
{
int offset = led_sequence_positions[c] * 4;
color_buf[offset + 1] = RGBGetRValue(colors[c]);
color_buf[offset + 2] = RGBGetGValue(colors[c]);
color_buf[offset + 3] = RGBGetBValue(colors[c]);
}
for(unsigned int p = 0; p < 9; p++)
{
memcpy(usb_buf, &color_buf[p * PACKET_DATA_LENGTH], PACKET_DATA_LENGTH);
Send(usb_buf);
}
// packets count sent: 17
/*-----------------------------------------*\
| Tells the device what the active mode is |
| This is the last packet |
\*-----------------------------------------*/
memset(usb_buf, 0x00, PACKET_DATA_LENGTH);
memcpy(usb_buf, &selected_mode[0], EFFECT_PAGE_LENGTH);
Send(usb_buf);
// packets count sent: 18 - let's hope the keyboard ACK in next frame
/*-----------------------------------------*\
| Tells the device that the pages are sent |
\*-----------------------------------------*/
EndCommunication();
/*-----------------------------------------*\
| Tells the device to apply what we've sent |
\*-----------------------------------------*/
StartEffectCommand();
}
void KeychronKeyboardController::StartEffectCommand()
{
unsigned char usb_buf[PACKET_DATA_LENGTH];
memset(usb_buf, 0x00, PACKET_DATA_LENGTH);
usb_buf[0x00] = PACKET_HEADER;
usb_buf[0x01] = LED_EFFECT_START_COMMAND;
Send(usb_buf);
}
void KeychronKeyboardController::StartEffectPage()
{
/*-----------------------------------------*\
| LED_SPECIAL_EFFECT_PACKETS: |
| Packet amount that will be sent in this |
| transaction |
\*-----------------------------------------*/
unsigned char usb_buf[PACKET_DATA_LENGTH];
memset(usb_buf, 0x00, PACKET_DATA_LENGTH);
usb_buf[0x00] = PACKET_HEADER;
usb_buf[0x01] = WRITE_LED_SPECIAL_EFFECT_AREA_COMMAND;
usb_buf[0x08] = LED_SPECIAL_EFFECT_PACKETS;
Send(usb_buf);
Read();
}
void KeychronKeyboardController::SetCustomization(bool state)
{
unsigned char usb_buf[PACKET_DATA_LENGTH];
memset(usb_buf, 0x00, PACKET_DATA_LENGTH);
usb_buf[0x00] = PACKET_HEADER;
usb_buf[0x01] = state ? TURN_ON_CUSTOMIZATION_COMMAND : TURN_OFF_CUSTOMIZATION_COMMAND;
Send(usb_buf);
Read();
}
void KeychronKeyboardController::EndCommunication()
{
unsigned char usb_buf[PACKET_DATA_LENGTH];
memset(usb_buf, 0x00, PACKET_DATA_LENGTH);
usb_buf[0x00] = PACKET_HEADER;
usb_buf[0x01] = COMMUNICATION_END_COMMAND;
Send(usb_buf);
Read();
}
void KeychronKeyboardController::Read()
{
unsigned char usb_buf[PACKET_DATA_LENGTH+1];
memset(usb_buf, 0x00, PACKET_DATA_LENGTH+1);
usb_buf[0x00] = REPORT_ID;
hid_get_feature_report(dev, usb_buf, PACKET_DATA_LENGTH+1);
std::this_thread::sleep_for(10ms);
}
void KeychronKeyboardController::Send(unsigned char data[PACKET_DATA_LENGTH])
{
unsigned char usb_buf[PACKET_DATA_LENGTH+1];
usb_buf[0] = REPORT_ID;
for(unsigned int x = 0; x < PACKET_DATA_LENGTH; x++)
{
usb_buf[x+1] = data[x];
}
hid_send_feature_report(dev, usb_buf, PACKET_DATA_LENGTH+1);
std::this_thread::sleep_for(10ms);
}

117
Controllers/KeychronKeyboardController/KeychronKeyboardController.h Normal file
View file

@ -0,0 +1,117 @@
/*-----------------------------------------*\
| KeychronKeyboardController.h |
| |
| Driver for Keychron Keyboard lighting |
| controller - header file |
| |
| Guimard Morgan (morg) 2/20/2022 |
\*-----------------------------------------*/
#pragma once
#include "RGBController.h"
#include <string>
#include <hidapi/hidapi.h>
#define REPORT_ID 0x00
#define PACKET_DATA_LENGTH 64
#define COLOR_BUF_SIZE 576
#define EFFECT_PAGE_LENGTH 16
#define LED_SPECIAL_EFFECT_PACKETS 0x12
#define PACKET_HEADER 0x04
#define EFFECT_PAGE_CHECK_CODE_L 0xAA
#define EFFECT_PAGE_CHECK_CODE_H 0x55
/*-----------------------------------------*\
| Commands |
\*-----------------------------------------*/
enum
{
COMMUNICATION_END_COMMAND = 0x02,
GET_BASIC_INFO_COMMAND = 0x05,
READ_KEY_DEFINITION_AREA_COMMAND = 0x10,
WRITE_KEY_DEFINITION_AREA_COMMAND = 0x11,
READ_LED_EFFECT_DEFINITION_AREA_COMMAND = 0x12,
WRITE_LED_SPECIAL_EFFECT_AREA_COMMAND = 0x13,
READ_MACRO_DEFINITION_AREA_COMMAND = 0x14,
WRITE_MACRO_DEFINITION_AREA_COMMAND = 0x15,
READ_GAME_MODE_AREA_COMMAND = 0x16,
WRITE_GAME_MODE_AREA_COMMAND = 0x17,
TURN_ON_CUSTOMIZATION_COMMAND = 0x18,
TURN_OFF_CUSTOMIZATION_COMMAND = 0x19,
LED_EFFECT_START_COMMAND = 0xF0,
LED_SYNC_INITIAL_COMMAND = 0xF1,
LED_SYNC_START_COMMAND = 0xF2,
LED_SYNC_STOP_COMMAND = 0xF3,
RANDOM_PACKET_START_COMMAND = 0xAB,
};
/*-----------------------------------------*\
| Modes |
\*-----------------------------------------*/
enum
{
CUSTOM_MODE_VALUE = 0x00,
STATIC_MODE_VALUE = 0x01,
KEYSTROKE_LIGHT_UP_MODE_VALUE = 0x02,
KEYSTROKE_DIM_MODE_VALUE = 0x03,
SPARKLE_MODE_VALUE = 0x04,
RAIN_MODE_VALUE = 0x05,
RANDOM_COLORS_MODE_VALUE = 0x06,
BREATHING_MODE_VALUE = 0x07,
SPECTRUM_CYCLE_MODE_VALUE = 0x08,
RING_GRADIENT_MODE_VALUE = 0x09,
VERTICAL_GRADIENT_MODE_VALUE = 0x0A,
HORIZONTAL_GRADIENT_WAVE_MODE_VALUE = 0x0B,
AROUND_EDGES_MODE_VALUE = 0x0C,
KEYSTROKE_HORIZONTAL_LINES_VALUE = 0x0D,
KEYSTROKE_TITLED_LINES_MODE_VALUE = 0x0E,
KEYSTROKE_RIPPLES_MODE_VALUE = 0x0F,
SEQUENCE_MODE_VALUE = 0x10,
WAVE_LINE_MODE_VALUE = 0x11,
TILTED_LINES_MODE_VALUE = 0x12,
BACK_AND_FORTH_MODE_VALUE = 0x13,
LIGHTS_OFF_MODE_VALUE = 0x80,
};
/*-----------------------------------------*\
| Other settings |
\*-----------------------------------------*/
enum
{
KEYCHRON_MIN_SPEED = 0x00,
KEYCHRON_MAX_SPEED = 0x0F,
KEYCHRON_MIN_BRIGHTNESS = 0x00,
KEYCHRON_MAX_BRIGHTNESS = 0x0F,
};
class KeychronKeyboardController
{
public:
KeychronKeyboardController(hid_device* dev_handle, const hid_device_info& info);
~KeychronKeyboardController();
std::string GetSerialString();
std::string GetDeviceLocation();
std::string GetFirmwareVersion();
void SetLedSequencePositions(std::vector<unsigned int> positions);
void SetMode(std::vector<mode> modes, int active_mode, std::vector<RGBColor> colors);
protected:
hid_device* dev;
private:
std::string location;
std::string serial_number;
std::string version;
std::vector<unsigned int> led_sequence_positions;
void SetCustomization(bool state);
void StartEffectPage();
void StartEffectCommand();
void EndCommunication();
void Read();
void Send(unsigned char data[PACKET_DATA_LENGTH]);
};

29
Controllers/KeychronKeyboardController/KeychronKeyboardControllerDetect.cpp Normal file
View file

@ -0,0 +1,29 @@
#include "Detector.h"
#include "KeychronKeyboardController.h"
#include "RGBController.h"
#include "RGBController_KeychronKeyboard.h"
/*---------------------------------------------------------*\
| KeychronKeyboard vendor ID |
\*---------------------------------------------------------*/
#define KEYCHRON_KEYBOARD_VID 0x05AC
/*---------------------------------------------------------*\
| Product ID |
\*---------------------------------------------------------*/
#define KEYCHRON_K3_V2_OPTICAL_RGB_PID 0x024F
void DetectKeychronKeyboardControllers(hid_device_info* info, const std::string& name)
{
hid_device* dev = hid_open_path(info->path);
if(dev)
{
KeychronKeyboardController* controller = new KeychronKeyboardController(dev, *info);
RGBController_KeychronKeyboard* rgb_controller = new RGBController_KeychronKeyboard(controller);
rgb_controller->name = name;
ResourceManager::get()->RegisterRGBController(rgb_controller);
}
}
REGISTER_HID_DETECTOR_IPU("Keychron Gaming Keyboard 1", DetectKeychronKeyboardControllers, KEYCHRON_KEYBOARD_VID, KEYCHRON_K3_V2_OPTICAL_RGB_PID, 0, 0x0001, 0x06);

670
Controllers/KeychronKeyboardController/RGBController_KeychronKeyboard.cpp Normal file
View file

@ -0,0 +1,670 @@
/*-----------------------------------------*\
| RGBController_KeychronKeyboard.cpp |
| |
| Generic RGB Interface for OpenRGB |
| Keychron Keyboard USB Driver |
| |
| Guimard Morgan (morg) 2/20/2022 |
\*-----------------------------------------*/
#include "RGBControllerKeyNames.h"
#include "RGBController_KeychronKeyboard.h"
#include <thread>
#include <chrono>
#define NA 0xFFFFFFFF
typedef struct
{
const unsigned int width; /* matrix width */
const unsigned int height; /* matrix height */
std::vector<std::vector<unsigned int>> matrix_map; /* matrix map */
std::vector<std::string> led_names; /* led names */
std::vector<unsigned int> led_sequence_positions; /* position in buffers */
} keychron;
/*-----------------------------------------*\
| The one that is showed in the original |
| issue |
\*-----------------------------------------*/
static keychron default_keychron =
{
17,
5,
{
{ 0, 5, 7, 12, 16, 20, 24, 29, 33, 37, 41, 46, 51, 54, NA, 61, 66},
{ 1, NA, 8, 13, 17, 21, 25, 30, 34, 38, 42, 47, 52, 55, 59, 62, 67},
{ 2, NA, 9, 14, 18, 22, 26, 31, 35, 39, 43, 48, 53, 56, NA, 63, 68},
{ 3, NA, 10, 15, 19, 23, 27, 32, 36, 40, 44, 49, NA, 57, NA, 64, 69},
{ 4, 6, 11, NA, NA, NA, 28, NA, NA, NA, 45, 50, NA, 58, 60, 65, 70}
},
{
KEY_EN_ESCAPE, //0
KEY_EN_TAB, //1
KEY_EN_CAPS_LOCK, //2
KEY_EN_LEFT_SHIFT, //3
KEY_EN_LEFT_CONTROL, //4
KEY_EN_1, //5
KEY_EN_LEFT_WINDOWS, //6
KEY_EN_2, //7
KEY_EN_Q, //8
KEY_EN_A, //9
KEY_EN_Z, //10
KEY_EN_LEFT_ALT, //11
KEY_EN_3, //12
KEY_EN_W, //13
KEY_EN_S, //14
KEY_EN_X, //15
KEY_EN_4, //16
KEY_EN_E, //17
KEY_EN_D, //18
KEY_EN_C, //19
KEY_EN_5, //20
KEY_EN_R, //21
KEY_EN_F, //22
KEY_EN_V, //23
KEY_EN_6, //24
KEY_EN_T, //25
KEY_EN_G, //26
KEY_EN_B, //27
KEY_EN_SPACE, //28
KEY_EN_7, //29
KEY_EN_Y, //30
KEY_EN_H, //31
KEY_EN_N, //32
KEY_EN_8, //33
KEY_EN_U, //34
KEY_EN_J, //35
KEY_EN_M, //36
KEY_EN_9, //37
KEY_EN_I, //38
KEY_EN_K, //39
KEY_EN_COMMA, //40
KEY_EN_0, //41
KEY_EN_O, //42
KEY_EN_L, //43
KEY_EN_PERIOD, //44
KEY_EN_RIGHT_ALT, //45
KEY_EN_MINUS, //46
KEY_EN_P, //47
KEY_EN_SEMICOLON, //48
KEY_EN_FORWARD_SLASH, //49
KEY_EN_RIGHT_FUNCTION, //50
KEY_EN_EQUALS, //51
KEY_EN_LEFT_BRACKET, //52
KEY_EN_QUOTE, //53
KEY_EN_BACKSPACE, //54
KEY_EN_RIGHT_BRACKET, //55
KEY_EN_ISO_ENTER, //56
KEY_EN_RIGHT_SHIFT, //57
KEY_EN_RIGHT_CONTROL, //58
KEY_EN_ISO_BACK_SLASH, //59
KEY_EN_LEFT_ARROW, //60
KEY_EN_INSERT, //61
KEY_EN_DELETE, //62
KEY_EN_PAUSE_BREAK, //63
KEY_EN_UP_ARROW, //64
KEY_EN_DOWN_ARROW, //65
KEY_EN_HOME, //66
KEY_EN_END, //67
KEY_EN_PAGE_UP, //68
KEY_EN_PAGE_DOWN, //69
KEY_EN_RIGHT_ARROW //70
},
{
0, //KEY_EN_ESCAPE, //0
1, //KEY_EN_TAB, //1
2, //KEY_EN_CAPS_LOCK, //2
3, //KEY_EN_LEFT_SHIFT, //3
4, //KEY_EN_LEFT_CONTROL, //4
5, //KEY_EN_1, //5
6, //KEY_EN_LEFT_WINDOWS, //6
7, //KEY_EN_2, //7
8, //KEY_EN_Q, //8
9, //KEY_EN_A, //9
10, //KEY_EN_Z, //10
11, //KEY_EN_LEFT_ALT, //11
12, //KEY_EN_3, //12
13, //KEY_EN_W, //13
14, //KEY_EN_S, //14
15, //KEY_EN_X, //15
16, //KEY_EN_4, //16
17, //KEY_EN_E, //17
18, //KEY_EN_D, //18
19, //KEY_EN_C, //19
20, //KEY_EN_5, //20
21, //KEY_EN_R, //21
22, //KEY_EN_F, //22
23, //KEY_EN_V, //23
24, //KEY_EN_6, //24
25, //KEY_EN_T, //25
26, //KEY_EN_G, //26
27, //KEY_EN_B, //27
28, //KEY_EN_SPACE, //28
29, //KEY_EN_7, //29
30, //KEY_EN_Y, //30
31, //KEY_EN_H, //31
32, //KEY_EN_N, //32
33, //KEY_EN_8, //33
34, //KEY_EN_U, //34
35, //KEY_EN_J, //35
36, //KEY_EN_M, //36
37, //KEY_EN_9, //37
38, //KEY_EN_I, //38
39, //KEY_EN_K, //39
40, //KEY_EN_COMMA, //40
41, //KEY_EN_0, //41
42, //KEY_EN_O, //42
43, //KEY_EN_L, //43
44, //KEY_EN_PERIOD, //44
45, //KEY_EN_RIGHT_ALT, //45
46, //KEY_EN_MINUS, //46
47, //KEY_EN_P, //47
48, //KEY_EN_SEMICOLON, //48
49, //KEY_EN_FORWARD_SLASH, //49
50, //KEY_EN_RIGHT_FUNCTION, //50
51, //KEY_EN_EQUALS, //51
52, //KEY_EN_LEFT_BRACKET, //52
53, //KEY_EN_QUOTE, //53
54, //KEY_EN_BACKSPACE, //54
55, //KEY_EN_RIGHT_BRACKET, //55
56, //KEY_EN_ISO_ENTER, //56
57, //KEY_EN_RIGHT_SHIFT, //57
58, //KEY_EN_RIGHT_CONTROL, //58
59, //KEY_EN_ISO_BACK_SLASH, //59
60, //KEY_EN_LEFT_ARROW, //60
61, //KEY_EN_INSERT, //61
62, //KEY_EN_DELETE, //62
63, //KEY_EN_PAUSE_BREAK, //63
64, //KEY_EN_UP_ARROW, //64
65, //KEY_EN_DOWN_ARROW, //65
66, //KEY_EN_HOME, //66
67, //KEY_EN_END, //67
68, //KEY_EN_PAGE_UP, //68
69, //KEY_EN_PAGE_DOWN, //69
70 //KEY_EN_RIGHT_ARROW //70
}
};
/*-----------------------------------------*\
| K3 V2 VERSION |
\*-----------------------------------------*/
static keychron k3_keychron =
{
16,
6,
{
{ 0, 6, 9, 15, 20, 25, 30, 36, 41, 46, 51, 57, 63, 69, 73, 78},
{ 1, 7, 10, 16, 21, 26, 31, 37, 42, 47, 52, 58, 64, 70, NA, 79},
{ 2, NA, 11, 17, 22, 27, 32, 38, 43, 48, 53, 59, 65, 71, 74, 80},
{ 3, NA, 12, 18, 23, 28, 33, 39, 44, 49, 54, 60, 66, NA, 75, 81},
{ 4, NA, 13, 19, 24, 29, 34, 40, 45, 50, 55, 61, 67, NA, 76, 82},
{ 5, 8, 14, NA, NA, NA, 35, NA, NA, NA, 56, 62, 68, 72, 77, 83}
},
{
KEY_EN_ESCAPE, //0
KEY_EN_BACK_TICK, //1
KEY_EN_TAB, //2
KEY_EN_CAPS_LOCK, //3
KEY_EN_LEFT_SHIFT, //4
KEY_EN_LEFT_CONTROL, //5
KEY_EN_F1, //6
KEY_EN_1, //7
KEY_EN_LEFT_WINDOWS, //8
KEY_EN_F2, //9
KEY_EN_2, //10
KEY_EN_Q, //11
KEY_EN_A, //12
KEY_EN_Z, //13
KEY_EN_LEFT_ALT, //14
KEY_EN_F3, //15
KEY_EN_3, //16
KEY_EN_W, //17
KEY_EN_S, //18
KEY_EN_X, //19
KEY_EN_F4, //20
KEY_EN_4, //21
KEY_EN_E, //22
KEY_EN_D, //23
KEY_EN_C, //24
KEY_EN_F5, //25
KEY_EN_5, //26
KEY_EN_R, //27
KEY_EN_F, //28
KEY_EN_V, //29
KEY_EN_F6, //30
KEY_EN_6, //31
KEY_EN_T, //32
KEY_EN_G, //33
KEY_EN_B, //34
KEY_EN_SPACE, //35
KEY_EN_F7, //36
KEY_EN_7, //37
KEY_EN_Y, //38
KEY_EN_H, //39
KEY_EN_N, //40
KEY_EN_F8, //41
KEY_EN_8, //42
KEY_EN_U, //43
KEY_EN_J, //44
KEY_EN_M, //45
KEY_EN_F9, //46
KEY_EN_9, //47
KEY_EN_I, //48
KEY_EN_K, //49
KEY_EN_COMMA, //50
KEY_EN_F10, //51
KEY_EN_0, //52
KEY_EN_O, //53
KEY_EN_L, //54
KEY_EN_PERIOD, //55
KEY_EN_RIGHT_ALT, //56
KEY_EN_F11, //57
KEY_EN_MINUS, //58
KEY_EN_P, //59
KEY_EN_SEMICOLON, //60
KEY_EN_FORWARD_SLASH, //61
KEY_EN_RIGHT_FUNCTION, //62
KEY_EN_F12, //63
KEY_EN_NUMPAD_PLUS, //64
KEY_EN_LEFT_BRACKET, //65
KEY_EN_QUOTE, //66
KEY_EN_LEFT_SHIFT, //67
KEY_EN_RIGHT_CONTROL, //68
KEY_EN_PRINT_SCREEN, //69
KEY_EN_BACKSPACE, //70
KEY_EN_RIGHT_BRACKET, //71
KEY_EN_LEFT_ARROW, //72
KEY_EN_DELETE, //73
KEY_EN_ANSI_BACK_SLASH, //74
KEY_EN_ISO_ENTER, //75
KEY_EN_UP_ARROW, //76
KEY_EN_DOWN_ARROW, //77
"Key: Light", //78
KEY_EN_PAGE_UP, //79
KEY_EN_PAGE_DOWN, //80
KEY_EN_HOME, //81
KEY_EN_END, //82
KEY_EN_RIGHT_ARROW //83
},
{
143,
18,
34,
50,
66,
81,
2,
19,
82,
3,
20,
35,
51,
67,
83,
4,
21,
36,
52,
68,
5,
22,
37,
53,
69,
6,
23,
38,
54,
70,
7,
24,
39,
55,
71,
84,
8,
25,
40,
56,
72,
9,
26,
41,
57,
73,
10,
27,
42,
58,
74,
11,
28,
43,
59,
75,
85,
12,
29,
44,
60,
76,
86,
13,
30,
45,
61,
77,
87,
14,
31,
46,
88,
15,
47,
63,
78,
89,
16,
32,
48,
64,
79,
90
}
};
typedef struct
{
std::string name;
int value;
int flags;
} keychron_effect;
RGBController_KeychronKeyboard::RGBController_KeychronKeyboard(KeychronKeyboardController* controller_ptr)
{
controller = controller_ptr;
name = "Keychron Keyboard";
vendor = "Keychron";
type = DEVICE_TYPE_KEYBOARD;
description = name;
location = controller->GetDeviceLocation();
serial = controller->GetSerialString();
version = controller->GetFirmwareVersion();
mode Custom;
Custom.name = "Custom";
Custom.value = CUSTOM_MODE_VALUE;
Custom.flags = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
Custom.color_mode = MODE_COLORS_PER_LED;
Custom.brightness_min = KEYCHRON_MIN_BRIGHTNESS;
Custom.brightness_max = KEYCHRON_MAX_BRIGHTNESS;
Custom.brightness = KEYCHRON_MAX_BRIGHTNESS;
modes.push_back(Custom);
keychron_effect keychron_effects[20] =
{
{
"Static",
STATIC_MODE_VALUE,
MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE
},
{
"Keystroke light up",
KEYSTROKE_LIGHT_UP_MODE_VALUE,
MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE
},
{
"Keystroke dim",
KEYSTROKE_DIM_MODE_VALUE,
MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE
},
{
"Sparkle",
SPARKLE_MODE_VALUE,
MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE
},
{
"Rain",
RAIN_MODE_VALUE,
MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE
},
{
"Random colors",
RANDOM_COLORS_MODE_VALUE,
MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE
},
{
"Breathing",
BREATHING_MODE_VALUE,
MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE
},
{
"Spectrum cycle",
SPECTRUM_CYCLE_MODE_VALUE,
MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE
},
{
"Ring gradient",
RING_GRADIENT_MODE_VALUE,
MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE
},
{
"Vertical gradient",
VERTICAL_GRADIENT_MODE_VALUE,
MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_UD | MODE_FLAG_AUTOMATIC_SAVE
},
{
"Horizontal gradient / Rainbow wave",
HORIZONTAL_GRADIENT_WAVE_MODE_VALUE,
MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_AUTOMATIC_SAVE
},
{
"Around edges",
AROUND_EDGES_MODE_VALUE,
MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE
},
{
"Keystroke horizontal lines",
KEYSTROKE_HORIZONTAL_LINES_VALUE,
MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE
},
{
"Keystroke tilted lines",
KEYSTROKE_TITLED_LINES_MODE_VALUE,
MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE
},
{
"Keystroke ripples",
KEYSTROKE_RIPPLES_MODE_VALUE,
MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE
},
{
"Sequence",
SEQUENCE_MODE_VALUE,
MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_AUTOMATIC_SAVE
},
{
"Wave line",
WAVE_LINE_MODE_VALUE,
MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE
},
{
"Tilted lines",
TILTED_LINES_MODE_VALUE,
MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE
},
{
"Back and forth",
BACK_AND_FORTH_MODE_VALUE,
MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_AUTOMATIC_SAVE
},
{
"Off",
LIGHTS_OFF_MODE_VALUE,
MODE_FLAG_AUTOMATIC_SAVE
}
};
for(const keychron_effect& effect : keychron_effects)
{
mode m;
m.name = effect.name;
m.value = effect.value;
m.flags = effect.flags;
if(m.flags & MODE_FLAG_HAS_MODE_SPECIFIC_COLOR)
{
m.color_mode = MODE_COLORS_MODE_SPECIFIC;
m.colors_min = 1;
m.colors_max = 1;
m.colors.resize(1);
}
else
{
m.color_mode = MODE_COLORS_NONE;
m.colors_min = 0;
m.colors_max = 0;
m.colors.resize(0);
}
if(m.flags & MODE_FLAG_HAS_SPEED)
{
m.speed_min = KEYCHRON_MIN_SPEED;
m.speed_max = KEYCHRON_MAX_SPEED;
m.speed = m.speed_min;
}
if(m.flags & MODE_FLAG_HAS_BRIGHTNESS)
{
m.brightness_min = KEYCHRON_MIN_BRIGHTNESS;
m.brightness_max = KEYCHRON_MAX_BRIGHTNESS;
m.brightness = m.brightness_max;
}
modes.push_back(m);
}
SetupZones();
}
RGBController_KeychronKeyboard::~RGBController_KeychronKeyboard()
{
delete controller;
}
void RGBController_KeychronKeyboard::SetupZones()
{
/*-----------------------------------------*\
| TODO: add logical switch here when we |
| will have to add different layouts |
\*-----------------------------------------*/
keychron keyboard = k3_keychron;
controller->SetLedSequencePositions(keyboard.led_sequence_positions);
/*-----------------------------------------*\
| Create the zone |
\*-----------------------------------------*/
unsigned int zone_size = 0;
zone keyboard_zone;
keyboard_zone.name = "Keyboard";
keyboard_zone.type = ZONE_TYPE_MATRIX;
keyboard_zone.matrix_map = new matrix_map_type;
keyboard_zone.matrix_map->height = keyboard.height;
keyboard_zone.matrix_map->width = keyboard.width;
keyboard_zone.matrix_map->map = new unsigned int[keyboard.height * keyboard.width];
for(unsigned int w = 0; w < keyboard.width; w++)
{
for(unsigned int h = 0; h < keyboard.height; h++)
{
unsigned int key = keyboard.matrix_map[h][w];
keyboard_zone.matrix_map->map[h * keyboard.width + w] = key;
if(key != NA)
{
led new_led;
new_led.name = keyboard.led_names[key];
leds.push_back(new_led);
zone_size++;
}
}
}
keyboard_zone.leds_min = zone_size;
keyboard_zone.leds_max = zone_size;
keyboard_zone.leds_count = zone_size;
zones.push_back(keyboard_zone);
SetupColors();
}
void RGBController_KeychronKeyboard::ResizeZone(int /*zone*/, int /*new_size*/)
{
/*---------------------------------------------------------*\
| This device does not support resizing zones |
\*---------------------------------------------------------*/
}
void RGBController_KeychronKeyboard::DeviceUpdateLEDs()
{
UpdateZoneLEDs(0);
}
void RGBController_KeychronKeyboard::UpdateZoneLEDs(int /*zone*/)
{
controller->SetMode(modes, active_mode, colors);
}
void RGBController_KeychronKeyboard::UpdateSingleLED(int led)
{
UpdateZoneLEDs(led);
}
void RGBController_KeychronKeyboard::SetCustomMode()
{
active_mode = 0;
}
void RGBController_KeychronKeyboard::DeviceUpdateMode()
{
UpdateZoneLEDs(0);
}

31
Controllers/KeychronKeyboardController/RGBController_KeychronKeyboard.h Normal file
View file

@ -0,0 +1,31 @@
/*-----------------------------------------*\
| RGBController_KeychronKeyboard.h |
| |
| Generic RGB Interface for OpenRGB |
| Keychron Keyboard RGB USB Driver |
| |
| Guimard Morgan (morg) 2/20/2022 |
\*-----------------------------------------*/
#pragma once
#include "RGBController.h"
#include "KeychronKeyboardController.h"
class RGBController_KeychronKeyboard : public RGBController
{
public:
RGBController_KeychronKeyboard(KeychronKeyboardController* controller_ptr);
~RGBController_KeychronKeyboard();
void SetupZones();
void ResizeZone(int zone, int new_size);
void DeviceUpdateLEDs();
void UpdateZoneLEDs(int zone);
void UpdateSingleLED(int led);
void DeviceUpdateMode();
void SetCustomMode();
private:
KeychronKeyboardController* controller;
};

5
OpenRGB.pro
View file

@ -370,6 +370,8 @@ HEADERS +=
Controllers/HyperXMouseController/RGBController_HyperXPulsefireDart.h \
Controllers/HyperXMousematController/HyperXMousematController.h \
Controllers/HyperXMousematController/RGBController_HyperXMousemat.h \
Controllers/KeychronKeyboardController/KeychronKeyboardController.h \
Controllers/KeychronKeyboardController/RGBController_KeychronKeyboard.h \
Controllers/LEDStripController/LEDStripController.h \
Controllers/LEDStripController/RGBController_LEDStrip.h \
Controllers/LexipMouseController/LexipMouseController.h \
@ -805,6 +807,9 @@ SOURCES +=
Controllers/HyperXMousematController/HyperXMousematController.cpp \
Controllers/HyperXMousematController/HyperXMousematControllerDetect.cpp \
Controllers/HyperXMousematController/RGBController_HyperXMousemat.cpp \
Controllers/KeychronKeyboardController/KeychronKeyboardController.cpp \
Controllers/KeychronKeyboardController/KeychronKeyboardControllerDetect.cpp \
Controllers/KeychronKeyboardController/RGBController_KeychronKeyboard.cpp \
Controllers/LEDStripController/LEDStripController.cpp \
Controllers/LEDStripController/LEDStripControllerDetect.cpp \
Controllers/LEDStripController/RGBController_LEDStrip.cpp \