diff --git a/Controllers/AuraAddressableController/AuraAddressableControllerDetect.cpp b/Controllers/AuraAddressableController/AuraAddressableControllerDetect.cpp deleted file mode 100644 index 43ce4902..00000000 --- a/Controllers/AuraAddressableController/AuraAddressableControllerDetect.cpp +++ /dev/null @@ -1,47 +0,0 @@ -#include "AuraAddressableController.h" -#include "RGBController.h" -#include "RGBController_AuraAddressable.h" -#include -#include - -#define AURA_ADDRESSABLE_VID 0x0B05 - -#define NUM_PIDS 4 -static const unsigned short pid_table[] = - { - 0x1867, - 0x1872, - 0x1889, - 0x18A3 - }; - -/******************************************************************************************\ -* * -* DetectAuraAddressableControllers * -* * -* Tests the USB address to see if an Asus Aura addressable RGB header controller * -* exists there. * -* * -\******************************************************************************************/ - -void DetectAuraAddressableControllers(std::vector& rgb_controllers) -{ - hid_device* dev; - - //Look for Asus Aura addressable RGB header controller - hid_init(); - - for(int pid_idx = 0; pid_idx < NUM_PIDS; pid_idx++) - { - dev = hid_open(AURA_ADDRESSABLE_VID, pid_table[pid_idx], 0); - - if( dev ) - { - AuraAddressableController* controller = new AuraAddressableController(dev); - - RGBController_AuraAddressable* rgb_controller = new RGBController_AuraAddressable(controller); - - rgb_controllers.push_back(rgb_controller); - } - } -} diff --git a/Controllers/AuraAddressableController/AuraAddressableController.cpp b/Controllers/AuraUSBController/AuraAddressableController.cpp similarity index 61% rename from Controllers/AuraAddressableController/AuraAddressableController.cpp rename to Controllers/AuraUSBController/AuraAddressableController.cpp index f7317d25..bc2b1ea6 100644 --- a/Controllers/AuraAddressableController/AuraAddressableController.cpp +++ b/Controllers/AuraUSBController/AuraAddressableController.cpp @@ -10,23 +10,8 @@ #include "AuraAddressableController.h" #include -#ifdef WIN32 -#include -#else -#include - -static void Sleep(unsigned int milliseconds) +AuraAddressableController::AuraAddressableController(hid_device* dev_handle) : AuraUSBController(dev_handle) { - usleep(1000 * milliseconds); -} -#endif - -AuraAddressableController::AuraAddressableController(hid_device* dev_handle) -{ - dev = dev_handle; - - GetFirmwareVersion(); - GetConfigTable(); } AuraAddressableController::~AuraAddressableController() @@ -34,16 +19,6 @@ AuraAddressableController::~AuraAddressableController() } -unsigned int AuraAddressableController::GetChannelCount() -{ - return( 5 ); -} - -std::string AuraAddressableController::GetDeviceName() -{ - return(device_name); -} - void AuraAddressableController::SetChannelLEDs(unsigned char channel, RGBColor * colors, unsigned int num_colors) { unsigned char led_data[60]; @@ -100,76 +75,6 @@ void AuraAddressableController::SetMode } } -void AuraAddressableController::GetConfigTable() -{ - unsigned char usb_buf[65]; - - /*-----------------------------------------------------*\ - | Zero out buffer | - \*-----------------------------------------------------*/ - memset(usb_buf, 0x00, sizeof(usb_buf)); - - /*-----------------------------------------------------*\ - | Set up config table request packet | - \*-----------------------------------------------------*/ - usb_buf[0x00] = 0xEC; - usb_buf[0x01] = AURA_REQUEST_CONFIG_TABLE; - - /*-----------------------------------------------------*\ - | Send packet | - \*-----------------------------------------------------*/ - hid_write(dev, usb_buf, 65); - hid_read(dev, usb_buf, 65); - - /*-----------------------------------------------------*\ - | Copy the firmware string if the reply ID is correct | - \*-----------------------------------------------------*/ - if(usb_buf[1] == 0x30) - { - memcpy(config_table, &usb_buf[4], 60); - - for(int i = 0; i < 60; i+=6) - { - printf("%02X %02X %02X %02X %02X %02X\r\n", config_table[i + 0], - config_table[i + 1], - config_table[i + 2], - config_table[i + 3], - config_table[i + 4], - config_table[i + 5]); - } - } -} - -void AuraAddressableController::GetFirmwareVersion() -{ - unsigned char usb_buf[65]; - - /*-----------------------------------------------------*\ - | Zero out buffer | - \*-----------------------------------------------------*/ - memset(usb_buf, 0x00, sizeof(usb_buf)); - - /*-----------------------------------------------------*\ - | Set up firmware version request packet | - \*-----------------------------------------------------*/ - usb_buf[0x00] = 0xEC; - usb_buf[0x01] = AURA_REQUEST_FIRMWARE_VERSION; - - /*-----------------------------------------------------*\ - | Send packet | - \*-----------------------------------------------------*/ - hid_write(dev, usb_buf, 65); - hid_read(dev, usb_buf, 65); - - /*-----------------------------------------------------*\ - | Copy the firmware string if the reply ID is correct | - \*-----------------------------------------------------*/ - if(usb_buf[1] == 0x02) - { - memcpy(device_name, &usb_buf[2], 16); - } -} - void AuraAddressableController::SendEffect ( unsigned char channel, @@ -190,7 +95,7 @@ void AuraAddressableController::SendEffect | Set up message packet | \*-----------------------------------------------------*/ usb_buf[0x00] = 0xEC; - usb_buf[0x01] = AURA_CONTROL_MODE_EFFECT; + usb_buf[0x01] = AURA_ADDRESSABLE_CONTROL_MODE_EFFECT; usb_buf[0x02] = channel; usb_buf[0x03] = 0x00; usb_buf[0x04] = mode; @@ -227,7 +132,7 @@ void AuraAddressableController::SendDirect | Set up message packet | \*-----------------------------------------------------*/ usb_buf[0x00] = 0xEC; - usb_buf[0x01] = AURA_CONTROL_MODE_DIRECT; + usb_buf[0x01] = AURA_ADDRESSABLE_CONTROL_MODE_DIRECT; usb_buf[0x02] = device; usb_buf[0x03] = start_led; usb_buf[0x04] = led_count; @@ -259,7 +164,7 @@ void AuraAddressableController::SendDirectApply | Set up message packet | \*-----------------------------------------------------*/ usb_buf[0x00] = 0xEC; - usb_buf[0x01] = AURA_CONTROL_MODE_DIRECT; + usb_buf[0x01] = AURA_ADDRESSABLE_CONTROL_MODE_DIRECT; usb_buf[0x02] = 0x80 | channel; /*-----------------------------------------------------*\ diff --git a/Controllers/AuraUSBController/AuraAddressableController.h b/Controllers/AuraUSBController/AuraAddressableController.h new file mode 100644 index 00000000..1acede8d --- /dev/null +++ b/Controllers/AuraUSBController/AuraAddressableController.h @@ -0,0 +1,68 @@ +/*-----------------------------------------*\ +| AuraAddressableController.h | +| | +| Definitions and types for ASUS Aura | +| Addressable RGB lighting controller | +| | +| Adam Honse (CalcProgrammer1) 1/18/2020 | +\*-----------------------------------------*/ + +#include "RGBController.h" +#include "AuraUSBController.h" + +#include +#include + +#pragma once + +enum +{ + AURA_ADDRESSABLE_CONTROL_MODE_EFFECT = 0x3B, /* Effect control mode */ + AURA_ADDRESSABLE_CONTROL_MODE_DIRECT = 0x40, /* Direct control mode */ +}; + +class AuraAddressableController : public AuraUSBController +{ +public: + AuraAddressableController(hid_device* dev_handle); + ~AuraAddressableController(); + + void SetChannelLEDs + ( + unsigned char channel, + RGBColor * colors, + unsigned int num_colors + ); + + void SetMode + ( + unsigned char mode, + unsigned char red, + unsigned char grn, + unsigned char blu + ); + +private: + + void SendEffect + ( + unsigned char channel, + unsigned char mode, + unsigned char red, + unsigned char grn, + unsigned char blu + ); + + void SendDirect + ( + unsigned char device, + unsigned char start_led, + unsigned char led_count, + unsigned char* led_data + ); + + void SendDirectApply + ( + unsigned char channel + ); +}; diff --git a/Controllers/AuraUSBController/AuraMainboardController.cpp b/Controllers/AuraUSBController/AuraMainboardController.cpp new file mode 100644 index 00000000..3814f0a0 --- /dev/null +++ b/Controllers/AuraUSBController/AuraMainboardController.cpp @@ -0,0 +1,177 @@ +/*-----------------------------------------*\ +| AuraMainboardController.cpp | +| | +| Driver for ASUS Aura RGB USB mainboard | +| lighting controller | +| | +| Martin Hartl (inlart) 4/25/2020 | +\*-----------------------------------------*/ + +#include "AuraMainboardController.h" +#include + +AuraMainboardController::AuraMainboardController(hid_device* dev_handle) : AuraUSBController(dev_handle), mode(AURA_MODE_DIRECT) +{ +} + +AuraMainboardController::~AuraMainboardController() +{ +} + +void AuraMainboardController::SetChannelLEDs(unsigned char channel, RGBColor * colors, unsigned int num_colors) +{ + unsigned char led_data[60]; + unsigned int leds_sent = 0; + + SendEffect(channel, mode); + + while(leds_sent < num_colors) + { + unsigned int leds_to_send = 20; + + if((num_colors - leds_sent) < leds_to_send) + { + leds_to_send = num_colors - leds_sent; + } + + for(int led_idx = 0; led_idx < leds_to_send; led_idx++) + { + led_data[(led_idx * 3) + 0] = RGBGetRValue(colors[led_idx + leds_sent]); + led_data[(led_idx * 3) + 1] = RGBGetGValue(colors[led_idx + leds_sent]); + led_data[(led_idx * 3) + 2] = RGBGetBValue(colors[led_idx + leds_sent]); + } + + SendDirect + ( + channel, + leds_sent, + leds_to_send, + led_data + ); + + leds_sent += leds_to_send; + } + + SendCommit(); +} + +void AuraMainboardController::SetMode + ( + unsigned char mode, + unsigned char red, + unsigned char grn, + unsigned char blu + ) +{ + this->mode = mode; + unsigned char led_data[3]; + led_data[0] = red; + led_data[1] = grn; + led_data[2] = blu; + + for(int channel_idx = 0; channel_idx < GetChannelCount(); channel_idx++) + { + SendEffect + ( + channel_idx, + mode + ); + SendDirect + ( + channel_idx, + 0, + 1, + led_data + ); + SendCommit(); + } +} + +void AuraMainboardController::SendEffect + ( + unsigned char channel, + unsigned char mode + ) +{ + unsigned char usb_buf[65]; + + if(mode == AURA_MODE_DIRECT) { + mode = AURA_MODE_STATIC; + } + /*-----------------------------------------------------*\ + | Zero out buffer | + \*-----------------------------------------------------*/ + memset(usb_buf, 0x00, sizeof(usb_buf)); + + /*-----------------------------------------------------*\ + | Set up message packet | + \*-----------------------------------------------------*/ + usb_buf[0x00] = 0xEC; + usb_buf[0x01] = AURA_MAINBOARD_CONTROL_MODE_EFFECT; + usb_buf[0x02] = 0x00; + usb_buf[0x03] = 0x00; + usb_buf[0x04] = channel; + usb_buf[0x05] = mode; + + /*-----------------------------------------------------*\ + | Send packet | + \*-----------------------------------------------------*/ + hid_write(dev, usb_buf, 65); +} + +void AuraMainboardController::SendDirect + ( + unsigned char device, + unsigned char start_led, + unsigned char led_count, + unsigned char* led_data + ) +{ + unsigned char usb_buf[65]; + + /*-----------------------------------------------------*\ + | Zero out buffer | + \*-----------------------------------------------------*/ + memset(usb_buf, 0x00, sizeof(usb_buf)); + + /*-----------------------------------------------------*\ + | Set up message packet | + \*-----------------------------------------------------*/ + usb_buf[0x00] = 0xEC; + usb_buf[0x01] = AURA_MAINBOARD_CONTROL_MODE_DIRECT; + usb_buf[0x02] = start_led; + usb_buf[0x03] = 0xff; + usb_buf[0x04] = 0x00; + + /*-----------------------------------------------------*\ + | Copy in color data bytes | + \*-----------------------------------------------------*/ + memcpy(&usb_buf[0x05], led_data, led_count * 3); + + /*-----------------------------------------------------*\ + | Send packet | + \*-----------------------------------------------------*/ + hid_write(dev, usb_buf, 65); +} + +void AuraMainboardController::SendCommit() +{ + unsigned char usb_buf[65]; + + /*-----------------------------------------------------*\ + | Zero out buffer | + \*-----------------------------------------------------*/ + memset(usb_buf, 0x00, sizeof(usb_buf)); + + /*-----------------------------------------------------*\ + | Set up message packet | + \*-----------------------------------------------------*/ + usb_buf[0x00] = 0xEC; + usb_buf[0x01] = AURA_MAINBOARD_CONTROL_MODE_COMMIT; + usb_buf[0x02] = 0x55; + + /*-----------------------------------------------------*\ + | Send packet | + \*-----------------------------------------------------*/ + hid_write(dev, usb_buf, 65); +} diff --git a/Controllers/AuraUSBController/AuraMainboardController.h b/Controllers/AuraUSBController/AuraMainboardController.h new file mode 100644 index 00000000..55475192 --- /dev/null +++ b/Controllers/AuraUSBController/AuraMainboardController.h @@ -0,0 +1,64 @@ +/*-----------------------------------------*\ +| AuraMainboardController.h | +| | +| Definitions and types for ASUS Aura | +| USB Mainboard RGB lighting controller | +| | +| Martin Hartl (inlart) 4/25/2020 | +\*-----------------------------------------*/ + +#include "RGBController.h" +#include "AuraUSBController.h" + +#include +#include + +#pragma once + +enum +{ + AURA_MAINBOARD_CONTROL_MODE_EFFECT = 0x35, /* Effect control mode */ + AURA_MAINBOARD_CONTROL_MODE_DIRECT = 0x36, /* Direct control mode */ + AURA_MAINBOARD_CONTROL_MODE_COMMIT = 0x3F, /* Direct control mode */ +}; + +class AuraMainboardController : public AuraUSBController +{ +public: + AuraMainboardController(hid_device* dev_handle); + ~AuraMainboardController(); + + void SetChannelLEDs + ( + unsigned char channel, + RGBColor * colors, + unsigned int num_colors + ); + + void SetMode + ( + unsigned char mode, + unsigned char red, + unsigned char grn, + unsigned char blu + ); + +private: + unsigned int mode; + + void SendEffect + ( + unsigned char channel, + unsigned char mode + ); + + void SendDirect + ( + unsigned char device, + unsigned char start_led, + unsigned char led_count, + unsigned char* led_data + ); + + void SendCommit(); +}; diff --git a/Controllers/AuraUSBController/AuraUSBController.cpp b/Controllers/AuraUSBController/AuraUSBController.cpp new file mode 100644 index 00000000..1265c214 --- /dev/null +++ b/Controllers/AuraUSBController/AuraUSBController.cpp @@ -0,0 +1,104 @@ +/*-----------------------------------------*\ +| AuraUSBController.cpp | +| | +| Driver for ASUS Aura RGB USB | +| lighting controller | +| | +| Martin Hartl (inlart) 4/25/2020 | +\*-----------------------------------------*/ + +#include "AuraUSBController.h" +#include + +AuraUSBController::AuraUSBController(hid_device* dev_handle) +{ + dev = dev_handle; + + GetFirmwareVersion(); + GetConfigTable(); +} + +AuraUSBController::~AuraUSBController() +{ + +} + +unsigned int AuraUSBController::GetChannelCount() +{ + return( 5 ); +} + +std::string AuraUSBController::GetDeviceName() +{ + return(device_name); +} + +void AuraUSBController::GetConfigTable() +{ + unsigned char usb_buf[65]; + + /*-----------------------------------------------------*\ + | Zero out buffer | + \*-----------------------------------------------------*/ + memset(usb_buf, 0x00, sizeof(usb_buf)); + + /*-----------------------------------------------------*\ + | Set up config table request packet | + \*-----------------------------------------------------*/ + usb_buf[0x00] = 0xEC; + usb_buf[0x01] = AURA_REQUEST_CONFIG_TABLE; + + /*-----------------------------------------------------*\ + | Send packet | + \*-----------------------------------------------------*/ + hid_write(dev, usb_buf, 65); + hid_read(dev, usb_buf, 65); + + /*-----------------------------------------------------*\ + | Copy the firmware string if the reply ID is correct | + \*-----------------------------------------------------*/ + if(usb_buf[1] == 0x30) + { + memcpy(config_table, &usb_buf[4], 60); + + for(int i = 0; i < 60; i+=6) + { + printf("%02X %02X %02X %02X %02X %02X\r\n", config_table[i + 0], + config_table[i + 1], + config_table[i + 2], + config_table[i + 3], + config_table[i + 4], + config_table[i + 5]); + } + } +} + +void AuraUSBController::GetFirmwareVersion() +{ + unsigned char usb_buf[65]; + + /*-----------------------------------------------------*\ + | Zero out buffer | + \*-----------------------------------------------------*/ + memset(usb_buf, 0x00, sizeof(usb_buf)); + + /*-----------------------------------------------------*\ + | Set up firmware version request packet | + \*-----------------------------------------------------*/ + usb_buf[0x00] = 0xEC; + usb_buf[0x01] = AURA_REQUEST_FIRMWARE_VERSION; + + /*-----------------------------------------------------*\ + | Send packet | + \*-----------------------------------------------------*/ + hid_write(dev, usb_buf, 65); + hid_read(dev, usb_buf, 65); + + /*-----------------------------------------------------*\ + | Copy the firmware string if the reply ID is correct | + \*-----------------------------------------------------*/ + if(usb_buf[1] == 0x02) + { + memcpy(device_name, &usb_buf[2], 16); + } +} diff --git a/Controllers/AuraAddressableController/AuraAddressableController.h b/Controllers/AuraUSBController/AuraUSBController.h similarity index 72% rename from Controllers/AuraAddressableController/AuraAddressableController.h rename to Controllers/AuraUSBController/AuraUSBController.h index 33e7a251..b2e0fc81 100644 --- a/Controllers/AuraAddressableController/AuraAddressableController.h +++ b/Controllers/AuraUSBController/AuraUSBController.h @@ -1,10 +1,10 @@ /*-----------------------------------------*\ -| AuraAddressableController.h | +| AuraUSBController.h | | | | Definitions and types for ASUS Aura | -| Addressable RGB lighting controller | +| USB RGB lighting controller | | | -| Adam Honse (CalcProgrammer1) 1/18/2020 | +| Martin Hartl (inlart) 4/25/2020 | \*-----------------------------------------*/ #include "RGBController.h" @@ -36,66 +36,42 @@ enum enum { - AURA_CONTROL_MODE_EFFECT = 0x3B, /* Effect control mode */ - AURA_CONTROL_MODE_DIRECT = 0x40, /* Direct control mode */ AURA_REQUEST_FIRMWARE_VERSION = 0x82, /* Request firmware string */ AURA_REQUEST_CONFIG_TABLE = 0xB0, /* Request configuration table */ }; -class AuraAddressableController +class AuraUSBController { public: - AuraAddressableController(hid_device* dev_handle); - ~AuraAddressableController(); + AuraUSBController(hid_device* dev_handle); + virtual ~AuraUSBController(); unsigned int GetChannelCount(); std::string GetDeviceName(); - void SetChannelLEDs + virtual void SetChannelLEDs ( unsigned char channel, RGBColor * colors, unsigned int num_colors - ); + ) = 0; - void SetMode + virtual void SetMode ( unsigned char mode, unsigned char red, unsigned char grn, unsigned char blu - ); - + ) = 0; +protected: + hid_device* dev; private: char device_name[16]; unsigned char config_table[60]; - hid_device* dev; unsigned int led_count; - + void GetConfigTable(); void GetFirmwareVersion(); - - void SendEffect - ( - unsigned char channel, - unsigned char mode, - unsigned char red, - unsigned char grn, - unsigned char blu - ); - - void SendDirect - ( - unsigned char device, - unsigned char start_led, - unsigned char led_count, - unsigned char* led_data - ); - - void SendDirectApply - ( - unsigned char channel - ); }; diff --git a/Controllers/AuraUSBController/AuraUSBControllerDetect.cpp b/Controllers/AuraUSBController/AuraUSBControllerDetect.cpp new file mode 100644 index 00000000..568067a9 --- /dev/null +++ b/Controllers/AuraUSBController/AuraUSBControllerDetect.cpp @@ -0,0 +1,68 @@ +#include "AuraAddressableController.h" +#include "AuraMainboardController.h" +#include "RGBController.h" +#include "RGBController_AuraUSB.h" +#include +#include + +#define AURA_USB_VID 0x0B05 + +#define NUM_ADDRESSABLE_PIDS 4 +static const unsigned short addressable_pid_table[] = + { + 0x1867, + 0x1872, + 0x1889, + 0x18A3 + }; + +#define NUM_MAINBOARD_PIDS 1 +static const unsigned short mainboard_pid_table[] = + { + 0x18f3 + }; + +/******************************************************************************************\ +* * +* DetectAuraUSBControllers * +* * +* Tests the USB address to see if an Asus Aura USB RGB header controller * +* exists there. * +* * +\******************************************************************************************/ + +void DetectAuraUSBControllers(std::vector& rgb_controllers) +{ + hid_device* dev; + + //Look for Asus Aura addressable RGB header controller + hid_init(); + + for(int pid_idx = 0; pid_idx < NUM_ADDRESSABLE_PIDS; pid_idx++) + { + dev = hid_open(AURA_USB_VID, addressable_pid_table[pid_idx], 0); + + if( dev ) + { + AuraAddressableController* controller = new AuraAddressableController(dev); + + RGBController_AuraUSB* rgb_controller = new RGBController_AuraUSB(controller); + + rgb_controllers.push_back(rgb_controller); + } + } + + for(int pid_idx = 0; pid_idx < NUM_MAINBOARD_PIDS; pid_idx++) + { + dev = hid_open(AURA_USB_VID, mainboard_pid_table[pid_idx], 0); + + if( dev ) + { + AuraMainboardController* controller = new AuraMainboardController(dev); + + RGBController_AuraUSB* rgb_controller = new RGBController_AuraUSB(controller); + + rgb_controllers.push_back(rgb_controller); + } + } +} diff --git a/OpenRGB.cpp b/OpenRGB.cpp index c055b068..09484b57 100644 --- a/OpenRGB.cpp +++ b/OpenRGB.cpp @@ -254,7 +254,7 @@ void DetectI2CBusses() memset(device_string, 0x00, sizeof(device_string)); read(test_fd, device_string, sizeof(device_string)); device_string[strlen(device_string) - 1] = 0x00; - + close(test_fd); strcpy(device_string, "/dev/"); @@ -294,7 +294,7 @@ void DetectRGBFusionGPUControllers(std::vector& busses, st void DetectRGBFusion2SMBusControllers(std::vector& busses, std::vector& rgb_controllers); void DetectMSIMysticLightControllers(std::vector &rgb_controllers); void DetectMSIRGBControllers(std::vector &rgb_controllers); -void DetectAuraAddressableControllers(std::vector &rgb_controllers); +void DetectAuraUSBControllers(std::vector &rgb_controllers); void DetectAuraCoreControllers(std::vector &rgb_controllers); void DetectLEDStripControllers(std::vector &rgb_controllers); void DetectHue2Controllers(std::vector &rgb_controllers); @@ -343,7 +343,7 @@ void DetectRGBControllers(void) DetectMSIMysticLightControllers(rgb_controllers); DetectMSIRGBControllers(rgb_controllers); - DetectAuraAddressableControllers(rgb_controllers); + DetectAuraUSBControllers(rgb_controllers); DetectAuraCoreControllers(rgb_controllers); DetectLEDStripControllers(rgb_controllers); DetectHue2Controllers(rgb_controllers); diff --git a/OpenRGB.pro b/OpenRGB.pro index 4541c8cd..183c2856 100644 --- a/OpenRGB.pro +++ b/OpenRGB.pro @@ -31,7 +31,7 @@ INCLUDEPATH += \ serial_port/ \ super_io/ \ Controllers/AMDWraithPrismController/ \ - Controllers/AuraAddressableController/ \ + Controllers/AuraUSBController/ \ Controllers/AuraCoreController/ \ Controllers/AuraGPUController/ \ Controllers/AuraSMBusController/ \ @@ -89,8 +89,10 @@ SOURCES += \ super_io/super_io.cpp \ Controllers/AMDWraithPrismController/AMDWraithPrismController.cpp \ Controllers/AMDWraithPrismController/AMDWraithPrismControllerDetect.cpp \ - Controllers/AuraAddressableController/AuraAddressableController.cpp \ - Controllers/AuraAddressableController/AuraAddressableControllerDetect.cpp \ + Controllers/AuraUSBController/AuraUSBController.cpp \ + Controllers/AuraUSBController/AuraAddressableController.cpp \ + Controllers/AuraUSBController/AuraMainboardController.cpp \ + Controllers/AuraUSBController/AuraUSBControllerDetect.cpp \ Controllers/AuraCoreController/AuraCoreController.cpp \ Controllers/AuraCoreController/AuraCoreControllerDetect.cpp \ Controllers/AuraGPUController/AuraGPUController.cpp \ @@ -149,7 +151,7 @@ SOURCES += \ RGBController/RGBController.cpp \ RGBController/E131ControllerDetect.cpp \ RGBController/RGBController_AMDWraithPrism.cpp \ - RGBController/RGBController_AuraAddressable.cpp \ + RGBController/RGBController_AuraUSB.cpp \ RGBController/RGBController_AuraCore.cpp \ RGBController/RGBController_AuraGPU.cpp \ RGBController/RGBController_AuraSMBus.cpp \ @@ -204,7 +206,9 @@ HEADERS += \ serial_port/serial_port.h \ super_io/super_io.h \ Controllers/AMDWraithPrismController/AMDWraithPrismController.h \ - Controllers/AuraAddressableController/AuraAddressableController.h \ + Controllers/AuraUSBController/AuraUSBController.h \ + Controllers/AuraUSBController/AuraAddressableController.h \ + Controllers/AuraUSBController/AuraMainboardController.h \ Controllers/AuraCoreController/AuraCoreController.h \ Controllers/AuraGPUController/AuraGPUController.h \ Controllers/AuraSMBusController/AuraSMBusController.h \ @@ -234,7 +238,7 @@ HEADERS += \ Controllers/ThermaltakeRiingController/ThermaltakeRiingController.h \ RGBController/RGBController.h \ RGBController/RGBController_AMDWraithPrism.h \ - RGBController/RGBController_AuraAddressable.h \ + RGBController/RGBController_AuraUSB.h \ RGBController/RGBController_AuraCore.h \ RGBController/RGBController_AuraGPU.h \ RGBController/RGBController_AuraSMBus.h \ diff --git a/RGBController/RGBController_AuraAddressable.cpp b/RGBController/RGBController_AuraUSB.cpp similarity index 87% rename from RGBController/RGBController_AuraAddressable.cpp rename to RGBController/RGBController_AuraUSB.cpp index 89014262..1506c647 100644 --- a/RGBController/RGBController_AuraAddressable.cpp +++ b/RGBController/RGBController_AuraUSB.cpp @@ -1,22 +1,22 @@ /*-----------------------------------------*\ -| RGBController_AuraAddressable.cpp | +| RGBController_AuraUSB.cpp | | | | Generic RGB Interface for Asus Aura | -| addressable controller driver | +| USB controller driver | | | | Adam Honse (CalcProgrammer1) 1/18/2020 | \*-----------------------------------------*/ -#include "RGBController_AuraAddressable.h" +#include "RGBController_AuraUSB.h" -RGBController_AuraAddressable::RGBController_AuraAddressable(AuraAddressableController* aura_ptr) +RGBController_AuraUSB::RGBController_AuraUSB(AuraUSBController* aura_ptr) { aura = aura_ptr; - name = "ASUS Aura Addressable"; + name = "ASUS Aura USB"; version = aura->GetDeviceName(); type = DEVICE_TYPE_MOTHERBOARD; - description = "ASUS Aura Addressable Device"; + description = "ASUS Aura USB Device"; mode Direct; Direct.name = "Direct"; @@ -99,12 +99,12 @@ RGBController_AuraAddressable::RGBController_AuraAddressable(AuraAddressableCont SetupZones(); } -RGBController_AuraAddressable::~RGBController_AuraAddressable() +RGBController_AuraUSB::~RGBController_AuraUSB() { } -void RGBController_AuraAddressable::SetupZones() +void RGBController_AuraUSB::SetupZones() { /*-------------------------------------------------*\ | Only set LED count on the first run | @@ -164,7 +164,7 @@ void RGBController_AuraAddressable::SetupZones() SetupColors(); } -void RGBController_AuraAddressable::ResizeZone(int zone, int new_size) +void RGBController_AuraUSB::ResizeZone(int zone, int new_size) { if(((unsigned int)new_size >= zones[zone].leds_min) && ((unsigned int)new_size <= zones[zone].leds_max)) { @@ -174,7 +174,7 @@ void RGBController_AuraAddressable::ResizeZone(int zone, int new_size) } } -void RGBController_AuraAddressable::DeviceUpdateLEDs() +void RGBController_AuraUSB::DeviceUpdateLEDs() { for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++) { @@ -182,24 +182,24 @@ void RGBController_AuraAddressable::DeviceUpdateLEDs() } } -void RGBController_AuraAddressable::UpdateZoneLEDs(int zone) +void RGBController_AuraUSB::UpdateZoneLEDs(int zone) { aura->SetChannelLEDs(zone, zones[zone].colors, zones[zone].leds_count); } -void RGBController_AuraAddressable::UpdateSingleLED(int led) +void RGBController_AuraUSB::UpdateSingleLED(int led) { unsigned int channel = leds[led].value; aura->SetChannelLEDs(channel, zones[channel].colors, zones[channel].leds_count); } -void RGBController_AuraAddressable::SetCustomMode() +void RGBController_AuraUSB::SetCustomMode() { } -void RGBController_AuraAddressable::UpdateMode() +void RGBController_AuraUSB::UpdateMode() { unsigned char red = 0; unsigned char grn = 0; diff --git a/RGBController/RGBController_AuraAddressable.h b/RGBController/RGBController_AuraUSB.h similarity index 68% rename from RGBController/RGBController_AuraAddressable.h rename to RGBController/RGBController_AuraUSB.h index 167e34a5..6436a8a4 100644 --- a/RGBController/RGBController_AuraAddressable.h +++ b/RGBController/RGBController_AuraUSB.h @@ -1,23 +1,23 @@ /*-----------------------------------------*\ -| RGBController_AuraAddressable.h | +| RGBController_AuraUSB.h | | | | Generic RGB Interface for Asus Aura | -| addressable controller driver | +| USB controller driver | | | | Adam Honse (CalcProgrammer1) 1/18/2020 | \*-----------------------------------------*/ #pragma once #include "RGBController.h" -#include "AuraAddressableController.h" +#include "AuraUSBController.h" #define AURA_ADDRESSABLE_MAX_LEDS 120 -class RGBController_AuraAddressable : public RGBController +class RGBController_AuraUSB : public RGBController { public: - RGBController_AuraAddressable(AuraAddressableController* aura_ptr); - ~RGBController_AuraAddressable(); + RGBController_AuraUSB(AuraUSBController* aura_ptr); + ~RGBController_AuraUSB(); void SetupZones(); @@ -31,7 +31,7 @@ public: void UpdateMode(); private: - AuraAddressableController* aura; + AuraUSBController* aura; std::vector leds_channel; std::vector zones_channel; };