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

Initial support for ASUS ROG Balteus mousemat (direct mode only for now)

Browse source
This commit is contained in:
Adam Honse 2022-01-10 20:24:12 -06:00
parent c5364264b1
commit be3846cf8b
6 changed files with 402 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

130
Controllers/AsusAuraUSBController/AsusAuraMousematController.cpp Normal file
View file

@ -0,0 +1,130 @@
/*-----------------------------------------*\
| AsusAuraMousematController.cpp |
| |
| Driver for ASUS Aura RGB USB |
| lighting controller |
| |
| Adam Honse (CalcProgrammer1) 1/10/2022 |
\*-----------------------------------------*/
#include "AsusAuraMousematController.h"
#include <cstring>
AuraMousematController::AuraMousematController(hid_device* dev_handle, const char* path)
{
dev = dev_handle;
location = path;
}
AuraMousematController::~AuraMousematController()
{
hid_close(dev);
}
std::string AuraMousematController::GetDeviceLocation()
{
return("HID: " + location);
}
std::string AuraMousematController::GetSerialString()
{
wchar_t serial_string[128];
int ret = hid_get_serial_number_string(dev, serial_string, 128);
if(ret != 0)
{
return("");
}
std::wstring return_wstring = serial_string;
std::string return_string(return_wstring.begin(), return_wstring.end());
return(return_string);
}
std::string AuraMousematController::GetVersion()
{
unsigned char usb_buf[65];
memset(usb_buf, 0x00, sizeof(usb_buf));
usb_buf[0x00] = 0xEE;
usb_buf[0x01] = 0x12;
usb_buf[0x02] = 0x00;
hid_write(dev, usb_buf, 65);
unsigned char usb_buf_out[65];
hid_read(dev, usb_buf_out, 65);
char version[5];
snprintf(version, 5, "%04X", (usb_buf_out[6] << 8) | usb_buf_out[7]);
return std::string(version);
}
void AuraMousematController::UpdateLeds
(
std::vector<RGBColor> colors
)
{
unsigned char usb_buf[65];
memset(usb_buf, 0x00, sizeof(usb_buf));
usb_buf[0x00] = 0xEE;
usb_buf[0x01] = 0xC0;
usb_buf[0x02] = 0x81;
usb_buf[0x03] = 0x00;
usb_buf[0x04] = 0x00;
for(unsigned int i = 0; i < 60; i += 4)
{
usb_buf[5 + i] = 0x00;
usb_buf[6 + i] = RGBGetRValue(colors[i / 4]);
usb_buf[7 + i] = RGBGetGValue(colors[i / 4]);
usb_buf[8 + i] = RGBGetBValue(colors[i / 4]);
}
hid_write(dev, usb_buf, 65);
}
void AuraMousematController::UpdateDevice
(
unsigned char mode,
unsigned char red,
unsigned char grn,
unsigned char blu,
unsigned char speed,
unsigned char brightness
)
{
unsigned char usb_buf[65];
memset(usb_buf, 0x00, sizeof(usb_buf));
usb_buf[0x00] = 0xEE;
usb_buf[0x01] = 0x51;
usb_buf[0x02] = 0x28;
usb_buf[0x03] = 0x00;
usb_buf[0x04] = 0x00;
usb_buf[0x05] = mode;
usb_buf[0x06] = speed;
usb_buf[0x07] = brightness;
usb_buf[0x08] = 0x00;
usb_buf[0x09] = 0x00;
usb_buf[0x0a] = red;
usb_buf[0x0b] = grn;
usb_buf[0x0c] = blu;
hid_write(dev, usb_buf, 65);
}
void AuraMousematController::SaveMode()
{
unsigned char usb_save_buf[65];
memset(usb_save_buf, 0x00, sizeof(usb_save_buf));
usb_save_buf[0x00] = 0xEE;
usb_save_buf[0x01] = 0x50;
usb_save_buf[0x02] = 0x55;
hid_write(dev, usb_save_buf, 65);
}

53
Controllers/AsusAuraUSBController/AsusAuraMousematController.h Normal file
View file

@ -0,0 +1,53 @@
/*-----------------------------------------*\
| AsusAuraMousematController.h |
| |
| Definitions and types for ASUS Aura |
| USB RGB lighting controller |
| |
| Adam Honse (CalcProgrammer1) 1/10/2022 |
\*-----------------------------------------*/
#include "RGBController.h"
#include <hidapi/hidapi.h>
#pragma once
enum
{
AURA_MOUSEMAT_MODE_DIRECT = 0,
AURA_MOUSEMAT_MODE_BREATHING = 1,
AURA_MOUSEMAT_MODE_CHASING = 3,
};
class AuraMousematController
{
public:
AuraMousematController(hid_device* dev_handle, const char* path);
virtual ~AuraMousematController();
std::string GetDeviceLocation();
std::string GetSerialString();
std::string GetVersion();
void UpdateLeds
(
std::vector<RGBColor> colors
);
void UpdateDevice
(
unsigned char mode,
unsigned char red,
unsigned char grn,
unsigned char blu,
unsigned char speed,
unsigned char brightness
);
void SaveMode();
private:
hid_device* dev;
std::string location;
};

24
Controllers/AsusAuraUSBController/AsusAuraUSBControllerDetect.cpp
View file

@ -5,6 +5,7 @@
#include "AsusAuraTUFKeyboardController.h"
#include "AsusAuraMainboardController.h"
#include "AsusAuraMouseController.h"
#include "AsusAuraMousematController.h"
#include "AsusAuraStrixEvolveController.h"
#include "RGBController.h"
#include "RGBController_AsusAuraUSB.h"
@ -12,6 +13,7 @@
#include "RGBController_AsusAuraKeyboard.h"
#include "RGBController_AsusAuraTUFKeyboard.h"
#include "RGBController_AsusAuraMouse.h"
#include "RGBController_AsusAuraMousemat.h"
#include "RGBController_AsusAuraStrixEvolve.h"
#include <stdexcept>
#include <hidapi/hidapi.h>
@ -48,6 +50,11 @@
#define AURA_ROG_STRIX_EVOLVE_PID 0x185B
/*-----------------------------------------------------------------*\
| MOUSEMATS |
\*-----------------------------------------------------------------*/
#define AURA_ROG_BALTEUS_PID 0x1891
/*-----------------------------------------------------------------*\
| OTHER |
\*-----------------------------------------------------------------*/
@ -154,6 +161,18 @@ void DetectAsusAuraUSBMice(hid_device_info* info, const std::string& name)
}
}
void DetectAsusAuraUSBMousemats(hid_device_info* info, const std::string& name)
{
hid_device* dev = hid_open_path(info->path);
if(dev)
{
AuraMousematController* controller = new AuraMousematController(dev, info->path);
RGBController_AuraMousemat* rgb_controller = new RGBController_AuraMousemat(controller);
rgb_controller->name = name;
ResourceManager::get()->RegisterRGBController(rgb_controller);
}
}
void DetectAsusAuraUSBStrixEvolve(hid_device_info* info, const std::string& name)
{
hid_device* dev = hid_open_path(info->path);
@ -235,6 +254,11 @@ REGISTER_HID_DETECTOR_IP("ASUS TUF Gaming M5", DetectAsusAuraUS
REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Evolve", DetectAsusAuraUSBStrixEvolve, AURA_USB_VID, AURA_ROG_STRIX_EVOLVE_PID, 1, 0x0008);
/*-----------------------------------------------------------------*\
| MOUSEMATS |
\*-----------------------------------------------------------------*/
REGISTER_HID_DETECTOR ("ASUS ROG Balteus", DetectAsusAuraUSBMousemats, AURA_USB_VID, AURA_ROG_BALTEUS_PID );
/*-----------------------------------------------------------------*\
| OTHER |
\*-----------------------------------------------------------------*/

147
Controllers/AsusAuraUSBController/RGBController_AsusAuraMousemat.cpp Normal file
View file

@ -0,0 +1,147 @@
/*-----------------------------------------*\
| RGBController_AsusAuraMousemat.cpp |
| |
| Generic RGB Interface for Asus Aura |
| USB controller driver |
| |
| Adam Honse (CalcProgrammer1) 1/10/2022 |
\*-----------------------------------------*/
#include "RGBController_AsusAuraMousemat.h"
RGBController_AuraMousemat::RGBController_AuraMousemat(AuraMousematController* controller_ptr)
{
controller = controller_ptr;
name = "ASUS Aura Mousemat";
vendor = "ASUS";
type = DEVICE_TYPE_MOUSEMAT;
description = "ASUS Aura Mousemat Device";
version = controller->GetVersion();
location = controller->GetDeviceLocation();
serial = controller->GetSerialString();
mode Direct;
Direct.name = "Direct";
Direct.value = AURA_MOUSEMAT_MODE_DIRECT;
Direct.flags = MODE_FLAG_HAS_PER_LED_COLOR;
Direct.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Direct);
// mode Breathing;
// Breathing.name = "Breathing";
// Breathing.value = AURA_MOUSEMAT_MODE_BREATHING;
// Breathing.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
// Breathing.color_mode = MODE_COLORS_MODE_SPECIFIC;
// Breathing.speed_min = AURA_MOUSEMAT_SPEED_MIN;
// Breathing.speed_max = AURA_MOUSEMAT_SPEED_MAX;
// Breathing.speed = AURA_MOUSEMAT_SPEED_DEFAULT;
// Breathing.brightness_min = AURA_MOUSEMAT_BRIGHTNESS_MIN;
// Breathing.brightness_max = AURA_MOUSEMAT_BRIGHTNESS_MAX;
// Breathing.brightness = AURA_MOUSEMAT_BRIGHTNESS_DEFAULT;
// Breathing.colors_min = 1;
// Breathing.colors_max = 1;
// Breathing.colors.resize(1);
// modes.push_back(Breathing);
// mode Chasing;
// Chasing.name = "Chasing";
// Chasing.value = AURA_MOUSEMAT_MODE_CHASING;
// Chasing.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
// Chasing.color_mode = MODE_COLORS_MODE_SPECIFIC;
// Chasing.speed_min = AURA_MOUSEMAT_SPEED_MIN;
// Chasing.speed_max = AURA_MOUSEMAT_SPEED_MAX;
// Chasing.speed = AURA_MOUSEMAT_SPEED_DEFAULT;
// Chasing.brightness_min = AURA_MOUSEMAT_BRIGHTNESS_MIN;
// Chasing.brightness_max = AURA_MOUSEMAT_BRIGHTNESS_MAX;
// Chasing.brightness = AURA_MOUSEMAT_BRIGHTNESS_DEFAULT;
// Chasing.colors_min = 1;
// Chasing.colors_max = 1;
// Chasing.colors.resize(1);
// modes.push_back(Chasing);
SetupZones();
}
RGBController_AuraMousemat::~RGBController_AuraMousemat()
{
delete controller;
}
void RGBController_AuraMousemat::SetupZones()
{
zone mousemat_zone;
mousemat_zone.name = "Mousemat";
mousemat_zone.type = ZONE_TYPE_LINEAR;
mousemat_zone.leds_min = 15;
mousemat_zone.leds_max = 15;
mousemat_zone.leds_count = 15;
mousemat_zone.matrix_map = NULL;
zones.push_back(mousemat_zone);
for(unsigned int i = 0; i < 15; i++)
{
led mousemat_led;
mousemat_led.name = "Mousemat LED " + std::to_string(i);
leds.push_back(mousemat_led);
}
SetupColors();
}
void RGBController_AuraMousemat::ResizeZone(int /*zone*/, int /*new_size*/)
{
/*---------------------------------------------------------*\
| This device does not support resizing zones |
\*---------------------------------------------------------*/
}
void RGBController_AuraMousemat::DeviceUpdateLEDs()
{
controller->UpdateLeds(std::vector<RGBColor>(colors));
}
void RGBController_AuraMousemat::UpdateZoneLEDs(int /*zone*/)
{
DeviceUpdateLEDs();
}
void RGBController_AuraMousemat::UpdateSingleLED(int /*led*/)
{
DeviceUpdateLEDs();
}
void RGBController_AuraMousemat::SetCustomMode()
{
active_mode = 0;
}
void RGBController_AuraMousemat::DeviceUpdateMode()
{
unsigned char red = 0;
unsigned char grn = 0;
unsigned char blu = 0;
switch(modes[active_mode].value)
{
case AURA_MOUSEMAT_MODE_DIRECT:
controller->UpdateLeds(std::vector<RGBColor>(colors));
break;
case AURA_MOUSEMAT_MODE_BREATHING:
case AURA_MOUSEMAT_MODE_CHASING:
red = RGBGetRValue(modes[active_mode].colors[0]);
grn = RGBGetGValue(modes[active_mode].colors[0]);
blu = RGBGetBValue(modes[active_mode].colors[0]);
controller->UpdateDevice(modes[active_mode].value, red, grn, blu, modes[active_mode].speed, modes[active_mode].brightness);
break;
}
}
void RGBController_AuraMousemat::DeviceSaveMode()
{
DeviceUpdateMode();
controller->SaveMode();
}

44
Controllers/AsusAuraUSBController/RGBController_AsusAuraMousemat.h Normal file
View file

@ -0,0 +1,44 @@
/*-----------------------------------------*\
| RGBController_AsusAuraMousemat.h |
| |
| Generic RGB Interface for Asus Aura |
| USB controller driver |
| |
| Mola19 06/04/2021 |
\*-----------------------------------------*/
#pragma once
#include "RGBController.h"
#include "AsusAuraMousematController.h"
enum
{
AURA_MOUSEMAT_BRIGHTNESS_MIN = 0,
AURA_MOUSEMAT_BRIGHTNESS_MAX = 4,
AURA_MOUSEMAT_BRIGHTNESS_DEFAULT = 4,
AURA_MOUSEMAT_SPEED_MIN = 0,
AURA_MOUSEMAT_SPEED_MAX = 255,
AURA_MOUSEMAT_SPEED_DEFAULT = 127,
};
class RGBController_AuraMousemat : public RGBController
{
public:
RGBController_AuraMousemat(AuraMousematController* controller_ptr);
~RGBController_AuraMousemat();
void SetupZones();
void ResizeZone(int zone, int new_size);
void DeviceUpdateLEDs();
void UpdateZoneLEDs(int zone);
void UpdateSingleLED(int led);
void SetCustomMode();
void DeviceUpdateMode();
void DeviceSaveMode();
private:
AuraMousematController* controller;
};

4
OpenRGB.pro
View file

@ -231,6 +231,7 @@ HEADERS +=
Controllers/AsusAuraUSBController/AsusAuraKeyboardController.h \
Controllers/AsusAuraUSBController/AsusAuraMainboardController.h \
Controllers/AsusAuraUSBController/AsusAuraMouseController.h \
Controllers/AsusAuraUSBController/AsusAuraMousematController.h \
Controllers/AsusAuraUSBController/AsusAuraMouseDevices.h \
Controllers/AsusAuraUSBController/AsusAuraStrixEvolveController.h \
Controllers/AsusAuraUSBController/AsusAuraTUFKeyboardController.h \
@ -238,6 +239,7 @@ HEADERS +=
Controllers/AsusAuraUSBController/RGBController_AsusAuraHeadsetStand.h \
Controllers/AsusAuraUSBController/RGBController_AsusAuraKeyboard.h \
Controllers/AsusAuraUSBController/RGBController_AsusAuraMouse.h \
Controllers/AsusAuraUSBController/RGBController_AsusAuraMousemat.h \
Controllers/AsusAuraUSBController/RGBController_AsusAuraStrixEvolve.h \
Controllers/AsusAuraUSBController/RGBController_AsusAuraTUFKeyboard.h \
Controllers/AsusAuraUSBController/RGBController_AsusAuraUSB.h \
@ -605,12 +607,14 @@ SOURCES +=
Controllers/AsusAuraUSBController/AsusAuraKeyboardController.cpp \
Controllers/AsusAuraUSBController/AsusAuraMainboardController.cpp \
Controllers/AsusAuraUSBController/AsusAuraMouseController.cpp \
Controllers/AsusAuraUSBController/AsusAuraMousematController.cpp \
Controllers/AsusAuraUSBController/AsusAuraStrixEvolveController.cpp \
Controllers/AsusAuraUSBController/AsusAuraTUFKeyboardController.cpp \
Controllers/AsusAuraUSBController/AsusAuraUSBControllerDetect.cpp \
Controllers/AsusAuraUSBController/RGBController_AsusAuraHeadsetStand.cpp \
Controllers/AsusAuraUSBController/RGBController_AsusAuraKeyboard.cpp \
Controllers/AsusAuraUSBController/RGBController_AsusAuraMouse.cpp \
Controllers/AsusAuraUSBController/RGBController_AsusAuraMousemat.cpp \
Controllers/AsusAuraUSBController/RGBController_AsusAuraStrixEvolve.cpp \
Controllers/AsusAuraUSBController/RGBController_AsusAuraTUFKeyboard.cpp \
Controllers/AsusAuraUSBController/RGBController_AsusAuraUSB.cpp \