diff --git a/.gitlab/CODEOWNERS b/.gitlab/CODEOWNERS index 4a78231e..288c599b 100644 --- a/.gitlab/CODEOWNERS +++ b/.gitlab/CODEOWNERS @@ -43,6 +43,7 @@ CODEOWNERS @Calcprogrammer1 /Controllers/EVGAGP102GPUController/ /Controllers/EVGAPascalGPUController/ /Controllers/EVGATuringGPUController/ @TheRogueZeta +/Controllers/EVGAUSBController/ @Dr_No /Controllers/EVisionKeyboardController/ /Controllers/EspurnaController/ /Controllers/FanBusController/ @@ -101,5 +102,5 @@ CODEOWNERS @Calcprogrammer1 # that is an exception to the above should be explicitly named here # #-----------------------------------------------------------------------------# [Controllers] -/Controllers/ASRockPolychromeSMBusController/ASRockPolychromeSMBusController.cpp @TheRogueZeta -/Controllers/ASRockPolychromeSMBusController/ASRockPolychromeSMBusController.h @TheRogueZeta +/Controllers/ASRockPolychromeSMBusController/ASRockPolychromeSMBusController.cpp @TheRogueZeta +/Controllers/ASRockPolychromeSMBusController/ASRockPolychromeSMBusController.h @TheRogueZeta diff --git a/60-openrgb.rules b/60-openrgb.rules index d0b936c3..d57fa798 100644 --- a/60-openrgb.rules +++ b/60-openrgb.rules @@ -305,6 +305,15 @@ SUBSYSTEMS=="usb", ATTR{idVendor}=="04d9", ATTR{idProduct}=="0356", TAG+="uacces #---------------------------------------------------------------# SUBSYSTEMS=="usb", ATTR{idVendor}=="0483", ATTR{idProduct}=="5750", TAG+="uaccess" +#---------------------------------------------------------------# +# EVGA Controller Devices # +# # +# Keyboards: # +# EVGA Z15 # +#---------------------------------------------------------------# +SUBSYSTEMS=="usb", ATTR{idVendor}=="3842", ATTR{idProduct}=="2608", TAG+="uaccess", TAG+="EVGA_ANSI_Z15" +SUBSYSTEMS=="usb", ATTR{idVendor}=="3842", ATTR{idProduct}=="260e", TAG+="uaccess", TAG+="EVGA_ISO_Z15" + #---------------------------------------------------------------# # Holtek Devices # # # diff --git a/Controllers/EVGAUSBController/EVGAKeyboardController.cpp b/Controllers/EVGAUSBController/EVGAKeyboardController.cpp new file mode 100644 index 00000000..d071f63b --- /dev/null +++ b/Controllers/EVGAUSBController/EVGAKeyboardController.cpp @@ -0,0 +1,417 @@ +/*-------------------------------------------------------------------*\ +| EVGAKeyboardController.cpp | +| | +| Driver for EVGA Z15 Keyboard | +| | +| Chris M (Dr_No) 25 Nov 2021 | +| | +\*-------------------------------------------------------------------*/ + +#include "EVGAKeyboardController.h" + +static uint8_t packet_map[EVGA_KEYBOARD_FULL_SIZE_KEYCOUNT] = +{ +/*00 ESC F1 F2 F3 F4 F5 F6 F7 F8 F9 */ + 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, + +/*10 F10 F11 F12 PRT SLK PBK ` 1 2 3 */ + 11, 12, 13, 14, 15, 16, 22, 23, 24, 25, + +/*20 4 5 6 7 8 9 0 - = BSP */ + 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, + +/*30 INS HME PUP TAB Q W E R T Y */ + 36, 37, 38, 44, 45, 46, 47, 48, 49, 50, + +/*40 U I O P [ ] \ DEL END PDN */ + 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, + +/*50 CAP A S D F G H J K L */ + 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, + +/*60 ; ' ENT LSH Z X C V B N */ + 76, 77, 78, 83, 84, 85, 86, 87, 88, 89, + +/*70 M , . / RSH UP LCTL LWIN LALT SPC */ + 90, 91, 92, 93, 94, 96, 103, 104, 105, 106, + +/*80 RALT RFNC MENU RCTL LFT DWN RGT NLK NM/ NM* */ + 107, 108, 109, 110, 111, 112, 113, 39, 40, 41, + +/*90 NM- NM+ NETR NM1 NM2 NM3 NM4 NM5 NM6 NM7 */ + 42, 64, 101, 98, 99, 100, 79, 80, 81, 61, + +/*100 NM8 NM9 NM0 NM. PRV PLY NXT MTE */ + 62, 63, 114, 115, 18, 19, 20, 118 +}; + +EVGAKeyboardController::EVGAKeyboardController(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 w_tmp = std::wstring(tmp); + device_name = std::string(w_tmp.begin(), w_tmp.end()); + + hid_get_product_string(dev, tmp, sz); + w_tmp = std::wstring(tmp); + device_name.append(" ").append(std::string(w_tmp.begin(), w_tmp.end())); + + SetSleepTime(); +} + +EVGAKeyboardController::~EVGAKeyboardController() +{ + hid_close(dev); +} + +std::string EVGAKeyboardController::GetDeviceName() +{ + return device_name; +} + +std::string EVGAKeyboardController::GetSerial() +{ + const uint8_t sz = HID_MAX_STR; + wchar_t tmp[sz]; + + hid_get_serial_number_string(dev, tmp, sz); + std::wstring w_tmp = std::wstring(tmp); + std::string serial = std::string(w_tmp.begin(), w_tmp.end()); + + return serial; +} + +std::string EVGAKeyboardController::GetLocation() +{ + return("HID: " + location); +} + +void EVGAKeyboardController::SetLedsDirect(std::vector colors) +{ + uint8_t buffer[EVGA_KEYBOARD_CONTROLLER_ID_6_SIZE] = { 0x06, 0xEA, 0x02, 0x01 }; + + /*-----------------------------------------------------------------*\ + | Set up Direct packet | + | packet_map is the index of the Key from full_matrix_map and | + | the value is the position in the direct packet buffer | + \*-----------------------------------------------------------------*/ + for(size_t i = 0; i < colors.size(); i++) + { + RGBColor key = colors[i]; + uint16_t offset = EVGA_KB_ZONE_BYTE + (packet_map[i] * 4); + + buffer[offset + 0] = EVGA_KEYBOARD_CONTROLLER_BRIGHTNESS_MAX; + buffer[offset + 1] = RGBGetRValue(key); + buffer[offset + 2] = RGBGetGValue(key); + buffer[offset + 3] = RGBGetBValue(key); + } + + buffer[EVGA_KB_CRC_BYTE] = GetChecksum(&buffer[8], EVGA_KEYBOARD_CONTROLLER_ID_6_SIZE - EVGA_KB_ZONE_BYTE); + hid_send_feature_report(dev, buffer, EVGA_KEYBOARD_CONTROLLER_ID_6_SIZE); +} + +void EVGAKeyboardController::SaveMode() +{ + uint8_t buffer[EVGA_KEYBOARD_CONTROLLER_ID_4_SIZE] = { 0x04, 0xEA, 0x02, 0x12 }; + + hid_send_feature_report(dev, buffer, EVGA_KEYBOARD_CONTROLLER_ID_4_SIZE); +} + +void EVGAKeyboardController::SetMode(uint8_t mode, uint16_t speed, uint8_t brightness, + uint8_t direction, std::vector colors) +{ + SetHWModes(); + SendMode(mode, direction); + SendColour(mode, speed, brightness, direction, colors); +} + +void EVGAKeyboardController::GetStatus(mode *mode) +{ + /*-----------------------------------------------------------------*\ + | Gets the status of mode mode->value from the keyboard and then | + | sets Colors, Brightness, Speed, Direction for the mode. | + \*-----------------------------------------------------------------*/ + uint8_t buffer[EVGA_KEYBOARD_CONTROLLER_ID_7_SIZE] = { 0x07, 0xEA, 0x02, 0x0C, 0x01 }; + buffer[EVGA_KB_MODE_BYTE] += mode->value; + + hid_send_feature_report(dev, buffer, EVGA_KEYBOARD_CONTROLLER_ID_7_SIZE); + int result = hid_get_feature_report (dev, buffer, EVGA_KEYBOARD_CONTROLLER_ID_7_SIZE); + + /*-----------------------------------------------------------------*\ + | If the read is successful fill in value from the packet | + \*-----------------------------------------------------------------*/ + if(result > 0) + { + switch(mode->value) + { + case EVGA_KEYBOARD_CONTROLLER_MODE_STATIC: + mode->brightness = FindColours(&buffer[EVGA_KB_SPEED_LSB], mode->colors_max, mode->colors); + break; + + case EVGA_KEYBOARD_CONTROLLER_MODE_BREATHING: + mode->brightness = buffer[27]; + mode->speed = buffer[EVGA_KB_SPEED_LSB] << 8 | buffer[EVGA_KB_SPEED_MSB]; + mode->colors.push_back(ToRGBColor(buffer[28], buffer[29], buffer[30])); + mode->colors.push_back(ToRGBColor(buffer[33], buffer[34], buffer[35])); + break; + + case EVGA_KEYBOARD_CONTROLLER_MODE_PULSE: + mode->brightness = FindColours(&buffer[33], buffer[EVGA_KB_COLORS_SZ], mode->colors); + mode->speed = buffer[EVGA_KB_SPEED_LSB] << 8 | buffer[EVGA_KB_SPEED_MSB]; + break; + + case EVGA_KEYBOARD_CONTROLLER_MODE_SPIRAL: + case EVGA_KEYBOARD_CONTROLLER_MODE_RAINBOW: + case EVGA_KEYBOARD_CONTROLLER_MODE_TRIGGER: + mode->direction = FindDirection(mode->value, buffer[11] + buffer[12]); + mode->brightness = FindColours(&buffer[27], buffer[EVGA_KB_COLORS_SZ], mode->colors); + mode->speed = buffer[EVGA_KB_SPEED_LSB] << 8 | buffer[EVGA_KB_SPEED_MSB]; + break; + + case EVGA_KEYBOARD_CONTROLLER_MODE_STAR: + mode->brightness = buffer[EVGA_KB_COLORS_SZ]; + mode->speed = buffer[EVGA_KB_SPEED_LSB]; + break; + } + LOG_DEBUG("[%s] Mode %d Setup with %d colours @ %04X speed and %02X brightness", device_name.c_str(), mode->value, mode->colors.size(), mode->speed, mode->brightness); + } + else + { + LOG_INFO("[%s] An error occured reading data for mode %d", device_name.c_str(), mode->value); + } +} + +void EVGAKeyboardController::SetHWModes() +{ + /*-----------------------------------------------------------------*\ + | Send Initialise Hardware Modes | + \*-----------------------------------------------------------------*/ + uint8_t buffer[EVGA_KEYBOARD_CONTROLLER_ID_6_SIZE] = { 0x06, 0xEA, 0x02 }; + + hid_send_feature_report(dev, buffer, EVGA_KEYBOARD_CONTROLLER_ID_6_SIZE); +} + +void EVGAKeyboardController::SendMode(uint8_t mode, uint8_t direction) +{ + /*-----------------------------------------------------------------*\ + | Send Mode | + \*-----------------------------------------------------------------*/ + uint8_t buffer[EVGA_KEYBOARD_CONTROLLER_ID_7_SIZE] = { 0x07, 0xEA, 0x02, 0x0C }; + + buffer[EVGA_KB_ZONE_BYTE] = mode; + buffer[EVGA_KB_DIR_BYTE] = direction; + + buffer[EVGA_KB_CRC_BYTE] = GetChecksum(&buffer[8], EVGA_KEYBOARD_CONTROLLER_ID_7_SIZE - EVGA_KB_ZONE_BYTE); + hid_send_feature_report(dev, buffer, EVGA_KEYBOARD_CONTROLLER_ID_7_SIZE); +} + +void EVGAKeyboardController::SendColour(uint8_t mode, uint16_t speed, uint8_t brightness, uint8_t direction, std::vector colors) +{ + uint8_t buffer[EVGA_KEYBOARD_CONTROLLER_ID_7_SIZE] = { 0x07, 0xEA, 0x02, 0x0C }; + + speed *= (mode == EVGA_KEYBOARD_CONTROLLER_MODE_TRIGGER) ? 10 : 100; + buffer[EVGA_KB_MODE_BYTE] += mode; + buffer[EVGA_KB_ZONE_BYTE] = EVGA_KEYBOARD_CONTROLLER_ZONE_ALL_KEYS; //zone + + /*-----------------------------------------------------------------*\ + | Static mode does not have speed but it will be overwritten | + \*-----------------------------------------------------------------*/ + buffer[EVGA_KB_SPEED_LSB] = speed & 0xFF; + buffer[EVGA_KB_SPEED_MSB] = speed >> 8; + /*-----------------------------------------------------------------*\ + | Static, Breathing and Star modes have fixed colour sizes | + | buffer[26] will be overwritten for these modes | + \*-----------------------------------------------------------------*/ + buffer[EVGA_KB_COLORS_SZ] = colors.size(); + + switch(mode) + { + case EVGA_KEYBOARD_CONTROLLER_MODE_STATIC: + FillColours(&buffer[24], brightness, colors); + break; + + case EVGA_KEYBOARD_CONTROLLER_MODE_BREATHING: + for(size_t i = 0; i < colors.size(); i++) + { + uint8_t offset = 26 + (i * 5); + + buffer[offset + 0] = 0x0A; + buffer[offset + 1] = brightness; + buffer[offset + 2] = RGBGetRValue(colors[i]); + buffer[offset + 3] = RGBGetGValue(colors[i]); + buffer[offset + 4] = RGBGetBValue(colors[i]); + } + break; + + case EVGA_KEYBOARD_CONTROLLER_MODE_PULSE: + /*-----------------------------------------------------------------*\ + | Buffer 27 thru 32 could be defining a "Transition Color" | + | 27 Identifier ?? | + | 28 Time in ms ?? | + | 29 - 32 Looks to be "Black" | + \*-----------------------------------------------------------------*/ + buffer[27] = 0x0A; + buffer[28] = 0x0A; + buffer[29] = 0xFF; + + FillColours(&buffer[33], brightness, colors); + break; + + case EVGA_KEYBOARD_CONTROLLER_MODE_SPIRAL: + buffer[11] = direction; + + FillColours(&buffer[27], brightness, colors); + break; + + case EVGA_KEYBOARD_CONTROLLER_MODE_RAINBOW: + buffer[12] = direction; + + FillColours(&buffer[27], brightness, colors); + break; + + case EVGA_KEYBOARD_CONTROLLER_MODE_TRIGGER: + buffer[3]--; //Why EVGA?? + buffer[12] = direction; + + FillColours(&buffer[27], brightness, colors); + break; + + case EVGA_KEYBOARD_CONTROLLER_MODE_STAR: + buffer[3]++; //Why EVGA?? + buffer[26] = brightness; + break; + } + + buffer[EVGA_KB_CRC_BYTE] = GetChecksum(&buffer[8], EVGA_KEYBOARD_CONTROLLER_ID_7_SIZE - EVGA_KB_ZONE_BYTE); + hid_send_feature_report(dev, buffer, EVGA_KEYBOARD_CONTROLLER_ID_7_SIZE); +} + +void EVGAKeyboardController::FillColours(uint8_t * buffer, uint8_t brightness, std::vector colors) +{ + for(size_t i = 0; i < colors.size(); i++) + { + uint8_t offset = (i * 4); + + buffer[offset + 0] = brightness; + buffer[offset + 1] = RGBGetRValue(colors[i]); + buffer[offset + 2] = RGBGetGValue(colors[i]); + buffer[offset + 3] = RGBGetBValue(colors[i]); + } +} + +uint8_t EVGAKeyboardController::GetChecksum(uint8_t * data, uint8_t count) +{ + uint8_t checksum = 0; + + for(size_t i = 0; i < count; i++) + { + checksum -= data[i]; + } + + return checksum; +} + +uint8_t EVGAKeyboardController::FindDirection(uint8_t mode, uint8_t direction) +{ + /*-----------------------------------------------------------------*\ + | Converts EVGAs buffer direction value to OpenRGB's directions | + \*-----------------------------------------------------------------*/ + uint8_t temp = 0; + + for(size_t i = 0; i < sizeof(direction_map[mode]); i++) + { + if(direction_map[mode][i] == direction) + { + temp = direction_map[mode][i]; + break; + } + } + + return temp; +} + +uint8_t EVGAKeyboardController::FindColours(uint8_t * data, uint8_t count, std::vector &colors) +{ + /*-----------------------------------------------------------------*\ + | Converts EVGAs buffer colours to OpenRGB's colours | + \*-----------------------------------------------------------------*/ + colors.clear(); + + for(size_t i = 0; i < count; i++) + { + uint8_t offset = (i * 4); + + colors.push_back(ToRGBColor(data[offset + 1],data[offset + 2],data[offset + 3])); + } + + return data[0]; +} + +uint8_t EVGAKeyboardController::GetMode() +{ + static const uint16_t index = 1289; + NFIPacket(); + /*-----------------------------------------------------------------*\ + | Requests the current set mode from the keyboard | + | | + | Request: 04 ea 02 07 01 00 00 6c 00 00 00 00 00 00 00 00 00 | + | Response: 04 ea 02 07 01 00 c0 6c 04 00 00 00 00 00 00 00 00 | + | Key Count?? ⇗ | + \*-----------------------------------------------------------------*/ + uint8_t buffer[EVGA_KEYBOARD_CONTROLLER_ID_3_SIZE] = { 0x08, 0xEA, 0x02, 0x01, 0xFE }; + + hid_send_feature_report(dev, buffer, EVGA_KEYBOARD_CONTROLLER_ID_3_SIZE); + int result = hid_get_feature_report (dev, buffer, EVGA_KEYBOARD_CONTROLLER_ID_3_SIZE); + + if(result > 0) + { + LOG_DEBUG("[%s] Returned mode %02X - %02X %02X %02X %02X %02X", device_name.c_str(), buffer[index], buffer[index-2], buffer[index-1], buffer[index], buffer[index+1], buffer[index+2]); + return buffer[index]; + } + else + { + LOG_INFO("[%s] An error occured reading current mode", device_name.c_str()); + return 0; + } +} + +void EVGAKeyboardController::NFIPacket() +{ + /*-----------------------------------------------------------------*\ + | Not sure what this packet is doing but it appears to be | + | required to retrieve the current mode from the (first) profile | + \*-----------------------------------------------------------------*/ + uint8_t buffer1[EVGA_KEYBOARD_CONTROLLER_ID_4_SIZE] = { 0x04, 0xEA, 0x02, 0x33, 0x00, 0x00, 0x00, 0x01 }; + hid_send_feature_report(dev, buffer1, EVGA_KEYBOARD_CONTROLLER_ID_4_SIZE); + + uint8_t buffer2[EVGA_KEYBOARD_CONTROLLER_ID_4_SIZE] = { 0x04, 0xEA, 0x02, 0x06, 0x01 }; + hid_send_feature_report(dev, buffer2, EVGA_KEYBOARD_CONTROLLER_ID_4_SIZE); +} + +void EVGAKeyboardController::SetSleepTime() +{ + /*-----------------------------------------------------------------*\ + | After a set timer the LED lighting on this keyboard will "sleep" | + \*-----------------------------------------------------------------*/ + const uint16_t minutes = 0; //Max value in Unleashed is 300min + const uint8_t multiply = 0xEA; + + uint8_t buffer1[EVGA_KEYBOARD_CONTROLLER_ID_7_SIZE] = { 0x07, 0xEA, 0x02, 0x1B, 0x00, 0x00, 0x00, 0xFE, 0x02 }; + hid_send_feature_report(dev, buffer1, EVGA_KEYBOARD_CONTROLLER_ID_7_SIZE); + + uint8_t buffer2[EVGA_KEYBOARD_CONTROLLER_ID_7_SIZE] = { 0x07, 0xEA, 0x02, 0x03 }; + + uint32_t sleep = minutes * multiply; + buffer2[EVGA_KB_ZONE_BYTE] = (sleep == 0) ? 0 : EVGA_KEYBOARD_CONTROLLER_ZONE_ALL_KEYS; //zone + buffer2[9] = sleep & 0xFF; + buffer2[10] = (sleep >> 8) & 0xFF; + buffer2[11] = (sleep >> 16) & 0xFF; + + buffer2[EVGA_KB_CRC_BYTE] = GetChecksum(&buffer2[8], EVGA_KEYBOARD_CONTROLLER_ID_7_SIZE - EVGA_KB_ZONE_BYTE); + hid_send_feature_report(dev, buffer2, EVGA_KEYBOARD_CONTROLLER_ID_7_SIZE); +} diff --git a/Controllers/EVGAUSBController/EVGAKeyboardController.h b/Controllers/EVGAUSBController/EVGAKeyboardController.h new file mode 100644 index 00000000..77708157 --- /dev/null +++ b/Controllers/EVGAUSBController/EVGAKeyboardController.h @@ -0,0 +1,119 @@ +/*-------------------------------------------------------------------*\ +| EVGAKeyboardController.h | +| | +| Driver for EVGA Z15 Keyboard | +| | +| Chris M (Dr_No) 25 Nov 2021 | +| | +\*-------------------------------------------------------------------*/ + +#include +#include +#include "LogManager.h" +#include "RGBController.h" + +#pragma once + +#define NA 0xFFFFFFFF +#define HID_MAX_STR 255 + +#define EVGA_KEYBOARD_CONTROLLER_ID_3_SIZE 1597 +#define EVGA_KEYBOARD_CONTROLLER_ID_4_SIZE 17 +#define EVGA_KEYBOARD_CONTROLLER_ID_6_SIZE 792 +#define EVGA_KEYBOARD_CONTROLLER_ID_7_SIZE 136 +#define EVGA_KEYBOARD_CONTROLLER_INTERRUPT_TIMEOUT 250 + +#define EVGA_KEYBOARD_CONTROLLER_BRIGHTNESS_MIN 0 +#define EVGA_KEYBOARD_CONTROLLER_BRIGHTNESS_MAX 255 +#define EVGA_KEYBOARD_FULL_SIZE_KEYCOUNT 108 + + +static const uint8_t direction_map[8][4] = +{ + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 1, 0, 0, 0 }, //Spiral - Left = Anti Clockwise, Right = Clockwise + { 3, 2, 0, 1 }, //Rainbow + { 0, 0, 0, 0 }, + { 0, 1, 2, 0 }, //Trigger - Right = Typing, Left = Single, Up = 3x3 +}; + +enum EVGA_Keyboard_Controller_Modes +{ + EVGA_KEYBOARD_CONTROLLER_MODE_OFF = 0x00, //Turn off - All leds off + EVGA_KEYBOARD_CONTROLLER_MODE_STATIC = 0x01, //Static Mode - Set entire zone to a single color. + EVGA_KEYBOARD_CONTROLLER_MODE_BREATHING = 0x02, //Breathing Mode - Fades between fully off and fully on. + EVGA_KEYBOARD_CONTROLLER_MODE_PULSE = 0x03, //Flashing Mode - Abruptly changing between fully off and fully on. + EVGA_KEYBOARD_CONTROLLER_MODE_SPIRAL = 0x04, //Spiral Mode - All keys light in a colourful spiral + EVGA_KEYBOARD_CONTROLLER_MODE_RAINBOW = 0x05, //Rainbow Wave Mode - Cycle thru the color spectrum as a wave across all LEDs + EVGA_KEYBOARD_CONTROLLER_MODE_STAR = 0x06, //Starry Night effect + EVGA_KEYBOARD_CONTROLLER_MODE_TRIGGER = 0x07, //Key reactive + EVGA_KEYBOARD_CONTROLLER_MODE_DIRECT = 0xFF, //Direct Led Control - Independently set LEDs in zone +}; + +enum EVGA_Keyboard_Controller_Zones +{ + EVGA_KEYBOARD_CONTROLLER_ZONE_NUMPAD_KEYS = (1 << 0), + EVGA_KEYBOARD_CONTROLLER_ZONE_FUNCTION_KEYS = (1 << 1), + EVGA_KEYBOARD_CONTROLLER_ZONE_NUMBER_KEYS = (1 << 2), + EVGA_KEYBOARD_CONTROLLER_ZONE_ARROW_KEYS = (1 << 3), + EVGA_KEYBOARD_CONTROLLER_ZONE_WASD_KEYS = (1 << 4), + EVGA_KEYBOARD_CONTROLLER_ZONE_ALL_KEYS = (1 << 7), +}; + +enum EVGA_Keyboard_Controller_Byte_Map +{ + EVGA_KB_REPORT_BYTE = 0, + EVGA_KB_COMMAND_BYTE = 1, + EVGA_KB_FUNCTION_BYTE = 2, + EVGA_KB_MODE_BYTE = 3, + EVGA_KB_CRC_BYTE = 7, + EVGA_KB_ZONE_BYTE = 8, + EVGA_KB_DIR_BYTE = 9, + EVGA_KB_SPEED_LSB = 24, + EVGA_KB_SPEED_MSB = 25, + EVGA_KB_COLORS_SZ = 26, +}; + +enum EVGA_Keyboard_Controller_Speed +{ + EVGA_KEYBOARD_CONTROLLER_SPEED_SLOWEST = 0x64, // Slowest speed + EVGA_KEYBOARD_CONTROLLER_SPEED_SLOWISH = 0x3E, // Slowish speed + EVGA_KEYBOARD_CONTROLLER_SPEED_NORMAL = 0x32, // Normal speed + EVGA_KEYBOARD_CONTROLLER_SPEED_FASTEST = 0x05, // Fastest speed +}; + +class EVGAKeyboardController +{ +public: + EVGAKeyboardController(hid_device* dev_handle, const char* path); + ~EVGAKeyboardController(); + + std::string GetDeviceName(); + std::string GetSerial(); + std::string GetLocation(); + + void SaveMode(); + void SetHWModes(); + void SetLedsDirect(std::vector colors); + void SetMode(uint8_t mode, uint16_t speed, uint8_t brightness, + uint8_t direction, std::vector colors); + void SetSleepTime(); + void GetStatus(mode *mode); + uint8_t GetMode(); +private: + std::string device_name; + std::string location; + hid_device* dev; + + void NFIPacket(); + void FillColours(uint8_t * buffer, uint8_t brightness, std::vector colors); + void SendMode(uint8_t mode, uint8_t direction); + void SendColour(uint8_t mode, uint16_t speed, uint8_t brightness, uint8_t direction, std::vector colors); + uint8_t GetChecksum(uint8_t * data, uint8_t count); + + uint8_t FindDirection(uint8_t mode, uint8_t direction); + uint8_t FindColours(uint8_t * data, uint8_t count, std::vector &colors); +}; diff --git a/Controllers/EVGAUSBController/EVGAUSBControllerDetect.cpp b/Controllers/EVGAUSBController/EVGAUSBControllerDetect.cpp new file mode 100644 index 00000000..c71b7a6e --- /dev/null +++ b/Controllers/EVGAUSBController/EVGAUSBControllerDetect.cpp @@ -0,0 +1,35 @@ +#include "Detector.h" +#include "LogManager.h" +#include "RGBController.h" +#include "RGBController_EVGAKeyboard.h" +#include + +/*-----------------------------------------------------*\ +| EVGA USB vendor ID | +\*-----------------------------------------------------*/ +#define EVGA_USB_VID 0x3842 + +/*-----------------------------------------------------*\ +| Keyboard product IDs | +\*-----------------------------------------------------*/ +#define Z15_ISO_PID 0x260E +#define Z15_ANSI_PID 0x2608 + +void DetectEVGAKeyboardControllers(hid_device_info* info, const std::string& name) +{ + static const char* controller_name = "EVGA Keyboard Controller"; + + hid_device* dev = hid_open_path(info->path); + + if(dev) + { + EVGAKeyboardController* controller = new EVGAKeyboardController(dev, info->path); + RGBController_EVGAKeyboard* rgb_controller = new RGBController_EVGAKeyboard(controller); + rgb_controller->name = name; + + ResourceManager::get()->RegisterRGBController(rgb_controller); + } +} + +REGISTER_HID_DETECTOR_IPU("EVGA Z15 Keyboard", DetectEVGAKeyboardControllers, EVGA_USB_VID, Z15_ISO_PID, 1, 0x08, 0x4B); +REGISTER_HID_DETECTOR_IPU("EVGA Z15 Keyboard", DetectEVGAKeyboardControllers, EVGA_USB_VID, Z15_ANSI_PID, 1, 0x08, 0x4B); diff --git a/Controllers/EVGAUSBController/RGBController_EVGAKeyboard.cpp b/Controllers/EVGAUSBController/RGBController_EVGAKeyboard.cpp new file mode 100644 index 00000000..35cf69ca --- /dev/null +++ b/Controllers/EVGAUSBController/RGBController_EVGAKeyboard.cpp @@ -0,0 +1,462 @@ +/*-------------------------------------------------------------------*\ +| RGBController_EVGAKeyboard.cpp | +| | +| Driver for EVGA Z15 Keyboard | +| | +| Chris M (Dr_No) 25 Nov 2021 | +| | +\*-------------------------------------------------------------------*/ + +#include +#include "Colors.h" +#include "RGBControllerKeyNames.h" +#include "RGBController_EVGAKeyboard.h" + +static unsigned int full_matrix_map[6][21] = +{ + { 0, NA, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 104, 105, 106, 107}, + { 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 87, 88, 89, 90}, + { 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 99, 100, 101, 91}, + { 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, NA, NA, NA, NA, 96, 97, 98, NA}, + { 63, NA, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, NA, NA, 75, NA, 93, 94, 95, 92}, + { 76, 77, 78, NA, NA, NA, 79, NA, NA, NA, 80, 81, 82, 83, 84, 85, 86, 102, NA, 103, 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, + 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, // 30 + KEY_EN_HOME, + KEY_EN_PAGE_UP, + + KEY_EN_TAB, + KEY_EN_Q, + KEY_EN_W, + KEY_EN_E, + KEY_EN_R, + KEY_EN_T, + KEY_EN_Y, + KEY_EN_U, // 40 + KEY_EN_I, + KEY_EN_O, + KEY_EN_P, + KEY_EN_LEFT_BRACKET, + KEY_EN_RIGHT_BRACKET, + KEY_EN_ANSI_BACK_SLASH, + KEY_EN_DELETE, + KEY_EN_END, + KEY_EN_PAGE_DOWN, + + KEY_EN_CAPS_LOCK, // 50 + 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, // 60 + KEY_EN_QUOTE, + KEY_EN_ANSI_ENTER, + + KEY_EN_LEFT_SHIFT, + KEY_EN_Z, + KEY_EN_X, + KEY_EN_C, + KEY_EN_V, + KEY_EN_B, + KEY_EN_N, + KEY_EN_M, // 70 + KEY_EN_COMMA, + KEY_EN_PERIOD, + KEY_EN_FORWARD_SLASH, + KEY_EN_RIGHT_SHIFT, + KEY_EN_UP_ARROW, + + KEY_EN_LEFT_CONTROL, + KEY_EN_LEFT_WINDOWS, + KEY_EN_LEFT_ALT, + KEY_EN_SPACE, + KEY_EN_RIGHT_ALT, // 80 + KEY_EN_RIGHT_FUNCTION, + KEY_EN_MENU, + KEY_EN_RIGHT_CONTROL, + KEY_EN_LEFT_ARROW, + KEY_EN_DOWN_ARROW, + KEY_EN_RIGHT_ARROW, + + KEY_EN_NUMPAD_LOCK, + KEY_EN_NUMPAD_DIVIDE, + KEY_EN_NUMPAD_TIMES, + KEY_EN_NUMPAD_MINUS, // 90 + KEY_EN_NUMPAD_PLUS, + KEY_EN_NUMPAD_ENTER, + KEY_EN_NUMPAD_1, + KEY_EN_NUMPAD_2, + KEY_EN_NUMPAD_3, + KEY_EN_NUMPAD_4, + KEY_EN_NUMPAD_5, + KEY_EN_NUMPAD_6, + KEY_EN_NUMPAD_7, + KEY_EN_NUMPAD_8, // 100 + KEY_EN_NUMPAD_9, + KEY_EN_NUMPAD_0, + KEY_EN_NUMPAD_PERIOD, + + KEY_EN_MEDIA_PREVIOUS, + KEY_EN_MEDIA_PLAY_PAUSE, + KEY_EN_MEDIA_NEXT, + KEY_EN_MEDIA_MUTE, +}; + +RGBController_EVGAKeyboard::RGBController_EVGAKeyboard(EVGAKeyboardController* controller_ptr) +{ + /*-----------------------------------------------------*\ + | Initialise the random functions from the clock | + \*-----------------------------------------------------*/ + std::srand(time(NULL)); + + controller = controller_ptr; + + name = "EVGA USB Keyboard"; + vendor = "EVGA"; + type = DEVICE_TYPE_KEYBOARD; + description = controller->GetDeviceName(); + serial = controller->GetSerial(); + location = controller->GetLocation(); + + mode Direct; + Direct.name = "Direct"; + Direct.value = EVGA_KEYBOARD_CONTROLLER_MODE_DIRECT; + Direct.flags = MODE_FLAG_HAS_PER_LED_COLOR; + Direct.color_mode = MODE_COLORS_PER_LED; + modes.push_back(Direct); + + mode Static; + Static.name = "Static"; + Static.value = EVGA_KEYBOARD_CONTROLLER_MODE_STATIC; + Static.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE; + Static.colors_min = 1; + Static.colors_max = 1; + Static.brightness_min = EVGA_KEYBOARD_CONTROLLER_BRIGHTNESS_MIN; + Static.brightness_max = EVGA_KEYBOARD_CONTROLLER_BRIGHTNESS_MAX; + Static.color_mode = MODE_COLORS_MODE_SPECIFIC; + + //controller->GetStatus(&Static); + Static.colors.resize(Static.colors_max); + Static.brightness = EVGA_KEYBOARD_CONTROLLER_BRIGHTNESS_MAX; + modes.push_back(Static); + + mode Breathing; + Breathing.name = "Breathing"; + Breathing.value = EVGA_KEYBOARD_CONTROLLER_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_MANUAL_SAVE; + Breathing.colors_min = 1; + Breathing.colors_max = 2; + Breathing.brightness_min = EVGA_KEYBOARD_CONTROLLER_BRIGHTNESS_MIN; + Breathing.brightness_max = EVGA_KEYBOARD_CONTROLLER_BRIGHTNESS_MAX; + Breathing.speed_min = EVGA_KEYBOARD_CONTROLLER_SPEED_SLOWEST; + Breathing.speed_max = EVGA_KEYBOARD_CONTROLLER_SPEED_FASTEST; + Breathing.color_mode = MODE_COLORS_MODE_SPECIFIC; + + //controller->GetStatus(&Breathing); + Breathing.colors.resize(Breathing.colors_max); + Breathing.brightness = EVGA_KEYBOARD_CONTROLLER_BRIGHTNESS_MAX; + Breathing.speed = EVGA_KEYBOARD_CONTROLLER_SPEED_NORMAL; + modes.push_back(Breathing); + + mode Pulse; + Pulse.name = "Flashing"; + Pulse.value = EVGA_KEYBOARD_CONTROLLER_MODE_PULSE; + Pulse.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE; + Pulse.colors_min = 2; + Pulse.colors_max = 7; + Pulse.brightness_min = EVGA_KEYBOARD_CONTROLLER_BRIGHTNESS_MIN; + Pulse.brightness_max = EVGA_KEYBOARD_CONTROLLER_BRIGHTNESS_MAX; + Pulse.speed_min = EVGA_KEYBOARD_CONTROLLER_SPEED_SLOWEST; + Pulse.speed_max = EVGA_KEYBOARD_CONTROLLER_SPEED_FASTEST; + Pulse.color_mode = MODE_COLORS_MODE_SPECIFIC; + + //controller->GetStatus(&Pulse); + Pulse.colors.resize(Pulse.colors_max); + Pulse.brightness = EVGA_KEYBOARD_CONTROLLER_BRIGHTNESS_MAX; + Pulse.speed = EVGA_KEYBOARD_CONTROLLER_SPEED_NORMAL; + modes.push_back(Pulse); + + mode Spiral; + Spiral.name = "Spiral"; + Spiral.value = EVGA_KEYBOARD_CONTROLLER_MODE_SPIRAL; + Spiral.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_MANUAL_SAVE; + Spiral.colors_min = 7; + Spiral.colors_max = 7; + Spiral.brightness_min = EVGA_KEYBOARD_CONTROLLER_BRIGHTNESS_MIN; + Spiral.brightness_max = EVGA_KEYBOARD_CONTROLLER_BRIGHTNESS_MAX; + Spiral.speed_min = EVGA_KEYBOARD_CONTROLLER_SPEED_SLOWEST; + Spiral.speed_max = EVGA_KEYBOARD_CONTROLLER_SPEED_FASTEST; + Spiral.color_mode = MODE_COLORS_MODE_SPECIFIC; + + //controller->GetStatus(&Spiral); + Spiral.colors.resize(Spiral.colors_max); + Spiral.colors = { COLOR_RED, COLOR_DARKORANGE, COLOR_YELLOW, COLOR_LIME, COLOR_BLUE, COLOR_DARKVIOLET, COLOR_MAGENTA}; + Spiral.brightness = EVGA_KEYBOARD_CONTROLLER_BRIGHTNESS_MAX; + Spiral.speed = EVGA_KEYBOARD_CONTROLLER_SPEED_NORMAL; + modes.push_back(Spiral); + + mode Rainbow; + Rainbow.name = "Rainbow Wave"; + Rainbow.value = EVGA_KEYBOARD_CONTROLLER_MODE_RAINBOW; + Rainbow.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_DIRECTION_UD | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE; + Rainbow.colors_min = 3; + Rainbow.colors_max = 7; + Rainbow.brightness_min = EVGA_KEYBOARD_CONTROLLER_BRIGHTNESS_MIN; + Rainbow.brightness_max = EVGA_KEYBOARD_CONTROLLER_BRIGHTNESS_MAX; + Rainbow.speed_min = EVGA_KEYBOARD_CONTROLLER_SPEED_SLOWISH; + Rainbow.speed_max = EVGA_KEYBOARD_CONTROLLER_SPEED_FASTEST; + Rainbow.color_mode = MODE_COLORS_MODE_SPECIFIC; + + //controller->GetStatus(&Rainbow); + Rainbow.colors.resize(Rainbow.colors_max); + Rainbow.colors = { COLOR_RED, COLOR_DARKORANGE, COLOR_YELLOW, COLOR_LIME, COLOR_BLUE, COLOR_DARKVIOLET, COLOR_MAGENTA}; + Rainbow.brightness = EVGA_KEYBOARD_CONTROLLER_BRIGHTNESS_MAX; + Rainbow.speed = EVGA_KEYBOARD_CONTROLLER_SPEED_NORMAL; + modes.push_back(Rainbow); + + mode Star; + Star.name = "Star Shining"; + Star.value = EVGA_KEYBOARD_CONTROLLER_MODE_STAR; + Star.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE; + Star.brightness_min = EVGA_KEYBOARD_CONTROLLER_BRIGHTNESS_MIN; + Star.brightness_max = EVGA_KEYBOARD_CONTROLLER_BRIGHTNESS_MAX; + Star.speed_min = EVGA_KEYBOARD_CONTROLLER_SPEED_SLOWEST; + Star.speed_max = EVGA_KEYBOARD_CONTROLLER_SPEED_FASTEST; + Star.color_mode = MODE_COLORS_NONE; + + //controller->GetStatus(&Star); + Star.brightness = EVGA_KEYBOARD_CONTROLLER_BRIGHTNESS_MAX; + Star.speed = EVGA_KEYBOARD_CONTROLLER_SPEED_NORMAL; + modes.push_back(Star); + + mode Typing; + Typing.name = "Typing Lighting"; + Typing.value = EVGA_KEYBOARD_CONTROLLER_MODE_TRIGGER; + Typing.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE; + Typing.colors_min = 1; + Typing.colors_max = 7; + Typing.brightness_min = EVGA_KEYBOARD_CONTROLLER_BRIGHTNESS_MIN; + Typing.brightness_max = EVGA_KEYBOARD_CONTROLLER_BRIGHTNESS_MAX; + Typing.speed_min = EVGA_KEYBOARD_CONTROLLER_SPEED_SLOWEST; + Typing.speed_max = EVGA_KEYBOARD_CONTROLLER_SPEED_FASTEST; + Typing.color_mode = MODE_COLORS_MODE_SPECIFIC; + + //controller->GetStatus(&Typing); + Typing.direction = 0; + Typing.colors.resize(Typing.colors_max); + Typing.colors = { COLOR_RED, COLOR_DARKORANGE, COLOR_YELLOW, COLOR_LIME, COLOR_BLUE, COLOR_DARKVIOLET, COLOR_MAGENTA}; + Typing.brightness = EVGA_KEYBOARD_CONTROLLER_BRIGHTNESS_MAX; + Typing.speed = EVGA_KEYBOARD_CONTROLLER_SPEED_NORMAL; + modes.push_back(Typing); + + mode Single; + Single.name = "Reactive (Single Key)"; + Single.value = EVGA_KEYBOARD_CONTROLLER_MODE_TRIGGER; + Single.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE; + Single.colors_min = 1; + Single.colors_max = 7; + Single.brightness_min = EVGA_KEYBOARD_CONTROLLER_BRIGHTNESS_MIN; + Single.brightness_max = EVGA_KEYBOARD_CONTROLLER_BRIGHTNESS_MAX; + Single.speed_min = EVGA_KEYBOARD_CONTROLLER_SPEED_SLOWEST; + Single.speed_max = EVGA_KEYBOARD_CONTROLLER_SPEED_FASTEST; + Single.color_mode = MODE_COLORS_MODE_SPECIFIC; + + //controller->GetStatus(&Single); + Single.direction = 1; + Single.colors.resize(Single.colors_max); + Single.colors = { COLOR_RED, COLOR_DARKORANGE, COLOR_YELLOW, COLOR_LIME, COLOR_BLUE, COLOR_DARKVIOLET, COLOR_MAGENTA}; + Single.brightness = EVGA_KEYBOARD_CONTROLLER_BRIGHTNESS_MAX; + Single.speed = EVGA_KEYBOARD_CONTROLLER_SPEED_NORMAL; + modes.push_back(Single); + + mode ThreeBy3; + ThreeBy3.name = "Reactive (3x3 Key)"; + ThreeBy3.value = EVGA_KEYBOARD_CONTROLLER_MODE_TRIGGER; + ThreeBy3.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE; + ThreeBy3.colors_min = 1; + ThreeBy3.colors_max = 7; + ThreeBy3.brightness_min = EVGA_KEYBOARD_CONTROLLER_BRIGHTNESS_MIN; + ThreeBy3.brightness_max = EVGA_KEYBOARD_CONTROLLER_BRIGHTNESS_MAX; + ThreeBy3.speed_min = EVGA_KEYBOARD_CONTROLLER_SPEED_SLOWEST; + ThreeBy3.speed_max = EVGA_KEYBOARD_CONTROLLER_SPEED_FASTEST; + ThreeBy3.color_mode = MODE_COLORS_MODE_SPECIFIC; + + //controller->GetStatus(&ThreeBy3); + ThreeBy3.direction = 2; + ThreeBy3.colors.resize(ThreeBy3.colors_max); + ThreeBy3.colors = { COLOR_RED, COLOR_DARKORANGE, COLOR_YELLOW, COLOR_LIME, COLOR_BLUE, COLOR_DARKVIOLET, COLOR_MAGENTA}; + ThreeBy3.brightness = EVGA_KEYBOARD_CONTROLLER_BRIGHTNESS_MAX; + ThreeBy3.speed = EVGA_KEYBOARD_CONTROLLER_SPEED_NORMAL; + modes.push_back(ThreeBy3); + + uint8_t set_mode = controller->GetMode(); + //active_mode = set_mode; + SetupZones(); +} + +RGBController_EVGAKeyboard::~RGBController_EVGAKeyboard() +{ + delete controller; +} + +void RGBController_EVGAKeyboard::SetupZones() +{ + /*-------------------------------------------------*\ + | Clear any existing color/LED configuration | + \*-------------------------------------------------*/ + zone KB_zone; + KB_zone.name = "Keyboard Zone"; + KB_zone.type = ZONE_TYPE_MATRIX; + KB_zone.leds_min = EVGA_KEYBOARD_FULL_SIZE_KEYCOUNT; + KB_zone.leds_max = EVGA_KEYBOARD_FULL_SIZE_KEYCOUNT; + KB_zone.leds_count = EVGA_KEYBOARD_FULL_SIZE_KEYCOUNT; + + KB_zone.matrix_map = new matrix_map_type; + KB_zone.matrix_map->height = 6; + KB_zone.matrix_map->width = 21; + KB_zone.matrix_map->map = (unsigned int *)&full_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_EVGAKeyboard::ResizeZone(int /*zone*/, int /*new_size*/) +{ + /*---------------------------------------------------------*\ + | This device does not support resizing zones | + \*---------------------------------------------------------*/ +} + +void RGBController_EVGAKeyboard::DeviceUpdateLEDs() +{ + controller->SetLedsDirect(colors); +} + +void RGBController_EVGAKeyboard::UpdateZoneLEDs(int zone) +{ + std::vector colour; + for(size_t i = 0; i < zones[zone].leds_count; i++) + { + colour.push_back(zones[zone].colors[i]); + } + + controller->SetLedsDirect(colour); +} + +void RGBController_EVGAKeyboard::UpdateSingleLED(int led) +{ + std::vector colour; + colour.push_back(colors[led]); + + controller->SetLedsDirect(colour); +} + +void RGBController_EVGAKeyboard::SetCustomMode() +{ + active_mode = 0; +} + +void RGBController_EVGAKeyboard::DeviceUpdateMode() +{ + /*---------------------------------------------------------*\ + | No mode set packets required for Direct mode but an | + | extra packet is sent when switching back to HW modes | + \*---------------------------------------------------------*/ + mode set_mode = modes[active_mode]; + + if(current_mode == EVGA_KEYBOARD_CONTROLLER_MODE_DIRECT) + { + controller->SetHWModes(); + } + current_mode = set_mode.value; + + if(set_mode.value == EVGA_KEYBOARD_CONTROLLER_MODE_DIRECT) + { + return; + } + + /*---------------------------------------------------------*\ + | Random colours are generated randoms from software | + \*---------------------------------------------------------*/ + uint8_t direction = direction_map[set_mode.value][set_mode.direction]; + std::vector colours = (set_mode.colors); + + if(set_mode.color_mode == MODE_COLORS_RANDOM) + { + for(int i = 0; i < colours.size(); i++) + { + colours[i] = GetRandomColor(); + } + } + + controller->SetMode( set_mode.value, set_mode.speed, set_mode.brightness, direction, colours ); +} + +void RGBController_EVGAKeyboard::DeviceSaveMode() +{ + controller->SaveMode(); +} + +RGBColor RGBController_EVGAKeyboard::GetRandomColor() +{ + return (rand() % 16777215); +} diff --git a/Controllers/EVGAUSBController/RGBController_EVGAKeyboard.h b/Controllers/EVGAUSBController/RGBController_EVGAKeyboard.h new file mode 100644 index 00000000..60864254 --- /dev/null +++ b/Controllers/EVGAUSBController/RGBController_EVGAKeyboard.h @@ -0,0 +1,37 @@ +/*-------------------------------------------------------------------*\ +| RGBController_EVGAKeyboard.h | +| | +| Driver for EVGA Z15 Keyboard | +| | +| Chris M (Dr_No) 25 Nov 2021 | +| | +\*-------------------------------------------------------------------*/ + +#pragma once +#include "RGBController.h" +#include "EVGAKeyboardController.h" + +class RGBController_EVGAKeyboard : public RGBController +{ +public: + RGBController_EVGAKeyboard(EVGAKeyboardController* controller_ptr); + ~RGBController_EVGAKeyboard(); + + void SetupZones(); + void ResizeZone(int zone, int new_size); + + void DeviceUpdateLEDs(); + void UpdateZoneLEDs(int zone); + void UpdateSingleLED(int led); + + void SetCustomMode(); + void DeviceUpdateMode(); + void DeviceSaveMode(); +private: + uint8_t current_mode; + + int GetDeviceMode(); + RGBColor GetRandomColor(); + + EVGAKeyboardController* controller; +}; diff --git a/OpenRGB.pro b/OpenRGB.pro index 74add79a..6116ab34 100644 --- a/OpenRGB.pro +++ b/OpenRGB.pro @@ -325,6 +325,8 @@ HEADERS += Controllers/EVGATuringGPUController/RGBController_EVGAGPUv2.h \ Controllers/EVGAAmpereGPUController/EVGAGPUv3Controller.h \ Controllers/EVGAAmpereGPUController/RGBController_EVGAGPUv3.h \ + Controllers/EVGAUSBController/EVGAKeyboardController.h \ + Controllers/EVGAUSBController/RGBController_EVGAKeyboard.h \ Controllers/EVisionKeyboardController/EVisionKeyboardController.h \ Controllers/EVisionKeyboardController/RGBController_EVisionKeyboard.h \ Controllers/FanBusController/FanBusController.h \ @@ -760,6 +762,9 @@ SOURCES += Controllers/EVGAAmpereGPUController/EVGAGPUv3Controller.cpp \ Controllers/EVGAAmpereGPUController/EVGAAmpereGPUControllerDetect.cpp \ Controllers/EVGAAmpereGPUController/RGBController_EVGAGPUv3.cpp \ + Controllers/EVGAUSBController/EVGAKeyboardController.cpp \ + Controllers/EVGAUSBController/EVGAUSBControllerDetect.cpp \ + Controllers/EVGAUSBController/RGBController_EVGAKeyboard.cpp \ Controllers/EVisionKeyboardController/EVisionKeyboardController.cpp \ Controllers/EVisionKeyboardController/EVisionKeyboardControllerDetect.cpp \ Controllers/EVisionKeyboardController/RGBController_EVisionKeyboard.cpp \