Publish curated LumaOps source from c85ee9ef8f1454f5c305398902afbb9e6738de40
Managed validation / full (push) Failing after 8s
Managed validation / full (push) Failing after 8s
This commit is contained in:
Public Source Publisher committed
1 parent
91f8b3e3c1
commit
def7920856
2271 files changed
+501225
-501178
No files matched your search
+410
-410
@@ -1,410 +1,410 @@
|
||||
/*---------------------------------------------------------*\
|
||||
| AsusAuraCoreController.cpp |
|
||||
| |
|
||||
| Driver for ASUS ROG Aura Core |
|
||||
| |
|
||||
| Adam Honse (CalcProgrammer1) 13 Apr 2020 |
|
||||
| |
|
||||
| This file is part of the OpenRGB project |
|
||||
| SPDX-License-Identifier: GPL-2.0-or-later |
|
||||
\*---------------------------------------------------------*/
|
||||
|
||||
#include <cstring>
|
||||
#include "AsusAuraCoreController.h"
|
||||
#include "StringUtils.h"
|
||||
|
||||
#define AURA_CORE_MAX_MESSAGE_SIZE 64
|
||||
|
||||
AuraCoreController::AuraCoreController(hid_device* dev_handle, const char* path)
|
||||
{
|
||||
dev = dev_handle;
|
||||
location = path;
|
||||
|
||||
aura_device.aura_type = AURA_CORE_DEVICE_UNKNOWN;
|
||||
aura_device.buff_size = 0;
|
||||
aura_device.report_id = 0x5D;
|
||||
aura_device.num_leds = 4;
|
||||
aura_device.supports_direct = false;
|
||||
|
||||
IdentifyDevice();
|
||||
Handshake();
|
||||
}
|
||||
|
||||
AuraCoreController::~AuraCoreController()
|
||||
{
|
||||
hid_close(dev);
|
||||
}
|
||||
|
||||
std::string AuraCoreController::GetDeviceLocation()
|
||||
{
|
||||
return("HID: " + location);
|
||||
}
|
||||
|
||||
std::string AuraCoreController::GetSerialString()
|
||||
{
|
||||
wchar_t serial_string[128];
|
||||
int ret = hid_get_serial_number_string(dev, serial_string, 128);
|
||||
|
||||
if(ret != 0)
|
||||
{
|
||||
return("");
|
||||
}
|
||||
|
||||
return(StringUtils::wstring_to_string(serial_string));
|
||||
}
|
||||
|
||||
void AuraCoreController::SendBrightness
|
||||
(
|
||||
unsigned char brightness
|
||||
)
|
||||
{
|
||||
unsigned char usb_buf[AURA_CORE_MAX_MESSAGE_SIZE];
|
||||
|
||||
if(aura_device.aura_type != AURA_CORE_DEVICE_UNKNOWN)
|
||||
{
|
||||
/*-----------------------------------------------------*\
|
||||
| Zero out buffer |
|
||||
\*-----------------------------------------------------*/
|
||||
memset(usb_buf, 0x00, sizeof(usb_buf));
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Set up message packet |
|
||||
\*-----------------------------------------------------*/
|
||||
usb_buf[0x00] = 0x5A;
|
||||
usb_buf[0x01] = AURA_CORE_COMMAND_BRIGHTNESS;
|
||||
usb_buf[0x02] = 0xC5;
|
||||
usb_buf[0x03] = 0xC4;
|
||||
usb_buf[0x04] = brightness;
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Send packet |
|
||||
\*-----------------------------------------------------*/
|
||||
hid_send_feature_report(dev, usb_buf, aura_device.buff_size);
|
||||
}
|
||||
}
|
||||
|
||||
void AuraCoreController::SendUpdate
|
||||
(
|
||||
unsigned char zone,
|
||||
unsigned char mode,
|
||||
unsigned char speed,
|
||||
unsigned char dir,
|
||||
unsigned char red,
|
||||
unsigned char green,
|
||||
unsigned char blue
|
||||
)
|
||||
{
|
||||
unsigned char usb_buf[AURA_CORE_MAX_MESSAGE_SIZE];
|
||||
|
||||
if(aura_device.aura_type != AURA_CORE_DEVICE_UNKNOWN)
|
||||
{
|
||||
if(aura_device.aura_type == AURA_CORE_DEVICE_KEYBOARD)
|
||||
{
|
||||
zone += 1;
|
||||
}
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Zero out buffer |
|
||||
\*-----------------------------------------------------*/
|
||||
memset(usb_buf, 0x00, sizeof(usb_buf));
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Set up message packet |
|
||||
\*-----------------------------------------------------*/
|
||||
usb_buf[0x00] = aura_device.report_id;
|
||||
usb_buf[0x01] = AURA_CORE_COMMAND_UPDATE;
|
||||
usb_buf[0x02] = zone;
|
||||
usb_buf[0x03] = mode;
|
||||
usb_buf[0x04] = red;
|
||||
usb_buf[0x05] = green;
|
||||
usb_buf[0x06] = blue;
|
||||
usb_buf[0x07] = speed;
|
||||
usb_buf[0x08] = dir;
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Send packet |
|
||||
\*-----------------------------------------------------*/
|
||||
hid_send_feature_report(dev, usb_buf, aura_device.buff_size);
|
||||
}
|
||||
}
|
||||
|
||||
void AuraCoreController::SendSet()
|
||||
{
|
||||
unsigned char usb_buf[AURA_CORE_MAX_MESSAGE_SIZE];
|
||||
|
||||
if(aura_device.aura_type != AURA_CORE_DEVICE_UNKNOWN)
|
||||
{
|
||||
/*-----------------------------------------------------*\
|
||||
| Zero out buffer |
|
||||
\*-----------------------------------------------------*/
|
||||
memset(usb_buf, 0x00, sizeof(usb_buf));
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Set up message packet |
|
||||
\*-----------------------------------------------------*/
|
||||
usb_buf[0x00] = aura_device.report_id;
|
||||
usb_buf[0x01] = AURA_CORE_COMMAND_SET;
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Send packet |
|
||||
\*-----------------------------------------------------*/
|
||||
hid_send_feature_report(dev, usb_buf, aura_device.buff_size);
|
||||
}
|
||||
}
|
||||
|
||||
void AuraCoreController::SendApply()
|
||||
{
|
||||
unsigned char usb_buf[AURA_CORE_MAX_MESSAGE_SIZE];
|
||||
|
||||
if(aura_device.aura_type != AURA_CORE_DEVICE_UNKNOWN)
|
||||
{
|
||||
/*-----------------------------------------------------*\
|
||||
| Zero out buffer |
|
||||
\*-----------------------------------------------------*/
|
||||
memset(usb_buf, 0x00, sizeof(usb_buf));
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Set up message packet |
|
||||
\*-----------------------------------------------------*/
|
||||
usb_buf[0x00] = aura_device.report_id;
|
||||
usb_buf[0x01] = AURA_CORE_COMMAND_APPLY;
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Send packet |
|
||||
\*-----------------------------------------------------*/
|
||||
hid_send_feature_report(dev, usb_buf, aura_device.buff_size);
|
||||
}
|
||||
}
|
||||
|
||||
void AuraCoreController::InitDirectMode()
|
||||
{
|
||||
unsigned char usb_buf[AURA_CORE_MAX_MESSAGE_SIZE];
|
||||
unsigned char msg_num = 0;
|
||||
int led_count = aura_device.num_leds;
|
||||
|
||||
if(aura_device.supports_direct)
|
||||
{
|
||||
/*-----------------------------------------------------*\
|
||||
| Zero out buffer |
|
||||
\*-----------------------------------------------------*/
|
||||
memset(usb_buf, 0x00, sizeof(usb_buf));
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Set up message packet |
|
||||
\*-----------------------------------------------------*/
|
||||
usb_buf[0x00] = aura_device.report_id;
|
||||
usb_buf[0x01] = AURA_CORE_COMMAND_DIRECT;
|
||||
usb_buf[0x02] = 0xD0;
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Send packet |
|
||||
\*-----------------------------------------------------*/
|
||||
hid_send_feature_report(dev, usb_buf, aura_device.buff_size);
|
||||
|
||||
while(led_count > 0)
|
||||
{
|
||||
/*-----------------------------------------------------*\
|
||||
| Set up second message packet |
|
||||
\*-----------------------------------------------------*/
|
||||
usb_buf[0x03] = 0x01;
|
||||
usb_buf[0x04] = 0x02;
|
||||
usb_buf[0x05] = 0x00;
|
||||
usb_buf[0x06] = msg_num++;
|
||||
usb_buf[0x07] = (led_count > aura_device.max_leds_per_message) ? aura_device.max_leds_per_message : led_count;
|
||||
usb_buf[0x08] = 0x00;
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Send packet 2 |
|
||||
\*-----------------------------------------------------*/
|
||||
hid_send_feature_report(dev, usb_buf, aura_device.buff_size);
|
||||
|
||||
led_count -= aura_device.max_leds_per_message;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void AuraCoreController::UpdateDirect(std::vector<AuraColor>& color_set)
|
||||
{
|
||||
unsigned char usb_buf[AURA_CORE_MAX_MESSAGE_SIZE];
|
||||
unsigned char msg_num = 0;
|
||||
unsigned char color_index = 0;
|
||||
unsigned char set_count = 0;
|
||||
int led_count = aura_device.num_leds;
|
||||
|
||||
if(aura_device.supports_direct)
|
||||
{
|
||||
while(led_count > 0)
|
||||
{
|
||||
unsigned char msg_index = 0x09;
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Zero out buffer |
|
||||
\*-----------------------------------------------------*/
|
||||
memset(usb_buf, 0x00, sizeof(usb_buf));
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Set up message packet |
|
||||
\*-----------------------------------------------------*/
|
||||
usb_buf[0x00] = aura_device.report_id;
|
||||
usb_buf[0x01] = AURA_CORE_COMMAND_DIRECT;
|
||||
usb_buf[0x02] = 0xD0;
|
||||
usb_buf[0x03] = 0x01;
|
||||
usb_buf[0x04] = 0x02;
|
||||
usb_buf[0x05] = 0x00;
|
||||
usb_buf[0x06] = msg_num++;
|
||||
usb_buf[0x07] = (led_count > aura_device.max_leds_per_message) ? aura_device.max_leds_per_message : led_count;
|
||||
usb_buf[0x08] = 0x00;
|
||||
|
||||
set_count = 0;
|
||||
|
||||
while( (msg_index < sizeof(usb_buf) ) &&
|
||||
(led_count > 0 ) &&
|
||||
(set_count < aura_device.max_leds_per_message) )
|
||||
{
|
||||
if(color_index < color_set.size())
|
||||
{
|
||||
usb_buf[msg_index++] = color_set[color_index].red;
|
||||
usb_buf[msg_index++] = color_set[color_index].green;
|
||||
usb_buf[msg_index++] = color_set[color_index].blue;
|
||||
}
|
||||
else
|
||||
{
|
||||
usb_buf[msg_index++] = 0;
|
||||
usb_buf[msg_index++] = 0;
|
||||
usb_buf[msg_index++] = 0;
|
||||
}
|
||||
|
||||
led_count--;
|
||||
color_index++;
|
||||
set_count++;
|
||||
}
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Send packet |
|
||||
\*-----------------------------------------------------*/
|
||||
hid_send_feature_report(dev, usb_buf, aura_device.buff_size);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void AuraCoreController::IdentifyDevice()
|
||||
{
|
||||
unsigned char usb_buf[AURA_CORE_MAX_MESSAGE_SIZE];
|
||||
int num_bytes = 0;
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Zero out buffer |
|
||||
\*-----------------------------------------------------*/
|
||||
memset(usb_buf, 0x00, sizeof(usb_buf));
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| First, attempt to read the report from the Keyboard |
|
||||
\*-----------------------------------------------------*/
|
||||
usb_buf[0x00] = aura_device.report_id;
|
||||
|
||||
num_bytes = hid_get_feature_report(dev, usb_buf, sizeof(usb_buf));
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Currently, there is no need to attempt to read the |
|
||||
| returned data. If the device responded,to the report,|
|
||||
| we're good. |
|
||||
\*-----------------------------------------------------*/
|
||||
if(num_bytes > 0)
|
||||
{
|
||||
aura_device.aura_type = AURA_CORE_DEVICE_KEYBOARD;
|
||||
aura_device.buff_size = 17;
|
||||
aura_device.report_id = 0x5D;
|
||||
aura_device.num_leds = 4;
|
||||
aura_device.supports_direct = false;
|
||||
}
|
||||
else if(num_bytes == -1)
|
||||
{
|
||||
/*-------------------------------------------------*\
|
||||
| First, attempt to read the report from the |
|
||||
| Keyboard |
|
||||
\*-------------------------------------------------*/
|
||||
usb_buf[0] = 0x5E;
|
||||
num_bytes = hid_get_feature_report(dev, usb_buf, sizeof(usb_buf));
|
||||
|
||||
if(num_bytes > 0)
|
||||
{
|
||||
/*---------------------------------------------*\
|
||||
| Currently, there is no need to attempt to |
|
||||
| read the returned data. If the device |
|
||||
| responded,to the report, we're good. |
|
||||
\*---------------------------------------------*/
|
||||
aura_device.aura_type = AURA_CORE_DEVICE_GA15DH;
|
||||
aura_device.buff_size = 64;
|
||||
aura_device.report_id = 0x5E;
|
||||
aura_device.num_leds = 20;
|
||||
aura_device.max_leds_per_message = 16;
|
||||
aura_device.supports_direct = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void AuraCoreController::Handshake()
|
||||
{
|
||||
unsigned char usb_buf[AURA_CORE_MAX_MESSAGE_SIZE];
|
||||
|
||||
|
||||
if(aura_device.aura_type == AURA_CORE_DEVICE_GA15DH)
|
||||
{
|
||||
usb_buf[0] = 0x5E;
|
||||
SendIdString();
|
||||
hid_get_feature_report(dev, usb_buf, sizeof(usb_buf));
|
||||
SendQuery();
|
||||
hid_get_feature_report(dev, usb_buf, sizeof(usb_buf));
|
||||
}
|
||||
}
|
||||
|
||||
void AuraCoreController::SendIdString()
|
||||
{
|
||||
unsigned char usb_buf[AURA_CORE_MAX_MESSAGE_SIZE];
|
||||
const char id[] = "ASUS Tech.Inc.";
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Zero out buffer |
|
||||
\*-----------------------------------------------------*/
|
||||
memset(usb_buf, 0x00, sizeof(usb_buf));
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Set up message packet |
|
||||
\*-----------------------------------------------------*/
|
||||
usb_buf[0x00] = aura_device.report_id;
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Copy in string data |
|
||||
\*-----------------------------------------------------*/
|
||||
memcpy(&usb_buf[0x01], id, sizeof(id));
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Send packet |
|
||||
\*-----------------------------------------------------*/
|
||||
hid_send_feature_report(dev, usb_buf, aura_device.buff_size);
|
||||
}
|
||||
|
||||
void AuraCoreController::SendQuery()
|
||||
{
|
||||
unsigned char usb_buf[AURA_CORE_MAX_MESSAGE_SIZE];
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Zero out buffer |
|
||||
\*-----------------------------------------------------*/
|
||||
memset(usb_buf, 0x00, sizeof(usb_buf));
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Set up message packet |
|
||||
\*-----------------------------------------------------*/
|
||||
usb_buf[0x00] = aura_device.report_id;
|
||||
usb_buf[0x01] = 0x05;
|
||||
usb_buf[0x02] = 0x20;
|
||||
usb_buf[0x03] = 0x31;
|
||||
usb_buf[0x04] = 0x00;
|
||||
usb_buf[0x05] = 0x10;
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Send packet |
|
||||
\*-----------------------------------------------------*/
|
||||
hid_send_feature_report(dev, usb_buf, aura_device.buff_size);
|
||||
}
|
||||
/*---------------------------------------------------------*\
|
||||
| AsusAuraCoreController.cpp |
|
||||
| |
|
||||
| Driver for ASUS ROG Aura Core |
|
||||
| |
|
||||
| Adam Honse (CalcProgrammer1) 13 Apr 2020 |
|
||||
| |
|
||||
| This file is part of the OpenRGB project |
|
||||
| SPDX-License-Identifier: GPL-2.0-or-later |
|
||||
\*---------------------------------------------------------*/
|
||||
|
||||
#include <cstring>
|
||||
#include "AsusAuraCoreController.h"
|
||||
#include "StringUtils.h"
|
||||
|
||||
#define AURA_CORE_MAX_MESSAGE_SIZE 64
|
||||
|
||||
AuraCoreController::AuraCoreController(hid_device* dev_handle, const char* path)
|
||||
{
|
||||
dev = dev_handle;
|
||||
location = path;
|
||||
|
||||
aura_device.aura_type = AURA_CORE_DEVICE_UNKNOWN;
|
||||
aura_device.buff_size = 0;
|
||||
aura_device.report_id = 0x5D;
|
||||
aura_device.num_leds = 4;
|
||||
aura_device.supports_direct = false;
|
||||
|
||||
IdentifyDevice();
|
||||
Handshake();
|
||||
}
|
||||
|
||||
AuraCoreController::~AuraCoreController()
|
||||
{
|
||||
hid_close(dev);
|
||||
}
|
||||
|
||||
std::string AuraCoreController::GetDeviceLocation()
|
||||
{
|
||||
return("HID: " + location);
|
||||
}
|
||||
|
||||
std::string AuraCoreController::GetSerialString()
|
||||
{
|
||||
wchar_t serial_string[128];
|
||||
int ret = hid_get_serial_number_string(dev, serial_string, 128);
|
||||
|
||||
if(ret != 0)
|
||||
{
|
||||
return("");
|
||||
}
|
||||
|
||||
return(StringUtils::wstring_to_string(serial_string));
|
||||
}
|
||||
|
||||
void AuraCoreController::SendBrightness
|
||||
(
|
||||
unsigned char brightness
|
||||
)
|
||||
{
|
||||
unsigned char usb_buf[AURA_CORE_MAX_MESSAGE_SIZE];
|
||||
|
||||
if(aura_device.aura_type != AURA_CORE_DEVICE_UNKNOWN)
|
||||
{
|
||||
/*-----------------------------------------------------*\
|
||||
| Zero out buffer |
|
||||
\*-----------------------------------------------------*/
|
||||
memset(usb_buf, 0x00, sizeof(usb_buf));
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Set up message packet |
|
||||
\*-----------------------------------------------------*/
|
||||
usb_buf[0x00] = 0x5A;
|
||||
usb_buf[0x01] = AURA_CORE_COMMAND_BRIGHTNESS;
|
||||
usb_buf[0x02] = 0xC5;
|
||||
usb_buf[0x03] = 0xC4;
|
||||
usb_buf[0x04] = brightness;
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Send packet |
|
||||
\*-----------------------------------------------------*/
|
||||
hid_send_feature_report(dev, usb_buf, aura_device.buff_size);
|
||||
}
|
||||
}
|
||||
|
||||
void AuraCoreController::SendUpdate
|
||||
(
|
||||
unsigned char zone,
|
||||
unsigned char mode,
|
||||
unsigned char speed,
|
||||
unsigned char dir,
|
||||
unsigned char red,
|
||||
unsigned char green,
|
||||
unsigned char blue
|
||||
)
|
||||
{
|
||||
unsigned char usb_buf[AURA_CORE_MAX_MESSAGE_SIZE];
|
||||
|
||||
if(aura_device.aura_type != AURA_CORE_DEVICE_UNKNOWN)
|
||||
{
|
||||
if(aura_device.aura_type == AURA_CORE_DEVICE_KEYBOARD)
|
||||
{
|
||||
zone += 1;
|
||||
}
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Zero out buffer |
|
||||
\*-----------------------------------------------------*/
|
||||
memset(usb_buf, 0x00, sizeof(usb_buf));
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Set up message packet |
|
||||
\*-----------------------------------------------------*/
|
||||
usb_buf[0x00] = aura_device.report_id;
|
||||
usb_buf[0x01] = AURA_CORE_COMMAND_UPDATE;
|
||||
usb_buf[0x02] = zone;
|
||||
usb_buf[0x03] = mode;
|
||||
usb_buf[0x04] = red;
|
||||
usb_buf[0x05] = green;
|
||||
usb_buf[0x06] = blue;
|
||||
usb_buf[0x07] = speed;
|
||||
usb_buf[0x08] = dir;
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Send packet |
|
||||
\*-----------------------------------------------------*/
|
||||
hid_send_feature_report(dev, usb_buf, aura_device.buff_size);
|
||||
}
|
||||
}
|
||||
|
||||
void AuraCoreController::SendSet()
|
||||
{
|
||||
unsigned char usb_buf[AURA_CORE_MAX_MESSAGE_SIZE];
|
||||
|
||||
if(aura_device.aura_type != AURA_CORE_DEVICE_UNKNOWN)
|
||||
{
|
||||
/*-----------------------------------------------------*\
|
||||
| Zero out buffer |
|
||||
\*-----------------------------------------------------*/
|
||||
memset(usb_buf, 0x00, sizeof(usb_buf));
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Set up message packet |
|
||||
\*-----------------------------------------------------*/
|
||||
usb_buf[0x00] = aura_device.report_id;
|
||||
usb_buf[0x01] = AURA_CORE_COMMAND_SET;
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Send packet |
|
||||
\*-----------------------------------------------------*/
|
||||
hid_send_feature_report(dev, usb_buf, aura_device.buff_size);
|
||||
}
|
||||
}
|
||||
|
||||
void AuraCoreController::SendApply()
|
||||
{
|
||||
unsigned char usb_buf[AURA_CORE_MAX_MESSAGE_SIZE];
|
||||
|
||||
if(aura_device.aura_type != AURA_CORE_DEVICE_UNKNOWN)
|
||||
{
|
||||
/*-----------------------------------------------------*\
|
||||
| Zero out buffer |
|
||||
\*-----------------------------------------------------*/
|
||||
memset(usb_buf, 0x00, sizeof(usb_buf));
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Set up message packet |
|
||||
\*-----------------------------------------------------*/
|
||||
usb_buf[0x00] = aura_device.report_id;
|
||||
usb_buf[0x01] = AURA_CORE_COMMAND_APPLY;
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Send packet |
|
||||
\*-----------------------------------------------------*/
|
||||
hid_send_feature_report(dev, usb_buf, aura_device.buff_size);
|
||||
}
|
||||
}
|
||||
|
||||
void AuraCoreController::InitDirectMode()
|
||||
{
|
||||
unsigned char usb_buf[AURA_CORE_MAX_MESSAGE_SIZE];
|
||||
unsigned char msg_num = 0;
|
||||
int led_count = aura_device.num_leds;
|
||||
|
||||
if(aura_device.supports_direct)
|
||||
{
|
||||
/*-----------------------------------------------------*\
|
||||
| Zero out buffer |
|
||||
\*-----------------------------------------------------*/
|
||||
memset(usb_buf, 0x00, sizeof(usb_buf));
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Set up message packet |
|
||||
\*-----------------------------------------------------*/
|
||||
usb_buf[0x00] = aura_device.report_id;
|
||||
usb_buf[0x01] = AURA_CORE_COMMAND_DIRECT;
|
||||
usb_buf[0x02] = 0xD0;
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Send packet |
|
||||
\*-----------------------------------------------------*/
|
||||
hid_send_feature_report(dev, usb_buf, aura_device.buff_size);
|
||||
|
||||
while(led_count > 0)
|
||||
{
|
||||
/*-----------------------------------------------------*\
|
||||
| Set up second message packet |
|
||||
\*-----------------------------------------------------*/
|
||||
usb_buf[0x03] = 0x01;
|
||||
usb_buf[0x04] = 0x02;
|
||||
usb_buf[0x05] = 0x00;
|
||||
usb_buf[0x06] = msg_num++;
|
||||
usb_buf[0x07] = (led_count > aura_device.max_leds_per_message) ? aura_device.max_leds_per_message : led_count;
|
||||
usb_buf[0x08] = 0x00;
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Send packet 2 |
|
||||
\*-----------------------------------------------------*/
|
||||
hid_send_feature_report(dev, usb_buf, aura_device.buff_size);
|
||||
|
||||
led_count -= aura_device.max_leds_per_message;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void AuraCoreController::UpdateDirect(std::vector<AuraColor>& color_set)
|
||||
{
|
||||
unsigned char usb_buf[AURA_CORE_MAX_MESSAGE_SIZE];
|
||||
unsigned char msg_num = 0;
|
||||
unsigned char color_index = 0;
|
||||
unsigned char set_count = 0;
|
||||
int led_count = aura_device.num_leds;
|
||||
|
||||
if(aura_device.supports_direct)
|
||||
{
|
||||
while(led_count > 0)
|
||||
{
|
||||
unsigned char msg_index = 0x09;
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Zero out buffer |
|
||||
\*-----------------------------------------------------*/
|
||||
memset(usb_buf, 0x00, sizeof(usb_buf));
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Set up message packet |
|
||||
\*-----------------------------------------------------*/
|
||||
usb_buf[0x00] = aura_device.report_id;
|
||||
usb_buf[0x01] = AURA_CORE_COMMAND_DIRECT;
|
||||
usb_buf[0x02] = 0xD0;
|
||||
usb_buf[0x03] = 0x01;
|
||||
usb_buf[0x04] = 0x02;
|
||||
usb_buf[0x05] = 0x00;
|
||||
usb_buf[0x06] = msg_num++;
|
||||
usb_buf[0x07] = (led_count > aura_device.max_leds_per_message) ? aura_device.max_leds_per_message : led_count;
|
||||
usb_buf[0x08] = 0x00;
|
||||
|
||||
set_count = 0;
|
||||
|
||||
while( (msg_index < sizeof(usb_buf) ) &&
|
||||
(led_count > 0 ) &&
|
||||
(set_count < aura_device.max_leds_per_message) )
|
||||
{
|
||||
if(color_index < color_set.size())
|
||||
{
|
||||
usb_buf[msg_index++] = color_set[color_index].red;
|
||||
usb_buf[msg_index++] = color_set[color_index].green;
|
||||
usb_buf[msg_index++] = color_set[color_index].blue;
|
||||
}
|
||||
else
|
||||
{
|
||||
usb_buf[msg_index++] = 0;
|
||||
usb_buf[msg_index++] = 0;
|
||||
usb_buf[msg_index++] = 0;
|
||||
}
|
||||
|
||||
led_count--;
|
||||
color_index++;
|
||||
set_count++;
|
||||
}
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Send packet |
|
||||
\*-----------------------------------------------------*/
|
||||
hid_send_feature_report(dev, usb_buf, aura_device.buff_size);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void AuraCoreController::IdentifyDevice()
|
||||
{
|
||||
unsigned char usb_buf[AURA_CORE_MAX_MESSAGE_SIZE];
|
||||
int num_bytes = 0;
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Zero out buffer |
|
||||
\*-----------------------------------------------------*/
|
||||
memset(usb_buf, 0x00, sizeof(usb_buf));
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| First, attempt to read the report from the Keyboard |
|
||||
\*-----------------------------------------------------*/
|
||||
usb_buf[0x00] = aura_device.report_id;
|
||||
|
||||
num_bytes = hid_get_feature_report(dev, usb_buf, sizeof(usb_buf));
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Currently, there is no need to attempt to read the |
|
||||
| returned data. If the device responded,to the report,|
|
||||
| we're good. |
|
||||
\*-----------------------------------------------------*/
|
||||
if(num_bytes > 0)
|
||||
{
|
||||
aura_device.aura_type = AURA_CORE_DEVICE_KEYBOARD;
|
||||
aura_device.buff_size = 17;
|
||||
aura_device.report_id = 0x5D;
|
||||
aura_device.num_leds = 4;
|
||||
aura_device.supports_direct = false;
|
||||
}
|
||||
else if(num_bytes == -1)
|
||||
{
|
||||
/*-------------------------------------------------*\
|
||||
| First, attempt to read the report from the |
|
||||
| Keyboard |
|
||||
\*-------------------------------------------------*/
|
||||
usb_buf[0] = 0x5E;
|
||||
num_bytes = hid_get_feature_report(dev, usb_buf, sizeof(usb_buf));
|
||||
|
||||
if(num_bytes > 0)
|
||||
{
|
||||
/*---------------------------------------------*\
|
||||
| Currently, there is no need to attempt to |
|
||||
| read the returned data. If the device |
|
||||
| responded,to the report, we're good. |
|
||||
\*---------------------------------------------*/
|
||||
aura_device.aura_type = AURA_CORE_DEVICE_GA15DH;
|
||||
aura_device.buff_size = 64;
|
||||
aura_device.report_id = 0x5E;
|
||||
aura_device.num_leds = 20;
|
||||
aura_device.max_leds_per_message = 16;
|
||||
aura_device.supports_direct = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void AuraCoreController::Handshake()
|
||||
{
|
||||
unsigned char usb_buf[AURA_CORE_MAX_MESSAGE_SIZE];
|
||||
|
||||
|
||||
if(aura_device.aura_type == AURA_CORE_DEVICE_GA15DH)
|
||||
{
|
||||
usb_buf[0] = 0x5E;
|
||||
SendIdString();
|
||||
hid_get_feature_report(dev, usb_buf, sizeof(usb_buf));
|
||||
SendQuery();
|
||||
hid_get_feature_report(dev, usb_buf, sizeof(usb_buf));
|
||||
}
|
||||
}
|
||||
|
||||
void AuraCoreController::SendIdString()
|
||||
{
|
||||
unsigned char usb_buf[AURA_CORE_MAX_MESSAGE_SIZE];
|
||||
const char id[] = "ASUS Tech.Inc.";
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Zero out buffer |
|
||||
\*-----------------------------------------------------*/
|
||||
memset(usb_buf, 0x00, sizeof(usb_buf));
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Set up message packet |
|
||||
\*-----------------------------------------------------*/
|
||||
usb_buf[0x00] = aura_device.report_id;
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Copy in string data |
|
||||
\*-----------------------------------------------------*/
|
||||
memcpy(&usb_buf[0x01], id, sizeof(id));
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Send packet |
|
||||
\*-----------------------------------------------------*/
|
||||
hid_send_feature_report(dev, usb_buf, aura_device.buff_size);
|
||||
}
|
||||
|
||||
void AuraCoreController::SendQuery()
|
||||
{
|
||||
unsigned char usb_buf[AURA_CORE_MAX_MESSAGE_SIZE];
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Zero out buffer |
|
||||
\*-----------------------------------------------------*/
|
||||
memset(usb_buf, 0x00, sizeof(usb_buf));
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Set up message packet |
|
||||
\*-----------------------------------------------------*/
|
||||
usb_buf[0x00] = aura_device.report_id;
|
||||
usb_buf[0x01] = 0x05;
|
||||
usb_buf[0x02] = 0x20;
|
||||
usb_buf[0x03] = 0x31;
|
||||
usb_buf[0x04] = 0x00;
|
||||
usb_buf[0x05] = 0x10;
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Send packet |
|
||||
\*-----------------------------------------------------*/
|
||||
hid_send_feature_report(dev, usb_buf, aura_device.buff_size);
|
||||
}
|
||||
+123
-123
@@ -1,123 +1,123 @@
|
||||
/*---------------------------------------------------------*\
|
||||
| AsusAuraCoreController.h |
|
||||
| |
|
||||
| Driver for ASUS ROG Aura Core |
|
||||
| |
|
||||
| Adam Honse (CalcProgrammer1) 13 Apr 2020 |
|
||||
| |
|
||||
| This file is part of the OpenRGB project |
|
||||
| SPDX-License-Identifier: GPL-2.0-or-later |
|
||||
\*---------------------------------------------------------*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <string>
|
||||
#include <hidapi.h>
|
||||
#include "RGBController.h"
|
||||
|
||||
enum AuraCoreDeviceType
|
||||
{
|
||||
AURA_CORE_DEVICE_UNKNOWN = 0,
|
||||
AURA_CORE_DEVICE_KEYBOARD = 1,
|
||||
AURA_CORE_DEVICE_GA15DH = 2
|
||||
};
|
||||
|
||||
enum
|
||||
{
|
||||
AURA_CORE_MODE_STATIC = 0, /* Static color mode */
|
||||
AURA_CORE_MODE_BREATHING = 1, /* Breathing effect mode */
|
||||
AURA_CORE_MODE_SPECTRUM_CYCLE = 2, /* Spectrum Cycle mode */
|
||||
AURA_CORE_MODE_RAINBOW = 3, /* Rainbow mode */
|
||||
AURA_CORE_MODE_STROBE = 10, /* Strobe mode */
|
||||
AURA_CORE_MODE_COMET = 11, /* Comet mode */
|
||||
AURA_CORE_MODE_FLASHNDASH = 12, /* Flash & Dash mode */
|
||||
AURA_CORE_MODE_IRRADIATION = 17, /* Irradiation mode */
|
||||
AURA_CORE_MODE_DIRECT = 255 /* Not a real mode - but need a way to differentiate */
|
||||
};
|
||||
|
||||
enum
|
||||
{
|
||||
AURA_CORE_COMMAND_UPDATE = 0xB3, /* Update mode and color */
|
||||
AURA_CORE_COMMAND_SET = 0xB5, /* Set command */
|
||||
AURA_CORE_COMMAND_APPLY = 0xB4, /* Apply command */
|
||||
AURA_CORE_COMMAND_BRIGHTNESS = 0xBA, /* Brightness command */
|
||||
AURA_CORE_COMMAND_DIRECT = 0xBC /* Set LEDs directly */
|
||||
};
|
||||
|
||||
enum
|
||||
{
|
||||
AURA_CORE_ZONE_IDX_ALL = 0x00, /* Update all zones */
|
||||
AURA_CORE_ZONE_IDX_1 = 0x01, /* Update zone 1 */
|
||||
AURA_CORE_ZONE_IDX_2 = 0x02, /* Update zone 2 */
|
||||
AURA_CORE_ZONE_IDX_3 = 0x03, /* Update zone 3 */
|
||||
AURA_CORE_ZONE_IDX_4 = 0x04, /* Update zone 4 */
|
||||
};
|
||||
|
||||
enum
|
||||
{
|
||||
AURA_CORE_SPEED_SLOW = 0xE1, /* Slowest speed */
|
||||
AURA_CORE_SPEED_NORMAL = 0xEB, /* Normal speed */
|
||||
AURA_CORE_SPEED_FAST = 0xF5, /* Fastest speed */
|
||||
};
|
||||
|
||||
struct AuraDeviceDescriptor
|
||||
{
|
||||
AuraCoreDeviceType aura_type;
|
||||
unsigned char buff_size;
|
||||
unsigned char report_id;
|
||||
unsigned char num_leds;
|
||||
unsigned char max_leds_per_message;
|
||||
bool supports_direct;
|
||||
};
|
||||
|
||||
struct AuraColor
|
||||
{
|
||||
unsigned char red;
|
||||
unsigned char green;
|
||||
unsigned char blue;
|
||||
};
|
||||
|
||||
class AuraCoreController
|
||||
{
|
||||
public:
|
||||
AuraDeviceDescriptor aura_device;
|
||||
|
||||
AuraCoreController(hid_device* dev_handle, const char* path);
|
||||
~AuraCoreController();
|
||||
|
||||
std::string GetDeviceLocation();
|
||||
std::string GetSerialString();
|
||||
|
||||
void SendBrightness
|
||||
(
|
||||
unsigned char brightness
|
||||
);
|
||||
|
||||
void SendUpdate
|
||||
(
|
||||
unsigned char zone,
|
||||
unsigned char mode,
|
||||
unsigned char speed,
|
||||
unsigned char dir,
|
||||
unsigned char red,
|
||||
unsigned char green,
|
||||
unsigned char blue
|
||||
);
|
||||
|
||||
void SendSet();
|
||||
|
||||
void SendApply();
|
||||
|
||||
void InitDirectMode();
|
||||
|
||||
void UpdateDirect(std::vector<AuraColor>& color_set);
|
||||
|
||||
private:
|
||||
hid_device* dev;
|
||||
std::string location;
|
||||
|
||||
void IdentifyDevice();
|
||||
void Handshake();
|
||||
void SendIdString();
|
||||
void SendQuery();
|
||||
};
|
||||
/*---------------------------------------------------------*\
|
||||
| AsusAuraCoreController.h |
|
||||
| |
|
||||
| Driver for ASUS ROG Aura Core |
|
||||
| |
|
||||
| Adam Honse (CalcProgrammer1) 13 Apr 2020 |
|
||||
| |
|
||||
| This file is part of the OpenRGB project |
|
||||
| SPDX-License-Identifier: GPL-2.0-or-later |
|
||||
\*---------------------------------------------------------*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <string>
|
||||
#include <hidapi.h>
|
||||
#include "RGBController.h"
|
||||
|
||||
enum AuraCoreDeviceType
|
||||
{
|
||||
AURA_CORE_DEVICE_UNKNOWN = 0,
|
||||
AURA_CORE_DEVICE_KEYBOARD = 1,
|
||||
AURA_CORE_DEVICE_GA15DH = 2
|
||||
};
|
||||
|
||||
enum
|
||||
{
|
||||
AURA_CORE_MODE_STATIC = 0, /* Static color mode */
|
||||
AURA_CORE_MODE_BREATHING = 1, /* Breathing effect mode */
|
||||
AURA_CORE_MODE_SPECTRUM_CYCLE = 2, /* Spectrum Cycle mode */
|
||||
AURA_CORE_MODE_RAINBOW = 3, /* Rainbow mode */
|
||||
AURA_CORE_MODE_STROBE = 10, /* Strobe mode */
|
||||
AURA_CORE_MODE_COMET = 11, /* Comet mode */
|
||||
AURA_CORE_MODE_FLASHNDASH = 12, /* Flash & Dash mode */
|
||||
AURA_CORE_MODE_IRRADIATION = 17, /* Irradiation mode */
|
||||
AURA_CORE_MODE_DIRECT = 255 /* Not a real mode - but need a way to differentiate */
|
||||
};
|
||||
|
||||
enum
|
||||
{
|
||||
AURA_CORE_COMMAND_UPDATE = 0xB3, /* Update mode and color */
|
||||
AURA_CORE_COMMAND_SET = 0xB5, /* Set command */
|
||||
AURA_CORE_COMMAND_APPLY = 0xB4, /* Apply command */
|
||||
AURA_CORE_COMMAND_BRIGHTNESS = 0xBA, /* Brightness command */
|
||||
AURA_CORE_COMMAND_DIRECT = 0xBC /* Set LEDs directly */
|
||||
};
|
||||
|
||||
enum
|
||||
{
|
||||
AURA_CORE_ZONE_IDX_ALL = 0x00, /* Update all zones */
|
||||
AURA_CORE_ZONE_IDX_1 = 0x01, /* Update zone 1 */
|
||||
AURA_CORE_ZONE_IDX_2 = 0x02, /* Update zone 2 */
|
||||
AURA_CORE_ZONE_IDX_3 = 0x03, /* Update zone 3 */
|
||||
AURA_CORE_ZONE_IDX_4 = 0x04, /* Update zone 4 */
|
||||
};
|
||||
|
||||
enum
|
||||
{
|
||||
AURA_CORE_SPEED_SLOW = 0xE1, /* Slowest speed */
|
||||
AURA_CORE_SPEED_NORMAL = 0xEB, /* Normal speed */
|
||||
AURA_CORE_SPEED_FAST = 0xF5, /* Fastest speed */
|
||||
};
|
||||
|
||||
struct AuraDeviceDescriptor
|
||||
{
|
||||
AuraCoreDeviceType aura_type;
|
||||
unsigned char buff_size;
|
||||
unsigned char report_id;
|
||||
unsigned char num_leds;
|
||||
unsigned char max_leds_per_message;
|
||||
bool supports_direct;
|
||||
};
|
||||
|
||||
struct AuraColor
|
||||
{
|
||||
unsigned char red;
|
||||
unsigned char green;
|
||||
unsigned char blue;
|
||||
};
|
||||
|
||||
class AuraCoreController
|
||||
{
|
||||
public:
|
||||
AuraDeviceDescriptor aura_device;
|
||||
|
||||
AuraCoreController(hid_device* dev_handle, const char* path);
|
||||
~AuraCoreController();
|
||||
|
||||
std::string GetDeviceLocation();
|
||||
std::string GetSerialString();
|
||||
|
||||
void SendBrightness
|
||||
(
|
||||
unsigned char brightness
|
||||
);
|
||||
|
||||
void SendUpdate
|
||||
(
|
||||
unsigned char zone,
|
||||
unsigned char mode,
|
||||
unsigned char speed,
|
||||
unsigned char dir,
|
||||
unsigned char red,
|
||||
unsigned char green,
|
||||
unsigned char blue
|
||||
);
|
||||
|
||||
void SendSet();
|
||||
|
||||
void SendApply();
|
||||
|
||||
void InitDirectMode();
|
||||
|
||||
void UpdateDirect(std::vector<AuraColor>& color_set);
|
||||
|
||||
private:
|
||||
hid_device* dev;
|
||||
std::string location;
|
||||
|
||||
void IdentifyDevice();
|
||||
void Handshake();
|
||||
void SendIdString();
|
||||
void SendQuery();
|
||||
};
|
||||
+328
-328
@@ -1,328 +1,328 @@
|
||||
/*---------------------------------------------------------*\
|
||||
| RGBController_AsusAuraCore.cpp |
|
||||
| |
|
||||
| RGBController for ASUS ROG Aura Core |
|
||||
| |
|
||||
| Adam Honse (CalcProgrammer1) 13 Apr 2020 |
|
||||
| |
|
||||
| This file is part of the OpenRGB project |
|
||||
| SPDX-License-Identifier: GPL-2.0-or-later |
|
||||
\*---------------------------------------------------------*/
|
||||
|
||||
#include "RGBController_AsusAuraCore.h"
|
||||
|
||||
/**------------------------------------------------------------------*\
|
||||
@name Asus AURA Core
|
||||
@category Keyboard,LEDStrip
|
||||
@type USB
|
||||
@save :x:
|
||||
@direct :rotating_light:
|
||||
@effects :white_check_mark:
|
||||
@detectors DetectAsusAuraCoreControllers
|
||||
@comment
|
||||
\*-------------------------------------------------------------------*/
|
||||
|
||||
RGBController_AuraCore::RGBController_AuraCore(AuraCoreController* controller_ptr)
|
||||
{
|
||||
controller = controller_ptr;
|
||||
|
||||
name = "ASUS Aura Core Device";
|
||||
vendor = "ASUS";
|
||||
location = controller->GetDeviceLocation();
|
||||
serial = controller->GetSerialString();
|
||||
description = "ASUS Aura Core Device";
|
||||
type = DEVICE_TYPE_UNKNOWN;
|
||||
|
||||
if(controller->aura_device.aura_type == AURA_CORE_DEVICE_KEYBOARD)
|
||||
{
|
||||
SetupKeyboard();
|
||||
}
|
||||
else if(controller->aura_device.aura_type == AURA_CORE_DEVICE_GA15DH)
|
||||
{
|
||||
SetupGA15DH();
|
||||
}
|
||||
|
||||
SetupZones();
|
||||
}
|
||||
|
||||
void RGBController_AuraCore::SetupKeyboard()
|
||||
{
|
||||
name = "ASUS Aura Keyboard";
|
||||
vendor = "ASUS";
|
||||
type = DEVICE_TYPE_KEYBOARD;
|
||||
description = "ASUS Aura Core Device";
|
||||
|
||||
mode Static;
|
||||
Static.name = "Static";
|
||||
Static.value = AURA_CORE_MODE_STATIC;
|
||||
Static.flags = MODE_FLAG_HAS_PER_LED_COLOR;
|
||||
Static.color_mode = MODE_COLORS_PER_LED;
|
||||
modes.push_back(Static);
|
||||
|
||||
mode Breathing;
|
||||
Breathing.name = "Breathing";
|
||||
Breathing.value = AURA_CORE_MODE_BREATHING;
|
||||
Breathing.flags = MODE_FLAG_HAS_PER_LED_COLOR;
|
||||
Breathing.color_mode = MODE_COLORS_PER_LED;
|
||||
modes.push_back(Breathing);
|
||||
|
||||
mode ColorCycle;
|
||||
ColorCycle.name = "Color Cycle";
|
||||
ColorCycle.value = AURA_CORE_MODE_SPECTRUM_CYCLE;
|
||||
ColorCycle.flags = 0;
|
||||
ColorCycle.color_mode = MODE_COLORS_NONE;
|
||||
modes.push_back(ColorCycle);
|
||||
}
|
||||
|
||||
void RGBController_AuraCore::SetupGA15DH()
|
||||
{
|
||||
name = "ASUS Aura GA15DH";
|
||||
vendor = "ASUS";
|
||||
type = DEVICE_TYPE_LEDSTRIP;
|
||||
description = "ASUS Aura Core Device";
|
||||
|
||||
mode Static;
|
||||
Static.name = "Static";
|
||||
Static.value = AURA_CORE_MODE_STATIC;
|
||||
Static.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
|
||||
Static.colors_min = 1;
|
||||
Static.colors_max = 1;
|
||||
Static.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Static.colors.resize(1);
|
||||
modes.push_back(Static);
|
||||
|
||||
mode Breathing;
|
||||
Breathing.name = "Breathing";
|
||||
Breathing.value = AURA_CORE_MODE_BREATHING;
|
||||
Breathing.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED;
|
||||
Breathing.speed_min = AURA_CORE_SPEED_SLOW;
|
||||
Breathing.speed_max = AURA_CORE_SPEED_FAST;
|
||||
Breathing.speed = AURA_CORE_SPEED_NORMAL;
|
||||
Breathing.colors_min = 1;
|
||||
Breathing.colors_max = 2;
|
||||
Breathing.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Breathing.colors.resize(2);
|
||||
modes.push_back(Breathing);
|
||||
|
||||
mode ColorCycle;
|
||||
ColorCycle.name = "Color Cycle";
|
||||
ColorCycle.value = AURA_CORE_MODE_SPECTRUM_CYCLE;
|
||||
ColorCycle.flags = MODE_FLAG_HAS_SPEED;
|
||||
ColorCycle.speed_min = AURA_CORE_SPEED_SLOW;
|
||||
ColorCycle.speed_max = AURA_CORE_SPEED_FAST;
|
||||
ColorCycle.speed = AURA_CORE_SPEED_NORMAL;
|
||||
ColorCycle.color_mode = MODE_COLORS_NONE;
|
||||
modes.push_back(ColorCycle);
|
||||
|
||||
mode Rainbow;
|
||||
Rainbow.name = "Rainbow";
|
||||
Rainbow.value = AURA_CORE_MODE_RAINBOW;
|
||||
Rainbow.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
|
||||
Rainbow.speed_min = AURA_CORE_SPEED_SLOW;
|
||||
Rainbow.speed_max = AURA_CORE_SPEED_FAST;
|
||||
Rainbow.speed = AURA_CORE_SPEED_NORMAL;
|
||||
Rainbow.direction = MODE_DIRECTION_RIGHT;
|
||||
Rainbow.color_mode = MODE_COLORS_NONE;
|
||||
modes.push_back(Rainbow);
|
||||
|
||||
mode Strobe;
|
||||
Strobe.name = "Strobe";
|
||||
Strobe.value = AURA_CORE_MODE_STROBE;
|
||||
Strobe.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
|
||||
Strobe.colors_min = 1;
|
||||
Strobe.colors_max = 1;
|
||||
Strobe.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Strobe.colors.resize(1);
|
||||
modes.push_back(Strobe);
|
||||
|
||||
mode Comet;
|
||||
Comet.name = "Comet";
|
||||
Comet.value = AURA_CORE_MODE_COMET;
|
||||
Comet.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
|
||||
Comet.colors_min = 1;
|
||||
Comet.colors_max = 1;
|
||||
Comet.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Comet.colors.resize(1);
|
||||
modes.push_back(Comet);
|
||||
|
||||
mode Flash;
|
||||
Flash.name = "Flash & Dash";
|
||||
Flash.value = AURA_CORE_MODE_FLASHNDASH;
|
||||
Flash.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
|
||||
Flash.colors_min = 1;
|
||||
Flash.colors_max = 1;
|
||||
Flash.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Flash.colors.resize(1);
|
||||
modes.push_back(Flash);
|
||||
|
||||
mode Irradiation;
|
||||
Irradiation.name = "Irradiation";
|
||||
Irradiation.value = AURA_CORE_MODE_IRRADIATION;
|
||||
Irradiation.flags = 0;
|
||||
Irradiation.color_mode = MODE_COLORS_NONE;
|
||||
modes.push_back(Irradiation);
|
||||
|
||||
mode Direct;
|
||||
Static.name = "Direct";
|
||||
Static.value = AURA_CORE_MODE_DIRECT;
|
||||
Static.flags = MODE_FLAG_HAS_PER_LED_COLOR;
|
||||
Static.color_mode = MODE_COLORS_PER_LED;
|
||||
modes.push_back(Static);
|
||||
}
|
||||
|
||||
RGBController_AuraCore::~RGBController_AuraCore()
|
||||
{
|
||||
delete controller;
|
||||
}
|
||||
|
||||
void RGBController_AuraCore::SetupZones()
|
||||
{
|
||||
zone auraZone;
|
||||
|
||||
if(controller->aura_device.aura_type == AURA_CORE_DEVICE_KEYBOARD)
|
||||
{
|
||||
auraZone.name = "Keyboard";
|
||||
auraZone.type = ZONE_TYPE_SINGLE;
|
||||
auraZone.leds_min = 4;
|
||||
auraZone.leds_max = 4;
|
||||
auraZone.leds_count = 4;
|
||||
auraZone.matrix_map = NULL;
|
||||
}
|
||||
else if(controller->aura_device.aura_type == AURA_CORE_DEVICE_GA15DH)
|
||||
{
|
||||
auraZone.name = "GA15DH";
|
||||
auraZone.type = ZONE_TYPE_LINEAR;
|
||||
auraZone.leds_min = 20;
|
||||
auraZone.leds_max = 20;
|
||||
auraZone.leds_count = 20;
|
||||
auraZone.matrix_map = NULL;
|
||||
}
|
||||
else
|
||||
{
|
||||
auraZone.leds_count = 0;
|
||||
}
|
||||
|
||||
zones.push_back(auraZone);
|
||||
|
||||
for(unsigned int led_idx = 0; led_idx < auraZone.leds_count; led_idx++)
|
||||
{
|
||||
led KeyLED;
|
||||
KeyLED.name = auraZone.name + " ";
|
||||
KeyLED.name.append(std::to_string(led_idx + 1));
|
||||
leds.push_back(KeyLED);
|
||||
}
|
||||
|
||||
SetupColors();
|
||||
}
|
||||
|
||||
void RGBController_AuraCore::ResizeZone(int /*zone*/, int /*new_size*/)
|
||||
{
|
||||
/*---------------------------------------------------------*\
|
||||
| This device does not support resizing zones |
|
||||
\*---------------------------------------------------------*/
|
||||
}
|
||||
|
||||
void RGBController_AuraCore::DeviceUpdateLEDs()
|
||||
{
|
||||
UpdateZoneLEDs(0);
|
||||
}
|
||||
|
||||
void RGBController_AuraCore::UpdateZoneLEDs(int /*zone*/)
|
||||
{
|
||||
if(modes[active_mode].value == AURA_CORE_MODE_DIRECT)
|
||||
{
|
||||
std::vector<AuraColor> aura_colors;
|
||||
std::vector<RGBColor>& color_set = colors;
|
||||
|
||||
if(modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC)
|
||||
{
|
||||
color_set = modes[active_mode].colors;
|
||||
}
|
||||
|
||||
for(unsigned int led_idx = 0; led_idx < leds.size(); led_idx++)
|
||||
{
|
||||
AuraColor new_color;
|
||||
|
||||
new_color.red = RGBGetRValue(color_set[led_idx]);
|
||||
new_color.green = RGBGetGValue(color_set[led_idx]);
|
||||
new_color.blue = RGBGetBValue(color_set[led_idx]);
|
||||
|
||||
aura_colors.push_back(new_color);
|
||||
}
|
||||
|
||||
controller->UpdateDirect(aura_colors);
|
||||
}
|
||||
else if(modes[active_mode].color_mode == MODE_COLORS_PER_LED)
|
||||
{
|
||||
for(unsigned int led_idx = 0; led_idx < leds.size(); led_idx++)
|
||||
{
|
||||
UpdateSingleLED(led_idx);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
UpdateSingleLED(0);
|
||||
}
|
||||
}
|
||||
|
||||
void RGBController_AuraCore::UpdateSingleLED(int led)
|
||||
{
|
||||
unsigned char speed = 0xFF;
|
||||
unsigned char red = 0;
|
||||
unsigned char green = 0;
|
||||
unsigned char blue = 0;
|
||||
unsigned char dir = 0;
|
||||
mode& curr_mode = modes[active_mode];
|
||||
|
||||
if(curr_mode.color_mode == MODE_COLORS_PER_LED)
|
||||
{
|
||||
red = RGBGetRValue(colors[led]);
|
||||
green = RGBGetGValue(colors[led]);
|
||||
blue = RGBGetBValue(colors[led]);
|
||||
}
|
||||
else if(curr_mode.color_mode == MODE_COLORS_MODE_SPECIFIC)
|
||||
{
|
||||
red = RGBGetRValue(curr_mode.colors[led]);
|
||||
green = RGBGetGValue(curr_mode.colors[led]);
|
||||
blue = RGBGetBValue(curr_mode.colors[led]);
|
||||
}
|
||||
|
||||
if(curr_mode.flags & MODE_FLAG_HAS_SPEED)
|
||||
{
|
||||
speed = curr_mode.speed;
|
||||
}
|
||||
|
||||
if(curr_mode.flags & MODE_FLAG_HAS_DIRECTION_LR)
|
||||
{
|
||||
if(curr_mode.direction == MODE_DIRECTION_RIGHT)
|
||||
{
|
||||
dir = 1;
|
||||
}
|
||||
}
|
||||
|
||||
controller->SendUpdate
|
||||
(
|
||||
led,
|
||||
curr_mode.value,
|
||||
speed,
|
||||
dir,
|
||||
red,
|
||||
green,
|
||||
blue
|
||||
);
|
||||
|
||||
controller->SendSet();
|
||||
controller->SendApply();
|
||||
}
|
||||
|
||||
void RGBController_AuraCore::DeviceUpdateMode()
|
||||
{
|
||||
if(modes[active_mode].value == AURA_CORE_MODE_DIRECT)
|
||||
{
|
||||
controller->InitDirectMode();
|
||||
}
|
||||
else
|
||||
{
|
||||
DeviceUpdateLEDs();
|
||||
}
|
||||
}
|
||||
/*---------------------------------------------------------*\
|
||||
| RGBController_AsusAuraCore.cpp |
|
||||
| |
|
||||
| RGBController for ASUS ROG Aura Core |
|
||||
| |
|
||||
| Adam Honse (CalcProgrammer1) 13 Apr 2020 |
|
||||
| |
|
||||
| This file is part of the OpenRGB project |
|
||||
| SPDX-License-Identifier: GPL-2.0-or-later |
|
||||
\*---------------------------------------------------------*/
|
||||
|
||||
#include "RGBController_AsusAuraCore.h"
|
||||
|
||||
/**------------------------------------------------------------------*\
|
||||
@name Asus AURA Core
|
||||
@category Keyboard,LEDStrip
|
||||
@type USB
|
||||
@save :x:
|
||||
@direct :rotating_light:
|
||||
@effects :white_check_mark:
|
||||
@detectors DetectAsusAuraCoreControllers
|
||||
@comment
|
||||
\*-------------------------------------------------------------------*/
|
||||
|
||||
RGBController_AuraCore::RGBController_AuraCore(AuraCoreController* controller_ptr)
|
||||
{
|
||||
controller = controller_ptr;
|
||||
|
||||
name = "ASUS Aura Core Device";
|
||||
vendor = "ASUS";
|
||||
location = controller->GetDeviceLocation();
|
||||
serial = controller->GetSerialString();
|
||||
description = "ASUS Aura Core Device";
|
||||
type = DEVICE_TYPE_UNKNOWN;
|
||||
|
||||
if(controller->aura_device.aura_type == AURA_CORE_DEVICE_KEYBOARD)
|
||||
{
|
||||
SetupKeyboard();
|
||||
}
|
||||
else if(controller->aura_device.aura_type == AURA_CORE_DEVICE_GA15DH)
|
||||
{
|
||||
SetupGA15DH();
|
||||
}
|
||||
|
||||
SetupZones();
|
||||
}
|
||||
|
||||
void RGBController_AuraCore::SetupKeyboard()
|
||||
{
|
||||
name = "ASUS Aura Keyboard";
|
||||
vendor = "ASUS";
|
||||
type = DEVICE_TYPE_KEYBOARD;
|
||||
description = "ASUS Aura Core Device";
|
||||
|
||||
mode Static;
|
||||
Static.name = "Static";
|
||||
Static.value = AURA_CORE_MODE_STATIC;
|
||||
Static.flags = MODE_FLAG_HAS_PER_LED_COLOR;
|
||||
Static.color_mode = MODE_COLORS_PER_LED;
|
||||
modes.push_back(Static);
|
||||
|
||||
mode Breathing;
|
||||
Breathing.name = "Breathing";
|
||||
Breathing.value = AURA_CORE_MODE_BREATHING;
|
||||
Breathing.flags = MODE_FLAG_HAS_PER_LED_COLOR;
|
||||
Breathing.color_mode = MODE_COLORS_PER_LED;
|
||||
modes.push_back(Breathing);
|
||||
|
||||
mode ColorCycle;
|
||||
ColorCycle.name = "Color Cycle";
|
||||
ColorCycle.value = AURA_CORE_MODE_SPECTRUM_CYCLE;
|
||||
ColorCycle.flags = 0;
|
||||
ColorCycle.color_mode = MODE_COLORS_NONE;
|
||||
modes.push_back(ColorCycle);
|
||||
}
|
||||
|
||||
void RGBController_AuraCore::SetupGA15DH()
|
||||
{
|
||||
name = "ASUS Aura GA15DH";
|
||||
vendor = "ASUS";
|
||||
type = DEVICE_TYPE_LEDSTRIP;
|
||||
description = "ASUS Aura Core Device";
|
||||
|
||||
mode Static;
|
||||
Static.name = "Static";
|
||||
Static.value = AURA_CORE_MODE_STATIC;
|
||||
Static.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
|
||||
Static.colors_min = 1;
|
||||
Static.colors_max = 1;
|
||||
Static.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Static.colors.resize(1);
|
||||
modes.push_back(Static);
|
||||
|
||||
mode Breathing;
|
||||
Breathing.name = "Breathing";
|
||||
Breathing.value = AURA_CORE_MODE_BREATHING;
|
||||
Breathing.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED;
|
||||
Breathing.speed_min = AURA_CORE_SPEED_SLOW;
|
||||
Breathing.speed_max = AURA_CORE_SPEED_FAST;
|
||||
Breathing.speed = AURA_CORE_SPEED_NORMAL;
|
||||
Breathing.colors_min = 1;
|
||||
Breathing.colors_max = 2;
|
||||
Breathing.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Breathing.colors.resize(2);
|
||||
modes.push_back(Breathing);
|
||||
|
||||
mode ColorCycle;
|
||||
ColorCycle.name = "Color Cycle";
|
||||
ColorCycle.value = AURA_CORE_MODE_SPECTRUM_CYCLE;
|
||||
ColorCycle.flags = MODE_FLAG_HAS_SPEED;
|
||||
ColorCycle.speed_min = AURA_CORE_SPEED_SLOW;
|
||||
ColorCycle.speed_max = AURA_CORE_SPEED_FAST;
|
||||
ColorCycle.speed = AURA_CORE_SPEED_NORMAL;
|
||||
ColorCycle.color_mode = MODE_COLORS_NONE;
|
||||
modes.push_back(ColorCycle);
|
||||
|
||||
mode Rainbow;
|
||||
Rainbow.name = "Rainbow";
|
||||
Rainbow.value = AURA_CORE_MODE_RAINBOW;
|
||||
Rainbow.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
|
||||
Rainbow.speed_min = AURA_CORE_SPEED_SLOW;
|
||||
Rainbow.speed_max = AURA_CORE_SPEED_FAST;
|
||||
Rainbow.speed = AURA_CORE_SPEED_NORMAL;
|
||||
Rainbow.direction = MODE_DIRECTION_RIGHT;
|
||||
Rainbow.color_mode = MODE_COLORS_NONE;
|
||||
modes.push_back(Rainbow);
|
||||
|
||||
mode Strobe;
|
||||
Strobe.name = "Strobe";
|
||||
Strobe.value = AURA_CORE_MODE_STROBE;
|
||||
Strobe.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
|
||||
Strobe.colors_min = 1;
|
||||
Strobe.colors_max = 1;
|
||||
Strobe.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Strobe.colors.resize(1);
|
||||
modes.push_back(Strobe);
|
||||
|
||||
mode Comet;
|
||||
Comet.name = "Comet";
|
||||
Comet.value = AURA_CORE_MODE_COMET;
|
||||
Comet.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
|
||||
Comet.colors_min = 1;
|
||||
Comet.colors_max = 1;
|
||||
Comet.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Comet.colors.resize(1);
|
||||
modes.push_back(Comet);
|
||||
|
||||
mode Flash;
|
||||
Flash.name = "Flash & Dash";
|
||||
Flash.value = AURA_CORE_MODE_FLASHNDASH;
|
||||
Flash.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
|
||||
Flash.colors_min = 1;
|
||||
Flash.colors_max = 1;
|
||||
Flash.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Flash.colors.resize(1);
|
||||
modes.push_back(Flash);
|
||||
|
||||
mode Irradiation;
|
||||
Irradiation.name = "Irradiation";
|
||||
Irradiation.value = AURA_CORE_MODE_IRRADIATION;
|
||||
Irradiation.flags = 0;
|
||||
Irradiation.color_mode = MODE_COLORS_NONE;
|
||||
modes.push_back(Irradiation);
|
||||
|
||||
mode Direct;
|
||||
Static.name = "Direct";
|
||||
Static.value = AURA_CORE_MODE_DIRECT;
|
||||
Static.flags = MODE_FLAG_HAS_PER_LED_COLOR;
|
||||
Static.color_mode = MODE_COLORS_PER_LED;
|
||||
modes.push_back(Static);
|
||||
}
|
||||
|
||||
RGBController_AuraCore::~RGBController_AuraCore()
|
||||
{
|
||||
delete controller;
|
||||
}
|
||||
|
||||
void RGBController_AuraCore::SetupZones()
|
||||
{
|
||||
zone auraZone;
|
||||
|
||||
if(controller->aura_device.aura_type == AURA_CORE_DEVICE_KEYBOARD)
|
||||
{
|
||||
auraZone.name = "Keyboard";
|
||||
auraZone.type = ZONE_TYPE_SINGLE;
|
||||
auraZone.leds_min = 4;
|
||||
auraZone.leds_max = 4;
|
||||
auraZone.leds_count = 4;
|
||||
auraZone.matrix_map = NULL;
|
||||
}
|
||||
else if(controller->aura_device.aura_type == AURA_CORE_DEVICE_GA15DH)
|
||||
{
|
||||
auraZone.name = "GA15DH";
|
||||
auraZone.type = ZONE_TYPE_LINEAR;
|
||||
auraZone.leds_min = 20;
|
||||
auraZone.leds_max = 20;
|
||||
auraZone.leds_count = 20;
|
||||
auraZone.matrix_map = NULL;
|
||||
}
|
||||
else
|
||||
{
|
||||
auraZone.leds_count = 0;
|
||||
}
|
||||
|
||||
zones.push_back(auraZone);
|
||||
|
||||
for(unsigned int led_idx = 0; led_idx < auraZone.leds_count; led_idx++)
|
||||
{
|
||||
led KeyLED;
|
||||
KeyLED.name = auraZone.name + " ";
|
||||
KeyLED.name.append(std::to_string(led_idx + 1));
|
||||
leds.push_back(KeyLED);
|
||||
}
|
||||
|
||||
SetupColors();
|
||||
}
|
||||
|
||||
void RGBController_AuraCore::ResizeZone(int /*zone*/, int /*new_size*/)
|
||||
{
|
||||
/*---------------------------------------------------------*\
|
||||
| This device does not support resizing zones |
|
||||
\*---------------------------------------------------------*/
|
||||
}
|
||||
|
||||
void RGBController_AuraCore::DeviceUpdateLEDs()
|
||||
{
|
||||
UpdateZoneLEDs(0);
|
||||
}
|
||||
|
||||
void RGBController_AuraCore::UpdateZoneLEDs(int /*zone*/)
|
||||
{
|
||||
if(modes[active_mode].value == AURA_CORE_MODE_DIRECT)
|
||||
{
|
||||
std::vector<AuraColor> aura_colors;
|
||||
std::vector<RGBColor>& color_set = colors;
|
||||
|
||||
if(modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC)
|
||||
{
|
||||
color_set = modes[active_mode].colors;
|
||||
}
|
||||
|
||||
for(unsigned int led_idx = 0; led_idx < leds.size(); led_idx++)
|
||||
{
|
||||
AuraColor new_color;
|
||||
|
||||
new_color.red = RGBGetRValue(color_set[led_idx]);
|
||||
new_color.green = RGBGetGValue(color_set[led_idx]);
|
||||
new_color.blue = RGBGetBValue(color_set[led_idx]);
|
||||
|
||||
aura_colors.push_back(new_color);
|
||||
}
|
||||
|
||||
controller->UpdateDirect(aura_colors);
|
||||
}
|
||||
else if(modes[active_mode].color_mode == MODE_COLORS_PER_LED)
|
||||
{
|
||||
for(unsigned int led_idx = 0; led_idx < leds.size(); led_idx++)
|
||||
{
|
||||
UpdateSingleLED(led_idx);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
UpdateSingleLED(0);
|
||||
}
|
||||
}
|
||||
|
||||
void RGBController_AuraCore::UpdateSingleLED(int led)
|
||||
{
|
||||
unsigned char speed = 0xFF;
|
||||
unsigned char red = 0;
|
||||
unsigned char green = 0;
|
||||
unsigned char blue = 0;
|
||||
unsigned char dir = 0;
|
||||
mode& curr_mode = modes[active_mode];
|
||||
|
||||
if(curr_mode.color_mode == MODE_COLORS_PER_LED)
|
||||
{
|
||||
red = RGBGetRValue(colors[led]);
|
||||
green = RGBGetGValue(colors[led]);
|
||||
blue = RGBGetBValue(colors[led]);
|
||||
}
|
||||
else if(curr_mode.color_mode == MODE_COLORS_MODE_SPECIFIC)
|
||||
{
|
||||
red = RGBGetRValue(curr_mode.colors[led]);
|
||||
green = RGBGetGValue(curr_mode.colors[led]);
|
||||
blue = RGBGetBValue(curr_mode.colors[led]);
|
||||
}
|
||||
|
||||
if(curr_mode.flags & MODE_FLAG_HAS_SPEED)
|
||||
{
|
||||
speed = curr_mode.speed;
|
||||
}
|
||||
|
||||
if(curr_mode.flags & MODE_FLAG_HAS_DIRECTION_LR)
|
||||
{
|
||||
if(curr_mode.direction == MODE_DIRECTION_RIGHT)
|
||||
{
|
||||
dir = 1;
|
||||
}
|
||||
}
|
||||
|
||||
controller->SendUpdate
|
||||
(
|
||||
led,
|
||||
curr_mode.value,
|
||||
speed,
|
||||
dir,
|
||||
red,
|
||||
green,
|
||||
blue
|
||||
);
|
||||
|
||||
controller->SendSet();
|
||||
controller->SendApply();
|
||||
}
|
||||
|
||||
void RGBController_AuraCore::DeviceUpdateMode()
|
||||
{
|
||||
if(modes[active_mode].value == AURA_CORE_MODE_DIRECT)
|
||||
{
|
||||
controller->InitDirectMode();
|
||||
}
|
||||
else
|
||||
{
|
||||
DeviceUpdateLEDs();
|
||||
}
|
||||
}
|
||||
+37
-37
@@ -1,37 +1,37 @@
|
||||
/*---------------------------------------------------------*\
|
||||
| RGBController_AsusAuraCore.h |
|
||||
| |
|
||||
| RGBController for ASUS ROG Aura Core |
|
||||
| |
|
||||
| Adam Honse (CalcProgrammer1) 13 Apr 2020 |
|
||||
| |
|
||||
| This file is part of the OpenRGB project |
|
||||
| SPDX-License-Identifier: GPL-2.0-or-later |
|
||||
\*---------------------------------------------------------*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include "RGBController.h"
|
||||
#include "AsusAuraCoreController.h"
|
||||
|
||||
class RGBController_AuraCore : public RGBController
|
||||
{
|
||||
public:
|
||||
RGBController_AuraCore(AuraCoreController* controller_ptr);
|
||||
~RGBController_AuraCore();
|
||||
|
||||
void SetupKeyboard();
|
||||
void SetupGA15DH();
|
||||
void SetupZones();
|
||||
|
||||
void ResizeZone(int zone, int new_size);
|
||||
|
||||
void DeviceUpdateLEDs();
|
||||
void UpdateZoneLEDs(int zone);
|
||||
void UpdateSingleLED(int led);
|
||||
|
||||
void DeviceUpdateMode();
|
||||
|
||||
private:
|
||||
AuraCoreController* controller;
|
||||
};
|
||||
/*---------------------------------------------------------*\
|
||||
| RGBController_AsusAuraCore.h |
|
||||
| |
|
||||
| RGBController for ASUS ROG Aura Core |
|
||||
| |
|
||||
| Adam Honse (CalcProgrammer1) 13 Apr 2020 |
|
||||
| |
|
||||
| This file is part of the OpenRGB project |
|
||||
| SPDX-License-Identifier: GPL-2.0-or-later |
|
||||
\*---------------------------------------------------------*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include "RGBController.h"
|
||||
#include "AsusAuraCoreController.h"
|
||||
|
||||
class RGBController_AuraCore : public RGBController
|
||||
{
|
||||
public:
|
||||
RGBController_AuraCore(AuraCoreController* controller_ptr);
|
||||
~RGBController_AuraCore();
|
||||
|
||||
void SetupKeyboard();
|
||||
void SetupGA15DH();
|
||||
void SetupZones();
|
||||
|
||||
void ResizeZone(int zone, int new_size);
|
||||
|
||||
void DeviceUpdateLEDs();
|
||||
void UpdateZoneLEDs(int zone);
|
||||
void UpdateSingleLED(int led);
|
||||
|
||||
void DeviceUpdateMode();
|
||||
|
||||
private:
|
||||
AuraCoreController* controller;
|
||||
};
|
||||
@@ -1,68 +1,68 @@
|
||||
/*---------------------------------------------------------*\
|
||||
| AsusAuraCoreControllerDetect.cpp |
|
||||
| |
|
||||
| Detector for ASUS ROG Aura Core |
|
||||
| |
|
||||
| Adam Honse (CalcProgrammer1) 13 Apr 2020 |
|
||||
| Chris M (Dr_No) 28 Jul 2022 |
|
||||
| |
|
||||
| This file is part of the OpenRGB project |
|
||||
| SPDX-License-Identifier: GPL-2.0-or-later |
|
||||
\*---------------------------------------------------------*/
|
||||
|
||||
#include "Detector.h"
|
||||
#include "AsusAuraCoreController.h"
|
||||
#include "RGBController.h"
|
||||
#include "RGBController_AsusAuraCore.h"
|
||||
#include "RGBController_AsusAuraCoreLaptop.h"
|
||||
#include <hidapi.h>
|
||||
|
||||
#define AURA_CORE_VID 0x0B05
|
||||
|
||||
/******************************************************************************************\
|
||||
* *
|
||||
* DetectAuraCoreControllers *
|
||||
* *
|
||||
* Tests the USB address to see if an Asus ROG Aura Core controller exists there *
|
||||
* *
|
||||
\******************************************************************************************/
|
||||
|
||||
void DetectAsusAuraCoreControllers(hid_device_info* info, const std::string& /*name*/)
|
||||
{
|
||||
hid_device* dev = hid_open_path(info->path);
|
||||
|
||||
if(dev)
|
||||
{
|
||||
AuraCoreController* controller = new AuraCoreController(dev, info->path);
|
||||
RGBController_AuraCore* rgb_controller = new RGBController_AuraCore(controller);
|
||||
|
||||
if(rgb_controller->type != DEVICE_TYPE_UNKNOWN)
|
||||
{
|
||||
ResourceManager::get()->RegisterRGBController(rgb_controller);
|
||||
}
|
||||
else
|
||||
{
|
||||
delete rgb_controller;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void DetectAsusAuraCoreLaptopControllers(hid_device_info* info, const std::string& /*name*/)
|
||||
{
|
||||
hid_device* dev = hid_open_path(info->path);
|
||||
|
||||
if(dev)
|
||||
{
|
||||
AsusAuraCoreLaptopController* controller = new AsusAuraCoreLaptopController(dev, info->path);
|
||||
RGBController_AsusAuraCoreLaptop* rgb_controller = new RGBController_AsusAuraCoreLaptop(controller);
|
||||
|
||||
ResourceManager::get()->RegisterRGBController(rgb_controller);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
REGISTER_HID_DETECTOR ("ASUS Aura Core", DetectAsusAuraCoreControllers, AURA_CORE_VID, 0x1854);
|
||||
REGISTER_HID_DETECTOR ("ASUS Aura Core", DetectAsusAuraCoreControllers, AURA_CORE_VID, 0x1866);
|
||||
REGISTER_HID_DETECTOR ("ASUS Aura Core", DetectAsusAuraCoreControllers, AURA_CORE_VID, 0x1869);
|
||||
REGISTER_HID_DETECTOR_PU("ASUS ROG Strix SCAR 15", DetectAsusAuraCoreLaptopControllers, AURA_CORE_VID, AURA_STRIX_SCAR_15_PID, 0xFF31, 0x79);
|
||||
REGISTER_HID_DETECTOR_PU("ASUS ROG Strix SCAR 17", DetectAsusAuraCoreLaptopControllers, AURA_CORE_VID, 0x1866, 0xFF31, 0x79);
|
||||
/*---------------------------------------------------------*\
|
||||
| AsusAuraCoreControllerDetect.cpp |
|
||||
| |
|
||||
| Detector for ASUS ROG Aura Core |
|
||||
| |
|
||||
| Adam Honse (CalcProgrammer1) 13 Apr 2020 |
|
||||
| Chris M (Dr_No) 28 Jul 2022 |
|
||||
| |
|
||||
| This file is part of the OpenRGB project |
|
||||
| SPDX-License-Identifier: GPL-2.0-or-later |
|
||||
\*---------------------------------------------------------*/
|
||||
|
||||
#include "Detector.h"
|
||||
#include "AsusAuraCoreController.h"
|
||||
#include "RGBController.h"
|
||||
#include "RGBController_AsusAuraCore.h"
|
||||
#include "RGBController_AsusAuraCoreLaptop.h"
|
||||
#include <hidapi.h>
|
||||
|
||||
#define AURA_CORE_VID 0x0B05
|
||||
|
||||
/******************************************************************************************\
|
||||
* *
|
||||
* DetectAuraCoreControllers *
|
||||
* *
|
||||
* Tests the USB address to see if an Asus ROG Aura Core controller exists there *
|
||||
* *
|
||||
\******************************************************************************************/
|
||||
|
||||
void DetectAsusAuraCoreControllers(hid_device_info* info, const std::string& /*name*/)
|
||||
{
|
||||
hid_device* dev = hid_open_path(info->path);
|
||||
|
||||
if(dev)
|
||||
{
|
||||
AuraCoreController* controller = new AuraCoreController(dev, info->path);
|
||||
RGBController_AuraCore* rgb_controller = new RGBController_AuraCore(controller);
|
||||
|
||||
if(rgb_controller->type != DEVICE_TYPE_UNKNOWN)
|
||||
{
|
||||
ResourceManager::get()->RegisterRGBController(rgb_controller);
|
||||
}
|
||||
else
|
||||
{
|
||||
delete rgb_controller;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void DetectAsusAuraCoreLaptopControllers(hid_device_info* info, const std::string& /*name*/)
|
||||
{
|
||||
hid_device* dev = hid_open_path(info->path);
|
||||
|
||||
if(dev)
|
||||
{
|
||||
AsusAuraCoreLaptopController* controller = new AsusAuraCoreLaptopController(dev, info->path);
|
||||
RGBController_AsusAuraCoreLaptop* rgb_controller = new RGBController_AsusAuraCoreLaptop(controller);
|
||||
|
||||
ResourceManager::get()->RegisterRGBController(rgb_controller);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
REGISTER_HID_DETECTOR ("ASUS Aura Core", DetectAsusAuraCoreControllers, AURA_CORE_VID, 0x1854);
|
||||
REGISTER_HID_DETECTOR ("ASUS Aura Core", DetectAsusAuraCoreControllers, AURA_CORE_VID, 0x1866);
|
||||
REGISTER_HID_DETECTOR ("ASUS Aura Core", DetectAsusAuraCoreControllers, AURA_CORE_VID, 0x1869);
|
||||
REGISTER_HID_DETECTOR_PU("ASUS ROG Strix SCAR 15", DetectAsusAuraCoreLaptopControllers, AURA_CORE_VID, AURA_STRIX_SCAR_15_PID, 0xFF31, 0x79);
|
||||
REGISTER_HID_DETECTOR_PU("ASUS ROG Strix SCAR 17", DetectAsusAuraCoreLaptopControllers, AURA_CORE_VID, 0x1866, 0xFF31, 0x79);
|
||||
+446
-446
@@ -1,446 +1,446 @@
|
||||
/*---------------------------------------------------------*\
|
||||
| AsusAuraCoreLaptopController.cpp |
|
||||
| |
|
||||
| Driver for ASUS ROG Aura Core Laptop |
|
||||
| |
|
||||
| Chris M (Dr_No) 28 Jul 2022 |
|
||||
| |
|
||||
| This file is part of the OpenRGB project |
|
||||
| SPDX-License-Identifier: GPL-2.0-or-later |
|
||||
\*---------------------------------------------------------*/
|
||||
|
||||
#include "AsusAuraCoreLaptopController.h"
|
||||
#include "dmiinfo.h"
|
||||
#include "SettingsManager.h"
|
||||
#include "StringUtils.h"
|
||||
|
||||
static std::string power_zones[ASUSAURACORELAPTOP_POWER_ZONES] =
|
||||
{
|
||||
"Logo",
|
||||
ZONE_EN_KEYBOARD,
|
||||
"Lightbar",
|
||||
"Lid Edges"
|
||||
};
|
||||
|
||||
static std::string power_states[ASUSAURACORELAPTOP_POWER_STATES] =
|
||||
{
|
||||
" when booting",
|
||||
" when awake",
|
||||
" when sleeping",
|
||||
" when off",
|
||||
};
|
||||
|
||||
AsusAuraCoreLaptopController::AsusAuraCoreLaptopController(hid_device* dev_handle, const char* path)
|
||||
{
|
||||
dev = dev_handle;
|
||||
location = path;
|
||||
|
||||
/*---------------------------------------------------------*\
|
||||
| The motherboard name will uniquely ID the laptop to |
|
||||
| determine the metadata of the device. |
|
||||
\*---------------------------------------------------------*/
|
||||
DMIInfo dmi_info;
|
||||
std::string dmi_name = dmi_info.getMainboard();
|
||||
bool not_found = true;
|
||||
|
||||
for(uint16_t i = 0; i < AURA_CORE_LAPTOP_DEVICE_COUNT; i++)
|
||||
{
|
||||
if(aura_core_laptop_device_list[i]->dmi_name == dmi_name)
|
||||
{
|
||||
/*---------------------------------------------------------*\
|
||||
| Set device ID |
|
||||
\*---------------------------------------------------------*/
|
||||
not_found = false;
|
||||
device_index = i;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if(not_found)
|
||||
{
|
||||
LOG_ERROR("[%s] device capabilities not found. Please creata a new device request.",
|
||||
dmi_name.c_str());
|
||||
return;
|
||||
}
|
||||
|
||||
/*---------------------------------------------------------*\
|
||||
| Only set power config for known devices |
|
||||
\*---------------------------------------------------------*/
|
||||
SetPowerConfigFromJSON();
|
||||
SendInitDirectMode();
|
||||
}
|
||||
|
||||
AsusAuraCoreLaptopController::~AsusAuraCoreLaptopController()
|
||||
{
|
||||
hid_close(dev);
|
||||
}
|
||||
|
||||
const aura_core_laptop_device* AsusAuraCoreLaptopController::GetDeviceData()
|
||||
{
|
||||
return aura_core_laptop_device_list[device_index];
|
||||
}
|
||||
|
||||
std::string AsusAuraCoreLaptopController::GetDeviceDescription()
|
||||
{
|
||||
/*---------------------------------------------------------*\
|
||||
| Get device name from HID manufacturer and product strings |
|
||||
\*---------------------------------------------------------*/
|
||||
wchar_t name_string[HID_MAX_STR];
|
||||
|
||||
hid_get_manufacturer_string(dev, name_string, HID_MAX_STR);
|
||||
std::string name = StringUtils::wstring_to_string(name_string);
|
||||
|
||||
hid_get_product_string(dev, name_string, HID_MAX_STR);
|
||||
name.append(" ").append(StringUtils::wstring_to_string(name_string));
|
||||
return name;
|
||||
}
|
||||
|
||||
unsigned int AsusAuraCoreLaptopController::GetKeyboardLayout()
|
||||
{
|
||||
const uint8_t index = 6;
|
||||
uint8_t result = 0;
|
||||
uint8_t rd_buf[ASUSAURACORELAPTOP_WRITE_PACKET_SIZE] = { ASUSAURACORELAPTOP_REPORT_ID };
|
||||
uint8_t buffer[ASUSAURACORELAPTOP_WRITE_PACKET_SIZE] = { ASUSAURACORELAPTOP_REPORT_ID,
|
||||
ASUSAURACORELAPTOP_CMD_LAYOUT,
|
||||
0x20,
|
||||
0x31,
|
||||
0x00,
|
||||
0x10 };
|
||||
|
||||
/*---------------------------------------------------------*\
|
||||
| Clear the read buffer to ensure we read the right packet |
|
||||
\*---------------------------------------------------------*/
|
||||
do
|
||||
{
|
||||
result = hid_read_timeout(dev, rd_buf, ASUSAURACORELAPTOP_WRITE_PACKET_SIZE, 10);
|
||||
}
|
||||
while(result > 0);
|
||||
|
||||
memset(&rd_buf[1], 0, ASUSAURACORELAPTOP_WRITE_PACKET_SIZE - 1);
|
||||
memset(&buffer[index], 0, ASUSAURACORELAPTOP_WRITE_PACKET_SIZE - index);
|
||||
|
||||
hid_send_feature_report(dev, buffer, ASUSAURACORELAPTOP_WRITE_PACKET_SIZE);
|
||||
result = hid_get_feature_report(dev, rd_buf, ASUSAURACORELAPTOP_WRITE_PACKET_SIZE);
|
||||
|
||||
LOG_DEBUG("[%s] GetKeyboardLayout %02X %02X %02X %02X %02X %02X %02X {%02X} %02X %02X %02X %02X",
|
||||
aura_core_laptop_device_list[device_index]->dmi_name.c_str(),
|
||||
rd_buf[5], rd_buf[6], rd_buf[7], rd_buf[8], rd_buf[9], rd_buf[10],
|
||||
rd_buf[11], rd_buf[12], rd_buf[13], rd_buf[14], rd_buf[15], rd_buf[16]);
|
||||
|
||||
if(result > 0)
|
||||
{
|
||||
return rd_buf[12];
|
||||
}
|
||||
|
||||
LOG_DEBUG("[%s] GetKeyboardLayout: An error occurred! Setting layout to ANSI",
|
||||
aura_core_laptop_device_list[device_index]->dmi_name.c_str());
|
||||
return ASUSAURACORELAPTOP_LAYOUT_ANSI;
|
||||
}
|
||||
|
||||
std::string AsusAuraCoreLaptopController::GetSerial()
|
||||
{
|
||||
wchar_t serial_string[128];
|
||||
int ret = hid_get_serial_number_string(dev, serial_string, 128);
|
||||
|
||||
if(ret != 0)
|
||||
{
|
||||
LOG_DEBUG("[%s] Get HID Serial string failed",
|
||||
aura_core_laptop_device_list[device_index]->dmi_name.c_str());
|
||||
return("");
|
||||
}
|
||||
|
||||
return(StringUtils::wstring_to_string(serial_string));
|
||||
}
|
||||
|
||||
std::string AsusAuraCoreLaptopController::GetLocation()
|
||||
{
|
||||
return("HID: " + location);
|
||||
}
|
||||
|
||||
void AsusAuraCoreLaptopController::SetMode(uint8_t mode, uint8_t speed, uint8_t brightness, RGBColor color1, RGBColor color2, uint8_t random, uint8_t direction)
|
||||
{
|
||||
bool needs_update = !( (current_mode == mode ) &&
|
||||
(current_speed == speed ) &&
|
||||
(current_brightness == brightness ) &&
|
||||
(current_c1 == color1 ) &&
|
||||
(current_c2 == color2 ) &&
|
||||
(current_random == random ) &&
|
||||
(current_direction == direction ) );
|
||||
|
||||
if(needs_update)
|
||||
{
|
||||
current_mode = mode;
|
||||
current_speed = speed;
|
||||
current_brightness = brightness;
|
||||
current_c1 = color1;
|
||||
current_c2 = color2;
|
||||
current_random = random;
|
||||
current_direction = direction;
|
||||
|
||||
if(current_mode == ASUSAURACORELAPTOP_MODE_DIRECT)
|
||||
{
|
||||
SendBrightness();
|
||||
SendInitDirectMode();
|
||||
return;
|
||||
}
|
||||
|
||||
SendUpdate();
|
||||
SendBrightness();
|
||||
}
|
||||
}
|
||||
|
||||
void AsusAuraCoreLaptopController::SendInitDirectMode()
|
||||
{
|
||||
uint8_t buffer[ASUSAURACORELAPTOP_WRITE_PACKET_SIZE] = { ASUSAURACORELAPTOP_REPORT_ID, ASUSAURACORELAPTOP_CMD_DIRECT };
|
||||
memset(&buffer[2], 0, ASUSAURACORELAPTOP_WRITE_PACKET_SIZE - 2);
|
||||
|
||||
LOG_DEBUG("[%s] Resetting device for direct control", aura_core_laptop_device_list[device_index]->dmi_name.c_str());
|
||||
hid_send_feature_report(dev, buffer, ASUSAURACORELAPTOP_WRITE_PACKET_SIZE);
|
||||
}
|
||||
|
||||
void AsusAuraCoreLaptopController::SetLedsDirect(std::vector<RGBColor *> colors)
|
||||
{
|
||||
/*---------------------------------------------------------*\
|
||||
| The keyboard zone is a set of 168 keys (indexed from 0) |
|
||||
| sent in 11 packets of 16 triplets. The Lid and Lightbar |
|
||||
| zones are sent in one final packet afterwards. |
|
||||
\*---------------------------------------------------------*/
|
||||
const uint8_t key_set = 167;
|
||||
const uint8_t led_count = (uint8_t)colors.size();
|
||||
const uint16_t map_size = 3 * led_count;
|
||||
const uint8_t leds_per_packet = 16;
|
||||
uint8_t buffer[ASUSAURACORELAPTOP_WRITE_PACKET_SIZE] = { ASUSAURACORELAPTOP_REPORT_ID, ASUSAURACORELAPTOP_CMD_DIRECT,
|
||||
0x00, 0x01, 0x01, 0x01, 0x00, leds_per_packet, 0x00 };
|
||||
uint8_t* key_buf = new uint8_t[map_size];
|
||||
|
||||
memset(key_buf, 0, map_size);
|
||||
|
||||
for(uint8_t led_index = 0; led_index < led_count; led_index++)
|
||||
{
|
||||
std::size_t buf_idx = (led_index * 3);
|
||||
|
||||
key_buf[buf_idx] = RGBGetRValue(*colors[led_index]);
|
||||
key_buf[buf_idx + 1] = RGBGetGValue(*colors[led_index]);
|
||||
key_buf[buf_idx + 2] = RGBGetBValue(*colors[led_index]);
|
||||
}
|
||||
|
||||
for(uint8_t i = 0; i < key_set; i += leds_per_packet)
|
||||
{
|
||||
uint8_t leds_remaining = key_set - i;
|
||||
|
||||
if(leds_remaining < leds_per_packet)
|
||||
{
|
||||
buffer[07] = leds_remaining;
|
||||
|
||||
memset(&buffer[ASUSAURACORELAPTOP_DATA_BYTE],
|
||||
0,
|
||||
ASUSAURACORELAPTOP_WRITE_PACKET_SIZE - ASUSAURACORELAPTOP_DATA_BYTE);
|
||||
}
|
||||
|
||||
buffer[06] = i;
|
||||
memcpy(&buffer[ASUSAURACORELAPTOP_DATA_BYTE], &key_buf[3 * i], (3 * buffer[07]));
|
||||
|
||||
LOG_DEBUG("[%s] Sending buffer @ index %d thru index %d",
|
||||
aura_core_laptop_device_list[device_index]->dmi_name.c_str(),
|
||||
i,
|
||||
i + buffer[07]);
|
||||
|
||||
hid_send_feature_report(dev, buffer, ASUSAURACORELAPTOP_WRITE_PACKET_SIZE);
|
||||
}
|
||||
|
||||
buffer[4] = 0x04;
|
||||
buffer[5] = 0x00;
|
||||
buffer[6] = 0x00;
|
||||
buffer[7] = 0x00;
|
||||
|
||||
memset(&buffer[ASUSAURACORELAPTOP_DATA_BYTE],
|
||||
0,
|
||||
ASUSAURACORELAPTOP_WRITE_PACKET_SIZE - ASUSAURACORELAPTOP_DATA_BYTE);
|
||||
|
||||
if(led_count > key_set)
|
||||
{
|
||||
memcpy(&buffer[ASUSAURACORELAPTOP_DATA_BYTE],
|
||||
&key_buf[3 * key_set],
|
||||
(3 * (led_count - key_set)));
|
||||
}
|
||||
|
||||
LOG_DEBUG("[%s] Sending buffer @ index %d thru index %d",
|
||||
aura_core_laptop_device_list[device_index]->dmi_name.c_str(),
|
||||
key_set,
|
||||
led_count);
|
||||
|
||||
hid_send_feature_report(dev, buffer, ASUSAURACORELAPTOP_WRITE_PACKET_SIZE);
|
||||
delete[] key_buf;
|
||||
}
|
||||
|
||||
void AsusAuraCoreLaptopController::SendBrightness()
|
||||
{
|
||||
const uint8_t index = 5;
|
||||
uint8_t buffer[ASUSAURACORELAPTOP_WRITE_PACKET_SIZE] = { ASUSAURACORELAPTOP_REPORT_ID, ASUSAURACORELAPTOP_CMD_BRIGHTNESS, 0xC5, 0xC4};
|
||||
|
||||
memset(&buffer[index], 0, ASUSAURACORELAPTOP_WRITE_PACKET_SIZE - index);
|
||||
buffer[4] = current_brightness;
|
||||
|
||||
hid_send_feature_report(dev, buffer, ASUSAURACORELAPTOP_WRITE_PACKET_SIZE);
|
||||
}
|
||||
|
||||
void AsusAuraCoreLaptopController::SendUpdate()
|
||||
{
|
||||
uint8_t buffer[ASUSAURACORELAPTOP_WRITE_PACKET_SIZE] = { ASUSAURACORELAPTOP_REPORT_ID, ASUSAURACORELAPTOP_CMD_UPDATE };
|
||||
|
||||
buffer[ASUSAURACORELAPTOP_ZONE_BYTE] = 0;
|
||||
buffer[ASUSAURACORELAPTOP_MODE_BYTE] = current_mode;
|
||||
buffer[ASUSAURACORELAPTOP_R1_BYTE] = RGBGetRValue(current_c1);
|
||||
buffer[ASUSAURACORELAPTOP_G1_BYTE] = RGBGetGValue(current_c1);
|
||||
buffer[ASUSAURACORELAPTOP_B1_BYTE] = RGBGetBValue(current_c1);
|
||||
buffer[ASUSAURACORELAPTOP_SPEED_BYTE] = current_speed;
|
||||
buffer[ASUSAURACORELAPTOP_DIRECTION_BYTE] = current_direction;
|
||||
buffer[ASUSAURACORELAPTOP_DATA_BYTE] = current_random;
|
||||
buffer[ASUSAURACORELAPTOP_R2_BYTE] = RGBGetRValue(current_c2);
|
||||
buffer[ASUSAURACORELAPTOP_G2_BYTE] = RGBGetGValue(current_c2);
|
||||
buffer[ASUSAURACORELAPTOP_B2_BYTE] = RGBGetBValue(current_c2);
|
||||
|
||||
hid_send_feature_report(dev, buffer, ASUSAURACORELAPTOP_WRITE_PACKET_SIZE);
|
||||
|
||||
SendApply();
|
||||
}
|
||||
|
||||
void AsusAuraCoreLaptopController::SendApply()
|
||||
{
|
||||
const uint8_t index = 2;
|
||||
uint8_t buffer[ASUSAURACORELAPTOP_WRITE_PACKET_SIZE] = { ASUSAURACORELAPTOP_REPORT_ID, ASUSAURACORELAPTOP_CMD_APPLY };
|
||||
|
||||
memset(&buffer[index], 0, ASUSAURACORELAPTOP_WRITE_PACKET_SIZE - index);
|
||||
|
||||
hid_send_feature_report(dev, buffer, ASUSAURACORELAPTOP_WRITE_PACKET_SIZE);
|
||||
}
|
||||
|
||||
void AsusAuraCoreLaptopController::SendSet()
|
||||
{
|
||||
const uint8_t index = 2;
|
||||
uint8_t buffer[ASUSAURACORELAPTOP_WRITE_PACKET_SIZE] = { ASUSAURACORELAPTOP_REPORT_ID, ASUSAURACORELAPTOP_CMD_SET };
|
||||
|
||||
memset(&buffer[index], 0, ASUSAURACORELAPTOP_WRITE_PACKET_SIZE - index);
|
||||
|
||||
hid_send_feature_report(dev, buffer, ASUSAURACORELAPTOP_WRITE_PACKET_SIZE);
|
||||
}
|
||||
|
||||
std::vector<p_state> AsusAuraCoreLaptopController::PowerConfigArray()
|
||||
{
|
||||
std::vector<p_state> temp;
|
||||
|
||||
for(uint8_t zone_index = 0; zone_index < ASUSAURACORELAPTOP_POWER_ZONES; zone_index++)
|
||||
{
|
||||
for(uint8_t state_index = 0; state_index < ASUSAURACORELAPTOP_POWER_STATES; state_index++)
|
||||
{
|
||||
p_state new_state;
|
||||
|
||||
new_state.zone = power_zones[zone_index] + power_states[state_index];
|
||||
new_state.state = true;
|
||||
|
||||
temp.push_back(new_state);
|
||||
}
|
||||
}
|
||||
|
||||
return temp;
|
||||
}
|
||||
|
||||
void AsusAuraCoreLaptopController::SetPowerConfigFromJSON()
|
||||
{
|
||||
std::vector<p_state> power_config = PowerConfigArray();
|
||||
const std::string section_power = "PowerConfig";
|
||||
const std::string detector_name = "Asus Aura Core Laptop";
|
||||
SettingsManager* settings_manager = ResourceManager::get()->GetSettingsManager();
|
||||
json device_settings = settings_manager->GetSettings(detector_name);
|
||||
|
||||
/*---------------------------------------------------------*\
|
||||
| Get Power state config from the settings manager |
|
||||
| If PowerConfig is not found then write it to settings |
|
||||
\*---------------------------------------------------------*/
|
||||
if(!device_settings.contains(section_power))
|
||||
{
|
||||
json pcfg;
|
||||
|
||||
for(size_t i = 0; i < power_config.size(); i++)
|
||||
{
|
||||
pcfg[power_config[i].zone] = power_config[i].state;
|
||||
}
|
||||
|
||||
device_settings[section_power] = pcfg;
|
||||
settings_manager->SetSettings(detector_name, device_settings);
|
||||
settings_manager->SaveSettings();
|
||||
LOG_DEBUG("[%s] default power config saved to openrgb.json",
|
||||
aura_core_laptop_device_list[device_index]->dmi_name.c_str());
|
||||
}
|
||||
else
|
||||
{
|
||||
for(size_t i = 0; i < power_config.size(); i++)
|
||||
{
|
||||
std::string key_name = power_config[i].zone;
|
||||
|
||||
if(device_settings[section_power].contains(key_name))
|
||||
{
|
||||
power_config[i].state = device_settings[section_power][key_name];
|
||||
LOG_DEBUG("[%s] Reading power config for %s: %s",
|
||||
aura_core_laptop_device_list[device_index]->dmi_name.c_str(),
|
||||
key_name.c_str(), ((power_config[i].state) ? "On" : "Off"));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/*-----------------------------------------------------------------------------*\
|
||||
| Power state flags are packed in zones but the order is inconsistent. |
|
||||
| With thanks to AsusCtl for helping to decipher the packet captures |
|
||||
| https://gitlab.com/asus-linux/asusctl/-/blob/main/rog-aura/src/usb.rs#L150 |
|
||||
\*-----------------------------------------------------------------------------*/
|
||||
bool flag_array[32] =
|
||||
{
|
||||
power_config[0].state, power_config[4].state,
|
||||
power_config[1].state, power_config[5].state,
|
||||
!power_config[2].state, !power_config[6].state,
|
||||
!power_config[3].state, !power_config[7].state,
|
||||
|
||||
false, power_config[8].state,
|
||||
power_config[9].state, !power_config[10].state,
|
||||
!power_config[11].state, false,
|
||||
false, false,
|
||||
|
||||
power_config[12].state, power_config[13].state,
|
||||
!power_config[14].state, !power_config[15].state
|
||||
};
|
||||
|
||||
uint32_t flags = PackPowerFlags(flag_array);
|
||||
LOG_DEBUG("[%s] Sending power config Logo+KB: %02X Lightbar: %02X Lid Edges: %02X Raw: %08X",
|
||||
aura_core_laptop_device_list[device_index]->dmi_name.c_str(),
|
||||
(flags & 0xFF), ((flags >> 8) & 0xFF), ((flags >> 16) & 0xFF), flags);
|
||||
SendPowerConfig(flags);
|
||||
}
|
||||
|
||||
void AsusAuraCoreLaptopController::SendPowerConfig(uint32_t flags)
|
||||
{
|
||||
const uint8_t index = 6;
|
||||
uint8_t buffer[ASUSAURACORELAPTOP_WRITE_PACKET_SIZE] = { ASUSAURACORELAPTOP_REPORT_ID, ASUSAURACORELAPTOP_CMD_POWER, 0x01, 0x00, 0x00, 0x0F };
|
||||
|
||||
memset(&buffer[index], 0, ASUSAURACORELAPTOP_WRITE_PACKET_SIZE - index);
|
||||
|
||||
buffer[3] = flags & 0xFF;
|
||||
buffer[4] = (flags >> 8) & 0xFF;
|
||||
buffer[5] = (flags >> 16) & 0xFF;
|
||||
|
||||
hid_send_feature_report(dev, buffer, ASUSAURACORELAPTOP_WRITE_PACKET_SIZE);
|
||||
}
|
||||
|
||||
uint32_t AsusAuraCoreLaptopController::PackPowerFlags(bool flags[])
|
||||
{
|
||||
uint32_t temp = {};
|
||||
const uint8_t length = 32;
|
||||
|
||||
for (size_t i = 0; i < length; ++i)
|
||||
{
|
||||
uint32_t flag = {flags[i]};
|
||||
flag <<= i;
|
||||
temp |= flag;
|
||||
}
|
||||
|
||||
return temp;
|
||||
}
|
||||
/*---------------------------------------------------------*\
|
||||
| AsusAuraCoreLaptopController.cpp |
|
||||
| |
|
||||
| Driver for ASUS ROG Aura Core Laptop |
|
||||
| |
|
||||
| Chris M (Dr_No) 28 Jul 2022 |
|
||||
| |
|
||||
| This file is part of the OpenRGB project |
|
||||
| SPDX-License-Identifier: GPL-2.0-or-later |
|
||||
\*---------------------------------------------------------*/
|
||||
|
||||
#include "AsusAuraCoreLaptopController.h"
|
||||
#include "dmiinfo.h"
|
||||
#include "SettingsManager.h"
|
||||
#include "StringUtils.h"
|
||||
|
||||
static std::string power_zones[ASUSAURACORELAPTOP_POWER_ZONES] =
|
||||
{
|
||||
"Logo",
|
||||
ZONE_EN_KEYBOARD,
|
||||
"Lightbar",
|
||||
"Lid Edges"
|
||||
};
|
||||
|
||||
static std::string power_states[ASUSAURACORELAPTOP_POWER_STATES] =
|
||||
{
|
||||
" when booting",
|
||||
" when awake",
|
||||
" when sleeping",
|
||||
" when off",
|
||||
};
|
||||
|
||||
AsusAuraCoreLaptopController::AsusAuraCoreLaptopController(hid_device* dev_handle, const char* path)
|
||||
{
|
||||
dev = dev_handle;
|
||||
location = path;
|
||||
|
||||
/*---------------------------------------------------------*\
|
||||
| The motherboard name will uniquely ID the laptop to |
|
||||
| determine the metadata of the device. |
|
||||
\*---------------------------------------------------------*/
|
||||
DMIInfo dmi_info;
|
||||
std::string dmi_name = dmi_info.getMainboard();
|
||||
bool not_found = true;
|
||||
|
||||
for(uint16_t i = 0; i < AURA_CORE_LAPTOP_DEVICE_COUNT; i++)
|
||||
{
|
||||
if(aura_core_laptop_device_list[i]->dmi_name == dmi_name)
|
||||
{
|
||||
/*---------------------------------------------------------*\
|
||||
| Set device ID |
|
||||
\*---------------------------------------------------------*/
|
||||
not_found = false;
|
||||
device_index = i;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if(not_found)
|
||||
{
|
||||
LOG_ERROR("[%s] device capabilities not found. Please creata a new device request.",
|
||||
dmi_name.c_str());
|
||||
return;
|
||||
}
|
||||
|
||||
/*---------------------------------------------------------*\
|
||||
| Only set power config for known devices |
|
||||
\*---------------------------------------------------------*/
|
||||
SetPowerConfigFromJSON();
|
||||
SendInitDirectMode();
|
||||
}
|
||||
|
||||
AsusAuraCoreLaptopController::~AsusAuraCoreLaptopController()
|
||||
{
|
||||
hid_close(dev);
|
||||
}
|
||||
|
||||
const aura_core_laptop_device* AsusAuraCoreLaptopController::GetDeviceData()
|
||||
{
|
||||
return aura_core_laptop_device_list[device_index];
|
||||
}
|
||||
|
||||
std::string AsusAuraCoreLaptopController::GetDeviceDescription()
|
||||
{
|
||||
/*---------------------------------------------------------*\
|
||||
| Get device name from HID manufacturer and product strings |
|
||||
\*---------------------------------------------------------*/
|
||||
wchar_t name_string[HID_MAX_STR];
|
||||
|
||||
hid_get_manufacturer_string(dev, name_string, HID_MAX_STR);
|
||||
std::string name = StringUtils::wstring_to_string(name_string);
|
||||
|
||||
hid_get_product_string(dev, name_string, HID_MAX_STR);
|
||||
name.append(" ").append(StringUtils::wstring_to_string(name_string));
|
||||
return name;
|
||||
}
|
||||
|
||||
unsigned int AsusAuraCoreLaptopController::GetKeyboardLayout()
|
||||
{
|
||||
const uint8_t index = 6;
|
||||
uint8_t result = 0;
|
||||
uint8_t rd_buf[ASUSAURACORELAPTOP_WRITE_PACKET_SIZE] = { ASUSAURACORELAPTOP_REPORT_ID };
|
||||
uint8_t buffer[ASUSAURACORELAPTOP_WRITE_PACKET_SIZE] = { ASUSAURACORELAPTOP_REPORT_ID,
|
||||
ASUSAURACORELAPTOP_CMD_LAYOUT,
|
||||
0x20,
|
||||
0x31,
|
||||
0x00,
|
||||
0x10 };
|
||||
|
||||
/*---------------------------------------------------------*\
|
||||
| Clear the read buffer to ensure we read the right packet |
|
||||
\*---------------------------------------------------------*/
|
||||
do
|
||||
{
|
||||
result = hid_read_timeout(dev, rd_buf, ASUSAURACORELAPTOP_WRITE_PACKET_SIZE, 10);
|
||||
}
|
||||
while(result > 0);
|
||||
|
||||
memset(&rd_buf[1], 0, ASUSAURACORELAPTOP_WRITE_PACKET_SIZE - 1);
|
||||
memset(&buffer[index], 0, ASUSAURACORELAPTOP_WRITE_PACKET_SIZE - index);
|
||||
|
||||
hid_send_feature_report(dev, buffer, ASUSAURACORELAPTOP_WRITE_PACKET_SIZE);
|
||||
result = hid_get_feature_report(dev, rd_buf, ASUSAURACORELAPTOP_WRITE_PACKET_SIZE);
|
||||
|
||||
LOG_DEBUG("[%s] GetKeyboardLayout %02X %02X %02X %02X %02X %02X %02X {%02X} %02X %02X %02X %02X",
|
||||
aura_core_laptop_device_list[device_index]->dmi_name.c_str(),
|
||||
rd_buf[5], rd_buf[6], rd_buf[7], rd_buf[8], rd_buf[9], rd_buf[10],
|
||||
rd_buf[11], rd_buf[12], rd_buf[13], rd_buf[14], rd_buf[15], rd_buf[16]);
|
||||
|
||||
if(result > 0)
|
||||
{
|
||||
return rd_buf[12];
|
||||
}
|
||||
|
||||
LOG_DEBUG("[%s] GetKeyboardLayout: An error occurred! Setting layout to ANSI",
|
||||
aura_core_laptop_device_list[device_index]->dmi_name.c_str());
|
||||
return ASUSAURACORELAPTOP_LAYOUT_ANSI;
|
||||
}
|
||||
|
||||
std::string AsusAuraCoreLaptopController::GetSerial()
|
||||
{
|
||||
wchar_t serial_string[128];
|
||||
int ret = hid_get_serial_number_string(dev, serial_string, 128);
|
||||
|
||||
if(ret != 0)
|
||||
{
|
||||
LOG_DEBUG("[%s] Get HID Serial string failed",
|
||||
aura_core_laptop_device_list[device_index]->dmi_name.c_str());
|
||||
return("");
|
||||
}
|
||||
|
||||
return(StringUtils::wstring_to_string(serial_string));
|
||||
}
|
||||
|
||||
std::string AsusAuraCoreLaptopController::GetLocation()
|
||||
{
|
||||
return("HID: " + location);
|
||||
}
|
||||
|
||||
void AsusAuraCoreLaptopController::SetMode(uint8_t mode, uint8_t speed, uint8_t brightness, RGBColor color1, RGBColor color2, uint8_t random, uint8_t direction)
|
||||
{
|
||||
bool needs_update = !( (current_mode == mode ) &&
|
||||
(current_speed == speed ) &&
|
||||
(current_brightness == brightness ) &&
|
||||
(current_c1 == color1 ) &&
|
||||
(current_c2 == color2 ) &&
|
||||
(current_random == random ) &&
|
||||
(current_direction == direction ) );
|
||||
|
||||
if(needs_update)
|
||||
{
|
||||
current_mode = mode;
|
||||
current_speed = speed;
|
||||
current_brightness = brightness;
|
||||
current_c1 = color1;
|
||||
current_c2 = color2;
|
||||
current_random = random;
|
||||
current_direction = direction;
|
||||
|
||||
if(current_mode == ASUSAURACORELAPTOP_MODE_DIRECT)
|
||||
{
|
||||
SendBrightness();
|
||||
SendInitDirectMode();
|
||||
return;
|
||||
}
|
||||
|
||||
SendUpdate();
|
||||
SendBrightness();
|
||||
}
|
||||
}
|
||||
|
||||
void AsusAuraCoreLaptopController::SendInitDirectMode()
|
||||
{
|
||||
uint8_t buffer[ASUSAURACORELAPTOP_WRITE_PACKET_SIZE] = { ASUSAURACORELAPTOP_REPORT_ID, ASUSAURACORELAPTOP_CMD_DIRECT };
|
||||
memset(&buffer[2], 0, ASUSAURACORELAPTOP_WRITE_PACKET_SIZE - 2);
|
||||
|
||||
LOG_DEBUG("[%s] Resetting device for direct control", aura_core_laptop_device_list[device_index]->dmi_name.c_str());
|
||||
hid_send_feature_report(dev, buffer, ASUSAURACORELAPTOP_WRITE_PACKET_SIZE);
|
||||
}
|
||||
|
||||
void AsusAuraCoreLaptopController::SetLedsDirect(std::vector<RGBColor *> colors)
|
||||
{
|
||||
/*---------------------------------------------------------*\
|
||||
| The keyboard zone is a set of 168 keys (indexed from 0) |
|
||||
| sent in 11 packets of 16 triplets. The Lid and Lightbar |
|
||||
| zones are sent in one final packet afterwards. |
|
||||
\*---------------------------------------------------------*/
|
||||
const uint8_t key_set = 167;
|
||||
const uint8_t led_count = (uint8_t)colors.size();
|
||||
const uint16_t map_size = 3 * led_count;
|
||||
const uint8_t leds_per_packet = 16;
|
||||
uint8_t buffer[ASUSAURACORELAPTOP_WRITE_PACKET_SIZE] = { ASUSAURACORELAPTOP_REPORT_ID, ASUSAURACORELAPTOP_CMD_DIRECT,
|
||||
0x00, 0x01, 0x01, 0x01, 0x00, leds_per_packet, 0x00 };
|
||||
uint8_t* key_buf = new uint8_t[map_size];
|
||||
|
||||
memset(key_buf, 0, map_size);
|
||||
|
||||
for(uint8_t led_index = 0; led_index < led_count; led_index++)
|
||||
{
|
||||
std::size_t buf_idx = (led_index * 3);
|
||||
|
||||
key_buf[buf_idx] = RGBGetRValue(*colors[led_index]);
|
||||
key_buf[buf_idx + 1] = RGBGetGValue(*colors[led_index]);
|
||||
key_buf[buf_idx + 2] = RGBGetBValue(*colors[led_index]);
|
||||
}
|
||||
|
||||
for(uint8_t i = 0; i < key_set; i += leds_per_packet)
|
||||
{
|
||||
uint8_t leds_remaining = key_set - i;
|
||||
|
||||
if(leds_remaining < leds_per_packet)
|
||||
{
|
||||
buffer[07] = leds_remaining;
|
||||
|
||||
memset(&buffer[ASUSAURACORELAPTOP_DATA_BYTE],
|
||||
0,
|
||||
ASUSAURACORELAPTOP_WRITE_PACKET_SIZE - ASUSAURACORELAPTOP_DATA_BYTE);
|
||||
}
|
||||
|
||||
buffer[06] = i;
|
||||
memcpy(&buffer[ASUSAURACORELAPTOP_DATA_BYTE], &key_buf[3 * i], (3 * buffer[07]));
|
||||
|
||||
LOG_DEBUG("[%s] Sending buffer @ index %d thru index %d",
|
||||
aura_core_laptop_device_list[device_index]->dmi_name.c_str(),
|
||||
i,
|
||||
i + buffer[07]);
|
||||
|
||||
hid_send_feature_report(dev, buffer, ASUSAURACORELAPTOP_WRITE_PACKET_SIZE);
|
||||
}
|
||||
|
||||
buffer[4] = 0x04;
|
||||
buffer[5] = 0x00;
|
||||
buffer[6] = 0x00;
|
||||
buffer[7] = 0x00;
|
||||
|
||||
memset(&buffer[ASUSAURACORELAPTOP_DATA_BYTE],
|
||||
0,
|
||||
ASUSAURACORELAPTOP_WRITE_PACKET_SIZE - ASUSAURACORELAPTOP_DATA_BYTE);
|
||||
|
||||
if(led_count > key_set)
|
||||
{
|
||||
memcpy(&buffer[ASUSAURACORELAPTOP_DATA_BYTE],
|
||||
&key_buf[3 * key_set],
|
||||
(3 * (led_count - key_set)));
|
||||
}
|
||||
|
||||
LOG_DEBUG("[%s] Sending buffer @ index %d thru index %d",
|
||||
aura_core_laptop_device_list[device_index]->dmi_name.c_str(),
|
||||
key_set,
|
||||
led_count);
|
||||
|
||||
hid_send_feature_report(dev, buffer, ASUSAURACORELAPTOP_WRITE_PACKET_SIZE);
|
||||
delete[] key_buf;
|
||||
}
|
||||
|
||||
void AsusAuraCoreLaptopController::SendBrightness()
|
||||
{
|
||||
const uint8_t index = 5;
|
||||
uint8_t buffer[ASUSAURACORELAPTOP_WRITE_PACKET_SIZE] = { ASUSAURACORELAPTOP_REPORT_ID, ASUSAURACORELAPTOP_CMD_BRIGHTNESS, 0xC5, 0xC4};
|
||||
|
||||
memset(&buffer[index], 0, ASUSAURACORELAPTOP_WRITE_PACKET_SIZE - index);
|
||||
buffer[4] = current_brightness;
|
||||
|
||||
hid_send_feature_report(dev, buffer, ASUSAURACORELAPTOP_WRITE_PACKET_SIZE);
|
||||
}
|
||||
|
||||
void AsusAuraCoreLaptopController::SendUpdate()
|
||||
{
|
||||
uint8_t buffer[ASUSAURACORELAPTOP_WRITE_PACKET_SIZE] = { ASUSAURACORELAPTOP_REPORT_ID, ASUSAURACORELAPTOP_CMD_UPDATE };
|
||||
|
||||
buffer[ASUSAURACORELAPTOP_ZONE_BYTE] = 0;
|
||||
buffer[ASUSAURACORELAPTOP_MODE_BYTE] = current_mode;
|
||||
buffer[ASUSAURACORELAPTOP_R1_BYTE] = RGBGetRValue(current_c1);
|
||||
buffer[ASUSAURACORELAPTOP_G1_BYTE] = RGBGetGValue(current_c1);
|
||||
buffer[ASUSAURACORELAPTOP_B1_BYTE] = RGBGetBValue(current_c1);
|
||||
buffer[ASUSAURACORELAPTOP_SPEED_BYTE] = current_speed;
|
||||
buffer[ASUSAURACORELAPTOP_DIRECTION_BYTE] = current_direction;
|
||||
buffer[ASUSAURACORELAPTOP_DATA_BYTE] = current_random;
|
||||
buffer[ASUSAURACORELAPTOP_R2_BYTE] = RGBGetRValue(current_c2);
|
||||
buffer[ASUSAURACORELAPTOP_G2_BYTE] = RGBGetGValue(current_c2);
|
||||
buffer[ASUSAURACORELAPTOP_B2_BYTE] = RGBGetBValue(current_c2);
|
||||
|
||||
hid_send_feature_report(dev, buffer, ASUSAURACORELAPTOP_WRITE_PACKET_SIZE);
|
||||
|
||||
SendApply();
|
||||
}
|
||||
|
||||
void AsusAuraCoreLaptopController::SendApply()
|
||||
{
|
||||
const uint8_t index = 2;
|
||||
uint8_t buffer[ASUSAURACORELAPTOP_WRITE_PACKET_SIZE] = { ASUSAURACORELAPTOP_REPORT_ID, ASUSAURACORELAPTOP_CMD_APPLY };
|
||||
|
||||
memset(&buffer[index], 0, ASUSAURACORELAPTOP_WRITE_PACKET_SIZE - index);
|
||||
|
||||
hid_send_feature_report(dev, buffer, ASUSAURACORELAPTOP_WRITE_PACKET_SIZE);
|
||||
}
|
||||
|
||||
void AsusAuraCoreLaptopController::SendSet()
|
||||
{
|
||||
const uint8_t index = 2;
|
||||
uint8_t buffer[ASUSAURACORELAPTOP_WRITE_PACKET_SIZE] = { ASUSAURACORELAPTOP_REPORT_ID, ASUSAURACORELAPTOP_CMD_SET };
|
||||
|
||||
memset(&buffer[index], 0, ASUSAURACORELAPTOP_WRITE_PACKET_SIZE - index);
|
||||
|
||||
hid_send_feature_report(dev, buffer, ASUSAURACORELAPTOP_WRITE_PACKET_SIZE);
|
||||
}
|
||||
|
||||
std::vector<p_state> AsusAuraCoreLaptopController::PowerConfigArray()
|
||||
{
|
||||
std::vector<p_state> temp;
|
||||
|
||||
for(uint8_t zone_index = 0; zone_index < ASUSAURACORELAPTOP_POWER_ZONES; zone_index++)
|
||||
{
|
||||
for(uint8_t state_index = 0; state_index < ASUSAURACORELAPTOP_POWER_STATES; state_index++)
|
||||
{
|
||||
p_state new_state;
|
||||
|
||||
new_state.zone = power_zones[zone_index] + power_states[state_index];
|
||||
new_state.state = true;
|
||||
|
||||
temp.push_back(new_state);
|
||||
}
|
||||
}
|
||||
|
||||
return temp;
|
||||
}
|
||||
|
||||
void AsusAuraCoreLaptopController::SetPowerConfigFromJSON()
|
||||
{
|
||||
std::vector<p_state> power_config = PowerConfigArray();
|
||||
const std::string section_power = "PowerConfig";
|
||||
const std::string detector_name = "Asus Aura Core Laptop";
|
||||
SettingsManager* settings_manager = ResourceManager::get()->GetSettingsManager();
|
||||
json device_settings = settings_manager->GetSettings(detector_name);
|
||||
|
||||
/*---------------------------------------------------------*\
|
||||
| Get Power state config from the settings manager |
|
||||
| If PowerConfig is not found then write it to settings |
|
||||
\*---------------------------------------------------------*/
|
||||
if(!device_settings.contains(section_power))
|
||||
{
|
||||
json pcfg;
|
||||
|
||||
for(size_t i = 0; i < power_config.size(); i++)
|
||||
{
|
||||
pcfg[power_config[i].zone] = power_config[i].state;
|
||||
}
|
||||
|
||||
device_settings[section_power] = pcfg;
|
||||
settings_manager->SetSettings(detector_name, device_settings);
|
||||
settings_manager->SaveSettings();
|
||||
LOG_DEBUG("[%s] default power config saved to openrgb.json",
|
||||
aura_core_laptop_device_list[device_index]->dmi_name.c_str());
|
||||
}
|
||||
else
|
||||
{
|
||||
for(size_t i = 0; i < power_config.size(); i++)
|
||||
{
|
||||
std::string key_name = power_config[i].zone;
|
||||
|
||||
if(device_settings[section_power].contains(key_name))
|
||||
{
|
||||
power_config[i].state = device_settings[section_power][key_name];
|
||||
LOG_DEBUG("[%s] Reading power config for %s: %s",
|
||||
aura_core_laptop_device_list[device_index]->dmi_name.c_str(),
|
||||
key_name.c_str(), ((power_config[i].state) ? "On" : "Off"));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/*-----------------------------------------------------------------------------*\
|
||||
| Power state flags are packed in zones but the order is inconsistent. |
|
||||
| With thanks to AsusCtl for helping to decipher the packet captures |
|
||||
| https://gitlab.com/asus-linux/asusctl/-/blob/main/rog-aura/src/usb.rs#L150 |
|
||||
\*-----------------------------------------------------------------------------*/
|
||||
bool flag_array[32] =
|
||||
{
|
||||
power_config[0].state, power_config[4].state,
|
||||
power_config[1].state, power_config[5].state,
|
||||
!power_config[2].state, !power_config[6].state,
|
||||
!power_config[3].state, !power_config[7].state,
|
||||
|
||||
false, power_config[8].state,
|
||||
power_config[9].state, !power_config[10].state,
|
||||
!power_config[11].state, false,
|
||||
false, false,
|
||||
|
||||
power_config[12].state, power_config[13].state,
|
||||
!power_config[14].state, !power_config[15].state
|
||||
};
|
||||
|
||||
uint32_t flags = PackPowerFlags(flag_array);
|
||||
LOG_DEBUG("[%s] Sending power config Logo+KB: %02X Lightbar: %02X Lid Edges: %02X Raw: %08X",
|
||||
aura_core_laptop_device_list[device_index]->dmi_name.c_str(),
|
||||
(flags & 0xFF), ((flags >> 8) & 0xFF), ((flags >> 16) & 0xFF), flags);
|
||||
SendPowerConfig(flags);
|
||||
}
|
||||
|
||||
void AsusAuraCoreLaptopController::SendPowerConfig(uint32_t flags)
|
||||
{
|
||||
const uint8_t index = 6;
|
||||
uint8_t buffer[ASUSAURACORELAPTOP_WRITE_PACKET_SIZE] = { ASUSAURACORELAPTOP_REPORT_ID, ASUSAURACORELAPTOP_CMD_POWER, 0x01, 0x00, 0x00, 0x0F };
|
||||
|
||||
memset(&buffer[index], 0, ASUSAURACORELAPTOP_WRITE_PACKET_SIZE - index);
|
||||
|
||||
buffer[3] = flags & 0xFF;
|
||||
buffer[4] = (flags >> 8) & 0xFF;
|
||||
buffer[5] = (flags >> 16) & 0xFF;
|
||||
|
||||
hid_send_feature_report(dev, buffer, ASUSAURACORELAPTOP_WRITE_PACKET_SIZE);
|
||||
}
|
||||
|
||||
uint32_t AsusAuraCoreLaptopController::PackPowerFlags(bool flags[])
|
||||
{
|
||||
uint32_t temp = {};
|
||||
const uint8_t length = 32;
|
||||
|
||||
for (size_t i = 0; i < length; ++i)
|
||||
{
|
||||
uint32_t flag = {flags[i]};
|
||||
flag <<= i;
|
||||
temp |= flag;
|
||||
}
|
||||
|
||||
return temp;
|
||||
}
|
||||
+147
-147
@@ -1,147 +1,147 @@
|
||||
/*---------------------------------------------------------*\
|
||||
| AsusAuraCoreLaptopController.h |
|
||||
| |
|
||||
| Driver for ASUS ROG Aura Core Laptop |
|
||||
| |
|
||||
| Chris M (Dr_No) 28 Jul 2022 |
|
||||
| |
|
||||
| This file is part of the OpenRGB project |
|
||||
| SPDX-License-Identifier: GPL-2.0-or-later |
|
||||
\*---------------------------------------------------------*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <string>
|
||||
#include <vector>
|
||||
#include <hidapi.h>
|
||||
#include "LogManager.h"
|
||||
#include "RGBController.h"
|
||||
#include "ResourceManager.h"
|
||||
#include "RGBControllerKeyNames.h"
|
||||
#include "AsusAuraCoreLaptopDevices.h"
|
||||
|
||||
#define NA 0xFFFFFFFF
|
||||
#define HID_MAX_STR 255
|
||||
#define ASUSAURACORELAPTOP_TIMEOUT 250
|
||||
#define ASUSAURACORELAPTOP_READ_PACKET_SIZE 64
|
||||
#define ASUSAURACORELAPTOP_WRITE_PACKET_SIZE 64 //Buffer requires a prepended ReportID hence + 1
|
||||
|
||||
#define ASUSAURACORELAPTOP_KEYCOUNT 91
|
||||
#define ASUSAURACORELAPTOP_KEY_WIDTH 18
|
||||
#define ASUSAURACORELAPTOP_KEY_HEIGHT 7
|
||||
#define ASUSAURACORELAPTOP_LIGHTBARCOUNT 6
|
||||
#define ASUSAURACORELAPTOP_LIDCOUNT 3
|
||||
#define ASUSAURACORELAPTOP_POWER_ZONES 4
|
||||
#define ASUSAURACORELAPTOP_POWER_STATES 4
|
||||
#define ASUSAURACORELAPTOP_BRIGHTNESS_MIN 0
|
||||
#define ASUSAURACORELAPTOP_BRIGHTNESS_MAX 3 // No device has proven to have 256 keyboard brightness levels, only 0..3
|
||||
|
||||
enum
|
||||
{
|
||||
ASUSAURACORELAPTOP_MODE_OFF = 0x00, //Turn off - All leds off
|
||||
ASUSAURACORELAPTOP_MODE_DIRECT = 0xFF, //Direct Led Control - Independently set LEDs in zone
|
||||
ASUSAURACORELAPTOP_MODE_STATIC = 0x00, //Static Mode - Set entire zone to a single color.
|
||||
ASUSAURACORELAPTOP_MODE_BREATHING = 0x01, //Breathing Mode - Fades between fully off and fully on.
|
||||
ASUSAURACORELAPTOP_MODE_SPECTRUM = 0x02, //Spectrum Cycle Mode - Cycles through the color spectrum on all lights on the device
|
||||
ASUSAURACORELAPTOP_MODE_RAINBOW = 0x03, //Rainbow Wave Mode - Cycle thru the color spectrum as a wave across all LEDs
|
||||
ASUSAURACORELAPTOP_MODE_FLASHING = 0x0A, //Flashing Mode - Abruptly changing between fully off and fully on.
|
||||
|
||||
/*-------------------------------------------------*\
|
||||
| Modes not implemented in the Armoury Crate |
|
||||
| OEM software that were discovered. |
|
||||
\*-------------------------------------------------*/
|
||||
ASUSAURACORELAPTOP_MODE_STARRY_NIGHT = 0x04, //Starry Night Mode
|
||||
ASUSAURACORELAPTOP_MODE_RAIN = 0x05, //Rain Mode
|
||||
ASUSAURACORELAPTOP_MODE_REACT_FADE = 0x06, //Reactive Fade Mode
|
||||
ASUSAURACORELAPTOP_MODE_REACT_LASER = 0x07, //Reactive Laser Mode
|
||||
ASUSAURACORELAPTOP_MODE_REACT_RIPPLE = 0x08, //Reactive Ripple Mode
|
||||
ASUSAURACORELAPTOP_MODE_COMET = 0x0B, //Comet Mode
|
||||
ASUSAURACORELAPTOP_MODE_FLASHNDASH = 0x0C, //Flash n Dash Mode
|
||||
ASUSAURACORELAPTOP_MODE_KEYSTONE = 0x0D, //Keystone Mode
|
||||
};
|
||||
|
||||
enum
|
||||
{
|
||||
ASUSAURACORELAPTOP_ZONE_BYTE = 2,
|
||||
ASUSAURACORELAPTOP_MODE_BYTE = 3,
|
||||
ASUSAURACORELAPTOP_R1_BYTE = 4,
|
||||
ASUSAURACORELAPTOP_G1_BYTE = 5,
|
||||
ASUSAURACORELAPTOP_B1_BYTE = 6,
|
||||
ASUSAURACORELAPTOP_SPEED_BYTE = 7,
|
||||
ASUSAURACORELAPTOP_DIRECTION_BYTE = 8,
|
||||
ASUSAURACORELAPTOP_DATA_BYTE = 9,
|
||||
ASUSAURACORELAPTOP_R2_BYTE = 10,
|
||||
ASUSAURACORELAPTOP_G2_BYTE = 11,
|
||||
ASUSAURACORELAPTOP_B2_BYTE = 12,
|
||||
};
|
||||
|
||||
enum
|
||||
{
|
||||
ASUSAURACORELAPTOP_REPORT_ID = 0x5D,
|
||||
ASUSAURACORELAPTOP_CMD_BRIGHTNESS = 0xBA,
|
||||
ASUSAURACORELAPTOP_CMD_DIRECT = 0xBC,
|
||||
ASUSAURACORELAPTOP_CMD_POWER = 0xBD,
|
||||
ASUSAURACORELAPTOP_CMD_UPDATE = 0xB3,
|
||||
ASUSAURACORELAPTOP_CMD_APPLY = 0xB4,
|
||||
ASUSAURACORELAPTOP_CMD_SET = 0xB5,
|
||||
ASUSAURACORELAPTOP_CMD_LAYOUT = 0x05,
|
||||
};
|
||||
|
||||
enum
|
||||
{
|
||||
ASUSAURACORELAPTOP_SPEED_SLOWEST = 0xE1, // Slowest speed
|
||||
ASUSAURACORELAPTOP_SPEED_NORMAL = 0xEB, // Normal speed
|
||||
ASUSAURACORELAPTOP_SPEED_FASTEST = 0xF5, // Fastest speed
|
||||
};
|
||||
|
||||
enum aura_core_laptop_layout
|
||||
{
|
||||
ASUSAURACORELAPTOP_LAYOUT_ANSI = 0x01, /* US ANSI Layout */
|
||||
ASUSAURACORELAPTOP_LAYOUT_ISO = 0x02, /* EURO ISO Layout */
|
||||
};
|
||||
|
||||
struct p_state
|
||||
{
|
||||
std::string zone;
|
||||
bool state;
|
||||
};
|
||||
|
||||
class AsusAuraCoreLaptopController
|
||||
{
|
||||
public:
|
||||
AsusAuraCoreLaptopController(hid_device* dev_handle, const char* path);
|
||||
~AsusAuraCoreLaptopController();
|
||||
|
||||
const aura_core_laptop_device* GetDeviceData();
|
||||
std::string GetDeviceDescription();
|
||||
std::string GetSerial();
|
||||
unsigned int GetKeyboardLayout();
|
||||
std::string GetLocation();
|
||||
|
||||
void SetMode(uint8_t mode, uint8_t speed, uint8_t brightness, RGBColor color1, RGBColor color2, uint8_t random, uint8_t direction);
|
||||
void SetLedsDirect(std::vector<RGBColor *>colors);
|
||||
void SendInitDirectMode();
|
||||
private:
|
||||
hid_device* dev;
|
||||
uint16_t device_index;
|
||||
std::string location;
|
||||
|
||||
uint8_t current_mode;
|
||||
uint8_t current_speed;
|
||||
uint8_t current_direction;
|
||||
|
||||
RGBColor current_c1;
|
||||
RGBColor current_c2;
|
||||
uint8_t current_brightness;
|
||||
uint8_t current_random;
|
||||
|
||||
void SendApply();
|
||||
void SendBrightness();
|
||||
void SendSet();
|
||||
void SendUpdate();
|
||||
|
||||
void SetPowerConfigFromJSON();
|
||||
void SendPowerConfig(uint32_t flags);
|
||||
uint32_t PackPowerFlags(bool flags[]);
|
||||
std::vector<p_state> PowerConfigArray();
|
||||
};
|
||||
/*---------------------------------------------------------*\
|
||||
| AsusAuraCoreLaptopController.h |
|
||||
| |
|
||||
| Driver for ASUS ROG Aura Core Laptop |
|
||||
| |
|
||||
| Chris M (Dr_No) 28 Jul 2022 |
|
||||
| |
|
||||
| This file is part of the OpenRGB project |
|
||||
| SPDX-License-Identifier: GPL-2.0-or-later |
|
||||
\*---------------------------------------------------------*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <string>
|
||||
#include <vector>
|
||||
#include <hidapi.h>
|
||||
#include "LogManager.h"
|
||||
#include "RGBController.h"
|
||||
#include "ResourceManager.h"
|
||||
#include "RGBControllerKeyNames.h"
|
||||
#include "AsusAuraCoreLaptopDevices.h"
|
||||
|
||||
#define NA 0xFFFFFFFF
|
||||
#define HID_MAX_STR 255
|
||||
#define ASUSAURACORELAPTOP_TIMEOUT 250
|
||||
#define ASUSAURACORELAPTOP_READ_PACKET_SIZE 64
|
||||
#define ASUSAURACORELAPTOP_WRITE_PACKET_SIZE 64 //Buffer requires a prepended ReportID hence + 1
|
||||
|
||||
#define ASUSAURACORELAPTOP_KEYCOUNT 91
|
||||
#define ASUSAURACORELAPTOP_KEY_WIDTH 18
|
||||
#define ASUSAURACORELAPTOP_KEY_HEIGHT 7
|
||||
#define ASUSAURACORELAPTOP_LIGHTBARCOUNT 6
|
||||
#define ASUSAURACORELAPTOP_LIDCOUNT 3
|
||||
#define ASUSAURACORELAPTOP_POWER_ZONES 4
|
||||
#define ASUSAURACORELAPTOP_POWER_STATES 4
|
||||
#define ASUSAURACORELAPTOP_BRIGHTNESS_MIN 0
|
||||
#define ASUSAURACORELAPTOP_BRIGHTNESS_MAX 3 // No device has proven to have 256 keyboard brightness levels, only 0..3
|
||||
|
||||
enum
|
||||
{
|
||||
ASUSAURACORELAPTOP_MODE_OFF = 0x00, //Turn off - All leds off
|
||||
ASUSAURACORELAPTOP_MODE_DIRECT = 0xFF, //Direct Led Control - Independently set LEDs in zone
|
||||
ASUSAURACORELAPTOP_MODE_STATIC = 0x00, //Static Mode - Set entire zone to a single color.
|
||||
ASUSAURACORELAPTOP_MODE_BREATHING = 0x01, //Breathing Mode - Fades between fully off and fully on.
|
||||
ASUSAURACORELAPTOP_MODE_SPECTRUM = 0x02, //Spectrum Cycle Mode - Cycles through the color spectrum on all lights on the device
|
||||
ASUSAURACORELAPTOP_MODE_RAINBOW = 0x03, //Rainbow Wave Mode - Cycle thru the color spectrum as a wave across all LEDs
|
||||
ASUSAURACORELAPTOP_MODE_FLASHING = 0x0A, //Flashing Mode - Abruptly changing between fully off and fully on.
|
||||
|
||||
/*-------------------------------------------------*\
|
||||
| Modes not implemented in the Armoury Crate |
|
||||
| OEM software that were discovered. |
|
||||
\*-------------------------------------------------*/
|
||||
ASUSAURACORELAPTOP_MODE_STARRY_NIGHT = 0x04, //Starry Night Mode
|
||||
ASUSAURACORELAPTOP_MODE_RAIN = 0x05, //Rain Mode
|
||||
ASUSAURACORELAPTOP_MODE_REACT_FADE = 0x06, //Reactive Fade Mode
|
||||
ASUSAURACORELAPTOP_MODE_REACT_LASER = 0x07, //Reactive Laser Mode
|
||||
ASUSAURACORELAPTOP_MODE_REACT_RIPPLE = 0x08, //Reactive Ripple Mode
|
||||
ASUSAURACORELAPTOP_MODE_COMET = 0x0B, //Comet Mode
|
||||
ASUSAURACORELAPTOP_MODE_FLASHNDASH = 0x0C, //Flash n Dash Mode
|
||||
ASUSAURACORELAPTOP_MODE_KEYSTONE = 0x0D, //Keystone Mode
|
||||
};
|
||||
|
||||
enum
|
||||
{
|
||||
ASUSAURACORELAPTOP_ZONE_BYTE = 2,
|
||||
ASUSAURACORELAPTOP_MODE_BYTE = 3,
|
||||
ASUSAURACORELAPTOP_R1_BYTE = 4,
|
||||
ASUSAURACORELAPTOP_G1_BYTE = 5,
|
||||
ASUSAURACORELAPTOP_B1_BYTE = 6,
|
||||
ASUSAURACORELAPTOP_SPEED_BYTE = 7,
|
||||
ASUSAURACORELAPTOP_DIRECTION_BYTE = 8,
|
||||
ASUSAURACORELAPTOP_DATA_BYTE = 9,
|
||||
ASUSAURACORELAPTOP_R2_BYTE = 10,
|
||||
ASUSAURACORELAPTOP_G2_BYTE = 11,
|
||||
ASUSAURACORELAPTOP_B2_BYTE = 12,
|
||||
};
|
||||
|
||||
enum
|
||||
{
|
||||
ASUSAURACORELAPTOP_REPORT_ID = 0x5D,
|
||||
ASUSAURACORELAPTOP_CMD_BRIGHTNESS = 0xBA,
|
||||
ASUSAURACORELAPTOP_CMD_DIRECT = 0xBC,
|
||||
ASUSAURACORELAPTOP_CMD_POWER = 0xBD,
|
||||
ASUSAURACORELAPTOP_CMD_UPDATE = 0xB3,
|
||||
ASUSAURACORELAPTOP_CMD_APPLY = 0xB4,
|
||||
ASUSAURACORELAPTOP_CMD_SET = 0xB5,
|
||||
ASUSAURACORELAPTOP_CMD_LAYOUT = 0x05,
|
||||
};
|
||||
|
||||
enum
|
||||
{
|
||||
ASUSAURACORELAPTOP_SPEED_SLOWEST = 0xE1, // Slowest speed
|
||||
ASUSAURACORELAPTOP_SPEED_NORMAL = 0xEB, // Normal speed
|
||||
ASUSAURACORELAPTOP_SPEED_FASTEST = 0xF5, // Fastest speed
|
||||
};
|
||||
|
||||
enum aura_core_laptop_layout
|
||||
{
|
||||
ASUSAURACORELAPTOP_LAYOUT_ANSI = 0x01, /* US ANSI Layout */
|
||||
ASUSAURACORELAPTOP_LAYOUT_ISO = 0x02, /* EURO ISO Layout */
|
||||
};
|
||||
|
||||
struct p_state
|
||||
{
|
||||
std::string zone;
|
||||
bool state;
|
||||
};
|
||||
|
||||
class AsusAuraCoreLaptopController
|
||||
{
|
||||
public:
|
||||
AsusAuraCoreLaptopController(hid_device* dev_handle, const char* path);
|
||||
~AsusAuraCoreLaptopController();
|
||||
|
||||
const aura_core_laptop_device* GetDeviceData();
|
||||
std::string GetDeviceDescription();
|
||||
std::string GetSerial();
|
||||
unsigned int GetKeyboardLayout();
|
||||
std::string GetLocation();
|
||||
|
||||
void SetMode(uint8_t mode, uint8_t speed, uint8_t brightness, RGBColor color1, RGBColor color2, uint8_t random, uint8_t direction);
|
||||
void SetLedsDirect(std::vector<RGBColor *>colors);
|
||||
void SendInitDirectMode();
|
||||
private:
|
||||
hid_device* dev;
|
||||
uint16_t device_index;
|
||||
std::string location;
|
||||
|
||||
uint8_t current_mode;
|
||||
uint8_t current_speed;
|
||||
uint8_t current_direction;
|
||||
|
||||
RGBColor current_c1;
|
||||
RGBColor current_c2;
|
||||
uint8_t current_brightness;
|
||||
uint8_t current_random;
|
||||
|
||||
void SendApply();
|
||||
void SendBrightness();
|
||||
void SendSet();
|
||||
void SendUpdate();
|
||||
|
||||
void SetPowerConfigFromJSON();
|
||||
void SendPowerConfig(uint32_t flags);
|
||||
uint32_t PackPowerFlags(bool flags[]);
|
||||
std::vector<p_state> PowerConfigArray();
|
||||
};
|
||||
+960
-960
File diff suppressed because it is too large.
Load diff
+50
-50
@@ -1,50 +1,50 @@
|
||||
#pragma once
|
||||
|
||||
#include <string>
|
||||
#include <vector>
|
||||
#include "RGBController.h"
|
||||
#include "RGBControllerKeyNames.h"
|
||||
#include "KeyboardLayoutManager.h"
|
||||
|
||||
#define AURA_CORE_LAPTOP_ZONES_MAX 6
|
||||
|
||||
enum aura_core_kb_layout
|
||||
{
|
||||
AURA_CORE_LAPTOP_KB_LAYOUT_ANSI = 0x01, /* US ANSI Layout */
|
||||
AURA_CORE_LAPTOP_KB_LAYOUT_ISO = 0x02, /* EURO ISO Layout */
|
||||
AURA_CORE_LAPTOP_KB_LAYOUT_ABNT = 0x03, /* Brazilian Layout */
|
||||
AURA_CORE_LAPTOP_KB_LAYOUT_JIS = 0x04, /* Japanese Layout */
|
||||
};
|
||||
|
||||
typedef struct
|
||||
{
|
||||
std::string name;
|
||||
keyboard_keymap_overlay_values* layout_new;
|
||||
} aura_core_laptop_zone;
|
||||
|
||||
typedef struct
|
||||
{
|
||||
uint8_t zone;
|
||||
uint8_t row;
|
||||
uint8_t col;
|
||||
uint8_t index;
|
||||
const char* name;
|
||||
} aura_core_laptop_led;
|
||||
|
||||
typedef struct
|
||||
{
|
||||
std::string dmi_name;
|
||||
const aura_core_laptop_zone* zones[AURA_CORE_LAPTOP_ZONES_MAX];
|
||||
} aura_core_laptop_device;
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Aura Core Laptop Protocol Keyboards |
|
||||
\*-----------------------------------------------------*/
|
||||
#define AURA_STRIX_SCAR_15_PID 0x19B6
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| These constant values are defined in |
|
||||
| AsusAuraCoreLaptopDevices.cpp |
|
||||
\*-----------------------------------------------------*/
|
||||
extern const unsigned int AURA_CORE_LAPTOP_DEVICE_COUNT;
|
||||
extern const aura_core_laptop_device** aura_core_laptop_device_list;
|
||||
#pragma once
|
||||
|
||||
#include <string>
|
||||
#include <vector>
|
||||
#include "RGBController.h"
|
||||
#include "RGBControllerKeyNames.h"
|
||||
#include "KeyboardLayoutManager.h"
|
||||
|
||||
#define AURA_CORE_LAPTOP_ZONES_MAX 6
|
||||
|
||||
enum aura_core_kb_layout
|
||||
{
|
||||
AURA_CORE_LAPTOP_KB_LAYOUT_ANSI = 0x01, /* US ANSI Layout */
|
||||
AURA_CORE_LAPTOP_KB_LAYOUT_ISO = 0x02, /* EURO ISO Layout */
|
||||
AURA_CORE_LAPTOP_KB_LAYOUT_ABNT = 0x03, /* Brazilian Layout */
|
||||
AURA_CORE_LAPTOP_KB_LAYOUT_JIS = 0x04, /* Japanese Layout */
|
||||
};
|
||||
|
||||
typedef struct
|
||||
{
|
||||
std::string name;
|
||||
keyboard_keymap_overlay_values* layout_new;
|
||||
} aura_core_laptop_zone;
|
||||
|
||||
typedef struct
|
||||
{
|
||||
uint8_t zone;
|
||||
uint8_t row;
|
||||
uint8_t col;
|
||||
uint8_t index;
|
||||
const char* name;
|
||||
} aura_core_laptop_led;
|
||||
|
||||
typedef struct
|
||||
{
|
||||
std::string dmi_name;
|
||||
const aura_core_laptop_zone* zones[AURA_CORE_LAPTOP_ZONES_MAX];
|
||||
} aura_core_laptop_device;
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Aura Core Laptop Protocol Keyboards |
|
||||
\*-----------------------------------------------------*/
|
||||
#define AURA_STRIX_SCAR_15_PID 0x19B6
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| These constant values are defined in |
|
||||
| AsusAuraCoreLaptopDevices.cpp |
|
||||
\*-----------------------------------------------------*/
|
||||
extern const unsigned int AURA_CORE_LAPTOP_DEVICE_COUNT;
|
||||
extern const aura_core_laptop_device** aura_core_laptop_device_list;
|
||||
+444
-444
@@ -1,444 +1,444 @@
|
||||
/*---------------------------------------------------------*\
|
||||
| RGBController_AsusAuraCoreLaptop.cpp |
|
||||
| |
|
||||
| RGBController for ASUS ROG Aura Core Laptop |
|
||||
| |
|
||||
| Chris M (Dr_No) 28 Jul 2022 |
|
||||
| |
|
||||
| This file is part of the OpenRGB project |
|
||||
| SPDX-License-Identifier: GPL-2.0-or-later |
|
||||
\*---------------------------------------------------------*/
|
||||
|
||||
#include "RGBController_AsusAuraCoreLaptop.h"
|
||||
|
||||
/**------------------------------------------------------------------*\
|
||||
@name AsusAuraCoreLaptop
|
||||
@category DEVICE_TYPE_KEYBOARD
|
||||
@type USB
|
||||
@save :x:
|
||||
@direct :white_check_mark:
|
||||
@effects :white_check_mark:
|
||||
@detectors DetectAsusAuraCoreLaptopControllers
|
||||
@comment Power profiles for this controller are set to `On` for all power
|
||||
state and scan be adjusted in the JSON config file.
|
||||
|
||||
For each zone available LEDs can be set as `On = true` or `Off = false` when
|
||||
* Booting
|
||||
* Awake (Normal Usage)
|
||||
* Sleeping
|
||||
* Shutdown / Power Off
|
||||
|
||||
MatrixMaps can be found in ArmouryCrate (it needs a chance to download device data)
|
||||
Default path is:
|
||||
C:\ProgramData\ASUS\ROG Live Service\DeviceContent\<Model name>\<Model name>.csv
|
||||
(Model name is the code like G814JV - can be found in the error in logs)
|
||||
\*-------------------------------------------------------------------*/
|
||||
|
||||
RGBController_AsusAuraCoreLaptop::RGBController_AsusAuraCoreLaptop(AsusAuraCoreLaptopController *controller_ptr)
|
||||
{
|
||||
controller = controller_ptr;
|
||||
const aura_core_laptop_device* aura_dev = controller->GetDeviceData();
|
||||
|
||||
name = aura_dev->dmi_name;
|
||||
vendor = "Asus";
|
||||
type = DEVICE_TYPE_LAPTOP;
|
||||
description = controller->GetDeviceDescription();
|
||||
serial = controller->GetSerial();
|
||||
location = controller->GetLocation();
|
||||
|
||||
mode Direct;
|
||||
Direct.name = "Direct";
|
||||
Direct.value = ASUSAURACORELAPTOP_MODE_DIRECT;
|
||||
Direct.flags = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
|
||||
Direct.brightness_min = ASUSAURACORELAPTOP_BRIGHTNESS_MIN;
|
||||
Direct.brightness_max = ASUSAURACORELAPTOP_BRIGHTNESS_MAX;
|
||||
Direct.brightness = ASUSAURACORELAPTOP_BRIGHTNESS_MAX;
|
||||
Direct.color_mode = MODE_COLORS_PER_LED;
|
||||
modes.push_back(Direct);
|
||||
|
||||
mode Static;
|
||||
Static.name = "Static";
|
||||
Static.value = ASUSAURACORELAPTOP_MODE_STATIC;
|
||||
Static.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
|
||||
Static.colors_min = 1;
|
||||
Static.colors_max = 1;
|
||||
Static.colors.resize(Static.colors_max);
|
||||
Static.brightness_min = ASUSAURACORELAPTOP_BRIGHTNESS_MIN;
|
||||
Static.brightness_max = ASUSAURACORELAPTOP_BRIGHTNESS_MAX;
|
||||
Static.brightness = ASUSAURACORELAPTOP_BRIGHTNESS_MAX;
|
||||
Static.speed_min = ASUSAURACORELAPTOP_SPEED_SLOWEST;
|
||||
Static.speed_max = ASUSAURACORELAPTOP_SPEED_FASTEST;
|
||||
Static.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Static.speed = ASUSAURACORELAPTOP_SPEED_NORMAL;
|
||||
modes.push_back(Static);
|
||||
|
||||
mode Breathing;
|
||||
Breathing.name = "Breathing";
|
||||
Breathing.value = ASUSAURACORELAPTOP_MODE_BREATHING;
|
||||
Breathing.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
|
||||
Breathing.colors_min = 1;
|
||||
Breathing.colors_max = 2;
|
||||
Breathing.colors.resize(Breathing.colors_min);
|
||||
Breathing.brightness_min = ASUSAURACORELAPTOP_BRIGHTNESS_MIN;
|
||||
Breathing.brightness_max = ASUSAURACORELAPTOP_BRIGHTNESS_MAX;
|
||||
Breathing.brightness = ASUSAURACORELAPTOP_BRIGHTNESS_MAX;
|
||||
Breathing.speed_min = ASUSAURACORELAPTOP_SPEED_SLOWEST;
|
||||
Breathing.speed_max = ASUSAURACORELAPTOP_SPEED_FASTEST;
|
||||
Breathing.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Breathing.speed = ASUSAURACORELAPTOP_SPEED_NORMAL;
|
||||
modes.push_back(Breathing);
|
||||
|
||||
mode Flashing;
|
||||
Flashing.name = "Flashing";
|
||||
Flashing.value = ASUSAURACORELAPTOP_MODE_FLASHING;
|
||||
Flashing.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
|
||||
Flashing.colors_min = 1;
|
||||
Flashing.colors_max = 1;
|
||||
Flashing.colors.resize(Flashing.colors_max);
|
||||
Flashing.brightness_min = ASUSAURACORELAPTOP_BRIGHTNESS_MIN;
|
||||
Flashing.brightness_max = ASUSAURACORELAPTOP_BRIGHTNESS_MAX;
|
||||
Flashing.brightness = ASUSAURACORELAPTOP_BRIGHTNESS_MAX;
|
||||
Flashing.speed_min = ASUSAURACORELAPTOP_SPEED_SLOWEST;
|
||||
Flashing.speed_max = ASUSAURACORELAPTOP_SPEED_FASTEST;
|
||||
Flashing.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Flashing.speed = ASUSAURACORELAPTOP_SPEED_NORMAL;
|
||||
modes.push_back(Flashing);
|
||||
|
||||
mode Spectrum;
|
||||
Spectrum.name = "Spectrum Cycle";
|
||||
Spectrum.value = ASUSAURACORELAPTOP_MODE_SPECTRUM;
|
||||
Spectrum.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
|
||||
Spectrum.brightness_min = ASUSAURACORELAPTOP_BRIGHTNESS_MIN;
|
||||
Spectrum.brightness_max = ASUSAURACORELAPTOP_BRIGHTNESS_MAX;
|
||||
Spectrum.brightness = ASUSAURACORELAPTOP_BRIGHTNESS_MAX;
|
||||
Spectrum.speed_min = ASUSAURACORELAPTOP_SPEED_SLOWEST;
|
||||
Spectrum.speed_max = ASUSAURACORELAPTOP_SPEED_FASTEST;
|
||||
Spectrum.color_mode = MODE_COLORS_NONE;
|
||||
Spectrum.speed = ASUSAURACORELAPTOP_SPEED_NORMAL;
|
||||
modes.push_back(Spectrum);
|
||||
|
||||
mode Rainbow;
|
||||
Rainbow.name = "Rainbow Wave";
|
||||
Rainbow.value = ASUSAURACORELAPTOP_MODE_RAINBOW;
|
||||
Rainbow.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_DIRECTION_UD;
|
||||
Rainbow.brightness_min = ASUSAURACORELAPTOP_BRIGHTNESS_MIN;
|
||||
Rainbow.brightness_max = ASUSAURACORELAPTOP_BRIGHTNESS_MAX;
|
||||
Rainbow.brightness = ASUSAURACORELAPTOP_BRIGHTNESS_MAX;
|
||||
Rainbow.speed_min = ASUSAURACORELAPTOP_SPEED_SLOWEST;
|
||||
Rainbow.speed_max = ASUSAURACORELAPTOP_SPEED_FASTEST;
|
||||
Rainbow.color_mode = MODE_COLORS_NONE;
|
||||
Rainbow.speed = ASUSAURACORELAPTOP_SPEED_NORMAL;
|
||||
modes.push_back(Rainbow);
|
||||
|
||||
mode Starry;
|
||||
Starry.name = "Starry Night";
|
||||
Starry.value = ASUSAURACORELAPTOP_MODE_STARRY_NIGHT;
|
||||
Starry.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
|
||||
Starry.colors_min = 1;
|
||||
Starry.colors_max = 2;
|
||||
Starry.colors.resize(Starry.colors_min);
|
||||
Starry.brightness_min = ASUSAURACORELAPTOP_BRIGHTNESS_MIN;
|
||||
Starry.brightness_max = ASUSAURACORELAPTOP_BRIGHTNESS_MAX;
|
||||
Starry.brightness = ASUSAURACORELAPTOP_BRIGHTNESS_MAX;
|
||||
Starry.speed_min = ASUSAURACORELAPTOP_SPEED_SLOWEST;
|
||||
Starry.speed_max = ASUSAURACORELAPTOP_SPEED_FASTEST;
|
||||
Starry.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Starry.speed = ASUSAURACORELAPTOP_SPEED_NORMAL;
|
||||
modes.push_back(Starry);
|
||||
|
||||
mode Rain;
|
||||
Rain.name = "Rain";
|
||||
Rain.value = ASUSAURACORELAPTOP_MODE_RAIN;
|
||||
Rain.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
|
||||
Rain.brightness_min = ASUSAURACORELAPTOP_BRIGHTNESS_MIN;
|
||||
Rain.brightness_max = ASUSAURACORELAPTOP_BRIGHTNESS_MAX;
|
||||
Rain.brightness = ASUSAURACORELAPTOP_BRIGHTNESS_MAX;
|
||||
Rain.speed_min = ASUSAURACORELAPTOP_SPEED_SLOWEST;
|
||||
Rain.speed_max = ASUSAURACORELAPTOP_SPEED_FASTEST;
|
||||
Rain.color_mode = MODE_COLORS_NONE;
|
||||
Rain.speed = ASUSAURACORELAPTOP_SPEED_NORMAL;
|
||||
modes.push_back(Rain);
|
||||
|
||||
mode ReactFade;
|
||||
ReactFade.name = "Reactive - Fade";
|
||||
ReactFade.value = ASUSAURACORELAPTOP_MODE_REACT_FADE;
|
||||
ReactFade.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
|
||||
ReactFade.colors_min = 1;
|
||||
ReactFade.colors_max = 1;
|
||||
ReactFade.colors.resize(ReactFade.colors_max);
|
||||
ReactFade.brightness_min = ASUSAURACORELAPTOP_BRIGHTNESS_MIN;
|
||||
ReactFade.brightness_max = ASUSAURACORELAPTOP_BRIGHTNESS_MAX;
|
||||
ReactFade.brightness = ASUSAURACORELAPTOP_BRIGHTNESS_MAX;
|
||||
ReactFade.speed_min = ASUSAURACORELAPTOP_SPEED_SLOWEST;
|
||||
ReactFade.speed_max = ASUSAURACORELAPTOP_SPEED_FASTEST;
|
||||
ReactFade.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
ReactFade.speed = ASUSAURACORELAPTOP_SPEED_NORMAL;
|
||||
modes.push_back(ReactFade);
|
||||
|
||||
mode ReactLaser;
|
||||
ReactLaser.name = "Reactive - Laser";
|
||||
ReactLaser.value = ASUSAURACORELAPTOP_MODE_REACT_LASER;
|
||||
ReactLaser.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
|
||||
ReactLaser.colors_min = 1;
|
||||
ReactLaser.colors_max = 1;
|
||||
ReactLaser.colors.resize(ReactLaser.colors_max);
|
||||
ReactLaser.brightness_min = ASUSAURACORELAPTOP_BRIGHTNESS_MIN;
|
||||
ReactLaser.brightness_max = ASUSAURACORELAPTOP_BRIGHTNESS_MAX;
|
||||
ReactLaser.brightness = ASUSAURACORELAPTOP_BRIGHTNESS_MAX;
|
||||
ReactLaser.speed_min = ASUSAURACORELAPTOP_SPEED_SLOWEST;
|
||||
ReactLaser.speed_max = ASUSAURACORELAPTOP_SPEED_FASTEST;
|
||||
ReactLaser.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
ReactLaser.speed = ASUSAURACORELAPTOP_SPEED_NORMAL;
|
||||
modes.push_back(ReactLaser);
|
||||
|
||||
mode ReactRipple;
|
||||
ReactRipple.name = "Reactive - Ripple";
|
||||
ReactRipple.value = ASUSAURACORELAPTOP_MODE_REACT_RIPPLE;
|
||||
ReactRipple.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
|
||||
ReactRipple.colors_min = 1;
|
||||
ReactRipple.colors_max = 1;
|
||||
ReactRipple.colors.resize(ReactRipple.colors_max);
|
||||
ReactRipple.brightness_min = ASUSAURACORELAPTOP_BRIGHTNESS_MIN;
|
||||
ReactRipple.brightness_max = ASUSAURACORELAPTOP_BRIGHTNESS_MAX;
|
||||
ReactRipple.brightness = ASUSAURACORELAPTOP_BRIGHTNESS_MAX;
|
||||
ReactRipple.speed_min = ASUSAURACORELAPTOP_SPEED_SLOWEST;
|
||||
ReactRipple.speed_max = ASUSAURACORELAPTOP_SPEED_FASTEST;
|
||||
ReactRipple.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
ReactRipple.speed = ASUSAURACORELAPTOP_SPEED_NORMAL;
|
||||
modes.push_back(ReactRipple);
|
||||
|
||||
mode Comet;
|
||||
Comet.name = "Comet";
|
||||
Comet.value = ASUSAURACORELAPTOP_MODE_COMET;
|
||||
Comet.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_DIRECTION_LR;
|
||||
Comet.colors_min = 1;
|
||||
Comet.colors_max = 1;
|
||||
Comet.colors.resize(Comet.colors_max);
|
||||
Comet.brightness_min = ASUSAURACORELAPTOP_BRIGHTNESS_MIN;
|
||||
Comet.brightness_max = ASUSAURACORELAPTOP_BRIGHTNESS_MAX;
|
||||
Comet.brightness = ASUSAURACORELAPTOP_BRIGHTNESS_MAX;
|
||||
Comet.speed_min = ASUSAURACORELAPTOP_SPEED_SLOWEST;
|
||||
Comet.speed_max = ASUSAURACORELAPTOP_SPEED_FASTEST;
|
||||
Comet.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Comet.speed = ASUSAURACORELAPTOP_SPEED_NORMAL;
|
||||
modes.push_back(Comet);
|
||||
|
||||
mode FlashNDash;
|
||||
FlashNDash.name = "Flash N Dash";
|
||||
FlashNDash.value = ASUSAURACORELAPTOP_MODE_FLASHNDASH;
|
||||
FlashNDash.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_DIRECTION_LR;
|
||||
FlashNDash.colors_min = 1;
|
||||
FlashNDash.colors_max = 1;
|
||||
FlashNDash.colors.resize(FlashNDash.colors_max);
|
||||
FlashNDash.brightness_min = ASUSAURACORELAPTOP_BRIGHTNESS_MIN;
|
||||
FlashNDash.brightness_max = ASUSAURACORELAPTOP_BRIGHTNESS_MAX;
|
||||
FlashNDash.brightness = ASUSAURACORELAPTOP_BRIGHTNESS_MAX;
|
||||
FlashNDash.speed_min = ASUSAURACORELAPTOP_SPEED_SLOWEST;
|
||||
FlashNDash.speed_max = ASUSAURACORELAPTOP_SPEED_FASTEST;
|
||||
FlashNDash.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
FlashNDash.speed = ASUSAURACORELAPTOP_SPEED_NORMAL;
|
||||
modes.push_back(FlashNDash);
|
||||
|
||||
mode Keystone;
|
||||
Keystone.name = "Keystone";
|
||||
Keystone.value = ASUSAURACORELAPTOP_MODE_KEYSTONE;
|
||||
Keystone.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
|
||||
Keystone.colors_min = 1;
|
||||
Keystone.colors_max = 1;
|
||||
Keystone.colors.resize(Keystone.colors_max);
|
||||
Keystone.brightness_min = ASUSAURACORELAPTOP_BRIGHTNESS_MIN;
|
||||
Keystone.brightness_max = ASUSAURACORELAPTOP_BRIGHTNESS_MAX;
|
||||
Keystone.brightness = ASUSAURACORELAPTOP_BRIGHTNESS_MAX;
|
||||
Keystone.speed_min = ASUSAURACORELAPTOP_SPEED_SLOWEST;
|
||||
Keystone.speed_max = ASUSAURACORELAPTOP_SPEED_FASTEST;
|
||||
Keystone.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Keystone.speed = ASUSAURACORELAPTOP_SPEED_NORMAL;
|
||||
modes.push_back(Keystone);
|
||||
|
||||
mode Off;
|
||||
Off.name = "Off";
|
||||
Off.value = ASUSAURACORELAPTOP_MODE_OFF;
|
||||
Off.color_mode = MODE_COLORS_NONE;
|
||||
modes.push_back(Off);
|
||||
|
||||
SetupZones();
|
||||
|
||||
SetMode(active_mode);
|
||||
}
|
||||
|
||||
RGBController_AsusAuraCoreLaptop::~RGBController_AsusAuraCoreLaptop()
|
||||
{
|
||||
delete controller;
|
||||
}
|
||||
|
||||
void RGBController_AsusAuraCoreLaptop::SetupZones()
|
||||
{
|
||||
std::string physical_size;
|
||||
KEYBOARD_LAYOUT new_layout;
|
||||
unsigned int max_led_value = 0;
|
||||
|
||||
const aura_core_laptop_device* aura_dev = controller->GetDeviceData();
|
||||
unsigned int layout = controller->GetKeyboardLayout();
|
||||
|
||||
switch(layout)
|
||||
{
|
||||
case ASUSAURACORELAPTOP_LAYOUT_ISO:
|
||||
new_layout = KEYBOARD_LAYOUT_ISO_QWERTY;
|
||||
break;
|
||||
|
||||
case ASUSAURACORELAPTOP_LAYOUT_ANSI:
|
||||
default:
|
||||
new_layout = KEYBOARD_LAYOUT_ANSI_QWERTY;
|
||||
break;
|
||||
}
|
||||
LOG_DEBUG("[%s] layout set as %d", description.c_str(), new_layout);
|
||||
|
||||
/*---------------------------------------------------------*\
|
||||
| Fill in zones from the device data |
|
||||
\*---------------------------------------------------------*/
|
||||
for(size_t i = 0; i < AURA_CORE_LAPTOP_ZONES_MAX; i++)
|
||||
{
|
||||
LOG_DEBUG("[%s] setting up zone %d", description.c_str(), i);
|
||||
|
||||
if(aura_dev->zones[i] == NULL)
|
||||
{
|
||||
break;
|
||||
}
|
||||
else
|
||||
{
|
||||
zone new_zone;
|
||||
|
||||
new_zone.name = aura_dev->zones[i]->name;
|
||||
|
||||
if(aura_dev->zones[i]->layout_new != NULL)
|
||||
{
|
||||
KeyboardLayoutManager new_kb(new_layout,
|
||||
aura_dev->zones[i]->layout_new->base_size,
|
||||
aura_dev->zones[i]->layout_new->key_values);
|
||||
|
||||
if(aura_dev->zones[i]->layout_new->base_size != KEYBOARD_SIZE_EMPTY ||
|
||||
aura_dev->zones[i]->layout_new->edit_keys.size() > 0)
|
||||
{
|
||||
/*---------------------------------------------------------*\
|
||||
| Minor adjustments to keyboard layout |
|
||||
\*---------------------------------------------------------*/
|
||||
keyboard_keymap_overlay_values* temp = aura_dev->zones[i]->layout_new;
|
||||
new_kb.ChangeKeys(*temp);
|
||||
|
||||
if(new_kb.GetRowCount() == 1 || new_kb.GetColumnCount() == 1)
|
||||
{
|
||||
if(new_kb.GetKeyCount() == 1)
|
||||
{
|
||||
new_zone.type = ZONE_TYPE_SINGLE;
|
||||
}
|
||||
else
|
||||
{
|
||||
new_zone.type = ZONE_TYPE_LINEAR;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
new_zone.type = ZONE_TYPE_MATRIX;
|
||||
matrix_map_type * new_map = new matrix_map_type;
|
||||
new_zone.matrix_map = new_map;
|
||||
|
||||
/*---------------------------------------------------------*\
|
||||
| Trusting the layout handed to the KLM is correct use the |
|
||||
| row & column counts to set the matrix height & width |
|
||||
\*---------------------------------------------------------*/
|
||||
new_map->height = new_kb.GetRowCount();
|
||||
new_map->width = new_kb.GetColumnCount();
|
||||
new_map->map = new unsigned int[new_map->height * new_map->width];
|
||||
|
||||
new_kb.GetKeyMap(new_map->map, KEYBOARD_MAP_FILL_TYPE_COUNT);
|
||||
}
|
||||
|
||||
/*---------------------------------------------------------*\
|
||||
| Create LEDs for the Matrix zone |
|
||||
| Place keys in the layout to populate the matrix |
|
||||
\*---------------------------------------------------------*/
|
||||
new_zone.leds_count = new_kb.GetKeyCount();
|
||||
for(unsigned int led_idx = 0; led_idx < new_zone.leds_count; led_idx++)
|
||||
{
|
||||
led new_led;
|
||||
|
||||
new_led.name = new_kb.GetKeyNameAt(led_idx);
|
||||
new_led.value = new_kb.GetKeyValueAt(led_idx);
|
||||
max_led_value = std::max(max_led_value, new_led.value);
|
||||
leds.push_back(new_led);
|
||||
}
|
||||
}
|
||||
|
||||
/*---------------------------------------------------------*\
|
||||
| Add 1 the max_led_value to account for the 0th index |
|
||||
\*---------------------------------------------------------*/
|
||||
max_led_value++;
|
||||
}
|
||||
|
||||
LOG_DEBUG("[%s] Creating a %s zone: %s with %d LEDs", name.c_str(),
|
||||
((new_zone.type == ZONE_TYPE_MATRIX) ? "matrix": "linear"),
|
||||
new_zone.name.c_str(), new_zone.leds_count);
|
||||
new_zone.leds_min = new_zone.leds_count;
|
||||
new_zone.leds_max = new_zone.leds_count;
|
||||
zones.push_back(new_zone);
|
||||
}
|
||||
}
|
||||
|
||||
SetupColors();
|
||||
|
||||
/*---------------------------------------------------------*\
|
||||
| Create a buffer map of pointers which contains the |
|
||||
| layout order of colors the device expects. |
|
||||
\*---------------------------------------------------------*/
|
||||
buffer_map.resize(max_led_value, &null_color);
|
||||
|
||||
for(size_t led_idx = 0; led_idx < leds.size(); led_idx++)
|
||||
{
|
||||
buffer_map[leds[led_idx].value] = &colors[led_idx];
|
||||
}
|
||||
}
|
||||
|
||||
void RGBController_AsusAuraCoreLaptop::ResizeZone(int /*zone*/, int /*new_size*/)
|
||||
{
|
||||
/*---------------------------------------------------------*\
|
||||
| This device does not support resizing zones |
|
||||
\*---------------------------------------------------------*/
|
||||
}
|
||||
|
||||
void RGBController_AsusAuraCoreLaptop::DeviceUpdateLEDs()
|
||||
{
|
||||
for(size_t i = 85; i < leds.size(); i++)
|
||||
{
|
||||
LOG_DEBUG("[%s] Setting %s @ LED index %d and buffer index %d to R: %02X G: %02X B: %02X",
|
||||
name.c_str(),
|
||||
leds[i].name.c_str(),
|
||||
i,
|
||||
leds[i].value,
|
||||
RGBGetRValue(colors[i]),
|
||||
RGBGetGValue(colors[i]),
|
||||
RGBGetBValue(colors[i]));
|
||||
}
|
||||
|
||||
controller->SetLedsDirect(buffer_map);
|
||||
}
|
||||
|
||||
void RGBController_AsusAuraCoreLaptop::UpdateZoneLEDs(int /*zone*/)
|
||||
{
|
||||
controller->SetLedsDirect(buffer_map);
|
||||
}
|
||||
|
||||
void RGBController_AsusAuraCoreLaptop::UpdateSingleLED(int /*led*/)
|
||||
{
|
||||
controller->SetLedsDirect(buffer_map);
|
||||
}
|
||||
|
||||
void RGBController_AsusAuraCoreLaptop::DeviceUpdateMode()
|
||||
{
|
||||
mode set_mode = modes[active_mode];
|
||||
|
||||
uint8_t random = (set_mode.color_mode == MODE_COLORS_RANDOM) ? 0xFF : 0;
|
||||
RGBColor color1 = (set_mode.colors.size() > 0) ? set_mode.colors[0] : 0;
|
||||
RGBColor color2 = (set_mode.colors.size() > 1) ? set_mode.colors[1] : 0;
|
||||
|
||||
controller->SetMode(set_mode.value, set_mode.speed, set_mode.brightness, color1, color2, random, set_mode.direction );
|
||||
}
|
||||
/*---------------------------------------------------------*\
|
||||
| RGBController_AsusAuraCoreLaptop.cpp |
|
||||
| |
|
||||
| RGBController for ASUS ROG Aura Core Laptop |
|
||||
| |
|
||||
| Chris M (Dr_No) 28 Jul 2022 |
|
||||
| |
|
||||
| This file is part of the OpenRGB project |
|
||||
| SPDX-License-Identifier: GPL-2.0-or-later |
|
||||
\*---------------------------------------------------------*/
|
||||
|
||||
#include "RGBController_AsusAuraCoreLaptop.h"
|
||||
|
||||
/**------------------------------------------------------------------*\
|
||||
@name AsusAuraCoreLaptop
|
||||
@category DEVICE_TYPE_KEYBOARD
|
||||
@type USB
|
||||
@save :x:
|
||||
@direct :white_check_mark:
|
||||
@effects :white_check_mark:
|
||||
@detectors DetectAsusAuraCoreLaptopControllers
|
||||
@comment Power profiles for this controller are set to `On` for all power
|
||||
state and scan be adjusted in the JSON config file.
|
||||
|
||||
For each zone available LEDs can be set as `On = true` or `Off = false` when
|
||||
* Booting
|
||||
* Awake (Normal Usage)
|
||||
* Sleeping
|
||||
* Shutdown / Power Off
|
||||
|
||||
MatrixMaps can be found in ArmouryCrate (it needs a chance to download device data)
|
||||
Default path is:
|
||||
C:\ProgramData\ASUS\ROG Live Service\DeviceContent\<Model name>\<Model name>.csv
|
||||
(Model name is the code like G814JV - can be found in the error in logs)
|
||||
\*-------------------------------------------------------------------*/
|
||||
|
||||
RGBController_AsusAuraCoreLaptop::RGBController_AsusAuraCoreLaptop(AsusAuraCoreLaptopController *controller_ptr)
|
||||
{
|
||||
controller = controller_ptr;
|
||||
const aura_core_laptop_device* aura_dev = controller->GetDeviceData();
|
||||
|
||||
name = aura_dev->dmi_name;
|
||||
vendor = "Asus";
|
||||
type = DEVICE_TYPE_LAPTOP;
|
||||
description = controller->GetDeviceDescription();
|
||||
serial = controller->GetSerial();
|
||||
location = controller->GetLocation();
|
||||
|
||||
mode Direct;
|
||||
Direct.name = "Direct";
|
||||
Direct.value = ASUSAURACORELAPTOP_MODE_DIRECT;
|
||||
Direct.flags = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
|
||||
Direct.brightness_min = ASUSAURACORELAPTOP_BRIGHTNESS_MIN;
|
||||
Direct.brightness_max = ASUSAURACORELAPTOP_BRIGHTNESS_MAX;
|
||||
Direct.brightness = ASUSAURACORELAPTOP_BRIGHTNESS_MAX;
|
||||
Direct.color_mode = MODE_COLORS_PER_LED;
|
||||
modes.push_back(Direct);
|
||||
|
||||
mode Static;
|
||||
Static.name = "Static";
|
||||
Static.value = ASUSAURACORELAPTOP_MODE_STATIC;
|
||||
Static.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
|
||||
Static.colors_min = 1;
|
||||
Static.colors_max = 1;
|
||||
Static.colors.resize(Static.colors_max);
|
||||
Static.brightness_min = ASUSAURACORELAPTOP_BRIGHTNESS_MIN;
|
||||
Static.brightness_max = ASUSAURACORELAPTOP_BRIGHTNESS_MAX;
|
||||
Static.brightness = ASUSAURACORELAPTOP_BRIGHTNESS_MAX;
|
||||
Static.speed_min = ASUSAURACORELAPTOP_SPEED_SLOWEST;
|
||||
Static.speed_max = ASUSAURACORELAPTOP_SPEED_FASTEST;
|
||||
Static.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Static.speed = ASUSAURACORELAPTOP_SPEED_NORMAL;
|
||||
modes.push_back(Static);
|
||||
|
||||
mode Breathing;
|
||||
Breathing.name = "Breathing";
|
||||
Breathing.value = ASUSAURACORELAPTOP_MODE_BREATHING;
|
||||
Breathing.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
|
||||
Breathing.colors_min = 1;
|
||||
Breathing.colors_max = 2;
|
||||
Breathing.colors.resize(Breathing.colors_min);
|
||||
Breathing.brightness_min = ASUSAURACORELAPTOP_BRIGHTNESS_MIN;
|
||||
Breathing.brightness_max = ASUSAURACORELAPTOP_BRIGHTNESS_MAX;
|
||||
Breathing.brightness = ASUSAURACORELAPTOP_BRIGHTNESS_MAX;
|
||||
Breathing.speed_min = ASUSAURACORELAPTOP_SPEED_SLOWEST;
|
||||
Breathing.speed_max = ASUSAURACORELAPTOP_SPEED_FASTEST;
|
||||
Breathing.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Breathing.speed = ASUSAURACORELAPTOP_SPEED_NORMAL;
|
||||
modes.push_back(Breathing);
|
||||
|
||||
mode Flashing;
|
||||
Flashing.name = "Flashing";
|
||||
Flashing.value = ASUSAURACORELAPTOP_MODE_FLASHING;
|
||||
Flashing.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
|
||||
Flashing.colors_min = 1;
|
||||
Flashing.colors_max = 1;
|
||||
Flashing.colors.resize(Flashing.colors_max);
|
||||
Flashing.brightness_min = ASUSAURACORELAPTOP_BRIGHTNESS_MIN;
|
||||
Flashing.brightness_max = ASUSAURACORELAPTOP_BRIGHTNESS_MAX;
|
||||
Flashing.brightness = ASUSAURACORELAPTOP_BRIGHTNESS_MAX;
|
||||
Flashing.speed_min = ASUSAURACORELAPTOP_SPEED_SLOWEST;
|
||||
Flashing.speed_max = ASUSAURACORELAPTOP_SPEED_FASTEST;
|
||||
Flashing.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Flashing.speed = ASUSAURACORELAPTOP_SPEED_NORMAL;
|
||||
modes.push_back(Flashing);
|
||||
|
||||
mode Spectrum;
|
||||
Spectrum.name = "Spectrum Cycle";
|
||||
Spectrum.value = ASUSAURACORELAPTOP_MODE_SPECTRUM;
|
||||
Spectrum.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
|
||||
Spectrum.brightness_min = ASUSAURACORELAPTOP_BRIGHTNESS_MIN;
|
||||
Spectrum.brightness_max = ASUSAURACORELAPTOP_BRIGHTNESS_MAX;
|
||||
Spectrum.brightness = ASUSAURACORELAPTOP_BRIGHTNESS_MAX;
|
||||
Spectrum.speed_min = ASUSAURACORELAPTOP_SPEED_SLOWEST;
|
||||
Spectrum.speed_max = ASUSAURACORELAPTOP_SPEED_FASTEST;
|
||||
Spectrum.color_mode = MODE_COLORS_NONE;
|
||||
Spectrum.speed = ASUSAURACORELAPTOP_SPEED_NORMAL;
|
||||
modes.push_back(Spectrum);
|
||||
|
||||
mode Rainbow;
|
||||
Rainbow.name = "Rainbow Wave";
|
||||
Rainbow.value = ASUSAURACORELAPTOP_MODE_RAINBOW;
|
||||
Rainbow.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_DIRECTION_UD;
|
||||
Rainbow.brightness_min = ASUSAURACORELAPTOP_BRIGHTNESS_MIN;
|
||||
Rainbow.brightness_max = ASUSAURACORELAPTOP_BRIGHTNESS_MAX;
|
||||
Rainbow.brightness = ASUSAURACORELAPTOP_BRIGHTNESS_MAX;
|
||||
Rainbow.speed_min = ASUSAURACORELAPTOP_SPEED_SLOWEST;
|
||||
Rainbow.speed_max = ASUSAURACORELAPTOP_SPEED_FASTEST;
|
||||
Rainbow.color_mode = MODE_COLORS_NONE;
|
||||
Rainbow.speed = ASUSAURACORELAPTOP_SPEED_NORMAL;
|
||||
modes.push_back(Rainbow);
|
||||
|
||||
mode Starry;
|
||||
Starry.name = "Starry Night";
|
||||
Starry.value = ASUSAURACORELAPTOP_MODE_STARRY_NIGHT;
|
||||
Starry.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
|
||||
Starry.colors_min = 1;
|
||||
Starry.colors_max = 2;
|
||||
Starry.colors.resize(Starry.colors_min);
|
||||
Starry.brightness_min = ASUSAURACORELAPTOP_BRIGHTNESS_MIN;
|
||||
Starry.brightness_max = ASUSAURACORELAPTOP_BRIGHTNESS_MAX;
|
||||
Starry.brightness = ASUSAURACORELAPTOP_BRIGHTNESS_MAX;
|
||||
Starry.speed_min = ASUSAURACORELAPTOP_SPEED_SLOWEST;
|
||||
Starry.speed_max = ASUSAURACORELAPTOP_SPEED_FASTEST;
|
||||
Starry.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Starry.speed = ASUSAURACORELAPTOP_SPEED_NORMAL;
|
||||
modes.push_back(Starry);
|
||||
|
||||
mode Rain;
|
||||
Rain.name = "Rain";
|
||||
Rain.value = ASUSAURACORELAPTOP_MODE_RAIN;
|
||||
Rain.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
|
||||
Rain.brightness_min = ASUSAURACORELAPTOP_BRIGHTNESS_MIN;
|
||||
Rain.brightness_max = ASUSAURACORELAPTOP_BRIGHTNESS_MAX;
|
||||
Rain.brightness = ASUSAURACORELAPTOP_BRIGHTNESS_MAX;
|
||||
Rain.speed_min = ASUSAURACORELAPTOP_SPEED_SLOWEST;
|
||||
Rain.speed_max = ASUSAURACORELAPTOP_SPEED_FASTEST;
|
||||
Rain.color_mode = MODE_COLORS_NONE;
|
||||
Rain.speed = ASUSAURACORELAPTOP_SPEED_NORMAL;
|
||||
modes.push_back(Rain);
|
||||
|
||||
mode ReactFade;
|
||||
ReactFade.name = "Reactive - Fade";
|
||||
ReactFade.value = ASUSAURACORELAPTOP_MODE_REACT_FADE;
|
||||
ReactFade.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
|
||||
ReactFade.colors_min = 1;
|
||||
ReactFade.colors_max = 1;
|
||||
ReactFade.colors.resize(ReactFade.colors_max);
|
||||
ReactFade.brightness_min = ASUSAURACORELAPTOP_BRIGHTNESS_MIN;
|
||||
ReactFade.brightness_max = ASUSAURACORELAPTOP_BRIGHTNESS_MAX;
|
||||
ReactFade.brightness = ASUSAURACORELAPTOP_BRIGHTNESS_MAX;
|
||||
ReactFade.speed_min = ASUSAURACORELAPTOP_SPEED_SLOWEST;
|
||||
ReactFade.speed_max = ASUSAURACORELAPTOP_SPEED_FASTEST;
|
||||
ReactFade.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
ReactFade.speed = ASUSAURACORELAPTOP_SPEED_NORMAL;
|
||||
modes.push_back(ReactFade);
|
||||
|
||||
mode ReactLaser;
|
||||
ReactLaser.name = "Reactive - Laser";
|
||||
ReactLaser.value = ASUSAURACORELAPTOP_MODE_REACT_LASER;
|
||||
ReactLaser.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
|
||||
ReactLaser.colors_min = 1;
|
||||
ReactLaser.colors_max = 1;
|
||||
ReactLaser.colors.resize(ReactLaser.colors_max);
|
||||
ReactLaser.brightness_min = ASUSAURACORELAPTOP_BRIGHTNESS_MIN;
|
||||
ReactLaser.brightness_max = ASUSAURACORELAPTOP_BRIGHTNESS_MAX;
|
||||
ReactLaser.brightness = ASUSAURACORELAPTOP_BRIGHTNESS_MAX;
|
||||
ReactLaser.speed_min = ASUSAURACORELAPTOP_SPEED_SLOWEST;
|
||||
ReactLaser.speed_max = ASUSAURACORELAPTOP_SPEED_FASTEST;
|
||||
ReactLaser.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
ReactLaser.speed = ASUSAURACORELAPTOP_SPEED_NORMAL;
|
||||
modes.push_back(ReactLaser);
|
||||
|
||||
mode ReactRipple;
|
||||
ReactRipple.name = "Reactive - Ripple";
|
||||
ReactRipple.value = ASUSAURACORELAPTOP_MODE_REACT_RIPPLE;
|
||||
ReactRipple.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
|
||||
ReactRipple.colors_min = 1;
|
||||
ReactRipple.colors_max = 1;
|
||||
ReactRipple.colors.resize(ReactRipple.colors_max);
|
||||
ReactRipple.brightness_min = ASUSAURACORELAPTOP_BRIGHTNESS_MIN;
|
||||
ReactRipple.brightness_max = ASUSAURACORELAPTOP_BRIGHTNESS_MAX;
|
||||
ReactRipple.brightness = ASUSAURACORELAPTOP_BRIGHTNESS_MAX;
|
||||
ReactRipple.speed_min = ASUSAURACORELAPTOP_SPEED_SLOWEST;
|
||||
ReactRipple.speed_max = ASUSAURACORELAPTOP_SPEED_FASTEST;
|
||||
ReactRipple.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
ReactRipple.speed = ASUSAURACORELAPTOP_SPEED_NORMAL;
|
||||
modes.push_back(ReactRipple);
|
||||
|
||||
mode Comet;
|
||||
Comet.name = "Comet";
|
||||
Comet.value = ASUSAURACORELAPTOP_MODE_COMET;
|
||||
Comet.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_DIRECTION_LR;
|
||||
Comet.colors_min = 1;
|
||||
Comet.colors_max = 1;
|
||||
Comet.colors.resize(Comet.colors_max);
|
||||
Comet.brightness_min = ASUSAURACORELAPTOP_BRIGHTNESS_MIN;
|
||||
Comet.brightness_max = ASUSAURACORELAPTOP_BRIGHTNESS_MAX;
|
||||
Comet.brightness = ASUSAURACORELAPTOP_BRIGHTNESS_MAX;
|
||||
Comet.speed_min = ASUSAURACORELAPTOP_SPEED_SLOWEST;
|
||||
Comet.speed_max = ASUSAURACORELAPTOP_SPEED_FASTEST;
|
||||
Comet.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Comet.speed = ASUSAURACORELAPTOP_SPEED_NORMAL;
|
||||
modes.push_back(Comet);
|
||||
|
||||
mode FlashNDash;
|
||||
FlashNDash.name = "Flash N Dash";
|
||||
FlashNDash.value = ASUSAURACORELAPTOP_MODE_FLASHNDASH;
|
||||
FlashNDash.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_DIRECTION_LR;
|
||||
FlashNDash.colors_min = 1;
|
||||
FlashNDash.colors_max = 1;
|
||||
FlashNDash.colors.resize(FlashNDash.colors_max);
|
||||
FlashNDash.brightness_min = ASUSAURACORELAPTOP_BRIGHTNESS_MIN;
|
||||
FlashNDash.brightness_max = ASUSAURACORELAPTOP_BRIGHTNESS_MAX;
|
||||
FlashNDash.brightness = ASUSAURACORELAPTOP_BRIGHTNESS_MAX;
|
||||
FlashNDash.speed_min = ASUSAURACORELAPTOP_SPEED_SLOWEST;
|
||||
FlashNDash.speed_max = ASUSAURACORELAPTOP_SPEED_FASTEST;
|
||||
FlashNDash.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
FlashNDash.speed = ASUSAURACORELAPTOP_SPEED_NORMAL;
|
||||
modes.push_back(FlashNDash);
|
||||
|
||||
mode Keystone;
|
||||
Keystone.name = "Keystone";
|
||||
Keystone.value = ASUSAURACORELAPTOP_MODE_KEYSTONE;
|
||||
Keystone.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
|
||||
Keystone.colors_min = 1;
|
||||
Keystone.colors_max = 1;
|
||||
Keystone.colors.resize(Keystone.colors_max);
|
||||
Keystone.brightness_min = ASUSAURACORELAPTOP_BRIGHTNESS_MIN;
|
||||
Keystone.brightness_max = ASUSAURACORELAPTOP_BRIGHTNESS_MAX;
|
||||
Keystone.brightness = ASUSAURACORELAPTOP_BRIGHTNESS_MAX;
|
||||
Keystone.speed_min = ASUSAURACORELAPTOP_SPEED_SLOWEST;
|
||||
Keystone.speed_max = ASUSAURACORELAPTOP_SPEED_FASTEST;
|
||||
Keystone.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Keystone.speed = ASUSAURACORELAPTOP_SPEED_NORMAL;
|
||||
modes.push_back(Keystone);
|
||||
|
||||
mode Off;
|
||||
Off.name = "Off";
|
||||
Off.value = ASUSAURACORELAPTOP_MODE_OFF;
|
||||
Off.color_mode = MODE_COLORS_NONE;
|
||||
modes.push_back(Off);
|
||||
|
||||
SetupZones();
|
||||
|
||||
SetMode(active_mode);
|
||||
}
|
||||
|
||||
RGBController_AsusAuraCoreLaptop::~RGBController_AsusAuraCoreLaptop()
|
||||
{
|
||||
delete controller;
|
||||
}
|
||||
|
||||
void RGBController_AsusAuraCoreLaptop::SetupZones()
|
||||
{
|
||||
std::string physical_size;
|
||||
KEYBOARD_LAYOUT new_layout;
|
||||
unsigned int max_led_value = 0;
|
||||
|
||||
const aura_core_laptop_device* aura_dev = controller->GetDeviceData();
|
||||
unsigned int layout = controller->GetKeyboardLayout();
|
||||
|
||||
switch(layout)
|
||||
{
|
||||
case ASUSAURACORELAPTOP_LAYOUT_ISO:
|
||||
new_layout = KEYBOARD_LAYOUT_ISO_QWERTY;
|
||||
break;
|
||||
|
||||
case ASUSAURACORELAPTOP_LAYOUT_ANSI:
|
||||
default:
|
||||
new_layout = KEYBOARD_LAYOUT_ANSI_QWERTY;
|
||||
break;
|
||||
}
|
||||
LOG_DEBUG("[%s] layout set as %d", description.c_str(), new_layout);
|
||||
|
||||
/*---------------------------------------------------------*\
|
||||
| Fill in zones from the device data |
|
||||
\*---------------------------------------------------------*/
|
||||
for(size_t i = 0; i < AURA_CORE_LAPTOP_ZONES_MAX; i++)
|
||||
{
|
||||
LOG_DEBUG("[%s] setting up zone %d", description.c_str(), i);
|
||||
|
||||
if(aura_dev->zones[i] == NULL)
|
||||
{
|
||||
break;
|
||||
}
|
||||
else
|
||||
{
|
||||
zone new_zone;
|
||||
|
||||
new_zone.name = aura_dev->zones[i]->name;
|
||||
|
||||
if(aura_dev->zones[i]->layout_new != NULL)
|
||||
{
|
||||
KeyboardLayoutManager new_kb(new_layout,
|
||||
aura_dev->zones[i]->layout_new->base_size,
|
||||
aura_dev->zones[i]->layout_new->key_values);
|
||||
|
||||
if(aura_dev->zones[i]->layout_new->base_size != KEYBOARD_SIZE_EMPTY ||
|
||||
aura_dev->zones[i]->layout_new->edit_keys.size() > 0)
|
||||
{
|
||||
/*---------------------------------------------------------*\
|
||||
| Minor adjustments to keyboard layout |
|
||||
\*---------------------------------------------------------*/
|
||||
keyboard_keymap_overlay_values* temp = aura_dev->zones[i]->layout_new;
|
||||
new_kb.ChangeKeys(*temp);
|
||||
|
||||
if(new_kb.GetRowCount() == 1 || new_kb.GetColumnCount() == 1)
|
||||
{
|
||||
if(new_kb.GetKeyCount() == 1)
|
||||
{
|
||||
new_zone.type = ZONE_TYPE_SINGLE;
|
||||
}
|
||||
else
|
||||
{
|
||||
new_zone.type = ZONE_TYPE_LINEAR;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
new_zone.type = ZONE_TYPE_MATRIX;
|
||||
matrix_map_type * new_map = new matrix_map_type;
|
||||
new_zone.matrix_map = new_map;
|
||||
|
||||
/*---------------------------------------------------------*\
|
||||
| Trusting the layout handed to the KLM is correct use the |
|
||||
| row & column counts to set the matrix height & width |
|
||||
\*---------------------------------------------------------*/
|
||||
new_map->height = new_kb.GetRowCount();
|
||||
new_map->width = new_kb.GetColumnCount();
|
||||
new_map->map = new unsigned int[new_map->height * new_map->width];
|
||||
|
||||
new_kb.GetKeyMap(new_map->map, KEYBOARD_MAP_FILL_TYPE_COUNT);
|
||||
}
|
||||
|
||||
/*---------------------------------------------------------*\
|
||||
| Create LEDs for the Matrix zone |
|
||||
| Place keys in the layout to populate the matrix |
|
||||
\*---------------------------------------------------------*/
|
||||
new_zone.leds_count = new_kb.GetKeyCount();
|
||||
for(unsigned int led_idx = 0; led_idx < new_zone.leds_count; led_idx++)
|
||||
{
|
||||
led new_led;
|
||||
|
||||
new_led.name = new_kb.GetKeyNameAt(led_idx);
|
||||
new_led.value = new_kb.GetKeyValueAt(led_idx);
|
||||
max_led_value = std::max(max_led_value, new_led.value);
|
||||
leds.push_back(new_led);
|
||||
}
|
||||
}
|
||||
|
||||
/*---------------------------------------------------------*\
|
||||
| Add 1 the max_led_value to account for the 0th index |
|
||||
\*---------------------------------------------------------*/
|
||||
max_led_value++;
|
||||
}
|
||||
|
||||
LOG_DEBUG("[%s] Creating a %s zone: %s with %d LEDs", name.c_str(),
|
||||
((new_zone.type == ZONE_TYPE_MATRIX) ? "matrix": "linear"),
|
||||
new_zone.name.c_str(), new_zone.leds_count);
|
||||
new_zone.leds_min = new_zone.leds_count;
|
||||
new_zone.leds_max = new_zone.leds_count;
|
||||
zones.push_back(new_zone);
|
||||
}
|
||||
}
|
||||
|
||||
SetupColors();
|
||||
|
||||
/*---------------------------------------------------------*\
|
||||
| Create a buffer map of pointers which contains the |
|
||||
| layout order of colors the device expects. |
|
||||
\*---------------------------------------------------------*/
|
||||
buffer_map.resize(max_led_value, &null_color);
|
||||
|
||||
for(size_t led_idx = 0; led_idx < leds.size(); led_idx++)
|
||||
{
|
||||
buffer_map[leds[led_idx].value] = &colors[led_idx];
|
||||
}
|
||||
}
|
||||
|
||||
void RGBController_AsusAuraCoreLaptop::ResizeZone(int /*zone*/, int /*new_size*/)
|
||||
{
|
||||
/*---------------------------------------------------------*\
|
||||
| This device does not support resizing zones |
|
||||
\*---------------------------------------------------------*/
|
||||
}
|
||||
|
||||
void RGBController_AsusAuraCoreLaptop::DeviceUpdateLEDs()
|
||||
{
|
||||
for(size_t i = 85; i < leds.size(); i++)
|
||||
{
|
||||
LOG_DEBUG("[%s] Setting %s @ LED index %d and buffer index %d to R: %02X G: %02X B: %02X",
|
||||
name.c_str(),
|
||||
leds[i].name.c_str(),
|
||||
i,
|
||||
leds[i].value,
|
||||
RGBGetRValue(colors[i]),
|
||||
RGBGetGValue(colors[i]),
|
||||
RGBGetBValue(colors[i]));
|
||||
}
|
||||
|
||||
controller->SetLedsDirect(buffer_map);
|
||||
}
|
||||
|
||||
void RGBController_AsusAuraCoreLaptop::UpdateZoneLEDs(int /*zone*/)
|
||||
{
|
||||
controller->SetLedsDirect(buffer_map);
|
||||
}
|
||||
|
||||
void RGBController_AsusAuraCoreLaptop::UpdateSingleLED(int /*led*/)
|
||||
{
|
||||
controller->SetLedsDirect(buffer_map);
|
||||
}
|
||||
|
||||
void RGBController_AsusAuraCoreLaptop::DeviceUpdateMode()
|
||||
{
|
||||
mode set_mode = modes[active_mode];
|
||||
|
||||
uint8_t random = (set_mode.color_mode == MODE_COLORS_RANDOM) ? 0xFF : 0;
|
||||
RGBColor color1 = (set_mode.colors.size() > 0) ? set_mode.colors[0] : 0;
|
||||
RGBColor color2 = (set_mode.colors.size() > 1) ? set_mode.colors[1] : 0;
|
||||
|
||||
controller->SetMode(set_mode.value, set_mode.speed, set_mode.brightness, color1, color2, random, set_mode.direction );
|
||||
}
|
||||
+39
-39
@@ -1,39 +1,39 @@
|
||||
/*---------------------------------------------------------*\
|
||||
| RGBController_AsusAuraCoreLaptop.h |
|
||||
| |
|
||||
| RGBController for ASUS ROG Aura Core Laptop |
|
||||
| |
|
||||
| Chris M (Dr_No) 28 Jul 2022 |
|
||||
| |
|
||||
| This file is part of the OpenRGB project |
|
||||
| SPDX-License-Identifier: GPL-2.0-or-later |
|
||||
\*---------------------------------------------------------*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <algorithm>
|
||||
#include <vector>
|
||||
#include "RGBController.h"
|
||||
#include "AsusAuraCoreLaptopController.h"
|
||||
|
||||
class RGBController_AsusAuraCoreLaptop : public RGBController
|
||||
{
|
||||
public:
|
||||
RGBController_AsusAuraCoreLaptop(AsusAuraCoreLaptopController* controller_ptr);
|
||||
~RGBController_AsusAuraCoreLaptop();
|
||||
|
||||
void SetupZones();
|
||||
void ResizeZone(int zone, int new_size);
|
||||
|
||||
void DeviceUpdateLEDs();
|
||||
void UpdateZoneLEDs(int zone);
|
||||
void UpdateSingleLED(int led);
|
||||
|
||||
void DeviceUpdateMode();
|
||||
|
||||
private:
|
||||
RGBColor null_color = 0;
|
||||
std::vector<RGBColor *> buffer_map;
|
||||
|
||||
AsusAuraCoreLaptopController* controller;
|
||||
};
|
||||
/*---------------------------------------------------------*\
|
||||
| RGBController_AsusAuraCoreLaptop.h |
|
||||
| |
|
||||
| RGBController for ASUS ROG Aura Core Laptop |
|
||||
| |
|
||||
| Chris M (Dr_No) 28 Jul 2022 |
|
||||
| |
|
||||
| This file is part of the OpenRGB project |
|
||||
| SPDX-License-Identifier: GPL-2.0-or-later |
|
||||
\*---------------------------------------------------------*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <algorithm>
|
||||
#include <vector>
|
||||
#include "RGBController.h"
|
||||
#include "AsusAuraCoreLaptopController.h"
|
||||
|
||||
class RGBController_AsusAuraCoreLaptop : public RGBController
|
||||
{
|
||||
public:
|
||||
RGBController_AsusAuraCoreLaptop(AsusAuraCoreLaptopController* controller_ptr);
|
||||
~RGBController_AsusAuraCoreLaptop();
|
||||
|
||||
void SetupZones();
|
||||
void ResizeZone(int zone, int new_size);
|
||||
|
||||
void DeviceUpdateLEDs();
|
||||
void UpdateZoneLEDs(int zone);
|
||||
void UpdateSingleLED(int led);
|
||||
|
||||
void DeviceUpdateMode();
|
||||
|
||||
private:
|
||||
RGBColor null_color = 0;
|
||||
std::vector<RGBColor *> buffer_map;
|
||||
|
||||
AsusAuraCoreLaptopController* controller;
|
||||
};
|
||||
Reference in new issue
Block a user