From ccb20f393064561badea3d9c15cb451949df7924 Mon Sep 17 00:00:00 2001 From: Le Philousophe Date: Thu, 22 Dec 2022 08:37:23 +0100 Subject: [PATCH] Add Champion's Bane and Ironclad suport --- .../EVisionKeyboardControllerDetect.cpp | 77 +- .../EVisionV2KeyboardController.cpp | 443 +++++++++ .../EVisionV2KeyboardController.h | 171 ++++ .../RGBController_EVisionV2Keyboard.cpp | 857 ++++++++++++++++++ .../RGBController_EVisionV2Keyboard.h | 46 + OpenRGB.pro | 4 + 6 files changed, 1576 insertions(+), 22 deletions(-) create mode 100644 Controllers/EVisionKeyboardController/EVisionV2KeyboardController.cpp create mode 100644 Controllers/EVisionKeyboardController/EVisionV2KeyboardController.h create mode 100644 Controllers/EVisionKeyboardController/RGBController_EVisionV2Keyboard.cpp create mode 100644 Controllers/EVisionKeyboardController/RGBController_EVisionV2Keyboard.h diff --git a/Controllers/EVisionKeyboardController/EVisionKeyboardControllerDetect.cpp b/Controllers/EVisionKeyboardController/EVisionKeyboardControllerDetect.cpp index 88d30e55..d56c666c 100644 --- a/Controllers/EVisionKeyboardController/EVisionKeyboardControllerDetect.cpp +++ b/Controllers/EVisionKeyboardController/EVisionKeyboardControllerDetect.cpp @@ -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 #include /*-----------------------------------------------------*\ | 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); diff --git a/Controllers/EVisionKeyboardController/EVisionV2KeyboardController.cpp b/Controllers/EVisionKeyboardController/EVisionV2KeyboardController.cpp new file mode 100644 index 00000000..c1775081 --- /dev/null +++ b/Controllers/EVisionKeyboardController/EVisionV2KeyboardController.cpp @@ -0,0 +1,443 @@ +/*-------------------------------------------------------------------*\ +| EVisionV2KeyboardController.cpp | +| | +| Driver for recent EVision RGB keyboard lighting controller | +| | +| Le Philousophe 25 Dec 2022 | +\*-------------------------------------------------------------------*/ + +#include +#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 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, 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, 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, ¤t_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, ¤t_profile); + if(ret < 0) + { + return; + } + if(current_profile > 2) + { + current_profile = 0; + Write(EVISION_V2_CMD_WRITE_CONFIG, EVISION_V2_OFFSET_CURRENT_PROFILE, ¤t_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& 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& 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& 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; +} diff --git a/Controllers/EVisionKeyboardController/EVisionV2KeyboardController.h b/Controllers/EVisionKeyboardController/EVisionV2KeyboardController.h new file mode 100644 index 00000000..509bf6a1 --- /dev/null +++ b/Controllers/EVisionKeyboardController/EVisionV2KeyboardController.h @@ -0,0 +1,171 @@ +/*-------------------------------------------------------------------*\ +| EVisionV2KeyboardController.h | +| | +| Definitions and types for EVision RGB keyboard lighting controller | +| | +| Le Philousophe 25 Dec 2022 | +\*-------------------------------------------------------------------*/ + +#include +#include +#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& colours); + void SetLedDirect(int led, RGBColor colours); + void RefreshLedDirect(); + void EndLedsDirect(); + int GetLedsCustom(uint8_t colorset, std::vector& colours); + void SetLedsCustom(uint8_t colorset, const std::vector& 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; +}; diff --git a/Controllers/EVisionKeyboardController/RGBController_EVisionV2Keyboard.cpp b/Controllers/EVisionKeyboardController/RGBController_EVisionV2Keyboard.cpp new file mode 100644 index 00000000..e9c04389 --- /dev/null +++ b/Controllers/EVisionKeyboardController/RGBController_EVisionV2Keyboard.cpp @@ -0,0 +1,857 @@ +/*-------------------------------------------------------------------*\ +| RGBController_EVisionV2Keyboard.cpp | +| | +| Generic RGB Interface for EVision V2 RGB Keyboard | +| | +| Le Philousophe 25 Dec 2022 | +\*-------------------------------------------------------------------*/ + +#define NA 0xFFFFFFFF + +#include +#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(); +} diff --git a/Controllers/EVisionKeyboardController/RGBController_EVisionV2Keyboard.h b/Controllers/EVisionKeyboardController/RGBController_EVisionV2Keyboard.h new file mode 100644 index 00000000..d8766cf5 --- /dev/null +++ b/Controllers/EVisionKeyboardController/RGBController_EVisionV2Keyboard.h @@ -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 + +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 keepalive_thread_run; + std::atomic has_color_set; + std::chrono::time_point last_update_time; +}; diff --git a/OpenRGB.pro b/OpenRGB.pro index a6b71af0..faba2180 100644 --- a/OpenRGB.pro +++ b/OpenRGB.pro @@ -490,7 +490,9 @@ HEADERS += Controllers/EVGAUSBController/RGBController_EVGAKeyboard.h \ Controllers/EVGAUSBController/RGBController_EVGAMouse.h \ Controllers/EVisionKeyboardController/EVisionKeyboardController.h \ + Controllers/EVisionKeyboardController/EVisionV2KeyboardController.h \ Controllers/EVisionKeyboardController/RGBController_EVisionKeyboard.h \ + Controllers/EVisionKeyboardController/RGBController_EVisionV2Keyboard.h \ Controllers/FanBusController/FanBusController.h \ Controllers/FanBusController/FanBusInterface.h \ Controllers/FanBusController/RGBController_FanBus.h \ @@ -1129,8 +1131,10 @@ SOURCES += Controllers/EVGAUSBController/RGBController_EVGAKeyboard.cpp \ Controllers/EVGAUSBController/RGBController_EVGAMouse.cpp \ Controllers/EVisionKeyboardController/EVisionKeyboardController.cpp \ + Controllers/EVisionKeyboardController/EVisionV2KeyboardController.cpp \ Controllers/EVisionKeyboardController/EVisionKeyboardControllerDetect.cpp \ Controllers/EVisionKeyboardController/RGBController_EVisionKeyboard.cpp \ + Controllers/EVisionKeyboardController/RGBController_EVisionV2Keyboard.cpp \ Controllers/FanBusController/FanBusController.cpp \ Controllers/FanBusController/FanBusControllerDetect.cpp \ Controllers/FanBusController/FanBusInterface.cpp \