mirror/OpenRGB
1
0
Fork 0
mirror of https://github.com/CalcProgrammer1/OpenRGB.git synced 2026-03-09 01:30:46 -04:00
Code Issues Packages Projects Releases Wiki Activity

Add support for TUXEDO laptop per-key RGB keyboard (ITE 8291)

Browse Source
This commit is contained in:
Kyle Cascade
2026-01-20 23:51:13 +00:00
committed by Adam Honse
parent 555fb7b042
commit c58ae260e5
5 changed files with 878 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

193
Controllers/ClevoKeyboardController/ClevoKeyboardController.cpp Normal file
View File

@@ -0,0 +1,193 @@
/*---------------------------------------------------------*\
| ClevoKeyboardController.cpp |
| |
| Driver for Clevo laptop per-key RGB keyboard (ITE 8291) |
| Protocol based on tuxedo-drivers ite_8291 module |
| |
| Kyle Cascade (kyle@cascade.family) 16 Jan 2026 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include "ClevoKeyboardController.h"
#include <cstring>
ClevoKeyboardController::ClevoKeyboardController(hid_device* dev_handle, const hid_device_info& info)
{
dev = dev_handle;
location = info.path;
}
ClevoKeyboardController::~ClevoKeyboardController()
{
hid_close(dev);
}
std::string ClevoKeyboardController::GetDeviceLocation()
{
return("HID: " + location);
}
std::string ClevoKeyboardController::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 ClevoKeyboardController::WriteControl(unsigned char* data)
{
hid_send_feature_report(dev, data, CLEVO_KEYBOARD_REPORT_SIZE);
}
void ClevoKeyboardController::WriteRowData(unsigned char* data)
{
hid_write(dev, data, CLEVO_KEYBOARD_ROW_DATA_SIZE);
}
void ClevoKeyboardController::TurnOff()
{
/*---------------------------------------------------------*\
| Turn off: 08 01 00 00 00 00 00 00 |
\*---------------------------------------------------------*/
unsigned char buf[CLEVO_KEYBOARD_REPORT_SIZE];
memset(buf, 0x00, CLEVO_KEYBOARD_REPORT_SIZE);
buf[0] = 0x08;
buf[1] = 0x01;
WriteControl(buf);
}
void ClevoKeyboardController::SetMode(unsigned char mode, unsigned char brightness, unsigned char speed, unsigned char behaviour)
{
/*---------------------------------------------------------*\
| Set params: 08 [power] [mode] [speed] [brightness] 08 |
| [behaviour] 00 |
| power: 01=off, 02=on |
\*---------------------------------------------------------*/
unsigned char buf[CLEVO_KEYBOARD_REPORT_SIZE];
memset(buf, 0x00, CLEVO_KEYBOARD_REPORT_SIZE);
buf[0] = 0x08;
buf[1] = 0x02; // Power on
buf[2] = mode;
buf[3] = speed;
buf[4] = brightness;
buf[5] = 0x08;
buf[6] = behaviour;
WriteControl(buf);
}
void ClevoKeyboardController::SetModeColor(unsigned char color_idx, unsigned char red, unsigned char green, unsigned char blue)
{
/*---------------------------------------------------------*\
| Set color define: 14 00 [index] R G B 00 00 |
| index: 1-7 for built-in effects |
\*---------------------------------------------------------*/
unsigned char buf[CLEVO_KEYBOARD_REPORT_SIZE];
memset(buf, 0x00, CLEVO_KEYBOARD_REPORT_SIZE);
buf[0] = 0x14;
buf[1] = 0x00;
buf[2] = color_idx;
buf[3] = red;
buf[4] = green;
buf[5] = blue;
WriteControl(buf);
}
void ClevoKeyboardController::SendColors(unsigned char* color_data, unsigned char brightness)
{
/*---------------------------------------------------------*\
| Per-key RGB mode (mode 0x33) |
| 1. Set params with mode 0x33 and brightness |
| 2. For each row 0-5: |
| - Announce row: 16 00 [row] 00 00 00 00 00 |
| - Send 65 bytes row data via output report |
| |
| Row data format (65 bytes): |
| [0x00 padding][0x00 padding] |
| [B0..B20][G0..G20][R0..R20] |
\*---------------------------------------------------------*/
unsigned char ctrl_buf[CLEVO_KEYBOARD_REPORT_SIZE];
unsigned char row_buf[CLEVO_KEYBOARD_ROW_DATA_SIZE];
/*---------------------------------------------------------*\
| Clamp brightness |
\*---------------------------------------------------------*/
if(brightness > CLEVO_KEYBOARD_BRIGHTNESS_MAX)
{
brightness = CLEVO_KEYBOARD_BRIGHTNESS_MAX;
}
/*---------------------------------------------------------*\
| Set params for per-key mode |
\*---------------------------------------------------------*/
memset(ctrl_buf, 0x00, CLEVO_KEYBOARD_REPORT_SIZE);
ctrl_buf[0] = 0x08;
ctrl_buf[1] = 0x02; // Power on
ctrl_buf[2] = CLEVO_KEYBOARD_MODE_DIRECT; // Per-key mode
ctrl_buf[3] = 0x00; // Speed (unused)
ctrl_buf[4] = brightness;
ctrl_buf[5] = 0x00;
ctrl_buf[6] = 0x00;
WriteControl(ctrl_buf);
/*---------------------------------------------------------*\
| Send each row |
\*---------------------------------------------------------*/
for(int row = 0; row < CLEVO_KEYBOARD_NUM_ROWS; row++)
{
/*-----------------------------------------------------*\
| Announce row data |
\*-----------------------------------------------------*/
memset(ctrl_buf, 0x00, CLEVO_KEYBOARD_REPORT_SIZE);
ctrl_buf[0] = 0x16;
ctrl_buf[1] = 0x00;
ctrl_buf[2] = row;
WriteControl(ctrl_buf);
/*-----------------------------------------------------*\
| Build row data buffer |
| Format: [pad][pad][B0..B20][G0..G20][R0..R20] |
\*-----------------------------------------------------*/
memset(row_buf, 0x00, CLEVO_KEYBOARD_ROW_DATA_SIZE);
for(int col = 0; col < CLEVO_KEYBOARD_NUM_COLS; col++)
{
int led_idx = (row * CLEVO_KEYBOARD_NUM_COLS) + col;
int color_offset = led_idx * 3;
unsigned char red = color_data[color_offset + 0];
unsigned char green = color_data[color_offset + 1];
unsigned char blue = color_data[color_offset + 2];
/*-------------------------------------------------*\
| Row data layout (after 2-byte padding): |
| Bytes 2-22: Blue values for columns 0-20 |
| Bytes 23-43: Green values for columns 0-20 |
| Bytes 44-64: Red values for columns 0-20 |
\*-------------------------------------------------*/
row_buf[2 + col] = blue;
row_buf[2 + CLEVO_KEYBOARD_NUM_COLS + col] = green;
row_buf[2 + CLEVO_KEYBOARD_NUM_COLS*2 + col] = red;
}
WriteRowData(row_buf);
}
}

87
Controllers/ClevoKeyboardController/ClevoKeyboardController.h Normal file
View File

@@ -0,0 +1,87 @@
/*---------------------------------------------------------*\
| ClevoKeyboardController.h |
| |
| Driver for Clevo laptop per-key RGB keyboard (ITE 8291) |
| |
| Kyle Cascade (kyle@cascade.family) 16 Jan 2026 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#pragma once
#include <string>
#include <hidapi.h>
/*-----------------------------------------------------*\
| ITE 8291 keyboard defines |
\*-----------------------------------------------------*/
#define CLEVO_KEYBOARD_REPORT_SIZE 8
#define CLEVO_KEYBOARD_ROW_DATA_SIZE 65
#define CLEVO_KEYBOARD_NUM_ROWS 6
#define CLEVO_KEYBOARD_NUM_COLS 21
#define CLEVO_KEYBOARD_NUM_LEDS (CLEVO_KEYBOARD_NUM_ROWS * CLEVO_KEYBOARD_NUM_COLS)
#define CLEVO_KEYBOARD_BRIGHTNESS_MIN 0x00
#define CLEVO_KEYBOARD_BRIGHTNESS_MAX 0x32
#define CLEVO_KEYBOARD_SPEED_MIN 0x01
#define CLEVO_KEYBOARD_SPEED_MAX 0x0A
/*-----------------------------------------------------*\
| ITE 8291 modes |
\*-----------------------------------------------------*/
enum
{
CLEVO_KEYBOARD_MODE_DIRECT = 0x33,
CLEVO_KEYBOARD_MODE_BREATH = 0x02,
CLEVO_KEYBOARD_MODE_WAVE = 0x03,
CLEVO_KEYBOARD_MODE_REACTIVE = 0x04,
CLEVO_KEYBOARD_MODE_RAINBOW = 0x05,
CLEVO_KEYBOARD_MODE_RIPPLE = 0x06,
CLEVO_KEYBOARD_MODE_MARQUEE = 0x09,
CLEVO_KEYBOARD_MODE_RAINDROP = 0x0A,
CLEVO_KEYBOARD_MODE_AURORA = 0x0E,
CLEVO_KEYBOARD_MODE_SPARK = 0x11,
};
/*-----------------------------------------------------*\
| Wave/reactive behaviour |
\*-----------------------------------------------------*/
enum
{
CLEVO_KEYBOARD_DIRECTION_LEFT = 0x01,
CLEVO_KEYBOARD_DIRECTION_RIGHT = 0x02,
CLEVO_KEYBOARD_DIRECTION_UP = 0x03,
CLEVO_KEYBOARD_DIRECTION_DOWN = 0x04,
};
enum
{
CLEVO_KEYBOARD_REACTIVE_KEYPRESS = 0x00,
CLEVO_KEYBOARD_REACTIVE_AUTO = 0x01,
};
class ClevoKeyboardController
{
public:
ClevoKeyboardController(hid_device* dev_handle, const hid_device_info& info);
~ClevoKeyboardController();
std::string GetDeviceLocation();
std::string GetSerialString();
void TurnOff();
void SetMode(unsigned char mode, unsigned char brightness, unsigned char speed, unsigned char behaviour);
void SetModeColor(unsigned char color_idx, unsigned char red, unsigned char green, unsigned char blue);
void SendColors(unsigned char* color_data, unsigned char brightness);
private:
hid_device* dev;
std::string location;
void WriteControl(unsigned char* data);
void WriteRowData(unsigned char* data);
};

43
Controllers/ClevoKeyboardController/ClevoKeyboardControllerDetect.cpp Normal file
View File

@@ -0,0 +1,43 @@
/*---------------------------------------------------------*\
| ClevoKeyboardControllerDetect.cpp |
| |
| Detector for Clevo per-key RGB keyboard (ITE 8291) |
| |
| Kyle Cascade (kyle@cascade.family) 16 Jan 2026 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include "Detector.h"
#include "ClevoKeyboardController.h"
#include "RGBController_ClevoKeyboard.h"
#include "RGBController.h"
#include <hidapi.h>
/*-----------------------------------------------------*\
| ITE Tech vendor ID |
\*-----------------------------------------------------*/
#define ITE_VID 0x048D
/*-----------------------------------------------------*\
| Clevo Keyboard product IDs |
| These are ITE 8291 per-key RGB keyboard controllers |
\*-----------------------------------------------------*/
#define CLEVO_KEYBOARD_PID_600B 0x600B
void DetectClevoKeyboardControllers(hid_device_info* info, const std::string& name)
{
hid_device* dev = hid_open_path(info->path);
if(dev)
{
ClevoKeyboardController* controller = new ClevoKeyboardController(dev, *info);
RGBController_ClevoKeyboard* rgb_controller = new RGBController_ClevoKeyboard(controller);
rgb_controller->name = name;
ResourceManager::get()->RegisterRGBController(rgb_controller);
}
}
REGISTER_HID_DETECTOR_PU("Clevo Keyboard", DetectClevoKeyboardControllers, 0x048D, 0x600B, 0xFF03, 0x01);

520
Controllers/ClevoKeyboardController/RGBController_ClevoKeyboard.cpp Normal file
View File

@@ -0,0 +1,520 @@
/*---------------------------------------------------------*\
| RGBController_ClevoKeyboard.cpp |
| |
| RGBController for Clevo per-key RGB keyboard (ITE 8291) |
| |
| Kyle Cascade (kyle@cascade.family) 16 Jan 2026 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include "RGBController_ClevoKeyboard.h"
#include "RGBControllerKeyNames.h"
/**------------------------------------------------------------------*\
@name CLEVO Keyboard
@category Keyboard
@type USB
@save :x:
@direct :white_check_mark:
@effects :white_check_mark:
@detectors DetectClevoKeyboardControllers
@comment Per-key RGB keyboard on CLEVO laptops using ITE 8291 controller.
\*-------------------------------------------------------------------*/
#define NA 0xFFFFFFFF
/*---------------------------------------------------------*\
| CLEVO Keyboard matrix layout |
| LED indices are stored bottom-to-top in hardware |
| Visual layout maps top-to-bottom for display |
| |
| Visual row 0 = LED row 5 (Esc, F-keys) |
| Visual row 1 = LED row 4 (Number row) |
| Visual row 2 = LED row 3 (QWERTY row) |
| Visual row 3 = LED row 2 (Home row) |
| Visual row 4 = LED row 1 (Z row) |
| Visual row 5 = LED row 0 (Bottom/modifier row) |
| Visual row 6 = Arrow keys (inverted-T bottom) |
\*---------------------------------------------------------*/
static unsigned int matrix_map[7][21] =
{
{ 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, NA }, // Esc, F1-F12, PrtSc, Ins, Del, Home, End, PgUp, PgDn
{ 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 98, 98, NA, 99, 100, 101, 102, NA }, // `, 1-0, -, =, Bksp (2-wide), NumLock, /, *, -
{ 63, NA, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, NA, 78, 79, 80, 81, NA }, // Tab, Q-], Enter, Num 7-9, +
{ 42, NA, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 77, NA, 57, 58, 59, NA, NA }, // Caps, A-\, Enter (2-high), Num 4-6
{ 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 35, 35, 35, NA, NA, 36, 37, 38, 39, NA }, // LShift, \, Z-./, RShift (3-wide), Num 1-3, NumEnter
{ 0, 2, 3, 4, NA, NA, 7, NA, 10, 12, 12, NA, NA, 14, NA, NA, 16, NA, 17, NA, NA }, // Ctrl, Fn, Super, Alt, Space, AltGr, RCtrl (2-wide), Up, Num0, NumDel
{ NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, 13, 18, 15, NA, NA, NA, NA, NA, NA }, // Left, Down, Right (inverted-T bottom)
};
static const char* key_names[] =
{
// Row 0 (LED indices 0-20) - Bottom row
KEY_EN_LEFT_CONTROL, // 0
KEY_EN_UNUSED, // 1
KEY_EN_LEFT_FUNCTION, // 2
KEY_EN_LEFT_WINDOWS, // 3
KEY_EN_LEFT_ALT, // 4
KEY_EN_UNUSED, // 5
KEY_EN_UNUSED, // 6
KEY_EN_SPACE, // 7
KEY_EN_UNUSED, // 8
KEY_EN_UNUSED, // 9
KEY_EN_RIGHT_ALT, // 10
KEY_EN_UNUSED, // 11
KEY_EN_RIGHT_CONTROL, // 12
KEY_EN_LEFT_ARROW, // 13
KEY_EN_UP_ARROW, // 14
KEY_EN_RIGHT_ARROW, // 15
KEY_EN_NUMPAD_0, // 16
KEY_EN_NUMPAD_PERIOD, // 17
KEY_EN_DOWN_ARROW, // 18
KEY_EN_UNUSED, // 19
KEY_EN_UNUSED, // 20
// Row 1 (LED indices 21-41) - Z row
KEY_EN_UNUSED, // 21
KEY_EN_LEFT_SHIFT, // 22
KEY_EN_ISO_BACK_SLASH, // 23
KEY_EN_Z, // 24
KEY_EN_X, // 25
KEY_EN_C, // 26
KEY_EN_V, // 27
KEY_EN_B, // 28
KEY_EN_N, // 29
KEY_EN_M, // 30
KEY_EN_COMMA, // 31
KEY_EN_PERIOD, // 32
KEY_EN_FORWARD_SLASH, // 33
KEY_EN_UNUSED, // 34
KEY_EN_RIGHT_SHIFT, // 35
KEY_EN_NUMPAD_1, // 36
KEY_EN_NUMPAD_2, // 37
KEY_EN_NUMPAD_3, // 38
KEY_EN_NUMPAD_ENTER, // 39
KEY_EN_UNUSED, // 40
KEY_EN_UNUSED, // 41
// Row 2 (LED indices 42-62) - Home row
KEY_EN_CAPS_LOCK, // 42
KEY_EN_UNUSED, // 43
KEY_EN_A, // 44
KEY_EN_S, // 45
KEY_EN_D, // 46
KEY_EN_F, // 47
KEY_EN_G, // 48
KEY_EN_H, // 49
KEY_EN_J, // 50
KEY_EN_K, // 51
KEY_EN_L, // 52
KEY_EN_SEMICOLON, // 53
KEY_EN_QUOTE, // 54
KEY_EN_ANSI_BACK_SLASH, // 55
KEY_EN_UNUSED, // 56
KEY_EN_NUMPAD_4, // 57
KEY_EN_NUMPAD_5, // 58
KEY_EN_NUMPAD_6, // 59
KEY_EN_UNUSED, // 60
KEY_EN_UNUSED, // 61
KEY_EN_UNUSED, // 62
// Row 3 (LED indices 63-83) - QWERTY row
KEY_EN_TAB, // 63
KEY_EN_UNUSED, // 64
KEY_EN_Q, // 65
KEY_EN_W, // 66
KEY_EN_E, // 67
KEY_EN_R, // 68
KEY_EN_T, // 69
KEY_EN_Y, // 70
KEY_EN_U, // 71
KEY_EN_I, // 72
KEY_EN_O, // 73
KEY_EN_P, // 74
KEY_EN_LEFT_BRACKET, // 75
KEY_EN_RIGHT_BRACKET, // 76
KEY_EN_ANSI_ENTER, // 77
KEY_EN_NUMPAD_7, // 78
KEY_EN_NUMPAD_8, // 79
KEY_EN_NUMPAD_9, // 80
KEY_EN_NUMPAD_PLUS, // 81
KEY_EN_UNUSED, // 82
KEY_EN_UNUSED, // 83
// Row 4 (LED indices 84-104) - Number row
KEY_EN_BACK_TICK, // 84
KEY_EN_1, // 85
KEY_EN_2, // 86
KEY_EN_3, // 87
KEY_EN_4, // 88
KEY_EN_5, // 89
KEY_EN_6, // 90
KEY_EN_7, // 91
KEY_EN_8, // 92
KEY_EN_9, // 93
KEY_EN_0, // 94
KEY_EN_MINUS, // 95
KEY_EN_EQUALS, // 96
KEY_EN_UNUSED, // 97
KEY_EN_BACKSPACE, // 98
KEY_EN_NUMPAD_LOCK, // 99
KEY_EN_NUMPAD_DIVIDE, // 100
KEY_EN_NUMPAD_TIMES, // 101
KEY_EN_NUMPAD_MINUS, // 102
KEY_EN_UNUSED, // 103
KEY_EN_UNUSED, // 104
// Row 5 (LED indices 105-125) - Function row
KEY_EN_ESCAPE, // 105
KEY_EN_F1, // 106
KEY_EN_F2, // 107
KEY_EN_F3, // 108
KEY_EN_F4, // 109
KEY_EN_F5, // 110
KEY_EN_F6, // 111
KEY_EN_F7, // 112
KEY_EN_F8, // 113
KEY_EN_F9, // 114
KEY_EN_F10, // 115
KEY_EN_F11, // 116
KEY_EN_F12, // 117
KEY_EN_PRINT_SCREEN, // 118
KEY_EN_INSERT, // 119
KEY_EN_DELETE, // 120
KEY_EN_HOME, // 121
KEY_EN_END, // 122
KEY_EN_PAGE_UP, // 123
KEY_EN_PAGE_DOWN, // 124
KEY_EN_UNUSED, // 125
};
RGBController_ClevoKeyboard::RGBController_ClevoKeyboard(ClevoKeyboardController* controller_ptr)
{
controller = controller_ptr;
name = "CLEVO Keyboard";
vendor = "CLEVO Computers";
type = DEVICE_TYPE_KEYBOARD;
description = "CLEVO Laptop Keyboard";
location = controller->GetDeviceLocation();
serial = controller->GetSerialString();
mode Direct;
Direct.name = "Direct";
Direct.value = CLEVO_KEYBOARD_MODE_DIRECT;
Direct.flags = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
Direct.brightness_min = CLEVO_KEYBOARD_BRIGHTNESS_MIN;
Direct.brightness_max = CLEVO_KEYBOARD_BRIGHTNESS_MAX;
Direct.brightness = CLEVO_KEYBOARD_BRIGHTNESS_MAX;
Direct.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Direct);
mode Rainbow;
Rainbow.name = "Rainbow";
Rainbow.value = CLEVO_KEYBOARD_MODE_RAINBOW;
Rainbow.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
Rainbow.speed_min = CLEVO_KEYBOARD_SPEED_MAX;
Rainbow.speed_max = CLEVO_KEYBOARD_SPEED_MIN;
Rainbow.speed = 0x05;
Rainbow.brightness_min = CLEVO_KEYBOARD_BRIGHTNESS_MIN;
Rainbow.brightness_max = CLEVO_KEYBOARD_BRIGHTNESS_MAX;
Rainbow.brightness = CLEVO_KEYBOARD_BRIGHTNESS_MAX;
Rainbow.color_mode = MODE_COLORS_NONE;
modes.push_back(Rainbow);
mode Wave;
Wave.name = "Wave";
Wave.value = CLEVO_KEYBOARD_MODE_WAVE;
Wave.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_DIRECTION_UD | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
Wave.speed_min = CLEVO_KEYBOARD_SPEED_MAX;
Wave.speed_max = CLEVO_KEYBOARD_SPEED_MIN;
Wave.speed = 0x05;
Wave.brightness_min = CLEVO_KEYBOARD_BRIGHTNESS_MIN;
Wave.brightness_max = CLEVO_KEYBOARD_BRIGHTNESS_MAX;
Wave.brightness = CLEVO_KEYBOARD_BRIGHTNESS_MAX;
Wave.direction = MODE_DIRECTION_LEFT;
Wave.colors_min = 1;
Wave.colors_max = 1;
Wave.colors.resize(1);
Wave.color_mode = MODE_COLORS_MODE_SPECIFIC;
modes.push_back(Wave);
mode Breathing;
Breathing.name = "Breathing";
Breathing.value = CLEVO_KEYBOARD_MODE_BREATH;
Breathing.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
Breathing.speed_min = CLEVO_KEYBOARD_SPEED_MAX;
Breathing.speed_max = CLEVO_KEYBOARD_SPEED_MIN;
Breathing.speed = 0x05;
Breathing.brightness_min = CLEVO_KEYBOARD_BRIGHTNESS_MIN;
Breathing.brightness_max = CLEVO_KEYBOARD_BRIGHTNESS_MAX;
Breathing.brightness = CLEVO_KEYBOARD_BRIGHTNESS_MAX;
Breathing.colors_min = 1;
Breathing.colors_max = 1;
Breathing.colors.resize(1);
Breathing.color_mode = MODE_COLORS_MODE_SPECIFIC;
modes.push_back(Breathing);
mode Reactive;
Reactive.name = "Reactive";
Reactive.value = CLEVO_KEYBOARD_MODE_REACTIVE;
Reactive.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
Reactive.speed_min = CLEVO_KEYBOARD_SPEED_MAX;
Reactive.speed_max = CLEVO_KEYBOARD_SPEED_MIN;
Reactive.speed = 0x05;
Reactive.brightness_min = CLEVO_KEYBOARD_BRIGHTNESS_MIN;
Reactive.brightness_max = CLEVO_KEYBOARD_BRIGHTNESS_MAX;
Reactive.brightness = CLEVO_KEYBOARD_BRIGHTNESS_MAX;
Reactive.colors_min = 1;
Reactive.colors_max = 1;
Reactive.colors.resize(1);
Reactive.color_mode = MODE_COLORS_MODE_SPECIFIC;
modes.push_back(Reactive);
mode Ripple;
Ripple.name = "Ripple";
Ripple.value = CLEVO_KEYBOARD_MODE_RIPPLE;
Ripple.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
Ripple.speed_min = CLEVO_KEYBOARD_SPEED_MAX;
Ripple.speed_max = CLEVO_KEYBOARD_SPEED_MIN;
Ripple.speed = 0x05;
Ripple.brightness_min = CLEVO_KEYBOARD_BRIGHTNESS_MIN;
Ripple.brightness_max = CLEVO_KEYBOARD_BRIGHTNESS_MAX;
Ripple.brightness = CLEVO_KEYBOARD_BRIGHTNESS_MAX;
Ripple.colors_min = 1;
Ripple.colors_max = 1;
Ripple.colors.resize(1);
Ripple.color_mode = MODE_COLORS_MODE_SPECIFIC;
modes.push_back(Ripple);
mode Marquee;
Marquee.name = "Marquee";
Marquee.value = CLEVO_KEYBOARD_MODE_MARQUEE;
Marquee.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
Marquee.speed_min = CLEVO_KEYBOARD_SPEED_MAX;
Marquee.speed_max = CLEVO_KEYBOARD_SPEED_MIN;
Marquee.speed = 0x05;
Marquee.brightness_min = CLEVO_KEYBOARD_BRIGHTNESS_MIN;
Marquee.brightness_max = CLEVO_KEYBOARD_BRIGHTNESS_MAX;
Marquee.brightness = CLEVO_KEYBOARD_BRIGHTNESS_MAX;
Marquee.colors_min = 1;
Marquee.colors_max = 1;
Marquee.colors.resize(1);
Marquee.color_mode = MODE_COLORS_MODE_SPECIFIC;
modes.push_back(Marquee);
mode Raindrop;
Raindrop.name = "Raindrop";
Raindrop.value = CLEVO_KEYBOARD_MODE_RAINDROP;
Raindrop.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
Raindrop.speed_min = CLEVO_KEYBOARD_SPEED_MAX;
Raindrop.speed_max = CLEVO_KEYBOARD_SPEED_MIN;
Raindrop.speed = 0x05;
Raindrop.brightness_min = CLEVO_KEYBOARD_BRIGHTNESS_MIN;
Raindrop.brightness_max = CLEVO_KEYBOARD_BRIGHTNESS_MAX;
Raindrop.brightness = CLEVO_KEYBOARD_BRIGHTNESS_MAX;
Raindrop.colors_min = 1;
Raindrop.colors_max = 1;
Raindrop.colors.resize(1);
Raindrop.color_mode = MODE_COLORS_MODE_SPECIFIC;
modes.push_back(Raindrop);
mode Aurora;
Aurora.name = "Aurora";
Aurora.value = CLEVO_KEYBOARD_MODE_AURORA;
Aurora.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
Aurora.speed_min = CLEVO_KEYBOARD_SPEED_MAX;
Aurora.speed_max = CLEVO_KEYBOARD_SPEED_MIN;
Aurora.speed = 0x05;
Aurora.brightness_min = CLEVO_KEYBOARD_BRIGHTNESS_MIN;
Aurora.brightness_max = CLEVO_KEYBOARD_BRIGHTNESS_MAX;
Aurora.brightness = CLEVO_KEYBOARD_BRIGHTNESS_MAX;
Aurora.colors_min = 1;
Aurora.colors_max = 1;
Aurora.colors.resize(1);
Aurora.color_mode = MODE_COLORS_MODE_SPECIFIC;
modes.push_back(Aurora);
mode Spark;
Spark.name = "Spark";
Spark.value = CLEVO_KEYBOARD_MODE_SPARK;
Spark.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
Spark.speed_min = CLEVO_KEYBOARD_SPEED_MAX;
Spark.speed_max = CLEVO_KEYBOARD_SPEED_MIN;
Spark.speed = 0x05;
Spark.brightness_min = CLEVO_KEYBOARD_BRIGHTNESS_MIN;
Spark.brightness_max = CLEVO_KEYBOARD_BRIGHTNESS_MAX;
Spark.brightness = CLEVO_KEYBOARD_BRIGHTNESS_MAX;
Spark.colors_min = 1;
Spark.colors_max = 1;
Spark.colors.resize(1);
Spark.color_mode = MODE_COLORS_MODE_SPECIFIC;
modes.push_back(Spark);
mode Off;
Off.name = "Off";
Off.value = 0xFF;
Off.flags = 0;
Off.color_mode = MODE_COLORS_NONE;
modes.push_back(Off);
SetupZones();
}
RGBController_ClevoKeyboard::~RGBController_ClevoKeyboard()
{
for(unsigned int zone_idx = 0; zone_idx < zones.size(); zone_idx++)
{
if(zones[zone_idx].matrix_map != nullptr)
{
delete[] zones[zone_idx].matrix_map->map;
delete zones[zone_idx].matrix_map;
}
}
delete controller;
}
void RGBController_ClevoKeyboard::SetupZones()
{
/*---------------------------------------------------------*\
| Create a matrix zone for the keyboard |
\*---------------------------------------------------------*/
zone keyboard_zone;
keyboard_zone.name = ZONE_EN_KEYBOARD;
keyboard_zone.type = ZONE_TYPE_MATRIX;
keyboard_zone.leds_min = CLEVO_KEYBOARD_NUM_LEDS;
keyboard_zone.leds_max = CLEVO_KEYBOARD_NUM_LEDS;
keyboard_zone.leds_count = CLEVO_KEYBOARD_NUM_LEDS;
keyboard_zone.matrix_map = new matrix_map_type;
keyboard_zone.matrix_map->height = 7;
keyboard_zone.matrix_map->width = 21;
keyboard_zone.matrix_map->map = new unsigned int[7 * 21];
for(int row = 0; row < 7; row++)
{
for(int col = 0; col < 21; col++)
{
keyboard_zone.matrix_map->map[row * 21 + col] = matrix_map[row][col];
}
}
zones.push_back(keyboard_zone);
/*---------------------------------------------------------*\
| Create LEDs with proper key names |
\*---------------------------------------------------------*/
for(int i = 0; i < CLEVO_KEYBOARD_NUM_LEDS; i++)
{
led new_led;
new_led.name = key_names[i];
leds.push_back(new_led);
}
SetupColors();
}
void RGBController_ClevoKeyboard::ResizeZone(int /*zone*/, int /*new_size*/)
{
/*---------------------------------------------------------*\
| This device does not support resizing zones |
\*---------------------------------------------------------*/
}
void RGBController_ClevoKeyboard::DeviceUpdateLEDs()
{
/*---------------------------------------------------------*\
| Build color data array and send to device |
\*---------------------------------------------------------*/
unsigned char color_data[CLEVO_KEYBOARD_NUM_LEDS * 3];
for(int i = 0; i < CLEVO_KEYBOARD_NUM_LEDS; i++)
{
color_data[i * 3 + 0] = RGBGetRValue(colors[i]);
color_data[i * 3 + 1] = RGBGetGValue(colors[i]);
color_data[i * 3 + 2] = RGBGetBValue(colors[i]);
}
controller->SendColors(color_data, modes[active_mode].brightness);
}
void RGBController_ClevoKeyboard::UpdateZoneLEDs(int /*zone*/)
{
DeviceUpdateLEDs();
}
void RGBController_ClevoKeyboard::UpdateSingleLED(int /*led*/)
{
DeviceUpdateLEDs();
}
void RGBController_ClevoKeyboard::DeviceUpdateMode()
{
unsigned char mode_value = modes[active_mode].value;
/*---------------------------------------------------------*\
| Handle Off mode |
\*---------------------------------------------------------*/
if(mode_value == 0xFF)
{
controller->TurnOff();
return;
}
/*---------------------------------------------------------*\
| Handle Direct (per-key) mode |
\*---------------------------------------------------------*/
if(mode_value == CLEVO_KEYBOARD_MODE_DIRECT)
{
DeviceUpdateLEDs();
return;
}
/*---------------------------------------------------------*\
| Handle built-in effect modes |
\*---------------------------------------------------------*/
unsigned char brightness = modes[active_mode].brightness;
unsigned char speed = modes[active_mode].speed;
unsigned char behaviour = 0x00;
/*---------------------------------------------------------*\
| Set direction for wave mode |
\*---------------------------------------------------------*/
if(mode_value == CLEVO_KEYBOARD_MODE_WAVE)
{
switch(modes[active_mode].direction)
{
case MODE_DIRECTION_LEFT:
behaviour = CLEVO_KEYBOARD_DIRECTION_LEFT;
break;
case MODE_DIRECTION_RIGHT:
behaviour = CLEVO_KEYBOARD_DIRECTION_RIGHT;
break;
case MODE_DIRECTION_UP:
behaviour = CLEVO_KEYBOARD_DIRECTION_UP;
break;
case MODE_DIRECTION_DOWN:
behaviour = CLEVO_KEYBOARD_DIRECTION_DOWN;
break;
}
}
/*---------------------------------------------------------*\
| Set mode color if applicable |
\*---------------------------------------------------------*/
if(modes[active_mode].colors.size() > 0)
{
unsigned char red = RGBGetRValue(modes[active_mode].colors[0]);
unsigned char green = RGBGetGValue(modes[active_mode].colors[0]);
unsigned char blue = RGBGetBValue(modes[active_mode].colors[0]);
controller->SetModeColor(1, red, green, blue);
}
controller->SetMode(mode_value, brightness, speed, behaviour);
}

35
Controllers/ClevoKeyboardController/RGBController_ClevoKeyboard.h Normal file
View File

@@ -0,0 +1,35 @@
/*---------------------------------------------------------*\
| RGBController_ClevoKeyboard.h |
| |
| RGBController for Clevo per-key RGB keyboard (ITE 8291) |
| |
| Kyle Cascade (kyle@cascade.family) 16 Jan 2026 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#pragma once
#include "RGBController.h"
#include "ClevoKeyboardController.h"
class RGBController_ClevoKeyboard : public RGBController
{
public:
RGBController_ClevoKeyboard(ClevoKeyboardController* controller_ptr);
~RGBController_ClevoKeyboard();
void SetupZones();
void ResizeZone(int zone, int new_size);
void DeviceUpdateLEDs();
void UpdateZoneLEDs(int zone);
void UpdateSingleLED(int led);
void DeviceUpdateMode();
private:
ClevoKeyboardController* controller;
};