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

Add Aura USB controller for X570 mainboards

Browse source
This commit is contained in:
Martin Hartl 2020-04-26 22:07:51 +02:00 • committed by Adam Honse
parent 9bd5536d07
commit 7ca0a1b6ab
12 changed files with 532 additions and 213 deletions
Download patch file Download diff file Expand all files Collapse all files

47
Controllers/AuraAddressableController/AuraAddressableControllerDetect.cpp
View file

@ -1,47 +0,0 @@
#include "AuraAddressableController.h"
#include "RGBController.h"
#include "RGBController_AuraAddressable.h"
#include <vector>
#include <hidapi/hidapi.h>
#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<RGBController*>& 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);
}
}
}

103
Controllers/AuraAddressableController/AuraAddressableController.cpp → Controllers/AuraUSBController/AuraAddressableController.cpp
View file

@ -10,23 +10,8 @@
#include "AuraAddressableController.h"
#include <cstring>
#ifdef WIN32
#include <Windows.h>
#else
#include <unistd.h>
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;
/*-----------------------------------------------------*\

68
Controllers/AuraUSBController/AuraAddressableController.h Normal file
View file

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

177
Controllers/AuraUSBController/AuraMainboardController.cpp Normal file
View file

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

64
Controllers/AuraUSBController/AuraMainboardController.h Normal file
View file

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

104
Controllers/AuraUSBController/AuraUSBController.cpp Normal file
View file

@ -0,0 +1,104 @@
/*-----------------------------------------*\
| AuraUSBController.cpp |
| |
| Driver for ASUS Aura RGB USB |
| lighting controller |
| |
| Martin Hartl (inlart) 4/25/2020 |
\*-----------------------------------------*/
#include "AuraUSBController.h"
#include <cstring>
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);
}
}

50
Controllers/AuraAddressableController/AuraAddressableController.h → Controllers/AuraUSBController/AuraUSBController.h
View file

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

68
Controllers/AuraUSBController/AuraUSBControllerDetect.cpp Normal file
View file

@ -0,0 +1,68 @@
#include "AuraAddressableController.h"
#include "AuraMainboardController.h"
#include "RGBController.h"
#include "RGBController_AuraUSB.h"
#include <vector>
#include <hidapi/hidapi.h>
#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<RGBController*>& 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);
}
}
}

6
OpenRGB.cpp
View file

@ -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<i2c_smbus_interface*>& busses, st
void DetectRGBFusion2SMBusControllers(std::vector<i2c_smbus_interface*>& busses, std::vector<RGBController*>& rgb_controllers);
void DetectMSIMysticLightControllers(std::vector<RGBController*> &rgb_controllers);
void DetectMSIRGBControllers(std::vector<RGBController*> &rgb_controllers);
void DetectAuraAddressableControllers(std::vector<RGBController*> &rgb_controllers);
void DetectAuraUSBControllers(std::vector<RGBController*> &rgb_controllers);
void DetectAuraCoreControllers(std::vector<RGBController*> &rgb_controllers);
void DetectLEDStripControllers(std::vector<RGBController*> &rgb_controllers);
void DetectHue2Controllers(std::vector<RGBController*> &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);

16
OpenRGB.pro
View file

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

28
RGBController/RGBController_AuraAddressable.cpp → RGBController/RGBController_AuraUSB.cpp
View file

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

14
RGBController/RGBController_AuraAddressable.h → RGBController/RGBController_AuraUSB.h
View file

@ -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<unsigned int> leds_channel;
std::vector<unsigned int> zones_channel;
};