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

Extended support Gigabyte AORUS ATC800

Browse source
This commit is contained in:
Денис Назаров 2024-02-07 14:29:07 +00:00 • committed by Adam Honse
parent 350863e3b8
commit cc376b71c8
4 changed files with 405 additions and 186 deletions
Download patch file Download diff file Expand all files Collapse all files

326
Controllers/GigabyteAorusCPUCoolerController/ATC800Controller.cpp
View file

@ -43,96 +43,240 @@ std::string ATC800Controller::GetSerialString()
return(return_string);
}
void ATC800Controller::SendCoolerMode
(
unsigned char mode,
unsigned short /*speed*/,
unsigned char channel,
unsigned char red,
unsigned char green,
unsigned char blue
)
void ATC800Controller::DisableTempRPMIndicator()
{
unsigned char usb_buf[9];
/*-----------------------------------------------------*\
| Zero out buffer |
\*-----------------------------------------------------*/
memset(usb_buf, 0x00, sizeof(usb_buf));
/*-----------------------------------------------------*\
| Set up Lighting Control packet |
\*-----------------------------------------------------*/
if (channel == AORUS_ATC800_TOP_ZONE)
{
usb_buf[0x00] = 0x00;
usb_buf[0x01] = 0xbe;
usb_buf[0x08] = 0xcc;
hid_send_feature_report(dev, usb_buf, 9);
memset(usb_buf, 0x00, sizeof(usb_buf));
usb_buf[0x00] = 0x00;
usb_buf[0x01] = 0xc9;
usb_buf[0x02] = mode;
usb_buf[0x03] = 0x3c;
usb_buf[0x04] = 0x02;
usb_buf[0x05] = 0x00;
usb_buf[0x06] = 0x00;
hid_send_feature_report(dev, usb_buf, 9);
memset(usb_buf, 0x00, sizeof(usb_buf));
usb_buf[0x00] = 0x00;
usb_buf[0x01] = 0xbc;
usb_buf[0x02] = red;
usb_buf[0x03] = green;
usb_buf[0x04] = blue;
hid_send_feature_report(dev, usb_buf, 9);
memset(usb_buf, 0x00, sizeof(usb_buf));
usb_buf[0x00] = 0x00;
usb_buf[0x01] = 0xb6;
}
else if (channel == AORUS_ATC800_FANS_ZONE)
{
hid_send_feature_report(dev, usb_buf, 9);
memset(usb_buf, 0x00, sizeof(usb_buf));
usb_buf[0x00] = 0x00;
usb_buf[0x01] = 0xc9;
usb_buf[0x02] = mode;
usb_buf[0x03] = 0x3c;
usb_buf[0x04] = 0x02;
usb_buf[0x05] = 0x00;
usb_buf[0x06] = 0x01;
hid_send_feature_report(dev, usb_buf, 9);
memset(usb_buf, 0x00, sizeof(usb_buf));
usb_buf[0x00] = 0x00;
usb_buf[0x01] = 0xb0;
usb_buf[0x02] = mode;
usb_buf[0x03] = red;
usb_buf[0x04] = green;
usb_buf[0x05] = blue;
usb_buf[0x06] = red;
usb_buf[0x07] = green;
usb_buf[0x08] = blue;
for(int i = 0xb0; i <= 0xb3; i++)
{
usb_buf[0x01] = i; //zone b0->b3
hid_send_feature_report(dev, usb_buf, 9);
}
}
memset(usb_buf, 0x00, sizeof(usb_buf));
usb_buf[0x00] = 0x00;
usb_buf[0x01] = 0xb6;
hid_send_feature_report(dev, usb_buf, 9);
uint8_t usb_buf[9] = { 0x00, 0xbe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xcc };
hid_send_feature_report(dev, usb_buf, sizeof(usb_buf));
}
void ATC800Controller::SendMode(uint8_t mode, uint8_t brightness, uint8_t speed, uint8_t mystery_flag, uint8_t zone)
{
uint8_t usb_buf[9] = { 0x00, 0xc9, mode, brightness, speed, mystery_flag, zone, 0x00, 0x00 };
hid_send_feature_report(dev, usb_buf, sizeof(usb_buf));
}
void ATC800Controller::SendOneColor(uint8_t color_flag, uint8_t red, uint8_t green, uint8_t blue)
{
uint8_t usb_buf[9] = { 0x00, color_flag, red, green, blue, 0x00, 0x00, 0x00, 0x00 };
hid_send_feature_report(dev, usb_buf, sizeof(usb_buf));
}
void ATC800Controller::SendMultiColor(uint8_t flag, uint8_t mode, uint8_t red1, uint8_t green1, uint8_t blue1, uint8_t red2, uint8_t green2, uint8_t blue2)
{
uint8_t usb_buf[9] = { 0x00, flag, mode, red1, green1, blue1, red2, green2, blue2 };
hid_send_feature_report(dev, usb_buf, sizeof(usb_buf));
}
void ATC800Controller::SendOk()
{
uint8_t usb_buf[9] = { 0x00, 0xb6, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
hid_send_feature_report(dev, usb_buf, sizeof(usb_buf));
}
void ATC800Controller::SendCoolerMode(uint8_t zone, uint8_t mode, mode_config zone_config)
{
switch (mode)
{
case AORUS_ATC800_MODE_OFF:
{
if (zone == AORUS_ATC800_TOP_ZONE)
{
DisableTempRPMIndicator();
SendMode(0x01, 0x3c, 0x02, 0x02, 0x00);
SendOneColor(0xbc, 0x00, 0x00, 0x00);
SendOk();
}
else if (zone == AORUS_ATC800_FANS_ZONE)
{
SendMode(0x01, 0x3c, 0x02, 0x02, 0x01);
for(int i = 0xb0; i <= 0xb3; i++)
{
SendMultiColor(i, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00);
}
SendOk();
}
}
break;
case AORUS_ATC800_MODE_CUSTOM:
{
if (zone == AORUS_ATC800_TOP_ZONE)
{
DisableTempRPMIndicator();
SendMode(mode, (zone_config.brightness + 1) * 0x0a, 0x02, 0x00, 0x00);
SendOneColor(0xbc, RGBGetRValue(zone_config.colors[0]), RGBGetGValue(zone_config.colors[0]), RGBGetBValue(zone_config.colors[0]));
SendOk();
}
else if (zone == AORUS_ATC800_FANS_ZONE)
{
SendMode(mode, (zone_config.brightness + 1) * 0x0a, 0x02, 0x00, 0x01);
for(int i = 0xb0; i <= 0xb3; i++)
{
SendMultiColor(i, mode, RGBGetRValue(zone_config.colors[0]), RGBGetGValue(zone_config.colors[0]), RGBGetBValue(zone_config.colors[0]), RGBGetRValue(zone_config.colors[0]), RGBGetGValue(zone_config.colors[0]), RGBGetBValue(zone_config.colors[0]));
}
SendOk();
}
}
break;
case AORUS_ATC800_MODE_BREATHING:
{
if (zone == AORUS_ATC800_TOP_ZONE)
{
DisableTempRPMIndicator();
SendMode(mode, 0x3c, zone_config.speed, 0x00, 0x00);
SendOneColor(0xbc, RGBGetRValue(zone_config.colors[0]), RGBGetGValue(zone_config.colors[0]), RGBGetBValue(zone_config.colors[0]));
SendOk();
}
else if (zone == AORUS_ATC800_FANS_ZONE)
{
SendMode(mode, 0x3c, zone_config.speed, 0x00, 0x01);
for(int i = 0xb0; i <= 0xb3; i++)
{
SendMultiColor(i, mode, RGBGetRValue(zone_config.colors[0]), RGBGetGValue(zone_config.colors[0]), RGBGetBValue(zone_config.colors[0]), RGBGetRValue(zone_config.colors[0]), RGBGetGValue(zone_config.colors[0]), RGBGetBValue(zone_config.colors[0]));
}
SendOk();
}
}
break;
case AORUS_ATC800_MODE_SPECTRUM_CYCLE:
{
if (zone == AORUS_ATC800_TOP_ZONE)
{
DisableTempRPMIndicator();
SendMode(mode, (zone_config.brightness + 1) * 0x0a, zone_config.speed, 0x00, 0x00);
SendOk();
}
else if (zone == AORUS_ATC800_FANS_ZONE)
{
SendMode(mode, (zone_config.brightness + 1) * 0x0a, zone_config.speed, 0x00, 0x01);
SendOk();
}
}
break;
case AORUS_ATC800_MODE_FLASHING:
case AORUS_ATC800_MODE_DOUBLE_FLASHING:
{
if (zone == AORUS_ATC800_TOP_ZONE)
{
DisableTempRPMIndicator();
SendMode(mode, (zone_config.brightness + 1) * 0x0a, zone_config.speed, 0x00, 0x00);
SendOneColor(0xbc, RGBGetRValue(zone_config.colors[0]), RGBGetGValue(zone_config.colors[0]), RGBGetBValue(zone_config.colors[0]));
SendOk();
}
else if (zone == AORUS_ATC800_FANS_ZONE)
{
SendMode(mode, (zone_config.brightness + 1) * 0x0a, zone_config.speed, 0x00, 0x01);
for(int i = 0xb0; i <= 0xb3; i++)
{
SendMultiColor(i, mode, RGBGetRValue(zone_config.colors[0]), RGBGetGValue(zone_config.colors[0]), RGBGetBValue(zone_config.colors[0]), RGBGetRValue(zone_config.colors[0]), RGBGetGValue(zone_config.colors[0]), RGBGetBValue(zone_config.colors[0]));
}
SendOk();
}
}
break;
case AORUS_ATC800_MODE_GRADIENT:
{
if (zone == AORUS_ATC800_TOP_ZONE)
{
DisableTempRPMIndicator();
SendMode(mode, (zone_config.brightness + 1) * 0x0a, zone_config.speed, 0x00, 0x00);
SendOneColor(0xcd, RGBGetRValue(zone_config.colors[0]), RGBGetGValue(zone_config.colors[0]), RGBGetBValue(zone_config.colors[0]));
SendMode(mode, (zone_config.brightness + 1) * 0x0a, zone_config.speed, 0x0a, 0x00);
SendOk();
}
else if (zone == AORUS_ATC800_FANS_ZONE)
{
SendMode(mode, (zone_config.brightness + 1) * 0x0a, zone_config.speed, 0x08, 0x01);
SendOneColor(0xcd, RGBGetRValue(zone_config.colors[0]), RGBGetGValue(zone_config.colors[0]), RGBGetBValue(zone_config.colors[0]));
SendMode(mode, (zone_config.brightness + 1) * 0x0a, zone_config.speed, 0x0a, 0x01);
SendOk();
}
}
break;
case AORUS_ATC800_MODE_COLOR_SHIFT:
{
DisableTempRPMIndicator();
SendMode(mode, (zone_config.brightness + 1) * 0x0a, zone_config.speed, zone_config.numberOfColors, 0x02);
SendMultiColor(0xb0, mode, RGBGetRValue(zone_config.colors[0]), RGBGetGValue(zone_config.colors[0]), RGBGetBValue(zone_config.colors[0]), RGBGetRValue(zone_config.colors[1]), RGBGetGValue(zone_config.colors[1]), RGBGetBValue(zone_config.colors[1]));
SendMultiColor(0xb1, mode, RGBGetRValue(zone_config.colors[2]), RGBGetGValue(zone_config.colors[2]), RGBGetBValue(zone_config.colors[2]), RGBGetRValue(zone_config.colors[3]), RGBGetGValue(zone_config.colors[3]), RGBGetBValue(zone_config.colors[3]));
SendMultiColor(0xb2, mode, RGBGetRValue(zone_config.colors[4]), RGBGetGValue(zone_config.colors[4]), RGBGetBValue(zone_config.colors[4]), RGBGetRValue(zone_config.colors[5]), RGBGetGValue(zone_config.colors[5]), RGBGetBValue(zone_config.colors[5]));
SendMultiColor(0xb3, mode, RGBGetRValue(zone_config.colors[6]), RGBGetGValue(zone_config.colors[6]), RGBGetBValue(zone_config.colors[6]), RGBGetRValue(zone_config.colors[7]), RGBGetGValue(zone_config.colors[7]), RGBGetBValue(zone_config.colors[7]));
SendOk();
}
break;
case AORUS_ATC800_MODE_RAINBOW_WAVE:
{
if (zone == AORUS_ATC800_TOP_ZONE)
{
DisableTempRPMIndicator();
SendMode(mode, (zone_config.brightness + 1) * 0x0a, zone_config.speed, 0x02, 0x00);
SendOk();
}
else if (zone == AORUS_ATC800_FANS_ZONE)
{
SendMode(mode, (zone_config.brightness + 1) * 0x0a, zone_config.speed, 0x02, 0x01);
SendOk();
}
}
break;
case AORUS_ATC800_MODE_RADIATE:
{
DisableTempRPMIndicator();
SendMode(mode, (zone_config.brightness + 1) * 0x0a, zone_config.speed, 0x02, 0x02);
SendMultiColor(0xb0, mode, RGBGetRValue(zone_config.colors[0]), RGBGetGValue(zone_config.colors[0]), RGBGetBValue(zone_config.colors[0]), RGBGetRValue(zone_config.colors[1]), RGBGetGValue(zone_config.colors[1]), RGBGetBValue(zone_config.colors[1]));
SendMultiColor(0xb1, mode, RGBGetRValue(zone_config.colors[2]), RGBGetGValue(zone_config.colors[2]), RGBGetBValue(zone_config.colors[2]), RGBGetRValue(zone_config.colors[3]), RGBGetGValue(zone_config.colors[3]), RGBGetBValue(zone_config.colors[3]));
SendMultiColor(0xb2, mode, RGBGetRValue(zone_config.colors[4]), RGBGetGValue(zone_config.colors[4]), RGBGetBValue(zone_config.colors[4]), RGBGetRValue(zone_config.colors[5]), RGBGetGValue(zone_config.colors[5]), RGBGetBValue(zone_config.colors[5]));
SendMultiColor(0xb3, mode, RGBGetRValue(zone_config.colors[6]), RGBGetGValue(zone_config.colors[6]), RGBGetBValue(zone_config.colors[6]), RGBGetRValue(zone_config.colors[7]), RGBGetGValue(zone_config.colors[7]), RGBGetBValue(zone_config.colors[7]));
SendOk();
}
break;
case AORUS_ATC800_MODE_RAINBOW_LOOP:
{
if (zone == AORUS_ATC800_TOP_ZONE)
{
DisableTempRPMIndicator();
SendMode(mode, (zone_config.brightness + 1) * 0x0a, zone_config.speed, 0x00, zone);
SendOk();
}
else if (zone == AORUS_ATC800_FANS_ZONE)
{
SendMode(mode, (zone_config.brightness + 1) * 0x0a, zone_config.speed, 0x08, zone);
SendOk();
}
}
break;
case AORUS_ATC800_MODE_TRICOLOR:
{
if (zone == AORUS_ATC800_TOP_ZONE)
{
DisableTempRPMIndicator();
SendMode(mode, (zone_config.brightness + 1) * 0x0a, zone_config.speed, 0x02, 0x00);
SendMultiColor(0xb0, mode, RGBGetRValue(zone_config.colors[0]), RGBGetGValue(zone_config.colors[0]), RGBGetBValue(zone_config.colors[0]), RGBGetRValue(zone_config.colors[1]), RGBGetGValue(zone_config.colors[1]), RGBGetBValue(zone_config.colors[1]));
SendMultiColor(0xb1, mode, RGBGetRValue(zone_config.colors[2]), RGBGetGValue(zone_config.colors[2]), RGBGetBValue(zone_config.colors[2]), 0x00, 0x00, 0x00);
SendMultiColor(0xb2, mode, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00);
SendMultiColor(0xb3, mode, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00);
SendOk();
}
else if (zone == AORUS_ATC800_FANS_ZONE)
{
SendMode(mode, (zone_config.brightness + 1) * 0x0a, zone_config.speed, 0x02, 0x01);
SendMultiColor(0xb0, mode, RGBGetRValue(zone_config.colors[0]), RGBGetGValue(zone_config.colors[0]), RGBGetBValue(zone_config.colors[0]), RGBGetRValue(zone_config.colors[1]), RGBGetGValue(zone_config.colors[1]), RGBGetBValue(zone_config.colors[1]));
SendMultiColor(0xb1, mode, RGBGetRValue(zone_config.colors[2]), RGBGetGValue(zone_config.colors[2]), RGBGetBValue(zone_config.colors[2]), 0x00, 0x00, 0x00);
SendMultiColor(0xb2, mode, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00);
SendMultiColor(0xb3, mode, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00);
SendOk();
}
}
break;
}
}

43
Controllers/GigabyteAorusCPUCoolerController/ATC800Controller.h
View file

@ -14,27 +14,41 @@
#pragma once
struct mode_config
{
RGBColor colors[8];
uint8_t numberOfColors;
uint8_t speed;
uint8_t brightness;
};
enum
{
AORUS_ATC800_MODE_OFF = 0x00,
AORUS_ATC800_MODE_STATIC = 0x01,
AORUS_ATC800_MODE_PULSE = 0x02,
AORUS_ATC800_MODE_CUSTOM = 0x01,
AORUS_ATC800_MODE_BREATHING = 0x02,
AORUS_ATC800_MODE_SPECTRUM_CYCLE = 0x03,
AORUS_ATC800_MODE_FLASHING = 0x04,
AORUS_ATC800_MODE_DOUBLE_FLASH = 0x05,
AORUS_ATC800_MODE_DOUBLE_FLASHING = 0x05,
AORUS_ATC800_MODE_GRADIENT = 0x06,
AORUS_ATC800_MODE_COLOR_SHIFT = 0x07,
AORUS_ATC800_MODE_RAINBOW_WAVE = 0x08,
AORUS_ATC800_MODE_RADIATE = 0x09,
AORUS_ATC800_MODE_RAINBOW_LOOP = 0x0A,
AORUS_ATC800_MODE_TRICOLOR = 0x0B,
AORUS_ATC800_MODE_SPECTRUM_CYCLE = 0x13,
};
enum
{
AORUS_ATC800_SPEED_SLOWEST = 0x00, /* Slowest speed */
AORUS_ATC800_SPEED_SLOW = 0x01, /* Slow speed */
AORUS_ATC800_SPEED_NORMAL = 0x02, /* Normal speed */
AORUS_ATC800_SPEED_FAST = 0x03, /* Fast speed */
AORUS_ATC800_SPEED_FASTEST = 0x04, /* Fastest speed */
AORUS_ATC800_SPEED_FASTEST = 0x05, /* Fastest speed */
};
enum
{
AORUS_ATC800_BRIGHTNESS_MIN = 0x00,
AORUS_ATC800_BRIGHTNESS_MAX = 0x05
};
enum
@ -52,15 +66,12 @@ public:
std::string GetDeviceLocation();
std::string GetSerialString();
void SendCoolerMode
(
unsigned char mode,
unsigned short speed,
unsigned char channel,
unsigned char red,
unsigned char green,
unsigned char blue
);
void DisableTempRPMIndicator();
void SendMode(uint8_t mode, uint8_t brightness, uint8_t speed, uint8_t mystery_flag, uint8_t zone);
void SendOneColor(uint8_t color_flag, uint8_t red, uint8_t green, uint8_t blue);
void SendMultiColor(uint8_t flag, uint8_t mode, uint8_t red1, uint8_t green1, uint8_t blue1, uint8_t red2, uint8_t green2, uint8_t blue2);
void SendOk();
void SendCoolerMode(uint8_t zone, uint8_t mode, mode_config zone_config);
private:
hid_device* dev;

2
Controllers/GigabyteAorusCPUCoolerController/GigabyteAorusCPUCoolerControllerDetect.cpp
View file

@ -36,4 +36,4 @@ void DetectGigabyteAorusCPUCoolerControllers(hid_device_info* info, const std::s
}
}
REGISTER_HID_DETECTOR_IPU("Aorus CPU Coolers", DetectGigabyteAorusCPUCoolerControllers, HOLTEK_VID, ATC_800_CONTROLLER_PID, 0, 0xFF01, 1);
REGISTER_HID_DETECTOR_IPU("Gigabyte AORUS ATC800", DetectGigabyteAorusCPUCoolerControllers, HOLTEK_VID, ATC_800_CONTROLLER_PID, 0, 0xFF01, 1);

220
Controllers/GigabyteAorusCPUCoolerController/RGBController_AorusATC800.cpp
View file

@ -31,98 +31,160 @@ RGBController_AorusATC800::RGBController_AorusATC800(ATC800Controller* controlle
location = controller->GetDeviceLocation();
serial = controller->GetSerialString();
mode Static;
Static.name = "Static";
Static.value = AORUS_ATC800_MODE_STATIC;
Static.flags = MODE_FLAG_HAS_PER_LED_COLOR;
Static.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Static);
mode Custom;
Custom.name = "Custom";
Custom.value = AORUS_ATC800_MODE_CUSTOM;
Custom.flags = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
Custom.color_mode = MODE_COLORS_PER_LED;
Custom.brightness_min = AORUS_ATC800_BRIGHTNESS_MIN;
Custom.brightness_max = AORUS_ATC800_BRIGHTNESS_MAX;
Custom.brightness = AORUS_ATC800_BRIGHTNESS_MAX;
modes.push_back(Custom);
mode Off;
Off.name = "Off";
Off.value = AORUS_ATC800_MODE_OFF;
Off.flags = 0;
Off.color_mode = MODE_COLORS_NONE;
Off.name = "Off";
Off.value = AORUS_ATC800_MODE_OFF;
Off.flags = MODE_FLAG_AUTOMATIC_SAVE;
Off.color_mode = MODE_COLORS_NONE;
modes.push_back(Off);
mode Flashing;
Flashing.name = "Flashing";
Flashing.value = AORUS_ATC800_MODE_FLASHING;
Flashing.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
Flashing.color_mode = MODE_COLORS_PER_LED;
Flashing.speed_min = AORUS_ATC800_SPEED_SLOWEST;
Flashing.speed_max = AORUS_ATC800_SPEED_FASTEST;
Flashing.speed = AORUS_ATC800_SPEED_NORMAL;
Flashing.name = "Flashing";
Flashing.value = AORUS_ATC800_MODE_FLASHING;
Flashing.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
Flashing.color_mode = MODE_COLORS_PER_LED;
Flashing.speed_min = AORUS_ATC800_SPEED_SLOWEST;
Flashing.speed_max = AORUS_ATC800_SPEED_FASTEST;
Flashing.speed = AORUS_ATC800_SPEED_NORMAL;
Flashing.brightness_min = AORUS_ATC800_BRIGHTNESS_MIN;
Flashing.brightness_max = AORUS_ATC800_BRIGHTNESS_MAX;
Flashing.brightness = AORUS_ATC800_BRIGHTNESS_MAX;
modes.push_back(Flashing);
mode DoubleFlashing;
DoubleFlashing.name = "Double Flashing";
DoubleFlashing.value = AORUS_ATC800_MODE_DOUBLE_FLASH;
DoubleFlashing.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
DoubleFlashing.color_mode = MODE_COLORS_PER_LED;
DoubleFlashing.speed_min = AORUS_ATC800_SPEED_SLOWEST;
DoubleFlashing.speed_max = AORUS_ATC800_SPEED_FASTEST;
DoubleFlashing.speed = AORUS_ATC800_SPEED_NORMAL;
DoubleFlashing.name = "Double Flashing";
DoubleFlashing.value = AORUS_ATC800_MODE_DOUBLE_FLASHING;
DoubleFlashing.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
DoubleFlashing.color_mode = MODE_COLORS_PER_LED;
DoubleFlashing.speed_min = AORUS_ATC800_SPEED_SLOWEST;
DoubleFlashing.speed_max = AORUS_ATC800_SPEED_FASTEST;
DoubleFlashing.speed = AORUS_ATC800_SPEED_NORMAL;
DoubleFlashing.brightness_min = AORUS_ATC800_BRIGHTNESS_MIN;
DoubleFlashing.brightness_max = AORUS_ATC800_BRIGHTNESS_MAX;
DoubleFlashing.brightness = AORUS_ATC800_BRIGHTNESS_MAX;
modes.push_back(DoubleFlashing);
mode Pulsing;
Pulsing.name = "Pulsing";
Pulsing.value = AORUS_ATC800_MODE_PULSE;
Pulsing.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
Pulsing.color_mode = MODE_COLORS_PER_LED;
Pulsing.speed_min = AORUS_ATC800_SPEED_SLOWEST;
Pulsing.speed_max = AORUS_ATC800_SPEED_FASTEST;
Pulsing.speed = AORUS_ATC800_SPEED_NORMAL;
modes.push_back(Pulsing);
mode Breathing;
Breathing.name = "Breathing";
Breathing.value = AORUS_ATC800_MODE_BREATHING;
Breathing.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
Breathing.color_mode = MODE_COLORS_PER_LED;
Breathing.speed_min = AORUS_ATC800_SPEED_SLOWEST;
Breathing.speed_max = AORUS_ATC800_SPEED_FASTEST;
Breathing.speed = AORUS_ATC800_SPEED_NORMAL;
modes.push_back(Breathing);
mode Gradient;
Gradient.name = "Gradient";
Gradient.value = AORUS_ATC800_MODE_GRADIENT;
Gradient.flags = MODE_FLAG_HAS_SPEED;
Gradient.color_mode = MODE_COLORS_NONE;
Gradient.speed_min = AORUS_ATC800_SPEED_SLOWEST;
Gradient.speed_max = AORUS_ATC800_SPEED_FASTEST;
Gradient.speed = AORUS_ATC800_SPEED_NORMAL;
Gradient.name = "Gradient";
Gradient.value = AORUS_ATC800_MODE_GRADIENT;
Gradient.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
Gradient.color_mode = MODE_COLORS_MODE_SPECIFIC;
Gradient.colors_min = 1;
Gradient.colors_max = 1;
Gradient.colors = { 0x0000FF };
Gradient.speed_min = AORUS_ATC800_SPEED_SLOWEST;
Gradient.speed_max = AORUS_ATC800_SPEED_FASTEST;
Gradient.speed = AORUS_ATC800_SPEED_NORMAL;
Gradient.brightness_min = AORUS_ATC800_BRIGHTNESS_MIN;
Gradient.brightness_max = AORUS_ATC800_BRIGHTNESS_MAX;
Gradient.brightness = AORUS_ATC800_BRIGHTNESS_MAX;
modes.push_back(Gradient);
mode ColorShift;
ColorShift.name = "Color Shift";
ColorShift.value = AORUS_ATC800_MODE_COLOR_SHIFT;
ColorShift.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
ColorShift.color_mode = MODE_COLORS_MODE_SPECIFIC;
ColorShift.colors_min = 2;
ColorShift.colors_max = 8;
ColorShift.colors = { 0x0000FF, 0x0072FF, 0x00FFFF, 0x00FF00, 0xFFFF00, 0xFF0000, 0xFF00FF, 0x8080FF };
ColorShift.speed_min = AORUS_ATC800_SPEED_SLOWEST;
ColorShift.speed_max = AORUS_ATC800_SPEED_FASTEST;
ColorShift.speed = AORUS_ATC800_SPEED_NORMAL;
ColorShift.brightness_min = AORUS_ATC800_BRIGHTNESS_MIN;
ColorShift.brightness_max = AORUS_ATC800_BRIGHTNESS_MAX;
ColorShift.brightness = AORUS_ATC800_BRIGHTNESS_MAX;
modes.push_back(ColorShift);
mode RainbowWave;
RainbowWave.name = "Rainbow Wave";
RainbowWave.value = AORUS_ATC800_MODE_RAINBOW_WAVE;
RainbowWave.flags = MODE_FLAG_HAS_SPEED;
RainbowWave.color_mode = MODE_COLORS_NONE;
RainbowWave.speed_min = AORUS_ATC800_SPEED_SLOWEST;
RainbowWave.speed_max = AORUS_ATC800_SPEED_FASTEST;
RainbowWave.speed = AORUS_ATC800_SPEED_NORMAL;
RainbowWave.name = "Rainbow Wave";
RainbowWave.value = AORUS_ATC800_MODE_RAINBOW_WAVE;
RainbowWave.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
RainbowWave.color_mode = MODE_COLORS_NONE;
RainbowWave.speed_min = AORUS_ATC800_SPEED_SLOWEST;
RainbowWave.speed_max = AORUS_ATC800_SPEED_FASTEST;
RainbowWave.speed = AORUS_ATC800_SPEED_NORMAL;
RainbowWave.brightness_min = AORUS_ATC800_BRIGHTNESS_MIN;
RainbowWave.brightness_max = AORUS_ATC800_BRIGHTNESS_MAX;
RainbowWave.brightness = AORUS_ATC800_BRIGHTNESS_MAX;
modes.push_back(RainbowWave);
mode Radiate;
Radiate.name = "Radiate";
Radiate.value = AORUS_ATC800_MODE_RADIATE;
Radiate.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
Radiate.color_mode = MODE_COLORS_MODE_SPECIFIC;
Radiate.colors_min = 8;
Radiate.colors_max = 8;
Radiate.colors = { 0x0000FF, 0x0072FF, 0x00FFFF, 0x00FF00, 0xFFFF00, 0xFFFF00, 0xFF00FF, 0x8080FF };
Radiate.speed_min = AORUS_ATC800_SPEED_SLOWEST;
Radiate.speed_max = AORUS_ATC800_SPEED_FASTEST;
Radiate.speed = AORUS_ATC800_SPEED_NORMAL;
Radiate.brightness_min = AORUS_ATC800_BRIGHTNESS_MIN;
Radiate.brightness_max = AORUS_ATC800_BRIGHTNESS_MAX;
Radiate.brightness = AORUS_ATC800_BRIGHTNESS_MAX;
modes.push_back(Radiate);
mode RainbowLoop;
RainbowLoop.name = "Rainbow Loop";
RainbowLoop.value = AORUS_ATC800_MODE_RAINBOW_LOOP;
RainbowLoop.flags = MODE_FLAG_HAS_SPEED;
RainbowLoop.color_mode = MODE_COLORS_NONE;
RainbowLoop.speed_min = AORUS_ATC800_SPEED_SLOWEST;
RainbowLoop.speed_max = AORUS_ATC800_SPEED_FASTEST;
RainbowLoop.speed = AORUS_ATC800_SPEED_NORMAL;
RainbowLoop.name = "Rainbow Loop";
RainbowLoop.value = AORUS_ATC800_MODE_RAINBOW_LOOP;
RainbowLoop.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
RainbowLoop.color_mode = MODE_COLORS_NONE;
RainbowLoop.speed_min = AORUS_ATC800_SPEED_SLOWEST;
RainbowLoop.speed_max = AORUS_ATC800_SPEED_FASTEST;
RainbowLoop.speed = AORUS_ATC800_SPEED_NORMAL;
RainbowLoop.brightness_min = AORUS_ATC800_BRIGHTNESS_MIN;
RainbowLoop.brightness_max = AORUS_ATC800_BRIGHTNESS_MAX;
RainbowLoop.brightness = AORUS_ATC800_BRIGHTNESS_MAX;
modes.push_back(RainbowLoop);
mode Tricolor;
Tricolor.name = "Tricolor";
Tricolor.value = AORUS_ATC800_MODE_TRICOLOR;
Tricolor.flags = MODE_FLAG_HAS_SPEED;
Tricolor.color_mode = MODE_COLORS_NONE;
Tricolor.speed_min = AORUS_ATC800_SPEED_SLOWEST;
Tricolor.speed_max = AORUS_ATC800_SPEED_FASTEST;
Tricolor.speed = AORUS_ATC800_SPEED_NORMAL;
Tricolor.name = "Tricolor";
Tricolor.value = AORUS_ATC800_MODE_TRICOLOR;
Tricolor.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
Tricolor.color_mode = MODE_COLORS_MODE_SPECIFIC;
Tricolor.colors_min = 3;
Tricolor.colors_max = 3;
Tricolor.colors = { 0xFF0000, 0xFF00FF, 0xFFFF00 };
Tricolor.speed_min = AORUS_ATC800_SPEED_SLOWEST;
Tricolor.speed_max = AORUS_ATC800_SPEED_FASTEST;
Tricolor.speed = AORUS_ATC800_SPEED_NORMAL;
Tricolor.brightness_min = AORUS_ATC800_BRIGHTNESS_MIN;
Tricolor.brightness_max = AORUS_ATC800_BRIGHTNESS_MAX;
Tricolor.brightness = AORUS_ATC800_BRIGHTNESS_MAX;
modes.push_back(Tricolor);
mode SpectrumCycle;
SpectrumCycle.name = "Spectrum Cycle";
SpectrumCycle.value = AORUS_ATC800_MODE_SPECTRUM_CYCLE;
SpectrumCycle.flags = MODE_FLAG_HAS_SPEED;
SpectrumCycle.color_mode = MODE_COLORS_NONE;
SpectrumCycle.speed_min = AORUS_ATC800_SPEED_SLOWEST;
SpectrumCycle.speed_max = AORUS_ATC800_SPEED_FASTEST;
SpectrumCycle.speed = AORUS_ATC800_SPEED_NORMAL;
SpectrumCycle.name = "Spectrum Cycle";
SpectrumCycle.value = AORUS_ATC800_MODE_SPECTRUM_CYCLE;
SpectrumCycle.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
SpectrumCycle.color_mode = MODE_COLORS_NONE;
SpectrumCycle.speed_min = AORUS_ATC800_SPEED_SLOWEST;
SpectrumCycle.speed_max = AORUS_ATC800_SPEED_FASTEST;
SpectrumCycle.speed = AORUS_ATC800_SPEED_NORMAL;
SpectrumCycle.brightness_min = AORUS_ATC800_BRIGHTNESS_MIN;
SpectrumCycle.brightness_max = AORUS_ATC800_BRIGHTNESS_MAX;
SpectrumCycle.brightness = AORUS_ATC800_BRIGHTNESS_MAX;
modes.push_back(SpectrumCycle);
SetupZones();
@ -179,20 +241,22 @@ void RGBController_AorusATC800::DeviceUpdateLEDs()
void RGBController_AorusATC800::UpdateZoneLEDs(int zone)
{
unsigned char mode = modes[active_mode].value;
unsigned char red = RGBGetRValue(colors[zone]);
unsigned char grn = RGBGetGValue(colors[zone]);
unsigned char blu = RGBGetBValue(colors[zone]);
mode_config zone_config;
if(mode == AORUS_ATC800_MODE_OFF)
zone_config.colors[0] = colors[zone];
zone_config.numberOfColors = (uint8_t)modes[active_mode].colors.size();
zone_config.speed = modes[active_mode].speed;
zone_config.brightness = modes[active_mode].brightness;
if (modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC)
{
mode = 1;
red = 0;
grn = 0;
blu = 0;
for (uint8_t i = 0; i < zone_config.numberOfColors; i++)
{
zone_config.colors[i] = modes[active_mode].colors[i];
}
}
controller->SendCoolerMode(mode, modes[active_mode].speed, zone, red, grn, blu);
controller->SendCoolerMode(zone, modes[active_mode].value, zone_config);
}
void RGBController_AorusATC800::UpdateSingleLED(int led)