diff --git a/60-openrgb.rules b/60-openrgb.rules index d9a5af58..600faa25 100644 --- a/60-openrgb.rules +++ b/60-openrgb.rules @@ -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" diff --git a/Controllers/CoolerMasterController/CMMMController.cpp b/Controllers/CoolerMasterController/CMMMController.cpp new file mode 100644 index 00000000..1cb1e27a --- /dev/null +++ b/Controllers/CoolerMasterController/CMMMController.cpp @@ -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 + +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); +} diff --git a/Controllers/CoolerMasterController/CMMMController.h b/Controllers/CoolerMasterController/CMMMController.h new file mode 100644 index 00000000..a0dc907f --- /dev/null +++ b/Controllers/CoolerMasterController/CMMMController.h @@ -0,0 +1,147 @@ +/*-------------------------------------------------------------------*\ +| CMMMController.h | +| | +| Driver for Coolermaster MasterMouse | +| | +| Chris M (Dr_No) 14th Feb 2021 - MM711 Base | +| Dracrius 12th Mar 2022 | +| | +\*-------------------------------------------------------------------*/ + +#include +#include +#include +#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]); +}; diff --git a/Controllers/CoolerMasterController/CoolerMasterControllerDetect.cpp b/Controllers/CoolerMasterController/CoolerMasterControllerDetect.cpp index 6c205041..c0c63ba7 100644 --- a/Controllers/CoolerMasterController/CoolerMasterControllerDetect.cpp +++ b/Controllers/CoolerMasterController/CoolerMasterControllerDetect.cpp @@ -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 ); diff --git a/Controllers/CoolerMasterController/RGBController_CMMMController.cpp b/Controllers/CoolerMasterController/RGBController_CMMMController.cpp new file mode 100644 index 00000000..86a16dc0 --- /dev/null +++ b/Controllers/CoolerMasterController/RGBController_CMMMController.cpp @@ -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(); +} diff --git a/Controllers/CoolerMasterController/RGBController_CMMMController.h b/Controllers/CoolerMasterController/RGBController_CMMMController.h new file mode 100644 index 00000000..79d23691 --- /dev/null +++ b/Controllers/CoolerMasterController/RGBController_CMMMController.h @@ -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 + +#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; +}; diff --git a/OpenRGB.pro b/OpenRGB.pro index e3bd8237..ce2090c7 100644 --- a/OpenRGB.pro +++ b/OpenRGB.pro @@ -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 \