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

Store name in AsusAuraUSBControllers to avoid setting it in detectors

Browse source
This commit is contained in:
Adam Honse 2025-08-16 18:26:09 -05:00
parent a0726dc065
commit c82a6052a2
40 changed files with 662 additions and 582 deletions
Download patch file Download diff file Expand all files Collapse all files

8
Controllers/AsusAuraUSBController/AsusAuraHeadsetStandController/AsusAuraHeadsetStandController.cpp
View file

@ -13,10 +13,11 @@
#include "AsusAuraHeadsetStandController.h"
#include "StringUtils.h"
AuraHeadsetStandController::AuraHeadsetStandController(hid_device* dev_handle, const char* path)
AuraHeadsetStandController::AuraHeadsetStandController(hid_device* dev_handle, const char* path, std::string dev_name)
{
dev = dev_handle;
location = path;
name = dev_name;
}
AuraHeadsetStandController::~AuraHeadsetStandController()
@ -29,6 +30,11 @@ std::string AuraHeadsetStandController::GetDeviceLocation()
return("HID: " + location);
}
std::string AuraHeadsetStandController::GetName()
{
return(name);
}
std::string AuraHeadsetStandController::GetSerialString()
{
wchar_t serial_string[128];

4
Controllers/AsusAuraUSBController/AsusAuraHeadsetStandController/AsusAuraHeadsetStandController.h
View file

@ -33,10 +33,11 @@ enum
class AuraHeadsetStandController
{
public:
AuraHeadsetStandController(hid_device* dev_handle, const char* path);
AuraHeadsetStandController(hid_device* dev_handle, const char* path, std::string dev_name);
virtual ~AuraHeadsetStandController();
std::string GetDeviceLocation();
std::string GetName();
std::string GetSerialString();
std::string GetVersion();
@ -60,4 +61,5 @@ public:
private:
hid_device* dev;
std::string location;
std::string name;
};

2
Controllers/AsusAuraUSBController/AsusAuraHeadsetStandController/RGBController_AsusAuraHeadsetStand.cpp
View file

@ -26,7 +26,7 @@ RGBController_AuraHeadsetStand::RGBController_AuraHeadsetStand(AuraHeadsetStandC
{
controller = controller_ptr;
name = "ASUS Aura Headset Stand";
name = controller->GetName();
vendor = "ASUS";
type = DEVICE_TYPE_HEADSET_STAND;
description = "ASUS Aura Headset Stand Device";

8
Controllers/AsusAuraUSBController/AsusAuraKeyboardController/AsusAuraKeyboardController.cpp
View file

@ -13,10 +13,11 @@
#include "AsusAuraKeyboardController.h"
#include "StringUtils.h"
AuraKeyboardController::AuraKeyboardController(hid_device* dev_handle, const char* path)
AuraKeyboardController::AuraKeyboardController(hid_device* dev_handle, const char* path, std::string dev_name)
{
dev = dev_handle;
location = path;
name = dev_name;
}
AuraKeyboardController::~AuraKeyboardController()
@ -29,6 +30,11 @@ std::string AuraKeyboardController::GetDeviceLocation()
return("HID: " + location);
}
std::string AuraKeyboardController::GetNameString()
{
return(name);
}
std::string AuraKeyboardController::GetSerialString()
{
wchar_t serial_string[128];

4
Controllers/AsusAuraUSBController/AsusAuraKeyboardController/AsusAuraKeyboardController.h
View file

@ -19,10 +19,11 @@
class AuraKeyboardController
{
public:
AuraKeyboardController(hid_device* dev_handle, const char* path);
AuraKeyboardController(hid_device* dev_handle, const char* path, std::string dev_name);
virtual ~AuraKeyboardController();
std::string GetDeviceLocation();
std::string GetNameString();
std::string GetSerialString();
void SendDirect
@ -34,4 +35,5 @@ public:
private:
hid_device* dev;
std::string location;
std::string name;
};

2
Controllers/AsusAuraUSBController/AsusAuraKeyboardController/RGBController_AsusAuraKeyboard.cpp
View file

@ -361,7 +361,7 @@ RGBController_AuraKeyboard::RGBController_AuraKeyboard(AuraKeyboardController* c
controller = controller_ptr;
layout = keyboard_layout;
name = "ASUS Aura Keyboard";
name = controller->GetNameString();
vendor = "ASUS";
type = DEVICE_TYPE_KEYBOARD;
description = "ASUS Aura Keyboard Device";

8
Controllers/AsusAuraUSBController/AsusAuraMonitorController/AsusAuraMonitorController.cpp
View file

@ -14,11 +14,12 @@
#include "LogManager.h"
#include "StringUtils.h"
AuraMonitorController::AuraMonitorController(hid_device* dev_handle, const char* path, uint16_t pid)
AuraMonitorController::AuraMonitorController(hid_device* dev_handle, const char* path, uint16_t pid, std::string dev_name)
{
dev = dev_handle;
location = path;
device_pid = pid;
name = dev_name;
}
AuraMonitorController::~AuraMonitorController()
@ -31,6 +32,11 @@ std::string AuraMonitorController::GetDeviceLocation()
return("HID: " + location);
}
std::string AuraMonitorController::GetNameString()
{
return(name);
}
std::string AuraMonitorController::GetSerialString()
{
wchar_t serial_string[128];

4
Controllers/AsusAuraUSBController/AsusAuraMonitorController/AsusAuraMonitorController.h
View file

@ -27,10 +27,11 @@ enum
class AuraMonitorController
{
public:
AuraMonitorController(hid_device* dev_handle, const char* path, uint16_t pid);
AuraMonitorController(hid_device* dev_handle, const char* path, uint16_t pid, std::string dev_name);
virtual ~AuraMonitorController();
std::string GetDeviceLocation();
std::string GetNameString();
std::string GetSerialString();
void BeginUpdate();
@ -42,4 +43,5 @@ public:
private:
hid_device* dev;
std::string location;
std::string name;
};

2
Controllers/AsusAuraUSBController/AsusAuraMonitorController/RGBController_AsusAuraMonitor.cpp
View file

@ -26,7 +26,7 @@ RGBController_AuraMonitor::RGBController_AuraMonitor(AuraMonitorController* cont
{
controller = controller_ptr;
name = "ASUS Aura Monitor";
name = controller->GetNameString();
vendor = "ASUS";
type = DEVICE_TYPE_MONITOR;
description = "ASUS Aura Monitor Device";

54
Controllers/AsusAuraUSBController/AsusAuraMouseController/AsusAuraMouseController.cpp
View file

@ -15,11 +15,12 @@
#define HID_MAX_STR 255
AuraMouseController::AuraMouseController(hid_device* dev_handle, const char* path, uint16_t pid)
AuraMouseController::AuraMouseController(hid_device* dev_handle, const char* path, uint16_t pid, std::string dev_name)
{
dev = dev_handle;
location = path;
device_pid = pid;
name = dev_name;
}
AuraMouseController::~AuraMouseController()
@ -32,30 +33,9 @@ std::string AuraMouseController::GetDeviceLocation()
return("HID: " + location);
}
std::string AuraMouseController::CleanSerial(const std::wstring& wstr)
std::string AuraMouseController::GetName()
{
/*---------------------------------------------------------------*\
| Cleans garbage at the end of serial numbers |
| (apparently 2 characters too much, but maybe variable) |
| Limited to new devices, old ones don't even have serial numbers |
\*---------------------------------------------------------------*/
std::string result;
for(wchar_t c : wstr)
{
/*-----------------------------------------------------*\
| Forbid anything besides digits and upper case letters |
\*-----------------------------------------------------*/
bool isUpperCaseLetter = (c >= 64 && c <= 90);
bool isDigit = (c >= 48 && c <= 57);
if(!isUpperCaseLetter && !isDigit)
{
break;
}
result += (char)c;
}
return(result);
return(name);
}
std::string AuraMouseController::GetSerialString()
@ -125,6 +105,32 @@ std::string AuraMouseController::GetVersion(bool wireless, int protocol)
return str;
}
std::string AuraMouseController::CleanSerial(const std::wstring& wstr)
{
/*---------------------------------------------------------------*\
| Cleans garbage at the end of serial numbers |
| (apparently 2 characters too much, but maybe variable) |
| Limited to new devices, old ones don't even have serial numbers |
\*---------------------------------------------------------------*/
std::string result;
for(wchar_t c : wstr)
{
/*-----------------------------------------------------*\
| Forbid anything besides digits and upper case letters |
\*-----------------------------------------------------*/
bool isUpperCaseLetter = (c >= 64 && c <= 90);
bool isDigit = (c >= 48 && c <= 57);
if(!isUpperCaseLetter && !isDigit)
{
break;
}
result += (char)c;
}
return(result);
}
void AuraMouseController::SaveMode()
{
unsigned char usb_save_buf[ASUS_AURA_MOUSE_PACKET_SIZE] = { 0x00, 0x50, 0x03 };

7
Controllers/AsusAuraUSBController/AsusAuraMouseController/AsusAuraMouseController.h
View file

@ -21,14 +21,16 @@
class AuraMouseController
{
public:
AuraMouseController(hid_device* dev_handle, const char* path, uint16_t pid);
AuraMouseController(hid_device* dev_handle, const char* path, uint16_t pid, std::string dev_name);
virtual ~AuraMouseController();
std::string GetDeviceLocation();
std::string CleanSerial(const std::wstring& wstr);
std::string GetName();
std::string GetSerialString();
std::string GetVersion(bool wireless, int protocol);
std::string CleanSerial(const std::wstring& wstr);
void SaveMode();
void SendUpdate
(
@ -52,4 +54,5 @@ public:
private:
hid_device* dev;
std::string location;
std::string name;
};

2
Controllers/AsusAuraUSBController/AsusAuraMouseController/RGBController_AsusAuraMouse.cpp
View file

@ -37,7 +37,7 @@ RGBController_AuraMouse::RGBController_AuraMouse(AuraMouseController* controller
pid = controller->device_pid;
name = "ASUS Aura Mouse";
name = controller->GetName();
vendor = "ASUS";
type = DEVICE_TYPE_MOUSE;
description = "ASUS Aura Mouse Device";

8
Controllers/AsusAuraUSBController/AsusAuraMouseGen1Controller/AsusAuraMouseGen1Controller.cpp
View file

@ -15,11 +15,12 @@
#include "AsusAuraMouseGen1Controller.h"
#include "StringUtils.h"
AsusAuraMouseGen1Controller::AsusAuraMouseGen1Controller(hid_device* dev_handle, const char* path, uint16_t pid)
AsusAuraMouseGen1Controller::AsusAuraMouseGen1Controller(hid_device* dev_handle, const char* path, uint16_t pid, std::string dev_name)
{
dev = dev_handle;
location = path;
device_pid = pid;
name = dev_name;
}
AsusAuraMouseGen1Controller::~AsusAuraMouseGen1Controller()
@ -32,6 +33,11 @@ std::string AsusAuraMouseGen1Controller::GetDeviceLocation()
return("HID: " + location);
}
std::string AsusAuraMouseGen1Controller::GetName()
{
return(name);
}
std::string AsusAuraMouseGen1Controller::GetSerialString()
{
wchar_t serial_string[HID_MAX_STR];

6
Controllers/AsusAuraUSBController/AsusAuraMouseGen1Controller/AsusAuraMouseGen1Controller.h
View file

@ -21,12 +21,14 @@
class AsusAuraMouseGen1Controller
{
public:
AsusAuraMouseGen1Controller(hid_device* dev_handle, const char* path, uint16_t pid);
AsusAuraMouseGen1Controller(hid_device* dev_handle, const char* path, uint16_t pid, std::string dev_name);
virtual ~AsusAuraMouseGen1Controller();
std::string GetDeviceLocation();
std::string GetName();
std::string GetSerialString();
std::string GetVersion();
int GetActiveProfile();
void SendUpdate
@ -41,6 +43,7 @@ public:
unsigned char profile,
unsigned char value
);
void SendDirectSpatha(std::vector<RGBColor> colors);
void ResetToSavedLighting();
@ -50,4 +53,5 @@ public:
private:
hid_device* dev;
std::string location;
std::string name;
};

2
Controllers/AsusAuraUSBController/AsusAuraMouseGen1Controller/RGBController_AsusROGSpatha.cpp
View file

@ -30,7 +30,7 @@ RGBController_AsusROGSpatha::RGBController_AsusROGSpatha(AsusAuraMouseGen1Contro
{
controller = controller_ptr;
name = "ASUS ROG Spatha";
name = controller->GetName();
vendor = "ASUS";
type = DEVICE_TYPE_MOUSE;
description = "ASUS Aura Mouse Device";

2
Controllers/AsusAuraUSBController/AsusAuraMouseGen1Controller/RGBController_AsusROGStrixEvolve.cpp
View file

@ -26,7 +26,7 @@ RGBController_AsusROGStrixEvolve::RGBController_AsusROGStrixEvolve(AsusAuraMouse
{
controller = controller_ptr;
name = "ASUS ROG Strix Evolve";
name = controller->GetName();
vendor = "ASUS";
type = DEVICE_TYPE_MOUSE;
description = "ASUS Aura Mouse Device";

8
Controllers/AsusAuraUSBController/AsusAuraMousematController/AsusAuraMousematController.cpp
View file

@ -13,10 +13,11 @@
#include "AsusAuraMousematController.h"
#include "StringUtils.h"
AuraMousematController::AuraMousematController(hid_device* dev_handle, const char* path)
AuraMousematController::AuraMousematController(hid_device* dev_handle, const char* path, std::string dev_name)
{
dev = dev_handle;
location = path;
name = dev_name;
}
AuraMousematController::~AuraMousematController()
@ -29,6 +30,11 @@ std::string AuraMousematController::GetDeviceLocation()
return("HID: " + location);
}
std::string AuraMousematController::GetName()
{
return(name);
}
std::string AuraMousematController::GetSerialString()
{
wchar_t serial_string[128];

4
Controllers/AsusAuraUSBController/AsusAuraMousematController/AsusAuraMousematController.h
View file

@ -31,10 +31,11 @@ enum
class AuraMousematController
{
public:
AuraMousematController(hid_device* dev_handle, const char* path);
AuraMousematController(hid_device* dev_handle, const char* path, std::string dev_name);
virtual ~AuraMousematController();
std::string GetDeviceLocation();
std::string GetName();
std::string GetSerialString();
std::string GetVersion();
@ -57,4 +58,5 @@ public:
private:
hid_device* dev;
std::string location;
std::string name;
};

2
Controllers/AsusAuraUSBController/AsusAuraMousematController/RGBController_AsusAuraMousemat.cpp
View file

@ -26,7 +26,7 @@ RGBController_AuraMousemat::RGBController_AuraMousemat(AuraMousematController* c
{
controller = controller_ptr;
name = "ASUS Aura Mousemat";
name = controller->GetName();
vendor = "ASUS";
type = DEVICE_TYPE_MOUSEMAT;
description = "ASUS Aura Mousemat Device";

2
Controllers/AsusAuraUSBController/AsusAuraRyuoAIOController/AsusAuraRyuoAIOController.cpp
View file

@ -12,7 +12,7 @@
#include "AsusAuraRyuoAIOController.h"
AsusAuraRyuoAIOController::AsusAuraRyuoAIOController(hid_device* dev_handle, const char* path) : AuraUSBController(dev_handle, path)
AsusAuraRyuoAIOController::AsusAuraRyuoAIOController(hid_device* dev_handle, const char* path, std::string dev_name) : AuraUSBController(dev_handle, path, dev_name)
{
/*-----------------------------------------------------*\
| Add addressable devices |

2
Controllers/AsusAuraUSBController/AsusAuraRyuoAIOController/AsusAuraRyuoAIOController.h
View file

@ -60,7 +60,7 @@ public:
SPEED_FASTEST = 0x00, // Fastest speed
};
AsusAuraRyuoAIOController(hid_device* dev_handle, const char* path);
AsusAuraRyuoAIOController(hid_device* dev_handle, const char* path, std::string dev_name);
~AsusAuraRyuoAIOController();
std::string GetLocation();

2
Controllers/AsusAuraUSBController/AsusAuraRyuoAIOController/RGBController_AsusAuraRyuoAIO.cpp
View file

@ -29,7 +29,7 @@ RGBController_AsusAuraRyuoAIO::RGBController_AsusAuraRyuoAIO(AsusAuraRyuoAIOCont
controller = controller_ptr;
uint8_t speed = controller->SPEED_NORMAL;
name = "ROG Ryuo AIO";
name = controller->GetDeviceName();
vendor = "ASUS";
type = DEVICE_TYPE_COOLER;
description = "ASUS Liquid Cooler with 120mm and 240mm radiators.";

8
Controllers/AsusAuraUSBController/AsusAuraTUFKeyboardController/AsusAuraTUFKeyboardController.cpp
View file

@ -21,10 +21,11 @@
#define HID_MAX_STR 128
AuraTUFKeyboardController::AuraTUFKeyboardController(hid_device* dev_handle, const char* path, uint16_t pid, unsigned short version)
AuraTUFKeyboardController::AuraTUFKeyboardController(hid_device* dev_handle, const char* path, uint16_t pid, unsigned short version, std::string dev_name)
{
dev = dev_handle;
location = path;
name = dev_name;
device_pid = pid;
rev_version = version;
@ -41,6 +42,11 @@ std::string AuraTUFKeyboardController::GetDeviceLocation()
return("HID: " + location);
}
std::string AuraTUFKeyboardController::GetName()
{
return(name);
}
std::string AuraTUFKeyboardController::GetSerialString()
{
wchar_t serial_string[HID_MAX_STR];

6
Controllers/AsusAuraUSBController/AsusAuraTUFKeyboardController/AsusAuraTUFKeyboardController.h
View file

@ -67,12 +67,14 @@ struct led_color
class AuraTUFKeyboardController
{
public:
AuraTUFKeyboardController(hid_device* dev_handle, const char* path, uint16_t pid, unsigned short version);
AuraTUFKeyboardController(hid_device* dev_handle, const char* path, uint16_t pid, unsigned short version, std::string dev_name);
~AuraTUFKeyboardController();
std::string GetDeviceLocation();
std::string GetName();
std::string GetSerialString();
std::string GetVersion();
int GetLayout();
int GetNumpadLocation();
void SaveMode();
@ -127,6 +129,7 @@ public:
unsigned char speed,
unsigned char brightness
);
void UpdateQuicksandColors(std::vector<RGBColor> colors);
void UpdateMode(unsigned char mode);
void AwaitResponse(int ms);
@ -138,6 +141,7 @@ public:
private:
hid_device* dev;
std::string location;
std::string name;
unsigned short rev_version;
};

20
Controllers/AsusAuraUSBController/AsusAuraTUFKeyboardController/RGBController_AsusAuraTUFKeyboard.cpp
View file

@ -32,7 +32,7 @@ RGBController_AuraTUFKeyboard::RGBController_AuraTUFKeyboard(AuraTUFKeyboardCont
if(pid != AURA_ROG_CLAYMORE_PID)
{
name = "ASUS Aura Keyboard";
name = controller->GetName();
vendor = "ASUS";
type = DEVICE_TYPE_KEYBOARD;
description = "ASUS Aura Keyboard Device";
@ -51,6 +51,7 @@ RGBController_AuraTUFKeyboard::RGBController_AuraTUFKeyboard(AuraTUFKeyboardCont
AURA_KEYBOARD_SPEED_MAX = 2;
AURA_KEYBOARD_SPEED_DEFAULT = 1;
break;
case AURA_ROG_STRIX_FLARE_PID:
case AURA_ROG_STRIX_FLARE_PNK_LTD_PID:
case AURA_ROG_STRIX_FLARE_COD_BO4_PID:
@ -60,6 +61,7 @@ RGBController_AuraTUFKeyboard::RGBController_AuraTUFKeyboard(AuraTUFKeyboardCont
AURA_KEYBOARD_SPEED_MAX = 0;
AURA_KEYBOARD_SPEED_DEFAULT = 8;
break;
case AURA_ROG_AZOTH_USB_PID:
case AURA_ROG_AZOTH_2_4_PID:
case AURA_ROG_FALCHION_WIRED_PID:
@ -79,10 +81,12 @@ RGBController_AuraTUFKeyboard::RGBController_AuraTUFKeyboard(AuraTUFKeyboardCont
AURA_KEYBOARD_SPEED_MAX = 0;
AURA_KEYBOARD_SPEED_DEFAULT = 30;
break;
default:
AURA_KEYBOARD_SPEED_MIN = 15;
AURA_KEYBOARD_SPEED_MAX = 0;
AURA_KEYBOARD_SPEED_DEFAULT = 8;
break;
}
mode Direct;
@ -109,8 +113,10 @@ RGBController_AuraTUFKeyboard::RGBController_AuraTUFKeyboard(AuraTUFKeyboardCont
Breathing.name = "Breathing";
Breathing.value = AURA_KEYBOARD_MODE_BREATHING;
Breathing.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
if(controller->is_per_led_keyboard) Breathing.flags |= MODE_FLAG_HAS_RANDOM_COLOR;
if(controller->is_per_led_keyboard)
{
Breathing.flags |= MODE_FLAG_HAS_RANDOM_COLOR;
}
Breathing.speed_min = AURA_KEYBOARD_SPEED_MIN;
Breathing.speed_max = AURA_KEYBOARD_SPEED_MAX;
Breathing.speed = AURA_KEYBOARD_SPEED_DEFAULT;
@ -140,8 +146,10 @@ RGBController_AuraTUFKeyboard::RGBController_AuraTUFKeyboard(AuraTUFKeyboardCont
Wave.name = "Rainbow Wave";
Wave.value = AURA_KEYBOARD_MODE_WAVE;
Wave.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_DIRECTION_HV | MODE_FLAG_MANUAL_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
if(controller->is_per_led_keyboard) Wave.flags |= MODE_FLAG_HAS_DIRECTION_UD;
if(controller->is_per_led_keyboard)
{
Wave.flags |= MODE_FLAG_HAS_DIRECTION_UD;
}
Wave.speed_min = AURA_KEYBOARD_SPEED_MIN;
Wave.speed_max = AURA_KEYBOARD_SPEED_MAX;
Wave.speed = AURA_KEYBOARD_SPEED_DEFAULT;
@ -268,7 +276,7 @@ RGBController_AuraTUFKeyboard::RGBController_AuraTUFKeyboard(AuraTUFKeyboardCont
else
{
name = "ASUS ROG Claymore";
name = controller->GetName();
vendor = "ASUS";
type = DEVICE_TYPE_KEYBOARD;
description = "ASUS Aura Keyboard Device";

2
Controllers/AsusAuraUSBController/AsusAuraUSBController/AsusAuraAddressableController.cpp
View file

@ -12,7 +12,7 @@
#include <cstring>
#include "AsusAuraAddressableController.h"
AuraAddressableController::AuraAddressableController(hid_device* dev_handle, const char* path) : AuraUSBController(dev_handle, path)
AuraAddressableController::AuraAddressableController(hid_device* dev_handle, const char* path, std::string dev_name) : AuraUSBController(dev_handle, path, dev_name)
{
/*-----------------------------------------------------*\
| Add addressable devices |

2
Controllers/AsusAuraUSBController/AsusAuraUSBController/AsusAuraAddressableController.h
View file

@ -24,7 +24,7 @@ enum
class AuraAddressableController : public AuraUSBController
{
public:
AuraAddressableController(hid_device* dev_handle, const char* path);
AuraAddressableController(hid_device* dev_handle, const char* path, std::string dev_name);
~AuraAddressableController();
void SetChannelLEDs

2
Controllers/AsusAuraUSBController/AsusAuraUSBController/AsusAuraMainboardController.cpp
View file

@ -12,7 +12,7 @@
#include <cstring>
#include "AsusAuraMainboardController.h"
AuraMainboardController::AuraMainboardController(hid_device* dev_handle, const char* path) : AuraUSBController(dev_handle, path), mode(AURA_MODE_DIRECT)
AuraMainboardController::AuraMainboardController(hid_device* dev_handle, const char* path, std::string dev_name) : AuraUSBController(dev_handle, path, dev_name), mode(AURA_MODE_DIRECT)
{
unsigned char num_total_mainboard_leds = config_table[0x1B];
unsigned char num_rgb_headers = config_table[0x1D];

2
Controllers/AsusAuraUSBController/AsusAuraUSBController/AsusAuraMainboardController.h
View file

@ -26,7 +26,7 @@ enum
class AuraMainboardController : public AuraUSBController
{
public:
AuraMainboardController(hid_device* dev_handle, const char* path);
AuraMainboardController(hid_device* dev_handle, const char* path, std::string dev_name);
~AuraMainboardController();
void SetChannelLEDs

18
Controllers/AsusAuraUSBController/AsusAuraUSBController/AsusAuraUSBController.cpp
View file

@ -14,10 +14,11 @@
#include "LogManager.h"
#include "StringUtils.h"
AuraUSBController::AuraUSBController(hid_device* dev_handle, const char* path)
AuraUSBController::AuraUSBController(hid_device* dev_handle, const char* path, std::string dev_name)
{
dev = dev_handle;
location = path;
name = dev_name;
GetFirmwareVersion();
GetConfigTable();
@ -40,7 +41,7 @@ std::string AuraUSBController::GetDeviceLocation()
std::string AuraUSBController::GetDeviceName()
{
return(device_name);
return(name);
}
std::string AuraUSBController::GetSerialString()
@ -56,6 +57,11 @@ std::string AuraUSBController::GetSerialString()
return(StringUtils::wstring_to_string(serial_string));
}
std::string AuraUSBController::GetDeviceVersion()
{
return(std::string(version));
}
const std::vector<AuraDeviceInfo>& AuraUSBController::GetAuraDevices() const
{
return(device_info);
@ -89,11 +95,11 @@ void AuraUSBController::GetConfigTable()
{
memcpy(config_table, &usb_buf[4], 60);
LOG_DEBUG("[%s] ASUS Aura USB config table:", device_name);
LOG_DEBUG("[%s] ASUS Aura USB config table:", version);
for(int i = 0; i < 60; i+=6)
{
LOG_DEBUG("[%s] %02X %02X %02X %02X %02X %02X", device_name,
LOG_DEBUG("[%s] %02X %02X %02X %02X %02X %02X", version,
config_table[i + 0],
config_table[i + 1],
config_table[i + 2],
@ -104,7 +110,7 @@ void AuraUSBController::GetConfigTable()
}
else
{
LOG_INFO("[%s] Could not read config table, can not add device", device_name);
LOG_INFO("[%s] Could not read config table, can not add device", version);
delete this;
}
}
@ -135,7 +141,7 @@ void AuraUSBController::GetFirmwareVersion()
\*-----------------------------------------------------*/
if(usb_buf[1] == 0x02)
{
memcpy(device_name, &usb_buf[2], 16);
memcpy(version, &usb_buf[2], 16);
}
}

9
Controllers/AsusAuraUSBController/AsusAuraUSBController/AsusAuraUSBController.h
View file

@ -64,7 +64,7 @@ struct AuraDeviceInfo
class AuraUSBController
{
public:
AuraUSBController(hid_device* dev_handle, const char* path);
AuraUSBController(hid_device* dev_handle, const char* path, std::string dev_name);
virtual ~AuraUSBController();
unsigned int GetChannelCount();
@ -72,6 +72,7 @@ public:
std::string GetDeviceLocation();
std::string GetDeviceName();
std::string GetSerialString();
std::string GetDeviceVersion();
const std::vector<AuraDeviceInfo>& GetAuraDevices() const;
@ -96,6 +97,8 @@ protected:
unsigned char config_table[60];
std::vector<AuraDeviceInfo> device_info;
std::string location;
std::string name;
char version[16];
void SendDirect
(
@ -103,10 +106,8 @@ protected:
unsigned char led_count,
RGBColor * colors
);
private:
char device_name[16];
void GetConfigTable();
void GetFirmwareVersion();
};

1
Controllers/AsusAuraUSBController/AsusAuraUSBController/RGBController_AsusAuraMainboard.cpp
View file

@ -26,7 +26,6 @@
RGBController_AuraMainboard::RGBController_AuraMainboard(AuraMainboardController* controller_ptr) :
RGBController_AuraUSB(controller_ptr)
{
name = "ASUS Aura USB Mainboard";
description = "ASUS Aura USB Mainboard Device";
/*-------------------------------------------------------*\

4
Controllers/AsusAuraUSBController/AsusAuraUSBController/RGBController_AsusAuraUSB.cpp
View file

@ -28,13 +28,13 @@ RGBController_AuraUSB::RGBController_AuraUSB(AuraUSBController* controller_ptr)
{
controller = controller_ptr;
name = "ASUS Aura USB";
name = controller->GetDeviceName();
vendor = "ASUS";
version = controller->GetDeviceName();
type = DEVICE_TYPE_MOTHERBOARD;
description = "ASUS Aura USB Device";
location = controller->GetDeviceLocation();
serial = controller->GetSerialString();
version = controller->GetDeviceVersion();
mode Direct;
Direct.name = "Direct";

61
Controllers/AsusAuraUSBController/AsusAuraUSBControllerDetect.cpp
View file

@ -83,7 +83,6 @@
/*-----------------------------------------------------------------*\
| MICE - defined in AsusAuraMouseDevices.h |
\*-----------------------------------------------------------------*/
#define AURA_ROG_STRIX_EVOLVE_PID 0x185B
#define AURA_ROG_SPATHA_WIRED_PID 0x181C
#define AURA_ROG_SPATHA_WIRELESS_PID 0x1824
@ -97,7 +96,6 @@
/*-----------------------------------------------------------------*\
| MONITORS |
\*-----------------------------------------------------------------*/
#define AURA_ROG_STRIX_XG27AQ_PID 0x198C
#define AURA_ROG_STRIX_XG27AQM_PID 0x19BB
#define AURA_ROG_STRIX_XG279Q_PID 0x1919
@ -106,9 +104,8 @@
#define AURA_ROG_PG32UQ_PID 0x19B9
/*-----------------------------------------------------------------*\
| HEADSETSTANDS |
| HEADSET STANDS |
\*-----------------------------------------------------------------*/
#define AURA_ROG_THRONE_PID 0x18D9
#define AURA_ROG_THRONE_QI_PID 0x18C5
#define AURA_ROG_THRONE_QI_GUNDAM_PID 0x1994
@ -148,9 +145,9 @@ void DetectAsusAuraUSBTerminal(hid_device_info* info, const std::string& name)
if(dev)
{
AuraAddressableController* controller = new AuraAddressableController(dev, info->path);
AuraAddressableController* controller = new AuraAddressableController(dev, info->path, name);
RGBController_AuraUSB* rgb_controller = new RGBController_AuraUSB(controller);
rgb_controller->name = name;
ResourceManager::get()->RegisterRGBController(rgb_controller);
}
}
@ -162,9 +159,9 @@ void DetectAsusAuraUSBAddressable(hid_device_info* info, const std::string& /*na
if(dev)
{
DMIInfo dmi;
AuraAddressableController* controller = new AuraAddressableController(dev, info->path);
AuraAddressableController* controller = new AuraAddressableController(dev, info->path, "ASUS " + dmi.getMainboard() + " Addressable");
RGBController_AuraUSB* rgb_controller = new RGBController_AuraUSB(controller);
rgb_controller->name = "ASUS " + dmi.getMainboard() + " Addressable";
ResourceManager::get()->RegisterRGBController(rgb_controller);
}
}
@ -178,9 +175,9 @@ void DetectAsusAuraUSBMotherboards(hid_device_info* info, const std::string& /*n
try
{
DMIInfo dmi;
AuraMainboardController* controller = new AuraMainboardController(dev, info->path);
AuraMainboardController* controller = new AuraMainboardController(dev, info->path, "ASUS " + dmi.getMainboard());
RGBController_AuraMainboard* rgb_controller = new RGBController_AuraMainboard(controller);
rgb_controller->name = "ASUS " + dmi.getMainboard();
ResourceManager::get()->RegisterRGBController(rgb_controller);
}
catch(const std::runtime_error& ex)
@ -197,10 +194,10 @@ void DetectAsusAuraUSBKeyboards(hid_device_info* info, const std::string& name)
if(dev)
{
AuraKeyboardController* controller = new AuraKeyboardController(dev, info->path);
AuraKeyboardController* controller = new AuraKeyboardController(dev, info->path, name);
AuraKeyboardMappingLayoutType layout = GetKeyboardMappingLayoutType(info->product_id);
RGBController_AuraKeyboard* rgb_controller = new RGBController_AuraKeyboard(controller, layout);
rgb_controller->name = name;
ResourceManager::get()->RegisterRGBController(rgb_controller);
}
}
@ -212,9 +209,9 @@ void DetectAsusAuraUSBMice(hid_device_info* info, const std::string& name)
if(dev)
{
uint16_t pid = (name == "Asus ROG Spatha X Dock") ? AURA_ROG_SPATHA_X_DOCK_FAKE_PID : info->product_id;
AuraMouseController* controller = new AuraMouseController(dev, info->path, pid);
AuraMouseController* controller = new AuraMouseController(dev, info->path, pid, name);
RGBController_AuraMouse* rgb_controller = new RGBController_AuraMouse(controller);
rgb_controller->name = name;
ResourceManager::get()->RegisterRGBController(rgb_controller);
}
}
@ -225,9 +222,9 @@ void DetectAsusAuraUSBMousemats(hid_device_info* info, const std::string& name)
if(dev)
{
AuraMousematController* controller = new AuraMousematController(dev, info->path);
AuraMousematController* controller = new AuraMousematController(dev, info->path, name);
RGBController_AuraMousemat* rgb_controller = new RGBController_AuraMousemat(controller);
rgb_controller->name = name;
ResourceManager::get()->RegisterRGBController(rgb_controller);
}
}
@ -238,9 +235,9 @@ void DetectAsusAuraUSBROGStrixLC(hid_device_info* info, const std::string& name)
if(dev)
{
AsusROGStrixLCController* controller = new AsusROGStrixLCController(dev, info->path);
AsusROGStrixLCController* controller = new AsusROGStrixLCController(dev, info->path, name);
RGBController_AsusROGStrixLC* rgb_controller = new RGBController_AsusROGStrixLC(controller);
rgb_controller->name = name;
ResourceManager::get()->RegisterRGBController(rgb_controller);
}
}
@ -251,9 +248,9 @@ void DetectAsusAuraUSBRyuoAIO(hid_device_info* info, const std::string& name)
if(dev)
{
AsusAuraRyuoAIOController* controller = new AsusAuraRyuoAIOController(dev, info->path);
AsusAuraRyuoAIOController* controller = new AsusAuraRyuoAIOController(dev, info->path, name);
RGBController_AsusAuraRyuoAIO* rgb_controller = new RGBController_AsusAuraRyuoAIO(controller);
rgb_controller->name = name;
ResourceManager::get()->RegisterRGBController(rgb_controller);
}
}
@ -264,9 +261,9 @@ void DetectAsusAuraUSBStrixEvolve(hid_device_info* info, const std::string& name
if(dev)
{
AsusAuraMouseGen1Controller* controller = new AsusAuraMouseGen1Controller(dev, info->path, info->product_id);
AsusAuraMouseGen1Controller* controller = new AsusAuraMouseGen1Controller(dev, info->path, info->product_id, name);
RGBController_AsusROGStrixEvolve* rgb_controller = new RGBController_AsusROGStrixEvolve(controller);
rgb_controller->name = name;
ResourceManager::get()->RegisterRGBController(rgb_controller);
}
}
@ -277,9 +274,9 @@ void DetectAsusAuraUSBSpatha(hid_device_info* info, const std::string& name)
if(dev)
{
AsusAuraMouseGen1Controller* controller = new AsusAuraMouseGen1Controller(dev, info->path, info->product_id);
AsusAuraMouseGen1Controller* controller = new AsusAuraMouseGen1Controller(dev, info->path, info->product_id, name);
RGBController_AsusROGSpatha* rgb_controller = new RGBController_AsusROGSpatha(controller);
rgb_controller->name = name;
ResourceManager::get()->RegisterRGBController(rgb_controller);
}
}
@ -290,9 +287,9 @@ void DetectAsusAuraUSBHeadsetStand(hid_device_info* info, const std::string& nam
if(dev)
{
AuraHeadsetStandController* controller = new AuraHeadsetStandController(dev, info->path);
AuraHeadsetStandController* controller = new AuraHeadsetStandController(dev, info->path, name);
RGBController_AuraHeadsetStand* rgb_controller = new RGBController_AuraHeadsetStand(controller);
rgb_controller->name = name;
ResourceManager::get()->RegisterRGBController(rgb_controller);
}
}
@ -303,9 +300,9 @@ void DetectAsusAuraTUFUSBKeyboard(hid_device_info* info, const std::string& name
if(dev)
{
AuraTUFKeyboardController* controller = new AuraTUFKeyboardController(dev, info->path, info->product_id, info->release_number);
AuraTUFKeyboardController* controller = new AuraTUFKeyboardController(dev, info->path, info->product_id, info->release_number, name);
RGBController_AuraTUFKeyboard* rgb_controller = new RGBController_AuraTUFKeyboard(controller);
rgb_controller->name = name;
ResourceManager::get()->RegisterRGBController(rgb_controller);
}
}
@ -316,9 +313,9 @@ void DetectAsusAuraUSBMonitor(hid_device_info* info, const std::string& name)
if(dev)
{
AuraMonitorController* controller = new AuraMonitorController(dev, info->path, info->product_id);
AuraMonitorController* controller = new AuraMonitorController(dev, info->path, info->product_id, name);
RGBController_AuraMonitor* rgb_controller = new RGBController_AuraMonitor(controller);
rgb_controller->name = name;
ResourceManager::get()->RegisterRGBController(rgb_controller);
}
}
@ -329,9 +326,9 @@ void DetectAsusROGAlly(hid_device_info* info, const std::string& name)
if(dev)
{
ROGAllyController* controller = new ROGAllyController(dev, info->path);
ROGAllyController* controller = new ROGAllyController(dev, info->path, name);
RGBController_AsusROGAlly* rgb_controller = new RGBController_AsusROGAlly(controller);
rgb_controller->name = name;
ResourceManager::get()->RegisterRGBController(rgb_controller);
}
}

8
Controllers/AsusAuraUSBController/AsusROGAllyController/AsusROGAllyController.cpp
View file

@ -13,10 +13,11 @@
#include "AsusROGAllyController.h"
#include "StringUtils.h"
ROGAllyController::ROGAllyController(hid_device* dev_handle, const char* path)
ROGAllyController::ROGAllyController(hid_device* dev_handle, const char* path, std::string dev_name)
{
dev = dev_handle;
location = path;
name = dev_name;
SendInitialization();
}
@ -31,6 +32,11 @@ std::string ROGAllyController::GetDeviceLocation()
return("HID: " + location);
}
std::string ROGAllyController::GetName()
{
return(name);
}
std::string ROGAllyController::GetSerialString()
{
wchar_t serial_string[128];

4
Controllers/AsusAuraUSBController/AsusROGAllyController/AsusROGAllyController.h
View file

@ -40,10 +40,11 @@ enum
class ROGAllyController
{
public:
ROGAllyController(hid_device* dev_handle, const char* path);
ROGAllyController(hid_device* dev_handle, const char* path, std::string dev_name);
virtual ~ROGAllyController();
std::string GetDeviceLocation();
std::string GetName();
std::string GetSerialString();
std::string GetVersion();
@ -72,4 +73,5 @@ public:
private:
hid_device* dev;
std::string location;
std::string name;
};

2
Controllers/AsusAuraUSBController/AsusROGAllyController/RGBController_AsusROGAlly.cpp
View file

@ -26,7 +26,7 @@ RGBController_AsusROGAlly::RGBController_AsusROGAlly(ROGAllyController* controll
{
controller = controller_ptr;
name = "ASUS ROG Ally";
name = controller->GetName();
vendor = "ASUS";
type = DEVICE_TYPE_GAMEPAD;
description = "ASUS ROG Ally Device";

2
Controllers/AsusAuraUSBController/AsusROGStrixLCController/AsusROGStrixLCController.cpp
View file

@ -11,7 +11,7 @@
#include "AsusROGStrixLCController.h"
AsusROGStrixLCController::AsusROGStrixLCController(hid_device* dev_handle, const char* path) : AuraUSBController(dev_handle, path)
AsusROGStrixLCController::AsusROGStrixLCController(hid_device* dev_handle, const char* path, std::string dev_name) : AuraUSBController(dev_handle, path, dev_name)
{
/*-----------------------------------------------------*\
| Add addressable devices |

2
Controllers/AsusAuraUSBController/AsusROGStrixLCController/AsusROGStrixLCController.h
View file

@ -58,7 +58,7 @@ enum
class AsusROGStrixLCController : public AuraUSBController
{
public:
AsusROGStrixLCController(hid_device* dev_handle, const char* path);
AsusROGStrixLCController(hid_device* dev_handle, const char* path, std::string dev_name);
~AsusROGStrixLCController();
std::string GetLocation();

2
Controllers/AsusAuraUSBController/AsusROGStrixLCController/RGBController_AsusROGStrixLC.cpp
View file

@ -28,7 +28,7 @@ RGBController_AsusROGStrixLC::RGBController_AsusROGStrixLC(AsusROGStrixLCControl
controller = controller_ptr;
uint8_t speed = ROGSTRIXLC_CONTROLLER_SPEED_NORMAL;
name = "ROG Strix LC";
name = controller->GetDeviceName();
vendor = "ASUS";
type = DEVICE_TYPE_COOLER;
description = "ASUS Liquid Cooler including 120mm, 140mm, 240mm, 280mm and 360mm radiators.";