From 6292ee166476b4ab81f7eb24e8ea0e48c0bb10bd Mon Sep 17 00:00:00 2001 From: Chris Date: Tue, 5 Apr 2022 23:15:25 +1000 Subject: [PATCH] Initial commit for the Cougar 700K EVO Keyboard to resolve #2310 * Adding entry for the Cougar 700K EVO VID & PID * Registered detectors * Creating CougarKeyboardController class * Creating RGBController_CougarKeyboard class --- .../CougarControllerDetect.cpp | 40 +- .../CougarKeyboardController.cpp | 227 ++++++++ .../CougarKeyboardController.h | 82 +++ .../RGBController_CougarKeyboard.cpp | 513 ++++++++++++++++++ .../RGBController_CougarKeyboard.h | 37 ++ OpenRGB.pro | 4 + 6 files changed, 893 insertions(+), 10 deletions(-) create mode 100644 Controllers/CougarController/CougarKeyboardController.cpp create mode 100644 Controllers/CougarController/CougarKeyboardController.h create mode 100644 Controllers/CougarController/RGBController_CougarKeyboard.cpp create mode 100644 Controllers/CougarController/RGBController_CougarKeyboard.h diff --git a/Controllers/CougarController/CougarControllerDetect.cpp b/Controllers/CougarController/CougarControllerDetect.cpp index 34eb2ef8..a9c88a35 100644 --- a/Controllers/CougarController/CougarControllerDetect.cpp +++ b/Controllers/CougarController/CougarControllerDetect.cpp @@ -1,17 +1,20 @@ #include "Detector.h" -#include "CougarRevengerSTController.h" #include "RGBController.h" + +#include "RGBController_CougarKeyboard.h" #include "RGBController_CougarRevengerST.h" -/*---------------------------------------------------------*\ -| Cougar vendor ID | -\*---------------------------------------------------------*/ -#define COUGAR_VID 0x12CF +/*----------------------------------------------------------*\ +| Cougar vendor ID | +\*----------------------------------------------------------*/ +#define COUGAR_VID 0x12CF +#define COUGAR_VID_2 0x060B -/*---------------------------------------------------------*\ -| Product ID | -\*---------------------------------------------------------*/ -#define COUGAR_REVENGER_ST_PID 0x0412 +/*----------------------------------------------------------*\ +| Product ID | +\*----------------------------------------------------------*/ +#define COUGAR_700K_EVO_PID 0x7010 +#define COUGAR_REVENGER_ST_PID 0x0412 void DetectCougarRevengerSTControllers(hid_device_info* info, const std::string& name) { @@ -26,4 +29,21 @@ void DetectCougarRevengerSTControllers(hid_device_info* info, const std::string& } } -REGISTER_HID_DETECTOR_IPU("Cougar Revenger ST", DetectCougarRevengerSTControllers, COUGAR_VID, COUGAR_REVENGER_ST_PID, 0, 0x0001, 0x02); + +void DetectCougar700kEvo(hid_device_info* info, const std::string& name) +{ + hid_device* dev = hid_open_path(info->path); + + if (dev) + { + CougarKeyboardController* controller = new CougarKeyboardController(dev, info->path); + RGBController_CougarKeyboard* rgb_controller = new RGBController_CougarKeyboard(controller); + rgb_controller->name = name; + + ResourceManager::get()->RegisterRGBController(rgb_controller); + } +} + + +REGISTER_HID_DETECTOR_IPU("Cougar 700K EVO Gaming Keyboard", DetectCougar700kEvo, COUGAR_VID_2, COUGAR_700K_EVO_PID, 3, 0xFF00, 1); +REGISTER_HID_DETECTOR_IPU("Cougar Revenger ST", DetectCougarRevengerSTControllers, COUGAR_VID, COUGAR_REVENGER_ST_PID, 0, 0x0001, 2); diff --git a/Controllers/CougarController/CougarKeyboardController.cpp b/Controllers/CougarController/CougarKeyboardController.cpp new file mode 100644 index 00000000..3fe1f951 --- /dev/null +++ b/Controllers/CougarController/CougarKeyboardController.cpp @@ -0,0 +1,227 @@ +/*-------------------------------------------------------------------*\ +| CougarKeyboardController.cpp | +| | +| Driver for CougarKeyboard USB Controller | +| | +| Chris M (DrNo) 5 Apr 2022 | +\*-------------------------------------------------------------------*/ + +#include +#include "CougarKeyboardController.h" + +using namespace std::chrono_literals; + +static uint8_t keyvalue_map[113] = +{ +/*00 ESC F1 F2 F3 F4 F5 F6 F7 F8 F9 */ + 0, 9, 18, 27, 36, 45, 54, 63, 72, 81, + +/*10 F10 F11 F12 PRT SLK PBK PLY VDN VUP MTE */ + 90, 99, 108, 117, 126, 15, 135, 140, 141, 142, + +/*20 ` 1 2 3 4 5 6 7 8 9 */ + 1, 10, 19, 28, 37, 46, 55, 64, 73, 82, + +/*30 0 - = BSP INS HME PUP NLK NM/ NM* */ + 91, 100, 109, 127, 128, 24, 33, 42, 51, 60, + +/*40 NM- TAB Q W E R T Y U I */ + 69, 2, 11, 20, 29, 38, 47, 56, 65, 74, + +/*50 O P [ ] \ DEL END PDN NM7 NM8 */ + 83, 92, 101, 110, 119, 129, 78, 87, 96, 105, + +/*60 NM9 NM+ CAP A S D F G H J */ + 16, 25, 3, 12, 21, 30, 39, 48, 57, 66, + +/*70 K L ; ' ENT NM4 NM5 NM6 LSH Z */ + 75, 84, 93, 102, 120, 34, 43, 52, 4, 22, + +/*80 X C V B N M , . / RSH */ + 31, 40, 49, 58, 67, 76, 85, 94, 103, 121, + +/*90 UP NM1 NM2 NM3 NETR LCTL LWIN LALT SPC RALT */ + 130, 70, 79, 88, 106, 5, 14, 23, 50, 86, + +/*100 RWIN RFNC RCTL LFT DWN RGT NM0 NM. G1 G2 */ + 95, 104, 113, 122, 131, 132, 133, 97, 147, 148, + +/*110 G3 G4 G5 */ + 149, 150, 151 +}; + +CougarKeyboardController::CougarKeyboardController(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())); +} + +CougarKeyboardController::~CougarKeyboardController() +{ + hid_close(dev); +} + +std::string CougarKeyboardController::GetDeviceName() +{ + return device_name; +} + +std::string CougarKeyboardController::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 CougarKeyboardController::GetLocation() +{ + return("HID: " + location); +} + +void CougarKeyboardController::SetMode(uint8_t mode, uint8_t speed, uint8_t brightness, uint8_t direction, std::vector colours, bool random_colours) +{ + uint8_t buffer[COUGARKEYBOARDCONTROLLER_WRITE_PACKET_SIZE] = { 0x00, 0x14, 0x2C }; + + buffer[COUGARKEYBOARDCONTROLLER_MODE_BYTE] = mode; + buffer[COUGARKEYBOARDCONTROLLER_SPEED_BYTE] = speed; + buffer[COUGARKEYBOARDCONTROLLER_BRIGHTNESS_BYTE] = brightness; + buffer[COUGARKEYBOARDCONTROLLER_RANDOM_BYTE] = (random_colours) ? 1 : 0; + buffer[COUGARKEYBOARDCONTROLLER_DIRECTION_BYTE] = direction; + + switch(mode) + { + /*-----------------------------------------------------*\ + | Off mode does not need any further settings & should | + | skip the default case to avoid an indexing error | + \*-----------------------------------------------------*/ + case COUGARKEYBOARDCONTROLLER_MODE_OFF: + break; + + /*-----------------------------------------------------*\ + | Spectrum Cycle mode (Circle) always sets random | + \*-----------------------------------------------------*/ + case COUGARKEYBOARDCONTROLLER_MODE_CIRCLE: + buffer[COUGARKEYBOARDCONTROLLER_RANDOM_BYTE] = 1; + break; + + /*-----------------------------------------------------*\ + | Wave mode does not have a true "random" colour and | + | needs to set the "rainbow" mode (val = 2) instead | + \*-----------------------------------------------------*/ + case COUGARKEYBOARDCONTROLLER_MODE_WAVE: + buffer[COUGARKEYBOARDCONTROLLER_RANDOM_BYTE] = (random_colours) ? 2 : 0; + buffer[COUGARKEYBOARDCONTROLLER_DATA_BYTE] = 2; + + case COUGARKEYBOARDCONTROLLER_MODE_RIPPLE: + case COUGARKEYBOARDCONTROLLER_MODE_SCAN: + { + uint8_t count = colours.size(); + uint8_t timer = 100 / count; + buffer[COUGARKEYBOARDCONTROLLER_DATA_BYTE + 1] = count; + + for(size_t i = 0; i < count; i++) + { + uint8_t offset = 11 + (i * 4); + + buffer[offset] = (i + 1) * timer; + buffer[offset + 1] = RGBGetRValue(colours[i]); + buffer[offset + 2] = RGBGetGValue(colours[i]); + buffer[offset + 3] = RGBGetBValue(colours[i]); + } + } + break; + + case COUGARKEYBOARDCONTROLLER_MODE_RHYTHM: + buffer[COUGARKEYBOARDCONTROLLER_RANDOM_BYTE] = (random_colours) ? 2 : 0; + + default: + buffer[COUGARKEYBOARDCONTROLLER_DATA_BYTE + 1] = RGBGetRValue(colours[0]); + buffer[COUGARKEYBOARDCONTROLLER_DATA_BYTE + 2] = RGBGetGValue(colours[0]); + buffer[COUGARKEYBOARDCONTROLLER_DATA_BYTE + 3] = RGBGetBValue(colours[0]); + break; + } + + hid_write(dev, buffer, COUGARKEYBOARDCONTROLLER_WRITE_PACKET_SIZE); +} + +void CougarKeyboardController::SetLedsDirect(std::vector colours) +{ + uint8_t max_leds = 14; + uint8_t leds_remaining = colours.size(); + uint8_t packet_flag = COUGARKEYBOARDCONTROLLER_DIRECTION_BYTE; + uint8_t buffer[COUGARKEYBOARDCONTROLLER_WRITE_PACKET_SIZE] = { 0x00, 0x14, 0x2C, 0x0B, 0x00, 0xFF, 0x64, 0x00, 0x01 }; + + /*-----------------------------------------------------------------*\ + | Set up Direct packet | + | keyvalue_map is the index of the Key from full_matrix_map | + \*-----------------------------------------------------------------*/ + for(size_t leds2send = 0; leds2send < leds_remaining; leds2send += max_leds) + { + /*-----------------------------------------------------------------*\ + | Check if there is enough leds for another pass | + \*-----------------------------------------------------------------*/ + if(leds2send + max_leds > leds_remaining) + { + max_leds = leds_remaining - leds2send; + + /*-----------------------------------------------------------------*\ + | The last packet flag should be 0x03 | + \*-----------------------------------------------------------------*/ + buffer[packet_flag] = 3; + } + + for(size_t i = 0; i < max_leds; i++) + { + uint8_t offset = COUGARKEYBOARDCONTROLLER_DATA_BYTE + (i * 4); + uint8_t led_num = leds2send + i; + + buffer[offset] = keyvalue_map[led_num]; + buffer[offset + 1] = RGBGetRValue(colours[led_num]); + buffer[offset + 2] = RGBGetGValue(colours[led_num]); + buffer[offset + 3] = RGBGetBValue(colours[led_num]); + } + hid_write(dev, buffer, COUGARKEYBOARDCONTROLLER_WRITE_PACKET_SIZE); + std::this_thread::sleep_for(1ms); + + /*-----------------------------------------------------------------*\ + | After the first packet the packet flag should be 0x02 | + \*-----------------------------------------------------------------*/ + buffer[packet_flag] = 2; + } +} + +void CougarKeyboardController::Save(uint8_t flag) +{ + uint8_t buffer[COUGARKEYBOARDCONTROLLER_WRITE_PACKET_SIZE] = { 0x00, 0x12, flag, 0x00, 0x00 }; + + hid_write(dev, buffer, COUGARKEYBOARDCONTROLLER_WRITE_PACKET_SIZE); +} + +void CougarKeyboardController::SendProfile(uint8_t profile, uint8_t light) +{ + uint8_t buffer[COUGARKEYBOARDCONTROLLER_WRITE_PACKET_SIZE] = { 0x00, 0x14, 0x00, 0x00, 0x00, profile, light, 0x00, 0x00}; + + hid_write(dev, buffer, COUGARKEYBOARDCONTROLLER_WRITE_PACKET_SIZE); +} diff --git a/Controllers/CougarController/CougarKeyboardController.h b/Controllers/CougarController/CougarKeyboardController.h new file mode 100644 index 00000000..7120ec34 --- /dev/null +++ b/Controllers/CougarController/CougarKeyboardController.h @@ -0,0 +1,82 @@ +/*-------------------------------------------------------------------*\ +| CougarKeyboardController.h | +| | +| Driver for CougarKeyboard USB Controller | +| | +| Chris M (DrNo) 5 Apr 2022 | +\*-------------------------------------------------------------------*/ + +#include +#include +#include "RGBController.h" + +#pragma once + +#define COUGARKEYBOARDCONTROLLER_WRITE_PACKET_SIZE 65 //Buffer requires a prepended ReportID hence + 1 +#define HID_MAX_STR 255 + +#define COUGARKEYBOARDCONTROLLER_BRIGHTNESS_MIN 0 +#define COUGARKEYBOARDCONTROLLER_BRIGHTNESS_MAX 100 +#define COUGARKEYBOARDCONTROLLER_MATRIX_WIDTH 23 + +static const uint8_t direction_map[6] = +{ + 4, 0, 6, 2, 11, 12 //Left, Right, Up, Down, Horizontal, Vertical +}; + +enum Cougar_Keyboard_Controller_Modes +{ + COUGARKEYBOARDCONTROLLER_MODE_OFF = 0x0C, //Turn off - All leds off + COUGARKEYBOARDCONTROLLER_MODE_DIRECT = 0x0B, //Customize Mode + COUGARKEYBOARDCONTROLLER_MODE_STATIC = 0x00, //Steady Mode + COUGARKEYBOARDCONTROLLER_MODE_BREATHING = 0x01, //Breathing Mode - Fades between fully off and fully on. + COUGARKEYBOARDCONTROLLER_MODE_CIRCLE = 0x02, + COUGARKEYBOARDCONTROLLER_MODE_REACTIVE = 0x03, //Click Mode + COUGARKEYBOARDCONTROLLER_MODE_WAVE = 0x04, + COUGARKEYBOARDCONTROLLER_MODE_RIPPLE = 0x05, + COUGARKEYBOARDCONTROLLER_MODE_STAR = 0x06, + COUGARKEYBOARDCONTROLLER_MODE_SCAN = 0x07, + COUGARKEYBOARDCONTROLLER_MODE_RHYTHM = 0x08, + COUGARKEYBOARDCONTROLLER_MODE_RAIN = 0x09, + COUGARKEYBOARDCONTROLLER_MODE_SNAKE = 0x0A, +}; + +enum Cougar_Keyboard_Controller_Byte_Map +{ + COUGARKEYBOARDCONTROLLER_REPORT_BYTE = 1, + COUGARKEYBOARDCONTROLLER_COMMAND_BYTE = 2, + COUGARKEYBOARDCONTROLLER_MODE_BYTE = 3, + COUGARKEYBOARDCONTROLLER_SPEED_BYTE = 5, + COUGARKEYBOARDCONTROLLER_BRIGHTNESS_BYTE = 6, + COUGARKEYBOARDCONTROLLER_RANDOM_BYTE = 7, + COUGARKEYBOARDCONTROLLER_DIRECTION_BYTE = 8, + COUGARKEYBOARDCONTROLLER_DATA_BYTE = 9, +}; + +enum Cougar_Keyboard_Controller_Speeds +{ + COUGARKEYBOARDCONTROLLER_SPEED_SLOWEST = 0x0A, // Slowest speed + COUGARKEYBOARDCONTROLLER_SPEED_NORMAL = 0x05, // Normal speed + COUGARKEYBOARDCONTROLLER_SPEED_FASTEST = 0x01, // Fastest speed +}; + +class CougarKeyboardController +{ +public: + CougarKeyboardController(hid_device* dev_handle, const char* path); + ~CougarKeyboardController(); + + std::string GetDeviceName(); + std::string GetSerial(); + std::string GetLocation(); + + void SetMode(uint8_t mode, uint8_t speed, uint8_t brightness, uint8_t direction, std::vector colours, bool random_colours); + void SetLedsDirect(std::vector colours); + void Save(uint8_t flag); + void SendProfile(uint8_t profile, uint8_t light); +private: + std::string device_name; + std::string serial; + std::string location; + hid_device* dev; +}; diff --git a/Controllers/CougarController/RGBController_CougarKeyboard.cpp b/Controllers/CougarController/RGBController_CougarKeyboard.cpp new file mode 100644 index 00000000..bddda10f --- /dev/null +++ b/Controllers/CougarController/RGBController_CougarKeyboard.cpp @@ -0,0 +1,513 @@ +/*-------------------------------------------------------------------*\ +| RGBController_CougarKeyboard.cpp | +| | +| Driver for CougarKeyboard USB Controller | +| | +| Chris M (DrNo) 5 Apr 2022 | +\*-------------------------------------------------------------------*/ + +#define NA 0xFFFFFFFF + +#include +#include "hsv.h" +#include "RGBControllerKeyNames.h" +#include "RGBController_CougarKeyboard.h" + +using namespace std::chrono_literals; + +static unsigned int matrix_map[6][COUGARKEYBOARDCONTROLLER_MATRIX_WIDTH] = +{ + { NA, 0, NA, 1, 2, 3, 4, 5, 6, 7, 8, NA, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19 }, + { 108, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, NA, 34, 35, 36, 37, 38, 39, 40 }, + { 109, 41, NA, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61 }, + { 110, 62, NA, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, NA, 74, NA, NA, NA, 75, 76, 77, NA }, + { 111, 78, NA, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, NA, 89, NA, NA, 90, NA, 91, 92, 93, 94 }, + { 112, 95, 96, 97, NA, NA, NA, 98, NA, NA, NA, 99, 100, NA, 101, 102, 103, 104, 105, 106, NA, 107, 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_MEDIA_PLAY_PAUSE, //OPEN MEDIA + KEY_EN_MEDIA_VOLUME_DOWN, + KEY_EN_MEDIA_VOLUME_UP, + KEY_EN_MEDIA_MUTE, + + KEY_EN_BACK_TICK, //20 + KEY_EN_1, + KEY_EN_2, + KEY_EN_3, + KEY_EN_4, + KEY_EN_5, + KEY_EN_6, + KEY_EN_7, + KEY_EN_8, + KEY_EN_9, + KEY_EN_0, //30 + KEY_EN_MINUS, + KEY_EN_EQUALS, + KEY_EN_BACKSPACE, + KEY_EN_INSERT, + KEY_EN_HOME, + KEY_EN_PAGE_UP, + KEY_EN_NUMPAD_LOCK, + KEY_EN_NUMPAD_DIVIDE, + KEY_EN_NUMPAD_TIMES, + KEY_EN_NUMPAD_MINUS, //40 + + KEY_EN_TAB, + KEY_EN_Q, + KEY_EN_W, + KEY_EN_E, + KEY_EN_R, + KEY_EN_T, + KEY_EN_Y, + KEY_EN_U, + KEY_EN_I, + KEY_EN_O, //50 + 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_NUMPAD_7, + KEY_EN_NUMPAD_8, + KEY_EN_NUMPAD_9, //60 + KEY_EN_NUMPAD_PLUS, + + KEY_EN_CAPS_LOCK, + KEY_EN_A, + KEY_EN_S, + KEY_EN_D, + KEY_EN_F, + KEY_EN_G, + KEY_EN_H, + KEY_EN_J, + KEY_EN_K, //70 + KEY_EN_L, + KEY_EN_SEMICOLON, + KEY_EN_QUOTE, + KEY_EN_ANSI_ENTER, + KEY_EN_NUMPAD_4, + KEY_EN_NUMPAD_5, + KEY_EN_NUMPAD_6, + + KEY_EN_LEFT_SHIFT, + KEY_EN_Z, + KEY_EN_X, //80 + KEY_EN_C, + KEY_EN_V, + 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, //90 + KEY_EN_NUMPAD_1, + KEY_EN_NUMPAD_2, + KEY_EN_NUMPAD_3, + KEY_EN_NUMPAD_ENTER, + + KEY_EN_LEFT_CONTROL, + KEY_EN_LEFT_WINDOWS, + KEY_EN_LEFT_ALT, + KEY_EN_SPACE, + KEY_EN_RIGHT_ALT, + KEY_EN_RIGHT_WINDOWS, //100 + KEY_EN_RIGHT_FUNCTION, + KEY_EN_RIGHT_CONTROL, + KEY_EN_LEFT_ARROW, + KEY_EN_DOWN_ARROW, + KEY_EN_RIGHT_ARROW, + KEY_EN_NUMPAD_0, + KEY_EN_NUMPAD_PERIOD, + + "Key: G1", + "Key: G2", + "Key: G3", //110 + "Key: G4", + "Key: G5" +}; + +/**------------------------------------------------------------------*\ + @name Cougar 700K Evo Keyboard + @category Keyboard + @type USB + @save :white_check_mark: + @direct :white_check_mark: + @effects :white_check_mark: + @detectors DetectCougar700kEvo + @comment The Cougar 700K Evo controller implements all hardware modes + found in the OEM software but has not been able to include all + options for some modes. eg. Rainbow colour mode. Music mode was + deteremined to be a software driven effect which can be added with + the (OpenRGB Effects Engine plugin)[https://gitlab.com/OpenRGBDevelopers/OpenRGBEffectsPlugin]. +\*-------------------------------------------------------------------*/ + +RGBController_CougarKeyboard::RGBController_CougarKeyboard(CougarKeyboardController *controller_ptr) +{ + controller = controller_ptr; + + name = "CougarKeyboard"; + vendor = "Cougar"; + type = DEVICE_TYPE_KEYBOARD; + description = controller->GetDeviceName(); + serial = controller->GetSerial(); + location = controller->GetLocation(); + + mode Direct; + Direct.name = "Direct"; + Direct.value = COUGARKEYBOARDCONTROLLER_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 = COUGARKEYBOARDCONTROLLER_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.colors.resize(Static.colors_max); + Static.brightness_min = COUGARKEYBOARDCONTROLLER_BRIGHTNESS_MIN; + Static.brightness_max = COUGARKEYBOARDCONTROLLER_BRIGHTNESS_MAX; + Static.brightness = COUGARKEYBOARDCONTROLLER_BRIGHTNESS_MAX; + Static.color_mode = MODE_COLORS_MODE_SPECIFIC; + modes.push_back(Static); + + mode Breathing; + Breathing.name = "Breathing"; + Breathing.value = COUGARKEYBOARDCONTROLLER_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 = 1; + Breathing.colors.resize(Breathing.colors_max); + Breathing.brightness_min = COUGARKEYBOARDCONTROLLER_BRIGHTNESS_MIN; + Breathing.brightness_max = COUGARKEYBOARDCONTROLLER_BRIGHTNESS_MAX; + Breathing.brightness = COUGARKEYBOARDCONTROLLER_BRIGHTNESS_MAX; + Breathing.speed_min = COUGARKEYBOARDCONTROLLER_SPEED_SLOWEST; + Breathing.speed_max = COUGARKEYBOARDCONTROLLER_SPEED_FASTEST; + Breathing.color_mode = MODE_COLORS_MODE_SPECIFIC; + Breathing.speed = COUGARKEYBOARDCONTROLLER_SPEED_NORMAL; + modes.push_back(Breathing); + + mode Circle; + Circle.name = "Spectrum Cycle"; + Circle.value = COUGARKEYBOARDCONTROLLER_MODE_CIRCLE; + Circle.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE; + Circle.brightness_min = COUGARKEYBOARDCONTROLLER_BRIGHTNESS_MIN; + Circle.brightness_max = COUGARKEYBOARDCONTROLLER_BRIGHTNESS_MAX; + Circle.brightness = COUGARKEYBOARDCONTROLLER_BRIGHTNESS_MAX; + Circle.speed_min = COUGARKEYBOARDCONTROLLER_SPEED_SLOWEST; + Circle.speed_max = COUGARKEYBOARDCONTROLLER_SPEED_FASTEST; + Circle.color_mode = MODE_COLORS_NONE; + Circle.speed = COUGARKEYBOARDCONTROLLER_SPEED_NORMAL; + modes.push_back(Circle); + + mode Reactive; + Reactive.name = "Reactive"; + Reactive.value = COUGARKEYBOARDCONTROLLER_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_MANUAL_SAVE; + Reactive.colors_min = 1; + Reactive.colors_max = 1; + Reactive.colors.resize(Reactive.colors_max); + Reactive.brightness_min = COUGARKEYBOARDCONTROLLER_BRIGHTNESS_MIN; + Reactive.brightness_max = COUGARKEYBOARDCONTROLLER_BRIGHTNESS_MAX; + Reactive.brightness = COUGARKEYBOARDCONTROLLER_BRIGHTNESS_MAX; + Reactive.speed_min = COUGARKEYBOARDCONTROLLER_SPEED_SLOWEST; + Reactive.speed_max = COUGARKEYBOARDCONTROLLER_SPEED_FASTEST; + Reactive.color_mode = MODE_COLORS_MODE_SPECIFIC; + Reactive.speed = COUGARKEYBOARDCONTROLLER_SPEED_NORMAL; + modes.push_back(Reactive); + + mode Wave; + Wave.name = "Wave"; + Wave.value = COUGARKEYBOARDCONTROLLER_MODE_WAVE; + Wave.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | + MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_DIRECTION_UD | MODE_FLAG_MANUAL_SAVE; + Wave.colors_min = 1; + Wave.colors_max = 1; + Wave.colors.resize(Wave.colors_max); + Wave.brightness_min = COUGARKEYBOARDCONTROLLER_BRIGHTNESS_MIN; + Wave.brightness_max = COUGARKEYBOARDCONTROLLER_BRIGHTNESS_MAX; + Wave.brightness = COUGARKEYBOARDCONTROLLER_BRIGHTNESS_MAX; + Wave.speed_min = COUGARKEYBOARDCONTROLLER_SPEED_SLOWEST; + Wave.speed_max = COUGARKEYBOARDCONTROLLER_SPEED_FASTEST; + Wave.color_mode = MODE_COLORS_MODE_SPECIFIC; + Wave.speed = COUGARKEYBOARDCONTROLLER_SPEED_NORMAL; + modes.push_back(Wave); + + mode Ripple; + Ripple.name = "Ripple"; + Ripple.value = COUGARKEYBOARDCONTROLLER_MODE_RIPPLE; + Ripple.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | + MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE; + Ripple.colors_min = 1; + Ripple.colors_max = 1; + Ripple.colors.resize(Ripple.colors_max); + Ripple.brightness_min = COUGARKEYBOARDCONTROLLER_BRIGHTNESS_MIN; + Ripple.brightness_max = COUGARKEYBOARDCONTROLLER_BRIGHTNESS_MAX; + Ripple.brightness = COUGARKEYBOARDCONTROLLER_BRIGHTNESS_MAX; + Ripple.speed_min = COUGARKEYBOARDCONTROLLER_SPEED_SLOWEST; + Ripple.speed_max = COUGARKEYBOARDCONTROLLER_SPEED_FASTEST; + Ripple.color_mode = MODE_COLORS_MODE_SPECIFIC; + Ripple.speed = COUGARKEYBOARDCONTROLLER_SPEED_NORMAL; + modes.push_back(Ripple); + + mode Star; + Star.name = "Star"; + Star.value = COUGARKEYBOARDCONTROLLER_MODE_STAR; + Star.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | + MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE; + Star.colors_min = 1; + Star.colors_max = 1; + Star.colors.resize(Star.colors_max); + Star.brightness_min = COUGARKEYBOARDCONTROLLER_BRIGHTNESS_MIN; + Star.brightness_max = COUGARKEYBOARDCONTROLLER_BRIGHTNESS_MAX; + Star.brightness = COUGARKEYBOARDCONTROLLER_BRIGHTNESS_MAX; + Star.speed_min = COUGARKEYBOARDCONTROLLER_SPEED_SLOWEST; + Star.speed_max = COUGARKEYBOARDCONTROLLER_SPEED_FASTEST; + Star.color_mode = MODE_COLORS_MODE_SPECIFIC; + Star.speed = COUGARKEYBOARDCONTROLLER_SPEED_NORMAL; + modes.push_back(Star); + + mode Scan; + Scan.name = "Scan"; + Scan.value = COUGARKEYBOARDCONTROLLER_MODE_SCAN; + Scan.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | + MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_DIRECTION_UD | + MODE_FLAG_HAS_DIRECTION_HV | MODE_FLAG_MANUAL_SAVE; + Scan.colors_min = 1; + Scan.colors_max = 1; + Scan.colors.resize(Scan.colors_max); + Scan.brightness_min = COUGARKEYBOARDCONTROLLER_BRIGHTNESS_MIN; + Scan.brightness_max = COUGARKEYBOARDCONTROLLER_BRIGHTNESS_MAX; + Scan.brightness = COUGARKEYBOARDCONTROLLER_BRIGHTNESS_MAX; + Scan.speed_min = COUGARKEYBOARDCONTROLLER_SPEED_SLOWEST; + Scan.speed_max = COUGARKEYBOARDCONTROLLER_SPEED_FASTEST; + Scan.color_mode = MODE_COLORS_MODE_SPECIFIC; + Scan.speed = COUGARKEYBOARDCONTROLLER_SPEED_NORMAL; + modes.push_back(Scan); + + mode Rhythm; + Rhythm.name = "Rhythm"; + Rhythm.value = COUGARKEYBOARDCONTROLLER_MODE_RHYTHM; + Rhythm.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | + MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE; + Rhythm.colors_min = 1; + Rhythm.colors_max = 1; + Rhythm.colors.resize(Rhythm.colors_max); + Rhythm.brightness_min = COUGARKEYBOARDCONTROLLER_BRIGHTNESS_MIN; + Rhythm.brightness_max = COUGARKEYBOARDCONTROLLER_BRIGHTNESS_MAX; + Rhythm.brightness = COUGARKEYBOARDCONTROLLER_BRIGHTNESS_MAX; + Rhythm.speed_min = COUGARKEYBOARDCONTROLLER_SPEED_SLOWEST; + Rhythm.speed_max = COUGARKEYBOARDCONTROLLER_SPEED_FASTEST; + Rhythm.color_mode = MODE_COLORS_MODE_SPECIFIC; + Rhythm.speed = COUGARKEYBOARDCONTROLLER_SPEED_NORMAL; + modes.push_back(Rhythm); + + mode Rain; + Rain.name = "Rain"; + Rain.value = COUGARKEYBOARDCONTROLLER_MODE_RAIN; + Rain.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | + MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE; + Rain.colors_min = 1; + Rain.colors_max = 1; + Rain.colors.resize(Rain.colors_max); + Rain.brightness_min = COUGARKEYBOARDCONTROLLER_BRIGHTNESS_MIN; + Rain.brightness_max = COUGARKEYBOARDCONTROLLER_BRIGHTNESS_MAX; + Rain.brightness = COUGARKEYBOARDCONTROLLER_BRIGHTNESS_MAX; + Rain.speed_min = COUGARKEYBOARDCONTROLLER_SPEED_SLOWEST; + Rain.speed_max = COUGARKEYBOARDCONTROLLER_SPEED_FASTEST; + Rain.color_mode = MODE_COLORS_MODE_SPECIFIC; + Rain.speed = COUGARKEYBOARDCONTROLLER_SPEED_NORMAL; + modes.push_back(Rain); + + mode Snake; + Snake.name = "Snake"; + Snake.value = COUGARKEYBOARDCONTROLLER_MODE_SNAKE; + Snake.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | + MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE; + Snake.colors_min = 1; + Snake.colors_max = 1; + Snake.colors.resize(Snake.colors_max); + Snake.brightness_min = COUGARKEYBOARDCONTROLLER_BRIGHTNESS_MIN; + Snake.brightness_max = COUGARKEYBOARDCONTROLLER_BRIGHTNESS_MAX; + Snake.brightness = COUGARKEYBOARDCONTROLLER_BRIGHTNESS_MAX; + Snake.speed_min = COUGARKEYBOARDCONTROLLER_SPEED_SLOWEST; + Snake.speed_max = COUGARKEYBOARDCONTROLLER_SPEED_FASTEST; + Snake.color_mode = MODE_COLORS_MODE_SPECIFIC; + Snake.speed = COUGARKEYBOARDCONTROLLER_SPEED_NORMAL; + modes.push_back(Snake); + + mode Off; + Off.name = "Off"; + Off.value = COUGARKEYBOARDCONTROLLER_MODE_OFF; + Off.color_mode = MODE_COLORS_NONE; + modes.push_back(Off); + + SetupZones(); +} + +RGBController_CougarKeyboard::~RGBController_CougarKeyboard() +{ + delete controller; +} + +void RGBController_CougarKeyboard::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 = 113; + 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 = 6; + KB_zone.matrix_map->width = COUGARKEYBOARDCONTROLLER_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_CougarKeyboard::ResizeZone(int /*zone*/, int /*new_size*/) +{ + /*---------------------------------------------------------*\ + | This device does not support resizing zones | + \*---------------------------------------------------------*/ +} + +void RGBController_CougarKeyboard::DeviceUpdateLEDs() +{ + controller->SetLedsDirect(colors); +} + +void RGBController_CougarKeyboard::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_CougarKeyboard::UpdateSingleLED(int led) +{ + std::vector colour; + colour.push_back(colors[led]); + + controller->SetLedsDirect(colour); +} + +void RGBController_CougarKeyboard::SetCustomMode() +{ + active_mode = 0; +} + +void RGBController_CougarKeyboard::DeviceUpdateMode() +{ + mode set_mode = modes[active_mode]; + std::vector colours = (set_mode.colors); + + /*---------------------------------------------------------*\ + | No mode set packets required for Direct mode | + | Wave mode requires 5 colours based on the selected colour | + \*---------------------------------------------------------*/ + switch(set_mode.value) + { + case COUGARKEYBOARDCONTROLLER_MODE_DIRECT: + return; + case COUGARKEYBOARDCONTROLLER_MODE_WAVE: + if(set_mode.color_mode == MODE_COLORS_MODE_SPECIFIC) + { + hsv_t temp; + colours.resize(1); + rgb2hsv( colours[0], &temp); + + temp.value = temp.value / 2; + RGBColor half = hsv2rgb(&temp); + + temp.value = temp.value / 4; + RGBColor eighth = hsv2rgb(&temp); + + colours.push_back(half); + colours.push_back(eighth); + colours.push_back(half); + colours.push_back(colours[0]); + } + break; + } + + uint8_t direction = direction_map[set_mode.direction]; + bool random_colours = (set_mode.color_mode == MODE_COLORS_RANDOM); + + controller->SetMode( set_mode.value, set_mode.speed, set_mode.brightness, direction, colours, random_colours ); +} + +void RGBController_CougarKeyboard::DeviceSaveMode() +{ + const uint8_t start = 0x02; + const uint8_t end = 0x03; + + /*---------------------------------------------------------*\ + | The Keyboard has the ability to save 3 light modes across | + | 3 profiles but currently we will only set the 1st of each | + | Profiles = 1 thru 3 | + | Lights = 0 thru 2 | + \*---------------------------------------------------------*/ + controller->Save(start); + std::this_thread::sleep_for(10ms); + controller->SendProfile(1, 0); + std::this_thread::sleep_for(150ms); + DeviceUpdateMode(); + std::this_thread::sleep_for(10ms); + controller->Save(end); +} diff --git a/Controllers/CougarController/RGBController_CougarKeyboard.h b/Controllers/CougarController/RGBController_CougarKeyboard.h new file mode 100644 index 00000000..c8727760 --- /dev/null +++ b/Controllers/CougarController/RGBController_CougarKeyboard.h @@ -0,0 +1,37 @@ +/*-------------------------------------------------------------------*\ +| RGBController_CougarKeyboardController.h | +| | +| Driver for CougarKeyboard USB Controller | +| | +| Chris M (DrNo) 5 Apr 2022 | +\*-------------------------------------------------------------------*/ + +#pragma once +#include "LogManager.h" +#include "RGBController.h" +#include "CougarKeyboardController.h" +#include + +class RGBController_CougarKeyboard : public RGBController +{ +public: + RGBController_CougarKeyboard(CougarKeyboardController* controller_ptr); + ~RGBController_CougarKeyboard(); + + 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: + int GetDeviceMode(); + int GetLED_Zone(int led_idx); + + CougarKeyboardController* controller; +}; diff --git a/OpenRGB.pro b/OpenRGB.pro index 6c867c72..26ee7bba 100644 --- a/OpenRGB.pro +++ b/OpenRGB.pro @@ -332,7 +332,9 @@ HEADERS += Controllers/CorsairVengeanceProController/RGBController_CorsairVengeancePro.h \ Controllers/CorsairWirelessController/CorsairWirelessController.h \ Controllers/CorsairWirelessController/RGBController_CorsairWireless.h \ + Controllers/CougarController/CougarKeyboardController.h \ Controllers/CougarController/CougarRevengerSTController.h \ + Controllers/CougarController/RGBController_CougarKeyboard.h \ Controllers/CougarController/RGBController_CougarRevengerST.h \ Controllers/CreativeController/CreativeSoundBlasterXG6Controller.h \ Controllers/CreativeController/RGBController_CreativeSoundBlasterXG6.h \ @@ -820,8 +822,10 @@ SOURCES += Controllers/CorsairWirelessController/CorsairWirelessController.cpp \ Controllers/CorsairWirelessController/CorsairWirelessControllerDetect.cpp \ Controllers/CorsairWirelessController/RGBController_CorsairWireless.cpp \ + Controllers/CougarController/CougarKeyboardController.cpp \ Controllers/CougarController/CougarRevengerSTController.cpp \ Controllers/CougarController/CougarControllerDetect.cpp \ + Controllers/CougarController/RGBController_CougarKeyboard.cpp \ Controllers/CougarController/RGBController_CougarRevengerST.cpp \ Controllers/CreativeController/CreativeSoundBlasterXG6Controller.cpp \ Controllers/CreativeController/CreativeControllerDetect.cpp \