From cc376b71c81094b2083448ede08644125205362e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=94=D0=B5=D0=BD=D0=B8=D1=81=20=D0=9D=D0=B0=D0=B7=D0=B0?= =?UTF-8?q?=D1=80=D0=BE=D0=B2?= Date: Wed, 7 Feb 2024 14:29:07 +0000 Subject: [PATCH] Extended support Gigabyte AORUS ATC800 --- .../ATC800Controller.cpp | 326 +++++++++++++----- .../ATC800Controller.h | 43 ++- ...GigabyteAorusCPUCoolerControllerDetect.cpp | 2 +- .../RGBController_AorusATC800.cpp | 220 +++++++----- 4 files changed, 405 insertions(+), 186 deletions(-) diff --git a/Controllers/GigabyteAorusCPUCoolerController/ATC800Controller.cpp b/Controllers/GigabyteAorusCPUCoolerController/ATC800Controller.cpp index a6480574..e07f20b3 100644 --- a/Controllers/GigabyteAorusCPUCoolerController/ATC800Controller.cpp +++ b/Controllers/GigabyteAorusCPUCoolerController/ATC800Controller.cpp @@ -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; + + } } diff --git a/Controllers/GigabyteAorusCPUCoolerController/ATC800Controller.h b/Controllers/GigabyteAorusCPUCoolerController/ATC800Controller.h index 5aa8dc51..b18efd11 100644 --- a/Controllers/GigabyteAorusCPUCoolerController/ATC800Controller.h +++ b/Controllers/GigabyteAorusCPUCoolerController/ATC800Controller.h @@ -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; diff --git a/Controllers/GigabyteAorusCPUCoolerController/GigabyteAorusCPUCoolerControllerDetect.cpp b/Controllers/GigabyteAorusCPUCoolerController/GigabyteAorusCPUCoolerControllerDetect.cpp index 76037f1d..e94e108b 100644 --- a/Controllers/GigabyteAorusCPUCoolerController/GigabyteAorusCPUCoolerControllerDetect.cpp +++ b/Controllers/GigabyteAorusCPUCoolerController/GigabyteAorusCPUCoolerControllerDetect.cpp @@ -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); diff --git a/Controllers/GigabyteAorusCPUCoolerController/RGBController_AorusATC800.cpp b/Controllers/GigabyteAorusCPUCoolerController/RGBController_AorusATC800.cpp index 6cced17c..78cdac62 100644 --- a/Controllers/GigabyteAorusCPUCoolerController/RGBController_AorusATC800.cpp +++ b/Controllers/GigabyteAorusCPUCoolerController/RGBController_AorusATC800.cpp @@ -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)