From c013d476babbe983b546c37a9d9b5d726ea9b34c Mon Sep 17 00:00:00 2001 From: Chris Date: Thu, 17 Mar 2022 21:13:55 +1100 Subject: [PATCH] Initial commit for ASUS ROG Strix LC120 to resolve #1068 + Adding entry for the ROG Strix LC120 PID + Registered detectors + Added ROGStrixLC_Controller to address protocol differences + Added RGBController_ROGStrixLC_Controller to allow for mode differences + Added UDEV rule to 60-openrgb.rules --- 60-openrgb.rules | 3 +- .../AsusAuraUSBControllerDetect.cpp | 78 ++++--- .../RGBController_ROGStrixLC_Controller.cpp | 221 ++++++++++++++++++ .../RGBController_ROGStrixLC_Controller.h | 37 +++ .../ROGStrixLC_Controller.cpp | 130 +++++++++++ .../ROGStrixLC_Controller.h | 92 ++++++++ OpenRGB.pro | 4 + 7 files changed, 533 insertions(+), 32 deletions(-) create mode 100644 Controllers/AsusAuraUSBController/RGBController_ROGStrixLC_Controller.cpp create mode 100644 Controllers/AsusAuraUSBController/RGBController_ROGStrixLC_Controller.h create mode 100644 Controllers/AsusAuraUSBController/ROGStrixLC_Controller.cpp create mode 100644 Controllers/AsusAuraUSBController/ROGStrixLC_Controller.h diff --git a/60-openrgb.rules b/60-openrgb.rules index 600faa25..17c0c29f 100644 --- a/60-openrgb.rules +++ b/60-openrgb.rules @@ -50,7 +50,8 @@ SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="1866", TAG+="uacces #---------------------------------------------------------------# SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="1867", TAG+="uaccess" SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="1872", TAG+="uaccess" -SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="1889", TAG+="uaccess" +SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="1889", TAG+="uaccess", TAG+="AURA_Terminal" +SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="879e", TAG+="uaccess", TAG+="ROG_Strix_LC120" SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="18a3", TAG+="uaccess" SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="18f3", TAG+="uaccess" SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="18a5", TAG+="uaccess" diff --git a/Controllers/AsusAuraUSBController/AsusAuraUSBControllerDetect.cpp b/Controllers/AsusAuraUSBController/AsusAuraUSBControllerDetect.cpp index 7d409d9e..1966fa4f 100644 --- a/Controllers/AsusAuraUSBController/AsusAuraUSBControllerDetect.cpp +++ b/Controllers/AsusAuraUSBController/AsusAuraUSBControllerDetect.cpp @@ -14,6 +14,7 @@ #include "RGBController_AsusAuraTUFKeyboard.h" #include "RGBController_AsusAuraMouse.h" #include "RGBController_AsusAuraMousemat.h" +#include "RGBController_ROGStrixLC_Controller.h" #include "RGBController_AsusAuraStrixEvolve.h" #include #include @@ -62,6 +63,7 @@ #define AURA_TERMINAL_PID 0x1889 #define AURA_ROG_THRONE_PID 0x18D9 #define AURA_ROG_THRONE_QI_PID 0x18C5 +#define ROG_STRIX_LC120_PID 0x879E AuraKeyboardMappingLayoutType GetKeyboardMappingLayoutType(int pid) { @@ -95,9 +97,9 @@ void DetectAsusAuraUSBTerminal(hid_device_info* info, const std::string& name) if(dev) { - AuraAddressableController* controller = new AuraAddressableController(dev, info->path); - RGBController_AuraUSB* rgb_controller = new RGBController_AuraUSB(controller); - rgb_controller->name = name; + AuraAddressableController* controller = new AuraAddressableController(dev, info->path); + RGBController_AuraUSB* rgb_controller = new RGBController_AuraUSB(controller); + rgb_controller->name = name; ResourceManager::get()->RegisterRGBController(rgb_controller); } } @@ -109,9 +111,9 @@ void DetectAsusAuraUSBAddressable(hid_device_info* info, const std::string& /*na if(dev) { DMIInfo dmi; - AuraAddressableController* controller = new AuraAddressableController(dev, info->path); - RGBController_AuraUSB* rgb_controller = new RGBController_AuraUSB(controller); - rgb_controller->name = "ASUS " + dmi.getMainboard() + " Addressable"; + AuraAddressableController* controller = new AuraAddressableController(dev, info->path); + RGBController_AuraUSB* rgb_controller = new RGBController_AuraUSB(controller); + rgb_controller->name = "ASUS " + dmi.getMainboard() + " Addressable"; ResourceManager::get()->RegisterRGBController(rgb_controller); } } @@ -125,9 +127,9 @@ void DetectAsusAuraUSBMotherboards(hid_device_info* info, const std::string& /*n try { DMIInfo dmi; - AuraMainboardController* controller = new AuraMainboardController(dev, info->path); - RGBController_AuraUSB* rgb_controller = new RGBController_AuraUSB(controller); - rgb_controller->name = "ASUS " + dmi.getMainboard(); + AuraMainboardController* controller = new AuraMainboardController(dev, info->path); + RGBController_AuraUSB* rgb_controller = new RGBController_AuraUSB(controller); + rgb_controller->name = "ASUS " + dmi.getMainboard(); ResourceManager::get()->RegisterRGBController(rgb_controller); } catch(const std::runtime_error& ex) @@ -144,10 +146,10 @@ void DetectAsusAuraUSBKeyboards(hid_device_info* info, const std::string& name) if(dev) { - AuraKeyboardController* controller = new AuraKeyboardController(dev, info->path); - AuraKeyboardMappingLayoutType layout = GetKeyboardMappingLayoutType(info->product_id); - RGBController_AuraKeyboard* rgb_controller = new RGBController_AuraKeyboard(controller, layout); - rgb_controller->name = name; + AuraKeyboardController* controller = new AuraKeyboardController(dev, info->path); + AuraKeyboardMappingLayoutType layout = GetKeyboardMappingLayoutType(info->product_id); + RGBController_AuraKeyboard* rgb_controller = new RGBController_AuraKeyboard(controller, layout); + rgb_controller->name = name; ResourceManager::get()->RegisterRGBController(rgb_controller); } } @@ -158,9 +160,9 @@ void DetectAsusAuraUSBMice(hid_device_info* info, const std::string& name) if(dev) { - AuraMouseController* controller = new AuraMouseController(dev, info->path, info->product_id); - RGBController_AuraMouse* rgb_controller = new RGBController_AuraMouse(controller); - rgb_controller->name = name; + AuraMouseController* controller = new AuraMouseController(dev, info->path, info->product_id); + RGBController_AuraMouse* rgb_controller = new RGBController_AuraMouse(controller); + rgb_controller->name = name; ResourceManager::get()->RegisterRGBController(rgb_controller); } } @@ -171,9 +173,22 @@ void DetectAsusAuraUSBMousemats(hid_device_info* info, const std::string& name) if(dev) { - AuraMousematController* controller = new AuraMousematController(dev, info->path); - RGBController_AuraMousemat* rgb_controller = new RGBController_AuraMousemat(controller); - rgb_controller->name = name; + AuraMousematController* controller = new AuraMousematController(dev, info->path); + RGBController_AuraMousemat* rgb_controller = new RGBController_AuraMousemat(controller); + rgb_controller->name = name; + ResourceManager::get()->RegisterRGBController(rgb_controller); + } +} + +void DetectAsusAuraUSBROGStrixLC(hid_device_info* info, const std::string& name) +{ + hid_device* dev = hid_open_path(info->path); + + if(dev) + { + ROGStrixLC_Controller* controller = new ROGStrixLC_Controller(dev, info->path); + RGBController_ROGStrixLC_Controller* rgb_controller = new RGBController_ROGStrixLC_Controller(controller); + rgb_controller->name = name; ResourceManager::get()->RegisterRGBController(rgb_controller); } } @@ -184,9 +199,9 @@ void DetectAsusAuraUSBStrixEvolve(hid_device_info* info, const std::string& name if(dev) { - AuraStrixEvolveController* controller = new AuraStrixEvolveController(dev, info->path, info->product_id); - RGBController_AuraStrixEvolve* rgb_controller = new RGBController_AuraStrixEvolve(controller); - rgb_controller->name = name; + AuraStrixEvolveController* controller = new AuraStrixEvolveController(dev, info->path, info->product_id); + RGBController_AuraStrixEvolve* rgb_controller = new RGBController_AuraStrixEvolve(controller); + rgb_controller->name = name; ResourceManager::get()->RegisterRGBController(rgb_controller); } } @@ -197,9 +212,9 @@ void DetectAsusAuraUSBHeadsetStand(hid_device_info* info, const std::string& nam if(dev) { - AuraHeadsetStandController* controller = new AuraHeadsetStandController(dev, info->path); - RGBController_AuraHeadsetStand* rgb_controller = new RGBController_AuraHeadsetStand(controller); - rgb_controller->name = name; + AuraHeadsetStandController* controller = new AuraHeadsetStandController(dev, info->path); + RGBController_AuraHeadsetStand* rgb_controller = new RGBController_AuraHeadsetStand(controller); + rgb_controller->name = name; ResourceManager::get()->RegisterRGBController(rgb_controller); } } @@ -210,9 +225,9 @@ void DetectAsusAuraTUFUSBKeyboard(hid_device_info* info, const std::string& name if(dev) { - AuraTUFKeyboardController* controller = new AuraTUFKeyboardController(dev, info->path); - RGBController_AuraTUFKeyboard* rgb_controller = new RGBController_AuraTUFKeyboard(controller); - rgb_controller->name = name; + AuraTUFKeyboardController* controller = new AuraTUFKeyboardController(dev, info->path); + RGBController_AuraTUFKeyboard* rgb_controller = new RGBController_AuraTUFKeyboard(controller); + rgb_controller->name = name; ResourceManager::get()->RegisterRGBController(rgb_controller); } } @@ -272,6 +287,7 @@ REGISTER_HID_DETECTOR_PU("ASUS ROG Balteus Qi", DetectAsusAuraUS /*-----------------------------------------------------------------*\ | OTHER | \*-----------------------------------------------------------------*/ -REGISTER_HID_DETECTOR ("ASUS ROG AURA Terminal", DetectAsusAuraUSBTerminal, AURA_USB_VID, AURA_TERMINAL_PID); -REGISTER_HID_DETECTOR_I ("ASUS ROG Throne", DetectAsusAuraUSBHeadsetStand, AURA_USB_VID, AURA_ROG_THRONE_PID, 0); -REGISTER_HID_DETECTOR_I ("ASUS ROG Throne QI", DetectAsusAuraUSBHeadsetStand, AURA_USB_VID, AURA_ROG_THRONE_QI_PID, 0); +REGISTER_HID_DETECTOR ("ASUS ROG AURA Terminal", DetectAsusAuraUSBTerminal, AURA_USB_VID, AURA_TERMINAL_PID); +REGISTER_HID_DETECTOR_PU ("ASUS ROG Strix LC", DetectAsusAuraUSBROGStrixLC, AURA_USB_VID, ROG_STRIX_LC120_PID, 0x00FF, 1); +REGISTER_HID_DETECTOR_I ("ASUS ROG Throne", DetectAsusAuraUSBHeadsetStand, AURA_USB_VID, AURA_ROG_THRONE_PID, 0); +REGISTER_HID_DETECTOR_I ("ASUS ROG Throne QI", DetectAsusAuraUSBHeadsetStand, AURA_USB_VID, AURA_ROG_THRONE_QI_PID, 0); diff --git a/Controllers/AsusAuraUSBController/RGBController_ROGStrixLC_Controller.cpp b/Controllers/AsusAuraUSBController/RGBController_ROGStrixLC_Controller.cpp new file mode 100644 index 00000000..c6660792 --- /dev/null +++ b/Controllers/AsusAuraUSBController/RGBController_ROGStrixLC_Controller.cpp @@ -0,0 +1,221 @@ +/*-------------------------------------------------------------------*\ +| RGBController_ROGStrixLC_Controller.cpp | +| | +| Driver for the ASUS Aura Liquid Cooler (LC) series | +| of lighting controllers | +| | +| Chris M (Dr_No) 17 Jan 2022 | +| | +\*-------------------------------------------------------------------*/ + +#include "RGBControllerKeyNames.h" +#include "RGBController_ROGStrixLC_Controller.h" + +RGBController_ROGStrixLC_Controller::RGBController_ROGStrixLC_Controller(ROGStrixLC_Controller *controller_ptr) +{ + controller = controller_ptr; + uint8_t speed = ROGSTRIXLC_CONTROLLER_SPEED_NORMAL; + + name = "ROG Strix LC"; + vendor = "ASUS"; + type = DEVICE_TYPE_COOLER; + description = "ASUS Liquid Cooler including 120mm, 140mm, 240mm, 280mm and 360mm radiators."; + version = KEY_EN_UNUSED; + serial = KEY_EN_UNUSED; + location = controller->GetLocation(); + + mode Direct; + Direct.name = "Direct"; + Direct.value = ROGSTRIXLC_CONTROLLER_MODE_DIRECT; + Direct.flags = MODE_FLAG_HAS_PER_LED_COLOR; + Direct.color_mode = MODE_COLORS_PER_LED; + modes.push_back(Direct); + + mode Static; + Static.name = "Static"; + Static.value = ROGSTRIXLC_CONTROLLER_MODE_STATIC; + Static.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR; + Static.colors_min = 1; + Static.colors_max = 1; + Static.colors.resize(Static.colors_max); + Static.color_mode = MODE_COLORS_MODE_SPECIFIC; + modes.push_back(Static); + + mode Breathing; + Breathing.name = "Breathing"; + Breathing.value = ROGSTRIXLC_CONTROLLER_MODE_BREATHING; + Breathing.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR; + Breathing.colors_min = 1; + Breathing.colors_max = 1; + Breathing.colors.resize(Breathing.colors_max); + Breathing.brightness_min = ROGSTRIXLC_CONTROLLER_BRIGHTNESS_MIN; + Breathing.brightness_max = ROGSTRIXLC_CONTROLLER_BRIGHTNESS_MAX; + Breathing.brightness = ROGSTRIXLC_CONTROLLER_BRIGHTNESS_MAX; + Breathing.speed_min = ROGSTRIXLC_CONTROLLER_SPEED_SLOWEST; + Breathing.speed_max = ROGSTRIXLC_CONTROLLER_SPEED_FASTEST; + Breathing.color_mode = MODE_COLORS_MODE_SPECIFIC; + Breathing.speed = speed; + modes.push_back(Breathing); + + mode Flashing; + Flashing.name = "Flashing"; + Flashing.value = ROGSTRIXLC_CONTROLLER_MODE_FLASHING; + Flashing.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR; + Flashing.colors_min = 1; + Flashing.colors_max = 1; + Flashing.colors.resize(Flashing.colors_max); + Flashing.brightness_min = ROGSTRIXLC_CONTROLLER_BRIGHTNESS_MIN; + Flashing.brightness_max = ROGSTRIXLC_CONTROLLER_BRIGHTNESS_MAX; + Flashing.brightness = ROGSTRIXLC_CONTROLLER_BRIGHTNESS_MAX; + Flashing.speed_min = ROGSTRIXLC_CONTROLLER_SPEED_SLOWEST; + Flashing.speed_max = ROGSTRIXLC_CONTROLLER_SPEED_FASTEST; + Flashing.color_mode = MODE_COLORS_MODE_SPECIFIC; + Flashing.speed = speed; + modes.push_back(Flashing); + + mode Spectrum; + Spectrum.name = "Spectrum"; + Spectrum.value = ROGSTRIXLC_CONTROLLER_MODE_SPECTRUM; + Spectrum.flags = MODE_FLAG_HAS_SPEED; + Spectrum.brightness_min = ROGSTRIXLC_CONTROLLER_BRIGHTNESS_MIN; + Spectrum.brightness_max = ROGSTRIXLC_CONTROLLER_BRIGHTNESS_MAX; + Spectrum.brightness = ROGSTRIXLC_CONTROLLER_BRIGHTNESS_MAX; + Spectrum.speed_min = ROGSTRIXLC_CONTROLLER_SPEED_SLOWEST; + Spectrum.speed_max = ROGSTRIXLC_CONTROLLER_SPEED_FASTEST; + Spectrum.color_mode = MODE_COLORS_NONE; + Spectrum.speed = speed; + modes.push_back(Spectrum); + + mode Rainbow; + Rainbow.name = "Rainbow"; + Rainbow.value = ROGSTRIXLC_CONTROLLER_MODE_RAINBOW; + Rainbow.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR; + Rainbow.brightness_min = ROGSTRIXLC_CONTROLLER_BRIGHTNESS_MIN; + Rainbow.brightness_max = ROGSTRIXLC_CONTROLLER_BRIGHTNESS_MAX; + Rainbow.brightness = ROGSTRIXLC_CONTROLLER_BRIGHTNESS_MAX; + Rainbow.speed_min = ROGSTRIXLC_CONTROLLER_SPEED_SLOWEST; + Rainbow.speed_max = ROGSTRIXLC_CONTROLLER_SPEED_FASTEST; + Rainbow.color_mode = MODE_COLORS_NONE; + Rainbow.speed = speed; + modes.push_back(Rainbow); + + mode FlashAndDash; + FlashAndDash.name = "Flash and Dash"; + FlashAndDash.value = ROGSTRIXLC_CONTROLLER_MODE_FLASHANDDASH; + FlashAndDash.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR; + FlashAndDash.brightness_min = ROGSTRIXLC_CONTROLLER_BRIGHTNESS_MIN; + FlashAndDash.brightness_max = ROGSTRIXLC_CONTROLLER_BRIGHTNESS_MAX; + FlashAndDash.brightness = ROGSTRIXLC_CONTROLLER_BRIGHTNESS_MAX; + FlashAndDash.speed_min = ROGSTRIXLC_CONTROLLER_SPEED_SLOWEST; + FlashAndDash.speed_max = ROGSTRIXLC_CONTROLLER_SPEED_FASTEST; + FlashAndDash.color_mode = MODE_COLORS_NONE; + FlashAndDash.speed = speed; + modes.push_back(FlashAndDash); + + SetupZones(); +} + +RGBController_ROGStrixLC_Controller::~RGBController_ROGStrixLC_Controller() +{ + delete controller; +} + +void RGBController_ROGStrixLC_Controller::SetupZones() +{ + /*-------------------------------------------------*\ + | Set up zones | + \*-------------------------------------------------*/ + LOG_DEBUG("[%s] - Get channel count: %i", name.c_str(), controller->GetChannelCount()); + + zones.resize(controller->GetChannelCount()); + + LOG_DEBUG("[%s] - Creating Zones and LEDs", name.c_str()); + for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++) + { + AuraDeviceInfo device_info = controller->GetAuraDevices()[zone_idx]; + LOG_INFO("[%s] %s Zone %i - Header Count %i LED Count %i FX %02X Direct %02X", name.c_str(), + ((device_info.device_type == AuraDeviceType::FIXED) ? "Fixed" : "Addressable"), + zone_idx, device_info.num_headers, device_info.num_leds, device_info.effect_channel, device_info.direct_channel); + + zones[zone_idx].name = name + " Zone "; + zones[zone_idx].name.append(std::to_string(zone_idx)); + zones[zone_idx].type = ZONE_TYPE_LINEAR; + zones[zone_idx].leds_min = device_info.num_leds; + zones[zone_idx].leds_max = device_info.num_leds; + zones[zone_idx].leds_count = device_info.num_leds; + + for(unsigned int lp_idx = 0; lp_idx < zones[zone_idx].leds_count; lp_idx++) + { + led new_led; + + new_led.name = zones[zone_idx].name; + new_led.name.append(" LED " + std::to_string(lp_idx)); + new_led.value = lp_idx; + + leds.push_back(new_led); + } + } + + LOG_DEBUG("[%s] - Device zones and LEDs set", name.c_str()); + SetupColors(); +} + +void RGBController_ROGStrixLC_Controller::ResizeZone(int zone, int new_size) +{ + /*---------------------------------------------------------*\ + | This device does not support resizing zones | + \*---------------------------------------------------------*/ +} + +void RGBController_ROGStrixLC_Controller::DeviceUpdateLEDs() +{ + for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++) + { + UpdateZoneLEDs(zone_idx); + } +} + +void RGBController_ROGStrixLC_Controller::UpdateZoneLEDs(int zone) +{ + controller->SetLedsDirect( zones[zone].colors, zones[zone].leds_count ); +} + +void RGBController_ROGStrixLC_Controller::UpdateSingleLED(int led) +{ + UpdateZoneLEDs(GetLED_Zone(led)); +} + +void RGBController_ROGStrixLC_Controller::SetCustomMode() +{ + for(std::size_t mode_idx = 0; mode_idx < modes.size() ; mode_idx++) + { + if (modes[mode_idx].value == ROGSTRIXLC_CONTROLLER_MODE_DIRECT) + { + active_mode = mode_idx; + break; + } + } +} + +void RGBController_ROGStrixLC_Controller::DeviceUpdateMode() +{ + RGBColor colour = (modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC) ? modes[active_mode].colors[0] : 0; + + controller->SetMode( modes[active_mode].value, modes[active_mode].speed, modes[active_mode].direction, colour ); +} + +int RGBController_ROGStrixLC_Controller::GetLED_Zone(int led_idx) +{ + for(size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++) + { + int zone_start = zones[zone_idx].start_idx; + int zone_end = zone_start + zones[zone_idx].leds_count - 1; + + if( zone_start <= led_idx && zone_end >= led_idx) + { + return(zone_idx); + } + } + + return -1; +} diff --git a/Controllers/AsusAuraUSBController/RGBController_ROGStrixLC_Controller.h b/Controllers/AsusAuraUSBController/RGBController_ROGStrixLC_Controller.h new file mode 100644 index 00000000..90fc0e7b --- /dev/null +++ b/Controllers/AsusAuraUSBController/RGBController_ROGStrixLC_Controller.h @@ -0,0 +1,37 @@ +/*-------------------------------------------------------------------*\ +| RGBController_ROGStrixLC_Controller.h | +| | +| Driver for the ASUS Aura Liquid Cooler (LC) series | +| of lighting controllers | +| | +| Chris M (Dr_No) 17 Jan 2022 | +| | +\*-------------------------------------------------------------------*/ + +#pragma once +#include "LogManager.h" +#include "RGBController.h" +#include "ROGStrixLC_Controller.h" +#include + +class RGBController_ROGStrixLC_Controller : public RGBController +{ +public: + RGBController_ROGStrixLC_Controller(ROGStrixLC_Controller* controller_ptr); + ~RGBController_ROGStrixLC_Controller(); + + void SetupZones(); + void ResizeZone(int zone, int new_size); + + void DeviceUpdateLEDs(); + void UpdateZoneLEDs(int zone); + void UpdateSingleLED(int led); + + void SetCustomMode(); + void DeviceUpdateMode(); +private: + int GetDeviceMode(); + int GetLED_Zone(int led_idx); + + ROGStrixLC_Controller* controller; +}; diff --git a/Controllers/AsusAuraUSBController/ROGStrixLC_Controller.cpp b/Controllers/AsusAuraUSBController/ROGStrixLC_Controller.cpp new file mode 100644 index 00000000..acfcd1e4 --- /dev/null +++ b/Controllers/AsusAuraUSBController/ROGStrixLC_Controller.cpp @@ -0,0 +1,130 @@ +/*-------------------------------------------------------------------*\ +| ROGStrixLC_Controller.cpp | +| | +| Driver for the ASUS Aura Liquid Cooler (LC) series | +| of lighting controllers | +| | +| Chris M (Dr_No) 17 Jan 2022 | +| | +\*-------------------------------------------------------------------*/ + +#include "ROGStrixLC_Controller.h" + +ROGStrixLC_Controller::ROGStrixLC_Controller(hid_device* dev_handle, const char* path) : AuraUSBController(dev_handle, path) +{ + const int szTemp = HID_MAX_STR; + wchar_t tmpName[szTemp]; + + /*-----------------------------------------------------*\ + | Add addressable devices | + | Manually adding device info for now | + | TODO: Implement config table accurately | + | LC120 - 1F FF 05 05 04 00 00 00 | + \*-----------------------------------------------------*/ + device_info.push_back({0x00, 0x00, 4, 0, AuraDeviceType::FIXED}); +} + +ROGStrixLC_Controller::~ROGStrixLC_Controller() +{ + hid_close(dev); +} + +std::string ROGStrixLC_Controller::GetLocation() +{ + return("HID: " + location); +} + +void ROGStrixLC_Controller::SetMode(unsigned char channel, unsigned char mode, unsigned char red, unsigned char grn, unsigned char blu) +{ + /*---------------------------------------------------------*\ + | This interface is not used in this controller however is | + | required by the abstract class | + \*---------------------------------------------------------*/ +} + +void ROGStrixLC_Controller::SetMode(unsigned char mode, unsigned char speed, unsigned char direction, RGBColor colour) +{ + bool needs_update = !( (current_mode == mode) && (ToRGBColor(current_red, current_green, current_blue) == colour) && (current_speed == speed) && (current_direction == direction)); + + if (needs_update) + { + current_mode = mode; + current_speed = speed; + current_direction = direction; + current_red = RGBGetRValue(colour); + current_green = RGBGetGValue(colour); + current_blue = RGBGetBValue(colour); + SendUpdate(); + } +} + +void ROGStrixLC_Controller::SetChannelLEDs(unsigned char channel, RGBColor * colors, unsigned int num_colors) +{ + /*---------------------------------------------------------*\ + | This interface is not used in this controller however is | + | required by the abstract class | + \*---------------------------------------------------------*/ +} + +void ROGStrixLC_Controller::SetLedsDirect(RGBColor * led_colours, uint8_t led_count) +{ + uint8_t buffer[write_packet_size] = { 0xEC, 0x40, 0x00, 0xFF, led_count }; + + /*---------------------------------------------------------*\ + | Set the colour bytes in the packet | + \*---------------------------------------------------------*/ + for(uint8_t index = 0; index < led_count; index++) + { + uint8_t offset = (index * 3) + ROGSTRIXLC_GREEN_BYTE; + + buffer[offset + 0] = RGBGetRValue(led_colours[index]); + buffer[offset + 1] = RGBGetGValue(led_colours[index]); + buffer[offset + 2] = RGBGetBValue(led_colours[index]); + } + + /*---------------------------------------------------------*\ + | These 3 bytes might be timing bytes | + \*---------------------------------------------------------*/ + uint8_t offset = led_count * 3 + ROGSTRIXLC_GREEN_BYTE; + buffer[offset + 0] = 0x77; + buffer[offset + 1] = 0x10; + buffer[offset + 2] = 0xF3; + + hid_write(dev, buffer, write_packet_size); +} + +void ROGStrixLC_Controller::GetStatus() +{ + uint8_t buffer[write_packet_size] = { 0xEC, 0x01, 0x02 }; + + hid_write(dev, buffer, write_packet_size); + hid_read_timeout(dev, buffer, read_packet_size, ROGSTRIXLC_CONTROLLER_TIMEOUT); + + current_red = buffer[ROGSTRIXLC_RED_BYTE - 1]; + current_green = buffer[ROGSTRIXLC_GREEN_BYTE - 1]; + current_blue = buffer[ROGSTRIXLC_BLUE_BYTE - 1]; +} + +void ROGStrixLC_Controller::SendUpdate() +{ + uint8_t buffer[write_packet_size]; + + /*-----------------------------------------------------*\ + | Zero out buffer | + \*-----------------------------------------------------*/ + memset(buffer, 0x00, write_packet_size); + + buffer[ROGSTRIXLC_REPORTID_BYTE] = rogstrixlc_reportid; + buffer[ROGSTRIXLC_COMMAND_BYTE] = rogstrixlc_modefx; + buffer[ROGSTRIXLC_ZONE_BYTE] = 0; + buffer[ROGSTRIXLC_MODE_BYTE] = current_mode; + buffer[ROGSTRIXLC_RED_BYTE] = current_red; + buffer[ROGSTRIXLC_GREEN_BYTE] = current_green; + buffer[ROGSTRIXLC_BLUE_BYTE] = current_blue; + + buffer[ROGSTRIXLC_DIRECTION_BYTE] = current_direction; + buffer[ROGSTRIXLC_SPEED_BYTE] = current_speed; + + hid_write(dev, buffer, write_packet_size); +} + diff --git a/Controllers/AsusAuraUSBController/ROGStrixLC_Controller.h b/Controllers/AsusAuraUSBController/ROGStrixLC_Controller.h new file mode 100644 index 00000000..ed44add8 --- /dev/null +++ b/Controllers/AsusAuraUSBController/ROGStrixLC_Controller.h @@ -0,0 +1,92 @@ +/*-------------------------------------------------------------------*\ +| ROGStrixLC_Controller.h | +| | +| Driver for the ASUS Aura Liquid Cooler (LC) series | +| of lighting controllers | +| | +| Chris M (Dr_No) 17 Jan 2022 | +| | +\*-------------------------------------------------------------------*/ + +#include +#include +#include "RGBController.h" +#include "AsusAuraUSBController.h" + +#pragma once + +#define ROGSTRIXLC_CONTROLLER_TIMEOUT 250 +#define HID_MAX_STR 255 + +#define ROGSTRIXLC_CONTROLLER_BRIGHTNESS_MIN 0 +#define ROGSTRIXLC_CONTROLLER_BRIGHTNESS_MAX 255 + +enum +{ + ROGSTRIXLC_CONTROLLER_MODE_DIRECT = 0xFF, //Direct Led Control - Independently set LEDs in zone + ROGSTRIXLC_CONTROLLER_MODE_STATIC = 0x01, //Static Mode - Set entire zone to a single color. + ROGSTRIXLC_CONTROLLER_MODE_BREATHING = 0x02, //Breathing Mode - Fades between fully off and fully on. + ROGSTRIXLC_CONTROLLER_MODE_FLASHING = 0x03, //Flashing Mode - Abruptly changing between fully off and fully on. + ROGSTRIXLC_CONTROLLER_MODE_SPECTRUM = 0x04, //Spectrum Cycle Mode - Cycles through the color spectrum on all lights on the device + ROGSTRIXLC_CONTROLLER_MODE_RAINBOW = 0x05, //Rainbow Wave Mode - Cycle thru the color spectrum as a wave across all LEDs + ROGSTRIXLC_CONTROLLER_MODE_FLASHANDDASH = 0x0A, //Flash n Dash - Flash twice and then flash in direction +}; + +enum AsusAuraStrixLC_PacketMap +{ + ROGSTRIXLC_REPORTID_BYTE = 0, + ROGSTRIXLC_COMMAND_BYTE = 1, + ROGSTRIXLC_ZONE_BYTE = 2, + ROGSTRIXLC_MODE_BYTE = 3, + ROGSTRIXLC_RED_BYTE = 4, + ROGSTRIXLC_GREEN_BYTE = 5, + ROGSTRIXLC_BLUE_BYTE = 6, + ROGSTRIXLC_DIRECTION_BYTE = 7, + ROGSTRIXLC_SPEED_BYTE = 8, +}; + +enum +{ + ROGSTRIXLC_CONTROLLER_SPEED_SLOWEST = 0x04, // Slowest speed + ROGSTRIXLC_CONTROLLER_SPEED_SLOW = 0x03, // Slower speed + ROGSTRIXLC_CONTROLLER_SPEED_NORMAL = 0x02, // Normal speed + ROGSTRIXLC_CONTROLLER_SPEED_FAST = 0x01, // Fast speed + ROGSTRIXLC_CONTROLLER_SPEED_FASTEST = 0x00, // Fastest speed +}; + +class ROGStrixLC_Controller : public AuraUSBController +{ +public: + ROGStrixLC_Controller(hid_device* dev_handle, const char* path); + ~ROGStrixLC_Controller(); + + std::string GetLocation(); + + void SetChannelLEDs(unsigned char channel, RGBColor *colors, unsigned int num_colors); + void SetLedsDirect(RGBColor * led_colours, uint8_t led_count); + + void SetMode(unsigned char channel, unsigned char mode, unsigned char red, unsigned char grn, unsigned char blu); + void SetMode(unsigned char mode, unsigned char speed, unsigned char direction, RGBColor colour); +private: + static const uint8_t read_packet_size = 64; + static const uint8_t write_packet_size = read_packet_size + 1; + static const uint8_t rogstrixlc_modefx = 0x3B; + static const uint8_t rogstrixlc_direct = 0x40; + static const uint8_t rogstrixlc_reportid = 0xEC; + + std::string location; + + uint8_t zone_index; + uint8_t current_mode; + uint8_t current_speed; + + uint8_t current_red; + uint8_t current_green; + uint8_t current_blue; + uint8_t current_direction; + + void GetStatus(); + void SendUpdate(); + void SendEffect(unsigned char channel, unsigned char mode, unsigned char red, unsigned char grn, unsigned char blu); + void SendDirectApply(unsigned char channel); +}; diff --git a/OpenRGB.pro b/OpenRGB.pro index ce2090c7..863eea2b 100644 --- a/OpenRGB.pro +++ b/OpenRGB.pro @@ -251,6 +251,8 @@ HEADERS += Controllers/AsusAuraUSBController/RGBController_AsusAuraStrixEvolve.h \ Controllers/AsusAuraUSBController/RGBController_AsusAuraTUFKeyboard.h \ Controllers/AsusAuraUSBController/RGBController_AsusAuraUSB.h \ + Controllers/AsusAuraUSBController/RGBController_ROGStrixLC_Controller.h \ + Controllers/AsusAuraUSBController/ROGStrixLC_Controller.h \ Controllers/BlinkyTapeController/BlinkyTapeController.h \ Controllers/BlinkyTapeController/RGBController_BlinkyTape.h \ Controllers/CoolerMasterController/CMARGBcontroller.h \ @@ -657,6 +659,8 @@ SOURCES += Controllers/AsusAuraUSBController/RGBController_AsusAuraStrixEvolve.cpp \ Controllers/AsusAuraUSBController/RGBController_AsusAuraTUFKeyboard.cpp \ Controllers/AsusAuraUSBController/RGBController_AsusAuraUSB.cpp \ + Controllers/AsusAuraUSBController/RGBController_ROGStrixLC_Controller.cpp \ + Controllers/AsusAuraUSBController/ROGStrixLC_Controller.cpp \ Controllers/BlinkyTapeController/BlinkyTapeController.cpp \ Controllers/BlinkyTapeController/BlinkyTapeControllerDetect.cpp \ Controllers/BlinkyTapeController/RGBController_BlinkyTape.cpp \