mirror/OpenRGB
1
0
Fork 0
mirror of https://github.com/CalcProgrammer1/OpenRGB.git synced 2025-12-24 07:47:49 -05:00
Code Issues Packages Projects Releases Wiki Activity

Added Support for MM530

Browse Source
This commit is contained in:
Dracrius
2022-03-21 15:34:25 +00:00
committed by Adam Honse
parent 3c1b168676
commit f33fc26810
7 changed files with 837 additions and 9 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
60-openrgb.rules
View File

@@ -96,7 +96,8 @@ ACTION=="add", SUBSYSTEM=="platform", KERNEL=="faustus", RUN+="/bin/chmod a+w /s
#---------------------------------------------------------------#
# Cooler Master Peripheral Devices #
# #
# Mice: #
# Mice: #
# Cooler Master MM530 #
# Cooler Master MM711 #
# Cooler Master MM720 #
# Mousemats: #
@@ -114,6 +115,7 @@ ACTION=="add", SUBSYSTEM=="platform", KERNEL=="faustus", RUN+="/bin/chmod a+w /s
# Masterkeys SK630 #
# Masterkeys SK650 #
#---------------------------------------------------------------#
SUBSYSTEMS=="usb", ATTR{idVendor}=="2516", ATTR{idProduct}=="0065", TAG+="uaccess", TAG+="MM530"
SUBSYSTEMS=="usb", ATTR{idVendor}=="2516", ATTR{idProduct}=="0101", TAG+="uaccess", TAG+="MM711"
SUBSYSTEMS=="usb", ATTR{idVendor}=="2516", ATTR{idProduct}=="0141", TAG+="uaccess", TAG+="MM720"
SUBSYSTEMS=="usb", ATTR{idVendor}=="2516", ATTR{idProduct}=="0109", TAG+="uaccess", TAG+="MP750_XL"

331
Controllers/CoolerMasterController/CMMMController.cpp Normal file
View File

@@ -0,0 +1,331 @@
/*-------------------------------------------------------------------*\
| CMMMController.cpp |
| |
| Driver for Coolermaster MasterMouse |
| |
| Chris M (Dr_No) 14th Feb 2021 - MM711 Base |
| Dracrius 12th Mar 2022 |
| |
\*-------------------------------------------------------------------*/
#include "CMMMController.h"
#include <cstring>
CMMMController::CMMMController(hid_device* dev_handle, char *_path, uint16_t pid) : product_id(pid)
{
const int szTemp = HID_MAX_STR;
wchar_t tmpName[szTemp];
dev = dev_handle;
location = _path;
current_speed = CM_MM_SPEED_3;
hid_get_manufacturer_string(dev, tmpName, szTemp);
std::wstring wName = std::wstring(tmpName);
vendor = std::string(wName.begin(), wName.end());
hid_get_indexed_string(dev, 2, tmpName, szTemp);
wName = std::wstring(tmpName);
serial = std::string(wName.begin(), wName.end());
if(product_id == CM_MM530_PID || product_id == CM_MM531_PID)
{
command_code = CM_MM5XX_COMMAND;
if(pid == CM_MM530_PID)
{
buttons_bytes[0] = CM_MM_MODE_BYTE;
buttons_bytes[1] = CM_MM_SPEED_BYTE;
buttons_bytes[2] = CM_MM_NFI_1;
wheel_bytes[0] = CM_MM_RED_BYTE;
wheel_bytes[1] = CM_MM_GREEN_BYTE;
wheel_bytes[2] = CM_MM_BLUE_BYTE;
}
else if(product_id == CM_MM531_PID) //Still Need Captures for Proper Mapping From a MM531 User
{
buttons_bytes[0] = CM_MM_MODE_BYTE;
buttons_bytes[1] = CM_MM_SPEED_BYTE;
buttons_bytes[2] = CM_MM_NFI_1;
wheel_bytes[0] = CM_MM_RED_BYTE;
wheel_bytes[1] = CM_MM_GREEN_BYTE;
wheel_bytes[2] = CM_MM_BLUE_BYTE;
}
}
else
{
command_code = CM_MM7XX_COMMAND;
buttons_bytes[0] = CM_MM_RED_BYTE;
buttons_bytes[1] = CM_MM_GREEN_BYTE;
buttons_bytes[2] = CM_MM_BLUE_BYTE;
wheel_bytes[0] = CM_MM_MODE_BYTE;
wheel_bytes[1] = CM_MM_SPEED_BYTE;
wheel_bytes[2] = CM_MM_NFI_1;
}
logo_bytes[0] = CM_MM_NFI_2;
logo_bytes[1] = CM_MM_NFI_3;
logo_bytes[2] = CM_MM_BRIGHTNESS_BYTE;
SendInitPacket();
GetColourStatus();
GetCustomStatus();
GetModeStatus();
}
CMMMController::~CMMMController()
{
hid_close(dev);
}
void CMMMController::GetColourStatus()
{
uint8_t buffer[CM_MM_PACKET_SIZE] = { 0x00, 0x52, command_code };
hid_write(dev, buffer, CM_MM_PACKET_SIZE);
hid_read_timeout(dev, buffer, CM_MM_PACKET_SIZE, CM_MM_INTERRUPT_TIMEOUT);
current_brightness = buffer[CM_MM_BRIGHTNESS_BYTE - 1];
current_red = buffer[CM_MM_RED_BYTE - 1];
current_green = buffer[CM_MM_GREEN_BYTE - 1];
current_blue = buffer[CM_MM_BLUE_BYTE - 1];
}
void CMMMController::GetCustomStatus()
{
uint8_t buffer[CM_MM_PACKET_SIZE] = { 0x00, 0x52, 0xA8 };
int read_size = CM_MM_PACKET_SIZE - 1;
int result = 0;
hid_write(dev, buffer, CM_MM_PACKET_SIZE);
do
{
result = hid_read_timeout(dev, buffer, read_size, CM_MM_INTERRUPT_TIMEOUT);
}while(buffer[1] != 0xA8 && result == read_size);
if(result == read_size)
{
buttons_colour = ToRGBColor(buffer[4], buffer[5], buffer[6]);
logo_colour = ToRGBColor(buffer[7], buffer[8], buffer[9]);
wheel_colour = ToRGBColor(buffer[10], buffer[11], buffer[12]);
}
}
void CMMMController::GetModeStatus()
{
uint8_t buffer[CM_MM_PACKET_SIZE] = { 0x00, 0x52, 0x28 };
int buffer_size = (sizeof(buffer) / sizeof(buffer[0]));
hid_write(dev, buffer, buffer_size);
hid_read_timeout(dev, buffer, buffer_size, CM_MM_INTERRUPT_TIMEOUT);
current_mode = buffer[CM_MM_MODE_BYTE - 1];
}
std::string CMMMController::GetDeviceVendor()
{
return vendor;
}
std::string CMMMController::GetSerial()
{
return serial;
}
std::string CMMMController::GetLocation()
{
return("HID: " + location);
}
uint16_t CMMMController::GetProductID()
{
return product_id;
}
unsigned char CMMMController::GetMode()
{
return current_mode;
}
unsigned char CMMMController::GetLedRed()
{
return current_red;
}
unsigned char CMMMController::GetLedGreen()
{
return current_green;
}
unsigned char CMMMController::GetLedBlue()
{
return current_blue;
}
unsigned char CMMMController::GetLedSpeed()
{
return current_speed;
}
RGBColor CMMMController::GetWheelColour()
{
return wheel_colour;
}
RGBColor CMMMController::GetButtonsColour()
{
return buttons_colour;
}
RGBColor CMMMController::GetLogoColour()
{
return logo_colour;
}
void CMMMController::SetLedsDirect(RGBColor wheel_colour, RGBColor buttons_colour, RGBColor logo_colour)
{
unsigned char buffer[CM_MM_PACKET_SIZE] = { 0x00, 0x51, 0xA8, 0x00, 0x00 };
buffer[buttons_bytes[0]] = RGBGetRValue(buttons_colour);
buffer[buttons_bytes[1]] = RGBGetGValue(buttons_colour);
buffer[buttons_bytes[2]] = RGBGetBValue(buttons_colour);
buffer[logo_bytes[0]] = RGBGetRValue(logo_colour);
buffer[logo_bytes[1]] = RGBGetGValue(logo_colour);
buffer[logo_bytes[2]] = RGBGetBValue(logo_colour);
buffer[wheel_bytes[0]] = RGBGetRValue(wheel_colour);
buffer[wheel_bytes[1]] = RGBGetGValue(wheel_colour);
buffer[wheel_bytes[2]] = RGBGetBValue(wheel_colour);
hid_write(dev, buffer, CM_MM_PACKET_SIZE);
hid_read_timeout(dev, buffer, CM_MM_PACKET_SIZE, CM_MM_INTERRUPT_TIMEOUT);
}
void CMMMController::SendUpdate(uint8_t mode, uint8_t speed, RGBColor colour, uint8_t brightness)
{
if (mode == CM_MM_MODE_CUSTOM || mode == CM_MM_MODE_MULTILAYER)
{
SendUsingZonesPacket(mode);
}
else
{
SendInitPacket();
SendApplyPacket(mode);
}
uint8_t nfi_1 = 0x20;
if (mode == CM_MM_MODE_STATIC || mode == CM_MM_MODE_SPECTRUM_CYCLE)
{
nfi_1 = 0x00;
}
if (mode != CM_MM_MODE_OFF)
{
unsigned char buffer[CM_MM_PACKET_SIZE] = { 0x00, 0x51, command_code, 0x00, 0x00 };
buffer[CM_MM_MODE_BYTE] = mode;
buffer[CM_MM_SPEED_BYTE] = speed;
buffer[CM_MM_NFI_1] = nfi_1;
buffer[CM_MM_NFI_2] = 0xFF;
buffer[CM_MM_NFI_3] = 0xFF;
buffer[CM_MM_BRIGHTNESS_BYTE] = brightness;
buffer[CM_MM_RED_BYTE] = RGBGetRValue(colour);
buffer[CM_MM_GREEN_BYTE] = RGBGetGValue(colour);
buffer[CM_MM_BLUE_BYTE] = RGBGetBValue(colour);
buffer[CM_MM_SKY_RED_BYTE] = 0x00;
buffer[CM_MM_SKY_GREEN_BYTE] = 0x00;
buffer[CM_MM_SKY_BLUE_BYTE] = 0x00;
for (int i = 17; i < CM_MM_PACKET_SIZE; i++)
{
buffer[i] = 0xFF;
}
hid_write(dev, buffer, CM_MM_PACKET_SIZE);
hid_read_timeout(dev, buffer, CM_MM_PACKET_SIZE, CM_MM_INTERRUPT_TIMEOUT);
}
if (mode == CM_MM_MODE_CUSTOM || mode == CM_MM_MODE_MULTILAYER)
{
SendApplyPacket(mode); //Post Apply for Zoned Modes
}
}
void CMMMController::SendUpdate(uint8_t mode, uint8_t speed, RGBColor mode_one, RGBColor mode_two, uint8_t brightness)
{
SendApplyPacket(mode);
unsigned char buffer[CM_MM_PACKET_SIZE] = { 0x00, 0x51, command_code, 0x00, 0x00 };
buffer[CM_MM_MODE_BYTE] = mode;
buffer[CM_MM_SPEED_BYTE] = speed;
buffer[CM_MM_NFI_1] = 0x00;
buffer[CM_MM_NFI_2] = 0x21;
buffer[CM_MM_NFI_3] = 0xFF;
buffer[CM_MM_BRIGHTNESS_BYTE] = brightness;
buffer[CM_MM_RED_BYTE] = RGBGetRValue(mode_one);
buffer[CM_MM_GREEN_BYTE] = RGBGetGValue(mode_one);
buffer[CM_MM_BLUE_BYTE] = RGBGetBValue(mode_one);
buffer[CM_MM_SKY_RED_BYTE] = RGBGetRValue(mode_two);
buffer[CM_MM_SKY_GREEN_BYTE] = RGBGetGValue(mode_two);
buffer[CM_MM_SKY_BLUE_BYTE] = RGBGetBValue(mode_two);
for (int i = 17; i < CM_MM_PACKET_SIZE; i++)
{
buffer[i] = 0xFF;
}
hid_write(dev, buffer, CM_MM_PACKET_SIZE);
hid_read_timeout(dev, buffer, CM_MM_PACKET_SIZE, CM_MM_INTERRUPT_TIMEOUT);
}
void CMMMController::SendInitPacket()
{
unsigned char buffer[CM_MM_PACKET_SIZE] = { 0x00, 0x41, 0x80 };
hid_write(dev, buffer, CM_MM_PACKET_SIZE);
hid_read_timeout(dev, buffer, CM_MM_PACKET_SIZE, CM_MM_INTERRUPT_TIMEOUT);
}
void CMMMController::SendUsingZonesPacket(uint8_t mode)
{
unsigned char buffer[CM_MM_PACKET_SIZE] = { 0x00, 0x51, 0x30, 0x00, 0x00 };
if (mode == CM_MM_MODE_MULTILAYER)
{
buffer[CM_MM_MODE_BYTE] = 0x01;
}
hid_write(dev, buffer, CM_MM_PACKET_SIZE);
hid_read_timeout(dev, buffer, CM_MM_PACKET_SIZE, CM_MM_INTERRUPT_TIMEOUT);
}
void CMMMController::SendApplyPacket(uint8_t mode)
{
unsigned char buffer[CM_MM_PACKET_SIZE] = { 0x00, 0x51, 0x28, 0x00, 0x00 };
buffer[CM_MM_MODE_BYTE] = mode;
hid_write(dev, buffer, CM_MM_PACKET_SIZE);
hid_read_timeout(dev, buffer, CM_MM_PACKET_SIZE, CM_MM_INTERRUPT_TIMEOUT);
}
void CMMMController::SendMultilayerPacket(uint8_t zones[3])
{
unsigned char buffer[CM_MM_PACKET_SIZE] = { 0x00, 0x51, 0xA0, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00 };
buffer[CM_MM_NFI_3] = zones[0];
buffer[CM_MM_BRIGHTNESS_BYTE] = zones[1];
buffer[CM_MM_RED_BYTE] = zones[2];
hid_write(dev, buffer, CM_MM_PACKET_SIZE);
hid_read_timeout(dev, buffer, CM_MM_PACKET_SIZE, CM_MM_INTERRUPT_TIMEOUT);
}
void CMMMController::SendSavePacket()
{
unsigned char buffer[CM_MM_PACKET_SIZE] = { 0x00, 0x50, 0x55 };
hid_write(dev, buffer, CM_MM_PACKET_SIZE);
hid_read_timeout(dev, buffer, CM_MM_PACKET_SIZE, CM_MM_INTERRUPT_TIMEOUT);
}

147
Controllers/CoolerMasterController/CMMMController.h Normal file
View File

@@ -0,0 +1,147 @@
/*-------------------------------------------------------------------*\
| CMMMController.h |
| |
| Driver for Coolermaster MasterMouse |
| |
| Chris M (Dr_No) 14th Feb 2021 - MM711 Base |
| Dracrius 12th Mar 2022 |
| |
\*-------------------------------------------------------------------*/
#include <string>
#include <array>
#include <hidapi/hidapi.h>
#include "RGBController.h"
#pragma once
#define CM_MM_PACKET_SIZE 65
#define CM_MM_COLOUR_MODE_DATA_SIZE (sizeof(colour_mode_data[0]) / sizeof(colour_mode_data[0][0]))
#define CM_MM_HEADER_DATA_SIZE (sizeof(argb_header_data) / sizeof(argb_headers) )
#define CM_MM_INTERRUPT_TIMEOUT 250
#define CM_MM_DEVICE_NAME_SIZE (sizeof(device_name) / sizeof(device_name[ 0 ]))
#define HID_MAX_STR 255
enum
{
CM_MM530_PID = 0x0065,
CM_MM531_PID = 0x0097,
CM_MM711_PID = 0x0101,
CM_MM720_PID = 0x0141,
};
enum
{
CM_MM_REPORT_BYTE = 1,
CM_MM_COMMAND_BYTE = 2,
CM_MM_FUNCTION_BYTE = 3,
CM_MM_ZONE_BYTE = 4,
CM_MM_MODE_BYTE = 5,
CM_MM_SPEED_BYTE = 6,
CM_MM_NFI_1 = 7,
CM_MM_NFI_2 = 8,
CM_MM_NFI_3 = 9,
CM_MM_BRIGHTNESS_BYTE = 10,
CM_MM_RED_BYTE = 11,
CM_MM_GREEN_BYTE = 12,
CM_MM_BLUE_BYTE = 13,
CM_MM_SKY_RED_BYTE = 14,
CM_MM_SKY_GREEN_BYTE = 15,
CM_MM_SKY_BLUE_BYTE = 16
};
enum
{
CM_MM5XX_COMMAND = 0x2C,
CM_MM7XX_COMMAND = 0x2B
};
enum
{
CM_MM_CUSTOM_APPLY = 0x30, //Also Used for Multilayer Mode
CM_MM_APPLY = 0x28 //Sent Before Update, Unless using a Zoned Mode then UsingZones Before and Apply After
};
enum
{
CM_MM_MODE_STATIC = 0, //Static Mode
CM_MM_MODE_BREATHING = 1, //Breathing Mode
CM_MM_MODE_SPECTRUM_CYCLE = 2, //Spectrum Cycle Mode
CM_MM_MODE_STARS = 3, //Stars Mode
CM_MM_MODE_INDICATOR = 4, //Indicator Mode
CM_MM_MODE_CUSTOM = 176, //Custom LED Control
CM_MM_MODE_MULTILAYER = 224, //Multilayer Mode, i.e. Effect per Zone.
CM_MM_MODE_OFF = 254 //Turn Off
};
enum
{
CM_MM_SPEED_1 = 0x3C, // Slowest speed
CM_MM_SPEED_2 = 0x37,
CM_MM_SPEED_3 = 0x31, // Normal speed
CM_MM_SPEED_4 = 0x2C,
CM_MM_SPEED_5 = 0x26 // Fastest speed
};
class CMMMController
{
public:
CMMMController(hid_device* dev_handle, char *_path, uint16_t pid);
~CMMMController();
std::string GetDeviceVendor();
std::string GetSerial();
std::string GetLocation();
uint16_t GetProductID();
uint8_t GetZoneIndex();
uint8_t GetMode();
uint8_t GetLedRed();
uint8_t GetLedGreen();
uint8_t GetLedBlue();
uint8_t GetLedSpeed();
RGBColor GetWheelColour();
RGBColor GetButtonsColour();
RGBColor GetLogoColour();
void SendUpdate(uint8_t mode, uint8_t speed, RGBColor colour, uint8_t brightness);
void SendUpdate(uint8_t mode, uint8_t speed, RGBColor mode_one, RGBColor mode_two, uint8_t brightness);
void SetLedsDirect(RGBColor wheel_colour, RGBColor buttons_colour, RGBColor logo_colour);
void SendSavePacket();
private:
std::string name;
std::string vendor;
std::string serial;
std::string location;
hid_device* dev;
uint16_t product_id;
uint8_t command_code;
uint8_t current_mode;
uint8_t current_speed;
uint8_t current_brightness;
uint8_t current_red;
uint8_t current_green;
uint8_t current_blue;
uint8_t buttons_bytes[3];
uint8_t logo_bytes[3];
uint8_t wheel_bytes[3];
RGBColor buttons_colour;
RGBColor logo_colour;
RGBColor wheel_colour;
void GetColourStatus();
void GetCustomStatus();
void GetModeStatus();
void SendInitPacket();
void SendUsingZonesPacket(uint8_t mode);
void SendApplyPacket(uint8_t mode);
void SendMultilayerPacket(uint8_t zones[3]);
};

32
Controllers/CoolerMasterController/CoolerMasterControllerDetect.cpp
View File

@@ -7,6 +7,7 @@
#include "CMR6000Controller.h"
#include "CMMKController.h"
#include "RGBController.h"
#include "RGBController_CMMMController.h"
#include "RGBController_CMMM711Controller.h"
#include "RGBController_CMMP750Controller.h"
#include "RGBController_CMARGBController.h"
@@ -18,6 +19,8 @@
#define COOLERMASTER_VID 0x2516
#define COOLERMASTER_MM530_PID 0x0065
#define COOLERMASTER_MM531_PID 0x0097
#define COOLERMASTER_MM711_PID 0x0101
#define COOLERMASTER_MM720_PID 0x0141
#define COOLERMASTER_MP750_XL_PID 0x0109
@@ -90,16 +93,27 @@ void DetectCoolerMasterKeyboards(hid_device_info* info, const std::string&)
}
}
void DetectCoolerMasterMouse(hid_device_info* info, const std::string&)
void DetectCoolerMasterMouse(hid_device_info* info, const std::string& name)
{
hid_device* dev = hid_open_path(info->path);
if(dev)
{
CMMM711Controller* controller = new CMMM711Controller(dev, info->path);
RGBController_CMMM711Controller* rgb_controller = new RGBController_CMMM711Controller(controller);
// Constructor sets the name
ResourceManager::get()->RegisterRGBController(rgb_controller);
if(info->product_id == COOLERMASTER_MM530_PID || info->product_id == COOLERMASTER_MM531_PID)
{
CMMMController* controller = new CMMMController(dev, info->path, info->product_id);
RGBController_CMMMController* rgb_controller = new RGBController_CMMMController(controller);
rgb_controller->name = name;
ResourceManager::get()->RegisterRGBController(rgb_controller);
}
else if(info->product_id == COOLERMASTER_MM711_PID)
{
CMMM711Controller* controller = new CMMM711Controller(dev, info->path);
RGBController_CMMM711Controller* rgb_controller = new RGBController_CMMM711Controller(controller);
// Constructor sets the name
ResourceManager::get()->RegisterRGBController(rgb_controller);
}
}
}
@@ -142,6 +156,8 @@ void DetectCoolerMasterSmallARGB(hid_device_info* info, const std::string&)
}
}
REGISTER_HID_DETECTOR_IPU("Cooler Master MM530", DetectCoolerMasterMouse, COOLERMASTER_VID, COOLERMASTER_MM530_PID, 1, 0xFF00, 1);
//REGISTER_HID_DETECTOR_IPU("Cooler Master MM531", DetectCoolerMasterMouse, COOLERMASTER_VID, COOLERMASTER_MM531_PID, 1, 0xFF00, 1);
REGISTER_HID_DETECTOR_IPU("Cooler Master MM711", DetectCoolerMasterMouse, COOLERMASTER_VID, COOLERMASTER_MM711_PID, 1, 0xFF00, 1);
REGISTER_HID_DETECTOR_IPU("Cooler Master MM720", DetectCoolerMasterMouse, COOLERMASTER_VID, COOLERMASTER_MM720_PID, 1, 0xFF00, 1);
REGISTER_HID_DETECTOR_PU ("Cooler Master MP750 XL", DetectCoolerMasterMousemats, COOLERMASTER_VID, COOLERMASTER_MP750_XL_PID, 0xFF00, 1);
@@ -153,7 +169,7 @@ REGISTER_HID_DETECTOR_IPU("Cooler Master MasterKeys Pro S", DetectCooler
REGISTER_HID_DETECTOR_IPU("Cooler Master MK570", DetectCoolerMasterKeyboards, COOLERMASTER_VID, COOLERMASTER_MASTERKEYS_MK750_PID, 1, 0xFF00, 1);
REGISTER_HID_DETECTOR_IPU("Cooler Master SK630", DetectCoolerMasterKeyboards, COOLERMASTER_VID, COOLERMASTER_MASTERKEYS_SK630_PID, 1, 0xFF00, 1);
REGISTER_HID_DETECTOR_IPU("Cooler Master SK650", DetectCoolerMasterKeyboards, COOLERMASTER_VID, COOLERMASTER_MASTERKEYS_SK650_PID, 1, 0xFF00, 1);
REGISTER_HID_DETECTOR_IPU("Cooler Master ARGB", DetectCoolerMasterARGB, COOLERMASTER_VID, COOLERMASTER_ARGB_PID, 0, 0xFF00, 1);
REGISTER_HID_DETECTOR_IPU("Cooler Master Small ARGB", DetectCoolerMasterSmallARGB, COOLERMASTER_VID, COOLERMASTER_SMALL_ARGB_PID, 0, 0xFF00, 1);
REGISTER_HID_DETECTOR_IPU("Cooler Master RGB", DetectCoolerMasterRGB, COOLERMASTER_VID, COOLERMASTER_RGB_PID, 1, 0xFF00, 1);
REGISTER_HID_DETECTOR_IPU("Cooler Master ARGB", DetectCoolerMasterARGB, COOLERMASTER_VID, COOLERMASTER_ARGB_PID, 0, 0xFF00, 1);
REGISTER_HID_DETECTOR_IPU("Cooler Master Small ARGB", DetectCoolerMasterSmallARGB, COOLERMASTER_VID, COOLERMASTER_SMALL_ARGB_PID, 0, 0xFF00, 1);
REGISTER_HID_DETECTOR_IPU("Cooler Master RGB", DetectCoolerMasterRGB, COOLERMASTER_VID, COOLERMASTER_RGB_PID, 0, 0xFF00, 1);
REGISTER_HID_DETECTOR_I ("Cooler Master Radeon 6000 GPU", DetectCoolerMasterGPU, COOLERMASTER_VID, COOLERMASTER_RADEON_6000_PID, 1 );

285
Controllers/CoolerMasterController/RGBController_CMMMController.cpp Normal file
View File

@@ -0,0 +1,285 @@
/*-------------------------------------------------------------------*\
| RGBController_CMMMController.cpp |
| |
| Driver for Cooler Master MasterMouse Controller |
| |
| Chris M (Dr_No) 14th Feb 2021 - MM711 Base |
| Dracrius 12th Mar 2022 |
| |
\*-------------------------------------------------------------------*/
#define applyBrightness(c, bright) ((RGBColor) ((RGBGetBValue(c) * bright / CM_MM_ARGB_BRIGHTNESS_MAX_DEFAULT) << 16 | (RGBGetGValue(c) * bright / CM_MM_ARGB_BRIGHTNESS_MAX_DEFAULT) << 8 | (RGBGetRValue(c) * bright / CM_MM_ARGB_BRIGHTNESS_MAX_DEFAULT)))
#include "RGBController_CMMMController.h"
RGBController_CMMMController::RGBController_CMMMController(CMMMController* controller_ptr)
{
controller = controller_ptr;
uint8_t speed = controller->GetLedSpeed();
name = "Cooler Master MasterMouse";
vendor = controller->GetDeviceVendor();
type = DEVICE_TYPE_MOUSE;
description = "Cooler Master MasterMouse";
serial = controller->GetSerial();
location = controller->GetLocation();
mode Custom;
Custom.name = "Direct";
Custom.value = CM_MM_MODE_CUSTOM;
Custom.flags = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
Custom.brightness_min = CM_MM_ARGB_BRIGHTNESS_MIN;
Custom.brightness_max = CM_MM_ARGB_BRIGHTNESS_MAX_DEFAULT;
Custom.brightness = CM_MM_ARGB_BRIGHTNESS_MAX_DEFAULT;
Custom.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Custom);
mode Static;
Static.name = "Static";
Static.value = CM_MM_MODE_STATIC;
Static.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
Static.brightness_min = CM_MM_ARGB_BRIGHTNESS_MIN;
Static.brightness_max = CM_MM_ARGB_BRIGHTNESS_MAX_DEFAULT;
Static.brightness = CM_MM_ARGB_BRIGHTNESS_MAX_DEFAULT;
Static.colors_min = 1;
Static.colors_max = 1;
Static.colors.resize(Static.colors_max);
Static.speed_min = CM_MM_SPEED_1;
Static.speed_max = CM_MM_SPEED_5;
Static.color_mode = MODE_COLORS_MODE_SPECIFIC;
Static.speed = CM_MM_SPEED_3;
modes.push_back(Static);
mode Breathing;
Breathing.name = "Breathing";
Breathing.value = CM_MM_MODE_BREATHING;
Breathing.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
Breathing.brightness_min = CM_MM_ARGB_BRIGHTNESS_MIN;
Breathing.brightness_max = CM_MM_ARGB_BRIGHTNESS_MAX_DEFAULT;
Breathing.brightness = CM_MM_ARGB_BRIGHTNESS_MAX_DEFAULT;
Breathing.colors_min = 1;
Breathing.colors_max = 1;
Breathing.colors.resize(Breathing.colors_max);
Breathing.speed_min = CM_MM_SPEED_1;
Breathing.speed_max = CM_MM_SPEED_5;
Breathing.color_mode = MODE_COLORS_MODE_SPECIFIC;
Breathing.speed = CM_MM_SPEED_3;
modes.push_back(Breathing);
mode Spectrum_Cycle;
Spectrum_Cycle.name = "Spectrum Cycle";
Spectrum_Cycle.value = CM_MM_MODE_SPECTRUM_CYCLE;
Spectrum_Cycle.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
Spectrum_Cycle.brightness_min = CM_MM_ARGB_BRIGHTNESS_MIN;
Spectrum_Cycle.brightness_max = CM_MM_ARGB_BRIGHTNESS_MAX_SPECTRUM;
Spectrum_Cycle.brightness = CM_MM_ARGB_BRIGHTNESS_MAX_SPECTRUM;
Spectrum_Cycle.speed_min = CM_MM_SPEED_1;
Spectrum_Cycle.speed_max = CM_MM_SPEED_5;
Spectrum_Cycle.color_mode = MODE_COLORS_NONE;
Spectrum_Cycle.speed = CM_MM_SPEED_3;
modes.push_back(Spectrum_Cycle);
mode Stars;
Stars.name = "Stars";
Stars.value = CM_MM_MODE_STARS;
Stars.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
Stars.brightness_min = CM_MM_ARGB_BRIGHTNESS_MIN;
Stars.brightness_max = CM_MM_ARGB_BRIGHTNESS_MAX_DEFAULT;
Stars.brightness = CM_MM_ARGB_BRIGHTNESS_MAX_DEFAULT;
Stars.colors_min = 2;
Stars.colors_max = 2;
Stars.colors.resize(Stars.colors_max);
Stars.speed_min = CM_MM_SPEED_1;
Stars.speed_max = CM_MM_SPEED_5;
Stars.color_mode = MODE_COLORS_MODE_SPECIFIC;
Stars.speed = CM_MM_SPEED_3;
modes.push_back(Stars);
mode Indicator;
Indicator.name = "Indicator";
Indicator.value = CM_MM_MODE_INDICATOR;
Indicator.flags = MODE_FLAG_MANUAL_SAVE;
Indicator.color_mode = MODE_COLORS_NONE;
modes.push_back(Indicator);
mode Off;
Off.name = "Turn Off";
Off.value = CM_MM_MODE_OFF;
Off.flags = MODE_FLAG_MANUAL_SAVE;
Off.color_mode = MODE_COLORS_NONE;
modes.push_back(Off);
uint16_t pid = controller->GetProductID();
if(pid == 0x0065 || pid == 0x0097)
{
leds_count = 3;
}
else
{
leds_count = 2;
}
Init_Controller(); //Only processed on first run
SetupZones();
uint8_t temp_mode = controller->GetMode();
for(std::size_t mode_index = 0; mode_index < modes.size(); mode_index++)
{
if(modes[mode_index].value == temp_mode)
{
active_mode = mode_index;
break;
}
}
if(modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC)
{
modes[active_mode].colors[0] = ToRGBColor(controller->GetLedRed(),controller->GetLedGreen(),controller->GetLedBlue());
}
if(pid == 0x0065 || pid == 0x0097)
{
colors[0] = controller->GetWheelColour();
colors[1] = controller->GetButtonsColour();
colors[2] = controller->GetLogoColour();
}
else
{
colors[0] = controller->GetWheelColour();
colors[1] = controller->GetLogoColour();
}
}
RGBController_CMMMController::~RGBController_CMMMController()
{
delete controller;
}
void RGBController_CMMMController::Init_Controller()
{
zone mouse_zone;
mouse_zone.name = name;
mouse_zone.type = ZONE_TYPE_LINEAR;
mouse_zone.leds_min = leds_count;
mouse_zone.leds_max = leds_count;
mouse_zone.leds_count = leds_count;
mouse_zone.matrix_map = NULL;
zones.push_back(mouse_zone);
int value = 0;
uint16_t pid = controller->GetProductID();
led wheel_led;
wheel_led.name = "Scroll Wheel";
wheel_led.value = value;
leds.push_back(wheel_led);
value++;
if(pid == 0x0065 || pid == 0x0097)
{
led buttons_led;
buttons_led.name = "Buttons";
buttons_led.value = value;
leds.push_back(buttons_led);
value++;
}
led logo_led;
logo_led.name = "Logo";
logo_led.value = value;
leds.push_back(logo_led);
}
void RGBController_CMMMController::SetupZones()
{
SetupColors();
}
void RGBController_CMMMController::ResizeZone(int /*zone*/, int /*new_size*/)
{
/*---------------------------------------------------------*\
| This device does not support resizing zones |
\*---------------------------------------------------------*/
}
void RGBController_CMMMController::DeviceUpdateLEDs()
{
int value = 0;
uint16_t pid = controller->GetProductID();
RGBColor wheel = applyBrightness(colors[value], modes[active_mode].brightness);
RGBColor buttons = ToRGBColor(0, 0, 0);
value++;
if(pid == 0x0065 || pid == 0x0097)
{
buttons = applyBrightness(colors[value], modes[active_mode].brightness);
value++;
}
RGBColor logo = applyBrightness(colors[value], modes[active_mode].brightness);
controller->SetLedsDirect(wheel, buttons, logo);
}
void RGBController_CMMMController::UpdateZoneLEDs(int /*zone*/)
{
DeviceUpdateLEDs();
}
void RGBController_CMMMController::UpdateSingleLED(int /*led*/)
{
DeviceUpdateLEDs();
}
void RGBController_CMMMController::SetCustomMode()
{
for(std::size_t mode_index = 0; mode_index < modes.size(); mode_index++)
{
if(modes[mode_index].value == CM_MM_MODE_CUSTOM)
{
active_mode = mode_index;
break;
}
}
}
void RGBController_CMMMController::DeviceUpdateMode()
{
RGBColor mode_one = 0;
RGBColor mode_two = 0;
if(modes[active_mode].value != CM_MM_MODE_CUSTOM)
{
if(modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC )
{
mode_one = modes[active_mode].colors[0];
if(modes[active_mode].colors.size() > 1)
{
mode_two = modes[active_mode].colors[1];
}
}
}
if(modes[active_mode].value == CM_MM_MODE_STARS)
{
controller->SendUpdate(modes[active_mode].value, modes[active_mode].speed, mode_one, mode_two, modes[active_mode].brightness);
}
else
{
controller->SendUpdate(modes[active_mode].value, modes[active_mode].speed, mode_one, modes[active_mode].brightness);
}
}
void RGBController_CMMMController::DeviceSaveMode()
{
DeviceUpdateMode();
controller->SendSavePacket();
}

43
Controllers/CoolerMasterController/RGBController_CMMMController.h Normal file
View File

@@ -0,0 +1,43 @@
/*-------------------------------------------------------------------*\
| RGBController_CMMMController.h |
| |
| Driver for Coolermaster MaterMouse Controller |
| |
| Chris M (Dr_No) 14th Feb 2021 - MM711 Base |
| Dracrius 12th Mar 2022 |
| |
\*-------------------------------------------------------------------*/
#pragma once
#include "RGBController.h"
#include "CMMMController.h"
#include <vector>
#define CM_MM_ARGB_BRIGHTNESS_MIN 0x00
#define CM_MM_ARGB_BRIGHTNESS_MAX_DEFAULT 0xFF
#define CM_MM_ARGB_BRIGHTNESS_MAX_SPECTRUM 0x7F
class RGBController_CMMMController : public RGBController
{
public:
RGBController_CMMMController(CMMMController* controller_ptr);
~RGBController_CMMMController();
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:
void Init_Controller();
int GetDeviceMode();
int leds_count;
CMMMController* controller;
};

4
OpenRGB.pro
View File

@@ -255,6 +255,7 @@ HEADERS +=
Controllers/BlinkyTapeController/RGBController_BlinkyTape.h \
Controllers/CoolerMasterController/CMARGBcontroller.h \
Controllers/CoolerMasterController/CMMKController.h \
Controllers/CoolerMasterController/CMMMController.h \
Controllers/CoolerMasterController/CMMM711Controller.h \
Controllers/CoolerMasterController/CMMP750Controller.h \
Controllers/CoolerMasterController/CMR6000Controller.h \
@@ -262,6 +263,7 @@ HEADERS +=
Controllers/CoolerMasterController/CMSmallARGBController.h \
Controllers/CoolerMasterController/RGBController_CMARGBController.h \
Controllers/CoolerMasterController/RGBController_CMMKController.h \
Controllers/CoolerMasterController/RGBController_CMMMController.h \
Controllers/CoolerMasterController/RGBController_CMMM711Controller.h \
Controllers/CoolerMasterController/RGBController_CMMP750Controller.h \
Controllers/CoolerMasterController/RGBController_CMR6000Controller.h \
@@ -660,6 +662,7 @@ SOURCES +=
Controllers/BlinkyTapeController/RGBController_BlinkyTape.cpp \
Controllers/CoolerMasterController/CMARGBcontroller.cpp \
Controllers/CoolerMasterController/CMMKController.cpp \
Controllers/CoolerMasterController/CMMMController.cpp \
Controllers/CoolerMasterController/CMMM711Controller.cpp \
Controllers/CoolerMasterController/CMMP750Controller.cpp \
Controllers/CoolerMasterController/CMR6000Controller.cpp \
@@ -668,6 +671,7 @@ SOURCES +=
Controllers/CoolerMasterController/CoolerMasterControllerDetect.cpp \
Controllers/CoolerMasterController/RGBController_CMARGBController.cpp \
Controllers/CoolerMasterController/RGBController_CMMKController.cpp \
Controllers/CoolerMasterController/RGBController_CMMMController.cpp \
Controllers/CoolerMasterController/RGBController_CMMM711Controller.cpp \
Controllers/CoolerMasterController/RGBController_CMMP750Controller.cpp \
Controllers/CoolerMasterController/RGBController_CMR6000Controller.cpp \