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

Initial commit for ASUS ROG Strix LC120 to resolve #1068

Browse source 
+ 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
This commit is contained in:
Chris 2022-03-17 21:13:55 +11:00 • committed by Adam Honse
parent 8fa85b3f27
commit c013d476ba
7 changed files with 533 additions and 32 deletions
Download patch file Download diff file Expand all files Collapse all files

3
60-openrgb.rules
View file

@ -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"

78
Controllers/AsusAuraUSBController/AsusAuraUSBControllerDetect.cpp
View file

@ -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 <stdexcept>
#include <hidapi/hidapi.h>
@ -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);

221
Controllers/AsusAuraUSBController/RGBController_ROGStrixLC_Controller.cpp Normal file
View file

@ -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;
}

37
Controllers/AsusAuraUSBController/RGBController_ROGStrixLC_Controller.h Normal file
View file

@ -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 <vector>
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;
};

130
Controllers/AsusAuraUSBController/ROGStrixLC_Controller.cpp Normal file
View file

@ -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);
}

92
Controllers/AsusAuraUSBController/ROGStrixLC_Controller.h Normal file
View file

@ -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 <string>
#include <hidapi/hidapi.h>
#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);
};

4
OpenRGB.pro
View file

@ -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 \