mirror/OpenRGB
1
0
Fork 0
mirror of https://github.com/CalcProgrammer1/OpenRGB.git synced 2026-04-03 22:01:20 -04:00
Code Issues Packages Projects Releases Wiki Activity
Files
ba1b68ee8a1e95ec5d200069bf3f1302b6f5c290
OpenRGB/Controllers/CoolerMasterController/CMARGBController/RGBController_CMARGBController.cpp

610 lines
24 KiB
C++
Raw Blame History

/*---------------------------------------------------------*\
| RGBController_CMARGBController.cpp |
| |
| RGBController for Cooler Master ARGB controller |
| |
| Chris M (Dr_No) 14 Oct 2020 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include "RGBController_CMARGBController.h"
/**------------------------------------------------------------------*\
@name Coolermaster ARGB
@category LEDStrip
@type USB
@save :robot:
@direct :white_check_mark:
@effects :white_check_mark:
@detectors DetectCoolerMasterARGB
@comment The Coolermaster ARGB device supports `Direct` mode from
firmware 0028 onwards. Check the serial number for the date
"A202105291658" or newer.
\*-------------------------------------------------------------------*/
RGBController_CMARGBController::RGBController_CMARGBController(CMARGBController* controller_ptr)
{
controller = controller_ptr;
name = controller->GetDeviceName();
vendor = "Cooler Master";
type = DEVICE_TYPE_LEDSTRIP;
description = "Cooler Master ARGB Controller Device";
version = controller->GetVersion();
serial = controller->GetSerial();
location = controller->GetLocation();
SetupZones();
SetupModes();
/*-----------------------------------------------------*\
| Initialize the active mode to port 0 |
\*-----------------------------------------------------*/
unsigned char port_mode;
unsigned char port_speed;
unsigned char port_brightness;
bool port_random;
unsigned char port_red;
unsigned char port_green;
unsigned char port_blue;
controller->GetPortStatus(0, &port_mode, &port_speed, &port_brightness, &port_random, &port_red, &port_green, &port_blue);
for(std::size_t mode_idx = 0; mode_idx < modes.size(); mode_idx++)
{
if(modes[mode_idx].value == port_mode)
{
active_mode = (int)mode_idx;
if((modes[mode_idx].flags & MODE_FLAG_HAS_MODE_SPECIFIC_COLOR) && (modes[mode_idx].colors.size() > 0))
{
modes[mode_idx].colors[0] = ToRGBColor(port_red, port_green, port_blue);
}
if(modes[mode_idx].flags & MODE_FLAG_HAS_SPEED)
{
modes[mode_idx].speed = port_speed;
}
if(modes[mode_idx].flags & MODE_FLAG_HAS_BRIGHTNESS)
{
modes[mode_idx].brightness = port_brightness;
}
if(modes[mode_idx].flags & MODE_FLAG_HAS_RANDOM_COLOR)
{
if(port_random)
{
modes[mode_idx].color_mode = MODE_COLORS_RANDOM;
}
}
break;
}
}
}
RGBController_CMARGBController::~RGBController_CMARGBController()
{
Shutdown();
delete controller;
}
void RGBController_CMARGBController::SetupModes()
{
/*-----------------------------------------------------*\
| Define Direct and Passthrough modes as require entire |
| device, these are not available as per-zone modes |
\*-----------------------------------------------------*/
mode Direct;
Direct.name = (serial >= CM_ARGB_FW0028) ? "Direct" : "Custom";
Direct.value = CM_ARGB_MODE_DIRECT;
Direct.flags = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_REQUIRES_ENTIRE_DEVICE;
Direct.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Direct);
mode PassThru;
PassThru.name = "Passthrough";
PassThru.value = CM_ARGB_MODE_PASSTHRU | MODE_FLAG_REQUIRES_ENTIRE_DEVICE;
PassThru.flags = 0;
PassThru.color_mode = MODE_COLORS_NONE;
modes.push_back(PassThru);
/*-----------------------------------------------------*\
| The ARGB ports support more modes than the RGB port. |
| Define all of the modes the ARGB ports support and |
| map RGB modes to them as best as we can. |
\*-----------------------------------------------------*/
mode Off;
Off.name = "Off";
Off.value = CM_ARGB_MODE_OFF;
Off.color_mode = MODE_COLORS_NONE;
modes.push_back(Off);
for(std::size_t zone_idx = 0; zone_idx < 4; zone_idx++)
{
zones[zone_idx].modes.push_back(Off);
}
mode Reload;
Reload.name = "Reload";
Reload.value = CM_ARGB_MODE_RELOAD;
Reload.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
Reload.speed_min = CM_ARGB_SPEED_SLOWEST;
Reload.speed_max = CM_ARGB_SPEED_FASTEST;
Reload.speed = CM_ARGB_SPEED_NORMAL;
Reload.brightness_min = 0;
Reload.brightness_max = CM_ARGB_BRIGHTNESS_MAX;
Reload.brightness = CM_ARGB_BRIGHTNESS_MAX;
Reload.color_mode = MODE_COLORS_MODE_SPECIFIC;
Reload.colors_min = 1;
Reload.colors_max = 1;
Reload.colors.resize(Reload.colors_max);
modes.push_back(Reload);
for(std::size_t zone_idx = 0; zone_idx < 4; zone_idx++)
{
zones[zone_idx].modes.push_back(Reload);
}
mode Recoil;
Recoil.name = "Recoil";
Recoil.value = CM_ARGB_MODE_RECOIL;
Recoil.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
Recoil.color_mode = MODE_COLORS_MODE_SPECIFIC;
Recoil.speed_min = CM_ARGB_SPEED_SLOWEST;
Recoil.speed_max = CM_ARGB_SPEED_FASTEST;
Recoil.speed = CM_ARGB_SPEED_NORMAL;
Recoil.brightness_min = 0;
Recoil.brightness_max = CM_ARGB_BRIGHTNESS_MAX;
Recoil.brightness = CM_ARGB_BRIGHTNESS_MAX;
Recoil.colors_min = 1;
Recoil.colors_max = 1;
Recoil.colors.resize(Recoil.colors_max);
modes.push_back(Recoil);
for(std::size_t zone_idx = 0; zone_idx < 4; zone_idx++)
{
zones[zone_idx].modes.push_back(Recoil);
}
mode Breathing;
Breathing.name = "Breathing";
Breathing.value = CM_ARGB_MODE_BREATHING;
Breathing.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
Breathing.color_mode = MODE_COLORS_MODE_SPECIFIC;
Breathing.speed_min = CM_ARGB_SPEED_SLOWEST;
Breathing.speed_max = CM_ARGB_SPEED_FASTEST;
Breathing.speed = CM_ARGB_SPEED_NORMAL;
Breathing.brightness_min = 0;
Breathing.brightness_max = CM_ARGB_BRIGHTNESS_MAX;
Breathing.brightness = CM_ARGB_BRIGHTNESS_MAX;
Breathing.colors_min = 1;
Breathing.colors_max = 1;
Breathing.colors.resize(Breathing.colors_max);
modes.push_back(Breathing);
for(std::size_t zone_idx = 0; zone_idx < 4; zone_idx++)
{
zones[zone_idx].modes.push_back(Breathing);
}
mode Refill;
Refill.name = "Refill";
Refill.value = CM_ARGB_MODE_REFILL;
Refill.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
Refill.color_mode = MODE_COLORS_MODE_SPECIFIC;
Refill.speed_min = CM_ARGB_SPEED_SLOWEST;
Refill.speed_max = CM_ARGB_SPEED_FASTEST;
Refill.speed = CM_ARGB_SPEED_NORMAL;
Refill.brightness_min = 0;
Refill.brightness_max = CM_ARGB_BRIGHTNESS_MAX;
Refill.brightness = CM_ARGB_BRIGHTNESS_MAX;
Refill.colors_min = 1;
Refill.colors_max = 1;
Refill.colors.resize(Refill.colors_max);
modes.push_back(Refill);
for(std::size_t zone_idx = 0; zone_idx < 4; zone_idx++)
{
zones[zone_idx].modes.push_back(Refill);
}
mode Demo;
Demo.name = "Demo";
Demo.value = CM_ARGB_MODE_DEMO;
Demo.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
Demo.color_mode = MODE_COLORS_NONE;
Demo.speed_min = CM_ARGB_SPEED_SLOWEST;
Demo.speed_max = CM_ARGB_SPEED_FASTEST;
Demo.speed = CM_ARGB_SPEED_NORMAL;
Demo.brightness_min = 0;
Demo.brightness_max = CM_ARGB_BRIGHTNESS_MAX;
Demo.brightness = CM_ARGB_BRIGHTNESS_MAX;
modes.push_back(Demo);
for(std::size_t zone_idx = 0; zone_idx < 4; zone_idx++)
{
zones[zone_idx].modes.push_back(Demo);
}
mode Spectrum;
Spectrum.name = "Rainbow Wave";
Spectrum.value = CM_ARGB_MODE_SPECTRUM;
Spectrum.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
Spectrum.color_mode = MODE_COLORS_NONE;
Spectrum.speed_min = CM_ARGB_SPEED_SLOWEST;
Spectrum.speed_max = CM_ARGB_SPEED_FASTEST;
Spectrum.speed = CM_ARGB_SPEED_NORMAL;
Spectrum.brightness_min = 0;
Spectrum.brightness_max = CM_ARGB_BRIGHTNESS_MAX;
Spectrum.brightness = CM_ARGB_BRIGHTNESS_MAX;
modes.push_back(Spectrum);
for(std::size_t zone_idx = 0; zone_idx < 4; zone_idx++)
{
zones[zone_idx].modes.push_back(Spectrum);
}
mode FillFlow;
FillFlow.name = "Fill Flow";
FillFlow.value = CM_ARGB_MODE_FILLFLOW;
FillFlow.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
FillFlow.color_mode = MODE_COLORS_NONE;
FillFlow.speed_min = CM_ARGB_SPEED_SLOWEST;
FillFlow.speed_max = CM_ARGB_SPEED_FASTEST;
FillFlow.speed = CM_ARGB_SPEED_NORMAL;
FillFlow.brightness_min = 0;
FillFlow.brightness_max = CM_ARGB_BRIGHTNESS_MAX;
FillFlow.brightness = CM_ARGB_BRIGHTNESS_MAX;
modes.push_back(FillFlow);
for(std::size_t zone_idx = 0; zone_idx < 4; zone_idx++)
{
zones[zone_idx].modes.push_back(FillFlow);
}
mode Rainbow;
Rainbow.name = "Rainbow";
Rainbow.value = CM_ARGB_MODE_RAINBOW;
Rainbow.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
Rainbow.color_mode = MODE_COLORS_NONE;
Rainbow.speed_min = CM_ARGB_SPEED_SLOWEST;
Rainbow.speed_max = CM_ARGB_SPEED_FASTEST;
Rainbow.speed = CM_ARGB_SPEED_NORMAL;
Rainbow.brightness_min = 0;
Rainbow.brightness_max = CM_ARGB_BRIGHTNESS_MAX;
Rainbow.brightness = CM_ARGB_BRIGHTNESS_MAX;
modes.push_back(Rainbow);
for(std::size_t zone_idx = 0; zone_idx < 4; zone_idx++)
{
zones[zone_idx].modes.push_back(Rainbow);
}
mode Static;
Static.name = "Static";
Static.value = CM_ARGB_MODE_STATIC;
Static.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
Static.color_mode = MODE_COLORS_MODE_SPECIFIC;
Static.brightness_min = 0;
Static.brightness_max = CM_ARGB_BRIGHTNESS_MAX;
Static.brightness = CM_ARGB_BRIGHTNESS_MAX;
Static.colors_min = 1;
Static.colors_max = 1;
Static.colors.resize(Static.colors_max);
modes.push_back(Static);
for(std::size_t zone_idx = 0; zone_idx < 4; zone_idx++)
{
zones[zone_idx].modes.push_back(Static);
}
/*-----------------------------------------------------*\
| Define zone-specific modes for the RGB port |
\*-----------------------------------------------------*/
mode RGBOff;
RGBOff.name = "Off";
RGBOff.value = CM_RGB_MODE_OFF;
RGBOff.color_mode = MODE_COLORS_NONE;
zones[4].modes.push_back(RGBOff);
mode RGBMirage;
RGBMirage.name = "Mirage";
RGBMirage.value = CM_RGB_MODE_MIRAGE;
RGBMirage.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
RGBMirage.color_mode = MODE_COLORS_MODE_SPECIFIC;
RGBMirage.speed_min = CM_ARGB_SPEED_SLOWEST;
RGBMirage.speed_max = CM_ARGB_SPEED_FASTEST;
RGBMirage.speed = CM_ARGB_SPEED_NORMAL;
RGBMirage.brightness_min = 0;
RGBMirage.brightness_max = CM_ARGB_BRIGHTNESS_MAX;
RGBMirage.brightness = CM_ARGB_BRIGHTNESS_MAX;
RGBMirage.colors_min = 1;
RGBMirage.colors_max = 1;
RGBMirage.colors.resize(RGBMirage.colors_max);
zones[4].modes.push_back(RGBMirage);
mode RGBFlash;
RGBFlash.name = "Flash";
RGBFlash.value = CM_RGB_MODE_FLASH;
RGBFlash.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
RGBFlash.color_mode = MODE_COLORS_MODE_SPECIFIC;
RGBFlash.speed_min = CM_ARGB_SPEED_SLOWEST;
RGBFlash.speed_max = CM_ARGB_SPEED_FASTEST;
RGBFlash.speed = CM_ARGB_SPEED_NORMAL;
RGBFlash.brightness_min = 0;
RGBFlash.brightness_max = CM_ARGB_BRIGHTNESS_MAX;
RGBFlash.brightness = CM_ARGB_BRIGHTNESS_MAX;
RGBFlash.colors_min = 1;
RGBFlash.colors_max = 1;
RGBFlash.colors.resize(RGBFlash.colors_max);
zones[4].modes.push_back(RGBFlash);
mode RGBBreathing;
RGBBreathing.name = "Breathing";
RGBBreathing.value = CM_RGB_MODE_BREATHING;
RGBBreathing.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
RGBBreathing.color_mode = MODE_COLORS_MODE_SPECIFIC;
RGBBreathing.speed_min = CM_ARGB_SPEED_SLOWEST;
RGBBreathing.speed_max = CM_ARGB_SPEED_FASTEST;
RGBBreathing.speed = CM_ARGB_SPEED_NORMAL;
RGBBreathing.brightness_min = 0;
RGBBreathing.brightness_max = CM_ARGB_BRIGHTNESS_MAX;
RGBBreathing.brightness = CM_ARGB_BRIGHTNESS_MAX;
RGBBreathing.colors_min = 1;
RGBBreathing.colors_max = 1;
RGBBreathing.colors.resize(RGBBreathing.colors_max);
zones[4].modes.push_back(RGBBreathing);
mode RGBStatic;
RGBStatic.name = "Static";
RGBStatic.value = CM_RGB_MODE_STATIC;
RGBStatic.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
RGBStatic.color_mode = MODE_COLORS_MODE_SPECIFIC;
RGBStatic.brightness_min = 0;
RGBStatic.brightness_max = CM_ARGB_BRIGHTNESS_MAX;
RGBStatic.brightness = CM_ARGB_BRIGHTNESS_MAX;
RGBStatic.colors_min = 1;
RGBStatic.colors_max = 1;
RGBStatic.colors.resize(RGBStatic.colors_max);
zones[4].modes.push_back(RGBStatic);
}
void RGBController_CMARGBController::SetupZones()
{
/*-----------------------------------------------------*\
| Only set LED count on the first run |
\*-----------------------------------------------------*/
bool first_run = false;
if(zones.size() == 0)
{
first_run = true;
}
/*-----------------------------------------------------*\
| Clear any existing color/LED configuration |
\*-----------------------------------------------------*/
leds.clear();
colors.clear();
zones.resize(5);
/*-----------------------------------------------------*\
| Set up addressable zones |
\*-----------------------------------------------------*/
for(unsigned int channel_idx = 0; channel_idx < 4; channel_idx++)
{
char ch_idx_string[2];
snprintf(ch_idx_string, 2, "%d", channel_idx + 1);
zones[channel_idx].name = "Addressable RGB Header ";
zones[channel_idx].name.append(ch_idx_string);
zones[channel_idx].type = ZONE_TYPE_LINEAR;
zones[channel_idx].leds_min = 0;
zones[channel_idx].leds_max = 48;
if(first_run)
{
zones[channel_idx].leds_count = 0;
}
for(unsigned int led_ch_idx = 0; led_ch_idx < zones[channel_idx].leds_count; led_ch_idx++)
{
char led_idx_string[4];
snprintf(led_idx_string, 4, "%d", led_ch_idx + 1);
led new_led;
new_led.name = zones[channel_idx].name;
new_led.name.append(", LED ");
new_led.name.append(led_idx_string);
new_led.value = channel_idx;
leds.push_back(new_led);
}
}
/*-----------------------------------------------------*\
| Set up RGB zone |
\*-----------------------------------------------------*/
zones[4].name = "RGB Header";
zones[4].type = ZONE_TYPE_SINGLE;
zones[4].leds_min = 1;
zones[4].leds_max = 1;
zones[4].leds_count = 1;
led new_led;
new_led.name = "RGB Header";
new_led.value = 4;
leds.push_back(new_led);
SetupColors();
}
void RGBController_CMARGBController::DeviceResizeZone(int zone, int new_size)
{
if((size_t) zone >= zones.size())
{
return;
}
if(((unsigned int)new_size >= zones[zone].leds_min) && ((unsigned int)new_size <= zones[zone].leds_max))
{
zones[zone].leds_count = new_size;
controller->SetPortLEDCount(zone, zones[zone].leds_count);
SetupZones();
}
}
void RGBController_CMARGBController::DeviceUpdateLEDs()
{
for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
{
DeviceUpdateZoneLEDs((int)zone_idx);
}
}
void RGBController_CMARGBController::DeviceUpdateZoneLEDs(int zone)
{
if(modes[active_mode].value != CM_ARGB_MODE_DIRECT)
{
return;
}
/*-----------------------------------------------------*\
| The RGB zone doesn't have a separate Direct mode, so |
| use static mode with the per-LED color for it |
\*-----------------------------------------------------*/
if(zone < 4)
{
controller->SetPortLEDsDirect(zone, zones[zone].colors, zones[zone].leds_count);
}
else
{
controller->SetPortMode(zone, CM_RGB_MODE_STATIC, 0, 255, false, RGBGetRValue(zones[zone].colors[0]), RGBGetGValue(zones[zone].colors[0]), RGBGetBValue(zones[zone].colors[0]));
}
}
void RGBController_CMARGBController::DeviceUpdateSingleLED(int led)
{
unsigned int zone_idx = leds[led].value;
UpdateZoneLEDs(zone_idx);
}
void RGBController_CMARGBController::DeviceUpdateMode()
{
/*-----------------------------------------------------*\
| Apply mode to all zones |
\*-----------------------------------------------------*/
for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
{
DeviceUpdateZoneMode((int)zone_idx);
}
}
void RGBController_CMARGBController::DeviceUpdateZoneMode(int zone)
{
/*-----------------------------------------------------*\
| Determine the active mode for this zone |
\*-----------------------------------------------------*/
bool use_zone_mode = false;
int zone_active_mode = active_mode;
int zone_mode_value = modes[active_mode].value;
/*-----------------------------------------------------*\
| Set up mode parameters |
\*-----------------------------------------------------*/
bool random = (modes[active_mode].color_mode == MODE_COLORS_RANDOM);
RGBColor color = 0;
unsigned int brightness = modes[active_mode].brightness;
unsigned int speed = modes[active_mode].speed;
if(modes[active_mode].colors.size() > 0)
{
color = modes[active_mode].colors[0];
}
if(!(modes[active_mode].flags & MODE_FLAG_REQUIRES_ENTIRE_DEVICE))
{
if(zones[zone].active_mode >= 0)
{
use_zone_mode = true;
zone_active_mode = zones[zone].active_mode;
zone_mode_value = zones[zone].modes[zone_active_mode].value;
random = (zones[zone].modes[zone_active_mode].color_mode == MODE_COLORS_RANDOM);
if(zones[zone].modes[zone_active_mode].colors.size() > 0)
{
color = zones[zone].modes[zone_active_mode].colors[0];
}
brightness = zones[zone].modes[zone_active_mode].brightness;
speed = zones[zone].modes[zone_active_mode].speed;
}
}
if((zone == 4) && !use_zone_mode)
{
/*-------------------------------------------------*\
| Map entire-device ARGB modes with the equivalent |
| RGB modes for the RGB zone |
\*-------------------------------------------------*/
switch(modes[active_mode].value)
{
case CM_ARGB_MODE_SPECTRUM:
case CM_ARGB_MODE_FILLFLOW:
case CM_ARGB_MODE_RAINBOW:
zone_mode_value = CM_RGB_MODE_MIRAGE;
random = true;
break;
case CM_ARGB_MODE_RELOAD:
case CM_ARGB_MODE_RECOIL:
zone_mode_value = CM_RGB_MODE_FLASH;
break;
case CM_ARGB_MODE_BREATHING:
zone_mode_value = CM_RGB_MODE_BREATHING;
break;
case CM_ARGB_MODE_REFILL:
case CM_ARGB_MODE_STATIC:
zone_mode_value = CM_RGB_MODE_STATIC;
break;
case CM_ARGB_MODE_DEMO:
zone_mode_value = CM_RGB_MODE_FLASH;
random = true;
break;
case CM_ARGB_MODE_OFF:
default:
zone_mode_value = CM_RGB_MODE_OFF;
break;
case CM_ARGB_MODE_PASSTHRU:
zone_mode_value = CM_RGB_MODE_PASSTHRU;
break;
}
}
controller->SetPortMode
(
zone,
zone_mode_value,
speed,
brightness,
random,
RGBGetRValue(color),
RGBGetGValue(color),
RGBGetBValue(color)
);
}
Reference in New Issue View Git Blame Copy Permalink