Initial commit for the Asus ROG Strix SCAR 15 to resolve #2622
+ Adding AsusAuraCoreLaptopController and RGBController_AsusAuraCoreLaptop + Adding PID `0x19B6` and registering detector in AsusAuraCoreControllerDetect.cpp
This commit is contained in:
Chris
parent
4d7fe885c9
commit
1c1bfee727
6 changed files with 1053 additions and 7 deletions
|
|
@ -2,9 +2,12 @@
|
|||
#include "AsusAuraCoreController.h"
|
||||
#include "RGBController.h"
|
||||
#include "RGBController_AsusAuraCore.h"
|
||||
#include "RGBController_AsusAuraCoreLaptop.h"
|
||||
#include <hidapi/hidapi.h>
|
||||
|
||||
#define AURA_CORE_VID 0x0B05
|
||||
#define AURA_CORE_VID 0x0B05
|
||||
|
||||
#define AURA_STRIX_SCAR_15_PID 0x19B6
|
||||
|
||||
/******************************************************************************************\
|
||||
* *
|
||||
|
|
@ -17,10 +20,11 @@
|
|||
void DetectAsusAuraCoreControllers(hid_device_info* info, const std::string&)
|
||||
{
|
||||
hid_device* dev = hid_open_path(info->path);
|
||||
if( dev )
|
||||
|
||||
if(dev)
|
||||
{
|
||||
AuraCoreController* controller = new AuraCoreController(dev, info->path);
|
||||
RGBController_AuraCore* rgb_controller = new RGBController_AuraCore(controller);
|
||||
AuraCoreController* controller = new AuraCoreController(dev, info->path);
|
||||
RGBController_AuraCore* rgb_controller = new RGBController_AuraCore(controller);
|
||||
// Constructor sets the name
|
||||
if(rgb_controller->type != DEVICE_TYPE_UNKNOWN)
|
||||
{
|
||||
|
|
@ -33,6 +37,21 @@ void DetectAsusAuraCoreControllers(hid_device_info* info, const std::string&)
|
|||
}
|
||||
}
|
||||
|
||||
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);
|
||||
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);
|
||||
// Constructor sets the name
|
||||
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);
|
||||
|
|
|
|||
|
|
@ -0,0 +1,356 @@
|
|||
/*---------------------------------------------------------------------*\
|
||||
| AsusAuraCoreLaptopController.cpp |
|
||||
| |
|
||||
| Driver for Asus Aura Core Laptop USB Controller |
|
||||
| |
|
||||
| Chris M (Dr_No) 28 Jul 2022 |
|
||||
| |
|
||||
\*---------------------------------------------------------------------*/
|
||||
|
||||
#include "AsusAuraCoreLaptopController.h"
|
||||
|
||||
static uint8_t packet_map[ASUSAURACORELAPTOP_KEYCOUNT +
|
||||
ASUSAURACORELAPTOP_LIGHTBARCOUNT +
|
||||
ASUSAURACORELAPTOP_LIDCOUNT ] =
|
||||
{
|
||||
/*00 ESC F1 F2 F3 F4 F5 F6 F7 F8 F9 */
|
||||
21, 23, 24, 25, 26, 28, 29, 30, 31, 33,
|
||||
|
||||
/*10 F10 F11 F12 DEL ` 1 2 3 4 5 */
|
||||
34, 35, 36, 37, 42, 43, 44, 45, 46, 47,
|
||||
|
||||
/*20 6 7 8 9 0 - = BSP BSP BSP */
|
||||
48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
|
||||
|
||||
/*30 PLY TAB Q W E R T Y U I */
|
||||
58, 63, 64, 65, 66, 67, 68, 69, 70, 71,
|
||||
|
||||
/*40 O P [ ] \ STP CAP A S D */
|
||||
72, 73, 74, 75, 76, 79, 84, 85, 86, 87,
|
||||
|
||||
/*50 F G H J K L ; ' ENT PRV */
|
||||
88, 89, 90, 91, 92, 93, 94, 95, 98, 100,
|
||||
|
||||
/*60 LSH Z X C V B N M , . */
|
||||
105, 107, 108, 109, 110, 111, 112, 113, 114, 115,
|
||||
|
||||
/*70 / RSH UP NXT LCTL LFN LWIN LALT SPC RALT */
|
||||
116, 119, 139, 121, 126, 127, 128, 129, 131, 135,
|
||||
|
||||
/*80 RCTL LFT DWN RGT PRT KSTN VDN VUP MICM HPFN */
|
||||
137, 159, 160, 161, 142, 175, 2, 3, 4, 5,
|
||||
|
||||
/*90 ARMC LB1 LB2 LB3 LB4 LB5 LB6 LOGO LIDL LIDR */
|
||||
6, 174, 173, 172, 171, 170, 169, 167, 176, 177,
|
||||
|
||||
};
|
||||
|
||||
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)
|
||||
{
|
||||
const uint8_t sz = HID_MAX_STR;
|
||||
wchar_t tmp[sz];
|
||||
|
||||
dev = dev_handle;
|
||||
location = path;
|
||||
|
||||
hid_get_manufacturer_string(dev, tmp, sz);
|
||||
std::wstring wName = std::wstring(tmp);
|
||||
device_name = std::string(wName.begin(), wName.end());
|
||||
|
||||
hid_get_product_string(dev, tmp, sz);
|
||||
wName = std::wstring(tmp);
|
||||
device_name.append(" ").append(std::string(wName.begin(), wName.end()));
|
||||
|
||||
SetPowerConfigFromJSON();
|
||||
}
|
||||
|
||||
AsusAuraCoreLaptopController::~AsusAuraCoreLaptopController()
|
||||
{
|
||||
hid_close(dev);
|
||||
}
|
||||
|
||||
std::string AsusAuraCoreLaptopController::GetDeviceName()
|
||||
{
|
||||
return device_name;
|
||||
}
|
||||
|
||||
std::string AsusAuraCoreLaptopController::GetSerial()
|
||||
{
|
||||
const uint8_t sz = HID_MAX_STR;
|
||||
wchar_t tmp[sz];
|
||||
|
||||
int ret = hid_get_serial_number_string(dev, tmp, sz);
|
||||
|
||||
if (ret != 0)
|
||||
{
|
||||
LOG_DEBUG("[%s] Get HID Serial string failed", device_name.c_str());
|
||||
return("");
|
||||
}
|
||||
|
||||
std::wstring w_tmp = std::wstring(tmp);
|
||||
std::string serial = std::string(w_tmp.begin(), w_tmp.end());
|
||||
|
||||
return serial;
|
||||
}
|
||||
|
||||
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;
|
||||
|
||||
SendUpdate();
|
||||
SendBrightness();
|
||||
}
|
||||
}
|
||||
|
||||
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 = 178;
|
||||
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[map_size];
|
||||
|
||||
memset(key_buf, 0, map_size);
|
||||
|
||||
for(size_t led_index = 0; led_index < colors.size(); led_index++)
|
||||
{
|
||||
uint16_t offset = 3 * packet_map[led_index];
|
||||
|
||||
key_buf[offset] = RGBGetRValue(colors[led_index]);
|
||||
key_buf[offset + 1] = RGBGetGValue(colors[led_index]);
|
||||
key_buf[offset + 2] = RGBGetBValue(colors[led_index]);
|
||||
}
|
||||
|
||||
for(size_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;
|
||||
}
|
||||
|
||||
buffer[06] = i;
|
||||
memcpy(&buffer[ASUSAURACORELAPTOP_DATA_BYTE], &key_buf[3 * i], (3 * buffer[07]));
|
||||
|
||||
hid_send_feature_report(dev, buffer, ASUSAURACORELAPTOP_WRITE_PACKET_SIZE);
|
||||
}
|
||||
|
||||
buffer[4] = 0x04;
|
||||
buffer[5] = 0x00;
|
||||
buffer[6] = 0x00;
|
||||
buffer[7] = 0x00;
|
||||
memcpy(&buffer[ASUSAURACORELAPTOP_DATA_BYTE], &key_buf[3 * key_set], (3 * (led_count - key_set)));
|
||||
|
||||
hid_send_feature_report(dev, buffer, ASUSAURACORELAPTOP_WRITE_PACKET_SIZE);
|
||||
}
|
||||
|
||||
void AsusAuraCoreLaptopController::SendBrightness()
|
||||
{
|
||||
const uint8_t index = 2;
|
||||
uint8_t buffer[ASUSAURACORELAPTOP_WRITE_PACKET_SIZE] = { ASUSAURACORELAPTOP_REPORT_ID, ASUSAURACORELAPTOP_CMD_BRIGHTNESS };
|
||||
|
||||
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();
|
||||
}
|
||||
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", device_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[] =
|
||||
{
|
||||
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", device_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;
|
||||
}
|
||||
|
|
@ -0,0 +1,135 @@
|
|||
/*---------------------------------------------------------------------*\
|
||||
| AsusAuraCoreLaptopController.h |
|
||||
| |
|
||||
| Driver for AsusAuraCoreLaptop USB Controller |
|
||||
| |
|
||||
| Chris M (Dr_No) 28 Jul 2022 |
|
||||
| |
|
||||
\*---------------------------------------------------------------------*/
|
||||
|
||||
#include <string>
|
||||
#include <vector>
|
||||
#include <hidapi/hidapi.h>
|
||||
#include "LogManager.h"
|
||||
#include "RGBController.h"
|
||||
#include "ResourceManager.h"
|
||||
#include "SettingsManager.h"
|
||||
#include "RGBControllerKeyNames.h"
|
||||
|
||||
#pragma once
|
||||
|
||||
#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 255
|
||||
|
||||
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,
|
||||
};
|
||||
|
||||
enum
|
||||
{
|
||||
ASUSAURACORELAPTOP_SPEED_SLOWEST = 0xE1, // Slowest speed
|
||||
ASUSAURACORELAPTOP_SPEED_NORMAL = 0xEB, // Normal speed
|
||||
ASUSAURACORELAPTOP_SPEED_FASTEST = 0xF5, // Fastest speed
|
||||
};
|
||||
|
||||
struct p_state
|
||||
{
|
||||
std::string zone;
|
||||
bool state;
|
||||
};
|
||||
|
||||
class AsusAuraCoreLaptopController
|
||||
{
|
||||
public:
|
||||
AsusAuraCoreLaptopController(hid_device* dev_handle, const char* path);
|
||||
~AsusAuraCoreLaptopController();
|
||||
|
||||
std::string GetDeviceName();
|
||||
std::string GetSerial();
|
||||
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);
|
||||
private:
|
||||
std::string device_name;
|
||||
std::string location;
|
||||
hid_device* dev;
|
||||
|
||||
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();
|
||||
};
|
||||
|
|
@ -0,0 +1,496 @@
|
|||
/*---------------------------------------------------------------------*\
|
||||
| RGBController_AsusAuraCoreLaptop.cpp |
|
||||
| |
|
||||
| Driver for AsusAuraCoreLaptop USB Controller |
|
||||
| |
|
||||
| Chris M (Dr_No) 28 Jul 2022 |
|
||||
| |
|
||||
\*---------------------------------------------------------------------*/
|
||||
|
||||
#include "RGBController_AsusAuraCoreLaptop.h"
|
||||
|
||||
static unsigned int matrix_map[ASUSAURACORELAPTOP_KEY_HEIGHT][ASUSAURACORELAPTOP_KEY_WIDTH] =
|
||||
{
|
||||
{ NA, NA, 86, 87, 88, 89, 90, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA },
|
||||
{ 0, NA, 1, 2, 3, 4, NA, 5, 6, 7, 8, NA, 9, 10, 11, 12, 13, NA },
|
||||
{ 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, NA },
|
||||
{ 31, NA, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, NA, 45, NA },
|
||||
{ 46, NA, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, NA, 58, NA, 59, NA },
|
||||
{ 60, NA, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, NA, 72, NA, 73, NA },
|
||||
{ 74, 75, 76, 77, NA, NA, NA, 78, NA, NA, NA, 79, 80, 81, 82, 83, 84, 85 }
|
||||
};
|
||||
|
||||
static const char *led_names[] =
|
||||
{
|
||||
KEY_EN_ESCAPE, //00
|
||||
KEY_EN_F1,
|
||||
KEY_EN_F2,
|
||||
KEY_EN_F3,
|
||||
KEY_EN_F4,
|
||||
KEY_EN_F5,
|
||||
KEY_EN_F6,
|
||||
KEY_EN_F7,
|
||||
KEY_EN_F8,
|
||||
KEY_EN_F9,
|
||||
KEY_EN_F10, //10
|
||||
KEY_EN_F11,
|
||||
KEY_EN_F12,
|
||||
KEY_EN_DELETE,
|
||||
|
||||
KEY_EN_BACK_TICK,
|
||||
KEY_EN_1,
|
||||
KEY_EN_2,
|
||||
KEY_EN_3,
|
||||
KEY_EN_4,
|
||||
KEY_EN_5,
|
||||
KEY_EN_6, //20
|
||||
KEY_EN_7,
|
||||
KEY_EN_8,
|
||||
KEY_EN_9,
|
||||
KEY_EN_0,
|
||||
KEY_EN_MINUS,
|
||||
KEY_EN_EQUALS,
|
||||
KEY_EN_BACKSPACE,
|
||||
KEY_EN_BACKSPACE,
|
||||
KEY_EN_BACKSPACE,
|
||||
KEY_EN_MEDIA_PLAY_PAUSE, //30
|
||||
|
||||
KEY_EN_TAB,
|
||||
KEY_EN_Q,
|
||||
KEY_EN_W,
|
||||
KEY_EN_E,
|
||||
KEY_EN_R,
|
||||
KEY_EN_T,
|
||||
KEY_EN_Y,
|
||||
KEY_EN_U,
|
||||
KEY_EN_I,
|
||||
KEY_EN_O, //40
|
||||
KEY_EN_P,
|
||||
KEY_EN_LEFT_BRACKET,
|
||||
KEY_EN_RIGHT_BRACKET,
|
||||
KEY_EN_ANSI_BACK_SLASH,
|
||||
KEY_EN_MEDIA_STOP,
|
||||
|
||||
KEY_EN_CAPS_LOCK,
|
||||
KEY_EN_A,
|
||||
KEY_EN_S,
|
||||
KEY_EN_D,
|
||||
KEY_EN_F, //50
|
||||
KEY_EN_G,
|
||||
KEY_EN_H,
|
||||
KEY_EN_J,
|
||||
KEY_EN_K,
|
||||
KEY_EN_L,
|
||||
KEY_EN_SEMICOLON,
|
||||
KEY_EN_QUOTE,
|
||||
KEY_EN_ANSI_ENTER,
|
||||
KEY_EN_MEDIA_PREVIOUS,
|
||||
|
||||
KEY_EN_LEFT_SHIFT, //60
|
||||
KEY_EN_Z,
|
||||
KEY_EN_X,
|
||||
KEY_EN_C,
|
||||
KEY_EN_V,
|
||||
KEY_EN_B,
|
||||
KEY_EN_N,
|
||||
KEY_EN_M,
|
||||
KEY_EN_COMMA,
|
||||
KEY_EN_PERIOD,
|
||||
KEY_EN_FORWARD_SLASH, //70
|
||||
KEY_EN_RIGHT_SHIFT,
|
||||
KEY_EN_UP_ARROW,
|
||||
KEY_EN_MEDIA_NEXT,
|
||||
|
||||
KEY_EN_LEFT_CONTROL,
|
||||
KEY_EN_LEFT_FUNCTION,
|
||||
KEY_EN_LEFT_WINDOWS,
|
||||
KEY_EN_LEFT_ALT,
|
||||
KEY_EN_SPACE,
|
||||
KEY_EN_RIGHT_ALT,
|
||||
KEY_EN_RIGHT_CONTROL, //80
|
||||
KEY_EN_LEFT_ARROW,
|
||||
KEY_EN_DOWN_ARROW,
|
||||
KEY_EN_RIGHT_ARROW,
|
||||
KEY_EN_PRINT_SCREEN,
|
||||
"Asus Keystone",
|
||||
|
||||
KEY_EN_MEDIA_VOLUME_DOWN,
|
||||
KEY_EN_MEDIA_VOLUME_UP,
|
||||
"Key: Mic On/Off",
|
||||
"Key: HyperFan",
|
||||
"Key: Armoury Crate", //90
|
||||
|
||||
"Lightbar LED 1",
|
||||
"Lightbar LED 2",
|
||||
"Lightbar LED 3",
|
||||
"Lightbar LED 4",
|
||||
"Lightbar LED 5",
|
||||
"Lightbar LED 6",
|
||||
|
||||
"Logo",
|
||||
"Lid Left",
|
||||
"Lid Right", //99
|
||||
};
|
||||
|
||||
/**------------------------------------------------------------------*\
|
||||
@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
|
||||
\*-------------------------------------------------------------------*/
|
||||
|
||||
RGBController_AsusAuraCoreLaptop::RGBController_AsusAuraCoreLaptop(AsusAuraCoreLaptopController *controller_ptr)
|
||||
{
|
||||
controller = controller_ptr;
|
||||
|
||||
name = "Asus Aura Core Laptop";
|
||||
vendor = "Asus";
|
||||
type = DEVICE_TYPE_KEYBOARD;
|
||||
description = controller->GetDeviceName();
|
||||
serial = controller->GetSerial();
|
||||
location = controller->GetLocation();
|
||||
|
||||
mode Direct;
|
||||
Direct.name = "Direct";
|
||||
Direct.value = ASUSAURACORELAPTOP_MODE_DIRECT;
|
||||
Direct.flags = MODE_FLAG_HAS_PER_LED_COLOR;
|
||||
Direct.color_mode = MODE_COLORS_PER_LED;
|
||||
modes.push_back(Direct);
|
||||
|
||||
mode Static;
|
||||
Static.name = "Static";
|
||||
Static.value = 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);
|
||||
|
||||
Init_Controller();
|
||||
SetupZones();
|
||||
}
|
||||
|
||||
RGBController_AsusAuraCoreLaptop::~RGBController_AsusAuraCoreLaptop()
|
||||
{
|
||||
delete controller;
|
||||
}
|
||||
|
||||
void RGBController_AsusAuraCoreLaptop::Init_Controller()
|
||||
{
|
||||
/*-------------------------------------------------*\
|
||||
| Create the keyboard zone and add the matix map |
|
||||
\*-------------------------------------------------*/
|
||||
zone KB_zone;
|
||||
KB_zone.name = "Keyboard Zone";
|
||||
KB_zone.type = ZONE_TYPE_MATRIX;
|
||||
KB_zone.leds_min = ASUSAURACORELAPTOP_KEYCOUNT;
|
||||
KB_zone.leds_max = ASUSAURACORELAPTOP_KEYCOUNT;
|
||||
KB_zone.leds_count = ASUSAURACORELAPTOP_KEYCOUNT;
|
||||
|
||||
KB_zone.matrix_map = new matrix_map_type;
|
||||
KB_zone.matrix_map->height = ASUSAURACORELAPTOP_KEY_HEIGHT;
|
||||
KB_zone.matrix_map->width = ASUSAURACORELAPTOP_KEY_WIDTH;
|
||||
KB_zone.matrix_map->map = (unsigned int *)&matrix_map;
|
||||
zones.push_back(KB_zone);
|
||||
|
||||
zone lightbar;
|
||||
lightbar.name = "Lightbar Zone";
|
||||
lightbar.type = ZONE_TYPE_LINEAR;
|
||||
lightbar.leds_min = ASUSAURACORELAPTOP_LIGHTBARCOUNT;
|
||||
lightbar.leds_max = ASUSAURACORELAPTOP_LIGHTBARCOUNT;
|
||||
lightbar.leds_count = ASUSAURACORELAPTOP_LIGHTBARCOUNT;
|
||||
zones.push_back(lightbar);
|
||||
|
||||
zone lid;
|
||||
lid.name = "Lid Zone";
|
||||
lid.type = ZONE_TYPE_LINEAR;
|
||||
lid.leds_min = ASUSAURACORELAPTOP_LIDCOUNT;
|
||||
lid.leds_max = ASUSAURACORELAPTOP_LIDCOUNT;
|
||||
lid.leds_count = ASUSAURACORELAPTOP_LIDCOUNT;
|
||||
zones.push_back(lid);
|
||||
}
|
||||
|
||||
void RGBController_AsusAuraCoreLaptop::SetupZones()
|
||||
{
|
||||
/*-------------------------------------------------*\
|
||||
| Clear any existing color/LED configuration |
|
||||
\*-------------------------------------------------*/
|
||||
leds.clear();
|
||||
colors.clear();
|
||||
|
||||
/*---------------------------------------------------------*\
|
||||
| Set up zones |
|
||||
\*---------------------------------------------------------*/
|
||||
for(std::size_t zone_index = 0; zone_index < zones.size(); zone_index++)
|
||||
{
|
||||
int zone_offset = leds.size();
|
||||
|
||||
for(unsigned int led_index = 0; led_index < zones[zone_index].leds_count; led_index++)
|
||||
{
|
||||
led new_led;
|
||||
new_led.value = led_index + zone_offset;
|
||||
new_led.name = led_names[new_led.value];
|
||||
leds.push_back(new_led);
|
||||
}
|
||||
}
|
||||
|
||||
SetupColors();
|
||||
}
|
||||
|
||||
void RGBController_AsusAuraCoreLaptop::ResizeZone(int /*zone*/, int /*new_size*/)
|
||||
{
|
||||
/*---------------------------------------------------------*\
|
||||
| This device does not support resizing zones |
|
||||
\*---------------------------------------------------------*/
|
||||
}
|
||||
|
||||
void RGBController_AsusAuraCoreLaptop::DeviceUpdateLEDs()
|
||||
{
|
||||
controller->SetLedsDirect(colors);
|
||||
}
|
||||
|
||||
void RGBController_AsusAuraCoreLaptop::UpdateZoneLEDs(int zone)
|
||||
{
|
||||
std::vector<RGBColor> colour;
|
||||
for(size_t i = 0; i < zones[zone].leds_count; i++)
|
||||
{
|
||||
colour.push_back(zones[zone].colors[i]);
|
||||
}
|
||||
|
||||
controller->SetLedsDirect(colour);
|
||||
}
|
||||
|
||||
void RGBController_AsusAuraCoreLaptop::UpdateSingleLED(int led)
|
||||
{
|
||||
std::vector<RGBColor> colour;
|
||||
colour.push_back(colors[led]);
|
||||
|
||||
controller->SetLedsDirect(colour);
|
||||
}
|
||||
|
||||
void RGBController_AsusAuraCoreLaptop::SetCustomMode()
|
||||
{
|
||||
active_mode = 0;
|
||||
}
|
||||
|
||||
void RGBController_AsusAuraCoreLaptop::DeviceUpdateMode()
|
||||
{
|
||||
mode set_mode = modes[active_mode];
|
||||
|
||||
if(set_mode.value == ASUSAURACORELAPTOP_MODE_DIRECT)
|
||||
{
|
||||
return;
|
||||
}
|
||||
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 );
|
||||
}
|
||||
|
|
@ -0,0 +1,36 @@
|
|||
/*---------------------------------------------------------------------*\
|
||||
| RGBController_AsusAuraCoreLaptop.h |
|
||||
| |
|
||||
| Driver for AsusAuraCoreLaptop USB Controller |
|
||||
| |
|
||||
| Chris M (Dr_No) 28 Jul 2022 |
|
||||
| |
|
||||
\*---------------------------------------------------------------------*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#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 SetCustomMode();
|
||||
void DeviceUpdateMode();
|
||||
|
||||
private:
|
||||
void Init_Controller();
|
||||
|
||||
AsusAuraCoreLaptopController* controller;
|
||||
};
|
||||
|
|
@ -255,7 +255,9 @@ HEADERS +=
|
|||
Controllers/ASRockSMBusController/ASRockPolychromeV2SMBusController.h \
|
||||
Controllers/ASRockSMBusController/RGBController_ASRockPolychromeV2SMBus.h \
|
||||
Controllers/AsusAuraCoreController/AsusAuraCoreController.h \
|
||||
Controllers/AsusAuraCoreController/AsusAuraCoreLaptopController.h \
|
||||
Controllers/AsusAuraCoreController/RGBController_AsusAuraCore.h \
|
||||
Controllers/AsusAuraCoreController/RGBController_AsusAuraCoreLaptop.h \
|
||||
Controllers/AsusAuraGPUController/AsusAuraGPUController.h \
|
||||
Controllers/AsusAuraGPUController/RGBController_AsusAuraGPU.h \
|
||||
Controllers/AsusAuraUSBController/AsusAuraUSBController.h \
|
||||
|
|
@ -727,7 +729,9 @@ SOURCES +=
|
|||
Controllers/ASRockSMBusController/RGBController_ASRockPolychromeV2SMBus.cpp \
|
||||
Controllers/AsusAuraCoreController/AsusAuraCoreController.cpp \
|
||||
Controllers/AsusAuraCoreController/AsusAuraCoreControllerDetect.cpp \
|
||||
Controllers/AsusAuraCoreController/AsusAuraCoreLaptopController.cpp \
|
||||
Controllers/AsusAuraCoreController/RGBController_AsusAuraCore.cpp \
|
||||
Controllers/AsusAuraCoreController/RGBController_AsusAuraCoreLaptop.cpp \
|
||||
Controllers/AsusAuraGPUController/AsusAuraGPUController.cpp \
|
||||
Controllers/AsusAuraGPUController/AsusAuraGPUControllerDetect.cpp \
|
||||
Controllers/AsusAuraGPUController/RGBController_AsusAuraGPU.cpp \
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue