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/ThermaltakeRiingController/ThermaltakeRiingController/RGBController_ThermaltakeRiing.cpp
+234
View File
@@ -0,0 +1,234 @@
/*---------------------------------------------------------*\
| RGBController_ThermaltakeRiing.cpp |
| |
| RGBController for Thermaltake Riing |
| |
| Adam Honse (CalcProgrammer1) 09 Feb 2020 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include "RGBController_ThermaltakeRiing.h"
/**------------------------------------------------------------------*\
@name Thermaltake Riing
@category Cooler
@type USB
@save :x:
@direct :white_check_mark:
@effects :white_check_mark:
@detectors DetectThermaltakeRiingControllers
@comment
\*-------------------------------------------------------------------*/
RGBController_ThermaltakeRiing::RGBController_ThermaltakeRiing(ThermaltakeRiingController* controller_ptr)
{
controller = controller_ptr;
name = "Thermaltake Riing";
vendor = "Thermaltake";
type = DEVICE_TYPE_COOLER;
description = "Thermaltake Riing Device";
location = controller->GetDeviceLocation();
serial = controller->GetSerialString();
version = controller->GetFirmwareVersion();
mode Direct;
Direct.name = "Direct";
Direct.value = THERMALTAKE_MODE_PER_LED;
Direct.flags = MODE_FLAG_HAS_PER_LED_COLOR;
Direct.speed_min = 0;
Direct.speed_max = 0;
Direct.speed = 0;
Direct.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Direct);
mode Static;
Static.name = "Static";
Static.value = THERMALTAKE_MODE_FULL;
Static.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
Static.colors_min = 1;
Static.colors_max = 1;
Static.speed_min = 0;
Static.speed_max = 0;
Static.speed = 0;
Static.color_mode = MODE_COLORS_MODE_SPECIFIC;
Static.colors.resize(1);
modes.push_back(Static);
mode Flow;
Flow.name = "Flow";
Flow.value = THERMALTAKE_MODE_FLOW;
Flow.flags = MODE_FLAG_HAS_SPEED;
Flow.speed_min = THERMALTAKE_SPEED_SLOW;
Flow.speed_max = THERMALTAKE_SPEED_EXTREME;
Flow.speed = THERMALTAKE_SPEED_NORMAL;
Flow.color_mode = MODE_COLORS_NONE;
modes.push_back(Flow);
mode Spectrum;
Spectrum.name = "Spectrum";
Spectrum.value = THERMALTAKE_MODE_SPECTRUM;
Spectrum.flags = MODE_FLAG_HAS_SPEED;
Spectrum.speed_min = THERMALTAKE_SPEED_SLOW;
Spectrum.speed_max = THERMALTAKE_SPEED_EXTREME;
Spectrum.speed = THERMALTAKE_SPEED_NORMAL;
Spectrum.color_mode = MODE_COLORS_NONE;
modes.push_back(Spectrum);
mode Ripple;
Ripple.name = "Ripple";
Ripple.value = THERMALTAKE_MODE_RIPPLE;
Ripple.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
Ripple.speed_min = THERMALTAKE_SPEED_SLOW;
Ripple.speed_max = THERMALTAKE_SPEED_EXTREME;
Ripple.speed = THERMALTAKE_SPEED_NORMAL;
Ripple.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Ripple);
mode Blink;
Blink.name = "Blink";
Blink.value = THERMALTAKE_MODE_BLINK;
Blink.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
Blink.speed_min = THERMALTAKE_SPEED_SLOW;
Blink.speed_max = THERMALTAKE_SPEED_EXTREME;
Blink.speed = THERMALTAKE_SPEED_NORMAL;
Blink.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Blink);
mode Pulse;
Pulse.name = "Pulse";
Pulse.value = THERMALTAKE_MODE_PULSE;
Pulse.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
Pulse.speed_min = THERMALTAKE_SPEED_SLOW;
Pulse.speed_max = THERMALTAKE_SPEED_EXTREME;
Pulse.speed = THERMALTAKE_SPEED_NORMAL;
Pulse.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Pulse);
mode Wave;
Wave.name = "Wave";
Wave.value = THERMALTAKE_MODE_WAVE;
Wave.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
Wave.speed_min = THERMALTAKE_SPEED_SLOW;
Wave.speed_max = THERMALTAKE_SPEED_EXTREME;
Wave.speed = THERMALTAKE_SPEED_NORMAL;
Wave.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Wave);
SetupZones();
}
RGBController_ThermaltakeRiing::~RGBController_ThermaltakeRiing()
{
delete controller;
}
void RGBController_ThermaltakeRiing::SetupZones()
{
/*-------------------------------------------------*\
| Only set LED count on the first run |
\*-------------------------------------------------*/
bool first_run = false;
if(zones.size() == 0)
{
first_run = true;
}
/*-------------------------------------------------*\
| Clear any existing color/LED configuration |
\*-------------------------------------------------*/
leds.clear();
colors.clear();
zones.resize(THERMALTAKE_NUM_CHANNELS);
/*-------------------------------------------------*\
| Set zones and leds |
\*-------------------------------------------------*/
for (unsigned int channel_idx = 0; channel_idx < THERMALTAKE_NUM_CHANNELS; channel_idx++)
{
char ch_idx_string[2];
snprintf(ch_idx_string, 2, "%d", channel_idx + 1);
zones[channel_idx].name = "Riing Channel ";
zones[channel_idx].name.append(ch_idx_string);
zones[channel_idx].type = ZONE_TYPE_LINEAR;
/*-------------------------------------------------*\
| The maximum number of colors that would fit in the|
| Riing protocol is 20 |
\*-------------------------------------------------*/
zones[channel_idx].leds_min = 0;
zones[channel_idx].leds_max = 20;
if(first_run)
{
zones[channel_idx].leds_count = 0;
}
zones[channel_idx].matrix_map = NULL;
for (unsigned int led_ch_idx = 0; led_ch_idx < zones[channel_idx].leds_count; led_ch_idx++)
{
char led_idx_string[3];
snprintf(led_idx_string, 3, "%d", led_ch_idx + 1);
led new_led;
new_led.name = "Riing Channel ";
new_led.name.append(ch_idx_string);
new_led.name.append(", LED ");
new_led.name.append(led_idx_string);
leds.push_back(new_led);
leds_channel.push_back(channel_idx);
}
}
SetupColors();
}
void RGBController_ThermaltakeRiing::ResizeZone(int zone, int new_size)
{
if((size_t) zone >= zones.size())
{
return;
}
if(((unsigned int)new_size >= zones[zone].leds_min) && ((unsigned int)new_size <= zones[zone].leds_max))
{
zones[zone].leds_count = new_size;
SetupZones();
}
}
void RGBController_ThermaltakeRiing::DeviceUpdateLEDs()
{
for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
{
controller->SetChannelLEDs((unsigned char)zone_idx, zones[zone_idx].colors, zones[zone_idx].leds_count);
}
}
void RGBController_ThermaltakeRiing::UpdateZoneLEDs(int zone)
{
controller->SetChannelLEDs(zone, zones[zone].colors, zones[zone].leds_count);
}
void RGBController_ThermaltakeRiing::UpdateSingleLED(int led)
{
unsigned int channel = leds_channel[led];
controller->SetChannelLEDs(channel, zones[channel].colors, zones[channel].leds_count);
}
void RGBController_ThermaltakeRiing::DeviceUpdateMode()
{
for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
{
controller->SetMode(modes[active_mode].value, modes[active_mode].speed);
controller->SetChannelLEDs((unsigned char)zone_idx, zones[zone_idx].colors, zones[zone_idx].leds_count);
}
}
Controllers/ThermaltakeRiingController/ThermaltakeRiingController/RGBController_ThermaltakeRiing.h
+36
View File
@@ -0,0 +1,36 @@
/*---------------------------------------------------------*\
| RGBController_ThermaltakeRiing.h |
| |
| RGBController for Thermaltake Riing |
| |
| Adam Honse (CalcProgrammer1) 09 Feb 2020 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#pragma once
#include "RGBController.h"
#include "ThermaltakeRiingController.h"
class RGBController_ThermaltakeRiing : public RGBController
{
public:
RGBController_ThermaltakeRiing(ThermaltakeRiingController* controller_ptr);
~RGBController_ThermaltakeRiing();
void SetupZones();
void ResizeZone(int zone, int new_size);
void DeviceUpdateLEDs();
void UpdateZoneLEDs(int zone);
void UpdateSingleLED(int led);
void DeviceUpdateMode();
private:
ThermaltakeRiingController* controller;
std::vector<unsigned int> leds_channel;
std::vector<unsigned int> zones_channel;
};
Controllers/ThermaltakeRiingController/ThermaltakeRiingController/ThermaltakeRiingController.cpp
+159
View File
@@ -0,0 +1,159 @@
/*---------------------------------------------------------*\
| ThermaltakeRiingController.cpp |
| |
| Driver for Thermaltake Riing |
| |
| Adam Honse (CalcProgrammer1) 07 Feb 2020 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include <cstring>
#include "StringUtils.h"
#include "ThermaltakeRiingController.h"
ThermaltakeRiingController::ThermaltakeRiingController(hid_device* dev_handle, const char* path)
{
dev = dev_handle;
location = path;
SendInit();
}
ThermaltakeRiingController::~ThermaltakeRiingController()
{
hid_close(dev);
}
std::string ThermaltakeRiingController::GetDeviceLocation()
{
return("HID: " + location);
}
std::string ThermaltakeRiingController::GetSerialString()
{
wchar_t serial_string[128];
int ret = hid_get_serial_number_string(dev, serial_string, 128);
if(ret != 0)
{
return("");
}
return(StringUtils::wstring_to_string(serial_string));
}
std::string ThermaltakeRiingController::GetFirmwareVersion()
{
unsigned char usb_buf[65];
/*-----------------------------------------------------*\
| Zero out buffer |
\*-----------------------------------------------------*/
memset(usb_buf, 0x00, sizeof(usb_buf));
/*-----------------------------------------------------*\
| Set up Get Firmware Version packet |
\*-----------------------------------------------------*/
usb_buf[0x00] = 0x00;
usb_buf[0x01] = 0x33;
usb_buf[0x02] = 0x50;
/*-----------------------------------------------------*\
| Send packet |
\*-----------------------------------------------------*/
hid_write(dev, usb_buf, 65);
hid_read_timeout(dev, usb_buf, 65, 100);
std::string ret_str = std::to_string(usb_buf[2]) + "." + std::to_string(usb_buf[3]) + "." + std::to_string(usb_buf[4]);
return(ret_str);
}
void ThermaltakeRiingController::SetChannelLEDs(unsigned char channel, RGBColor * colors, unsigned int num_colors)
{
unsigned char* color_data = new unsigned char[3 * num_colors];
for(unsigned int color = 0; color < num_colors; color++)
{
unsigned int color_idx = color * 3;
color_data[color_idx + 0] = RGBGetGValue(colors[color]);
color_data[color_idx + 1] = RGBGetRValue(colors[color]);
color_data[color_idx + 2] = RGBGetBValue(colors[color]);
}
SendRGB(channel + 1, current_mode, current_speed, num_colors, color_data);
delete[] color_data;
}
void ThermaltakeRiingController::SetMode(unsigned char mode, unsigned char speed)
{
current_mode = mode;
current_speed = speed;
}
/*-------------------------------------------------------------------------------------------------*\
| Private packet sending functions. |
\*-------------------------------------------------------------------------------------------------*/
void ThermaltakeRiingController::SendInit()
{
unsigned char usb_buf[65];
/*-----------------------------------------------------*\
| Zero out buffer |
\*-----------------------------------------------------*/
memset(usb_buf, 0x00, sizeof(usb_buf));
/*-----------------------------------------------------*\
| Set up Init packet |
\*-----------------------------------------------------*/
usb_buf[0x00] = 0x00;
usb_buf[0x01] = 0xFE;
usb_buf[0x02] = 0x33;
/*-----------------------------------------------------*\
| Send packet |
\*-----------------------------------------------------*/
hid_write(dev, usb_buf, 65);
hid_read_timeout(dev, usb_buf, 65, 100);
}
void ThermaltakeRiingController::SendRGB
(
unsigned char port,
unsigned char mode,
unsigned char speed,
unsigned char num_colors,
unsigned char* color_data
)
{
unsigned char usb_buf[65];
/*-----------------------------------------------------*\
| Zero out buffer |
\*-----------------------------------------------------*/
memset(usb_buf, 0x00, sizeof(usb_buf));
/*-----------------------------------------------------*\
| Set up RGB packet |
\*-----------------------------------------------------*/
usb_buf[0x00] = 0x00;
usb_buf[0x01] = 0x32;
usb_buf[0x02] = 0x52;
usb_buf[0x03] = port;
usb_buf[0x04] = mode + ( speed & 0x03 );
/*-----------------------------------------------------*\
| Copy in GRB color data |
\*-----------------------------------------------------*/
memcpy(&usb_buf[0x05], color_data, (num_colors * 3));
/*-----------------------------------------------------*\
| Send packet |
\*-----------------------------------------------------*/
hid_write(dev, usb_buf, 65);
hid_read_timeout(dev, usb_buf, 65, 100);
}
Controllers/ThermaltakeRiingController/ThermaltakeRiingController/ThermaltakeRiingController.h
+82
View File
@@ -0,0 +1,82 @@
/*---------------------------------------------------------*\
| ThermaltakeRiingController.h |
| |
| Driver for Thermaltake Riing |
| |
| Adam Honse (CalcProgrammer1) 07 Feb 2020 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#pragma once
#include <vector>
#include <hidapi.h>
#include "RGBController.h"
enum
{
THERMALTAKE_PORT_1 = 0x01,
THERMALTAKE_PORT_2 = 0x02,
THERMALTAKE_PORT_3 = 0x03,
THERMALTAKE_PORT_4 = 0x04,
THERMALTAKE_PORT_5 = 0x05
};
enum
{
THERMALTAKE_MODE_FLOW = 0x00,
THERMALTAKE_MODE_SPECTRUM = 0x04,
THERMALTAKE_MODE_RIPPLE = 0x08,
THERMALTAKE_MODE_BLINK = 0x0C,
THERMALTAKE_MODE_PULSE = 0x10,
THERMALTAKE_MODE_WAVE = 0x14,
THERMALTAKE_MODE_PER_LED = 0x18,
THERMALTAKE_MODE_FULL = 0x19
};
enum
{
THERMALTAKE_SPEED_SLOW = 0x03,
THERMALTAKE_SPEED_NORMAL = 0x02,
THERMALTAKE_SPEED_FAST = 0x01,
THERMALTAKE_SPEED_EXTREME = 0x00
};
#define THERMALTAKE_NUM_CHANNELS 5
class ThermaltakeRiingController
{
public:
ThermaltakeRiingController(hid_device* dev_handle, const char* path);
~ThermaltakeRiingController();
std::string GetDeviceLocation();
std::string GetSerialString();
std::string GetFirmwareVersion();
void SetChannelLEDs(unsigned char channel, RGBColor * colors, unsigned int num_colors);
void SetMode(unsigned char mode, unsigned char speed);
private:
hid_device* dev;
unsigned char current_mode;
unsigned char current_speed;
std::string location;
void SendInit();
void SendRGB
(
unsigned char port,
unsigned char mode,
unsigned char speed,
unsigned char num_colors,
unsigned char* color_data
);
void SendFan();
void SendSave();
};
Controllers/ThermaltakeRiingController/ThermaltakeRiingControllerDetect.cpp
+124
View File
@@ -0,0 +1,124 @@
/*---------------------------------------------------------*\
| ThermaltakeRiingControllerDetect.cpp |
| |
| Detector for Thermaltake Riing devices |
| |
| Adam Honse (CalcProgrammer1) 07 Feb 2020 |
| Chris M (Dr_No) 15 Feb 2021 |
| Sam B (4rcheria) 24 Nov 2024 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include <hidapi.h>
#include "Detector.h"
#include "ThermaltakeRiingController.h"
#include "ThermaltakeRiingQuadController.h"
#include "ThermaltakeRiingTrioController.h"
#include "RGBController_ThermaltakeRiing.h"
#include "RGBController_ThermaltakeRiingQuad.h"
#include "RGBController_ThermaltakeRiingTrio.h"
#define THERMALTAKE_RIING_VID 0x264A
#define THERMALTAKE_RIING_PID_BEGIN 0x1FA5
#define THERMALTAKE_RIING_PID_END 0x1FB5
/******************************************************************************************\
* *
* DetectThermaltakeRiingControllers *
* *
* Tests the USB address to see if an AMD Wraith Prism controller exists there. *
* *
\******************************************************************************************/
void DetectThermaltakeRiingControllers(hid_device_info* info, const std::string&)
{
hid_device* dev = hid_open_path(info->path);
if(dev)
{
ThermaltakeRiingController* controller = new ThermaltakeRiingController(dev, info->path);
RGBController_ThermaltakeRiing* rgb_controller = new RGBController_ThermaltakeRiing(controller);
// Constructor sets the name
ResourceManager::get()->RegisterRGBController(rgb_controller);
}
} /* DetectThermaltakeRiingControllers() */
void DetectThermaltakeRiingQuadControllers(hid_device_info* info, const std::string&)
{
hid_device* dev = hid_open_path(info->path);
if(dev)
{
ThermaltakeRiingQuadController* controller = new ThermaltakeRiingQuadController(dev, info->path);
RGBController_ThermaltakeRiingQuad* rgb_controller = new RGBController_ThermaltakeRiingQuad(controller);
// Constructor sets the name
ResourceManager::get()->RegisterRGBController(rgb_controller);
}
}
void DetectThermaltakeRiingTrioControllers(hid_device_info* info, const std::string&)
{
hid_device* dev = hid_open_path(info->path);
if(dev)
{
ThermaltakeRiingTrioController* controller = new ThermaltakeRiingTrioController(dev, info->path);
RGBController_ThermaltakeRiingTrio* rgb_controller = new RGBController_ThermaltakeRiingTrio(controller);
// Constructor sets the name
ResourceManager::get()->RegisterRGBController(rgb_controller);
}
}
REGISTER_HID_DETECTOR("Thermaltake Riing (PID 0x1FA5)", DetectThermaltakeRiingControllers, THERMALTAKE_RIING_VID, 0x1FA5);
REGISTER_HID_DETECTOR("Thermaltake Riing (PID 0x1FA6)", DetectThermaltakeRiingControllers, THERMALTAKE_RIING_VID, 0x1FA6);
REGISTER_HID_DETECTOR("Thermaltake Riing (PID 0x1FA7)", DetectThermaltakeRiingControllers, THERMALTAKE_RIING_VID, 0x1FA7);
REGISTER_HID_DETECTOR("Thermaltake Riing (PID 0x1FA8)", DetectThermaltakeRiingControllers, THERMALTAKE_RIING_VID, 0x1FA8);
REGISTER_HID_DETECTOR("Thermaltake Riing (PID 0x1FA9)", DetectThermaltakeRiingControllers, THERMALTAKE_RIING_VID, 0x1FA9);
REGISTER_HID_DETECTOR("Thermaltake Riing (PID 0x1FAA)", DetectThermaltakeRiingControllers, THERMALTAKE_RIING_VID, 0x1FAA);
REGISTER_HID_DETECTOR("Thermaltake Riing (PID 0x1FAB)", DetectThermaltakeRiingControllers, THERMALTAKE_RIING_VID, 0x1FAB);
REGISTER_HID_DETECTOR("Thermaltake Riing (PID 0x1FAC)", DetectThermaltakeRiingControllers, THERMALTAKE_RIING_VID, 0x1FAC);
REGISTER_HID_DETECTOR("Thermaltake Riing (PID 0x1FAD)", DetectThermaltakeRiingControllers, THERMALTAKE_RIING_VID, 0x1FAD);
REGISTER_HID_DETECTOR("Thermaltake Riing (PID 0x1FAE)", DetectThermaltakeRiingControllers, THERMALTAKE_RIING_VID, 0x1FAE);
REGISTER_HID_DETECTOR("Thermaltake Riing (PID 0x1FAF)", DetectThermaltakeRiingControllers, THERMALTAKE_RIING_VID, 0x1FAF);
REGISTER_HID_DETECTOR("Thermaltake Riing (PID 0x1FB0)", DetectThermaltakeRiingControllers, THERMALTAKE_RIING_VID, 0x1FB0);
REGISTER_HID_DETECTOR("Thermaltake Riing (PID 0x1FB1)", DetectThermaltakeRiingControllers, THERMALTAKE_RIING_VID, 0x1FB1);
REGISTER_HID_DETECTOR("Thermaltake Riing (PID 0x1FB2)", DetectThermaltakeRiingControllers, THERMALTAKE_RIING_VID, 0x1FB2);
REGISTER_HID_DETECTOR("Thermaltake Riing (PID 0x1FB3)", DetectThermaltakeRiingControllers, THERMALTAKE_RIING_VID, 0x1FB3);
REGISTER_HID_DETECTOR("Thermaltake Riing (PID 0x1FB4)", DetectThermaltakeRiingControllers, THERMALTAKE_RIING_VID, 0x1FB4);
REGISTER_HID_DETECTOR("Thermaltake Riing (PID 0x1FB5)", DetectThermaltakeRiingControllers, THERMALTAKE_RIING_VID, 0x1FB5);
REGISTER_HID_DETECTOR("Thermaltake Riing Quad (PID 0x2260)", DetectThermaltakeRiingQuadControllers, THERMALTAKE_RIING_VID, 0x2260);
REGISTER_HID_DETECTOR("Thermaltake Riing Quad (PID 0x2261)", DetectThermaltakeRiingQuadControllers, THERMALTAKE_RIING_VID, 0x2261);
REGISTER_HID_DETECTOR("Thermaltake Riing Quad (PID 0x2262)", DetectThermaltakeRiingQuadControllers, THERMALTAKE_RIING_VID, 0x2262);
REGISTER_HID_DETECTOR("Thermaltake Riing Quad (PID 0x2263)", DetectThermaltakeRiingQuadControllers, THERMALTAKE_RIING_VID, 0x2263);
REGISTER_HID_DETECTOR("Thermaltake Riing Quad (PID 0x2264)", DetectThermaltakeRiingQuadControllers, THERMALTAKE_RIING_VID, 0x2264);
REGISTER_HID_DETECTOR("Thermaltake Riing Quad (PID 0x2265)", DetectThermaltakeRiingQuadControllers, THERMALTAKE_RIING_VID, 0x2265);
REGISTER_HID_DETECTOR("Thermaltake Riing Quad (PID 0x2266)", DetectThermaltakeRiingQuadControllers, THERMALTAKE_RIING_VID, 0x2266);
REGISTER_HID_DETECTOR("Thermaltake Riing Quad (PID 0x2267)", DetectThermaltakeRiingQuadControllers, THERMALTAKE_RIING_VID, 0x2267);
REGISTER_HID_DETECTOR("Thermaltake Riing Quad (PID 0x2268)", DetectThermaltakeRiingQuadControllers, THERMALTAKE_RIING_VID, 0x2268);
REGISTER_HID_DETECTOR("Thermaltake Riing Quad (PID 0x2269)", DetectThermaltakeRiingQuadControllers, THERMALTAKE_RIING_VID, 0x2269);
REGISTER_HID_DETECTOR("Thermaltake Riing Quad (PID 0x226A)", DetectThermaltakeRiingQuadControllers, THERMALTAKE_RIING_VID, 0x226A);
REGISTER_HID_DETECTOR("Thermaltake Riing Quad (PID 0x226B)", DetectThermaltakeRiingQuadControllers, THERMALTAKE_RIING_VID, 0x226B);
REGISTER_HID_DETECTOR("Thermaltake Riing Quad (PID 0x226C)", DetectThermaltakeRiingQuadControllers, THERMALTAKE_RIING_VID, 0x226C);
REGISTER_HID_DETECTOR("Thermaltake Riing Quad (PID 0x226D)", DetectThermaltakeRiingQuadControllers, THERMALTAKE_RIING_VID, 0x226D);
REGISTER_HID_DETECTOR("Thermaltake Riing Quad (PID 0x226E)", DetectThermaltakeRiingQuadControllers, THERMALTAKE_RIING_VID, 0x226E);
REGISTER_HID_DETECTOR("Thermaltake Riing Quad (PID 0x226F)", DetectThermaltakeRiingQuadControllers, THERMALTAKE_RIING_VID, 0x226F);
REGISTER_HID_DETECTOR("Thermaltake Riing Quad (PID 0x2270)", DetectThermaltakeRiingQuadControllers, THERMALTAKE_RIING_VID, 0x2270);
REGISTER_HID_DETECTOR("Thermaltake Riing Quad (PID 0x232B)", DetectThermaltakeRiingQuadControllers, THERMALTAKE_RIING_VID, 0x232B);
REGISTER_HID_DETECTOR("Thermaltake Riing Trio (PID 0x2135)", DetectThermaltakeRiingTrioControllers, THERMALTAKE_RIING_VID, 0x2135);
REGISTER_HID_DETECTOR("Thermaltake Riing Trio (PID 0x2136)", DetectThermaltakeRiingTrioControllers, THERMALTAKE_RIING_VID, 0x2136);
REGISTER_HID_DETECTOR("Thermaltake Riing Trio (PID 0x2137)", DetectThermaltakeRiingTrioControllers, THERMALTAKE_RIING_VID, 0x2137);
REGISTER_HID_DETECTOR("Thermaltake Riing Trio (PID 0x2138)", DetectThermaltakeRiingTrioControllers, THERMALTAKE_RIING_VID, 0x2138);
REGISTER_HID_DETECTOR("Thermaltake Riing Trio (PID 0x2139)", DetectThermaltakeRiingTrioControllers, THERMALTAKE_RIING_VID, 0x2139);
REGISTER_HID_DETECTOR("Thermaltake Riing Trio (PID 0x213A)", DetectThermaltakeRiingTrioControllers, THERMALTAKE_RIING_VID, 0x213A);
REGISTER_HID_DETECTOR("Thermaltake Riing Trio (PID 0x213B)", DetectThermaltakeRiingTrioControllers, THERMALTAKE_RIING_VID, 0x213B);
REGISTER_HID_DETECTOR("Thermaltake Riing Trio (PID 0x213C)", DetectThermaltakeRiingTrioControllers, THERMALTAKE_RIING_VID, 0x213C);
REGISTER_HID_DETECTOR("Thermaltake Riing Trio (PID 0x213D)", DetectThermaltakeRiingTrioControllers, THERMALTAKE_RIING_VID, 0x213D);
REGISTER_HID_DETECTOR("Thermaltake Riing Trio (PID 0x213E)", DetectThermaltakeRiingTrioControllers, THERMALTAKE_RIING_VID, 0x213E);
REGISTER_HID_DETECTOR("Thermaltake Riing Trio (PID 0x213F)", DetectThermaltakeRiingTrioControllers, THERMALTAKE_RIING_VID, 0x213F);
REGISTER_HID_DETECTOR("Thermaltake Riing Trio (PID 0x2141)", DetectThermaltakeRiingTrioControllers, THERMALTAKE_RIING_VID, 0x2141);
REGISTER_HID_DETECTOR("Thermaltake Riing Trio (PID 0x2142)", DetectThermaltakeRiingTrioControllers, THERMALTAKE_RIING_VID, 0x2142);
REGISTER_HID_DETECTOR("Thermaltake Riing Trio (PID 0x2143)", DetectThermaltakeRiingTrioControllers, THERMALTAKE_RIING_VID, 0x2143);
REGISTER_HID_DETECTOR("Thermaltake Riing Trio (PID 0x2144)", DetectThermaltakeRiingTrioControllers, THERMALTAKE_RIING_VID, 0x2144);
REGISTER_HID_DETECTOR("Thermaltake Riing Trio (PID 0x2145)", DetectThermaltakeRiingTrioControllers, THERMALTAKE_RIING_VID, 0x2145);
Controllers/ThermaltakeRiingController/ThermaltakeRiingQuadController/RGBController_ThermaltakeRiingQuad.cpp
+160
View File
@@ -0,0 +1,160 @@
/*---------------------------------------------------------*\
| RGBController_ThermaltakeRiingQuad.cpp |
| |
| RGBController for Thermaltake Riing Quad |
| |
| Chris M (Dr_No) 15 Feb 2021 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include "RGBController_ThermaltakeRiingQuad.h"
/**------------------------------------------------------------------*\
@name Thermaltake Riing Quad
@category Cooler
@type USB
@save :x:
@direct :white_check_mark:
@effects :x:
@detectors DetectThermaltakeRiingQuadControllers
@comment
\*-------------------------------------------------------------------*/
RGBController_ThermaltakeRiingQuad::RGBController_ThermaltakeRiingQuad(ThermaltakeRiingQuadController* controller_ptr)
{
controller = controller_ptr;
name = controller->GetDeviceName();
vendor = "Thermaltake";
type = DEVICE_TYPE_COOLER;
description = "Thermaltake Riing Quad Device";
location = controller->GetDeviceLocation();
serial = controller->GetSerial();
mode Direct;
Direct.name = "Direct";
Direct.value = THERMALTAKE_QUAD_MODE_DIRECT;
Direct.flags = MODE_FLAG_HAS_PER_LED_COLOR;
Direct.speed_min = 0;
Direct.speed_max = 0;
Direct.speed = 0;
Direct.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Direct);
SetupZones();
}
RGBController_ThermaltakeRiingQuad::~RGBController_ThermaltakeRiingQuad()
{
delete controller;
}
void RGBController_ThermaltakeRiingQuad::SetupZones()
{
/*-------------------------------------------------*\
| Only set LED count on the first run |
\*-------------------------------------------------*/
bool first_run = false;
if(zones.size() == 0)
{
first_run = true;
}
/*-------------------------------------------------*\
| Clear any existing color/LED configuration |
\*-------------------------------------------------*/
leds.clear();
colors.clear();
zones.resize(THERMALTAKE_QUAD_NUM_CHANNELS);
/*-------------------------------------------------*\
| Set zones and leds |
\*-------------------------------------------------*/
for (unsigned int channel_idx = 0; channel_idx < THERMALTAKE_QUAD_NUM_CHANNELS; channel_idx++)
{
char ch_idx_string[2];
snprintf(ch_idx_string, 2, "%d", channel_idx + 1);
zones[channel_idx].name = "Riing Channel ";
zones[channel_idx].name.append(ch_idx_string);
zones[channel_idx].type = ZONE_TYPE_LINEAR;
/*-------------------------------------------------*\
| The maximum number of colors that would fit in the|
| Riing Quad protocol is 54 |
\*-------------------------------------------------*/
zones[channel_idx].leds_min = 0;
zones[channel_idx].leds_max = 60;
if(first_run)
{
zones[channel_idx].leds_count = 0;
}
zones[channel_idx].matrix_map = NULL;
for (unsigned int led_ch_idx = 0; led_ch_idx < zones[channel_idx].leds_count; led_ch_idx++)
{
char led_idx_string[3];
snprintf(led_idx_string, 3, "%d", led_ch_idx + 1);
led new_led;
new_led.name = "Riing Channel ";
new_led.name.append(ch_idx_string);
new_led.name.append(", LED ");
new_led.name.append(led_idx_string);
leds.push_back(new_led);
leds_channel.push_back(channel_idx);
}
}
SetupColors();
}
void RGBController_ThermaltakeRiingQuad::ResizeZone(int zone, int new_size)
{
if((size_t) zone >= zones.size())
{
return;
}
if(((unsigned int)new_size >= zones[zone].leds_min) && ((unsigned int)new_size <= zones[zone].leds_max))
{
zones[zone].leds_count = new_size;
SetupZones();
}
}
void RGBController_ThermaltakeRiingQuad::DeviceUpdateLEDs()
{
for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
{
controller->SetChannelLEDs((unsigned char)zone_idx, zones[zone_idx].colors, zones[zone_idx].leds_count);
}
}
void RGBController_ThermaltakeRiingQuad::UpdateZoneLEDs(int zone)
{
controller->SetChannelLEDs(zone, zones[zone].colors, zones[zone].leds_count);
}
void RGBController_ThermaltakeRiingQuad::UpdateSingleLED(int led)
{
unsigned int channel = leds_channel[led];
controller->SetChannelLEDs(channel, zones[channel].colors, zones[channel].leds_count);
}
void RGBController_ThermaltakeRiingQuad::DeviceUpdateMode()
{
for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
{
controller->SetMode(modes[active_mode].value, modes[active_mode].speed);
controller->SetChannelLEDs((unsigned char)zone_idx, zones[zone_idx].colors, zones[zone_idx].leds_count);
}
}
Controllers/ThermaltakeRiingController/ThermaltakeRiingQuadController/RGBController_ThermaltakeRiingQuad.h
+36
View File
@@ -0,0 +1,36 @@
/*---------------------------------------------------------*\
| RGBController_ThermaltakeRiingQuad.h |
| |
| RGBController for Thermaltake Riing Quad |
| |
| Chris M (Dr_No) 15 Feb 2021 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#pragma once
#include "RGBController.h"
#include "ThermaltakeRiingQuadController.h"
class RGBController_ThermaltakeRiingQuad : public RGBController
{
public:
RGBController_ThermaltakeRiingQuad(ThermaltakeRiingQuadController* controller_ptr);
~RGBController_ThermaltakeRiingQuad();
void SetupZones();
void ResizeZone(int zone, int new_size);
void DeviceUpdateLEDs();
void UpdateZoneLEDs(int zone);
void UpdateSingleLED(int led);
void DeviceUpdateMode();
private:
ThermaltakeRiingQuadController* controller;
std::vector<unsigned int> leds_channel;
std::vector<unsigned int> zones_channel;
};
Controllers/ThermaltakeRiingController/ThermaltakeRiingQuadController/ThermaltakeRiingQuadController.cpp
+164
View File
@@ -0,0 +1,164 @@
/*---------------------------------------------------------*\
| ThermaltakeRiingQuadController.cpp |
| |
| Driver for Thermaltake Riing Quad |
| |
| Chris M (Dr_No) 15 Feb 2021 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include <cstring>
#include "StringUtils.h"
#include "ThermaltakeRiingQuadController.h"
ThermaltakeRiingQuadController::ThermaltakeRiingQuadController(hid_device* dev_handle, const char* path)
{
dev = dev_handle;
location = path;
/*---------------------------------------------------------*\
| 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);
device_name = StringUtils::wstring_to_string(name_string);
hid_get_product_string(dev, name_string, HID_MAX_STR);
device_name.append(" ").append(StringUtils::wstring_to_string(name_string));
SendInit();
/*-----------------------------------------------------*\
| The Riing Quad only seems to run in direct mode and |
| requires a packet within seconds to remain in the |
| set mode (similar to Corsair Node Pro). Start a thread|
| to send a packet every TT_QUAD_KEEPALIVE seconds |
\*-----------------------------------------------------*/
memset(tt_quad_buffer, 0x00, sizeof(tt_quad_buffer));
unsigned char temp_buffer[3] = { 0x00, 0x32, 0x52 };
for(std::size_t zone_index = 0; zone_index < THERMALTAKE_QUAD_NUM_CHANNELS; zone_index++)
{
/*-------------------------------------------------*\
| Add the constant bytes for the mode info buffer |
\*-------------------------------------------------*/
memcpy(&tt_quad_buffer[zone_index][0], temp_buffer, 3);
}
keepalive_thread_run = 1;
keepalive_thread = new std::thread(&ThermaltakeRiingQuadController::KeepaliveThread, this);
}
ThermaltakeRiingQuadController::~ThermaltakeRiingQuadController()
{
keepalive_thread_run = 0;
keepalive_thread->join();
delete keepalive_thread;
hid_close(dev);
}
void ThermaltakeRiingQuadController::KeepaliveThread()
{
while(keepalive_thread_run.load())
{
if((std::chrono::steady_clock::now() - last_commit_time) > std::chrono::seconds(THERMALTAKE_QUAD_KEEPALIVE))
{
SendBuffer();
}
std::this_thread::sleep_for(std::chrono::seconds(1));
}
}
std::string ThermaltakeRiingQuadController::GetDeviceName()
{
return device_name;
}
std::string ThermaltakeRiingQuadController::GetDeviceLocation()
{
return("HID: " + location);
}
std::string ThermaltakeRiingQuadController::GetSerial()
{
wchar_t serial_string[128];
int ret = hid_get_serial_number_string(dev, serial_string, 128);
if(ret != 0)
{
return("");
}
return(StringUtils::wstring_to_string(serial_string));
}
void ThermaltakeRiingQuadController::SetChannelLEDs(unsigned char channel, RGBColor * colors, unsigned int num_colors)
{
unsigned char* color_data = new unsigned char[3 * num_colors];
for(unsigned int color = 0; color < num_colors; color++)
{
unsigned int color_idx = color * 3;
color_data[color_idx + 0] = RGBGetGValue(colors[color]);
color_data[color_idx + 1] = RGBGetRValue(colors[color]);
color_data[color_idx + 2] = RGBGetBValue(colors[color]);
}
tt_quad_buffer[channel][THERMALTAKE_QUAD_ZONE_BYTE] = channel + 1;
tt_quad_buffer[channel][THERMALTAKE_QUAD_MODE_BYTE] = current_mode + ( current_speed & 0x03 );
memcpy(&tt_quad_buffer[channel][THERMALTAKE_QUAD_DATA_BYTE], color_data, (num_colors * 3));
hid_write(dev, tt_quad_buffer[channel], THERMALTAKE_QUAD_PACKET_SIZE);
delete[] color_data;
}
void ThermaltakeRiingQuadController::SetMode(unsigned char mode, unsigned char speed)
{
current_mode = mode;
current_speed = speed;
}
/*-------------------------------------------------------------------------------------------------*\
| Private packet sending functions. |
\*-------------------------------------------------------------------------------------------------*/
void ThermaltakeRiingQuadController::SendInit()
{
unsigned char usb_buf[THERMALTAKE_QUAD_PACKET_SIZE];
/*-----------------------------------------------------*\
| Zero out buffer |
\*-----------------------------------------------------*/
memset(usb_buf, 0x00, sizeof(usb_buf));
/*-----------------------------------------------------*\
| Set up Init packet |
\*-----------------------------------------------------*/
usb_buf[0x00] = 0x00;
usb_buf[0x01] = 0xFE;
usb_buf[0x02] = 0x33;
/*-----------------------------------------------------*\
| Send packet |
\*-----------------------------------------------------*/
hid_write(dev, usb_buf, THERMALTAKE_QUAD_PACKET_SIZE);
hid_read_timeout(dev, usb_buf, THERMALTAKE_QUAD_PACKET_SIZE, THERMALTAKE_QUAD_INTERRUPT_TIMEOUT);
}
void ThermaltakeRiingQuadController::SendBuffer()
{
for(std::size_t channel_index = 0; channel_index < THERMALTAKE_QUAD_NUM_CHANNELS; channel_index++)
{
hid_write(dev, tt_quad_buffer[channel_index], THERMALTAKE_QUAD_PACKET_SIZE);
}
/*-------------------------------------*\
| Update the last commit time |
\*-------------------------------------*/
last_commit_time = std::chrono::steady_clock::now();
}
Controllers/ThermaltakeRiingController/ThermaltakeRiingQuadController/ThermaltakeRiingQuadController.h
+81
View File
@@ -0,0 +1,81 @@
/*---------------------------------------------------------*\
| ThermaltakeRiingQuadController.h |
| |
| Driver for Thermaltake Riing Quad |
| |
| Chris M (Dr_No) 15 Feb 2021 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#pragma once
#include <chrono>
#include <vector>
#include <hidapi.h>
#include "RGBController.h"
#define THERMALTAKE_QUAD_PACKET_SIZE 193
#define THERMALTAKE_QUAD_INTERRUPT_TIMEOUT 250
#define THERMALTAKE_QUAD_KEEPALIVE 3
#define HID_MAX_STR 255
enum
{
THERMALTAKE_QUAD_COMMAND_BYTE = 1,
THERMALTAKE_QUAD_FUNCTION_BYTE = 2,
THERMALTAKE_QUAD_ZONE_BYTE = 3,
THERMALTAKE_QUAD_MODE_BYTE = 4,
THERMALTAKE_QUAD_DATA_BYTE = 5,
};
enum
{
THERMALTAKE_QUAD_MODE_DIRECT = 0x24
};
enum
{
THERMALTAKE_QUAD_SPEED_EXTREME = 0x00,
THERMALTAKE_QUAD_SPEED_FAST = 0x01,
THERMALTAKE_QUAD_SPEED_NORMAL = 0x02,
THERMALTAKE_QUAD_SPEED_SLOW = 0x03,
};
#define THERMALTAKE_QUAD_NUM_CHANNELS 5
class ThermaltakeRiingQuadController
{
public:
ThermaltakeRiingQuadController(hid_device* dev_handle, const char* path);
~ThermaltakeRiingQuadController();
std::string GetDeviceName();
std::string GetDeviceLocation();
std::string GetSerial();
void SetChannelLEDs(unsigned char channel, RGBColor * colors, unsigned int num_colors);
void SetMode(unsigned char mode, unsigned char speed);
private:
hid_device* dev;
unsigned char current_mode;
unsigned char current_speed;
std::string device_name;
std::string location;
uint8_t tt_quad_buffer[THERMALTAKE_QUAD_NUM_CHANNELS][THERMALTAKE_QUAD_PACKET_SIZE];
std::thread* keepalive_thread;
std::atomic<bool> keepalive_thread_run;
std::chrono::time_point<std::chrono::steady_clock> last_commit_time;
void SendBuffer();
void KeepaliveThread();
void SendInit();
void SendFan();
void SendSave();
};
Controllers/ThermaltakeRiingController/ThermaltakeRiingTrioController/RGBController_ThermaltakeRiingTrio.cpp
+160
View File
@@ -0,0 +1,160 @@
/*---------------------------------------------------------*\
| RGBController_ThermaltakeRiingTrio.cpp |
| |
| RGBController for Thermaltake Riing Trio |
| |
| Sam B (4rcheria) 24 Nov 2024 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include "RGBController_ThermaltakeRiingTrio.h"
/**------------------------------------------------------------------*\
@name Thermaltake Riing Trio
@category Cooler
@type USB
@save :x:
@direct :white_check_mark:
@effects :x:
@detectors DetectThermaltakeRiingTrioControllers
@comment
\*-------------------------------------------------------------------*/
RGBController_ThermaltakeRiingTrio::RGBController_ThermaltakeRiingTrio(ThermaltakeRiingTrioController* controller_ptr)
{
controller = controller_ptr;
name = "Thermaltake Trio";
vendor = "Thermaltake";
type = DEVICE_TYPE_COOLER;
description = "Thermaltake Riing Trio Device";
location = controller->GetDeviceLocation();
serial = controller->GetSerial();
mode Direct;
Direct.name = "Direct";
Direct.value = THERMALTAKE_TRIO_MODE_DIRECT;
Direct.flags = MODE_FLAG_HAS_PER_LED_COLOR;
Direct.speed_min = 0;
Direct.speed_max = 0;
Direct.speed = 0;
Direct.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Direct);
SetupZones();
}
RGBController_ThermaltakeRiingTrio::~RGBController_ThermaltakeRiingTrio()
{
delete controller;
}
void RGBController_ThermaltakeRiingTrio::SetupZones()
{
/*-------------------------------------------------*\
| Only set LED count on the first run |
\*-------------------------------------------------*/
bool first_run = false;
if(zones.size() == 0)
{
first_run = true;
}
/*-------------------------------------------------*\
| Clear any existing color/LED configuration |
\*-------------------------------------------------*/
leds.clear();
colors.clear();
zones.resize(THERMALTAKE_TRIO_NUM_CHANNELS);
/*-------------------------------------------------*\
| Set zones and leds |
\*-------------------------------------------------*/
for (unsigned int channel_idx = 0; channel_idx < THERMALTAKE_TRIO_NUM_CHANNELS; channel_idx++)
{
char ch_idx_string[2];
snprintf(ch_idx_string, 2, "%d", channel_idx + 1);
zones[channel_idx].name = "Riing Channel ";
zones[channel_idx].name.append(ch_idx_string);
zones[channel_idx].type = ZONE_TYPE_LINEAR;
/*-------------------------------------------------*\
| The maximum number of colors that would fit in the|
| Riing Trio protocol is 54 |
\*-------------------------------------------------*/
zones[channel_idx].leds_min = 0;
zones[channel_idx].leds_max = 54;
if(first_run)
{
zones[channel_idx].leds_count = 0;
}
zones[channel_idx].matrix_map = NULL;
for (unsigned int led_ch_idx = 0; led_ch_idx < zones[channel_idx].leds_count; led_ch_idx++)
{
char led_idx_string[3];
snprintf(led_idx_string, 3, "%d", led_ch_idx + 1);
led new_led;
new_led.name = "Riing Channel ";
new_led.name.append(ch_idx_string);
new_led.name.append(", LED ");
new_led.name.append(led_idx_string);
leds.push_back(new_led);
leds_channel.push_back(channel_idx);
}
}
SetupColors();
}
void RGBController_ThermaltakeRiingTrio::ResizeZone(int zone, int new_size)
{
if((size_t) zone >= zones.size())
{
return;
}
if(((unsigned int)new_size >= zones[zone].leds_min) && ((unsigned int)new_size <= zones[zone].leds_max))
{
zones[zone].leds_count = new_size;
SetupZones();
}
}
void RGBController_ThermaltakeRiingTrio::DeviceUpdateLEDs()
{
for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
{
controller->SetChannelLEDs((unsigned char)zone_idx, zones[zone_idx].colors, zones[zone_idx].leds_count);
}
}
void RGBController_ThermaltakeRiingTrio::UpdateZoneLEDs(int zone)
{
controller->SetChannelLEDs(zone, zones[zone].colors, zones[zone].leds_count);
}
void RGBController_ThermaltakeRiingTrio::UpdateSingleLED(int led)
{
unsigned int channel = leds_channel[led];
controller->SetChannelLEDs(channel, zones[channel].colors, zones[channel].leds_count);
}
void RGBController_ThermaltakeRiingTrio::DeviceUpdateMode()
{
for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
{
controller->SetMode(modes[active_mode].value, modes[active_mode].speed);
controller->SetChannelLEDs((unsigned char)zone_idx, zones[zone_idx].colors, zones[zone_idx].leds_count);
}
}
Controllers/ThermaltakeRiingController/ThermaltakeRiingTrioController/RGBController_ThermaltakeRiingTrio.h
+36
View File
@@ -0,0 +1,36 @@
/*---------------------------------------------------------*\
| RGBController_ThermaltakeRiingTrio.h |
| |
| RGBController for Thermaltake Riing Trio |
| |
| Sam B (4rcheria) 24 Nov 2024 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#pragma once
#include "RGBController.h"
#include "ThermaltakeRiingTrioController.h"
class RGBController_ThermaltakeRiingTrio : public RGBController
{
public:
RGBController_ThermaltakeRiingTrio(ThermaltakeRiingTrioController* controller_ptr);
~RGBController_ThermaltakeRiingTrio();
void SetupZones();
void ResizeZone(int zone, int new_size);
void DeviceUpdateLEDs();
void UpdateZoneLEDs(int zone);
void UpdateSingleLED(int led);
void DeviceUpdateMode();
private:
ThermaltakeRiingTrioController* controller;
std::vector<unsigned int> leds_channel;
std::vector<unsigned int> zones_channel;
};
Controllers/ThermaltakeRiingController/ThermaltakeRiingTrioController/ThermaltakeRiingTrioController.cpp
+146
View File
@@ -0,0 +1,146 @@
/*---------------------------------------------------------*\
| ThermaltakeRiingTrioController.cpp |
| |
| Driver for Thermaltake Riing Trio |
| |
| Sam B (4rcheria) 24 Nov 2024 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include <cstring>
#include "StringUtils.h"
#include "ThermaltakeRiingTrioController.h"
ThermaltakeRiingTrioController::ThermaltakeRiingTrioController(hid_device* dev_handle, const char* path)
{
dev = dev_handle;
location = path;
/*---------------------------------------------------------*\
| 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);
device_name = StringUtils::wstring_to_string(name_string);
hid_get_product_string(dev, name_string, HID_MAX_STR);
device_name.append(" ").append(StringUtils::wstring_to_string(name_string));
SendInit();
memset(tt_trio_buffer, 0x00, sizeof(tt_trio_buffer));
unsigned char temp_buffer[3] = { 0x00, 0x32, 0x52 };
for(std::size_t zone_index = 0; zone_index < THERMALTAKE_TRIO_NUM_CHANNELS; zone_index++)
{
/*-------------------------------------------------*\
| Add the constant bytes for the mode info buffer |
\*-------------------------------------------------*/
memcpy(&tt_trio_buffer[zone_index][0], temp_buffer, 3);
}
}
ThermaltakeRiingTrioController::~ThermaltakeRiingTrioController()
{
hid_close(dev);
}
std::string ThermaltakeRiingTrioController::GetDeviceName()
{
return device_name;
}
std::string ThermaltakeRiingTrioController::GetDeviceLocation()
{
return("HID: " + location);
}
std::string ThermaltakeRiingTrioController::GetSerial()
{
wchar_t serial_string[128];
int ret = hid_get_serial_number_string(dev, serial_string, 128);
if(ret != 0)
{
return("");
}
return(StringUtils::wstring_to_string(serial_string));
}
void ThermaltakeRiingTrioController::SetChannelLEDs(unsigned char channel, RGBColor * colors, unsigned int num_colors)
{
if(num_colors == 0) return;
unsigned char* color_data = new unsigned char[3 * num_colors];
for(unsigned int color = 0; color < num_colors; color++)
{
unsigned int color_idx = color * 3;
color_data[color_idx + 0] = RGBGetGValue(colors[color]);
color_data[color_idx + 1] = RGBGetRValue(colors[color]);
color_data[color_idx + 2] = RGBGetBValue(colors[color]);
}
tt_trio_buffer[channel][THERMALTAKE_TRIO_ZONE_BYTE] = channel + 1;
tt_trio_buffer[channel][THERMALTAKE_TRIO_MODE_BYTE] = 0x24;
tt_trio_buffer[channel][5] = 0x03;
tt_trio_buffer[channel][7] = 0x00;
/*-------------------------------------------------*\
| create and send chunks min = 2 max = 4 |
\*-------------------------------------------------*/
for(unsigned int i = 0; (num_colors > (THERMALTAKE_TRIO_CHUNK_LENGTH * i)) || i < 2; i++)
{
unsigned int colors_transmitted = THERMALTAKE_TRIO_CHUNK_LENGTH * i;
unsigned int colors_to_transmit = (num_colors > colors_transmitted) ? num_colors - colors_transmitted : 0;
memset(&tt_trio_buffer[channel][THERMALTAKE_TRIO_CHUNK_ID], 0x00, sizeof(tt_trio_buffer[channel]) - THERMALTAKE_TRIO_CHUNK_ID);
tt_trio_buffer[channel][THERMALTAKE_TRIO_CHUNK_ID] = i + 1;
if(colors_to_transmit < THERMALTAKE_TRIO_CHUNK_LENGTH)
{
memcpy(&tt_trio_buffer[channel][THERMALTAKE_TRIO_DATA_BYTE], &color_data[colors_transmitted * 3], (colors_to_transmit * 3));
}
else
{
memcpy(&tt_trio_buffer[channel][THERMALTAKE_TRIO_DATA_BYTE], &color_data[colors_transmitted * 3], (THERMALTAKE_TRIO_CHUNK_LENGTH * 3));
}
hid_write(dev, tt_trio_buffer[channel], THERMALTAKE_TRIO_PACKET_SIZE);
}
delete[] color_data;
}
void ThermaltakeRiingTrioController::SetMode(unsigned char mode, unsigned char speed)
{
current_mode = mode;
current_speed = speed;
}
void ThermaltakeRiingTrioController::SendInit()
{
unsigned char usb_buf[THERMALTAKE_TRIO_PACKET_SIZE];
/*-----------------------------------------------------*\
| Zero out buffer |
\*-----------------------------------------------------*/
memset(usb_buf, 0x00, sizeof(usb_buf));
/*-----------------------------------------------------*\
| Set up Init packet |
\*-----------------------------------------------------*/
usb_buf[0x00] = 0x00;
usb_buf[0x01] = 0xFE;
usb_buf[0x02] = 0x33;
/*-----------------------------------------------------*\
| Send packet |
\*-----------------------------------------------------*/
hid_write(dev, usb_buf, THERMALTAKE_TRIO_PACKET_SIZE);
hid_read_timeout(dev, usb_buf, THERMALTAKE_TRIO_PACKET_SIZE, THERMALTAKE_TRIO_INTERRUPT_TIMEOUT);
}
Controllers/ThermaltakeRiingController/ThermaltakeRiingTrioController/ThermaltakeRiingTrioController.h
+77
View File
@@ -0,0 +1,77 @@
/*---------------------------------------------------------*\
| ThermaltakeRiingTrioController.h |
| |
| Driver for Thermaltake Riing Trio |
| |
| Sam B (4rcheria) 24 Nov 2024 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#pragma once
#include <chrono>
#include <vector>
#include <hidapi.h>
#include "RGBController.h"
#define THERMALTAKE_TRIO_PACKET_SIZE 65
#define THERMALTAKE_TRIO_INTERRUPT_TIMEOUT 250
#define THERMALTAKE_TRIO_KEEPALIVE 3
#define HID_MAX_STR 255
enum
{
THERMALTAKE_TRIO_COMMAND_BYTE = 1,
THERMALTAKE_TRIO_FUNCTION_BYTE = 2,
THERMALTAKE_TRIO_ZONE_BYTE = 3,
THERMALTAKE_TRIO_MODE_BYTE = 4,
THERMALTAKE_TRIO_CHUNK_ID = 6,
THERMALTAKE_TRIO_DATA_BYTE = 8,
THERMALTAKE_TRIO_CHUNK_LENGTH = 19,
};
enum
{
THERMALTAKE_TRIO_MODE_DIRECT = 0x24
};
enum
{
THERMALTAKE_TRIO_SPEED_EXTREME = 0x00,
THERMALTAKE_TRIO_SPEED_FAST = 0x01,
THERMALTAKE_TRIO_SPEED_NORMAL = 0x02,
THERMALTAKE_TRIO_SPEED_SLOW = 0x03,
};
#define THERMALTAKE_TRIO_NUM_CHANNELS 5
class ThermaltakeRiingTrioController
{
public:
ThermaltakeRiingTrioController(hid_device* dev_handle, const char* path);
~ThermaltakeRiingTrioController();
std::string GetDeviceName();
std::string GetDeviceLocation();
std::string GetSerial();
void SetChannelLEDs(unsigned char channel, RGBColor * colors, unsigned int num_colors);
void SetMode(unsigned char mode, unsigned char speed);
private:
hid_device* dev;
unsigned char current_mode;
unsigned char current_speed;
std::string device_name;
std::string location;
uint8_t tt_trio_buffer[THERMALTAKE_TRIO_NUM_CHANNELS][THERMALTAKE_TRIO_PACKET_SIZE];
void SendInit();
void SendFan();
void SendSave();
};