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

Remove redundant K100 controller

Browse source 
* Moved Existing K100 optical and K100 MX Red detectors to new V2 controller.
This commit is contained in:
Chris 2024-01-27 12:56:35 +11:00 • committed by Adam Honse
parent 2dfde7e8cd
commit bfb3052255
9 changed files with 71 additions and 691 deletions
Download patch file Download diff file Expand all files Collapse all files

172
Controllers/CorsairPeripheralController/CorsairK100Controller.cpp
View file

@ -1,172 +0,0 @@
/*-----------------------------------------*\
| CorsairK100Controller.cpp |
| |
| Driver for Corsair K100 Keyboard |
\*-----------------------------------------*/
#include "CorsairK100Controller.h"
#include "LogManager.h"
static unsigned int keys_k100[] = {0x25, 0x31, 0x27, 0x35, 0x66, 0x65, 0x41, 0x2A, 0x6E, 0x5B, 0x36, 0x1A, 0x10, 0x00, 0x68, 0x42,
0x62, 0x5C, 0x37, 0x1B, 0x16, 0x12, 0x19, 0x67, 0x43, 0x26, 0x77, 0x5D, 0x38, 0x1C, 0x04, 0x03,
0x17, 0x44, 0x48, 0x7A, 0x39, 0x1D, 0x11, 0x05, 0x02, 0x28, 0x45, 0x49, 0x78, 0x58, 0x3A, 0x1E,
0x13, 0x06, 0x15, 0x46, 0x4A, 0x79, 0x59, 0x3B, 0x1F, 0x18, 0x07, 0x01, 0x47, 0x6A, 0x4F, 0x5A,
0x3C, 0x20, 0x14, 0x09, 0x0D, 0x6B, 0x2C, 0x69, 0x50, 0x55, 0x3D, 0x21, 0x08, 0x0A, 0x0C, 0x76,
0x2D, 0x4E, 0x51, 0x56, 0x3E, 0x22, 0x0E, 0x0B, 0x32, 0x61, 0x4C, 0x52, 0x57, 0x3F, 0x23, 0x0F,
0x2F, 0x33, 0x24, 0x4D, 0x53, 0x5E, 0x40, 0x29, 0x2B, 0x30, 0x34, /*Brightness,*/
0x4B, 0x54, 0x5F, 0x60, 0x2E, 0x7C,
0x7F, 0x80, 0x81, 0x82, 0x83, 0x84,//Macro
0xA6, 0xA5, 0xA4, 0xA3, 0xA2, 0xA1, 0xA0, 0x9F, 0x9E, 0x9D, 0x9C, 0x86, 0x87, 0x88, 0x89, 0x8A,
0x8B, 0x8C, 0x8D, 0x8E, 0x8F, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9A,
0x9B, 0xA7, 0xA8, 0xA9, 0xAA, 0xAB, 0xAC, 0xAD, 0xAE, 0xAF,0xB0, 0xB1, //Light Bar
0x85, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9,//Nameplate
0xBA, 0xBB, 0xBC/*Logo*/};
CorsairK100Controller::CorsairK100Controller(hid_device* dev_handle, const char* path)
{
dev = dev_handle;
location = path;
keyboard_type = CORSAIR_TYPE_K100;
LightingControl();
}
CorsairK100Controller::~CorsairK100Controller()
{
hid_close(dev);
}
std::string CorsairK100Controller::GetDeviceLocation()
{
return("HID: " + location);
}
std::string CorsairK100Controller::GetFirmwareString()
{
return "";
}
std::string CorsairK100Controller::GetName()
{
return name;
}
void CorsairK100Controller::SetName(std::string device_name)
{
name = device_name;
}
CorsairKeyboardType CorsairK100Controller::GetKeyboardType()
{
return keyboard_type;
}
std::string CorsairK100Controller::GetSerialString()
{
wchar_t serial_string[128];
int ret = hid_get_serial_number_string(dev, serial_string, 128);
if(ret != 0)
{
return("");
}
std::wstring return_wstring = serial_string;
std::string return_string(return_wstring.begin(), return_wstring.end());
return(return_string);
}
void CorsairK100Controller::LightingControl()
{
unsigned char usb_buf[65];
memset(usb_buf, 0x00, sizeof(usb_buf));
//This is requered
usb_buf[0x01] = 0x08;
usb_buf[0x02] = 0x01;
usb_buf[0x03] = 0x03;
usb_buf[0x05] = 0x02;
hid_write(dev, (unsigned char *)usb_buf, 65);
memset(usb_buf, 0x00, sizeof(usb_buf));
usb_buf[0x01] = 0x08;
usb_buf[0x02] = 0x01;
usb_buf[0x03] = 0x4A;
usb_buf[0x05] = 0x01;
hid_write(dev, (unsigned char *)usb_buf, 65);
memset(usb_buf, 0x00, sizeof(usb_buf));
usb_buf[0x01] = 0x08;
usb_buf[0x02] = 0x01;
usb_buf[0x03] = 0x45;
usb_buf[0x05] = 0x00;
hid_write(dev, (unsigned char *)usb_buf, 65);
memset(usb_buf, 0x00, sizeof(usb_buf));
//This is requered
usb_buf[0x01] = 0x08;
usb_buf[0x02] = 0x0D;
usb_buf[0x03] = 0x01;
usb_buf[0x04] = 0x22;
hid_write(dev, (unsigned char *)usb_buf, 65);
/*memset(usb_buf, 0x00, sizeof(usb_buf));
usb_buf[0x01] = 0x08;
usb_buf[0x02] = 0x05;
usb_buf[0x03] = 0x01;
hid_write(dev, (unsigned char *)usb_buf, 65);
memset(usb_buf, 0x00, sizeof(usb_buf));
int res = hid_read_timeout(dev, usb_buf, 50, 1000);
if (res == 0 || usb_buf[1] != 0x01)
{
LOG_INFO("[Corsair-K100] This device did not allow to take control over it. recieved response: %02X", usb_buf[1]);
keyboard_type = CORSAIR_TYPE_UNKNOWN;
}*/
}
void CorsairK100Controller::SetLEDs(std::vector<RGBColor>colors)
{
switch(keyboard_type)
{
case CORSAIR_TYPE_K100:
SetLEDsKeyboardFull(colors);
break;
case CORSAIR_TYPE_UNKNOWN:
break;
}
}
void CorsairK100Controller::SetLEDsKeyboardFull(std::vector<RGBColor> colors)
{
unsigned char usb_buf[600];
memset(usb_buf, 0x00, sizeof(usb_buf));
usb_buf[0x01] = 0x08;
usb_buf[0x02] = 0x06;
usb_buf[0x03] = 0x01;
usb_buf[0x04] = 0x45;
usb_buf[0x05] = 0x02;
usb_buf[0x08] = 0x12;
for(std::size_t color_idx = 0; color_idx < colors.size(); color_idx++)
{
RGBColor color = colors[color_idx];
usb_buf[0x16 + keys_k100[color_idx]*3] = RGBGetRValue(color);
usb_buf[0x17 + keys_k100[color_idx]*3] = RGBGetGValue(color);
usb_buf[0x18 + keys_k100[color_idx]*3] = RGBGetBValue(color);
}
hid_write(dev, (unsigned char *)usb_buf, 600);
}

49
Controllers/CorsairPeripheralController/CorsairK100Controller.h
View file

@ -1,49 +0,0 @@
/*-----------------------------------------*\
| CorsairK100Controller.h |
| |
| Driver for Corsair K100 Keyboard |
\*-----------------------------------------*/
#ifndef CORSAIRK100CONTROLLER_H
#define CORSAIRK100CONTROLLER_H
#include "RGBController.h"
#include <string>
#include <hidapi/hidapi.h>
typedef enum
{
CORSAIR_TYPE_UNKNOWN = 0,
CORSAIR_TYPE_K100 = 1
} CorsairKeyboardType;
class CorsairK100Controller
{
public:
CorsairK100Controller(hid_device* dev_handle, const char* path);
~CorsairK100Controller();
CorsairKeyboardType GetKeyboardType();
std::string GetDeviceLocation();
std::string GetFirmwareString();
std::string GetName();
std::string GetSerialString();
void SetLEDs(std::vector<RGBColor> colors);
void SetLEDsKeyboardLimited(std::vector<RGBColor> colors);
void SetName(std::string device_name);
private:
hid_device* dev;
std::string firmware_version;
std::string location;
std::string name;
device_type type;
CorsairKeyboardType keyboard_type;
void LightingControl();
void SetLEDsKeyboardFull(std::vector<RGBColor> colors);
};
#endif // CORSAIRK100CONTROLLER_H

36
Controllers/CorsairPeripheralController/CorsairPeripheralControllerDetect.cpp
View file

@ -3,7 +3,6 @@
\*-----------------------------------------------------*/
#include <hidapi/hidapi.h>
#include "Detector.h"
#include "CorsairK55RGBPROXTController.h"
#include "LogManager.h"
#include "RGBController.h"
@ -11,7 +10,6 @@
| Corsair Peripheral specific includes |
\*-----------------------------------------------------*/
#include "RGBController_CorsairPeripheral.h"
#include "RGBController_CorsairK100.h"
#include "RGBController_CorsairK55RGBPROXT.h"
#include "RGBController_CorsairK65Mini.h"
#include "RGBController_CorsairK95PlatinumXT.h"
@ -85,13 +83,6 @@
\*-----------------------------------------------------*/
#define CORSAIR_ST100_PID 0x0A34
/*-----------------------------------------------------*\
| Corsair K100 Keyboard product ID |
| This keyboard uses a separate driver |
\*-----------------------------------------------------*/
#define CORSAIR_K100_OPTICAL_PID 0x1B7C
#define CORSAIR_K100_MXRED_PID 0x1B7D
/*-----------------------------------------------------*\
| Corsair K55 RGB PRO XT Keyboard product ID |
| This keyboard uses a separate driver |
@ -110,27 +101,6 @@
\*-----------------------------------------------------*/
#define CORSAIR_K95_PLATINUM_XT_PID 0x1B89
void DetectCorsairK100Controllers(hid_device_info* info, const std::string& name)
{
hid_device* dev = hid_open_path(info->path);
if(dev)
{
CorsairK100Controller* controller = new CorsairK100Controller(dev, info->path);
controller->SetName(name);
if(controller->GetKeyboardType() != CORSAIR_TYPE_UNKNOWN)
{
RGBController_CorsairK100* rgb_controller = new RGBController_CorsairK100(controller);
ResourceManager::get()->RegisterRGBController(rgb_controller);
}
else
{
delete controller;
}
}
} /* DetectCorsairPeripheralControllers() */
void DetectCorsairK55RGBPROXTControllers(hid_device_info* info, const std::string& name)
{
hid_device* dev = hid_open_path(info->path);
@ -259,12 +229,6 @@ REGISTER_HID_DETECTOR_P("Corsair ST100 RGB", DetectCorsairPeriphe
REGISTER_HID_DETECTOR_I("Corsair ST100 RGB", DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_ST100_PID, 0);
#endif
/*-----------------------------------------------------------------------------------------------------*\
| Corsair K100 Keyboard |
\*-----------------------------------------------------------------------------------------------------*/
REGISTER_HID_DETECTOR_IP("Corsair K100", DetectCorsairK100Controllers, CORSAIR_VID, CORSAIR_K100_OPTICAL_PID, 1, 0xFF42);
REGISTER_HID_DETECTOR_IP("Corsair K100", DetectCorsairK100Controllers, CORSAIR_VID, CORSAIR_K100_MXRED_PID, 1, 0xFF42);
/*-----------------------------------------------------------------------------------------------------*\
| Corsair K65 Mini Keyboard |
\*-----------------------------------------------------------------------------------------------------*/

383
Controllers/CorsairPeripheralController/RGBController_CorsairK100.cpp
View file

@ -1,383 +0,0 @@
/*-----------------------------------------*\
| RGBController_CorsairK100.cpp |
| |
| Driver for Corsair K100 Keyboard |
\*-----------------------------------------*/
#include "RGBControllerKeyNames.h"
#include "RGBController_CorsairK100.h"
#include "LogManager.h"
using namespace std::chrono_literals;
#define NA 0xFFFFFFFF
static unsigned int matrix_map_k100[7][24] =
{ { NA, 112, NA, 8, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, 16, NA, NA, NA,},
{ 113, 0, NA, 10, 18, 28, 36, NA, 46, 55, 64, 74, NA, 84, 93, 102, 6, 15, 24, 33, 26, 35, 44, 53 },
{ 114, 1, 11, 19, 29, 37, 47, 56, 65, 75, 85, 94, NA, 103, 7, 25, NA, 42, 51, 60, 62, 72, 82, 91 },
{ 115, 2, NA, 12, 20, 30, 38, NA, 48, 57, 66, 76, 86, 95, 104, 70, 80, 34, 43, 52, 9, 17, 27, 100 },
{ 116, 3, NA, 13, 21, 31, 39, NA, 49, 58, 67, 77, 87, 96, 105, 98, 111, NA, NA, NA, 45, 54, 63, NA },
{ 117, 4, 110, 22, 32, 40, 50, NA, 59, NA, 68, 78, 88, 97, 106, 61, NA, NA, 81, NA, 73, 83, 92, 108 },
{ 118, 5, 14, 23, NA, NA, NA, NA, 41, NA, NA, NA, NA, 69, 79, 89, 71, 90, 99, 107, 101, NA, 109, NA } };
static const char* led_names_k100[] =
{
KEY_EN_ESCAPE, //0
KEY_EN_BACK_TICK, //1
KEY_EN_TAB, //2
KEY_EN_CAPS_LOCK, //3
KEY_EN_LEFT_SHIFT, //4
KEY_EN_LEFT_CONTROL, //5
KEY_EN_F12, //6
KEY_EN_EQUALS, //7
"Key: Lock", //8
KEY_EN_NUMPAD_7, //9
KEY_EN_F1, //12
KEY_EN_1, //13
KEY_EN_Q, //14
KEY_EN_A, //15
KEY_EN_LEFT_WINDOWS, //17
KEY_EN_PRINT_SCREEN, //18
KEY_EN_MEDIA_MUTE, //20
KEY_EN_NUMPAD_8, //21
KEY_EN_F2, //24
KEY_EN_2, //25
KEY_EN_W, //26
KEY_EN_S, //27
KEY_EN_Z, //28
KEY_EN_LEFT_ALT, //29
KEY_EN_SCROLL_LOCK, //30
KEY_EN_BACKSPACE, //31
KEY_EN_MEDIA_STOP, //32
KEY_EN_NUMPAD_9, //33
KEY_EN_F3, //36
KEY_EN_3, //37
KEY_EN_E, //38
KEY_EN_D, //39
KEY_EN_X, //40
KEY_EN_PAUSE_BREAK, //42
KEY_EN_DELETE, //43
KEY_EN_MEDIA_PREVIOUS, //44
KEY_EN_F4, //48
KEY_EN_4, //49
KEY_EN_R, //50
KEY_EN_F, //51
KEY_EN_C, //52
KEY_EN_SPACE, //53
KEY_EN_INSERT, //54
KEY_EN_END, //55
KEY_EN_MEDIA_PLAY_PAUSE, //56
KEY_EN_NUMPAD_4, //57
KEY_EN_F5, //60
KEY_EN_5, //61
KEY_EN_T, //62
KEY_EN_G, //63
KEY_EN_V, //64
KEY_EN_HOME, //66
KEY_EN_PAGE_DOWN, //67
KEY_EN_MEDIA_NEXT, //68
KEY_EN_NUMPAD_5, //69
KEY_EN_F6, //72
KEY_EN_6, //73
KEY_EN_Y, //74
KEY_EN_H, //75
KEY_EN_B, //76
KEY_EN_PAGE_UP, //78
KEY_EN_RIGHT_SHIFT, //79
KEY_EN_NUMPAD_LOCK, //80
KEY_EN_NUMPAD_6, //81
KEY_EN_F7, //84
KEY_EN_7, //85
KEY_EN_U, //86
KEY_EN_J, //87
KEY_EN_N, //88
KEY_EN_RIGHT_ALT, //89
KEY_EN_RIGHT_BRACKET, //90
KEY_EN_RIGHT_CONTROL, //91
KEY_EN_NUMPAD_DIVIDE, //92
KEY_EN_NUMPAD_1, //93
KEY_EN_F8, //96
KEY_EN_8, //97
KEY_EN_I, //98
KEY_EN_K, //99
KEY_EN_M, //100
KEY_EN_RIGHT_WINDOWS, //101
KEY_EN_ANSI_BACK_SLASH, //102
KEY_EN_UP_ARROW, //103
KEY_EN_NUMPAD_TIMES, //104
KEY_EN_NUMPAD_2, //105
KEY_EN_F9, //108
KEY_EN_9, //109
KEY_EN_O, //110
KEY_EN_L, //111
KEY_EN_COMMA, //112
KEY_EN_MENU, //113
KEY_EN_LEFT_ARROW, //115
KEY_EN_NUMPAD_MINUS, //116
KEY_EN_NUMPAD_3, //117
KEY_EN_F10, //120
KEY_EN_0, //121
KEY_EN_P, //122
KEY_EN_SEMICOLON, //123
KEY_EN_PERIOD, //124
KEY_EN_ANSI_ENTER, //126
KEY_EN_DOWN_ARROW, //127
KEY_EN_NUMPAD_PLUS, //128
KEY_EN_NUMPAD_0, //129
KEY_EN_F11, //132
KEY_EN_MINUS, //133
KEY_EN_LEFT_BRACKET, //134
KEY_EN_QUOTE, //135
KEY_EN_FORWARD_SLASH, //136
// "Key: Brightness", //137
KEY_EN_RIGHT_ARROW, //139
KEY_EN_NUMPAD_ENTER, //140
KEY_EN_NUMPAD_PERIOD, //141
"Key: / (ISO)",
KEY_EN_ISO_BACK_SLASH,
"Key: Preset",
"Key: G1",
"Key: G2",
"Key: G3",
"Key: G4",
"Key: G5",
"Key: G6",
};
static const char* led_names_lightbar[] =
{
"Underglow 1",
"Underglow 2",
"Underglow 3",
"Underglow 4",
"Underglow 5",
"Underglow 6",
"Underglow 7",
"Underglow 8",
"Underglow 9",
"Underglow 10",
"Underglow 11",
"Underglow 12",
"Underglow 13",
"Underglow 14",
"Underglow 15",
"Underglow 16",
"Underglow 17",
"Underglow 18",
"Underglow 19",
"Underglow 20",
"Underglow 21",
"Underglow 22",
"Underglow 23",
"Underglow 24",
"Underglow 25",
"Underglow 26",
"Underglow 27",
"Underglow 28",
"Underglow 29",
"Underglow 30",
"Underglow 31",
"Underglow 32",
"Underglow 33",
"Underglow 34",
"Underglow 35",
"Underglow 36",
"Underglow 37",
"Underglow 38",
"Underglow 39",
"Underglow 40",
"Underglow 41",
"Underglow 42",
"Underglow 43",
"Underglow 44",
};
static const char* led_names_nameplate[] =
{
"Nameplate 1",
"Nameplate 2",
"Nameplate 3",
"Nameplate 4",
"Nameplate 5",
"Nameplate 6",
"Nameplate 7",
"Nameplate 8",
"Nameplate 9",
};
static const char* led_names_logo[] =
{
"Logo",
"Logo",
"Logo",
};
typedef struct
{
const char* name;
const unsigned int size;
const zone_type type;
const char** led_names;
matrix_map_type* matrix;
} led_zone_layout;
/**------------------------------------------------------------------*\
@name Corsair K100 Keyboard
@category Keyboard
@type USB
@save :x:
@direct :white_check_mark:
@effects :x:
@detectors DetectCorsairK100Controllers
@comment
\*-------------------------------------------------------------------*/
RGBController_CorsairK100::RGBController_CorsairK100(CorsairK100Controller* controller_ptr)
{
controller = controller_ptr;
name = controller->GetName();
vendor = "Corsair";
description = "Corsair K100 Keyboard Device";
type = DEVICE_TYPE_KEYBOARD;
version = controller->GetFirmwareString();
location = controller->GetDeviceLocation();
serial = controller->GetSerialString();
logical_layout = controller->GetKeyboardType();
mode Direct;
Direct.name = "Direct";
Direct.value = 0;
Direct.flags = MODE_FLAG_HAS_PER_LED_COLOR;
Direct.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Direct);
SetupZones();
/*-----------------------------------------------------*\
| The Corsair K100 requires a packet within |
| 1 minutes of sending the lighting change in order |
| to not revert back into rainbow mode. Start a thread |
| to continuously send a keepalive packet every 50 sec |
\*-----------------------------------------------------*/
keepalive_thread_run = true;
keepalive_thread = new std::thread(&RGBController_CorsairK100::KeepaliveThread, this);
}
RGBController_CorsairK100::~RGBController_CorsairK100()
{
/*-----------------------------------------------------*\
| Close keepalive thread |
\*-----------------------------------------------------*/
keepalive_thread_run = false;
keepalive_thread->join();
delete keepalive_thread;
/*---------------------------------------------------------*\
| Delete the matrix map |
\*---------------------------------------------------------*/
for(unsigned int zone_index = 0; zone_index < zones.size(); zone_index++)
{
if(zones[zone_index].type == ZONE_TYPE_MATRIX)
{
delete zones[zone_index].matrix_map;
}
}
delete controller;
}
void RGBController_CorsairK100::SetupZones()
{
std::vector<led_zone_layout> selected_zone;
switch(logical_layout)
{
case CORSAIR_TYPE_K100:
selected_zone.push_back({ZONE_EN_KEYBOARD, 119, ZONE_TYPE_MATRIX, led_names_k100, new matrix_map_type{7, 24, (unsigned int *)&matrix_map_k100}});
selected_zone.push_back({"Underglow", 44, ZONE_TYPE_LINEAR, led_names_lightbar, NULL});
selected_zone.push_back({"Nameplate", 9, ZONE_TYPE_LINEAR, led_names_nameplate, NULL});
selected_zone.push_back({"Logo", 3, ZONE_TYPE_LINEAR, led_names_logo, NULL});
break;
case CORSAIR_TYPE_UNKNOWN:
break;
}
/*---------------------------------------------------------*\
| Set up zones |
\*---------------------------------------------------------*/
for(unsigned int zone_idx = 0; zone_idx < selected_zone.size(); zone_idx++)
{
zone new_zone;
new_zone.name = selected_zone[zone_idx].name;
new_zone.type = selected_zone[zone_idx].type;
new_zone.leds_min = selected_zone[zone_idx].size;
new_zone.leds_max = selected_zone[zone_idx].size;
new_zone.leds_count = selected_zone[zone_idx].size;
if (new_zone.type == ZONE_TYPE_MATRIX)
{
new_zone.matrix_map = selected_zone[zone_idx].matrix;
}
else
{
new_zone.matrix_map = NULL;
}
zones.push_back(new_zone);
for(unsigned int led_idx = 0; led_idx < selected_zone[zone_idx].size; led_idx++)
{
led new_led;
new_led.name = selected_zone[zone_idx].led_names[led_idx];
leds.push_back(new_led);
}
}
SetupColors();
}
void RGBController_CorsairK100::ResizeZone(int /*zone*/, int /*new_size*/)
{
/*---------------------------------------------------------*\
| This device does not support resizing zones |
\*---------------------------------------------------------*/
}
void RGBController_CorsairK100::DeviceUpdateLEDs()
{
last_update_time = std::chrono::steady_clock::now();
controller->SetLEDs(colors);
}
void RGBController_CorsairK100::UpdateZoneLEDs(int /*zone*/)
{
controller->SetLEDs(colors);
}
void RGBController_CorsairK100::UpdateSingleLED(int /*led*/)
{
controller->SetLEDs(colors);
}
void RGBController_CorsairK100::DeviceUpdateMode()
{
}
void RGBController_CorsairK100::KeepaliveThread()
{
while(keepalive_thread_run.load())
{
if(active_mode == 0)
{
if((std::chrono::steady_clock::now() - last_update_time) > std::chrono::milliseconds(50000))
{
DeviceUpdateLEDs();
}
}
std::this_thread::sleep_for(3000ms);
}
}

40
Controllers/CorsairPeripheralController/RGBController_CorsairK100.h
View file

@ -1,40 +0,0 @@
/*-----------------------------------------*\
| RGBController_CorsairK100.cpp |
| |
| Driver for Corsair K100 Keyboard |
\*-----------------------------------------*/
#ifndef RGBCONTROLLER_CORSAIRK100_H
#define RGBCONTROLLER_CORSAIRK100_H
#include "RGBController.h"
#include "CorsairK100Controller.h"
class RGBController_CorsairK100 : public RGBController
{
public:
RGBController_CorsairK100(CorsairK100Controller* controller_ptr);
~RGBController_CorsairK100();
void SetupZones();
void ResizeZone(int zone, int new_size);
void DeviceUpdateLEDs();
void UpdateZoneLEDs(int zone);
void UpdateSingleLED(int led);
void DeviceUpdateMode();
void KeepaliveThread();
private:
CorsairK100Controller* controller;
CorsairKeyboardType logical_layout;
std::thread* keepalive_thread;
std::atomic<bool> keepalive_thread_run;
std::chrono::time_point<std::chrono::steady_clock> last_update_time;
};
#endif // RGBCONTROLLER_CORSAIRK100_H

4
Controllers/CorsairPeripheralV2Controller/CorsairPeripheralV2ControllerDetect.cpp
View file

@ -65,7 +65,9 @@ REGISTER_HID_DETECTOR_IP("Corsair K60 RGB PRO TKL", DetectCorsai
REGISTER_HID_DETECTOR_IP("Corsair K70 RGB PRO", DetectCorsairV2HardwareControllers, CORSAIR_VID, CORSAIR_K70_RGB_PRO_PID, 1, 0xFF42);
REGISTER_HID_DETECTOR_IP("Corsair K70 RGB TKL", DetectCorsairV2HardwareControllers, CORSAIR_VID, CORSAIR_K70_RGB_TKL_PID, 1, 0xFF42);
REGISTER_HID_DETECTOR_IP("Corsair K70 RGB TKL Champion Series", DetectCorsairV2HardwareControllers, CORSAIR_VID, CORSAIR_K70_RGB_TKL_CS_PID, 1, 0xFF42);
REGISTER_HID_DETECTOR_IP("Corsair K100 RGB Optical", DetectCorsairV2HardwareControllers, CORSAIR_VID, CORSAIR_K100_OPTICAL_PID, 1, 0xFF42);
REGISTER_HID_DETECTOR_IP("Corsair K100 RGB Optical", DetectCorsairV2HardwareControllers, CORSAIR_VID, CORSAIR_K100_OPTICAL_V1_PID, 1, 0xFF42);
REGISTER_HID_DETECTOR_IP("Corsair K100 RGB Optical", DetectCorsairV2HardwareControllers, CORSAIR_VID, CORSAIR_K100_OPTICAL_V2_PID, 1, 0xFF42);
REGISTER_HID_DETECTOR_IP("Corsair K100 MX Red", DetectCorsairV2HardwareControllers, CORSAIR_VID, CORSAIR_K100_MXRED_PID, 1, 0xFF42);
/*-----------------------------------------------------------------------------------------------------*\
| Mice |

70
Controllers/CorsairPeripheralV2Controller/CorsairPeripheralV2Devices.cpp
View file

@ -820,7 +820,7 @@ static const corsair_v2_device k70_rgb_tkl_cs_device =
};
/*-------------------------------------------------------------*\
| Corsair k70 RGB Pro 1B1C:1BC4 |
| Corsair K70 RGB Pro 1B1C:1BC4 |
| |
| Zone "Keyboard" |
| Matrix |
@ -852,7 +852,40 @@ static const corsair_v2_device k70_rgb_pro_device =
};
/*-------------------------------------------------------------*\
| Corsair k100 RGB Optical 1B1C:1BC5 |
| Corsair K100 MX Red 1B1C:1B7D |
| |
| Zone "Keyboard" |
| Matrix |
| 12 Rows, 24 Columns |
\*-------------------------------------------------------------*/
static const corsair_v2_zone k100_mx_red_zone =
{
ZONE_EN_KEYBOARD,
ZONE_TYPE_MATRIX,
12,
24
};
static const corsair_v2_device k100_mx_red_device =
{
CORSAIR_K100_MXRED_PID,
DEVICE_TYPE_KEYBOARD,
12,
24,
{
&k100_mx_red_zone,
nullptr,
nullptr,
nullptr,
nullptr,
nullptr
},
&corsair_k100_layout
};
/*-------------------------------------------------------------*\
| Corsair K100 RGB Optical V1 1B1C:1B7C |
| |
| Zone "Keyboard" |
| Matrix |
@ -867,9 +900,34 @@ static const corsair_v2_zone k100_rgb_opt_zone =
24
};
static const corsair_v2_device k100_rgb_opt_device =
static const corsair_v2_device k100_rgb_opt_v1_device =
{
CORSAIR_K100_OPTICAL_PID,
CORSAIR_K100_OPTICAL_V1_PID,
DEVICE_TYPE_KEYBOARD,
12,
24,
{
&k100_rgb_opt_zone,
nullptr,
nullptr,
nullptr,
nullptr,
nullptr
},
&corsair_k100_layout
};
/*-------------------------------------------------------------*\
| Corsair K100 RGB Optical V2 1B1C:1BC5 |
| |
| Zone "Keyboard" |
| Matrix |
| 12 Rows, 24 Columns |
\*-------------------------------------------------------------*/
static const corsair_v2_device k100_rgb_opt_v2_device =
{
CORSAIR_K100_OPTICAL_V2_PID,
DEVICE_TYPE_KEYBOARD,
12,
24,
@ -1035,7 +1093,9 @@ const corsair_v2_device* corsair_v2_device_list_data[] =
&k70_rgb_pro_device,
&k70_rgb_tkl_device,
&k70_rgb_tkl_cs_device,
&k100_rgb_opt_device,
&k100_mx_red_device,
&k100_rgb_opt_v1_device,
&k100_rgb_opt_v2_device,
/*-----------------------------------------------------------------*\
| MICE |

4
Controllers/CorsairPeripheralV2Controller/CorsairPeripheralV2Devices.h
View file

@ -66,7 +66,9 @@ typedef struct
#define CORSAIR_K70_RGB_PRO_PID 0x1BC4
#define CORSAIR_K70_RGB_TKL_PID 0x1B73
#define CORSAIR_K70_RGB_TKL_CS_PID 0x1BB9
#define CORSAIR_K100_OPTICAL_PID 0x1BC5
#define CORSAIR_K100_OPTICAL_V1_PID 0x1B7C
#define CORSAIR_K100_OPTICAL_V2_PID 0x1BC5
#define CORSAIR_K100_MXRED_PID 0x1B7D
/*-----------------------------------------------------*\
| Corsair V2 Protocol Mice |

4
OpenRGB.pro
View file

@ -431,12 +431,10 @@ HEADERS +=
Controllers/CorsairLightingNodeController/CorsairLightingNodeController.h \
Controllers/CorsairLightingNodeController/RGBController_CorsairLightingNode.h \
Controllers/CorsairPeripheralController/CorsairPeripheralController.h \
Controllers/CorsairPeripheralController/CorsairK100Controller.h \
Controllers/CorsairPeripheralController/CorsairK55RGBPROXTController.h \
Controllers/CorsairPeripheralController/CorsairK65MiniController.h \
Controllers/CorsairPeripheralController/CorsairK95PlatinumXTController.h \
Controllers/CorsairPeripheralController/RGBController_CorsairPeripheral.h \
Controllers/CorsairPeripheralController/RGBController_CorsairK100.h \
Controllers/CorsairPeripheralController/RGBController_CorsairK55RGBPROXT.h \
Controllers/CorsairPeripheralController/RGBController_CorsairK65Mini.h \
Controllers/CorsairPeripheralController/RGBController_CorsairK95PlatinumXT.h \
@ -1085,12 +1083,10 @@ SOURCES +=
Controllers/CorsairLightingNodeController/RGBController_CorsairLightingNode.cpp \
Controllers/CorsairPeripheralController/CorsairPeripheralController.cpp \
Controllers/CorsairPeripheralController/CorsairPeripheralControllerDetect.cpp \
Controllers/CorsairPeripheralController/CorsairK100Controller.cpp \
Controllers/CorsairPeripheralController/CorsairK55RGBPROXTController.cpp \
Controllers/CorsairPeripheralController/CorsairK65MiniController.cpp \
Controllers/CorsairPeripheralController/CorsairK95PlatinumXTController.cpp \
Controllers/CorsairPeripheralController/RGBController_CorsairPeripheral.cpp \
Controllers/CorsairPeripheralController/RGBController_CorsairK100.cpp \
Controllers/CorsairPeripheralController/RGBController_CorsairK55RGBPROXT.cpp \
Controllers/CorsairPeripheralController/RGBController_CorsairK65Mini.cpp \
Controllers/CorsairPeripheralController/RGBController_CorsairK95PlatinumXT.cpp \