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

Migrated Asus Aura Core Laptop controller to the KLM

Browse source 
* Added AsusAuraCoreLaptopDevices to record device metadata.
* Adjusted AsusAuraCoreLaptopDevices to allow KLM layouts per zone
* Modified RGBController_AsusAuraCoreLaptop to use KLM layouts.
* Adjust AsusAuraCoreLaptopController to align with new data model
* Other code changes to accomodate
This commit is contained in:
Chris M 2024-09-04 22:43:44 +10:00 • committed by Adam Honse
parent f115d2cbd9
commit e0cffcfb3a
7 changed files with 666 additions and 283 deletions
Download patch file Download diff file Expand all files Collapse all files

2
Controllers/AsusAuraCoreController/AsusAuraCoreControllerDetect.cpp
View file

@ -19,8 +19,6 @@
#define AURA_CORE_VID 0x0B05
#define AURA_STRIX_SCAR_15_PID 0x19B6
/******************************************************************************************\
* *
* DetectAuraCoreControllers *

195
Controllers/AsusAuraCoreController/AsusAuraCoreLaptopController/AsusAuraCoreLaptopController.cpp
View file

@ -10,45 +10,10 @@
\*---------------------------------------------------------*/
#include "AsusAuraCoreLaptopController.h"
#include "dmiinfo.h"
#include "SettingsManager.h"
#include "StringUtils.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",
@ -67,20 +32,40 @@ static std::string power_states[ASUSAURACORELAPTOP_POWER_STATES] =
AsusAuraCoreLaptopController::AsusAuraCoreLaptopController(hid_device* dev_handle, const char* path)
{
dev = dev_handle;
location = path;
dev = dev_handle;
location = path;
/*---------------------------------------------------------*\
| Get device name from HID manufacturer and product strings |
| The motherboard name will uniquely ID the laptop to |
| determine the metadata of the device. |
\*---------------------------------------------------------*/
wchar_t name_string[HID_MAX_STR];
DMIInfo dmi_info;
std::string dmi_name = dmi_info.getMainboard();
bool not_found = true;
hid_get_manufacturer_string(dev, name_string, HID_MAX_STR);
device_name = StringUtils::wstring_to_string(name_string);
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;
}
}
hid_get_product_string(dev, name_string, HID_MAX_STR);
device_name.append(" ").append(StringUtils::wstring_to_string(name_string));
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();
}
@ -89,9 +74,66 @@ AsusAuraCoreLaptopController::~AsusAuraCoreLaptopController()
hid_close(dev);
}
std::string AsusAuraCoreLaptopController::GetDeviceName()
const aura_core_laptop_device* AsusAuraCoreLaptopController::GetDeviceData()
{
return device_name;
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()
@ -101,6 +143,8 @@ std::string AsusAuraCoreLaptopController::GetSerial()
if(ret != 0)
{
LOG_DEBUG("[%s] Get HID Serial string failed",
aura_core_laptop_device_list[device_index]->dmi_name.c_str());
return("");
}
@ -137,30 +181,30 @@ void AsusAuraCoreLaptopController::SetMode(uint8_t mode, uint8_t speed, uint8_t
}
}
void AsusAuraCoreLaptopController::SetLedsDirect(std::vector<RGBColor> colors)
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;
const uint8_t key_set = 167;
const uint8_t led_count = 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[map_size];
uint8_t* key_buf = new uint8_t[map_size];
memset(key_buf, 0, map_size);
for(size_t led_index = 0; led_index < colors.size(); led_index++)
for(size_t led_index = 0; led_index < led_count; led_index++)
{
uint16_t offset = 3 * packet_map[led_index];
std::size_t buf_idx = (led_index * 3);
key_buf[offset] = RGBGetRValue(colors[led_index]);
key_buf[offset + 1] = RGBGetGValue(colors[led_index]);
key_buf[offset + 2] = RGBGetBValue(colors[led_index]);
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(size_t i = 0; i < key_set; i+=leds_per_packet)
@ -170,11 +214,20 @@ void AsusAuraCoreLaptopController::SetLedsDirect(std::vector<RGBColor> colors)
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] = (uint8_t)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);
}
@ -182,9 +235,25 @@ void AsusAuraCoreLaptopController::SetLedsDirect(std::vector<RGBColor> colors)
buffer[5] = 0x00;
buffer[6] = 0x00;
buffer[7] = 0x00;
memcpy(&buffer[ASUSAURACORELAPTOP_DATA_BYTE], &key_buf[3 * key_set], (3 * (led_count - key_set)));
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()
@ -283,6 +352,8 @@ void AsusAuraCoreLaptopController::SetPowerConfigFromJSON()
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
{
@ -293,7 +364,9 @@ void AsusAuraCoreLaptopController::SetPowerConfigFromJSON()
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"));
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"));
}
}
}
@ -320,7 +393,9 @@ void AsusAuraCoreLaptopController::SetPowerConfigFromJSON()
};
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);
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);
}

56
Controllers/AsusAuraCoreController/AsusAuraCoreLaptopController/AsusAuraCoreLaptopController.h
View file

@ -18,6 +18,7 @@
#include "RGBController.h"
#include "ResourceManager.h"
#include "RGBControllerKeyNames.h"
#include "AsusAuraCoreLaptopDevices.h"
#define NA 0xFFFFFFFF
#define HID_MAX_STR 255
@ -83,6 +84,7 @@ enum
ASUSAURACORELAPTOP_CMD_UPDATE = 0xB3,
ASUSAURACORELAPTOP_CMD_APPLY = 0xB4,
ASUSAURACORELAPTOP_CMD_SET = 0xB5,
ASUSAURACORELAPTOP_CMD_LAYOUT = 0x05,
};
enum
@ -92,6 +94,12 @@ enum
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;
@ -104,33 +112,35 @@ public:
AsusAuraCoreLaptopController(hid_device* dev_handle, const char* path);
~AsusAuraCoreLaptopController();
std::string GetDeviceName();
std::string GetSerial();
std::string GetLocation();
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 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;
hid_device* dev;
uint16_t device_index;
std::string location;
uint8_t current_mode;
uint8_t current_speed;
uint8_t current_direction;
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;
RGBColor current_c1;
RGBColor current_c2;
uint8_t current_brightness;
uint8_t current_random;
void SendApply();
void SendBrightness();
void SendSet();
void SendUpdate();
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();
void SetPowerConfigFromJSON();
void SendPowerConfig(uint32_t flags);
uint32_t PackPowerFlags(bool flags[]);
std::vector<p_state> PowerConfigArray();
};

307
Controllers/AsusAuraCoreController/AsusAuraCoreLaptopController/AsusAuraCoreLaptopDevices.cpp Normal file
View file

@ -0,0 +1,307 @@
#include "AsusAuraCoreLaptopDevices.h"
/*-------------------------------------------------------------------------*\
| Aura Core Key Values |
| NULL values are keys that are handed to the KLM but are removed as |
| a part of customisation. They are included to maintain expected key |
| count is aligned to the value count. |
\*-------------------------------------------------------------------------*/
std::vector<unsigned int> aura_core_laptop_15_values =
{
/* ESC F1 F2 F3 F4 F5 F6 F7 F8 F9 F10 F11 F12 DEL */
21, 23, 24, 25, 26, 28, 29, 30, 31, 33, 34, 35, 36,
/* BKTK 1 2 3 4 5 6 7 8 9 0 - = BSPC PLAY */
42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55,
/* TAB Q W E R T Y U I O P [ ] \ STOP */
63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76,
/* CPLK A S D F G H J K L ; " # ENTR PREV */
84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 98,
/* LSFT ISO\ Z X C V B N M , . / RSFT ARWU NEXT */
105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 119,
/* LCTL LWIN LALT SPC RALT RFNC RMNU RCTL ARWL ARWD ARWR */
126, 128, 129, 131, 135, 136, 136, 137,
};
std::vector<unsigned int> aura_core_laptop_17_values =
{
/* ESC F1 F2 F3 F4 F5 F6 F7 F8 F9 F10 F11 F12 NULL NULL PAUS */
21, 23, 24, 25, 26, 28, 29, 30, 31, 33, 34, 35, 36, 0, 0, 39,
/* BKTK 1 2 3 4 5 6 7 8 9 0 - = BSPC NULL NULL NULL NMLK NMDV NMTM NMMI */
42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 56, 0, 0, 0, 59, 60, 61, 62,
/* TAB Q W E R T Y U I O P [ ] \ NULL NULL NULL NM7 NM8 NM9 NMPL */
63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 0, 0, 0, 80, 81, 82, 83,
/* CPLK A S D F G H J K L ; " # ENTR NM4 NM5 NM6 */
84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 98, 101, 102, 103,
/* LSFT ISO\ Z X C V B N M , . / RSFT ARWU NM1 NM2 NM3 NMER */
105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 119, 139, 122, 123, 124, 125,
/* LCTL LWIN LALT SPC RALT RFNC RMNU RCTL ARWL ARWD ARWR NM0 NMPD */
126, 128, 129, 131, 135, 136, 136, 137, 159, 160, 161, 144, 145,
};
/*-------------------------------------------------------------------------*\
| KEYMAPS |
\*-------------------------------------------------------------------------*/
keyboard_keymap_overlay_values g533zm_layout
{
KEYBOARD_SIZE_SEVENTY_FIVE,
{
aura_core_laptop_15_values,
{
/* Add more regional layout fixes here */
}
},
{
/*---------------------------------------------------------------------------------------------------------*\
| Edit Keys |
| Zone, Row, Column, Value, Key, OpCode, |
\*---------------------------------------------------------------------------------------------------------*/
{ 0, 0, 15, 37, KEY_EN_DELETE, KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, }, // Insert Delete
{ 0, 1, 15, 58, KEY_EN_MEDIA_PLAY_PAUSE, KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, }, // Insert Play / Pause
{ 0, 2, 15, 79, KEY_EN_MEDIA_STOP, KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, }, // Insert Play / Pause
{ 0, 3, 15, 100, KEY_EN_MEDIA_PREVIOUS, KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, }, // Insert Play / Pause
{ 0, 4, 13, 139, KEY_EN_UP_ARROW, KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, }, // Insert Up Arrow
{ 0, 4, 15, 121, KEY_EN_MEDIA_NEXT, KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, }, // Insert Play / Pause
{ 0, 5, 12, 159, KEY_EN_LEFT_ARROW, KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, }, // Insert Left Arrow
{ 0, 5, 13, 160, KEY_EN_DOWN_ARROW, KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, }, // Insert Down Arrow
{ 0, 5, 14, 161, KEY_EN_RIGHT_ARROW, KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, }, // Insert Right Arrow
}
};
keyboard_keymap_overlay_values g713rw_keyboard_layout
{
KEYBOARD_SIZE_FULL,
{
aura_core_laptop_17_values,
{
/* Add more regional layout fixes here */
}
},
{
/*---------------------------------------------------------------------------------------------------------*\
| Edit Keys |
| Zone, Row, Column, Value, Key, OpCode, |
\*---------------------------------------------------------------------------------------------------------*/
{ 0, 0, 2, 2, KEY_EN_MEDIA_VOLUME_DOWN, KEYBOARD_OPCODE_INSERT_ROW, }, // Insert Row and add Volume Down
{ 0, 0, 3, 3, KEY_EN_MEDIA_VOLUME_UP, KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, }, // Insert Volume Up
{ 0, 0, 4, 4, KEY_EN_MEDIA_MUTE, KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, }, // Insert Mute
{ 0, 0, 5, 5, "Key: Sun", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, }, // Insert "Sun" key
{ 0, 0, 6, 6, "Key: ROG", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, }, // Insert "ROG" key
{ 0, 6, 1, 127, KEY_EN_LEFT_FUNCTION, KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, }, // Insert Left Fuction
{ 0, 6, 12, 136, KEY_EN_RIGHT_FUNCTION, KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT, }, // Remove Right Fuction
{ 0, 6, 12, 136, KEY_EN_RIGHT_WINDOWS, KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT, }, // Remove Right Win Key
{ 0, 1, 14, 0, KEY_EN_UNUSED, KEYBOARD_OPCODE_SWAP_ONLY, },
{ 0, 1, 15, 0, KEY_EN_UNUSED, KEYBOARD_OPCODE_SWAP_ONLY, },
{ 0, 1, 16, 38, KEY_EN_DELETE, KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, }, // Insert a Delete key
{ 0, 1, 18, 40, KEY_EN_PRINT_SCREEN, KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, }, // Insert a Print Screen key
{ 0, 1, 19, 41, KEY_EN_HOME, KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, }, // Insert a Home key
{ 0, 2, 14, 0, KEY_EN_UNUSED, KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT, },
{ 0, 2, 14, 0, KEY_EN_UNUSED, KEYBOARD_OPCODE_SWAP_ONLY, },
{ 0, 2, 15, 0, KEY_EN_UNUSED, KEYBOARD_OPCODE_SWAP_ONLY, },
{ 0, 3, 14, 0, KEY_EN_UNUSED, KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT, },
{ 0, 3, 14, 0, KEY_EN_UNUSED, KEYBOARD_OPCODE_SWAP_ONLY, },
{ 0, 3, 15, 0, KEY_EN_UNUSED, KEYBOARD_OPCODE_SWAP_ONLY, },
{ 0, 4, 16, 0, KEY_EN_UNUSED, KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT, },
{ 0, 5, 14, 0, KEY_EN_UNUSED, KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT, },
{ 0, 6, 16, 0, KEY_EN_UNUSED, KEYBOARD_OPCODE_REMOVE_SHIFT_LEFT, },
}
};
keyboard_keymap_overlay_values g713rw_lightbar_layout
{
KEYBOARD_SIZE_EMPTY,
{
{ /* Values not set in empty keyboard */ },
{
/* Add more regional layout fixes here */
}
},
{
/*---------------------------------------------------------------------------------------------------------*\
| Edit Keys |
| Zone, Row, Column, Value, Key, OpCode, |
\*---------------------------------------------------------------------------------------------------------*/
{ 0, 0, 0, 126, "Lightbar L1", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, }, // Insert Lightbar L1
{ 0, 0, 1, 127, "Lightbar L2", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, }, // Insert Lightbar L2
{ 0, 0, 2, 128, "Lightbar L3", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, }, // Insert Lightbar L3
{ 0, 0, 3, 144, "Lightbar R3", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, }, // Insert Lightbar R3
{ 0, 0, 4, 145, "Lightbar R2", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, }, // Insert Lightbar R2
{ 0, 0, 5, 125, "Lightbar R1", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, }, // Insert Lightbar R1
}
};
keyboard_keymap_overlay_values g713rw_test_layout
{
KEYBOARD_SIZE_EMPTY,
{
{ /* Values not set in empty keyboard */ },
{
/* Add more regional layout fixes here */
}
},
{
/*---------------------------------------------------------------------------------------------------------*\
| Edit Keys |
| Zone, Row, Column, Value, Key, OpCode, |
\*---------------------------------------------------------------------------------------------------------*/
{ 0, 0, 0, 7, "Test01", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 0, 1, 8, "Test02", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 0, 2, 9, "Test03", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 0, 3, 10, "Test04", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 0, 4, 11, "Test05", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 0, 5, 12, "Test06", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 0, 6, 13, "Test07", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 0, 7, 14, "Test08", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 0, 8, 15, "Test09", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 0, 9, 16, "Test10", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 0, 10, 17, "Test11", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 0, 11, 18, "Test12", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 0, 12, 19, "Test13", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 0, 13, 20, "Test14", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 0, 14, 22, "Test15", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 0, 15, 27, "Test16", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 0, 16, 55, "Test17", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 0, 17, 57, "Test18", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 0, 18, 58, "Test19", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 0, 19, 77, "Test20", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 0, 20, 78, "Test21", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 0, 21, 79, "Test22", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 0, 22, 96, "Test23", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 0, 23, 97, "Test24", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 0, 24, 99, "Test25", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 0, 25, 100, "Test26", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 0, 26, 104, "Test27", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 0, 27, 117, "Test28", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 0, 28, 118, "Test29", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 0, 29, 120, "Test30", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 0, 30, 121, "Test31", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 0, 31, 130, "Test32", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 0, 32, 132, "Test33", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 0, 33, 133, "Test34", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 0, 34, 134, "Test35", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 0, 35, 138, "Test36", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 0, 36, 140, "Test37", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 0, 37, 141, "Test38", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 0, 38, 142, "Test39", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 0, 39, 143, "Test40", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 0, 40, 146, "Test41", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 0, 41, 147, "Test42", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 0, 42, 148, "Test43", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 0, 43, 149, "Test44", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 0, 44, 150, "Test45", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 0, 45, 151, "Test46", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 0, 46, 152, "Test47", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 0, 47, 153, "Test48", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 0, 48, 154, "Test49", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 0, 49, 155, "Test50", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 0, 50, 156, "Test51", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 0, 51, 157, "Test52", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 0, 52, 158, "Test53", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 0, 53, 162, "Test54", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 0, 54, 163, "Test55", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 0, 55, 164, "Test56", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 0, 56, 165, "Test57", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 0, 57, 166, "Test58", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
{ 0, 0, 58, 167, "Test59", KEYBOARD_OPCODE_INSERT_SHIFT_RIGHT, },
}
};
keyboard_keymap_overlay_values g733zm_layout
{
KEYBOARD_SIZE_FULL,
{
aura_core_laptop_17_values,
{
/* Add more regional layout fixes here */
}
},
{
/*---------------------------------------------------------------------------------------------------------*\
| Edit Keys |
| Zone, Row, Column, Value, Key, OpCode, |
\*---------------------------------------------------------------------------------------------------------*/
}
};
/*-------------------------------------------------------------------------*\
| AURA CORE LAPTOP DEVICES |
\*-------------------------------------------------------------------------*/
/*-------------------------------------------------------------*\
| ASUS ROG Strix SCAR 15 |
| |
| Zone "Keyboard" |
| Matrix |
| 7 Rows, 16 Columns |
\*-------------------------------------------------------------*/
static const aura_core_laptop_zone g533zm_zone =
{
ZONE_EN_KEYBOARD,
&g533zm_layout
};
static const aura_core_laptop_device g533zm_device =
{
"G533ZM",
{
&g533zm_zone,
nullptr,
nullptr,
nullptr,
nullptr,
nullptr
}
};
/*-------------------------------------------------------------*\
| ASUS ROG Strix SCAR G713RW |
| |
| Zone "Keyboard" |
| Matrix |
| 7 Rows, 20 Columns |
\*-------------------------------------------------------------*/
static const aura_core_laptop_zone g713rw_keyboard_zone =
{
ZONE_EN_KEYBOARD,
&g713rw_keyboard_layout
};
static const aura_core_laptop_zone g713rw_lightbar_zone =
{
"Lightbar",
&g713rw_lightbar_layout
};
static const aura_core_laptop_zone g713rw_test_zone =
{
"TEST",
&g713rw_test_layout
};
static const aura_core_laptop_device g713rw_device =
{
"G713RW",
{
&g713rw_keyboard_zone,
&g713rw_lightbar_zone,
&g713rw_test_zone,
nullptr,
nullptr,
nullptr
}
};
/*-------------------------------------------------------------------------*\
| DEVICE MASTER LIST |
\*-------------------------------------------------------------------------*/
const aura_core_laptop_device* aura_core_laptop_device_list_data[] =
{
/*-----------------------------------------------------------------*\
| KEYBOARDS |
\*-----------------------------------------------------------------*/
&g533zm_device,
&g713rw_device,
};
const unsigned int AURA_CORE_LAPTOP_DEVICE_COUNT = (sizeof(aura_core_laptop_device_list_data) / sizeof(aura_core_laptop_device_list_data[ 0 ]));
const aura_core_laptop_device** aura_core_laptop_device_list = aura_core_laptop_device_list_data;

50
Controllers/AsusAuraCoreController/AsusAuraCoreLaptopController/AsusAuraCoreLaptopDevices.h Normal file
View file

@ -0,0 +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;

333
Controllers/AsusAuraCoreController/AsusAuraCoreLaptopController/RGBController_AsusAuraCoreLaptop.cpp
View file

@ -11,129 +11,6 @@
#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
@ -154,14 +31,15 @@ static const char *led_names[] =
RGBController_AsusAuraCoreLaptop::RGBController_AsusAuraCoreLaptop(AsusAuraCoreLaptopController *controller_ptr)
{
controller = controller_ptr;
controller = controller_ptr;
const aura_core_laptop_device* aura_dev = controller->GetDeviceData();
name = "Asus Aura Core Laptop";
vendor = "Asus";
type = DEVICE_TYPE_KEYBOARD;
description = controller->GetDeviceName();
serial = controller->GetSerial();
location = controller->GetLocation();
name = aura_dev->dmi_name;
vendor = "Asus";
type = DEVICE_TYPE_KEYBOARD;
description = controller->GetDeviceDescription();
serial = controller->GetSerial();
location = controller->GetLocation();
mode Direct;
Direct.name = "Direct";
@ -375,7 +253,6 @@ RGBController_AsusAuraCoreLaptop::RGBController_AsusAuraCoreLaptop(AsusAuraCoreL
Off.color_mode = MODE_COLORS_NONE;
modes.push_back(Off);
Init_Controller();
SetupZones();
}
@ -384,70 +261,131 @@ 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;
lightbar.matrix_map = NULL;
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;
lid.matrix_map = NULL;
zones.push_back(lid);
}
void RGBController_AsusAuraCoreLaptop::SetupZones()
{
/*-------------------------------------------------*\
| Clear any existing color/LED configuration |
\*-------------------------------------------------*/
leds.clear();
colors.clear();
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);
/*---------------------------------------------------------*\
| Set up zones |
| Fill in zones from the device data |
\*---------------------------------------------------------*/
for(std::size_t zone_index = 0; zone_index < zones.size(); zone_index++)
for(size_t i = 0; i < AURA_CORE_LAPTOP_ZONES_MAX; i++)
{
int zone_offset = (int)leds.size();
LOG_DEBUG("[%s] setting up zone %d", description.c_str(), i);
for(unsigned int led_index = 0; led_index < zones[zone_index].leds_count; led_index++)
if(aura_dev->zones[i] == NULL)
{
led new_led;
new_led.value = led_index + zone_offset;
new_led.name = led_names[new_led.value];
leds.push_back(new_led);
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(size_t 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*/)
@ -459,26 +397,29 @@ void RGBController_AsusAuraCoreLaptop::ResizeZone(int /*zone*/, int /*new_size*/
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++)
for(size_t i = 85; i < leds.size(); i++)
{
colour.push_back(zones[zone].colors[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(colour);
controller->SetLedsDirect(buffer_map);
}
void RGBController_AsusAuraCoreLaptop::UpdateSingleLED(int led)
void RGBController_AsusAuraCoreLaptop::UpdateZoneLEDs(int /*zone*/)
{
std::vector<RGBColor> colour;
colour.push_back(colors[led]);
controller->SetLedsDirect(buffer_map);
}
controller->SetLedsDirect(colour);
void RGBController_AsusAuraCoreLaptop::UpdateSingleLED(int /*led*/)
{
controller->SetLedsDirect(buffer_map);
}
void RGBController_AsusAuraCoreLaptop::DeviceUpdateMode()

6
Controllers/AsusAuraCoreController/AsusAuraCoreLaptopController/RGBController_AsusAuraCoreLaptop.h
View file

@ -11,6 +11,7 @@
#pragma once
#include <algorithm>
#include <vector>
#include "RGBController.h"
#include "AsusAuraCoreLaptopController.h"
@ -31,7 +32,8 @@ public:
void DeviceUpdateMode();
private:
void Init_Controller();
RGBColor null_color = 0;
std::vector<RGBColor *> buffer_map;
AsusAuraCoreLaptopController* controller;
AsusAuraCoreLaptopController* controller;
};