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

Add ROG Ryuo Water Cooler

Browse source
This commit is contained in:
Cooper Hall 2022-06-04 04:42:35 +00:00 • committed by Adam Honse
parent 15be3f6336
commit f3663af404
6 changed files with 497 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

121
Controllers/AsusAuraUSBController/AsusAuraRyuoAIOController.cpp Normal file
View file

@ -0,0 +1,121 @@
/*-------------------------------------------------------------------*\
| AsusAuraRyuoAIOController.cpp |
| |
| Driver for the ASUS Aura Ryuo AIO |
| lighting controller |
| |
| Cooper Hall (geobot19 / Geo_bot) 08 Apr 2022 |
| using snipets from Chris M (Dr.No) |
\*-------------------------------------------------------------------*/
#include "AsusAuraRyuoAIOController.h"
AsusAuraRyuoAIOController::AsusAuraRyuoAIOController(hid_device* dev_handle, const char* path) : AuraUSBController(dev_handle, path)
{
const int szTemp = ASUSAURARYUOAIOCONTROLLER_HID_MAX_STR;
wchar_t tmpName[szTemp];
/*-----------------------------------------------------*\
| Add addressable devices |
| Manually adding device info for now |
| TODO: Implement config table accurately |
\*-----------------------------------------------------*/
device_info.push_back({0x00, 0x00, 12, 0, AuraDeviceType::FIXED});
}
AsusAuraRyuoAIOController::~AsusAuraRyuoAIOController()
{
hid_close(dev);
}
std::string AsusAuraRyuoAIOController::GetLocation()
{
return("HID: " + location);
}
void AsusAuraRyuoAIOController::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 AsusAuraRyuoAIOController::SetMode(unsigned char mode, unsigned char speed, unsigned char direction, RGBColor colour)
{
//check if update is needed
if(!((current_mode == mode) && (ToRGBColor(current_red, current_green, current_blue) == colour) && (current_speed == speed) && (current_direction == direction)))
{
current_mode = mode;
current_speed = speed;
current_direction = direction;
current_red = RGBGetRValue(colour);
current_green = RGBGetGValue(colour);
current_blue = RGBGetBValue(colour);
SendUpdate();
}
}
void AsusAuraRyuoAIOController::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 AsusAuraRyuoAIOController::SetLedsDirect(RGBColor * led_colours, uint8_t led_count)
{
uint8_t buffer[write_packet_size] = { 0xEC, 0x40, 0x80, 0x00, led_count };
/*---------------------------------------------------------*\
| Set the colour bytes in the packet |
\*---------------------------------------------------------*/
for(uint8_t index = 0; index < led_count; index++)
{
uint8_t offset = (index * 3) + RED_BYTE;
buffer[offset + 0] = RGBGetRValue(led_colours[index]);
buffer[offset + 1] = RGBGetGValue(led_colours[index]);
buffer[offset + 2] = RGBGetBValue(led_colours[index]);
}
hid_write(dev, buffer, write_packet_size);
}
void AsusAuraRyuoAIOController::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, ASUSAURARYUOAIOCONTROLLER_TIMEOUT);
current_red = buffer[RED_BYTE - 1];
current_green = buffer[GREEN_BYTE - 1];
current_blue = buffer[BLUE_BYTE - 1];
}
void AsusAuraRyuoAIOController::SendUpdate()
{
uint8_t buffer[write_packet_size];
/*-----------------------------------------------------*\
| Zero out buffer |
\*-----------------------------------------------------*/
memset(buffer, 0x00, write_packet_size);
buffer[REPORTID_BYTE] = reportid;
buffer[COMMAND_BYTE] = modefx;
buffer[ZONE_BYTE] = 0;
buffer[PROGRAM_ID_BYTE] = program_id;
buffer[MODE_BYTE] = current_mode;
buffer[RED_BYTE] = current_red;
buffer[GREEN_BYTE] = current_green;
buffer[BLUE_BYTE] = current_blue;
buffer[DIRECTION_BYTE]= current_direction;
buffer[SPEED_BYTE] = current_speed;
hid_write(dev, buffer, write_packet_size);
}

94
Controllers/AsusAuraUSBController/AsusAuraRyuoAIOController.h Normal file
View file

@ -0,0 +1,94 @@
/*-------------------------------------------------------------------*\
| AsusAuraRyuoAIOController.h |
| |
| Driver for the ASUS Aura Ryuo AIO |
| lighting controller |
| |
| Cooper Hall (geobot19 / Geo_bot) 08 Apr 2022 |
| using snipets from Chris M (Dr.No) |
\*-------------------------------------------------------------------*/
#include <string>
#include <hidapi/hidapi.h>
#include "RGBController.h"
#include "AsusAuraUSBController.h"
#pragma once
#define ASUSAURARYUOAIOCONTROLLER_TIMEOUT 250
#define ASUSAURARYUOAIOCONTROLLER_HID_MAX_STR 255
#define ASUSAURARYUOAIOCONTROLLER_BRIGHTNESS_MIN 0
#define ASUSAURARYUOAIOCONTROLLER_BRIGHTNESS_MAX 255
class AsusAuraRyuoAIOController : public AuraUSBController
{
public:
enum
{
MODE_DIRECT = 0xFF, //Direct Led Control - Independently set LEDs in zone
MODE_STATIC = 0x01, //Static Mode - Set entire zone to a single color.
MODE_BREATHING = 0x02, //Breathing Mode - Fades between fully off and fully on.
MODE_FLASHING = 0x03, //Flashing Mode - Abruptly changing between fully off and fully on.
MODE_SPECTRUM = 0x04, //Spectrum Cycle Mode - Cycles through the color spectrum on all lights on the device
MODE_RAINBOW = 0x05, //Rainbow Wave Mode - Cycle thru the color spectrum as a wave across all LEDs
MODE_FLASHANDDASH = 0x0A, //Flash n Dash - Flash twice and then flash in direction
};
enum PacketMap
{
REPORTID_BYTE = 0,
COMMAND_BYTE = 1,
ZONE_BYTE = 2,
PROGRAM_ID_BYTE= 3,
MODE_BYTE = 4,
RED_BYTE = 5,
GREEN_BYTE = 6,
BLUE_BYTE = 7,
DIRECTION_BYTE = 8,
SPEED_BYTE = 9,
};
enum
{
SPEED_SLOWEST = 0x04, // Slowest speed
SPEED_SLOW = 0x03, // Slower speed
SPEED_NORMAL = 0x02, // Normal speed
SPEED_FAST = 0x01, // Fast speed
SPEED_FASTEST = 0x00, // Fastest speed
};
AsusAuraRyuoAIOController(hid_device* dev_handle, const char* path);
~AsusAuraRyuoAIOController();
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 = 65;
static const uint8_t write_packet_size = 65;
static const uint8_t modefx = 0x3B;
static const uint8_t direct = 0x40;
static const uint8_t reportid = 0xEC;
static const uint8_t program_id = 0x22;
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);
};

17
Controllers/AsusAuraUSBController/AsusAuraUSBControllerDetect.cpp
View file

@ -8,6 +8,7 @@
#include "AsusAuraMousematController.h"
#include "AsusAuraStrixEvolveController.h"
#include "AsusAuraMonitorController.h"
#include "AsusAuraRyuoAIOController.h"
#include "RGBController.h"
#include "RGBController_AsusAuraUSB.h"
#include "RGBController_AsusAuraHeadsetStand.h"
@ -18,6 +19,7 @@
#include "RGBController_ROGStrixLC_Controller.h"
#include "RGBController_AsusAuraStrixEvolve.h"
#include "RGBController_AsusAuraMonitor.h"
#include "RGBController_AsusAuraRyuoAIO.h"
#include <stdexcept>
#include <hidapi/hidapi.h>
#include "dependencies/dmiinfo.h"
@ -80,6 +82,7 @@
\*-----------------------------------------------------------------*/
#define AURA_TERMINAL_PID 0x1889
#define ROG_STRIX_LC120_PID 0x879E
#define AURA_RYUO_AIO_PID 0x1887
AuraKeyboardMappingLayoutType GetKeyboardMappingLayoutType(int pid)
{
@ -209,6 +212,19 @@ void DetectAsusAuraUSBROGStrixLC(hid_device_info* info, const std::string& name)
}
}
void DetectAsusAuraUSBRyuoAIO(hid_device_info* info, const std::string& name)
{
hid_device* dev = hid_open_path(info->path);
if(dev)
{
AsusAuraRyuoAIOController* controller = new AsusAuraRyuoAIOController(dev, info->path);
RGBController_AsusAuraRyuoAIO* rgb_controller = new RGBController_AsusAuraRyuoAIO(controller);
rgb_controller->name = name;
ResourceManager::get()->RegisterRGBController(rgb_controller);
}
}
void DetectAsusAuraUSBStrixEvolve(hid_device_info* info, const std::string& name)
{
hid_device* dev = hid_open_path(info->path);
@ -337,6 +353,7 @@ REGISTER_HID_DETECTOR_PU("ASUS ROG PG32UQ", DetectAs
\*-----------------------------------------------------------------*/
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_PU ("ASUS ROG Ryuo AIO", DetectAsusAuraUSBRyuoAIO, AURA_USB_VID, AURA_RYUO_AIO_PID, 0xFF72, 0x00A1);
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_I ("ASUS ROG Throne QI GUNDAM", DetectAsusAuraUSBHeadsetStand, AURA_USB_VID, AURA_ROG_THRONE_QI_GUNDAM_PID, 0);

223
Controllers/AsusAuraUSBController/RGBController_AsusAuraRyuoAIO.cpp Normal file
View file

@ -0,0 +1,223 @@
/*-------------------------------------------------------------------*\
| RGBController_AsusAuraRyuoAIO.cpp |
| |
| Driver for the ASUS Aura Ryuo AIO |
| lighting controller |
| |
| Cooper Hall (geobot19 / Geo_bot) 08 Apr 2022 |
| using snipets from Chris M (Dr.No) |
\*-------------------------------------------------------------------*/
#include "RGBControllerKeyNames.h"
#include "RGBController_AsusAuraRyuoAIO.h"
/**------------------------------------------------------------------*\
@name Asus Aura Ryuo AIO
@type USB
@save :white_check_mark:
@direct :white_check_mark:
@effects :white_check_mark:
@detectors DetectAsusAuraUSBMousemats
@category Cooler
@comment
\*-------------------------------------------------------------------*/
RGBController_AsusAuraRyuoAIO::RGBController_AsusAuraRyuoAIO(AsusAuraRyuoAIOController *controller_ptr)
{
controller = controller_ptr;
uint8_t speed = controller->SPEED_NORMAL;
name = "ROG Ryuo AIO";
vendor = "ASUS";
type = DEVICE_TYPE_COOLER;
description = "ASUS Liquid Cooler with 120mm and 240mm radiators.";
location = controller->GetLocation();
mode Direct;
Direct.name = "Direct";
Direct.value = 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 = 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 = 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 = ASUSAURARYUOAIOCONTROLLER_BRIGHTNESS_MIN;
Breathing.brightness_max = ASUSAURARYUOAIOCONTROLLER_BRIGHTNESS_MAX;
Breathing.brightness = ASUSAURARYUOAIOCONTROLLER_BRIGHTNESS_MAX;
Breathing.speed_min = controller->SPEED_SLOWEST;
Breathing.speed_max = controller->SPEED_FASTEST;
Breathing.color_mode = MODE_COLORS_MODE_SPECIFIC;
Breathing.speed = speed;
modes.push_back(Breathing);
mode Flashing;
Flashing.name = "Flashing";
Flashing.value = 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 = ASUSAURARYUOAIOCONTROLLER_BRIGHTNESS_MIN;
Flashing.brightness_max = ASUSAURARYUOAIOCONTROLLER_BRIGHTNESS_MAX;
Flashing.brightness = ASUSAURARYUOAIOCONTROLLER_BRIGHTNESS_MAX;
Flashing.speed_min = controller->SPEED_SLOWEST;
Flashing.speed_max = controller->SPEED_FASTEST;
Flashing.color_mode = MODE_COLORS_MODE_SPECIFIC;
Flashing.speed = speed;
modes.push_back(Flashing);
mode Spectrum;
Spectrum.name = "Spectrum";
Spectrum.value = controller->MODE_SPECTRUM;
Spectrum.flags = MODE_FLAG_HAS_SPEED;
Spectrum.brightness_min = ASUSAURARYUOAIOCONTROLLER_BRIGHTNESS_MIN;
Spectrum.brightness_max = ASUSAURARYUOAIOCONTROLLER_BRIGHTNESS_MAX;
Spectrum.brightness = ASUSAURARYUOAIOCONTROLLER_BRIGHTNESS_MAX;
Spectrum.speed_min = controller->SPEED_SLOWEST;
Spectrum.speed_max = controller->SPEED_FASTEST;
Spectrum.color_mode = MODE_COLORS_NONE;
Spectrum.speed = speed;
modes.push_back(Spectrum);
mode Rainbow;
Rainbow.name = "Rainbow";
Rainbow.value = controller->MODE_RAINBOW;
Rainbow.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
Rainbow.brightness_min = ASUSAURARYUOAIOCONTROLLER_BRIGHTNESS_MIN;
Rainbow.brightness_max = ASUSAURARYUOAIOCONTROLLER_BRIGHTNESS_MAX;
Rainbow.brightness = ASUSAURARYUOAIOCONTROLLER_BRIGHTNESS_MAX;
Rainbow.speed_min = controller->SPEED_SLOWEST;
Rainbow.speed_max = 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 = controller->MODE_FLASHANDDASH;
FlashAndDash.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
FlashAndDash.brightness_min = ASUSAURARYUOAIOCONTROLLER_BRIGHTNESS_MIN;
FlashAndDash.brightness_max = ASUSAURARYUOAIOCONTROLLER_BRIGHTNESS_MAX;
FlashAndDash.brightness = ASUSAURARYUOAIOCONTROLLER_BRIGHTNESS_MAX;
FlashAndDash.speed_min = controller->SPEED_SLOWEST;
FlashAndDash.speed_max = controller->SPEED_FASTEST;
FlashAndDash.color_mode = MODE_COLORS_NONE;
FlashAndDash.speed = speed;
modes.push_back(FlashAndDash);
SetupZones();
}
RGBController_AsusAuraRyuoAIO::~RGBController_AsusAuraRyuoAIO()
{
delete controller;
}
void RGBController_AsusAuraRyuoAIO::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_AsusAuraRyuoAIO::ResizeZone(int zone, int new_size)
{
/*---------------------------------------------------------*\
| This device does not support resizing zones |
\*---------------------------------------------------------*/
}
void RGBController_AsusAuraRyuoAIO::DeviceUpdateLEDs()
{
for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
{
UpdateZoneLEDs(zone_idx);
}
}
void RGBController_AsusAuraRyuoAIO::UpdateZoneLEDs(int zone)
{
controller->SetLedsDirect(zones[zone].colors, zones[zone].leds_count);
}
void RGBController_AsusAuraRyuoAIO::UpdateSingleLED(int led)
{
UpdateZoneLEDs(GetLED_Zone(led));
}
void RGBController_AsusAuraRyuoAIO::SetCustomMode()
{
active_mode = 0;
}
void RGBController_AsusAuraRyuoAIO::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_AsusAuraRyuoAIO::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;
}

38
Controllers/AsusAuraUSBController/RGBController_AsusAuraRyuoAIO.h Normal file
View file

@ -0,0 +1,38 @@
/*-------------------------------------------------------------------*\
| RGBController_AsusAuraRyuoAIO.h |
| |
| Driver for the ASUS Aura Ryuo AIO |
| lighting controller |
| |
| Cooper Hall (geobot19 / Geo_bot) 08 Apr 2022 |
| using snipets from Chris M (Dr.No) |
\*-------------------------------------------------------------------*/
#pragma once
#include "LogManager.h"
#include "RGBController.h"
#include "AsusAuraRyuoAIOController.h"
#include <vector>
class RGBController_AsusAuraRyuoAIO : public RGBController
{
public:
RGBController_AsusAuraRyuoAIO(AsusAuraRyuoAIOController* controller_ptr);
~RGBController_AsusAuraRyuoAIO();
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);
AsusAuraRyuoAIOController* controller;
};

4
OpenRGB.pro
View file

@ -259,6 +259,7 @@ HEADERS +=
Controllers/AsusAuraUSBController/AsusAuraMouseController.h \
Controllers/AsusAuraUSBController/AsusAuraMousematController.h \
Controllers/AsusAuraUSBController/AsusAuraMouseDevices.h \
Controllers/AsusAuraUSBController/AsusAuraRyuoAIOController.h \
Controllers/AsusAuraUSBController/AsusAuraStrixEvolveController.h \
Controllers/AsusAuraUSBController/AsusAuraTUFKeyboardController.h \
Controllers/AsusAuraUSBController/AsusAuraTUFKeyboardLayouts.h \
@ -267,6 +268,7 @@ HEADERS +=
Controllers/AsusAuraUSBController/RGBController_AsusAuraMonitor.h \
Controllers/AsusAuraUSBController/RGBController_AsusAuraMouse.h \
Controllers/AsusAuraUSBController/RGBController_AsusAuraMousemat.h \
Controllers/AsusAuraUSBController/RGBController_AsusAuraRyuoAIO.h \
Controllers/AsusAuraUSBController/RGBController_AsusAuraStrixEvolve.h \
Controllers/AsusAuraUSBController/RGBController_AsusAuraTUFKeyboard.h \
Controllers/AsusAuraUSBController/RGBController_AsusAuraUSB.h \
@ -705,6 +707,7 @@ SOURCES +=
Controllers/AsusAuraUSBController/AsusAuraMonitorController.cpp \
Controllers/AsusAuraUSBController/AsusAuraMouseController.cpp \
Controllers/AsusAuraUSBController/AsusAuraMousematController.cpp \
Controllers/AsusAuraUSBController/AsusAuraRyuoAIOController.cpp \
Controllers/AsusAuraUSBController/AsusAuraStrixEvolveController.cpp \
Controllers/AsusAuraUSBController/AsusAuraTUFKeyboardController.cpp \
Controllers/AsusAuraUSBController/AsusAuraUSBControllerDetect.cpp \
@ -713,6 +716,7 @@ SOURCES +=
Controllers/AsusAuraUSBController/RGBController_AsusAuraMonitor.cpp \
Controllers/AsusAuraUSBController/RGBController_AsusAuraMouse.cpp \
Controllers/AsusAuraUSBController/RGBController_AsusAuraMousemat.cpp \
Controllers/AsusAuraUSBController/RGBController_AsusAuraRyuoAIO.cpp \
Controllers/AsusAuraUSBController/RGBController_AsusAuraStrixEvolve.cpp \
Controllers/AsusAuraUSBController/RGBController_AsusAuraTUFKeyboard.cpp \
Controllers/AsusAuraUSBController/RGBController_AsusAuraUSB.cpp \