Jens/LumaOps-Public
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Publish LumaOps source

Browse Source
This commit is contained in:
LumaOps release export
2026-09-03 01:18:36 +02:00
commit 7f1c0e5f71
2363 changed files with 501543 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Controllers/AsusAuraUSBController/AsusROGStrixLCController/AsusROGStrixLCController.cpp
+128
View File
@@ -0,0 +1,128 @@
/*---------------------------------------------------------*\
| AsusROGStrixLCController.cpp |
| |
| Driver for ASUS Aura liquid cooler |
| |
| Chris M (Dr_No) 17 Jan 2022 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include "AsusROGStrixLCController.h"
AsusROGStrixLCController::AsusROGStrixLCController(hid_device* dev_handle, const char* path, std::string dev_name) : AuraUSBController(dev_handle, path, dev_name)
{
/*-----------------------------------------------------*\
| Add addressable devices |
| Manually adding device info for now |
| TODO: Implement config table accurately |
| LC120 - 1F FF 05 05 04 00 00 00 |
\*-----------------------------------------------------*/
device_info.push_back({0x00, 0x00, 4, 0, AuraDeviceType::FIXED});
}
AsusROGStrixLCController::~AsusROGStrixLCController()
{
// Device will close at AuraUSBController destructor
}
std::string AsusROGStrixLCController::GetLocation()
{
return("HID: " + location);
}
void AsusROGStrixLCController::SetMode(unsigned char /*channel*/, unsigned char /*mode*/, unsigned char /*red*/, unsigned char /*grn*/, unsigned char /*blu*/)
{
/*---------------------------------------------------------*\
| This interface is not used in this controller however is |
| required by the abstract class |
\*---------------------------------------------------------*/
}
void AsusROGStrixLCController::SetMode(unsigned char mode, unsigned char speed, unsigned char direction, RGBColor colour)
{
bool needs_update = !( (current_mode == mode) && (ToRGBColor(current_red, current_green, current_blue) == colour) && (current_speed == speed) && (current_direction == direction));
if (needs_update)
{
current_mode = mode;
current_speed = speed;
current_direction = direction;
current_red = RGBGetRValue(colour);
current_green = RGBGetGValue(colour);
current_blue = RGBGetBValue(colour);
SendUpdate();
}
}
void AsusROGStrixLCController::SetChannelLEDs(unsigned char /*channel*/, RGBColor* /*colors*/, unsigned int /*num_colors*/)
{
/*---------------------------------------------------------*\
| This interface is not used in this controller however is |
| required by the abstract class |
\*---------------------------------------------------------*/
}
void AsusROGStrixLCController::SetLedsDirect(RGBColor * led_colours, uint8_t led_count)
{
uint8_t buffer[write_packet_size] = { 0xEC, 0x40, 0x00, 0xFF, led_count };
/*---------------------------------------------------------*\
| Set the colour bytes in the packet |
\*---------------------------------------------------------*/
for(uint8_t index = 0; index < led_count; index++)
{
uint8_t offset = (index * 3) + ROGSTRIXLC_GREEN_BYTE;
buffer[offset + 0] = RGBGetRValue(led_colours[index]);
buffer[offset + 1] = RGBGetGValue(led_colours[index]);
buffer[offset + 2] = RGBGetBValue(led_colours[index]);
}
/*---------------------------------------------------------*\
| These 3 bytes might be timing bytes |
\*---------------------------------------------------------*/
uint8_t offset = led_count * 3 + ROGSTRIXLC_GREEN_BYTE;
buffer[offset + 0] = 0x77;
buffer[offset + 1] = 0x10;
buffer[offset + 2] = 0xF3;
hid_write(dev, buffer, write_packet_size);
}
void AsusROGStrixLCController::GetStatus()
{
uint8_t buffer[write_packet_size] = { 0xEC, 0x01, 0x02 };
hid_write(dev, buffer, write_packet_size);
hid_read_timeout(dev, buffer, read_packet_size, ROGSTRIXLC_CONTROLLER_TIMEOUT);
current_red = buffer[ROGSTRIXLC_RED_BYTE - 1];
current_green = buffer[ROGSTRIXLC_GREEN_BYTE - 1];
current_blue = buffer[ROGSTRIXLC_BLUE_BYTE - 1];
}
void AsusROGStrixLCController::SendUpdate()
{
uint8_t buffer[write_packet_size];
/*-----------------------------------------------------*\
| Zero out buffer |
\*-----------------------------------------------------*/
memset(buffer, 0x00, write_packet_size);
buffer[ROGSTRIXLC_REPORTID_BYTE] = rogstrixlc_reportid;
buffer[ROGSTRIXLC_COMMAND_BYTE] = rogstrixlc_modefx;
buffer[ROGSTRIXLC_ZONE_BYTE] = 0;
buffer[ROGSTRIXLC_MODE_BYTE] = current_mode;
buffer[ROGSTRIXLC_RED_BYTE] = current_red;
buffer[ROGSTRIXLC_GREEN_BYTE] = current_green;
buffer[ROGSTRIXLC_BLUE_BYTE] = current_blue;
buffer[ROGSTRIXLC_DIRECTION_BYTE] = current_direction;
buffer[ROGSTRIXLC_SPEED_BYTE] = current_speed;
hid_write(dev, buffer, write_packet_size);
}
Controllers/AsusAuraUSBController/AsusROGStrixLCController/AsusROGStrixLCController.h
+93
View File
@@ -0,0 +1,93 @@
/*---------------------------------------------------------*\
| AsusROGStrixLCController.h |
| |
| Driver for ASUS Aura liquid cooler |
| |
| Chris M (Dr_No) 17 Jan 2022 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#pragma once
#include <string>
#include <hidapi.h>
#include "RGBController.h"
#include "AsusAuraUSBController.h"
#define ROGSTRIXLC_CONTROLLER_TIMEOUT 250
#define HID_MAX_STR 255
#define ROGSTRIXLC_CONTROLLER_BRIGHTNESS_MIN 0
#define ROGSTRIXLC_CONTROLLER_BRIGHTNESS_MAX 255
enum
{
ROGSTRIXLC_CONTROLLER_MODE_DIRECT = 0xFF, //Direct Led Control - Independently set LEDs in zone
ROGSTRIXLC_CONTROLLER_MODE_STATIC = 0x01, //Static Mode - Set entire zone to a single color.
ROGSTRIXLC_CONTROLLER_MODE_BREATHING = 0x02, //Breathing Mode - Fades between fully off and fully on.
ROGSTRIXLC_CONTROLLER_MODE_FLASHING = 0x03, //Flashing Mode - Abruptly changing between fully off and fully on.
ROGSTRIXLC_CONTROLLER_MODE_SPECTRUM = 0x04, //Spectrum Cycle Mode - Cycles through the color spectrum on all lights on the device
ROGSTRIXLC_CONTROLLER_MODE_RAINBOW = 0x05, //Rainbow Wave Mode - Cycle thru the color spectrum as a wave across all LEDs
ROGSTRIXLC_CONTROLLER_MODE_FLASHANDDASH = 0x0A, //Flash n Dash - Flash twice and then flash in direction
};
enum AsusAuraStrixLC_PacketMap
{
ROGSTRIXLC_REPORTID_BYTE = 0,
ROGSTRIXLC_COMMAND_BYTE = 1,
ROGSTRIXLC_ZONE_BYTE = 2,
ROGSTRIXLC_MODE_BYTE = 3,
ROGSTRIXLC_RED_BYTE = 4,
ROGSTRIXLC_GREEN_BYTE = 5,
ROGSTRIXLC_BLUE_BYTE = 6,
ROGSTRIXLC_DIRECTION_BYTE = 7,
ROGSTRIXLC_SPEED_BYTE = 8,
};
enum
{
ROGSTRIXLC_CONTROLLER_SPEED_SLOWEST = 0x04, // Slowest speed
ROGSTRIXLC_CONTROLLER_SPEED_SLOW = 0x03, // Slower speed
ROGSTRIXLC_CONTROLLER_SPEED_NORMAL = 0x02, // Normal speed
ROGSTRIXLC_CONTROLLER_SPEED_FAST = 0x01, // Fast speed
ROGSTRIXLC_CONTROLLER_SPEED_FASTEST = 0x00, // Fastest speed
};
class AsusROGStrixLCController : public AuraUSBController
{
public:
AsusROGStrixLCController(hid_device* dev_handle, const char* path, std::string dev_name);
~AsusROGStrixLCController();
std::string GetLocation();
void SetChannelLEDs(unsigned char channel, RGBColor *colors, unsigned int num_colors);
void SetLedsDirect(RGBColor * led_colours, uint8_t led_count);
void SetMode(unsigned char channel, unsigned char mode, unsigned char red, unsigned char grn, unsigned char blu);
void SetMode(unsigned char mode, unsigned char speed, unsigned char direction, RGBColor colour);
private:
static const uint8_t read_packet_size = 64;
static const uint8_t write_packet_size = read_packet_size + 1;
static const uint8_t rogstrixlc_modefx = 0x3B;
static const uint8_t rogstrixlc_direct = 0x40;
static const uint8_t rogstrixlc_reportid = 0xEC;
std::string location;
uint8_t zone_index;
uint8_t current_mode;
uint8_t current_speed;
uint8_t current_red;
uint8_t current_green;
uint8_t current_blue;
uint8_t current_direction;
void GetStatus();
void SendUpdate();
void SendEffect(unsigned char channel, unsigned char mode, unsigned char red, unsigned char grn, unsigned char blu);
void SendDirectApply(unsigned char channel);
};
Controllers/AsusAuraUSBController/AsusROGStrixLCController/RGBController_AsusROGStrixLC.cpp
+221
View File
@@ -0,0 +1,221 @@
/*---------------------------------------------------------*\
| RGBController_AsusROGStrixLC.cpp |
| |
| RGBController for ASUS Aura liquid cooler |
| |
| Chris M (Dr_No) 17 Jan 2022 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include "RGBControllerKeyNames.h"
#include "RGBController_AsusROGStrixLC.h"
/**------------------------------------------------------------------*\
@name Asus ROG Strix Liquid Cooler
@category Cooler
@type USB
@save :x:
@direct :white_check_mark:
@effects :white_check_mark:
@detectors DetectAsusAuraUSBROGStrixLC
@comment
\*-------------------------------------------------------------------*/
RGBController_AsusROGStrixLC::RGBController_AsusROGStrixLC(AsusROGStrixLCController *controller_ptr)
{
controller = controller_ptr;
uint8_t speed = ROGSTRIXLC_CONTROLLER_SPEED_NORMAL;
name = controller->GetDeviceName();
vendor = "ASUS";
type = DEVICE_TYPE_COOLER;
description = "ASUS Liquid Cooler including 120mm, 140mm, 240mm, 280mm and 360mm radiators.";
version = KEY_EN_UNUSED;
serial = KEY_EN_UNUSED;
location = controller->GetLocation();
mode Direct;
Direct.name = "Direct";
Direct.value = ROGSTRIXLC_CONTROLLER_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 = ROGSTRIXLC_CONTROLLER_MODE_STATIC;
Static.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
Static.colors_min = 1;
Static.colors_max = 1;
Static.colors.resize(Static.colors_max);
Static.color_mode = MODE_COLORS_MODE_SPECIFIC;
modes.push_back(Static);
mode Breathing;
Breathing.name = "Breathing";
Breathing.value = ROGSTRIXLC_CONTROLLER_MODE_BREATHING;
Breathing.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
Breathing.colors_min = 1;
Breathing.colors_max = 1;
Breathing.colors.resize(Breathing.colors_max);
Breathing.brightness_min = ROGSTRIXLC_CONTROLLER_BRIGHTNESS_MIN;
Breathing.brightness_max = ROGSTRIXLC_CONTROLLER_BRIGHTNESS_MAX;
Breathing.brightness = ROGSTRIXLC_CONTROLLER_BRIGHTNESS_MAX;
Breathing.speed_min = ROGSTRIXLC_CONTROLLER_SPEED_SLOWEST;
Breathing.speed_max = ROGSTRIXLC_CONTROLLER_SPEED_FASTEST;
Breathing.color_mode = MODE_COLORS_MODE_SPECIFIC;
Breathing.speed = speed;
modes.push_back(Breathing);
mode Flashing;
Flashing.name = "Flashing";
Flashing.value = ROGSTRIXLC_CONTROLLER_MODE_FLASHING;
Flashing.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
Flashing.colors_min = 1;
Flashing.colors_max = 1;
Flashing.colors.resize(Flashing.colors_max);
Flashing.brightness_min = ROGSTRIXLC_CONTROLLER_BRIGHTNESS_MIN;
Flashing.brightness_max = ROGSTRIXLC_CONTROLLER_BRIGHTNESS_MAX;
Flashing.brightness = ROGSTRIXLC_CONTROLLER_BRIGHTNESS_MAX;
Flashing.speed_min = ROGSTRIXLC_CONTROLLER_SPEED_SLOWEST;
Flashing.speed_max = ROGSTRIXLC_CONTROLLER_SPEED_FASTEST;
Flashing.color_mode = MODE_COLORS_MODE_SPECIFIC;
Flashing.speed = speed;
modes.push_back(Flashing);
mode Spectrum;
Spectrum.name = "Spectrum";
Spectrum.value = ROGSTRIXLC_CONTROLLER_MODE_SPECTRUM;
Spectrum.flags = MODE_FLAG_HAS_SPEED;
Spectrum.brightness_min = ROGSTRIXLC_CONTROLLER_BRIGHTNESS_MIN;
Spectrum.brightness_max = ROGSTRIXLC_CONTROLLER_BRIGHTNESS_MAX;
Spectrum.brightness = ROGSTRIXLC_CONTROLLER_BRIGHTNESS_MAX;
Spectrum.speed_min = ROGSTRIXLC_CONTROLLER_SPEED_SLOWEST;
Spectrum.speed_max = ROGSTRIXLC_CONTROLLER_SPEED_FASTEST;
Spectrum.color_mode = MODE_COLORS_NONE;
Spectrum.speed = speed;
modes.push_back(Spectrum);
mode Rainbow;
Rainbow.name = "Rainbow";
Rainbow.value = ROGSTRIXLC_CONTROLLER_MODE_RAINBOW;
Rainbow.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
Rainbow.brightness_min = ROGSTRIXLC_CONTROLLER_BRIGHTNESS_MIN;
Rainbow.brightness_max = ROGSTRIXLC_CONTROLLER_BRIGHTNESS_MAX;
Rainbow.brightness = ROGSTRIXLC_CONTROLLER_BRIGHTNESS_MAX;
Rainbow.speed_min = ROGSTRIXLC_CONTROLLER_SPEED_SLOWEST;
Rainbow.speed_max = ROGSTRIXLC_CONTROLLER_SPEED_FASTEST;
Rainbow.color_mode = MODE_COLORS_NONE;
Rainbow.speed = speed;
modes.push_back(Rainbow);
mode FlashAndDash;
FlashAndDash.name = "Flash and Dash";
FlashAndDash.value = ROGSTRIXLC_CONTROLLER_MODE_FLASHANDDASH;
FlashAndDash.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
FlashAndDash.brightness_min = ROGSTRIXLC_CONTROLLER_BRIGHTNESS_MIN;
FlashAndDash.brightness_max = ROGSTRIXLC_CONTROLLER_BRIGHTNESS_MAX;
FlashAndDash.brightness = ROGSTRIXLC_CONTROLLER_BRIGHTNESS_MAX;
FlashAndDash.speed_min = ROGSTRIXLC_CONTROLLER_SPEED_SLOWEST;
FlashAndDash.speed_max = ROGSTRIXLC_CONTROLLER_SPEED_FASTEST;
FlashAndDash.color_mode = MODE_COLORS_NONE;
FlashAndDash.speed = speed;
modes.push_back(FlashAndDash);
SetupZones();
}
RGBController_AsusROGStrixLC::~RGBController_AsusROGStrixLC()
{
delete controller;
}
void RGBController_AsusROGStrixLC::SetupZones()
{
/*-------------------------------------------------*\
| Set up zones |
\*-------------------------------------------------*/
LOG_DEBUG("[%s] - Get channel count: %i", name.c_str(), controller->GetChannelCount());
zones.resize(controller->GetChannelCount());
LOG_DEBUG("[%s] - Creating Zones and LEDs", name.c_str());
for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
{
AuraDeviceInfo device_info = controller->GetAuraDevices()[zone_idx];
LOG_INFO("[%s] %s Zone %i - Header Count %i LED Count %i FX %02X Direct %02X", name.c_str(),
((device_info.device_type == AuraDeviceType::FIXED) ? "Fixed" : "Addressable"),
zone_idx, device_info.num_headers, device_info.num_leds, device_info.effect_channel, device_info.direct_channel);
zones[zone_idx].name = name + " Zone ";
zones[zone_idx].name.append(std::to_string(zone_idx));
zones[zone_idx].type = ZONE_TYPE_LINEAR;
zones[zone_idx].leds_min = device_info.num_leds;
zones[zone_idx].leds_max = device_info.num_leds;
zones[zone_idx].leds_count = device_info.num_leds;
for(unsigned int lp_idx = 0; lp_idx < zones[zone_idx].leds_count; lp_idx++)
{
led new_led;
new_led.name = zones[zone_idx].name;
new_led.name.append(" LED " + std::to_string(lp_idx));
new_led.value = lp_idx;
leds.push_back(new_led);
}
}
LOG_DEBUG("[%s] - Device zones and LEDs set", name.c_str());
SetupColors();
}
void RGBController_AsusROGStrixLC::ResizeZone(int /*zone*/, int /*new_size*/)
{
/*---------------------------------------------------------*\
| This device does not support resizing zones |
\*---------------------------------------------------------*/
}
void RGBController_AsusROGStrixLC::DeviceUpdateLEDs()
{
for(unsigned int zone_idx = 0; zone_idx < zones.size(); zone_idx++)
{
UpdateZoneLEDs(zone_idx);
}
}
void RGBController_AsusROGStrixLC::UpdateZoneLEDs(int zone)
{
controller->SetLedsDirect( zones[zone].colors, zones[zone].leds_count );
}
void RGBController_AsusROGStrixLC::UpdateSingleLED(int led)
{
UpdateZoneLEDs(GetLED_Zone(led));
}
void RGBController_AsusROGStrixLC::DeviceUpdateMode()
{
RGBColor colour = (modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC) ? modes[active_mode].colors[0] : 0;
controller->SetMode( modes[active_mode].value, modes[active_mode].speed, modes[active_mode].direction, colour );
}
int RGBController_AsusROGStrixLC::GetLED_Zone(int led_idx)
{
for(unsigned int zone_idx = 0; zone_idx < zones.size(); zone_idx++)
{
int zone_start = zones[zone_idx].start_idx;
int zone_end = zone_start + zones[zone_idx].leds_count - 1;
if(zone_start <= led_idx && zone_end >= led_idx)
{
return(zone_idx);
}
}
return -1;
}
Controllers/AsusAuraUSBController/AsusROGStrixLCController/RGBController_AsusROGStrixLC.h
+38
View File
@@ -0,0 +1,38 @@
/*---------------------------------------------------------*\
| RGBController_AsusROGStrixLC.h |
| |
| RGBController for ASUS Aura liquid cooler |
| |
| Chris M (Dr_No) 17 Jan 2022 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#pragma once
#include <vector>
#include "LogManager.h"
#include "RGBController.h"
#include "AsusROGStrixLCController.h"
class RGBController_AsusROGStrixLC : public RGBController
{
public:
RGBController_AsusROGStrixLC(AsusROGStrixLCController* controller_ptr);
~RGBController_AsusROGStrixLC();
void SetupZones();
void ResizeZone(int zone, int new_size);
void DeviceUpdateLEDs();
void UpdateZoneLEDs(int zone);
void UpdateSingleLED(int led);
void DeviceUpdateMode();
private:
int GetDeviceMode();
int GetLED_Zone(int led_idx);
AsusROGStrixLCController* controller;
};