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

Organize most controller files into subfolders

Browse source
This commit is contained in:
Adam Honse 2024-04-30 17:18:39 -05:00
parent ba57bad361
commit d52ad02c5c
415 changed files with 44 additions and 43 deletions
Download patch file Download diff file Expand all files Collapse all files

203
Controllers/CoolerMasterController/CMKeyboardController/CMKeyboardAbstractController.cpp Normal file
View file

@ -0,0 +1,203 @@
/*-------------------------------------------------------------------*\
| CMKeyboardAbstractController.h |
| |
| Abstract driver for Coolermaster keyboards |
| |
| Tam D (too.manyhobbies) 30th Nov 2023 |
| |
\*-------------------------------------------------------------------*/
#include "CMKeyboardAbstractController.h"
CMKeyboardAbstractController::CMKeyboardAbstractController(hid_device* dev_handle, hid_device_info* dev_info)
{
wchar_t tmp[HID_MAX_STR];
m_pDev = dev_handle;
m_productId = dev_info->product_id;
m_sLocation = dev_info->path;
hid_get_manufacturer_string(m_pDev, tmp, HID_MAX_STR);
std::wstring wVendorName = std::wstring(tmp);
m_vendorName = std::string(wVendorName.begin(), wVendorName.end());
hid_get_product_string(m_pDev, tmp, HID_MAX_STR);
std::wstring wDeviceName = std::wstring(tmp);
m_deviceName = std::string(wDeviceName.begin(), wDeviceName.end());
m_serialNumber = m_deviceName;
bool bNotFound = true;
for(uint16_t i = 0; i < COOLERMASTER_KEYBOARD_DEVICE_COUNT; i++)
{
if(cm_kb_device_list[i]->product_id == m_productId)
{
bNotFound = false;
m_deviceIndex = i;
break;
}
}
if(bNotFound)
{
LOG_ERROR("[%s] device capabilities not found. Please creata a new device request.",
m_deviceName.c_str());
}
};
CMKeyboardAbstractController::~CMKeyboardAbstractController()
{
if(m_pDev)
{
hid_close(m_pDev);
}
};
std::string CMKeyboardAbstractController::GetDeviceName()
{
return m_deviceName;
}
void CMKeyboardAbstractController::SetDeviceName(std::string name)
{
m_deviceName = name;
}
std::string CMKeyboardAbstractController::GetDeviceVendor()
{
return m_vendorName;
}
std::string CMKeyboardAbstractController::GetDeviceSerial()
{
return m_serialNumber;
}
const cm_kb_device* CMKeyboardAbstractController::GetDeviceData()
{
return cm_kb_device_list[m_deviceIndex];
}
std::string CMKeyboardAbstractController::GetLocation()
{
return m_sLocation;
}
std::string CMKeyboardAbstractController::GetFirmwareVersion()
{
return m_sFirmwareVersion;
}
int CMKeyboardAbstractController::GetProductID()
{
return m_productId;
}
std::vector<uint8_t> CMKeyboardAbstractController::SendCommand(std::vector<uint8_t> buf, uint8_t fill)
{
int status;
std::vector<uint8_t> read;
uint8_t data[CM_KEYBOARD_WRITE_SIZE];
memset(data, fill, CM_KEYBOARD_WRITE_SIZE);
size_t i = 1;
for(uint8_t b : buf)
{
data[i++] = b;
}
std::lock_guard<std::mutex> guard(m_mutexSendCommand);
status = hid_write(m_pDev, data, CM_KEYBOARD_WRITE_SIZE);
if(status < 0)
{
LOG_ERROR("[%s] SendCommand() failed code %d.", m_deviceName.c_str(), status);
return read;
}
memset(data, 0, CM_KEYBOARD_WRITE_SIZE);
status = hid_read(m_pDev, data, CM_KEYBOARD_WRITE_SIZE);
if(status < 0)
{
LOG_ERROR("[%s] SendCommand() failed code %d.", m_deviceName.c_str(), status);
return read;
}
for(i = 0; i < (size_t)status; i++)
{
read.push_back(data[i]);
}
return read;
}
/*---------------------------------------------------------*\
| Enter/leave direct control mode |
\*---------------------------------------------------------*/
void CMKeyboardAbstractController::SetControlMode(uint8_t modeId)
{
SendCommand({0x41, (uint8_t)modeId});
};
/*---------------------------------------------------------*\
| Sets the currently active profile. |
| byte[0] = 0x51 0x00 0x00 0x00 |
| byte[4] = profileId |
| - corresponds to saved keyboard profile i.e. [1-4] |
| - 0x05 - Used on MK and CK style keyboards? |
\*---------------------------------------------------------*/
void CMKeyboardAbstractController::SetActiveProfile(uint8_t profileId)
{
SendCommand({0x51, 0x00, 0x00, 0x00, profileId});
};
uint8_t CMKeyboardAbstractController::GetActiveProfile()
{
std::vector<uint8_t> data = SendCommand({0x52, 0x00});
if(data.size() > 4)
{
return (int)data[4];
}
return 0xFF; // error
}
/*---------------------------------------------------------*\
| Saves changes in currently used profile. |
| byte[1] = 0x52 |
\*---------------------------------------------------------*/
void CMKeyboardAbstractController::SaveActiveProfile()
{
SendCommand({0x50, 0x55});
}
void CMKeyboardAbstractController::SetActiveEffect(uint8_t effectId)
{
SendCommand({0x51, 0x28, 0x00, 0x00, effectId});
};
void CMKeyboardAbstractController::SaveProfile()
{
SendCommand({0x50, 0x55});
}
uint8_t CMKeyboardAbstractController::GetModeStatus()
{
std::vector<uint8_t> data = SendCommand({0x52, 0x28});
return data[4];
};
std::string CMKeyboardAbstractController::GetHexString(std::vector<uint8_t> buf)
{
std::stringstream hexss;
for(uint8_t b : buf)
{
hexss << std::hex << b << " ";
}
return hexss.str();
}

122
Controllers/CoolerMasterController/CMKeyboardController/CMKeyboardAbstractController.h Normal file
View file

@ -0,0 +1,122 @@
/*-------------------------------------------------------------------*\
| CMKeyboardAbstractController.h |
| |
| Abstract driver for Coolermaster keyboards |
| |
| Tam D (too.manyhobbies) 30th Nov 2023 |
| |
\*-------------------------------------------------------------------*/
#pragma once
#include <cstring>
#include <stdint.h>
#include <string>
#include <sstream>
#include <map>
#include <vector>
#include <hidapi/hidapi.h>
#include "CMKeyboardDevices.h"
#include "KeyboardLayoutManager.h"
#include "RGBController.h"
#include "LogManager.h"
#define HID_MAX_STR 255
#define CM_KEYBOARD_WRITE_SIZE 65
#define CM_MAX_LEDS 255
#define CM_KEYBOARD_TIMEOUT 50
#define CM_KEYBOARD_TIMEOUT_SHORT 3
struct cm_keyboard_effect
{
uint8_t effectId;
uint8_t p1;
uint8_t p2;
uint8_t p3;
RGBColor color1;
RGBColor color2;
};
/*---------------------------------------------------------*\
| byte[0] = 0x41 |
| byte[1] = modeId |
\*---------------------------------------------------------*/
enum cm_keyboard_control_mode
{
MODE_FIRMWARE = 0x00,
MODE_EFFECT = 0x01,
MODE_MANUAL_V2 = 0x02,
MODE_CUSTOM_PROFILE = 0x03,
MODE_CUSTOM_PROFILE_V2 = 0x05,
MODE_DIRECT = 0x80
};
class CMKeyboardAbstractController
{
public:
CMKeyboardAbstractController(hid_device* dev_handle, hid_device_info* dev_info);
~CMKeyboardAbstractController();
/*---------------------------------------------------------*\
| Common USB controller fuctions |
\*---------------------------------------------------------*/
int GetProductID();
std::string GetDeviceName();
void SetDeviceName(std::string name);
std::string GetDeviceVendor();
std::string GetDeviceSerial();
std::string GetLocation();
std::string GetFirmwareVersion();
const cm_kb_device* GetDeviceData();
/*---------------------------------------------------------*\
| Keyboard Layout Manager support funtions |
\*---------------------------------------------------------*/
/*---------------------------------------------------------*\
| Common keyboard driver functions |
\*---------------------------------------------------------*/
virtual void SetControlMode(uint8_t modeId);
virtual void SetActiveProfile(uint8_t profileId);
virtual uint8_t GetActiveProfile();
virtual void SaveActiveProfile();
virtual void SaveProfile();
virtual void SetActiveEffect(uint8_t effectId);
virtual uint8_t GetModeStatus();
virtual void InitializeModes(std::vector<mode> &modes) = 0;
virtual KEYBOARD_LAYOUT GetKeyboardLayout() = 0;
/*---------------------------------------------------------*\
| Protocol specific funtions to be implmented |
\*---------------------------------------------------------*/
virtual void SetLeds(std::vector<led> leds, std::vector<RGBColor> colors) = 0;
virtual void SetSingleLED(uint8_t in_led, RGBColor in_color) = 0;
virtual void Initialize() = 0;
virtual void Shutdown() = 0;
virtual void SetLEDControl(bool bManual) = 0; // FW or SW control
virtual void SetCustomMode() = 0;
virtual void SetMode(mode selectedMode) = 0;
protected:
/*---------------------------------------------------------*\
| Utility functions. |
\*---------------------------------------------------------*/
std::vector<std::uint8_t> SendCommand(std::vector<uint8_t> buf, uint8_t fill=0x00);
std::string GetHexString(std::vector<uint8_t> buf);
std::string m_sFirmwareVersion;
std::string m_deviceName;
hid_device* m_pDev;
uint16_t m_productId;
uint16_t m_deviceIndex;
std::string m_vendorName;
std::string m_sLocation;
std::string m_serialNumber;
KEYBOARD_LAYOUT m_keyboardLayout;
std::map<int, int> mapModeValueEffect;
std::mutex m_mutex;
std::mutex m_mutexSendCommand;
};

768
Controllers/CoolerMasterController/CMKeyboardController/CMKeyboardDevices.cpp Normal file
View file

@ -0,0 +1,768 @@
/*-------------------------------------------------------------------*\
| CMKeyboardDevices.cpp |
| |
| Keymap definitions for Cooler Master Keyboards |
| |
| Tam D (too.manyhobbies) 30th Nov 2023 |
| |
\*-------------------------------------------------------------------*/
#include "CMKeyboardDevices.h"
/*-------------------------------------------------------------------------*\
| Coolermaster Key Values |
\*-------------------------------------------------------------------------*/
const std::vector<unsigned int> mk_pro_s_keymap =
{
/* ESC F1 F2 F3 F4 F5 F6 F7 F8 F9 F10 F11 F12 PRSC SCLK PSBK */
96, 97, 98, 99, 104, 105, 106, 112, 113, 114, 67, 68, 69, 102, 103, 107,
/* BKTK 1 2 3 4 5 6 7 8 9 0 - = BPSC INS HOME PGUP */
0, 1, 8, 9, 16, 17, 24, 25, 32, 33, 40, 41, 48, 49, 56, 57, 64,
/* TAB Q W E R T Y U I O P [ ] \ DEL END PGDN */
2, 3, 10, 11, 18, 19, 26, 27, 34, 35, 42, 43, 50, 51, 58, 59, 66,
/* CPLK A S D F G H J K L ; " # ENTR */
4, 5, 12, 13, 20, 21, 28, 29, 36, 37, 44, 45, 89, 52,
/* LSFT ISO\ Z X C V B N M , . / RSFT ARWU */
6, 100, 7, 14, 15, 22, 23, 30, 31, 38, 39, 46, 47, 61,
/* LCTL LWIN LALT SPC RALT RFNC RMNU RCTL ARWL ARWD ARWR */
91, 90, 92, 93, 94, 60, 95, 54, 63, 62, 70,
};
const std::vector<unsigned int> mk_pro_l_keymap =
{
/* ESC F1 F2 F3 F4 F5 F6 F7 F8 F9 F10 F11 F12 PRSC SCLK PSBK P1 P2 P3 P4 */
11, 22, 30, 25, 27, 7, 51, 57, 62, 86, 87, 83, 85, 79, 72, 0,
/* BKTK 1 2 3 4 5 6 7 8 9 0 - = BPSC INS HOME PGUP NMLK NMDV NMTM NMMI */
14, 15, 23, 31, 39, 38, 46, 47, 55, 63, 71, 70, 54, 81, 3, 1, 2, 100, 108, 116, 118,
/* TAB Q W E R T Y U I O P [ ] \ DEL END PGDN NM7 NM8 NM9 NMPL */
9, 8, 16, 24, 32, 33, 41, 40, 48, 56, 64, 65, 49, 82, 94, 92, 88, 96, 104, 112, 110,
/* CPLK A S D F G H J K L ; ' \ ENTR NM4 NM5 NM6 */
17, 10, 18, 26, 34, 35, 43, 42, 50, 58, 66, 67, 68, 84, 97, 105, 113,
/* LSFT ISO\ Z X C V B N M , . / RSFT ARWU NM1 NM2 NM3 NMER */
73, 19, 12, 20, 28, 36, 37, 45, 44, 52, 60, 69, 74, 80, 98, 106, 114, 111,
/* LCTL LWIN LALT SPACE RALT RWFNC RMNU RCTRL ARWL ARDN ARWR NM0 NMPD */
6, 90, 75, 91, 77, 78, 61, 4, 95, 93, 5, 107, 115,
};
const std::vector<unsigned int> mk850_keymap =
{
/* ESC F1 F2 F3 F4 F5 F6 F7 F8 F9 F10 F11 F12 PRSC SCLK PSBK AIM AIMU AIMD */
6, 27, 34, 41, 48, 62, 69, 76, 83, 90, 97, 104, 111, 118, 125, 132,
/* M1 BKTK 1 2 3 4 5 6 7 8 9 0 - = BPSC INS HOME PGUP NMLK NMDV NMTM NMMI */
7, 21, 28, 35, 42, 49, 56, 63, 70, 77, 84, 91, 98, 112, 119, 126, 133, 254, 147, 154, 161,
/* M2 TAB Q W E R T Y U I O P [ ] \ DEL END PGDN NM7 NM8 NM9 NMPL */
8, 22, 29, 36, 43, 50, 57, 64, 71, 78, 85, 92, 99, 113, 120, 127, 134, 141, 148, 155, 162,
/* M3 CPLK A S D F G H J K L ; ' # ENTR NM4 NM5 NM6 */
9, 23, 30, 37, 44, 51, 58, 65, 72, 79, 86, 93, 0, 114, 142, 149, 156,
/* M4 LSFT ISO\ Z X C V B N M , . / RSFT ARWU NM1 NM2 NM3 NMER */
10, 0, 24, 31, 38, 45, 52, 59, 66, 73, 80, 87, 115, 129, 143, 150, 157, 164,
/* M5 LCTL LWIN LALT SPACE RALT RWFNC RMNU RCTRL ARWL ARDN ARWR NM0 NMPD */
11, 18, 25, 53, 81, 88, 95, 116, 123, 130, 137, 144, 158,
};
/*-------------------------------------------------------------*\
| CoolerMaster SK (60%) |
\*-------------------------------------------------------------*/
const std::vector<unsigned int> sk622_keymap =
{
/* T1 T2 T3 T4 T5 T6 T7 T8 T9 T10 T11 T12 T13 T14 T15 */
/* L1 ESC 1 2 3 4 5 6 7 8 9 0 - = BPSC R1 */
8, 15, 22, 29, 36, 43, 50, 57, 64, 71, 78, 85, 92, 106,
/* L2 TAB Q W E R T Y U I O P [ ] R2 */
9, 23, 30, 37, 44, 51, 58, 65, 72, 79, 86, 93, 100,
/* L3 CPLK A S D F G H J K L ; " \ ENTR R3 */
10, 24, 31, 38, 45, 52, 59, 66, 73, 80, 87, 94, 101, 108,
/* L4 LSFT ISO\ Z X C V B N M , . # RSFT ARWU DEL R$ */
11, 18, 25, 32, 39, 46, 53, 60, 67, 74, 81, 88, 95, 102, 109,
/* L5 LCTL LWIN LALT SPACE RALT RWFNC ARWL ARDN ARWR R5 */
12, 19, 26, 54, 82, 89, 96, 103, 110,
/* B1 B2 B3 B4 B5 B6 B7 B8 B9 B10 B11 B12 B13 B14 B15 B15 */
};
const std::vector<unsigned int> sk630_keymap =
{
/* ESC F1 F2 F3 F4 F5 F6 F7 F8 F9 F10 F11 F12 PRSC SCLK PSBK */
9, 33, 41, 49, 57, 73, 81, 89, 97, 105, 113, 121, 129, 137, 145, 153,
/* BKTK 1 2 3 4 5 6 7 8 9 0 - = BPSC INS HOME PGUP */
10, 26, 34, 42, 50, 58, 66, 74, 82, 90, 98, 106, 114, 130, 138, 146, 154,
/* TAB Q W E R T Y U I O P [ ] \ DEL END PGDN */
11, 27, 35, 43, 51, 59, 67, 75, 83, 91, 99, 107, 115, 131, 139, 147, 155,
/* CPLK A S D F G H J K L ; " # ENTR */
12, 28, 36, 44, 52, 60, 68, 76, 84, 92, 100, 108, 116, 132,
/* LSFT ISO\ Z X C V B N M , . / RSFT ARWU */
13, 21, 29, 37, 45, 53, 61, 69, 77, 85, 93, 101, 133, 149,
/* LCTL LWIN LALT SPC RALT RFNC RMNU RCTL ARWL ARWD ARWR */
14, 22, 30, 62, 94, 102, 110, 134, 142, 150, 158,
};
const std::vector<unsigned int> sk650_keymap =
{
/* ESC F1 F2 F3 F4 F5 F6 F7 F8 F9 F10 F11 F12 PRSC SCLK PSBK */
0, 24, 32, 40, 48, 64, 72, 80, 88, 96, 104, 112, 120, 128, 136, 144,
/* BKTK 1 2 3 4 5 6 7 8 9 0 - = BPSC INS HOME PGUP NMLK NMDV NMTM NMMI */
1, 17, 25, 33, 41, 49, 57, 65, 73, 81, 89, 97, 105, 121, 129, 137, 145, 153, 161, 169, 177,
/* TAB Q W E R T Y U I O P [ ] \ DEL END PGDN NM7 NM8 NM9 NMPL */
2, 18, 26, 34, 42, 50, 58, 66, 74, 82, 90, 98, 106, 122, 130, 138, 146, 154, 162, 170, 178,
/* CPLK A S D F G H J K L ; ' # ENTR NM4 NM5 NM6 */
3, 19, 27, 35, 43, 51, 59, 67, 75, 83, 91, 99, 107, 123, 155, 163, 171,
/* LSFT ISO\ Z X C V B N M , . / RSFT ARWU NM1 NM2 NM3 NMER */
4, 20, 28, 36, 44, 52, 60, 68, 76, 84, 92, 100, 124, 140, 156, 164, 172, 180,
/* LCTL LWIN LALT SPACE RALT RWFNC RMNU RCTRL ARWL ARDN ARWR NM0 NMPD */
5, 13, 21, 53, 85, 93, 101, 125, 133, 141, 149, 165, 173,
};
const std::vector<unsigned int> sk652_keymap =
{
/* ESC F1 F2 F3 F4 F5 F6 F7 F8 F9 F10 F11 F12 PRSC SCLK PSBK */
9, 33, 41, 49, 57, 73, 81, 89, 97, 105, 113, 121, 129, 137, 145, 153,
/* BKTK 1 2 3 4 5 6 7 8 9 0 - = BPSC INS HOME PGUP NMLK NMDV NMTM NMMI */
10, 26, 34, 42, 50, 58, 66, 74, 82, 90, 98, 106, 114, 130, 138, 146, 154, 162, 170, 178, 186,
/* TAB Q W E R T Y U I O P [ ] \ DEL END PGDN NM7 NM8 NM9 NMPL */
11, 27, 35, 43, 51, 59, 67, 75, 83, 91, 99, 107, 115, 131, 139, 147, 155, 163, 171, 179, 187,
/* CPLK A S D F G H J K L ; ' # ENTR NM4 NM5 NM6 */
12, 28, 36, 44, 52, 60, 68, 76, 84, 92, 100, 108, 116, 132, 164, 172, 180,
/* LSFT ISO\ Z X C V B N M , . / RSFT ARWU NM1 NM2 NM3 NMER */
13, 21, 29, 37, 45, 53, 61, 69, 77, 85, 93, 101, 133, 149, 165, 173, 181, 189,
/* LCTL LWIN LALT SPACE RALT RWFNC RMNU RCTRL ARWL ARDN ARWR NM0 NMPD */
14, 22, 30, 62, 94, 102, 110, 134, 142, 150, 158, 174, 182,
};
const std::vector<unsigned int> sk653_keymap =
{
/* ESC F1 F2 F3 F4 F5 F6 F7 F8 F9 F10 F11 F12 PRSC SCLK PSBK */
0, 24, 32, 40, 48, 64, 72, 80, 88, 96, 104, 112, 120, 128, 136, 144,
/* BKTK 1 2 3 4 5 6 7 8 9 0 - = BPSC INS HOME PGUP NMLK NMDV NMTM NMMI */
1, 17, 25, 33, 41, 49, 57, 65, 73, 81, 89, 97, 105, 121, 129, 137, 145, 153, 161, 169, 177,
/* TAB Q W E R T Y U I O P [ ] \ DEL END PGDN NM7 NM8 NM9 NMPL */
2, 18, 26, 34, 42, 50, 58, 66, 74, 82, 90, 98, 106, 122, 130, 138, 146, 154, 162, 170, 178,
/* CPLK A S D F G H J K L ; ' # ENTR NM4 NM5 NM6 */
3, 19, 27, 35, 43, 51, 59, 67, 75, 83, 91, 99, 107, 123, 155, 163, 171,
/* LSFT ISO\ Z X C V B N M , . / RSFT ARWU NM1 NM2 NM3 NMER */
4, 20, 28, 36, 44, 52, 60, 68, 76, 84, 92, 100, 124, 140, 156, 164, 172, 180,
/* LCTL LWIN LALT SPACE RALT RWFNC RMNU RCTRL ARWL ARDN ARWR NM0 NMPD */
5, 13, 21, 53, 85, 93, 101, 125, 133, 141, 149, 165, 173,
};
const std::vector<unsigned int> mk730_keymap =
{
/* ESC F1 F2 F3 F4 F5 F6 F7 F8 F9 F10 F11 F12 PRSC SCLK PSBK */
7, 28, 35, 42, 49, 63, 70, 77, 84, 91, 98, 105, 112, 119, 126, 133,
/* L1 BKTK 1 2 3 4 5 6 7 8 9 0 - = BPSC INS HOME PGUP R1 */
8, 22, 29, 36, 43, 50, 57, 64, 71, 78, 85, 92, 99, 113, 120, 127, 134,
/* L2 TAB Q W E R T Y U I O P [ ] \ DEL END PGDN R2 */
9, 23, 30, 37, 44, 51, 58, 65, 72, 79, 86, 93, 100, 114, 121, 128, 135,
/* L3 CPLK A S D F G H J K L ; ' # ENTR R3 */
10, 24, 31, 38, 45, 52, 59, 66, 73, 80, 87, 94, 108, 115,
/* L4 LSFT ISO\ Z X C V B N M , . / RSFT ARWU R4 */
11, 18, 25, 32, 39, 46, 53, 60, 67, 74, 81, 88, 116, 130,
/* LCTL LWIN LALT SPACE RALT RWFNC RMNU RCTRL ARWL ARDN ARWR */
12, 19, 26, 54, 82, 89, 96, 117, 124, 131, 138,
/* B1 B2 B3 B4 B5 B6 B7 B8 B9 B10 B11 B12 B12 */
};
const std::vector<unsigned int> mk750_keymap =
{
/* ESC F1 F2 F3 F4 F5 F6 F7 F8 F9 F10 F11 F12 PRSC SCLK PSBK MUT PLA REW FFWD */
7, 28, 35, 42, 49, 63, 70, 77, 84, 91, 98, 105, 112, 119, 136, 133,
/* L1 BKTK 1 2 3 4 5 6 7 8 9 0 - = BPSC INS HOME PGUP NMLK NMDV NMTM NMMI R1 */
8, 22, 29, 36, 43, 50, 57, 64, 71, 78, 85, 92, 99, 113, 120, 127, 134, 0, 148, 155, 162,
/* L2 TAB Q W E R T Y U I O P [ ] \ DEL END PGDN NM7 NM8 NM9 NMPL R2 */
9, 23, 30, 37, 44, 51, 58, 65, 72, 79, 86, 93, 100, 114, 121, 128, 135, 142, 149, 156, 163,
/* L3 CPLK A S D F G H J K L ; ' # ENTR NM4 NM5 NM6 R3 */
10, 24, 31, 38, 45, 52, 59, 66, 73, 80, 87, 94, 108, 115, 143, 150, 157,
/* L4 LSFT ISO\ Z X C V B N M , . / RSFT ARWU NM1 NM2 NM3 NMER R4 */
11, 18, 25, 32, 39, 46, 53, 60, 67, 74, 81, 88, 116, 130, 144, 151, 158, 165,
/* LCTL LWIN LALT SPACE RALT RWFNC RMNU RCTRL ARWL ARDN ARWR NM0 NMPD */
12, 19, 26, 54, 82, 89, 96, 117, 124, 131, 138, 152, 159,
/* B1 B2 B3 B4 B5 B6 B7 B8 B9 B10 B11 B12 B12 B13 B14 B15 B16 B17 B18 */
};
const std::vector<unsigned int> ck530_keymap =
{
/* ESC F1 F2 F3 F4 F5 F6 F7 F8 F9 F10 F11 F12 PRSC SCLK PSBK */
6, 21, 27, 34, 41, 55, 62, 69, 76, 83, 90, 97, 104, 111, 118, 125,
/* BKTK 1 2 3 4 5 6 7 8 9 0 - = BPSC INS HOME PGUP */
7, 15, 22, 28, 35, 42, 49, 56, 63, 70, 77, 84, 91, 105, 112, 119, 126,
/* TAB Q W E R T Y U I O P [ ] \ DEL END PGDN */
8, 16, 23, 29, 36, 43, 50, 57, 64, 71, 78, 85, 92, 106, 113, 120, 127,
/* CPLK A S D F G H J K L ; " # ENTR */
9, 17, 24, 30, 37, 44, 51, 58, 65, 72, 79, 86, 93, 107,
/* LSFT ISO\ Z X C V B N M , . / RSFT ARWU */
10, 18, 25, 31, 38, 45, 52, 59, 66, 73, 80, 87, 108, 122,
/* LCTL LWIN LALT SPC RALT RFNC RMNU RCTL ARWL ARWD ARWR */
11, 12, 19, 46, 74, 81, 88, 109, 116, 123, 130,
};
const std::vector<unsigned int> ck550_v2_keymap =
{
/* ESC F1 F2 F3 F4 F5 F6 F7 F8 F9 F10 F11 F12 PRSC SCLK PSBK */
0, 18, 24, 30, 36, 48, 54, 60, 66, 72, 78, 84, 90, 96, 102, 108,
/* BKTK 1 2 3 4 5 6 7 8 9 0 - = BPSC INS HOME PGUP NMLK NMDV NMTM NMMI */
1, 13, 19, 25, 31, 37, 43, 49, 55, 61, 67, 73, 79, 91, 97, 103, 109, 115, 121, 127, 133,
/* TAB Q W E R T Y U I O P [ ] \ DEL END PGDN NM7 NM8 NM9 NMPL */
2, 14, 20, 26, 32, 38, 44, 50, 56, 62, 68, 74, 80, 92, 98, 104, 110, 116, 122, 128, 134,
/* CPLK A S D F G H J K L ; ' # ENTR NM4 NM5 NM6 */
3, 15, 21, 27, 33, 39, 45, 51, 57, 63, 69, 75, 87, 93, 117, 123, 129,
/* LSFT ISO\ Z X C V B N M , . / RSFT ARWU NM1 NM2 NM3 NMER */
4, 10, 16, 22, 28, 34, 40, 46, 52, 58, 64, 70,/*76,*/ 94, 106, 118, 124, 130, 136,
/* LCTL LWIN LALT SPACE RALT RWFNC RMNU RCTRL ARWL ARDN ARWR NM0 NMPD */
5, 11, 17, 41, 65, 71, 77, 95, 101, 107, 113, 125, 131,
};
const std::vector<unsigned int> ck552_keymap =
{
/* ESC F1 F2 F3 F4 F5 F6 F7 F8 F9 F10 F11 F12 PRSC SCLK PSBK */
0, 18, 24, 30, 36, 48, 54, 60, 66, 72, 78, 84, 90, 96, 102, 108,
/* BKTK 1 2 3 4 5 6 7 8 9 0 - = BPSC INS HOME PGUP NMLK NMDV NMTM NMMI */
1, 13, 19, 25, 31, 37, 43, 49, 55, 61, 67, 73, 79, 91, 97, 103, 109, 115, 121, 127, 133,
/* TAB Q W E R T Y U I O P [ ] \ DEL END PGDN NM7 NM8 NM9 NMPL */
2, 14, 20, 26, 32, 38, 44, 50, 56, 62, 68, 74, 80, 92, 98, 104, 110, 116, 122, 128, 134,
/* CPLK A S D F G H J K L ; ' # ENTR NM4 NM5 NM6 */
3, 15, 21, 27, 33, 39, 45, 51, 57, 63, 69, 75, 81, 93, 117, 123, 129,
/* LSFT ISO\ Z X C V B N M , . / RSFT ARWU NM1 NM2 NM3 NMER */
4, 10, 16, 22, 28, 34, 40, 46, 52, 58, 64, 70,/*76,*/ 94, 106, 118, 124, 130, 136,
/* LCTL LWIN LALT SPACE RALT RWFNC RMNU RCTRL ARWL ARDN ARWR NM0 NMPD */
5, 11, 17, 41, 65, 71, 77, 95, 101, 107, 113, 125, 131,
};
/*-------------------------------------------------------------------------*\
| KEYMAPS |
\*-------------------------------------------------------------------------*/
keyboard_keymap_overlay_values mk_pro_s_layout
{
KEYBOARD_SIZE::KEYBOARD_SIZE_TKL,
{
mk_pro_s_keymap,
{
/* Add more regional layout fixes here */
}
},
{
/*---------------------------------------------------------------------------------------------------------*\
| Edit Keys |
| Zone, Row, Column, Value, Key, OpCode, |
\*---------------------------------------------------------------------------------------------------------*/
},
};
keyboard_keymap_overlay_values mk_pro_l_layout
{
KEYBOARD_SIZE::KEYBOARD_SIZE_FULL,
{
mk_pro_l_keymap,
{
/* Add more regional layout fixes here */
}
},
{
/*---------------------------------------------------------------------------------------------------------*\
| Edit Keys |
| Zone, Row, Column, Value, Key, OpCode, |
\*---------------------------------------------------------------------------------------------------------*/
{ 0, 0, 17, 101, "Key: P1", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 0, 18, 109, "Key: P2", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 0, 19, 117, "Key: P3", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 0, 20, 119, "Key: P4", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
},
};
/*-------------------------------------------------------------*\
| CoolerMaster MK85O Keyboard |
| Unknown Keys: ISO\, ISO# set to 0 |
\*-------------------------------------------------------------*/
keyboard_keymap_overlay_values mk850_layout
{
KEYBOARD_SIZE::KEYBOARD_SIZE_FULL,
{
mk850_keymap,
{
/* Add more regional layout fixes here */
}
},
{
/*---------------------------------------------------------------------------------------------------------*\
| Edit Keys |
| Zone, Row, Column, Value, Key, OpCode, |
\*---------------------------------------------------------------------------------------------------------*/
{ 0, 0, 17, 146, "Key: Aim <|>", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, }, // aimpad <|>
{ 0, 0, 18, 153, "Key: Aim -", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, }, // aimpad +
{ 0, 0, 19, 160, "Key: Aim +", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, }, // aimpad -
{ 0, 1, 0, 0, "Key: M5", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 2, 0, 1, "Key: M4", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 3, 0, 2, "Key: M3", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 4, 0, 3, "Key: M2", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 5, 0, 4, "Key: M1", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
},
};
keyboard_keymap_overlay_values sk622_layout
{
KEYBOARD_SIZE::KEYBOARD_SIZE_SIXTY,
{
sk622_keymap,
{
/* Add more regional layout fixes here */
}
},
{
/*---------------------------------------------------------------------------------------------------------*\
| Edit Keys |
| Zone, Row, Column, Value, Key, OpCode, |
\*---------------------------------------------------------------------------------------------------------*/
{ 0, 0, 0, 7, "Light: Top 1", KEYBOARD_OPCODE_INSERT_ROW, },
{ 0, 0, 1, 14, "Light: Top 2", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 0, 2, 21, "Light: Top 3", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 0, 3, 28, "Light: Top 4", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 0, 4, 35, "Light: Top 5", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 0, 5, 42, "Light: Top 6", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 0, 6, 49, "Light: Top 7", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 0, 7, 56, "Light: Top 8", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 0, 8, 63, "Light: Top 9", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 0, 9, 70, "Light: Top 10", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 0, 10, 77, "Light: Top 11", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 0, 11, 84, "Light: Top 12", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 0, 12, 91, "Light: Top 13", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 0, 13, 98, "Light: Top 14", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 0, 14, 105, "Light: Top 14", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 1, 0, 0, "Light: Left 1", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 2, 0, 1, "Light: Left 2", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 3, 0, 2, "Light: Left 3", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 4, 0, 3, "Light: Left 4", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 5, 0, 4, "Light: Left 5", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 1, 16, 112, "Light: Right 1", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 2, 16, 113, "Light: Right 2", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 3, 16, 114, "Light: Right 3", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 4, 16, 115, "Light: Right 4", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 5, 16, 116, "Light: Right 5", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 6, 0, 6, "Light: Bottom 1", KEYBOARD_OPCODE_INSERT_ROW, },
{ 0, 6, 1, 20, "Light: Bottom 2", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 6, 2, 27, "Light: Bottom 3", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 6, 3, 34, "Light: Bottom 4", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 6, 4, 41, "Light: Bottom 5", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 6, 5, 48, "Light: Bottom 6", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 6, 6, 55, "Light: Bottom 7", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 6, 7, 62, "Light: Bottom 8", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 6, 8, 69, "Light: Bottom 9", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 6, 9, 76, "Light: Bottom 10", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 6, 10, 83, "Light: Bottom 11", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 6, 11, 90, "Light: Bottom 12", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 6, 12, 97, "Light: Bottom 13", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 6, 13, 104, "Light: Bottom 14", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 6, 14, 111, "Light: Bottom 15", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 6, 14, 118, "Light: Bottom 16", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
},
};
keyboard_keymap_overlay_values sk630_layout
{
KEYBOARD_SIZE::KEYBOARD_SIZE_TKL,
{
sk630_keymap,
{
/* Add more regional layout fixes here */
}
},
{
/*---------------------------------------------------------------------------------------------------------*\
| Edit Keys |
| Zone, Row, Column, Value, Key, OpCode, |
\*---------------------------------------------------------------------------------------------------------*/
}
};
keyboard_keymap_overlay_values sk650_layout
{
KEYBOARD_SIZE::KEYBOARD_SIZE_FULL,
{
sk650_keymap,
{
/* Add more regional layout fixes here */
}
},
{
/*---------------------------------------------------------------------------------------------------------*\
| Edit Keys |
| Zone, Row, Column, Value, Key, OpCode, |
\*---------------------------------------------------------------------------------------------------------*/
}
};
keyboard_keymap_overlay_values sk652_layout
{
KEYBOARD_SIZE::KEYBOARD_SIZE_FULL,
{
sk652_keymap,
{
/* Add more regional layout fixes here */
}
},
{
/*---------------------------------------------------------------------------------------------------------*\
| Edit Keys |
| Zone, Row, Column, Value, Key, OpCode, |
\*---------------------------------------------------------------------------------------------------------*/
}
};
keyboard_keymap_overlay_values sk653_layout
{
KEYBOARD_SIZE::KEYBOARD_SIZE_FULL,
{
sk653_keymap,
{
/* Add more regional layout fixes here */
}
},
{
/*---------------------------------------------------------------------------------------------------------*\
| Edit Keys |
| Zone, Row, Column, Value, Key, OpCode, |
\*---------------------------------------------------------------------------------------------------------*/
}
};
/*-------------------------------------------------------------*\
| CoolerMaster MK730 Keyboard |
\*-------------------------------------------------------------*/
keyboard_keymap_overlay_values mk730_layout
{
KEYBOARD_SIZE::KEYBOARD_SIZE_TKL,
{
mk730_keymap,
{
/* Add more regional layout fixes here */
}
},
{
/*---------------------------------------------------------------------------------------------------------*\
| Edit Keys |
| Zone, Row, Column, Value, Key, OpCode, |
\*---------------------------------------------------------------------------------------------------------*/
{ 0, 1, 0, 1, "Light: Left 1", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 2, 0, 2, "Light: Left 2", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 3, 0, 3, "Light: Left 3", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 4, 0, 4, "Light: Left 4", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 1, 18, 141, "Light: Right 1", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 2, 18, 142, "Light: Right 2", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 3, 18, 143, "Light: Right 3", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 4, 18, 144, "Light: Right 4", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 6, 1, 13, "Light: Bottom 1", KEYBOARD_OPCODE_INSERT_ROW, },
{ 0, 6, 2, 20, "Light: Bottom 2", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 6, 3, 27, "Light: Bottom 3", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 6, 4, 34, "Light: Bottom 4", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 6, 5, 41, "Light: Bottom 5", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 6, 6, 55, "Light: Bottom 6", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 6, 7, 62, "Light: Bottom 7", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 6, 8, 69, "Light: Logo", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 6, 10, 76, "Light: Bottom 8", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 6, 11, 90, "Light: Bottom 9", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 6, 12, 104, "Light: Bottom 10", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 6, 13, 111, "Light: Bottom 11", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 6, 14, 118, "Light: Bottom 12", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 6, 15, 125, "Light: Bottom 13", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
}
};
/*-------------------------------------------------------------*\
| CoolerMaster MK750 Keyboard |
| based on keymap defined in Signal. |
| The keymap needs the following adjustments |
| NMLK - Unknown set to 0 |
| SCLK - Unknown set to 0 |
| CAPS - Unknown set to 0 |
| Guesses on ISO\ and # |
\*-------------------------------------------------------------*/
keyboard_keymap_overlay_values mk750_layout
{
KEYBOARD_SIZE::KEYBOARD_SIZE_FULL,
{
mk750_keymap,
{
/* Add more regional layout fixes here */
}
},
{
/*---------------------------------------------------------------------------------------------------------*\
| Edit Keys |
| Zone, Row, Column, Value, Key, OpCode, |
\*---------------------------------------------------------------------------------------------------------*/
{ 0, 0, 17, 140, KEY_EN_MEDIA_MUTE, KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 0, 18, 147, KEY_EN_MEDIA_PLAY_PAUSE, KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 0, 19, 154, KEY_EN_MEDIA_PREVIOUS, KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 0, 20, 161, KEY_EN_MEDIA_NEXT, KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 1, 0, 1, "Light: Left 1", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 2, 0, 2, "Light: Left 2", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 3, 0, 3, "Light: Left 3", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 4, 0, 4, "Light: Left 4", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 1, 22, 170, "Light: Right 1", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 2, 22, 171, "Light: Right 2", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 3, 22, 172, "Light: Right 3", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 4, 22, 173, "Light: Right 4", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 6, 1, 20, "Light: Bottom 1", KEYBOARD_OPCODE_INSERT_ROW, },
{ 0, 6, 2, 27, "Light: Bottom 2", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 6, 3, 34, "Light: Bottom 3", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 6, 4, 41, "Light: Bottom 4", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 6, 5, 55, "Light: Bottom 5", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 6, 6, 62, "Light: Bottom 6", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 6, 7, 69, "Light: Bottom 7", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 6, 8, 76, "Light: Bottom 8", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 6, 9, 83, "Light: Bottom 9", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 6, 10, 90, "Light: Bottom 10", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 6, 11, 104, "Light: Bottom 11", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 6, 12, 111, "Light: Bottom 12", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 6, 13, 118, "Light: Bottom 13", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 6, 14, 125, "Light: Bottom 14", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 6, 15, 132, "Light: Bottom 15", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 6, 16, 146, "Light: Bottom 16", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 6, 17, 153, "Light: Bottom 17", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 6, 18, 160, "Light: Bottom 18", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
}
};
keyboard_keymap_overlay_values ck530_layout
{
KEYBOARD_SIZE::KEYBOARD_SIZE_TKL,
{
ck530_keymap,
{
/* Add more regional layout fixes here */
}
},
{
/*---------------------------------------------------------------------------------------------------------*\
| Edit Keys |
| Zone, Row, Column, Value, Key, OpCode, |
\*---------------------------------------------------------------------------------------------------------*/
}
};
keyboard_keymap_overlay_values ck550v2_layout
{
KEYBOARD_SIZE::KEYBOARD_SIZE_FULL,
{
ck550_v2_keymap,
{
{
/* Add more regional layout fixes here */
/*---------------------------------------------------------------------------------------------------------*\
| Edit Keys |
| Zone, Row, Column, Value, Key, OpCode, |
\*---------------------------------------------------------------------------------------------------------*/
},
},
},
{
/*---------------------------------------------------------------------------------------------------------*\
| Edit Keys |
| Zone, Row, Column, Value, Key, OpCode, |
\*---------------------------------------------------------------------------------------------------------*/
{ 0, 0, 17, 120, "Indicator: N", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 0, 18, 126, "Indicator: C", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 0, 19, 132, "Indicator: S", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
},
};
keyboard_keymap_overlay_values ck552_layout
{
KEYBOARD_SIZE::KEYBOARD_SIZE_FULL,
{
ck552_keymap,
{
{
/* Add more regional layout fixes here */
/*---------------------------------------------------------------------------------------------------------*\
| Edit Keys |
| Zone, Row, Column, Value, Key, OpCode, |
\*---------------------------------------------------------------------------------------------------------*/
},
},
},
{
/*---------------------------------------------------------------------------------------------------------*\
| Edit Keys |
| Zone, Row, Column, Value, Key, OpCode, |
\*---------------------------------------------------------------------------------------------------------*/
},
};
static const cm_kb_zone cm_generic_zone =
{
ZONE_EN_KEYBOARD,
ZONE_TYPE_MATRIX,
};
cm_kb_device mk_pro_s_device
{
COOLERMASTER_KEYBOARD_PRO_S_PID,
{
&cm_generic_zone,
},
&mk_pro_s_layout,
};
cm_kb_device mk_pro_l_device
{
COOLERMASTER_KEYBOARD_PRO_L_PID,
{
&cm_generic_zone,
},
&mk_pro_l_layout,
};
cm_kb_device mk850_device
{
COOLERMASTER_KEYBOARD_MK850_PID,
{
&cm_generic_zone,
},
&mk850_layout,
};
cm_kb_device sk622w_device
{
COOLERMASTER_KEYBOARD_SK622W_PID,
{
&cm_generic_zone,
},
&sk622_layout,
};
cm_kb_device sk622b_device
{
COOLERMASTER_KEYBOARD_SK622B_PID,
{
&cm_generic_zone,
},
&sk622_layout,
};
cm_kb_device sk630_device
{
COOLERMASTER_KEYBOARD_SK630_PID,
{
&cm_generic_zone,
},
&sk630_layout,
};
cm_kb_device sk650_device
{
COOLERMASTER_KEYBOARD_SK650_PID,
{
&cm_generic_zone,
},
&sk650_layout,
};
cm_kb_device sk652_device
{
COOLERMASTER_KEYBOARD_SK652_PID,
{
&cm_generic_zone,
},
&sk652_layout,
};
cm_kb_device sk653_device
{
COOLERMASTER_KEYBOARD_SK653_PID,
{
&cm_generic_zone,
},
&sk652_layout,
};
/*---------------------------------------------------------*\
| TODO: Keymap is incomplete. Extra keys mode enabled to |
| aid in key discovery. |
\*---------------------------------------------------------*/
cm_kb_device mk730_device
{
COOLERMASTER_KEYBOARD_MK730_PID,
{
&cm_generic_zone,
},
&mk730_layout,
};
cm_kb_device mk750_device
{
COOLERMASTER_KEYBOARD_MK750_PID,
{
&cm_generic_zone,
},
&mk750_layout,
};
cm_kb_device ck530_device
{
COOLERMASTER_KEYBOARD_CK530_PID,
{
&cm_generic_zone,
},
&ck530_layout,
};
cm_kb_device ck530_v2_device
{
COOLERMASTER_KEYBOARD_CK530_V2_PID,
{
&cm_generic_zone,
},
&ck530_layout,
};
cm_kb_device ck550_v2_device
{
COOLERMASTER_KEYBOARD_CK550_V2_PID,
{
&cm_generic_zone,
},
&ck550v2_layout,
};
cm_kb_device ck552_v2_device
{
COOLERMASTER_KEYBOARD_CK552_V2_PID,
{
&cm_generic_zone,
},
&ck552_layout,
};
cm_kb_device mk_pro_l_white_device
{
COOLERMASTER_KEYBOARD_PRO_L_WHITE_PID,
{
&cm_generic_zone,
},
&mk_pro_s_layout,
};
/*-----------------------------------------------------------------*\
| KEYBOARDS |
\*-----------------------------------------------------------------*/
const cm_kb_device* cm_kb_devices[] =
{
&mk_pro_s_device,
&mk_pro_l_device,
&mk850_device,
&sk622w_device,
&sk622b_device,
&sk630_device,
&sk650_device,
&sk652_device,
&sk653_device,
&mk730_device,
&mk750_device,
&ck530_device,
&ck530_v2_device,
&ck550_v2_device,
&ck552_v2_device,
&mk_pro_l_white_device,
};
const unsigned int COOLERMASTER_KEYBOARD_DEVICE_COUNT = (sizeof(cm_kb_devices) / sizeof(cm_kb_devices[ 0 ]));
const cm_kb_device** cm_kb_device_list = cm_kb_devices;

120
Controllers/CoolerMasterController/CMKeyboardController/CMKeyboardDevices.h Normal file
View file

@ -0,0 +1,120 @@
/*-------------------------------------------------------------------*\
| CMKeyboardDevices.h |
| |
| Keymap definitions for Cooler Master Keyboards |
| |
| Tam D (too.manyhobbies) 30th Nov 2023 |
| |
\*-------------------------------------------------------------------*/
#pragma once
#include "RGBController.h"
#include "KeyboardLayoutManager.h"
/*-----------------------------------------------------*\
| List of all supported effects by this controller. |
| All of these effects are firmware controlled, and |
| they types of effects supported will depend on the |
| Keyboard. |
| |
| To enable a command, the SetEffect(effectId) needs |
| to be called. The specific effectId->Effect mapping |
| depends on the keyboard. |
\*-----------------------------------------------------*/
enum cm_keyboard_effect_type
{
NONE = 0,
DIRECT,
SINGLE,
FULLY_LIT,
STATIC,
BREATHE,
CYCLE,
WAVE,
RIPPLE,
CROSS,
RAINDROPS,
STARS,
SNAKE,
CUSTOMIZED,
INDICATOR,
MULTILAYER,
REACTIVE_FADE,
REACTIVE_PUNCH,
REACTIVE_TORNADO,
HEARTBEAT,
FIREBALL,
SNOW,
CIRCLE_SPECTRUM,
WATER_RIPPLE,
OFF
};
#define CM_KB_ZONES_MAX 1
typedef struct
{
std::string name;
zone_type type;
} cm_kb_zone;
typedef struct
{
uint16_t product_id;
const cm_kb_zone * zones[CM_KB_ZONES_MAX];
keyboard_keymap_overlay_values* layout_new;
} cm_kb_device;
#define COOLERMASTER_VID 0x2516
#define CMKB_MAXKEYS 256
/*-----------------------------------------------------------------*\
| keyboard support status is indicated to the right of |
| the PID definition. Attribution to products is also |
| indicated. |
| |
| libcmmk |
| signal https://gitlab.com/signalrgb/signal-plugins |
| openrgb |
| ck550-macos https://github.com/vookimedlo/ck550-macos/tree/master |
| reversed |
| |
| issue tickets, open merge requests etc are provided |
| for developer references. |
| # denotes issue ticket |
| ! denotes merge/pull request |
\*-----------------------------------------------------------------*/
#define COOLERMASTER_KEYBOARD_CK351_PID 0x014F // unsupported
#define COOLERMASTER_KEYBOARD_CK530_PID 0x009F // [ck550-macos]
#define COOLERMASTER_KEYBOARD_CK530_V2_PID 0x0147 // [signal]
#define COOLERMASTER_KEYBOARD_CK550_V2_PID 0x0145 // [openrgb #800, #2863, signal]
#define COOLERMASTER_KEYBOARD_CK552_V2_PID 0x007F // [ck550-macos, signal]
#define COOLERMASTER_KEYBOARD_CK570_V2_PID 0x01E8 // unsupported
#define COOLERMASTER_KEYBOARD_CK720_PID 0x016B // unsupported
#define COOLERMASTER_KEYBOARD_CK721_PID 0x016D // unsupported
#define COOLERMASTER_KEYBOARD_CK721LINE_PID 0x01EE // unsupported
#define COOLERMASTER_KEYBOARD_PRO_L_PID 0x003B // [libcmmk !16]
#define COOLERMASTER_KEYBOARD_PRO_L_WHITE_PID 0x0047 // [libcmmk]
#define COOLERMASTER_KEYBOARD_PRO_S_PID 0x003C // [libcmmk #30 !31 !36, !37, !7, #5(closed), #3(closed)]
// MASTERKEYS PRO M [libcmmk #17]
#define COOLERMASTER_KEYBOARD_MK721_PID 0x016F // unsupported
#define COOLERMASTER_KEYBOARD_MK730_PID 0x008F // [openrgb #1630, libcmmk]
#define COOLERMASTER_KEYBOARD_MK750_PID 0x0067 // fw1.2 [libcmmk #25 !9, !14, signal]
#define COOLERMASTER_KEYBOARD_MK770_PID 0x01D5 // unsupported
#define COOLERMASTER_KEYBOARD_MK850_PID 0x0069 // [signal]
#define COOLERMASTER_KEYBOARD_SK620B_PID 0x0157 // unsupported
#define COOLERMASTER_KEYBOARD_SK620W_PID 0x0159 // [signal]
#define COOLERMASTER_KEYBOARD_SK622B_PID 0x0149 // [openrgb #3110, signal #217(closed)]
#define COOLERMASTER_KEYBOARD_SK622W_PID 0x014B // [signal]
#define COOLERMASTER_KEYBOARD_SK630_PID 0x0089 // [openrgb #967, libcmmk !21]
#define COOLERMASTER_KEYBOARD_SK631B_PID 0x008B // unsupported
#define COOLERMASTER_KEYBOARD_SK631W_PID 0x0125 // [libcmmk]
#define COOLERMASTER_KEYBOARD_SK650_PID 0x008D // [openrgb #613, libcmmk #23 !37 !27 !28, signal]
#define COOLERMASTER_KEYBOARD_SK651B_PID 0x0091 // unsupported
#define COOLERMASTER_KEYBOARD_SK651W_PID 0x0127 // [signal]
#define COOLERMASTER_KEYBOARD_SK652_PID 0x015D // [signal]
#define COOLERMASTER_KEYBOARD_SK653_PID 0x01AB // [openrgb #3571, signal]
extern const unsigned int COOLERMASTER_KEYBOARD_DEVICE_COUNT;
extern const cm_kb_device** cm_kb_device_list;

497
Controllers/CoolerMasterController/CMKeyboardController/CMKeyboardV1Controller.cpp Normal file
View file

@ -0,0 +1,497 @@
/*-------------------------------------------------------------------*\
| CMKeyboardV1Controller.cpp |
| |
| Driver for Coolermaster MasterKeys keyboards (V1) |
| |
| Tam D (too.manyhobbies) 30th Nov 2023 |
| |
\*-------------------------------------------------------------------*/
#include "CMKeyboardV1Controller.h"
#include "LogManager.h"
#include <cmath>
CMKeyboardV1Controller::CMKeyboardV1Controller(hid_device* dev_handle, hid_device_info* dev_info) : CMKeyboardAbstractController(dev_handle, dev_info)
{
m_sFirmwareVersion = _GetFirmwareVersion();
}
CMKeyboardV1Controller::~CMKeyboardV1Controller()
{
}
void CMKeyboardV1Controller::Initialize()
{
SetLEDControl(true);
}
void CMKeyboardV1Controller::SetActiveEffect(uint8_t effectId)
{
SendCommand({0x51, 0x28, 0x00, 0x00, effectId});
}
uint8_t CMKeyboardV1Controller::GetActiveEffect()
{
std::vector<uint8_t> data = SendCommand({0x52, 0x28});
return data[4];
}
void CMKeyboardV1Controller::SetEffect(uint8_t effectId, uint8_t p1, uint8_t p2, uint8_t p3, RGBColor color1, RGBColor color2)
{
std::vector<uint8_t> data;
data.push_back(0x51);
data.push_back(0x2C);
data.push_back(0x00); // multilayer_mode - NOT SUPPORTED
data.push_back(0x00);
data.push_back(effectId);
data.push_back(p1);
data.push_back(p2);
data.push_back(p3);
data.push_back(0xFF);
data.push_back(0xFF);
data.push_back(RGBGetRValue(color1));
data.push_back(RGBGetGValue(color1));
data.push_back(RGBGetBValue(color1));
data.push_back(RGBGetRValue(color2));
data.push_back(RGBGetGValue(color2));
data.push_back(RGBGetBValue(color2));
/*-------------------------------------------*\
| Likely a bit mask for each LEDs. |
| 3 bits per LED x 127 possible LEDs ~48 bytes|
\*-------------------------------------------*/
for(size_t i = 0; i < 48; i++)
{
data.push_back(0xFF);
}
SetCustomMode();
SetActiveEffect(effectId);
SendCommand(data);
}
void CMKeyboardV1Controller::SetCustomMode()
{
SetControlMode(0x01);
}
void CMKeyboardV1Controller::SetMode(mode selectedMode)
{
RGBColor color1 = 0;
RGBColor color2 = 0;
uint8_t cSpeed = 0;
uint8_t cDirection = 0;
uint8_t effectId = selectedMode.value;
bool bModeRandom = false;
if(selectedMode.colors.size() >= 1)
{
color1 = selectedMode.colors[0];
}
if(selectedMode.colors.size() >= 2)
{
color2 = selectedMode.colors[1];
}
if(selectedMode.color_mode == MODE_COLORS_RANDOM)
{
bModeRandom = true;
}
int selectedEffect = mapModeValueEffect[effectId];
cSpeed = selectedMode.speed;
switch(selectedMode.direction)
{
case MODE_DIRECTION_LEFT:
case MODE_DIRECTION_HORIZONTAL:
cDirection = 0x00;
break;
case MODE_DIRECTION_RIGHT:
cDirection = 0x04;
break;
case MODE_DIRECTION_UP:
case MODE_DIRECTION_VERTICAL:
cDirection = 0x06;
break;
case MODE_DIRECTION_DOWN:
cDirection = 0x02;
break;
default:
break;
}
switch(selectedEffect)
{
case DIRECT:
case STATIC:
{
SetEffect(effectId, 0, 0, 0, color1, color2);
}
break;
case CROSS:
case BREATHE:
case REACTIVE_PUNCH:
case CIRCLE_SPECTRUM:
case SNAKE:
{
SetEffect(effectId, cSpeed, 0, 0xFF, color1, color2);
}
break;
case WAVE:
{
SetEffect(effectId, cSpeed, cDirection, 0xFF, color1, color2);
}
break;
case RIPPLE:
{
SetEffect(effectId, cSpeed, bModeRandom ? 0x80 : 0x00, 0xFF, color1, color2);
}
break;
case RAINDROPS:
{
SetEffect(effectId, 0x6a, 0x00, cSpeed, color1, color2);
}
break;
case STARS:
{
SetEffect(effectId, cSpeed, 0x00, 0x10, color1, color2);
}
break;
default:
break;
}
}
void CMKeyboardV1Controller::InitializeModes(std::vector<mode> &modes)
{
mode Direct;
Direct.name = "Direct";
Direct.value = 0x02;
Direct.flags = MODE_FLAG_HAS_PER_LED_COLOR;
Direct.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Direct);
mapModeValueEffect[0x02] = DIRECT;
mode Static;
Static.name = "Static";
Static.value = 0x00;
Static.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
Static.color_mode = MODE_COLORS_MODE_SPECIFIC;
Static.colors_min = 1;
Static.colors_max = 1;
Static.colors.resize(1);
modes.push_back(Static);
mapModeValueEffect[0x00] = STATIC;
mode Breathing;
Breathing.name = "Breathing";
Breathing.value = 0x01;
Breathing.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED;
Breathing.color_mode = MODE_COLORS_MODE_SPECIFIC;
Breathing.speed_min = 0x46;
Breathing.speed_max = 0x27;
Breathing.speed = 0x36;
Breathing.colors_min = 1;
Breathing.colors_max = 1;
Breathing.colors.resize(1);
modes.push_back(Breathing);
mapModeValueEffect[0x01] = BREATHE;
mode Cycle;
Cycle.name = "Spectrum Cycle";
Cycle.value = 0x02;
Cycle.flags = MODE_FLAG_HAS_SPEED;
Cycle.color_mode = MODE_COLORS_NONE;
Cycle.speed_min = 0x96;
Cycle.speed_max = 0x68;
Cycle.speed = 0x7F;
modes.push_back(Cycle);
mapModeValueEffect[0x02] = CIRCLE_SPECTRUM;
mode Reactive;
Reactive.name = "Reactive";
Reactive.value = 0x03;
Reactive.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED;
Reactive.color_mode = MODE_COLORS_MODE_SPECIFIC;
Reactive.speed_min = 0x3C;
Reactive.speed_max = 0x2F;
Reactive.speed = 0x35;
Reactive.colors_min = 2;
Reactive.colors_max = 2;
Reactive.colors.resize(2);
modes.push_back(Reactive);
mapModeValueEffect[0x03] = REACTIVE_PUNCH;
mode Wave;
Wave.name = "Rainbow Wave";
Wave.value = 0x04;
Wave.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_DIRECTION_UD;
Wave.color_mode = MODE_COLORS_MODE_SPECIFIC;
Wave.speed_min = 0x48;
Wave.speed_max = 0x2A;
Wave.speed = 0x29;
Wave.direction = MODE_DIRECTION_LEFT;
Wave.colors_min = 1;
Wave.colors_max = 1;
Wave.colors.resize(1);
modes.push_back(Wave);
mapModeValueEffect[0x04] = WAVE;
mode Ripple;
Ripple.name = "Ripple Effect";
Ripple.value = 0x05;
Ripple.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED;
Ripple.color_mode = MODE_COLORS_MODE_SPECIFIC;
Ripple.speed_min = 0x96;
Ripple.speed_max = 0x62;
Ripple.speed = 0x7C;
Ripple.colors_min = 2;
Ripple.colors_max = 2;
Ripple.colors.resize(2);
modes.push_back(Ripple);
mapModeValueEffect[0x05] = RIPPLE;
mode Cross;
Cross.name = "Cross";
Cross.value = 0x06;
Cross.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED;
Cross.color_mode = MODE_COLORS_MODE_SPECIFIC;
Cross.speed_min = 0x2A;
Cross.speed_max = 0x48;
Cross.speed = 0x39;
Cross.colors_min = 2;
Cross.colors_max = 2;
Cross.colors.resize(2);
modes.push_back(Cross);
mapModeValueEffect[0x06] = CROSS;
mode Raindrops;
Raindrops.name = "Raindrops";
Raindrops.value = 0x07;
Raindrops.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED;
Raindrops.color_mode = MODE_COLORS_MODE_SPECIFIC;
Raindrops.speed_min = 0x40;
Raindrops.speed_max = 0x08;
Raindrops.speed = 0x24;
Raindrops.colors_min = 2;
Raindrops.colors_max = 2;
Raindrops.colors.resize(2);
modes.push_back(Raindrops);
mapModeValueEffect[0x07] = RAINDROPS;
mode Stars;
Stars.name = "Starfield";
Stars.value = 0x08;
Stars.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED;
Stars.color_mode = MODE_COLORS_MODE_SPECIFIC;
Stars.speed_min = 0x46;
Stars.speed_max = 0x32;
Stars.speed = 0x3C;
Stars.colors_min = 2;
Stars.colors_max = 2;
Stars.colors.resize(2);
modes.push_back(Stars);
mapModeValueEffect[0x08] = STARS;
mode Snake;
Snake.name = "Snake";
Snake.value = 0x09;
Snake.flags = MODE_FLAG_HAS_SPEED;
Snake.color_mode = MODE_COLORS_NONE;
Snake.speed_min = 0x48;
Snake.speed_max = 0x2A;
Snake.speed = 0x39;
modes.push_back(Snake);
mapModeValueEffect[0x09] = SNAKE;
}
struct cm_keyboard_effect CMKeyboardV1Controller::GetEffect(uint8_t effectId)
{
std::vector<uint8_t> data;
data.push_back(0x52);
data.push_back(0x2C);
data.push_back(0x00);
data.push_back(0x00);
data.push_back(effectId);
data = SendCommand(data);
struct cm_keyboard_effect response;
response.effectId = effectId;
response.p1 = data[5];
response.p2 = data[6];
response.p3 = data[7];
response.color1 = ToRGBColor(data[10], data[11], data[12]);
response.color2 = ToRGBColor(data[13], data[14], data[15]);
return response;
}
std::vector<uint8_t> CMKeyboardV1Controller::GetEnabledEffects()
{
std::vector<uint8_t> data;
data = SendCommand({0x52, 0x29});
std::vector<uint8_t> effects;
for(size_t i = 4; data[i] != 0xFF; i++)
{
effects.push_back(data[i]);
}
return effects;
}
void CMKeyboardV1Controller::SetLEDControl(bool bManual)
{
uint8_t modeId = 0; // firmware
if(bManual)
{
modeId = 0x02; // manual
}
SetControlMode(modeId);
};
void CMKeyboardV1Controller::SetLeds(std::vector<led> leds, std::vector<RGBColor> colors)
{
SetLEDControl(true);
RGBColor rgbColorMap[CM_MAX_LEDS];
memset(rgbColorMap, 0, sizeof(RGBColor)*CM_MAX_LEDS);
for(size_t i = 0; i < leds.size(); i++)
{
rgbColorMap[leds[i].value] = colors[i];
}
RGBColor * pRGBColor = rgbColorMap;
std::lock_guard<std::mutex> guard(m_mutex);
for(size_t i = 0; i < 8; i++)
{
std::vector<uint8_t> data;
data.push_back(0xC0);
data.push_back(0x02);
data.push_back((uint8_t)(i * 2));
data.push_back(0x00);
for(size_t j = 0; j < 16; j++)
{
data.push_back(RGBGetRValue(*pRGBColor));
data.push_back(RGBGetGValue(*pRGBColor));
data.push_back(RGBGetBValue(*pRGBColor));
++pRGBColor;
}
SendCommand(data);
}
}
void CMKeyboardV1Controller::SetSingleLED(uint8_t in_led, RGBColor in_color)
{
std::vector<uint8_t> data;
data.push_back(0xC0);
data.push_back(0x01);
data.push_back(0x01);
data.push_back(0x00);
data.push_back(in_led);
data.push_back(RGBGetRValue(in_color));
data.push_back(RGBGetGValue(in_color));
data.push_back(RGBGetBValue(in_color));
SendCommand(data);
}
/*-------------------------------------------------------------------*\
| Detect the Firmware Version |
| |
| Firmware version string is in the format: |
| <layout>.<minor>.<major> |
| Where <layout> is: |
| UNK = 0, ANSI/US = 1, ISO/EU = 2, JP = 3 |
| Examples: |
| 1.2.1 = ANSI/US Keyboard (PRO S) |
| 2.2.1 = ISO/EU Keyboard (PRO L) |
\*-------------------------------------------------------------------*/
std::string CMKeyboardV1Controller::_GetFirmwareVersion()
{
std::vector<uint8_t> read;
SetControlMode(MODE_FIRMWARE);
read = SendCommand({0x01, 0x02});
char cVersionStr[CM_KEYBOARD_WRITE_SIZE];
for(size_t i = 0; i < read.size(); i++)
{
cVersionStr[i] = read[i];
}
cVersionStr[CM_KEYBOARD_WRITE_SIZE - 1] = 0;
std::string sFirmwareVersion;
sFirmwareVersion = std::string(cVersionStr+4);
LOG_VERBOSE("[%s] GetFirmwareVersion(): [%s]", m_deviceName.c_str(), sFirmwareVersion.c_str());
return sFirmwareVersion;
}
void CMKeyboardV1Controller::Shutdown()
{
}
KEYBOARD_LAYOUT CMKeyboardV1Controller::GetKeyboardLayout()
{
KEYBOARD_LAYOUT layout = KEYBOARD_LAYOUT_DEFAULT;
if(m_sFirmwareVersion.empty())
{
LOG_WARNING("[%s] GetKeyboardLayout() empty firmware string detected. Unable to detect firmware layout. Assuming defaults.", m_deviceName.c_str());
layout = KEYBOARD_LAYOUT_ANSI_QWERTY;
return layout;
}
switch(m_sFirmwareVersion.c_str()[0])
{
case '0':
default:
case '1':
layout = KEYBOARD_LAYOUT_ANSI_QWERTY;
break;
case '2':
layout = KEYBOARD_LAYOUT_ISO_QWERTY;
break;
case '3':
layout = KEYBOARD_LAYOUT_JIS;
break;
}
return layout;
}

39
Controllers/CoolerMasterController/CMKeyboardController/CMKeyboardV1Controller.h Normal file
View file

@ -0,0 +1,39 @@
/*-------------------------------------------------------------------*\
| CMKeyboardV1Controller.h |
| |
| Driver for Coolermaster MasterKeys keyboards (V1) |
| |
| Tam D (too.manyhobbies) 30th Nov 2023 |
| |
\*-------------------------------------------------------------------*/
#include "CMKeyboardAbstractController.h"
class CMKeyboardV1Controller : public CMKeyboardAbstractController
{
public:
CMKeyboardV1Controller(hid_device* dev_handle, hid_device_info* dev_info);
~CMKeyboardV1Controller();
/*---------------------------------------------------------*\
| Protocol specific funtions to be implmented |
\*---------------------------------------------------------*/
void SetLeds(std::vector<led> leds, std::vector<RGBColor> colors);
void SetSingleLED(uint8_t in_led, RGBColor in_color);
void Initialize();
void Shutdown();
void SetLEDControl(bool bManual);
void SetActiveEffect(uint8_t effectId);
uint8_t GetActiveEffect();
void SetEffect(uint8_t effectId, uint8_t p1, uint8_t p2, uint8_t p3, RGBColor color1, RGBColor color2);
struct cm_keyboard_effect GetEffect(uint8_t effectId);
void SetCustomMode();
void SetMode(mode selectedMode);
std::vector<uint8_t> GetEnabledEffects();
void InitializeModes(std::vector<mode> &modes);
KEYBOARD_LAYOUT GetKeyboardLayout();
private:
std::string _GetFirmwareVersion();
};

1046
Controllers/CoolerMasterController/CMKeyboardController/CMKeyboardV2Controller.cpp Normal file
View file

File diff suppressed because it is too large Load diff

54
Controllers/CoolerMasterController/CMKeyboardController/CMKeyboardV2Controller.h Normal file
View file

@ -0,0 +1,54 @@
/*-------------------------------------------------------------------*\
| CMKeyboardV2Controller.h |
| |
| Driver for Coolermaster V2 |
| |
| Tam D (too.manyhobbies) 30th Nov 2023 |
| |
\*-------------------------------------------------------------------*/
#include "CMKeyboardAbstractController.h"
struct stCMKeyboardV2_mode
{
const char *name;
unsigned int value;
unsigned int speed_min;
unsigned int speed_max;
unsigned int speed;
unsigned int brightness;
unsigned int direction;
unsigned int nColors;
unsigned int color_mode;
unsigned int flags;
};
class CMKeyboardV2Controller : public CMKeyboardAbstractController
{
public:
CMKeyboardV2Controller(hid_device* dev_handle, hid_device_info* dev_info);
~CMKeyboardV2Controller();
/*---------------------------------------------------------*\
| Protocol specific funtions to be implmented |
\*---------------------------------------------------------*/
void SetLeds(std::vector<led> leds, std::vector<RGBColor> colors);
void SetSingleLED(uint8_t in_led, RGBColor in_color);
void Initialize();
void Shutdown();
void SetLEDControl(bool bManual);
void SendApplyPacket(uint8_t mode);
void MagicStartupPacket();
void MagicCommand(uint8_t profileId);
void SetCustomMode();
void SetMode(mode selectedMode);
void SetEffect(uint8_t effectId, uint8_t p1, uint8_t p2, uint8_t p3, RGBColor color1, RGBColor color2);
void InitializeModes(std::vector<mode> &modes);
KEYBOARD_LAYOUT GetKeyboardLayout();
private:
void _SetEffectMode(uint8_t effectId);
void _UpdateSpeed(mode selectedMode, uint8_t &cSpeed1, uint8_t &cSpeed2);
std::string _GetFirmwareVersion();
bool m_bMoreFFs;
};

182
Controllers/CoolerMasterController/CMKeyboardController/RGBController_CMKeyboardController.cpp Normal file
View file

@ -0,0 +1,182 @@
/*-------------------------------------------------------------------*\
| RGBController_CMKeyboardController.cpp |
| |
| Controller for Coolermaster keyboards |
| |
| Tam D (too.manyhobbies) 30th Nov 2023 |
| |
\*-------------------------------------------------------------------*/
#include "RGBController_CMKeyboardController.h"
#include "CMKeyboardDevices.h"
/**------------------------------------------------------------------*\
@name Coolermaster Masterkeys Keyboards
@category Keyboard
@type USB
@save :robot:
@direct :white_check_mark:
@effects :white_check_mark:
@detectors DetectCoolerMasterKeyboards
@comment
In CMKeyboardV1Controller brightness control not supported.
Supported effects differ between CMKeyboardV1Controller and
CMKeyboardV2Controller.
\*-------------------------------------------------------------------*/
RGBController_CMKeyboardController::RGBController_CMKeyboardController(CMKeyboardAbstractController* pController)
{
m_pController = pController;
vendor = m_pController->GetDeviceVendor();
type = DEVICE_TYPE_KEYBOARD;
description = "Cooler Master Keyboard Device";
version = m_pController->GetFirmwareVersion();
/*----------------------------------------------------------------*\
| Coolermaster uses the name field to store the serial number in |
| many of their keyboards. |
\*----------------------------------------------------------------*/
serial = m_pController->GetDeviceSerial();
location = m_pController->GetLocation();
m_keyboardLayout = m_pController->GetKeyboardLayout();
name = m_pController->GetDeviceName();
m_pController->InitializeModes(modes);
SetupZones();
}
RGBController_CMKeyboardController::~RGBController_CMKeyboardController()
{
for(size_t i = 0; i < m_pUnknownKeyNames.size(); i++)
{
if(m_pUnknownKeyNames[i])
{
delete(m_pUnknownKeyNames[i]);
}
}
}
#define COOLERMASTER_ZONES_MAX 1
void RGBController_CMKeyboardController::SetupZones()
{
std::string physical_size;
unsigned int max_led_value = 0;
const cm_kb_device* coolermaster = m_pController->GetDeviceData();
/*---------------------------------------------------------*\
| Fill in zones from the device data |
\*---------------------------------------------------------*/
for(size_t i = 0; i < COOLERMASTER_ZONES_MAX; i++)
{
if(coolermaster->zones[i] == NULL)
{
break;
}
else
{
zone new_zone;
new_zone.name = coolermaster->zones[i]->name;
new_zone.type = coolermaster->zones[i]->type;
if(new_zone.type == ZONE_TYPE_MATRIX)
{
KeyboardLayoutManager new_kb(m_keyboardLayout, coolermaster->layout_new->base_size, coolermaster->layout_new->key_values);
matrix_map_type * new_map = new matrix_map_type;
new_zone.matrix_map = new_map;
new_map->map = new unsigned int[new_map->height * new_map->width];
if(coolermaster->layout_new->base_size != KEYBOARD_SIZE_EMPTY)
{
/*---------------------------------------------------------*\
| Minor adjustments to keyboard layout |
\*---------------------------------------------------------*/
keyboard_keymap_overlay_values* temp = coolermaster->layout_new;
new_kb.ChangeKeys(*temp);
new_map->height = new_kb.GetRowCount();
new_map->width = new_kb.GetColumnCount();
/*---------------------------------------------------------*\
| Matrix map still uses declared zone rows and columns |
| as the packet structure depends on the matrix map |
\*---------------------------------------------------------*/
new_kb.GetKeyMap(new_map->map, KEYBOARD_MAP_FILL_TYPE_COUNT, new_map->height, new_map->width);
/*---------------------------------------------------------*\
| Create LEDs for the Matrix zone |
| Place keys in the layout to populate the matrix |
\*---------------------------------------------------------*/
new_zone.leds_count = new_kb.GetKeyCount();
LOG_DEBUG("[%s] Created KB matrix with %d rows and %d columns containing %d keys",
m_pController->GetDeviceName().c_str(), new_kb.GetRowCount(), new_kb.GetColumnCount(), new_zone.leds_count);
for(unsigned int led_idx = 0; led_idx < new_zone.leds_count; led_idx++)
{
led new_led;
new_led.name = new_kb.GetKeyNameAt(led_idx);
new_led.value = new_kb.GetKeyValueAt(led_idx);
max_led_value = std::max(max_led_value, new_led.value);
leds.push_back(new_led);
}
}
/*---------------------------------------------------------*\
| Add 1 the max_led_value to account for the 0th index |
\*---------------------------------------------------------*/
max_led_value++;
}
/*---------------------------------------------------------*\
| name is not set yet so description is used instead |
\*---------------------------------------------------------*/
LOG_DEBUG("[%s] Creating a %s zone: %s with %d LEDs", description.c_str(),
((new_zone.type == ZONE_TYPE_MATRIX) ? "matrix": "linear"),
new_zone.name.c_str(), new_zone.leds_count);
new_zone.leds_min = new_zone.leds_count;
new_zone.leds_max = new_zone.leds_count;
zones.push_back(new_zone);
}
}
SetupColors();
}
void RGBController_CMKeyboardController::ResizeZone(int /*zone*/, int /*new_size*/)
{
}
void RGBController_CMKeyboardController::DeviceUpdateLEDs()
{
m_pController->SetLeds(leds, colors);
}
void RGBController_CMKeyboardController::UpdateSingleLED(int led, RGBColor color)
{
uint8_t key_value = m_pLayoutManager->GetKeyValueAt(led);
m_pController->SetSingleLED(key_value, color);
}
void RGBController_CMKeyboardController::UpdateSingleLED(int led)
{
m_pController->SetSingleLED(led, colors[led]);
}
void RGBController_CMKeyboardController::UpdateZoneLEDs(int /*zone_idx*/)
{
DeviceUpdateLEDs();
}
void RGBController_CMKeyboardController::DeviceUpdateMode()
{
m_pController->SetMode(modes[active_mode]);
}
void RGBController_CMKeyboardController::SetCustomMode()
{
}

41
Controllers/CoolerMasterController/CMKeyboardController/RGBController_CMKeyboardController.h Normal file
View file

@ -0,0 +1,41 @@
/*-------------------------------------------------------------------*\
| RGBController_CMKeyboardController.h |
| |
| Controller for Coolermaster keyboards |
| |
| Tam D (too.manyhobbies) 30th Nov 2023 |
| |
\*-------------------------------------------------------------------*/
#pragma once
#include "RGBController.h"
#include "CMKeyboardAbstractController.h"
#include "CMKeyboardV1Controller.h"
#include "CMKeyboardV2Controller.h"
#include "CMKeyboardDevices.h"
class RGBController_CMKeyboardController : public RGBController
{
public:
RGBController_CMKeyboardController(CMKeyboardAbstractController* pController);
~RGBController_CMKeyboardController();
void SetupZones();
void ResizeZone(int zone, int new_size);
void DeviceUpdateLEDs();
void UpdateSingleLED(int led, RGBColor color);
void UpdateSingleLED(int led);
void UpdateZoneLEDs(int zone_idx);
void SetCustomMode();
void DeviceUpdateMode();
private:
CMKeyboardAbstractController* m_pController;;
KeyboardLayoutManager* m_pLayoutManager;
KEYBOARD_LAYOUT m_keyboardLayout;
KEYBOARD_SIZE m_keyboardSize;
layout_values m_layoutValues;
std::vector<char *> m_pUnknownKeyNames;
};