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

Initial commit for the Cougar 700K EVO Keyboard to resolve #2310

Browse source 
* Adding entry for the Cougar 700K EVO VID & PID
* Registered detectors
* Creating CougarKeyboardController class
* Creating RGBController_CougarKeyboard class
This commit is contained in:
Chris 2022-04-05 23:15:25 +10:00 • committed by Adam Honse
parent cac67592b7
commit 6292ee1664
6 changed files with 893 additions and 10 deletions
Download patch file Download diff file Expand all files Collapse all files

40
Controllers/CougarController/CougarControllerDetect.cpp
View file

@ -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);

227
Controllers/CougarController/CougarKeyboardController.cpp Normal file
View file

@ -0,0 +1,227 @@
/*-------------------------------------------------------------------*\
| CougarKeyboardController.cpp |
| |
| Driver for CougarKeyboard USB Controller |
| |
| Chris M (DrNo) 5 Apr 2022 |
\*-------------------------------------------------------------------*/
#include <cstring>
#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<RGBColor> 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<RGBColor> 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);
}

82
Controllers/CougarController/CougarKeyboardController.h Normal file
View file

@ -0,0 +1,82 @@
/*-------------------------------------------------------------------*\
| CougarKeyboardController.h |
| |
| Driver for CougarKeyboard USB Controller |
| |
| Chris M (DrNo) 5 Apr 2022 |
\*-------------------------------------------------------------------*/
#include <string>
#include <hidapi/hidapi.h>
#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<RGBColor> colours, bool random_colours);
void SetLedsDirect(std::vector<RGBColor> 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;
};

513
Controllers/CougarController/RGBController_CougarKeyboard.cpp Normal file
View file

@ -0,0 +1,513 @@
/*-------------------------------------------------------------------*\
| RGBController_CougarKeyboard.cpp |
| |
| Driver for CougarKeyboard USB Controller |
| |
| Chris M (DrNo) 5 Apr 2022 |
\*-------------------------------------------------------------------*/
#define NA 0xFFFFFFFF
#include <chrono>
#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<RGBColor> 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<RGBColor> 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<RGBColor> 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);
}

37
Controllers/CougarController/RGBController_CougarKeyboard.h Normal file
View file

@ -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 <vector>
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;
};

4
OpenRGB.pro
View file

@ -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 \