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

Add Champion's Bane and Ironclad suport

Browse source
This commit is contained in:
Le Philousophe 2022-12-22 08:37:23 +01:00 • committed by Adam Honse
parent 3d8c11ea88
commit ccb20f3930
6 changed files with 1576 additions and 22 deletions
Download patch file Download diff file Expand all files Collapse all files

77
Controllers/EVisionKeyboardController/EVisionKeyboardControllerDetect.cpp
View file

@ -1,25 +1,29 @@
#include "Detector.h"
#include "EVisionKeyboardController.h"
#include "EVisionV2KeyboardController.h"
#include "RGBController.h"
#include "RGBController_EVisionKeyboard.h"
#include "RGBController_EVisionV2Keyboard.h"
#include "SettingsManager.h"
#include <vector>
#include <hidapi/hidapi.h>
/*-----------------------------------------------------*\
| Keyboard product IDs |
\*-----------------------------------------------------*/
#define EVISION_KEYBOARD_VID 0x0C45
#define EVISION_KEYBOARD2_VID 0x320F
#define EVISION_KEYBOARD_USAGE_PAGE 0xFF1C
#define GLORIOUS_GMMK_TKL_PID 0x5064
#define REDRAGON_K550_PID 0x5204
#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 EVISION_KEYBOARD_VID 0x0C45
#define EVISION_KEYBOARD2_VID 0x320F
#define EVISION_KEYBOARD_USAGE_PAGE 0xFF1C
#define GLORIOUS_GMMK_TKL_PID 0x5064
#define REDRAGON_K550_PID 0x5204
#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
/******************************************************************************************\
* *
@ -35,22 +39,51 @@ void DetectEVisionKeyboards(hid_device_info* info, const std::string& /*name*/)
if(dev)
{
EVisionKeyboardController* controller = new EVisionKeyboardController(dev, info->path);
EVisionKeyboardController* controller = new EVisionKeyboardController(dev, info->path);
RGBController_EVisionKeyboard* rgb_controller = new RGBController_EVisionKeyboard(controller);
rgb_controller->name = "EVision Keyboard";
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);
RGBController_EVisionV2Keyboard* rgb_controller = new RGBController_EVisionV2Keyboard(controller, EVISION_V2_KEYBOARD_PART_KEYBOARD);
rgb_controller->name = name;
ResourceManager::get()->RegisterRGBController(rgb_controller);
if(!settings.contains("AdditionalZones") || settings["AdditionalZones"] == true)
{
rgb_controller = new RGBController_EVisionV2Keyboard(controller, EVISION_V2_KEYBOARD_PART_LOGO);
rgb_controller->name = name;
rgb_controller->name += " Logo";
ResourceManager::get()->RegisterRGBController(rgb_controller);
rgb_controller = new RGBController_EVisionV2Keyboard(controller, EVISION_V2_KEYBOARD_PART_EDGE);
rgb_controller->name = name;
rgb_controller->name += " Edge";
ResourceManager::get()->RegisterRGBController(rgb_controller);
}
}
}
/*---------------------------------------------------------------------------------------------------------------------------------------------*\
| Keyboards |
\*---------------------------------------------------------------------------------------------------------------------------------------------*/
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 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("CSB/ICL01 Keyboard", DetectEVisionV2Keyboards, EVISION_KEYBOARD2_VID, BYGG_CSB_ICL01_PID, 1, EVISION_KEYBOARD_USAGE_PAGE);

443
Controllers/EVisionKeyboardController/EVisionV2KeyboardController.cpp Normal file
View file

@ -0,0 +1,443 @@
/*-------------------------------------------------------------------*\
| EVisionV2KeyboardController.cpp |
| |
| Driver for recent EVision RGB keyboard lighting controller |
| |
| Le Philousophe 25 Dec 2022 |
\*-------------------------------------------------------------------*/
#include <cstring>
#include "LogManager.h"
#include "EVisionV2KeyboardController.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 keyvalue_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,
};
EVisionV2KeyboardController::EVisionV2KeyboardController(hid_device* dev_handle, const char* path)
{
const uint8_t sz = HID_MAX_STR;
wchar_t tmp[sz];
dev = dev_handle;
location = path;
hid_get_manufacturer_string(dev, tmp, sz);
std::wstring wName = std::wstring(tmp);
device_name = std::string(wName.begin(), wName.end());
hid_get_product_string(dev, tmp, sz);
wName = std::wstring(tmp);
device_name.append(" ").append(std::string(wName.begin(), wName.end()));
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;
}
EVisionV2KeyboardController::~EVisionV2KeyboardController()
{
hid_close(dev);
}
std::string EVisionV2KeyboardController::GetDeviceName()
{
return device_name;
}
std::string EVisionV2KeyboardController::GetSerial()
{
const uint8_t sz = HID_MAX_STR;
wchar_t tmp[sz];
int ret = hid_get_serial_number_string(dev, tmp, sz);
if(ret != 0)
{
return("");
}
std::wstring w_tmp = std::wstring(tmp);
std::string serial = std::string(w_tmp.begin(), w_tmp.end());
return serial;
}
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 = 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 = 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:
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;
}
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)
{
// 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)
{
// 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;
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:
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(), sizeof(keyvalue_map) / sizeof(keyvalue_map[0]));
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, 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(), sizeof(keyvalue_map) / sizeof(keyvalue_map[0]));
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, 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(), sizeof(keyvalue_map) / sizeof(keyvalue_map[0]));
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, 3 * map_size);
EndConfigure();
delete[] buffer;
}

171
Controllers/EVisionKeyboardController/EVisionV2KeyboardController.h Normal file
View file

@ -0,0 +1,171 @@
/*-------------------------------------------------------------------*\
| EVisionV2KeyboardController.h |
| |
| Definitions and types for EVision RGB keyboard lighting controller |
| |
| Le Philousophe 25 Dec 2022 |
\*-------------------------------------------------------------------*/
#include <string>
#include <hidapi/hidapi.h>
#include "RGBController.h"
#pragma once
#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
{
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 EVisionV2KeyboardPart
{
EVISION_V2_KEYBOARD_PART_KEYBOARD,
EVISION_V2_KEYBOARD_PART_LOGO,
EVISION_V2_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);
~EVisionV2KeyboardController();
std::string GetDeviceName();
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);
private:
std::string device_name;
std::string serial;
std::string location;
hid_device* dev;
size_t map_size;
size_t macros_size;
std::mutex query_mutex;
};

857
Controllers/EVisionKeyboardController/RGBController_EVisionV2Keyboard.cpp Normal file
View file

@ -0,0 +1,857 @@
/*-------------------------------------------------------------------*\
| RGBController_EVisionV2Keyboard.cpp |
| |
| Generic RGB Interface for EVision V2 RGB Keyboard |
| |
| Le Philousophe 25 Dec 2022 |
\*-------------------------------------------------------------------*/
#define NA 0xFFFFFFFF
#include <chrono>
#include "hsv.h"
#include "RGBControllerKeyNames.h"
#include "RGBController_EVisionV2Keyboard.h"
using namespace std::chrono_literals;
static unsigned int matrix_map[EVISION_V2_MATRIX_HEIGHT][EVISION_V2_MATRIX_WIDTH] =
{
/* 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 19 19 20 */
{ 0, NA, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, NA, NA, NA, NA },
{ 16, 17, 18, 19, 20, 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, NA, NA, NA, 72, 73, 74, NA },
{ 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, NA, 87, NA, 88, NA, 89, 90, 91, 92 },
{ 93, 94, 95, NA, NA, NA, 96, NA, NA, NA, 97, 98, 99, 100, 101, 102, 103, NA, 104, 105, NA }
};
static const char *led_names[] =
{
KEY_EN_ESCAPE, //00
KEY_EN_F1,
KEY_EN_F2,
KEY_EN_F3,
KEY_EN_F4,
KEY_EN_F5,
KEY_EN_F6,
KEY_EN_F7,
KEY_EN_F8,
KEY_EN_F9,
KEY_EN_F10, //10
KEY_EN_F11,
KEY_EN_F12,
KEY_EN_PRINT_SCREEN,
KEY_EN_SCROLL_LOCK,
KEY_EN_PAUSE_BREAK,
KEY_EN_BACK_TICK, //16
KEY_EN_1,
KEY_EN_2,
KEY_EN_3,
KEY_EN_4, //20
KEY_EN_5,
KEY_EN_6,
KEY_EN_7,
KEY_EN_8,
KEY_EN_9,
KEY_EN_0,
KEY_EN_MINUS,
KEY_EN_EQUALS,
KEY_EN_BACKSPACE,
KEY_EN_INSERT,
KEY_EN_HOME, //30
KEY_EN_PAGE_UP,
KEY_EN_NUMPAD_LOCK,
KEY_EN_NUMPAD_DIVIDE,
KEY_EN_NUMPAD_TIMES,
KEY_EN_NUMPAD_MINUS,
KEY_EN_TAB, //37
KEY_EN_Q,
KEY_EN_W,
KEY_EN_E, //40
KEY_EN_R,
KEY_EN_T,
KEY_EN_Y,
KEY_EN_U,
KEY_EN_I,
KEY_EN_O,
KEY_EN_P,
KEY_EN_LEFT_BRACKET,
KEY_EN_RIGHT_BRACKET,
KEY_EN_ANSI_BACK_SLASH, //50
KEY_EN_DELETE,
KEY_EN_END,
KEY_EN_PAGE_DOWN,
KEY_EN_NUMPAD_7,
KEY_EN_NUMPAD_8,
KEY_EN_NUMPAD_9,
KEY_EN_NUMPAD_PLUS,
KEY_EN_CAPS_LOCK, //58
KEY_EN_A,
KEY_EN_S,
KEY_EN_D,
KEY_EN_F,
KEY_EN_G,
KEY_EN_H,
KEY_EN_J,
KEY_EN_K,
KEY_EN_L,
KEY_EN_SEMICOLON,
KEY_EN_QUOTE,
KEY_EN_POUND, //70
KEY_EN_ISO_ENTER,
KEY_EN_NUMPAD_4,
KEY_EN_NUMPAD_5,
KEY_EN_NUMPAD_6,
KEY_EN_LEFT_SHIFT, //75
KEY_EN_ISO_BACK_SLASH,
KEY_EN_Z,
KEY_EN_X,
KEY_EN_C,
KEY_EN_V, //80
KEY_EN_B,
KEY_EN_N,
KEY_EN_M,
KEY_EN_COMMA,
KEY_EN_PERIOD,
KEY_EN_FORWARD_SLASH,
KEY_EN_RIGHT_SHIFT,
KEY_EN_UP_ARROW,
KEY_EN_NUMPAD_1,
KEY_EN_NUMPAD_2, //90
KEY_EN_NUMPAD_3,
KEY_EN_NUMPAD_ENTER,
KEY_EN_LEFT_CONTROL, //93
KEY_EN_LEFT_WINDOWS,
KEY_EN_LEFT_ALT,
KEY_EN_SPACE,
KEY_EN_RIGHT_ALT,
KEY_EN_RIGHT_WINDOWS,
KEY_EN_RIGHT_FUNCTION,
KEY_EN_RIGHT_CONTROL, //100
KEY_EN_LEFT_ARROW,
KEY_EN_DOWN_ARROW,
KEY_EN_RIGHT_ARROW,
KEY_EN_NUMPAD_0,
KEY_EN_NUMPAD_PERIOD,
};
/**------------------------------------------------------------------*\
@name EVision V2 Keyboard
@category Keyboard
@type USB
@save :white_check_mark:
@direct :white_check_mark:
@effects :white_check_mark:
@detectors DetectEVisionV2Keyboard
@comment The Evision V2 controller implements all hardware modes
found in the OEM software. Some options may not be named correctly
like directions for some modes.
\*-------------------------------------------------------------------*/
RGBController_EVisionV2Keyboard::RGBController_EVisionV2Keyboard(EVisionV2KeyboardController* controller_ptr, EVisionV2KeyboardPart part_)
{
controller = controller_ptr;
part = part_;
name = "EVision Keyboard Device";
vendor = "Evision";
type = DEVICE_TYPE_KEYBOARD;
description = "EVision Keyboard Device";
location = controller->GetLocation();
serial = controller->GetSerial();
switch(part)
{
case EVISION_V2_KEYBOARD_PART_KEYBOARD:
SetupKeyboardModes();
break;
case EVISION_V2_KEYBOARD_PART_LOGO:
case EVISION_V2_KEYBOARD_PART_EDGE:
SetupLogoEdgeModes();
break;
}
SetupZones();
LoadConfig();
keepalive_thread_run = false;
keepalive_thread = nullptr;
if(part == EVISION_V2_KEYBOARD_PART_KEYBOARD)
{
keepalive_thread_run = true;
keepalive_thread = new std::thread(&RGBController_EVisionV2Keyboard::KeepaliveThread, this);
}
}
RGBController_EVisionV2Keyboard::~RGBController_EVisionV2Keyboard()
{
if(keepalive_thread)
{
keepalive_thread_run = false;
keepalive_thread->join();
delete keepalive_thread;
}
delete controller;
}
void RGBController_EVisionV2Keyboard::SetupKeyboardModes()
{
mode Direct;
Direct.name = "Direct";
Direct.value = EVISION_V2_MODE_DIRECT;
Direct.flags = MODE_FLAG_HAS_PER_LED_COLOR;
Direct.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Direct);
mode ColorWave;
ColorWave.name = "Color Wave short";
ColorWave.value = EVISION_V2_MODE_COLOR_WAVE_SHORT;
ColorWave.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
ColorWave.speed_min = EVISION_V2_SPEED_SLOWEST;
ColorWave.speed_max = EVISION_V2_SPEED_FASTEST;
ColorWave.speed = EVISION_V2_SPEED_NORMAL;
ColorWave.colors_min = 1;
ColorWave.colors_max = 1;
ColorWave.color_mode = MODE_COLORS_RANDOM;
ColorWave.colors.resize(1);
ColorWave.brightness_min = EVISION_V2_BRIGHTNESS_LOWEST;
ColorWave.brightness_max = EVISION_V2_BRIGHTNESS_HIGHEST;
ColorWave.brightness = EVISION_V2_BRIGHTNESS_HIGHEST;
modes.push_back(ColorWave);
mode ColorWaveLong;
ColorWaveLong.name = "Color Wave long";
ColorWaveLong.value = EVISION_V2_MODE_COLOR_WAVE_LONG;
ColorWaveLong.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
ColorWaveLong.speed_min = EVISION_V2_SPEED_SLOWEST;
ColorWaveLong.speed_max = EVISION_V2_SPEED_FASTEST;
ColorWaveLong.speed = EVISION_V2_SPEED_NORMAL;
ColorWaveLong.colors_min = 1;
ColorWaveLong.colors_max = 1;
ColorWaveLong.color_mode = MODE_COLORS_RANDOM;
ColorWaveLong.colors.resize(1);
ColorWaveLong.brightness_min = EVISION_V2_BRIGHTNESS_LOWEST;
ColorWaveLong.brightness_max = EVISION_V2_BRIGHTNESS_HIGHEST;
ColorWaveLong.brightness = EVISION_V2_BRIGHTNESS_HIGHEST;
modes.push_back(ColorWaveLong);
mode ColorWheel;
ColorWheel.name = "Color Wheel";
ColorWheel.value = EVISION_V2_MODE_COLOR_WHEEL;
ColorWheel.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
ColorWheel.speed_min = EVISION_V2_SPEED_SLOWEST;
ColorWheel.speed_max = EVISION_V2_SPEED_FASTEST;
ColorWheel.speed = EVISION_V2_SPEED_NORMAL;
ColorWheel.colors_min = 1;
ColorWheel.colors_max = 1;
ColorWheel.color_mode = MODE_COLORS_RANDOM;
ColorWheel.colors.resize(1);
ColorWheel.brightness_min = EVISION_V2_BRIGHTNESS_LOWEST;
ColorWheel.brightness_max = EVISION_V2_BRIGHTNESS_HIGHEST;
ColorWheel.brightness = EVISION_V2_BRIGHTNESS_HIGHEST;
modes.push_back(ColorWheel);
mode SpectrumCycle;
SpectrumCycle.name = "Spectrum Cycle";
SpectrumCycle.value = EVISION_V2_MODE_SPECTRUM_CYCLE;
SpectrumCycle.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
SpectrumCycle.speed_min = EVISION_V2_SPEED_SLOWEST;
SpectrumCycle.speed_max = EVISION_V2_SPEED_FASTEST;
SpectrumCycle.speed = EVISION_V2_SPEED_NORMAL;
SpectrumCycle.color_mode = MODE_COLORS_NONE;
SpectrumCycle.brightness_min = EVISION_V2_BRIGHTNESS_LOWEST;
SpectrumCycle.brightness_max = EVISION_V2_BRIGHTNESS_HIGHEST;
SpectrumCycle.brightness = EVISION_V2_BRIGHTNESS_HIGHEST;
modes.push_back(SpectrumCycle);
mode Breathing;
Breathing.name = "Breathing";
Breathing.value = EVISION_V2_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_V2_SPEED_SLOWEST;
Breathing.speed_max = EVISION_V2_SPEED_FASTEST;
Breathing.speed = EVISION_V2_SPEED_NORMAL;
Breathing.colors_min = 1;
Breathing.colors_max = 1;
Breathing.color_mode = MODE_COLORS_RANDOM;
Breathing.colors.resize(1);
Breathing.brightness_min = EVISION_V2_BRIGHTNESS_LOWEST;
Breathing.brightness_max = EVISION_V2_BRIGHTNESS_HIGHEST;
Breathing.brightness = EVISION_V2_BRIGHTNESS_HIGHEST;
modes.push_back(Breathing);
mode Static;
Static.name = "Static";
Static.value = EVISION_V2_MODE_STATIC;
Static.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
Static.colors_min = 1;
Static.colors_max = 1;
Static.color_mode = MODE_COLORS_RANDOM;
Static.colors.resize(1);
Static.brightness_min = EVISION_V2_BRIGHTNESS_LOWEST;
Static.brightness_max = EVISION_V2_BRIGHTNESS_HIGHEST;
Static.brightness = EVISION_V2_BRIGHTNESS_HIGHEST;
modes.push_back(Static);
mode Reactive;
Reactive.name = "Reactive";
Reactive.value = EVISION_V2_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_V2_SPEED_SLOWEST;
Reactive.speed_max = EVISION_V2_SPEED_FASTEST;
Reactive.speed = EVISION_V2_SPEED_NORMAL;
Reactive.colors_min = 1;
Reactive.colors_max = 1;
Reactive.color_mode = MODE_COLORS_RANDOM;
Reactive.colors.resize(1);
Reactive.brightness_min = EVISION_V2_BRIGHTNESS_LOWEST;
Reactive.brightness_max = EVISION_V2_BRIGHTNESS_HIGHEST;
Reactive.brightness = EVISION_V2_BRIGHTNESS_HIGHEST;
modes.push_back(Reactive);
mode ReactiveRipple;
ReactiveRipple.name = "Reactive Ripple";
ReactiveRipple.value = EVISION_V2_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_V2_SPEED_SLOWEST;
ReactiveRipple.speed_max = EVISION_V2_SPEED_FASTEST;
ReactiveRipple.speed = EVISION_V2_SPEED_NORMAL;
ReactiveRipple.colors_min = 1;
ReactiveRipple.colors_max = 1;
ReactiveRipple.color_mode = MODE_COLORS_RANDOM;
ReactiveRipple.colors.resize(1);
ReactiveRipple.brightness_min = EVISION_V2_BRIGHTNESS_LOWEST;
ReactiveRipple.brightness_max = EVISION_V2_BRIGHTNESS_HIGHEST;
ReactiveRipple.brightness = EVISION_V2_BRIGHTNESS_HIGHEST;
modes.push_back(ReactiveRipple);
mode ReactiveLine;
ReactiveLine.name = "Reactive Line";
ReactiveLine.value = EVISION_V2_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_V2_SPEED_SLOWEST;
ReactiveLine.speed_max = EVISION_V2_SPEED_FASTEST;
ReactiveLine.speed = EVISION_V2_SPEED_NORMAL;
ReactiveLine.colors_min = 1;
ReactiveLine.colors_max = 1;
ReactiveLine.color_mode = MODE_COLORS_RANDOM;
ReactiveLine.colors.resize(1);
ReactiveLine.brightness_min = EVISION_V2_BRIGHTNESS_LOWEST;
ReactiveLine.brightness_max = EVISION_V2_BRIGHTNESS_HIGHEST;
ReactiveLine.brightness = EVISION_V2_BRIGHTNESS_HIGHEST;
modes.push_back(ReactiveLine);
mode Starlight;
Starlight.name = "Starlight";
Starlight.value = EVISION_V2_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_V2_SPEED_SLOWEST;
Starlight.speed_max = EVISION_V2_SPEED_FASTEST;
Starlight.speed = EVISION_V2_SPEED_NORMAL;
Starlight.colors_min = 1;
Starlight.colors_max = 1;
Starlight.color_mode = MODE_COLORS_RANDOM;
Starlight.colors.resize(1);
Starlight.brightness_min = EVISION_V2_BRIGHTNESS_LOWEST;
Starlight.brightness_max = EVISION_V2_BRIGHTNESS_HIGHEST;
Starlight.brightness = EVISION_V2_BRIGHTNESS_HIGHEST;
modes.push_back(Starlight);
mode Blooming;
Blooming.name = "Blooming";
Blooming.value = EVISION_V2_MODE_BLOOMING;
Blooming.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
Blooming.speed_min = EVISION_V2_SPEED_SLOWEST;
Blooming.speed_max = EVISION_V2_SPEED_FASTEST;
Blooming.speed = EVISION_V2_SPEED_NORMAL;
Blooming.color_mode = MODE_COLORS_NONE;
Blooming.brightness_min = EVISION_V2_BRIGHTNESS_LOWEST;
Blooming.brightness_max = EVISION_V2_BRIGHTNESS_HIGHEST;
Blooming.brightness = EVISION_V2_BRIGHTNESS_HIGHEST;
modes.push_back(Blooming);
mode RainbowWaveVertical;
RainbowWaveVertical.name = "Rainbow Wave vertical";
RainbowWaveVertical.value = EVISION_V2_MODE_RAINBOW_WAVE_VERTICAL;
RainbowWaveVertical.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_UD | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
RainbowWaveVertical.speed_min = EVISION_V2_SPEED_SLOWEST;
RainbowWaveVertical.speed_max = EVISION_V2_SPEED_FASTEST;
RainbowWaveVertical.speed = EVISION_V2_SPEED_NORMAL;
RainbowWaveVertical.color_mode = MODE_COLORS_NONE;
RainbowWaveVertical.brightness_min = EVISION_V2_BRIGHTNESS_LOWEST;
RainbowWaveVertical.brightness_max = EVISION_V2_BRIGHTNESS_HIGHEST;
RainbowWaveVertical.brightness = EVISION_V2_BRIGHTNESS_HIGHEST;
modes.push_back(RainbowWaveVertical);
mode Hurricane;
Hurricane.name = "Hurricane";
Hurricane.value = EVISION_V2_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_V2_SPEED_SLOWEST;
Hurricane.speed_max = EVISION_V2_SPEED_FASTEST;
Hurricane.speed = EVISION_V2_SPEED_NORMAL;
Hurricane.colors_min = 1;
Hurricane.colors_max = 1;
Hurricane.color_mode = MODE_COLORS_RANDOM;
Hurricane.colors.resize(1);
Hurricane.brightness_min = EVISION_V2_BRIGHTNESS_LOWEST;
Hurricane.brightness_max = EVISION_V2_BRIGHTNESS_HIGHEST;
Hurricane.brightness = EVISION_V2_BRIGHTNESS_HIGHEST;
modes.push_back(Hurricane);
mode Accumulate;
Accumulate.name = "Accumulate";
Accumulate.value = EVISION_V2_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_V2_SPEED_SLOWEST;
Accumulate.speed_max = EVISION_V2_SPEED_FASTEST;
Accumulate.speed = EVISION_V2_SPEED_NORMAL;
Accumulate.colors_min = 1;
Accumulate.colors_max = 1;
Accumulate.color_mode = MODE_COLORS_RANDOM;
Accumulate.colors.resize(1);
Accumulate.brightness_min = EVISION_V2_BRIGHTNESS_LOWEST;
Accumulate.brightness_max = EVISION_V2_BRIGHTNESS_HIGHEST;
Accumulate.brightness = EVISION_V2_BRIGHTNESS_HIGHEST;
modes.push_back(Accumulate);
mode StarlightSlow;
StarlightSlow.name = "Starlight slow";
StarlightSlow.value = EVISION_V2_MODE_STARLIGHT_FAST;
StarlightSlow.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
StarlightSlow.speed_min = EVISION_V2_SPEED_SLOWEST;
StarlightSlow.speed_max = EVISION_V2_SPEED_FASTEST;
StarlightSlow.speed = EVISION_V2_SPEED_NORMAL;
StarlightSlow.colors_min = 1;
StarlightSlow.colors_max = 1;
StarlightSlow.color_mode = MODE_COLORS_RANDOM;
StarlightSlow.colors.resize(1);
StarlightSlow.brightness_min = EVISION_V2_BRIGHTNESS_LOWEST;
StarlightSlow.brightness_max = EVISION_V2_BRIGHTNESS_HIGHEST;
StarlightSlow.brightness = EVISION_V2_BRIGHTNESS_HIGHEST;
modes.push_back(StarlightSlow);
mode Visor;
Visor.name = "Visor";
Visor.value = EVISION_V2_MODE_VISOR;
Visor.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
Visor.speed_min = EVISION_V2_SPEED_SLOWEST;
Visor.speed_max = EVISION_V2_SPEED_FASTEST;
Visor.speed = EVISION_V2_SPEED_NORMAL;
Visor.colors_min = 1;
Visor.colors_max = 1;
Visor.color_mode = MODE_COLORS_RANDOM;
Visor.colors.resize(1);
Visor.brightness_min = EVISION_V2_BRIGHTNESS_LOWEST;
Visor.brightness_max = EVISION_V2_BRIGHTNESS_HIGHEST;
Visor.brightness = EVISION_V2_BRIGHTNESS_HIGHEST;
modes.push_back(Visor);
mode Surmount;
Surmount.name = "Surmount";
Surmount.value = EVISION_V2_MODE_SURMOUNT;
Surmount.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
Surmount.colors_min = 1;
Surmount.colors_max = 1;
Surmount.color_mode = MODE_COLORS_MODE_SPECIFIC;
Surmount.colors.resize(1);
Surmount.brightness_min = EVISION_V2_BRIGHTNESS_LOWEST;
Surmount.brightness_max = EVISION_V2_BRIGHTNESS_HIGHEST;
Surmount.brightness = EVISION_V2_BRIGHTNESS_HIGHEST;
modes.push_back(Surmount);
mode RainbowCircle;
RainbowCircle.name = "Rainbow Circle";
RainbowCircle.value = EVISION_V2_MODE_RAINBOW_WAVE_CIRCLE;
RainbowCircle.flags = MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
RainbowCircle.color_mode = MODE_COLORS_NONE;
RainbowCircle.brightness_min = EVISION_V2_BRIGHTNESS_LOWEST;
RainbowCircle.brightness_max = EVISION_V2_BRIGHTNESS_HIGHEST;
RainbowCircle.brightness = EVISION_V2_BRIGHTNESS_HIGHEST;
modes.push_back(RainbowCircle);
for(unsigned int i = 0; i < 10; i++)
{
mode Custom;
Custom.name = "Custom ";
Custom.name += std::to_string(i+1);
Custom.value = EVISION_V2_MODE_CUSTOM | i << 8;
Custom.flags = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
Custom.color_mode = MODE_COLORS_PER_LED;
Custom.brightness_min = EVISION_V2_BRIGHTNESS_LOWEST;
Custom.brightness_max = EVISION_V2_BRIGHTNESS_HIGHEST;
Custom.brightness = EVISION_V2_BRIGHTNESS_HIGHEST;
modes.push_back(Custom);
}
}
void RGBController_EVisionV2Keyboard::SetupLogoEdgeModes()
{
mode ColorWave;
ColorWave.name = "Color Wave";
ColorWave.value = EVISION_V2_MODE2_COLOR_WAVE;
ColorWave.flags = MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
ColorWave.speed_min = EVISION_V2_SPEED_SLOWEST;
ColorWave.speed_max = EVISION_V2_SPEED_FASTEST;
ColorWave.speed = EVISION_V2_SPEED_NORMAL;
ColorWave.colors_min = 1;
ColorWave.colors_max = 1;
ColorWave.color_mode = MODE_COLORS_RANDOM;
ColorWave.colors.resize(1);
ColorWave.brightness_min = EVISION_V2_BRIGHTNESS_LOWEST;
ColorWave.brightness_max = EVISION_V2_BRIGHTNESS_HIGHEST;
ColorWave.brightness = EVISION_V2_BRIGHTNESS_HIGHEST;
modes.push_back(ColorWave);
mode Breathing;
Breathing.name = "Breathing";
Breathing.value = EVISION_V2_MODE2_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_V2_SPEED_SLOWEST;
Breathing.speed_max = EVISION_V2_SPEED_FASTEST;
Breathing.speed = EVISION_V2_SPEED_NORMAL;
Breathing.colors_min = 1;
Breathing.colors_max = 1;
Breathing.color_mode = MODE_COLORS_RANDOM;
Breathing.colors.resize(1);
Breathing.brightness_min = EVISION_V2_BRIGHTNESS_LOWEST;
Breathing.brightness_max = EVISION_V2_BRIGHTNESS_HIGHEST;
Breathing.brightness = EVISION_V2_BRIGHTNESS_HIGHEST;
modes.push_back(Breathing);
mode Yoyo;
Yoyo.name = "Yoyo";
Yoyo.value = EVISION_V2_MODE2_YOYO;
Yoyo.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
Yoyo.speed_min = EVISION_V2_SPEED_SLOWEST;
Yoyo.speed_max = EVISION_V2_SPEED_FASTEST;
Yoyo.speed = EVISION_V2_SPEED_NORMAL;
Yoyo.colors_min = 1;
Yoyo.colors_max = 1;
Yoyo.color_mode = MODE_COLORS_RANDOM;
Yoyo.colors.resize(1);
Yoyo.brightness_min = EVISION_V2_BRIGHTNESS_LOWEST;
Yoyo.brightness_max = EVISION_V2_BRIGHTNESS_HIGHEST;
Yoyo.brightness = EVISION_V2_BRIGHTNESS_HIGHEST;
modes.push_back(Yoyo);
mode Blink;
Blink.name = "Blink";
Blink.value = EVISION_V2_MODE2_BLINK;
Blink.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
Blink.speed_min = EVISION_V2_SPEED_SLOWEST;
Blink.speed_max = EVISION_V2_SPEED_FASTEST;
Blink.speed = EVISION_V2_SPEED_NORMAL;
Blink.colors_min = 1;
Blink.colors_max = 1;
Blink.color_mode = MODE_COLORS_RANDOM;
Blink.colors.resize(1);
Blink.brightness_min = EVISION_V2_BRIGHTNESS_LOWEST;
Blink.brightness_max = EVISION_V2_BRIGHTNESS_HIGHEST;
Blink.brightness = EVISION_V2_BRIGHTNESS_HIGHEST;
modes.push_back(Blink);
mode Static;
Static.name = "Static";
Static.value = EVISION_V2_MODE2_STATIC;
Static.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
Static.colors_min = 1;
Static.colors_max = 1;
Static.color_mode = MODE_COLORS_RANDOM;
Static.colors.resize(1);
Static.brightness_min = EVISION_V2_BRIGHTNESS_LOWEST;
Static.brightness_max = EVISION_V2_BRIGHTNESS_HIGHEST;
Static.brightness = EVISION_V2_BRIGHTNESS_HIGHEST;
modes.push_back(Static);
mode Off;
Off.name = "Off";
Off.value = EVISION_V2_MODE2_OFF;
Off.flags = MODE_FLAG_AUTOMATIC_SAVE;
modes.push_back(Off);
}
void RGBController_EVisionV2Keyboard::SetupZones()
{
/*-------------------------------------------------*\
| Clear any existing color/LED configuration |
\*-------------------------------------------------*/
zone KB_zone;
KB_zone.name = ZONE_EN_KEYBOARD;
KB_zone.type = ZONE_TYPE_MATRIX;
KB_zone.leds_count = 106;
KB_zone.leds_min = KB_zone.leds_count;
KB_zone.leds_max = KB_zone.leds_count;
KB_zone.matrix_map = new matrix_map_type;
KB_zone.matrix_map->height = EVISION_V2_MATRIX_HEIGHT;
KB_zone.matrix_map->width = EVISION_V2_MATRIX_WIDTH;
KB_zone.matrix_map->map = (unsigned int *)&matrix_map;
zones.push_back(KB_zone);
/*-------------------------------------------------*\
| Clear any existing color/LED configuration |
\*-------------------------------------------------*/
leds.clear();
colors.clear();
/*---------------------------------------------------------*\
| Set up zones |
\*---------------------------------------------------------*/
for(std::size_t zone_index = 0; zone_index < zones.size(); zone_index++)
{
for(unsigned int led_index = 0; led_index < zones[zone_index].leds_count; led_index++)
{
led new_led;
new_led.name = led_names[led_index];
new_led.value = led_index;
leds.push_back(new_led);
}
}
SetupColors();
}
void RGBController_EVisionV2Keyboard::LoadConfig()
{
EvisionV2ModeConfig config;
controller->GetMode(part, config);
int mode = config.mode;
if((part == EVISION_V2_KEYBOARD_PART_KEYBOARD) && (mode == EVISION_V2_MODE_CUSTOM))
{
mode |= config.ledmode << 8;
}
config.direction = (config.direction == 0) ? 0 : 1;
// Define default colors
for(std::size_t mode_index = 0; mode_index < modes.size(); mode_index++)
{
if(config.random_colours)
{
if(modes[mode_index].flags & MODE_FLAG_HAS_RANDOM_COLOR)
{
modes[mode_index].color_mode = MODE_COLORS_RANDOM;
}
if(modes[mode_index].colors.size() > 0)
{
modes[mode_index].colors[0] = 0xffffff;
}
}
else
{
if(modes[mode_index].flags & MODE_FLAG_HAS_MODE_SPECIFIC_COLOR)
{
modes[mode_index].color_mode = MODE_COLORS_MODE_SPECIFIC;
}
if(modes[mode_index].colors.size() > 0)
{
modes[mode_index].colors[0] = config.colour;
}
}
if(modes[mode_index].value == mode)
{
modes[mode_index].brightness = config.brightness;
modes[mode_index].speed = config.speed;
if(modes[mode_index].flags & MODE_FLAG_HAS_DIRECTION_LR)
{
modes[mode_index].direction = (1 - config.direction) + MODE_DIRECTION_LEFT;
}
else if(modes[mode_index].flags & MODE_FLAG_HAS_DIRECTION_UD)
{
modes[mode_index].direction = (1 - config.direction) + MODE_DIRECTION_UP;
}
else if(modes[mode_index].flags & MODE_FLAG_HAS_DIRECTION_HV)
{
modes[mode_index].direction = (1 - config.direction) + MODE_DIRECTION_HORIZONTAL;
}
if(part == EVISION_V2_KEYBOARD_PART_KEYBOARD)
{
if(mode == EVISION_V2_MODE_SURMOUNT)
{
switch(config.ledmode)
{
case EVISION_V2_SURMOUNT_MODE_COLOR_RED:
modes[mode_index].colors[0] = ToRGBColor(0xff, 0, 0);
break;
case EVISION_V2_SURMOUNT_MODE_COLOR_YELLOW:
modes[mode_index].colors[0] = ToRGBColor(0xff, 0xff, 0);
break;
case EVISION_V2_SURMOUNT_MODE_COLOR_GREEN:
modes[mode_index].colors[0] = ToRGBColor(0, 0xff, 0);
break;
case EVISION_V2_SURMOUNT_MODE_COLOR_CYAN:
modes[mode_index].colors[0] = ToRGBColor(0, 0xff, 0xff);
break;
default:
break;
}
}
else if(config.mode == EVISION_V2_MODE_CUSTOM)
{
controller->GetLedsCustom(config.ledmode, colors);
}
}
active_mode = mode_index;
}
}
}
void RGBController_EVisionV2Keyboard::ResizeZone(int /*zone*/, int /*new_size*/)
{
/*---------------------------------------------------------*\
| This device does not support resizing zones |
\*---------------------------------------------------------*/
}
void RGBController_EVisionV2Keyboard::DeviceUpdateLEDs()
{
if(part != EVISION_V2_KEYBOARD_PART_KEYBOARD)
{
return;
}
controller->SetLedsDirect(colors);
has_color_set = true;
last_update_time = std::chrono::steady_clock::now();
}
void RGBController_EVisionV2Keyboard::UpdateZoneLEDs(int /*zone*/)
{
DeviceUpdateLEDs();
}
void RGBController_EVisionV2Keyboard::UpdateSingleLED(int led)
{
if(part != EVISION_V2_KEYBOARD_PART_KEYBOARD)
{
return;
}
controller->SetLedDirect(led, colors[led]);
has_color_set = true;
last_update_time = std::chrono::steady_clock::now();
}
void RGBController_EVisionV2Keyboard::SetCustomMode()
{
if(part == EVISION_V2_KEYBOARD_PART_KEYBOARD)
{
active_mode = EVISION_V2_MODE_DIRECT;
}
else
{
active_mode = EVISION_V2_MODE2_STATIC;
}
}
void RGBController_EVisionV2Keyboard::DeviceUpdateMode()
{
mode set_mode = modes[active_mode];
// No mode set packets required for Direct mode
if((part == EVISION_V2_KEYBOARD_PART_KEYBOARD) && (set_mode.value == EVISION_V2_MODE_DIRECT))
{
return;
}
EvisionV2ModeConfig config;
config.mode = set_mode.value & 0xff;
config.brightness = set_mode.brightness;
config.speed = set_mode.speed;
config.direction = 1 - (set_mode.direction & 0x1);
config.random_colours = (set_mode.color_mode == MODE_COLORS_RANDOM);
config.colour = 0;
if(modes[active_mode].colors.size() > 0)
{
config.colour = set_mode.colors[0];
}
config.ledmode = 0;
if(part == EVISION_V2_KEYBOARD_PART_KEYBOARD)
{
if(config.mode == EVISION_V2_MODE_SURMOUNT)
{
hsv_t temp;
rgb2hsv(config.colour, &temp);
if(temp.hue <= 30 || temp.hue > 300)
{
config.ledmode = EVISION_V2_SURMOUNT_MODE_COLOR_RED;
}
else if(temp.hue > 30 && temp.hue <= 90)
{
config.ledmode = EVISION_V2_SURMOUNT_MODE_COLOR_YELLOW;
}
else if(temp.hue > 90 && temp.hue <= 150)
{
config.ledmode = EVISION_V2_SURMOUNT_MODE_COLOR_GREEN;
}
else if(temp.hue > 150 && temp.hue <= 300)
{
config.ledmode = EVISION_V2_SURMOUNT_MODE_COLOR_CYAN;
}
}
else if(config.mode == EVISION_V2_MODE_CUSTOM)
{
config.ledmode = (set_mode.value >> 8) & 0xff;
}
}
controller->SetMode(part, config);
if((part == EVISION_V2_KEYBOARD_PART_KEYBOARD) && (config.mode == EVISION_V2_MODE_CUSTOM))
{
controller->GetLedsCustom(config.ledmode, colors);
SignalUpdate();
}
}
void RGBController_EVisionV2Keyboard::DeviceSaveMode()
{
if(part != EVISION_V2_KEYBOARD_PART_KEYBOARD)
{
return;
}
int value = modes[active_mode].value;
if((value & 0xff) == EVISION_V2_MODE_CUSTOM)
{
controller->SetLedsCustom((value >> 8) & 0xff, colors);
}
}
void RGBController_EVisionV2Keyboard::KeepaliveThread()
{
bool was_active = false;
while(keepalive_thread_run.load())
{
if(modes[active_mode].value == EVISION_V2_MODE_DIRECT && has_color_set)
{
if((std::chrono::steady_clock::now() - last_update_time) > std::chrono::milliseconds(200))
{
controller->RefreshLedDirect();
last_update_time = std::chrono::steady_clock::now();
was_active = true;
}
}
else if(was_active)
{
controller->EndLedsDirect();
was_active = false;
}
std::this_thread::sleep_for(100ms);
}
controller->EndLedsDirect();
}

46
Controllers/EVisionKeyboardController/RGBController_EVisionV2Keyboard.h Normal file
View file

@ -0,0 +1,46 @@
/*-------------------------------------------------------------------*\
| RGBController_EVisionV2KeyboardController.h |
| |
| Generic RGB Interface for EVision V2 RGB Keyboard |
| |
| Le Philousophe 25 Dec 2022 |
\*-------------------------------------------------------------------*/
#pragma once
#include "LogManager.h"
#include "RGBController.h"
#include "EVisionV2KeyboardController.h"
#include <vector>
class RGBController_EVisionV2Keyboard : public RGBController
{
public:
RGBController_EVisionV2Keyboard(EVisionV2KeyboardController* controller_ptr, EVisionV2KeyboardPart part);
~RGBController_EVisionV2Keyboard();
void SetupZones() override;
void ResizeZone(int zone, int new_size) override;
void SetCustomMode() 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 LoadConfig();
void KeepaliveThread();
EVisionV2KeyboardController* controller;
EVisionV2KeyboardPart part;
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;
};