Jens/LumaOps-Public
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Publish LumaOps source

Browse Source
This commit is contained in:
LumaOps release export
2026-09-03 01:18:36 +02:00
commit 7f1c0e5f71
2363 changed files with 501543 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Controllers/EVisionKeyboardController/EVisionKeyboardController.cpp
+268
View File
@@ -0,0 +1,268 @@
/*---------------------------------------------------------*\
| EVisionKeyboardController.cpp |
| |
| Driver for EVision keyboard (Redragon, Glorious, Ajazz, |
| Tecware, and many other brands) |
| |
| Adam Honse (CalcProgrammer1) 15 Mar 2020 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include <cstring>
#include "EVisionKeyboardController.h"
#include "StringUtils.h"
EVisionKeyboardController::EVisionKeyboardController(hid_device* dev_handle, const char* path, std::string dev_name)
{
dev = dev_handle;
location = path;
name = dev_name;
}
EVisionKeyboardController::~EVisionKeyboardController()
{
hid_close(dev);
}
std::string EVisionKeyboardController::GetDeviceLocation()
{
return("HID: " + location);
}
std::string EVisionKeyboardController::GetNameString()
{
return(name);
}
std::string EVisionKeyboardController::GetSerialString()
{
wchar_t serial_string[128];
int ret = hid_get_serial_number_string(dev, serial_string, 128);
if(ret != 0)
{
return("");
}
return(StringUtils::wstring_to_string(serial_string));
}
void EVisionKeyboardController::SetKeyboardColors
(
unsigned char * color_data,
unsigned int size
)
{
unsigned int packet_size = 0;
unsigned int packet_offset = 0;
while(size > 0)
{
if(size >= EVISION_KB_MAX_PACKET_SIZE)
{
packet_size = EVISION_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 EVisionKeyboardController::SendKeyboardMode
(
unsigned char mode
)
{
SendKeyboardParameter(EVISION_KB_PARAMETER_MODE, 1, &mode);
}
void EVisionKeyboardController::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 EVisionKeyboardController::ComputeChecksum
(
char usb_buf[64]
)
{
unsigned short checksum = 0;
for(unsigned int byte_idx = 0x03; byte_idx < 64; byte_idx++)
{
checksum += usb_buf[byte_idx];
}
usb_buf[0x01] = checksum & 0xFF;
usb_buf[0x02] = checksum >> 8;
}
void EVisionKeyboardController::SendKeyboardBegin()
{
char usb_buf[64];
/*-----------------------------------------------------*\
| 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] = EVISION_KB_COMMAND_BEGIN;
usb_buf[0x02] = 0x00;
usb_buf[0x03] = EVISION_KB_COMMAND_BEGIN;
/*-----------------------------------------------------*\
| Send packet |
\*-----------------------------------------------------*/
hid_write(dev, (unsigned char *)usb_buf, 64);
hid_read(dev, (unsigned char *)usb_buf, 64);
}
void EVisionKeyboardController::SendKeyboardEnd()
{
char usb_buf[64];
/*-----------------------------------------------------*\
| 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] = EVISION_KB_COMMAND_END;
usb_buf[0x02] = 0x00;
usb_buf[0x03] = EVISION_KB_COMMAND_END;
/*-----------------------------------------------------*\
| Send packet |
\*-----------------------------------------------------*/
hid_write(dev, (unsigned char *)usb_buf, 64);
hid_read(dev, (unsigned char *)usb_buf, 64);
}
void EVisionKeyboardController::SendKeyboardData
(
unsigned char * data,
unsigned char data_size,
unsigned short data_offset
)
{
char usb_buf[64];
/*-----------------------------------------------------*\
| Zero out buffer |
\*-----------------------------------------------------*/
memset(usb_buf, 0x00, sizeof(usb_buf));
/*-----------------------------------------------------*\
| Set up Keyboard Color Data (0x11) packet |
\*-----------------------------------------------------*/
usb_buf[0x00] = 0x04;
usb_buf[0x03] = 0x11;
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, 64);
hid_read(dev, (unsigned char *)usb_buf, 64);
}
void EVisionKeyboardController::SendKeyboardParameter
(
unsigned char parameter,
unsigned char parameter_size,
unsigned char* parameter_data
)
{
char usb_buf[64];
/*-----------------------------------------------------*\
| Zero out buffer |
\*-----------------------------------------------------*/
memset(usb_buf, 0x00, sizeof(usb_buf));
/*-----------------------------------------------------*\
| Set up Keyboard Parameter (0x06) packet |
\*-----------------------------------------------------*/
usb_buf[0x00] = 0x04;
usb_buf[0x03] = EVISION_KB_COMMAND_SET_PARAMETER;
usb_buf[0x04] = parameter_size;
usb_buf[0x05] = parameter;
/*-----------------------------------------------------*\
| Copy in data bytes |
\*-----------------------------------------------------*/
memcpy(&usb_buf[0x08], parameter_data, parameter_size);
/*-----------------------------------------------------*\
| Compute Checksum |
\*-----------------------------------------------------*/
ComputeChecksum(usb_buf);
/*-----------------------------------------------------*\
| Send packet |
\*-----------------------------------------------------*/
hid_write(dev, (unsigned char *)usb_buf, 64);
hid_read(dev, (unsigned char *)usb_buf, 64);
}
Controllers/EVisionKeyboardController/EVisionKeyboardController.h
+154
View File
@@ -0,0 +1,154 @@
/*---------------------------------------------------------*\
| EVisionKeyboardController.h |
| |
| Driver for EVision keyboard (Redragon, Glorious, Ajazz, |
| Tecware, and many other brands) |
| |
| Adam Honse (CalcProgrammer1) 15 Mar 2020 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#pragma once
#include <string>
#include <hidapi.h>
#include "RGBController.h"
#define EVISION_KB_MAX_PACKET_SIZE ( 0x36 )/* max packet size for color*/
/* update packets */
enum
{
EVISION_KB_COMMAND_BEGIN = 0x01, /* Begin packet command */
EVISION_KB_COMMAND_END = 0x02, /* End packet command */
EVISION_KB_COMMAND_SET_PARAMETER = 0x06, /* Set parameter command */
EVISION_KB_COMMAND_READ_CUSTOM_COLOR_DATA = 0x10, /* Read custom color data */
EVISION_KB_COMMAND_WRITE_CUSTOM_COLOR_DATA = 0x11, /* Write custom color data */
};
enum
{
EVISION_KB_PARAMETER_MODE = 0x00, /* Mode parameter */
EVISION_KB_PARAMETER_BRIGHTNESS = 0x01, /* Brightness parameter */
EVISION_KB_PARAMETER_SPEED = 0x02, /* Speed parameter */
EVISION_KB_PARAMETER_DIRECTION = 0x03, /* Direction parameter */
EVISION_KB_PARAMETER_RANDOM_COLOR_FLAG = 0x04, /* Random color parameter */
EVISION_KB_PARAMETER_MODE_COLOR = 0x05, /* Mode color (RGB) */
EVISION_KB_PARAMETER_POLLING_RATE = 0x0F, /* Polling rate */
EVISION_KB_PARAMETER_SURMOUNT_MODE_COLOR = 0x11, /* Surmount mode color */
};
enum
{
EVISION_KB_MODE_COLOR_WAVE_SHORT = 0x01, /* "Go with the stream" */
EVISION_KB_MODE_COLOR_WAVE_LONG = 0x02, /* "Clouds fly" */
EVISION_KB_MODE_COLOR_WHEEL = 0x03, /* "Winding paths" */
EVISION_KB_MODE_SPECTRUM_CYCLE = 0x04, /* "The trial of light" */
EVISION_KB_MODE_BREATHING = 0x05, /* "Breathing" */
EVISION_KB_MODE_STATIC = 0x06, /* "Normally on" */
EVISION_KB_MODE_REACTIVE = 0x07, /* "Pass without trace" */
EVISION_KB_MODE_REACTIVE_RIPPLE = 0x08, /* "Ripple graff" */
EVISION_KB_MODE_REACTIVE_LINE = 0x09, /* "Fast run without trace" */
EVISION_KB_MODE_STARLIGHT_FAST = 0x0A, /* "Swift action" */
EVISION_KB_MODE_BLOOMING = 0x0B, /* "Flowers blooming" */
EVISION_KB_MODE_RAINBOW_WAVE_VERTICAL = 0x0C, /* "Snow winter jasmine" */
EVISION_KB_MODE_HURRICANE = 0x0D, /* "Hurricane" */
EVISION_KB_MODE_ACCUMULATE = 0x0E, /* "Accumulate" */
EVISION_KB_MODE_STARLIGHT_SLOW = 0x0F, /* "Digital times" */
EVISION_KB_MODE_VISOR = 0x10, /* "Both ways" */
EVISION_KB_MODE_SURMOUNT = 0x11, /* "Surmount" */
EVISION_KB_MODE_RAINBOW_WAVE_CIRCLE = 0x12, /* "Fast and the Furious" */
EVISION_KB_MODE_CUSTOM = 0x14, /* "Coastal" */
};
enum
{
EVISION_KB_BRIGHTNESS_LOWEST = 0x00, /* Lowest brightness (off) */
EVISION_KB_BRIGHTNESS_HIGHEST = 0x04, /* Highest brightness */
};
enum
{
EVISION_KB_SPEED_SLOWEST = 0x05, /* Slowest speed setting */
EVISION_KB_SPEED_NORMAL = 0x03, /* Normal speed setting */
EVISION_KB_SPEED_FASTEST = 0x00, /* Fastest speed setting */
};
enum
{
EVISION_KB_SURMOUNT_MODE_COLOR_RED = 0x01, /* Red surmount color */
EVISION_KB_SURMOUNT_MODE_COLOR_YELLOW = 0x02, /* Yellow surmount color */
EVISION_KB_SURMOUNT_MODE_COLOR_GREEN = 0x03, /* Green surmount color */
EVISION_KB_SURMOUNT_MODE_COLOR_BLUE = 0x04, /* Blue surmount color */
};
enum
{
EVISION_KB_POLLING_RATE_125HZ = 0x00, /* 125Hz polling rate */
EVISION_KB_POLLING_RATE_250HZ = 0x01, /* 250Hz polling rate */
EVISION_KB_POLLING_RATE_500HZ = 0x02, /* 500Hz polling rate */
EVISION_KB_POLLING_RATE_1000HZ = 0x03, /* 1000Hz polling rate */
};
class EVisionKeyboardController
{
public:
EVisionKeyboardController(hid_device* dev_handle, const char* path, std::string dev_name);
~EVisionKeyboardController();
std::string GetDeviceLocation();
std::string GetNameString();
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;
std::string name;
void ComputeChecksum
(
char usb_buf[64]
);
void SendKeyboardParameter
(
unsigned char parameter,
unsigned char parameter_size,
unsigned char* parameter_data
);
};
Controllers/EVisionKeyboardController/EVisionKeyboardControllerDetect.cpp
+125
View File
@@ -0,0 +1,125 @@
/*---------------------------------------------------------*\
| EVisionKeyboardControllerDetect.cpp |
| |
| Detector for EVision keyboards |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include <hidapi.h>
#include "Detector.h"
#include "EVisionKeyboardController.h"
#include "EVisionV2KeyboardController.h"
#include "RGBController_EVisionKeyboard.h"
#include "RGBController_EVisionV2Keyboard.h"
#include "SettingsManager.h"
/*-----------------------------------------------------*\
| Keyboard product IDs |
\*-----------------------------------------------------*/
#define EVISION_KEYBOARD_VID 0x0C45
#define EVISION_KEYBOARD2_VID 0x320F
#define EVISION_KEYBOARD3_VID 0x3299
#define EVISION_KEYBOARD_USAGE_PAGE 0xFF1C
#define ENDORFY_OMNIS_PID 0x0012
#define DEXP_BLAZE_PID 0x5084
#define GLORIOUS_GMMK_TKL_PID 0x5064
#define REDRAGON_K550_PID 0x5204
#define MARS_GAMING_MKMINI_PID 0x5078
#define SKILLKORP_K5_PID 0x505B
#define REDRAGON_K552_PID 0x5104
#define REDRAGON_K552_V2_PID 0x5000
#define REDRAGON_K556_PID 0x5004
#define TECWARE_PHANTOM_ELITE_PID 0x652F
#define WARRIOR_KANE_TC235 0x8520
#define WOMIER_K87_PID 0x502A
#define WOMIER_K66_PID 0x7698
#define BYGG_CSB_ICL01_PID 0x5041
#define GAMEPOWER_OGRE_RGB_PID 0x7672
/******************************************************************************************\
* *
* DetectEVisionKeyboards *
* *
* Tests the USB address to see if an EVision RGB Keyboard controller exists there. *
* *
\******************************************************************************************/
void DetectEVisionKeyboards(hid_device_info* info, const std::string& name)
{
hid_device* dev = hid_open_path(info->path);
if(dev)
{
EVisionKeyboardController* controller = new EVisionKeyboardController(dev, info->path, name);
RGBController_EVisionKeyboard* rgb_controller = new RGBController_EVisionKeyboard(controller);
ResourceManager::get()->RegisterRGBController(rgb_controller);
}
}
void DetectEVisionV2Keyboards(hid_device_info* info, const std::string& name)
{
json settings = ResourceManager::get()->GetSettingsManager()->GetSettings("EVision2Settings");
hid_device* dev = hid_open_path(info->path);
if(dev)
{
EVisionV2KeyboardController* controller = new EVisionV2KeyboardController(dev, info->path, EVISION_V2_KEYBOARD_LAYOUT, name);
RGBController_EVisionV2Keyboard* rgb_controller = new RGBController_EVisionV2Keyboard(controller, EVISION_V2_KEYBOARD_PART_KEYBOARD);
ResourceManager::get()->RegisterRGBController(rgb_controller);
if(!settings.contains("AdditionalZones") || settings["AdditionalZones"] == true)
{
rgb_controller = new RGBController_EVisionV2Keyboard(controller, EVISION_V2_KEYBOARD_PART_LOGO);
ResourceManager::get()->RegisterRGBController(rgb_controller);
rgb_controller = new RGBController_EVisionV2Keyboard(controller, EVISION_V2_KEYBOARD_PART_EDGE);
ResourceManager::get()->RegisterRGBController(rgb_controller);
}
}
}
void DetectEndorfyKeyboards(hid_device_info* info, const std::string& name)
{
json settings = ResourceManager::get()->GetSettingsManager()->GetSettings("EndorfySettings");
hid_device* dev = hid_open_path(info->path);
if(dev)
{
EVisionV2KeyboardController* controller = new EVisionV2KeyboardController(dev, info->path, ENDORFY_KEYBOARD_LAYOUT, name);
RGBController_EVisionV2Keyboard* rgb_controller = new RGBController_EVisionV2Keyboard(controller, EVISION_V2_KEYBOARD_PART_KEYBOARD);
ResourceManager::get()->RegisterRGBController(rgb_controller);
if(!settings.contains("AdditionalZones") || settings["AdditionalZones"] == true)
{
rgb_controller = new RGBController_EVisionV2Keyboard(controller, ENDORFY_KEYBOARD_PART_EDGE);
ResourceManager::get()->RegisterRGBController(rgb_controller);
}
}
}
/*---------------------------------------------------------------------------------------------------------------------------------------------*\
| Keyboards |
\*---------------------------------------------------------------------------------------------------------------------------------------------*/
REGISTER_HID_DETECTOR_IP("EVision Keyboard 320F:5078", DetectEVisionKeyboards, EVISION_KEYBOARD2_VID, MARS_GAMING_MKMINI_PID, 1, EVISION_KEYBOARD_USAGE_PAGE);
REGISTER_HID_DETECTOR_IP("EVision Keyboard 0C45:5204", DetectEVisionKeyboards, EVISION_KEYBOARD_VID, REDRAGON_K550_PID, 1, EVISION_KEYBOARD_USAGE_PAGE);
REGISTER_HID_DETECTOR_IP("EVision Keyboard 0C45:5104", DetectEVisionKeyboards, EVISION_KEYBOARD_VID, REDRAGON_K552_PID, 1, EVISION_KEYBOARD_USAGE_PAGE);
REGISTER_HID_DETECTOR_IP("EVision Keyboard 320F:5000", DetectEVisionKeyboards, EVISION_KEYBOARD2_VID, REDRAGON_K552_V2_PID, 1, EVISION_KEYBOARD_USAGE_PAGE);
REGISTER_HID_DETECTOR_IP("EVision Keyboard 0C45:5004", DetectEVisionKeyboards, EVISION_KEYBOARD_VID, REDRAGON_K556_PID, 1, EVISION_KEYBOARD_USAGE_PAGE);
REGISTER_HID_DETECTOR_IP("EVision Keyboard 0C45:652F", DetectEVisionKeyboards, EVISION_KEYBOARD_VID, TECWARE_PHANTOM_ELITE_PID, 1, EVISION_KEYBOARD_USAGE_PAGE);
REGISTER_HID_DETECTOR_IP("EVision Keyboard 0C45:8520", DetectEVisionKeyboards, EVISION_KEYBOARD_VID, WARRIOR_KANE_TC235, 1, EVISION_KEYBOARD_USAGE_PAGE);
REGISTER_HID_DETECTOR_IP("EVision Keyboard 320F:502A", DetectEVisionKeyboards, EVISION_KEYBOARD2_VID, WOMIER_K87_PID, 1, EVISION_KEYBOARD_USAGE_PAGE);
REGISTER_HID_DETECTOR_IP("EVision Keyboard 0C45:7698", DetectEVisionKeyboards, EVISION_KEYBOARD_VID, WOMIER_K66_PID, 1, EVISION_KEYBOARD_USAGE_PAGE);
REGISTER_HID_DETECTOR_IP("EVision Keyboard 320F:5064", DetectEVisionKeyboards, EVISION_KEYBOARD2_VID, GLORIOUS_GMMK_TKL_PID, 1, EVISION_KEYBOARD_USAGE_PAGE);
REGISTER_HID_DETECTOR_IP("EVision Keyboard 320F:5084", DetectEVisionKeyboards, EVISION_KEYBOARD2_VID, DEXP_BLAZE_PID, 1, EVISION_KEYBOARD_USAGE_PAGE);
REGISTER_HID_DETECTOR_IP("EVision Keyboard 320F:505B", DetectEVisionKeyboards, EVISION_KEYBOARD2_VID, SKILLKORP_K5_PID, 1, EVISION_KEYBOARD_USAGE_PAGE);
REGISTER_HID_DETECTOR_IP("Endorfy Omnis", DetectEndorfyKeyboards, EVISION_KEYBOARD3_VID, ENDORFY_OMNIS_PID, 1, EVISION_KEYBOARD_USAGE_PAGE);
REGISTER_HID_DETECTOR_IP("CSB/ICL01 Keyboard", DetectEVisionV2Keyboards, EVISION_KEYBOARD2_VID, BYGG_CSB_ICL01_PID, 1, EVISION_KEYBOARD_USAGE_PAGE);
REGISTER_HID_DETECTOR_IP("Gamepower Ogre RGB 0C45:7672", DetectEVisionKeyboards, EVISION_KEYBOARD_VID, GAMEPOWER_OGRE_RGB_PID, 1, EVISION_KEYBOARD_USAGE_PAGE);
Controllers/EVisionKeyboardController/EVisionV2KeyboardController.cpp
+465
View File
@@ -0,0 +1,465 @@
/*---------------------------------------------------------*\
| EVisionV2KeyboardController.cpp |
| |
| Driver for EVision V2 keyboard |
| |
| Le Philousophe 25 Dec 2022 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include <cstring>
#include "LogManager.h"
#include "EVisionV2KeyboardController.h"
#include "StringUtils.h"
#define BLANK_SPACE 6
#define query_check_buffer(c) \
do \
{ \
if(!(c)) \
{ \
return -256; \
} \
} while(0)
using namespace std::chrono_literals;
static uint8_t evisionv2_map[EVISION_V2_MATRIX_WIDTH * EVISION_V2_MATRIX_HEIGHT] =
{
/* 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 19 19 20 */
0, 12, 18, 24, 30, 36, 42, 48, 54, 60, 66, 72, 78, 84, 90, 96,
1, 7, 13, 19, 25, 31, 37, 43, 49, 55, 61, 67, 73, 79, 85, 91, 97, 103, 109, 115, 121,
2, 8, 14, 20, 26, 32, 38, 44, 50, 56, 62, 68, 74, 80, 86, 92, 98, 104, 110, 116, 122,
3, 9, 15, 21, 27, 33, 39, 45, 51, 57, 63, 69, 75, 81, 105, 111, 117,
4, 10, 16, 22, 28, 34, 40, 46, 52, 58, 64, 70, 82, 94, 106, 112, 118, 124,
5, 11, 17, 41, 65, 71, 77, 83, 89, 95, 101, 113, 119,
};
static uint8_t endorfy_map[EVISION_V2_MATRIX_WIDTH * EVISION_V2_MATRIX_HEIGHT] =
{
/* 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 19 19 20 */
0, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41,
42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62,
63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 76, 80, 81, 82,
84, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 97, 99, 101, 102, 103, 104,
105, 106, 107, 111, 115, 116, 117, 118, 119, 120, 121, 123, 124,
};
EVisionV2KeyboardController::EVisionV2KeyboardController(hid_device* dev_handle, const char* path, EVisionV2KeyboardLayout dev_layout, std::string dev_name)
{
dev = dev_handle;
location = path;
name = dev_name;
layout = dev_layout;
/*---------------------------------------------------------*\
| Get capabilities and layout |
\*---------------------------------------------------------*/
uint8_t buffer[7];
if(Read(EVISION_V2_CMD_READ_CAPABILITIES, 0, sizeof(buffer), buffer) < 0)
{
return;
}
if(buffer[0] != 0xAA && buffer[1] != 0x55)
{
return;
}
map_size = buffer[5];
macros_size = buffer[6] * 0x80;
switch(layout)
{
case EVISION_V2_KEYBOARD_LAYOUT:
keyvalue_map = evisionv2_map;
led_count = 106;
break;
case ENDORFY_KEYBOARD_LAYOUT:
keyvalue_map = endorfy_map;
led_count = 104;
break;
}
}
EVisionV2KeyboardController::~EVisionV2KeyboardController()
{
hid_close(dev);
}
std::string EVisionV2KeyboardController::GetName()
{
return(name);
}
std::string EVisionV2KeyboardController::GetSerial()
{
wchar_t serial_string[128];
int ret = hid_get_serial_number_string(dev, serial_string, 128);
if(ret != 0)
{
return("");
}
return(StringUtils::wstring_to_string(serial_string));
}
std::string EVisionV2KeyboardController::GetLocation()
{
return("HID: " + location);
}
int EVisionV2KeyboardController::Query(uint8_t cmd, uint16_t offset, const uint8_t* idata, uint8_t size, uint8_t* odata)
{
uint8_t buffer[EVISION_V2_PACKET_SIZE];
memset(buffer, 0, sizeof(buffer));
buffer[0] = EVISION_V2_REPORT_ID;
buffer[3] = cmd;
buffer[4] = size;
buffer[5] = offset & 0xff;
buffer[6] = (offset >> 8) & 0xff;
if(idata)
{
memcpy(buffer + 8, idata, size);
}
uint16_t chksum = 0;
for(uint8_t* p = &buffer[3]; p != &buffer[EVISION_V2_PACKET_SIZE]; p++)
{
chksum += *p;
}
buffer[1] = chksum & 0xff;
buffer[2] = (chksum >> 8) & 0xff;
int bytes_read;
{
const std::lock_guard<std::mutex> lock(query_mutex);
hid_write(dev, buffer, sizeof(buffer));
do
{
bytes_read = hid_read(dev, buffer, sizeof(buffer));
} while(bytes_read != 0 && buffer[0] != EVISION_V2_REPORT_ID);
}
query_check_buffer(bytes_read == sizeof(buffer));
query_check_buffer(buffer[0] == EVISION_V2_REPORT_ID);
query_check_buffer(buffer[1] == (chksum & 0xff));
query_check_buffer(buffer[2] == ((chksum >> 8) & 0xff));
query_check_buffer(buffer[3] == cmd);
query_check_buffer(buffer[5] == (offset & 0xff));
query_check_buffer(buffer[6] == ((offset >> 8) & 0xff));
if(buffer[7] != 0)
{
return -buffer[7];
}
size = buffer[4];
if(size > EVISION_V2_PACKET_SIZE - 8)
{
return -256;
}
if(odata)
{
memcpy(odata, buffer + 8, size);
}
return size;
}
int EVisionV2KeyboardController::BeginConfigure()
{
return Query(EVISION_V2_CMD_BEGIN_CONFIGURE);
}
int EVisionV2KeyboardController::EndConfigure()
{
return Query(EVISION_V2_CMD_END_CONFIGURE);
}
int EVisionV2KeyboardController::Read(uint8_t cmd, uint16_t offset, uint16_t size, uint8_t* odata)
{
while(size > 0)
{
uint8_t pktsz = (uint8_t)std::min<size_t>(size, EVISION_V2_PACKET_SIZE - 8);
int result = Query(cmd, offset, nullptr, pktsz, odata);
if(result <= 0)
{
return result;
}
else if(result > size)
{
return -256;
}
offset += result;
odata += result;
size -= result;
}
return 0;
}
int EVisionV2KeyboardController::Write(uint8_t cmd, uint16_t offset, const uint8_t* idata, uint16_t size)
{
while(size > 0)
{
uint8_t pktsz = (uint8_t)std::min<size_t>(size, EVISION_V2_PACKET_SIZE - 8);
int result = Query(cmd, offset, idata, pktsz);
if(result <= 0)
{
return result;
}
offset += pktsz;
idata += pktsz;
size -= pktsz;
}
return 0;
}
int EVisionV2KeyboardController::GetMode(EVisionV2KeyboardPart part, EvisionV2ModeConfig& config)
{
uint8_t buffer[18];
memset(buffer, 0, sizeof(buffer));
uint8_t current_profile;
int ret = Read(EVISION_V2_CMD_READ_CONFIG, EVISION_V2_OFFSET_CURRENT_PROFILE, 1, &current_profile);
if(ret < 0)
{
return ret;
}
if(current_profile > 2)
{
current_profile = 0;
}
uint16_t offset;
uint8_t size;
offset = current_profile * 0x40 + EVISION_V2_OFFSET_FIRST_PROFILE;
switch(part)
{
case EVISION_V2_KEYBOARD_PART_KEYBOARD:
size = sizeof(buffer);
break;
case EVISION_V2_KEYBOARD_PART_LOGO:
case ENDORFY_KEYBOARD_PART_EDGE:
offset += EVISION_V2_PARAMETER_LOGO;
size = EVISION_V2_PARAMETER_LOGO_ON_OFF - EVISION_V2_PARAMETER_LOGO + 1;
break;
case EVISION_V2_KEYBOARD_PART_EDGE:
offset += EVISION_V2_PARAMETER_EDGE;
size = EVISION_V2_PARAMETER_END - EVISION_V2_PARAMETER_EDGE;
break;
default:
size = 0;
break;
}
ret = Read(EVISION_V2_CMD_READ_CONFIG, offset, size, buffer);
if(ret < 0)
{
return ret;
}
config.mode = buffer[EVISION_V2_PARAMETER_MODE];
config.brightness = buffer[EVISION_V2_PARAMETER_BRIGHTNESS];
config.speed = buffer[EVISION_V2_PARAMETER_SPEED];
config.direction = buffer[EVISION_V2_PARAMETER_DIRECTION];
config.random_colours = buffer[EVISION_V2_PARAMETER_RANDOM_COLOR_FLAG] != 0;
config.colour = ToRGBColor(buffer[EVISION_V2_PARAMETER_MODE_COLOR + 0],
buffer[EVISION_V2_PARAMETER_MODE_COLOR + 1], buffer[EVISION_V2_PARAMETER_MODE_COLOR + 2]);
if(part == EVISION_V2_KEYBOARD_PART_KEYBOARD)
{
config.ledmode = buffer[EVISION_V2_PARAMETER_LED_MODE_COLOR];
if(config.mode == EVISION_V2_MODE_CUSTOM)
{
ret = Read(EVISION_V2_CMD_READ_CONFIG, current_profile * 0x40 + EVISION_V2_OFFSET_FIRST_PROFILE + EVISION_V2_PARAMETER_CURRENT_CUSTOM_MODE, sizeof(config.ledmode), &config.ledmode);
if(ret < 0)
{
return ret;
}
}
}
else if(part == EVISION_V2_KEYBOARD_PART_LOGO || part == ENDORFY_KEYBOARD_PART_EDGE)
{
// Use ledmode for logo on/off
config.ledmode = buffer[EVISION_V2_PARAMETER_LOGO_ON_OFF - EVISION_V2_PARAMETER_LOGO];
}
return 0;
}
void EVisionV2KeyboardController::SetMode(EVisionV2KeyboardPart part, const EvisionV2ModeConfig& config)
{
uint8_t buffer[18];
memset(buffer, 0, sizeof(buffer));
buffer[EVISION_V2_PARAMETER_MODE] = config.mode;
buffer[EVISION_V2_PARAMETER_BRIGHTNESS] = config.brightness;
buffer[EVISION_V2_PARAMETER_SPEED] = config.speed;
buffer[EVISION_V2_PARAMETER_DIRECTION] = config.direction;
buffer[EVISION_V2_PARAMETER_RANDOM_COLOR_FLAG] = (config.random_colours) ? 255 : 0;
buffer[EVISION_V2_PARAMETER_MODE_COLOR + 0] = RGBGetRValue(config.colour);
buffer[EVISION_V2_PARAMETER_MODE_COLOR + 1] = RGBGetGValue(config.colour);
buffer[EVISION_V2_PARAMETER_MODE_COLOR + 2] = RGBGetBValue(config.colour);
if(part == EVISION_V2_KEYBOARD_PART_KEYBOARD)
{
buffer[EVISION_V2_PARAMETER_COLOR_OFFSET] = 0;
if(config.mode != EVISION_V2_MODE_CUSTOM)
{
buffer[EVISION_V2_PARAMETER_LED_MODE_COLOR] = config.ledmode;
}
}
else if(part == EVISION_V2_KEYBOARD_PART_LOGO || part == ENDORFY_KEYBOARD_PART_EDGE)
{
// Use ledmode for logo on/off
buffer[EVISION_V2_PARAMETER_LOGO_ON_OFF - EVISION_V2_PARAMETER_LOGO] = config.ledmode;
}
BeginConfigure();
uint8_t current_profile;
int ret = Read(EVISION_V2_CMD_READ_CONFIG, EVISION_V2_OFFSET_CURRENT_PROFILE, 1, &current_profile);
if(ret < 0)
{
return;
}
if(current_profile > 2)
{
current_profile = 0;
Write(EVISION_V2_CMD_WRITE_CONFIG, EVISION_V2_OFFSET_CURRENT_PROFILE, &current_profile, 1);
}
uint16_t offset = 0;
uint8_t size = 0;
offset = current_profile * 0x40 + EVISION_V2_OFFSET_FIRST_PROFILE;
switch(part)
{
case EVISION_V2_KEYBOARD_PART_KEYBOARD:
size = sizeof(buffer);
break;
case EVISION_V2_KEYBOARD_PART_LOGO:
case ENDORFY_KEYBOARD_PART_EDGE:
offset += EVISION_V2_PARAMETER_LOGO;
size = EVISION_V2_PARAMETER_LOGO_ON_OFF - EVISION_V2_PARAMETER_LOGO + 1;
break;
case EVISION_V2_KEYBOARD_PART_EDGE:
offset += EVISION_V2_PARAMETER_EDGE;
size = EVISION_V2_PARAMETER_END - EVISION_V2_PARAMETER_EDGE;
break;
}
Write(EVISION_V2_CMD_WRITE_CONFIG, offset, buffer, size);
if((part == EVISION_V2_KEYBOARD_PART_KEYBOARD) && (config.mode == EVISION_V2_MODE_CUSTOM))
{
Write(EVISION_V2_CMD_WRITE_CONFIG, current_profile * 0x40 + EVISION_V2_OFFSET_FIRST_PROFILE + EVISION_V2_PARAMETER_CURRENT_CUSTOM_MODE, &config.ledmode, sizeof(config.ledmode));
}
EndConfigure();
}
void EVisionV2KeyboardController::SetLedsDirect(const std::vector<RGBColor>& colours)
{
const size_t colours_num = std::min(colours.size(), led_count);
uint8_t* buffer = new uint8_t[3 * map_size];
memset(buffer, 0, 3 * map_size);
for(size_t i = 0; i < colours_num; i++)
{
size_t j = (size_t)keyvalue_map[i] * 3;
buffer[j + 0] = RGBGetRValue(colours[i]);
buffer[j + 1] = RGBGetGValue(colours[i]);
buffer[j + 2] = RGBGetBValue(colours[i]);
}
Write(EVISION_V2_CMD_SEND_DYNAMIC_COLORS, 0, buffer, (uint16_t)(3 * map_size));
delete[] buffer;
}
void EVisionV2KeyboardController::SetLedDirect(int led, RGBColor colour)
{
uint8_t buffer[3];
buffer[0] = RGBGetRValue(colour);
buffer[1] = RGBGetGValue(colour);
buffer[2] = RGBGetBValue(colour);
Write(EVISION_V2_CMD_SEND_DYNAMIC_COLORS, keyvalue_map[led] * 3, buffer, sizeof(buffer));
}
void EVisionV2KeyboardController::RefreshLedDirect()
{
// Write one zero byte in the first blank space
Query(EVISION_V2_CMD_SEND_DYNAMIC_COLORS, BLANK_SPACE * 3, nullptr, 1, nullptr);
}
void EVisionV2KeyboardController::EndLedsDirect()
{
Query(EVISION_V2_CMD_END_DYNAMIC_COLORS);
}
int EVisionV2KeyboardController::GetLedsCustom(uint8_t colorset, std::vector<RGBColor>& colours)
{
if(colorset > 9)
{
return -256;
}
const size_t colours_num = std::min(colours.size(), led_count);
uint8_t* buffer = new uint8_t[3 * map_size];
memset(buffer, 0, 3 * map_size);
int ret = Read(EVISION_V2_CMD_READ_CUSTOM_COLORS, 512 * colorset, (uint16_t)(3 * map_size), buffer);
if(ret < 0)
{
return ret;
}
for(size_t i = 0; i < colours_num; i++)
{
size_t j = (size_t)keyvalue_map[i] * 3;
colours[i] = ToRGBColor(buffer[j + 0], buffer[j + 1], buffer[j + 2]);
}
delete[] buffer;
return 0;
}
void EVisionV2KeyboardController::SetLedsCustom(uint8_t colorset, const std::vector<RGBColor>& colours)
{
if(colorset > 9)
{
return;
}
const size_t colours_num = std::min(colours.size(), led_count);
uint8_t* buffer = new uint8_t[3 * map_size];
memset(buffer, 0, 3 * map_size);
for(size_t i = 0; i < colours_num; i++)
{
size_t j = (size_t)keyvalue_map[i] * 3;
buffer[j + 0] = RGBGetRValue(colours[i]);
buffer[j + 1] = RGBGetGValue(colours[i]);
buffer[j + 2] = RGBGetBValue(colours[i]);
}
BeginConfigure();
Write(EVISION_V2_CMD_WRITE_CUSTOM_COLORS, 512 * colorset, buffer, (uint16_t)(3 * map_size));
EndConfigure();
delete[] buffer;
}
Controllers/EVisionKeyboardController/EVisionV2KeyboardController.h
+197
View File
@@ -0,0 +1,197 @@
/*---------------------------------------------------------*\
| EVisionV2KeyboardController.h |
| |
| Driver for EVision V2 keyboard |
| |
| Le Philousophe 25 Dec 2022 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#pragma once
#include <string>
#include <hidapi.h>
#include "RGBController.h"
#define EVISION_V2_PACKET_SIZE 64
#define HID_MAX_STR 255
#define EVISION_V2_REPORT_ID 4
#define EVISION_V2_MATRIX_HEIGHT 6
#define EVISION_V2_MATRIX_WIDTH 21
enum
{
EVISION_V2_MODE_COLOR_WAVE_SHORT = 0x01, /* "Go with the stream" */
EVISION_V2_MODE_COLOR_WAVE_LONG = 0x02, /* "Clouds fly" */
EVISION_V2_MODE_COLOR_WHEEL = 0x03, /* "Winding paths" */
EVISION_V2_MODE_SPECTRUM_CYCLE = 0x04, /* "Spectrum" */
EVISION_V2_MODE_BREATHING = 0x05, /* "Breath" */
EVISION_V2_MODE_STATIC = 0x06, /* "Normal" */
EVISION_V2_MODE_REACTIVE = 0x07, /* "Pass without trace" */
EVISION_V2_MODE_REACTIVE_RIPPLE = 0x08, /* "Ripples" */
EVISION_V2_MODE_REACTIVE_LINE = 0x09, /* "Stream" */
EVISION_V2_MODE_STARLIGHT_FAST = 0x0A, /* "Stars" */
EVISION_V2_MODE_BLOOMING = 0x0B, /* "Flowers" */
EVISION_V2_MODE_RAINBOW_WAVE_VERTICAL = 0x0C, /* "Swift action" */
EVISION_V2_MODE_HURRICANE = 0x0D, /* "Hurricane" */
EVISION_V2_MODE_ACCUMULATE = 0x0E, /* "Cartoon" */
EVISION_V2_MODE_STARLIGHT_SLOW = 0x0F, /* "Digital times" */
EVISION_V2_MODE_VISOR = 0x10, /* "Both ways" */
EVISION_V2_MODE_SURMOUNT = 0x11, /* "Surmount" */
EVISION_V2_MODE_RAINBOW_WAVE_CIRCLE = 0x12, /* "Speed" */
EVISION_V2_MODE_CUSTOM = 0x14, /* "Custom" */
EVISION_V2_MODE_DIRECT = 0xFF, /* Software controlled mode */
};
enum
{
EVISION_V2_MODE2_COLOR_WAVE = 0x00, /* "Pulsation" */
EVISION_V2_MODE2_BREATHING = 0x01, /* "Breath" */
EVISION_V2_MODE2_YOYO = 0x02, /* "Yoyo" */
EVISION_V2_MODE2_BLINK = 0x03, /* "Blink" */
EVISION_V2_MODE2_STATIC = 0x04, /* "Normal" */
EVISION_V2_MODE2_OFF = 0x05, /* "Off" */
};
enum
{
/* Official software doesn't support changing edges */
ENDORFY_MODE2_FREEZE = 0x00,
ENDORFY_MODE2_COLOR_WAVE = 0x01,
ENDORFY_MODE2_SPECTRUM_CYCLE = 0x02,
ENDORFY_MODE2_BREATHING = 0x03,
ENDORFY_MODE2_STATIC = 0x04,
ENDORFY_MODE2_OFF = 0x05,
};
enum
{
EVISION_V2_CMD_BEGIN_CONFIGURE = 0x01,
EVISION_V2_CMD_END_CONFIGURE = 0x02,
EVISION_V2_CMD_READ_CAPABILITIES = 0x03,
//EVISION_V2_CMD_WRITE_CAPABILITIES = 0x04,
EVISION_V2_CMD_READ_CONFIG = 0x05,
EVISION_V2_CMD_WRITE_CONFIG = 0x06,
EVISION_V2_CMD_READ_CUSTOM_COLORS = 0x0A,
EVISION_V2_CMD_WRITE_CUSTOM_COLORS = 0x0B,
EVISION_V2_CMD_SEND_DYNAMIC_COLORS = 0x12,
EVISION_V2_CMD_END_DYNAMIC_COLORS = 0x13,
};
enum
{
EVISION_V2_OFFSET_CURRENT_PROFILE = 0x00,
EVISION_V2_OFFSET_FIRST_PROFILE = 0x01,
EVISION_V2_OFFSET_SECOND_PROFILE = 0x41,
EVISION_V2_OFFSET_THIRD_PROFILE = 0x81,
};
enum
{
EVISION_V2_PARAMETER_MODE = 0x00, /* Mode parameter */
EVISION_V2_PARAMETER_BRIGHTNESS = 0x01, /* Brightness parameter */
EVISION_V2_PARAMETER_SPEED = 0x02, /* Speed parameter */
EVISION_V2_PARAMETER_DIRECTION = 0x03, /* Direction parameter */
EVISION_V2_PARAMETER_RANDOM_COLOR_FLAG = 0x04, /* Random color parameter */
EVISION_V2_PARAMETER_MODE_COLOR = 0x05, /* Mode color (RGB) */
EVISION_V2_PARAMETER_COLOR_OFFSET = 0x08, /* Unknown color offset */
EVISION_V2_PARAMETER_LED_MODE_COLOR = 0x11, /* Led mode color */
EVISION_V2_PARAMETER_CURRENT_CUSTOM_MODE = 0x19, /* Custom mode current colorset */
EVISION_V2_PARAMETER_LOGO = 0x1a, /* Logo parameters */
EVISION_V2_PARAMETER_LOGO_ON_OFF = 0x23, /* Logo on/off */
EVISION_V2_PARAMETER_EDGE = 0x24, /* Edge parameters */
EVISION_V2_PARAMETER_END = 0x2b, /* Address after last parameter */
};
enum
{
EVISION_V2_BRIGHTNESS_LOWEST = 0x00, /* Lowest brightness (off) */
EVISION_V2_BRIGHTNESS_HIGHEST = 0x04, /* Highest brightness */
};
enum
{
EVISION_V2_SPEED_SLOWEST = 0x05, /* Slowest speed setting */
EVISION_V2_SPEED_NORMAL = 0x03, /* Normal speed setting */
EVISION_V2_SPEED_FASTEST = 0x00, /* Fastest speed setting */
};
enum
{
EVISION_V2_SURMOUNT_MODE_COLOR_RED = 0x00, /* Red surmount color */
EVISION_V2_SURMOUNT_MODE_COLOR_YELLOW = 0x01, /* Yellow surmount color */
EVISION_V2_SURMOUNT_MODE_COLOR_GREEN = 0x02, /* Green surmount color */
EVISION_V2_SURMOUNT_MODE_COLOR_CYAN = 0x03, /* Cyan surmount color */
};
enum EVisionV2KeyboardLayout
{
EVISION_V2_KEYBOARD_LAYOUT,
ENDORFY_KEYBOARD_LAYOUT,
};
enum EVisionV2KeyboardPart
{
EVISION_V2_KEYBOARD_PART_KEYBOARD,
EVISION_V2_KEYBOARD_PART_LOGO,
EVISION_V2_KEYBOARD_PART_EDGE,
ENDORFY_KEYBOARD_PART_EDGE,
};
struct EvisionV2ModeConfig
{
uint8_t mode;
uint8_t brightness;
uint8_t speed;
uint8_t direction;
bool random_colours;
RGBColor colour;
uint8_t ledmode;
};
class EVisionV2KeyboardController
{
public:
EVisionV2KeyboardController(hid_device* dev_handle, const char* path, EVisionV2KeyboardLayout dev_layout, std::string dev_name);
~EVisionV2KeyboardController();
std::string GetName();
std::string GetSerial();
std::string GetLocation();
int Query(uint8_t cmd, uint16_t offset = 0, const uint8_t* idata = nullptr, uint8_t size = 0, uint8_t* odata = nullptr);
int BeginConfigure();
int EndConfigure();
int Read(uint8_t cmd, uint16_t offset, uint16_t size, uint8_t* odata);
int Write(uint8_t cmd, uint16_t offset, const uint8_t* idata, uint16_t size);
int GetMode(EVisionV2KeyboardPart part, EvisionV2ModeConfig& config);
void SetMode(EVisionV2KeyboardPart part, const EvisionV2ModeConfig& config);
void SetLedsDirect(const std::vector<RGBColor>& colours);
void SetLedDirect(int led, RGBColor colours);
void RefreshLedDirect();
void EndLedsDirect();
int GetLedsCustom(uint8_t colorset, std::vector<RGBColor>& colours);
void SetLedsCustom(uint8_t colorset, const std::vector<RGBColor>& colours);
EVisionV2KeyboardLayout layout;
private:
std::string name;
std::string serial;
std::string location;
hid_device* dev;
size_t map_size;
size_t macros_size;
uint8_t * keyvalue_map;
size_t led_count;
std::mutex query_mutex;
};
Controllers/EVisionKeyboardController/RGBController_EVisionKeyboard.cpp
+408
View File
@@ -0,0 +1,408 @@
/*---------------------------------------------------------*\
| RGBController_EVisionKeyboard.cpp |
| |
| RGBController for EVision keyboard (Redragon, Glorious, |
| Ajazz, Tecware, and many other brands) |
| |
| Adam Honse (CalcProgrammer1) 25 Mar 2020 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include "RGBController_EVisionKeyboard.h"
//0xFFFFFFFF indicates an unused entry in matrix
#define NA 0xFFFFFFFF
static unsigned int matrix_map[6][23] =
{ { 0, NA, 1, 2, 3, 4, NA, 5, 6, 7, 8, NA, 9, 10, 11, 12, 14, 15, 16, NA, NA, NA, NA },
{ 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, NA, 32, 33, 34, NA, 35, 36, 37, 38, 39, 40, 41 },
{ 42, NA, 43, 44, 45, 46, NA, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62 },
{ 63, NA, 64, 65, 66, 67, NA, 68, 69, 70, 71, 72, 73, 74, 76, NA, NA, NA, NA, 80, 81, 82, NA },
{ 84, NA, 86, 87, 88, 89, NA, 90, NA, 91, 92, 93, 94, 95, 97, NA, NA, 99, NA, 101, 102, 103, 104 },
{ 105, 106, 107, NA, NA, NA, NA, 108, NA, NA, NA, NA, 109, 110, 111, 113, 119, 120, 121, 123, NA, 124, NA } };
/**------------------------------------------------------------------*\
@name EVision Keyboard
@category Keyboard
@type USB
@save :robot:
@direct :x:
@effects :white_check_mark:
@detectors DetectEVisionKeyboards
@comment
\*-------------------------------------------------------------------*/
RGBController_EVisionKeyboard::RGBController_EVisionKeyboard(EVisionKeyboardController* controller_ptr)
{
controller = controller_ptr;
name = controller->GetNameString();
vendor = "EVision";
type = DEVICE_TYPE_KEYBOARD;
description = "EVision Keyboard Device";
location = controller->GetDeviceLocation();
serial = controller->GetSerialString();
mode Custom;
Custom.name = "Custom";
Custom.value = EVISION_KB_MODE_CUSTOM;
Custom.flags = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
Custom.brightness_min = EVISION_KB_BRIGHTNESS_LOWEST;
Custom.brightness_max = EVISION_KB_BRIGHTNESS_HIGHEST;
Custom.brightness = EVISION_KB_BRIGHTNESS_HIGHEST;
Custom.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Custom);
mode ColorWave;
ColorWave.name = "Color Wave";
ColorWave.value = EVISION_KB_MODE_COLOR_WAVE_LONG;
ColorWave.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_AUTOMATIC_SAVE;
ColorWave.speed_min = EVISION_KB_SPEED_SLOWEST;
ColorWave.speed_max = EVISION_KB_SPEED_FASTEST;
ColorWave.speed = EVISION_KB_SPEED_NORMAL;
ColorWave.brightness_min = EVISION_KB_BRIGHTNESS_LOWEST;
ColorWave.brightness_max = EVISION_KB_BRIGHTNESS_HIGHEST;
ColorWave.brightness = EVISION_KB_BRIGHTNESS_HIGHEST;
ColorWave.direction = MODE_DIRECTION_LEFT;
ColorWave.colors_min = 1;
ColorWave.colors_max = 1;
ColorWave.color_mode = MODE_COLORS_MODE_SPECIFIC;
ColorWave.colors.resize(1);
modes.push_back(ColorWave);
mode ColorWaveShort;
ColorWaveShort.name = "Color Wave (Short)";
ColorWaveShort.value = EVISION_KB_MODE_COLOR_WAVE_SHORT;
ColorWaveShort.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_AUTOMATIC_SAVE;
ColorWaveShort.speed_min = EVISION_KB_SPEED_SLOWEST;
ColorWaveShort.speed_max = EVISION_KB_SPEED_FASTEST;
ColorWaveShort.speed = EVISION_KB_SPEED_NORMAL;
ColorWaveShort.brightness_min = EVISION_KB_BRIGHTNESS_LOWEST;
ColorWaveShort.brightness_max = EVISION_KB_BRIGHTNESS_HIGHEST;
ColorWaveShort.brightness = EVISION_KB_BRIGHTNESS_HIGHEST;
ColorWaveShort.direction = MODE_DIRECTION_LEFT;
ColorWaveShort.colors_min = 1;
ColorWaveShort.colors_max = 1;
ColorWaveShort.color_mode = MODE_COLORS_MODE_SPECIFIC;
ColorWaveShort.colors.resize(1);
modes.push_back(ColorWaveShort);
mode ColorWheel;
ColorWheel.name = "Color Wheel";
ColorWheel.value = EVISION_KB_MODE_COLOR_WHEEL;
ColorWheel.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_AUTOMATIC_SAVE;
ColorWheel.speed_min = EVISION_KB_SPEED_SLOWEST;
ColorWheel.speed_max = EVISION_KB_SPEED_FASTEST;
ColorWheel.speed = EVISION_KB_SPEED_NORMAL;
ColorWheel.brightness_min = EVISION_KB_BRIGHTNESS_LOWEST;
ColorWheel.brightness_max = EVISION_KB_BRIGHTNESS_HIGHEST;
ColorWheel.brightness = EVISION_KB_BRIGHTNESS_HIGHEST;
ColorWheel.direction = MODE_DIRECTION_LEFT;
ColorWheel.colors_min = 1;
ColorWheel.colors_max = 1;
ColorWheel.color_mode = MODE_COLORS_MODE_SPECIFIC;
ColorWheel.colors.resize(1);
modes.push_back(ColorWheel);
mode SpectrumCycle;
SpectrumCycle.name = "Spectrum Cycle";
SpectrumCycle.value = EVISION_KB_MODE_SPECTRUM_CYCLE;
SpectrumCycle.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
SpectrumCycle.speed_min = EVISION_KB_SPEED_SLOWEST;
SpectrumCycle.speed_max = EVISION_KB_SPEED_FASTEST;
SpectrumCycle.speed = EVISION_KB_SPEED_NORMAL;
SpectrumCycle.brightness_min = EVISION_KB_BRIGHTNESS_LOWEST;
SpectrumCycle.brightness_max = EVISION_KB_BRIGHTNESS_HIGHEST;
SpectrumCycle.brightness = EVISION_KB_BRIGHTNESS_HIGHEST;
SpectrumCycle.color_mode = MODE_COLORS_NONE;
modes.push_back(SpectrumCycle);
mode Breathing;
Breathing.name = "Breathing";
Breathing.value = EVISION_KB_MODE_BREATHING;
Breathing.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
Breathing.speed_min = EVISION_KB_SPEED_SLOWEST;
Breathing.speed_max = EVISION_KB_SPEED_FASTEST;
Breathing.speed = EVISION_KB_SPEED_NORMAL;
Breathing.brightness_min = EVISION_KB_BRIGHTNESS_LOWEST;
Breathing.brightness_max = EVISION_KB_BRIGHTNESS_HIGHEST;
Breathing.brightness = EVISION_KB_BRIGHTNESS_HIGHEST;
Breathing.colors_min = 1;
Breathing.colors_max = 1;
Breathing.color_mode = MODE_COLORS_MODE_SPECIFIC;
Breathing.colors.resize(1);
modes.push_back(Breathing);
mode Hurricane;
Hurricane.name = "Hurricane";
Hurricane.value = EVISION_KB_MODE_HURRICANE;
Hurricane.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
Hurricane.speed_min = EVISION_KB_SPEED_SLOWEST;
Hurricane.speed_max = EVISION_KB_SPEED_FASTEST;
Hurricane.speed = EVISION_KB_SPEED_NORMAL;
Hurricane.brightness_min = EVISION_KB_BRIGHTNESS_LOWEST;
Hurricane.brightness_max = EVISION_KB_BRIGHTNESS_HIGHEST;
Hurricane.brightness = EVISION_KB_BRIGHTNESS_HIGHEST;
Hurricane.colors_min = 1;
Hurricane.colors_max = 1;
Hurricane.color_mode = MODE_COLORS_MODE_SPECIFIC;
Hurricane.colors.resize(1);
modes.push_back(Hurricane);
mode Accumulate;
Accumulate.name = "Accumulate";
Accumulate.value = EVISION_KB_MODE_ACCUMULATE;
Accumulate.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
Accumulate.speed_min = EVISION_KB_SPEED_SLOWEST;
Accumulate.speed_max = EVISION_KB_SPEED_FASTEST;
Accumulate.speed = EVISION_KB_SPEED_NORMAL;
Accumulate.brightness_min = EVISION_KB_BRIGHTNESS_LOWEST;
Accumulate.brightness_max = EVISION_KB_BRIGHTNESS_HIGHEST;
Accumulate.brightness = EVISION_KB_BRIGHTNESS_HIGHEST;
Accumulate.colors_min = 1;
Accumulate.colors_max = 1;
Accumulate.color_mode = MODE_COLORS_MODE_SPECIFIC;
Accumulate.colors.resize(1);
modes.push_back(Accumulate);
mode Starlight;
Starlight.name = "Starlight";
Starlight.value = EVISION_KB_MODE_STARLIGHT_FAST;
Starlight.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
Starlight.speed_min = EVISION_KB_SPEED_SLOWEST;
Starlight.speed_max = EVISION_KB_SPEED_FASTEST;
Starlight.speed = EVISION_KB_SPEED_NORMAL;
Starlight.brightness_min = EVISION_KB_BRIGHTNESS_LOWEST;
Starlight.brightness_max = EVISION_KB_BRIGHTNESS_HIGHEST;
Starlight.brightness = EVISION_KB_BRIGHTNESS_HIGHEST;
Starlight.colors_min = 1;
Starlight.colors_max = 1;
Starlight.color_mode = MODE_COLORS_MODE_SPECIFIC;
Starlight.colors.resize(1);
modes.push_back(Starlight);
mode Visor;
Visor.name = "Visor";
Visor.value = EVISION_KB_MODE_VISOR;
Visor.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
Visor.brightness_min = EVISION_KB_BRIGHTNESS_LOWEST;
Visor.brightness_max = EVISION_KB_BRIGHTNESS_HIGHEST;
Visor.brightness = EVISION_KB_BRIGHTNESS_HIGHEST;
Visor.colors_min = 1;
Visor.colors_max = 1;
Visor.color_mode = MODE_COLORS_MODE_SPECIFIC;
Visor.colors.resize(1);
modes.push_back(Visor);
mode Static;
Static.name = "Static";
Static.value = EVISION_KB_MODE_STATIC;
Static.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
Static.brightness_min = EVISION_KB_BRIGHTNESS_LOWEST;
Static.brightness_max = EVISION_KB_BRIGHTNESS_HIGHEST;
Static.brightness = EVISION_KB_BRIGHTNESS_HIGHEST;
Static.colors_min = 1;
Static.colors_max = 1;
Static.color_mode = MODE_COLORS_MODE_SPECIFIC;
Static.colors.resize(1);
modes.push_back(Static);
mode RainbowCircle;
RainbowCircle.name = "Rainbow Circle";
RainbowCircle.value = EVISION_KB_MODE_RAINBOW_WAVE_CIRCLE;
RainbowCircle.flags = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
RainbowCircle.brightness_min = EVISION_KB_BRIGHTNESS_LOWEST;
RainbowCircle.brightness_max = EVISION_KB_BRIGHTNESS_HIGHEST;
RainbowCircle.brightness = EVISION_KB_BRIGHTNESS_HIGHEST;
RainbowCircle.color_mode = MODE_COLORS_RANDOM;
modes.push_back(RainbowCircle);
mode VerticalRainbow;
VerticalRainbow.name = "Vertical Rainbow";
VerticalRainbow.value = EVISION_KB_MODE_RAINBOW_WAVE_VERTICAL;
VerticalRainbow.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_DIRECTION_UD | MODE_FLAG_AUTOMATIC_SAVE;
VerticalRainbow.speed_min = EVISION_KB_SPEED_SLOWEST;
VerticalRainbow.speed_max = EVISION_KB_SPEED_FASTEST;
VerticalRainbow.speed = EVISION_KB_SPEED_NORMAL;
VerticalRainbow.brightness_min = EVISION_KB_BRIGHTNESS_LOWEST;
VerticalRainbow.brightness_max = EVISION_KB_BRIGHTNESS_HIGHEST;
VerticalRainbow.brightness = EVISION_KB_BRIGHTNESS_HIGHEST;
VerticalRainbow.direction = MODE_DIRECTION_UP;
VerticalRainbow.colors_min = 1;
VerticalRainbow.colors_max = 1;
VerticalRainbow.color_mode = MODE_COLORS_MODE_SPECIFIC;
VerticalRainbow.colors.resize(1);
modes.push_back(VerticalRainbow);
mode Blooming;
Blooming.name = "Blooming";
Blooming.value = EVISION_KB_MODE_BLOOMING;
Blooming.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
Blooming.speed_min = EVISION_KB_SPEED_SLOWEST;
Blooming.speed_max = EVISION_KB_SPEED_FASTEST;
Blooming.speed = EVISION_KB_SPEED_NORMAL;
Blooming.brightness_min = EVISION_KB_BRIGHTNESS_LOWEST;
Blooming.brightness_max = EVISION_KB_BRIGHTNESS_HIGHEST;
Blooming.brightness = EVISION_KB_BRIGHTNESS_HIGHEST;
Blooming.color_mode = MODE_COLORS_RANDOM;
modes.push_back(Blooming);
mode Reactive;
Reactive.name = "Reactive";
Reactive.value = EVISION_KB_MODE_REACTIVE;
Reactive.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
Reactive.speed_min = EVISION_KB_SPEED_SLOWEST;
Reactive.speed_max = EVISION_KB_SPEED_FASTEST;
Reactive.speed = EVISION_KB_SPEED_NORMAL;
Reactive.brightness_min = EVISION_KB_BRIGHTNESS_LOWEST;
Reactive.brightness_max = EVISION_KB_BRIGHTNESS_HIGHEST;
Reactive.brightness = EVISION_KB_BRIGHTNESS_HIGHEST;
Reactive.colors_min = 1;
Reactive.colors_max = 1;
Reactive.color_mode = MODE_COLORS_MODE_SPECIFIC;
Reactive.colors.resize(1);
modes.push_back(Reactive);
mode ReactiveRipple;
ReactiveRipple.name = "Reactive Ripple";
ReactiveRipple.value = EVISION_KB_MODE_REACTIVE_RIPPLE;
ReactiveRipple.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
ReactiveRipple.speed_min = EVISION_KB_SPEED_SLOWEST;
ReactiveRipple.speed_max = EVISION_KB_SPEED_FASTEST;
ReactiveRipple.speed = EVISION_KB_SPEED_NORMAL;
ReactiveRipple.brightness_min = EVISION_KB_BRIGHTNESS_LOWEST;
ReactiveRipple.brightness_max = EVISION_KB_BRIGHTNESS_HIGHEST;
ReactiveRipple.brightness = EVISION_KB_BRIGHTNESS_HIGHEST;
ReactiveRipple.colors_min = 1;
ReactiveRipple.colors_max = 1;
ReactiveRipple.color_mode = MODE_COLORS_MODE_SPECIFIC;
ReactiveRipple.colors.resize(1);
modes.push_back(ReactiveRipple);
mode ReactiveLine;
ReactiveLine.name = "Reactive Line";
ReactiveLine.value = EVISION_KB_MODE_REACTIVE_LINE;
ReactiveLine.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
ReactiveLine.speed_min = EVISION_KB_SPEED_SLOWEST;
ReactiveLine.speed_max = EVISION_KB_SPEED_FASTEST;
ReactiveLine.speed = EVISION_KB_SPEED_NORMAL;
ReactiveLine.brightness_min = EVISION_KB_BRIGHTNESS_LOWEST;
ReactiveLine.brightness_max = EVISION_KB_BRIGHTNESS_HIGHEST;
ReactiveLine.brightness = EVISION_KB_BRIGHTNESS_HIGHEST;
ReactiveLine.colors_min = 1;
ReactiveLine.colors_max = 1;
ReactiveLine.color_mode = MODE_COLORS_MODE_SPECIFIC;
ReactiveLine.colors.resize(1);
modes.push_back(ReactiveLine);
SetupZones();
}
RGBController_EVisionKeyboard::~RGBController_EVisionKeyboard()
{
/*---------------------------------------------------------*\
| 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_EVisionKeyboard::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_EVisionKeyboard::ResizeZone(int /*zone*/, int /*new_size*/)
{
/*---------------------------------------------------------*\
| This device does not support resizing zones |
\*---------------------------------------------------------*/
}
void RGBController_EVisionKeyboard::DeviceUpdateLEDs()
{
unsigned char color_data[7*0x36];
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,
0x36 * 7
);
}
void RGBController_EVisionKeyboard::UpdateZoneLEDs(int /*zone*/)
{
DeviceUpdateLEDs();
}
void RGBController_EVisionKeyboard::UpdateSingleLED(int /*led*/)
{
DeviceUpdateLEDs();
}
void RGBController_EVisionKeyboard::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,
modes[active_mode].brightness,
modes[active_mode].speed,
modes[active_mode].direction,
random,
red,
grn,
blu
);
}
Controllers/EVisionKeyboardController/RGBController_EVisionKeyboard.h
+36
View File
@@ -0,0 +1,36 @@
/*---------------------------------------------------------*\
| RGBController_EVisionKeyboard.h |
| |
| RGBController for EVision keyboard (Redragon, Glorious, |
| Ajazz, Tecware, and many other brands) |
| |
| Adam Honse (CalcProgrammer1) 25 Mar 2020 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#pragma once
#include "RGBController.h"
#include "EVisionKeyboardController.h"
class RGBController_EVisionKeyboard : public RGBController
{
public:
RGBController_EVisionKeyboard(EVisionKeyboardController* controller_ptr);
~RGBController_EVisionKeyboard();
void SetupZones();
void ResizeZone(int zone, int new_size);
void DeviceUpdateLEDs();
void UpdateZoneLEDs(int zone);
void UpdateSingleLED(int led);
void DeviceUpdateMode();
private:
EVisionKeyboardController* controller;
};
Controllers/EVisionKeyboardController/RGBController_EVisionV2Keyboard.cpp
+1041
View File
File diff suppressed because it is too large Load Diff
Controllers/EVisionKeyboardController/RGBController_EVisionV2Keyboard.h
+51
View File
@@ -0,0 +1,51 @@
/*---------------------------------------------------------*\
| RGBController_EVisionV2Keyboard.h |
| |
| RGBController for EVision V2 keyboard |
| |
| Le Philousophe 25 Dec 2022 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#pragma once
#include <vector>
#include "LogManager.h"
#include "RGBController.h"
#include "EVisionV2KeyboardController.h"
class RGBController_EVisionV2Keyboard : public RGBController
{
public:
RGBController_EVisionV2Keyboard(EVisionV2KeyboardController* controller_ptr, EVisionV2KeyboardPart kb_part);
~RGBController_EVisionV2Keyboard();
void SetupZones() override;
void ResizeZone(int zone, int new_size) override;
void DeviceUpdateLEDs() override;
void UpdateZoneLEDs(int zone) override;
void UpdateSingleLED(int led) override;
void DeviceUpdateMode() override;
void DeviceSaveMode() override;
private:
void SetupKeyboardModes();
void SetupLogoEdgeModes();
void SetupEdgeModes();
void LoadConfig();
void KeepaliveThread();
EVisionV2KeyboardController* controller;
EVisionV2KeyboardPart part;
EVisionV2KeyboardLayout layout;
std::thread* keepalive_thread;
std::atomic<bool> keepalive_thread_run;
std::atomic<bool> has_color_set;
std::chrono::time_point<std::chrono::steady_clock> last_update_time;
};