Publish LumaOps source
This commit is contained in:
LumaOps release export
@@ -0,0 +1,306 @@
|
||||
/*---------------------------------------------------------*\
|
||||
| LianLiControllerDetect.cpp |
|
||||
| |
|
||||
| Detector for Lian Li devices |
|
||||
| |
|
||||
| This file is part of the OpenRGB project |
|
||||
| SPDX-License-Identifier: GPL-2.0-or-later |
|
||||
\*---------------------------------------------------------*/
|
||||
|
||||
#include <string>
|
||||
#include <vector>
|
||||
#include <libusb.h>
|
||||
#include "Detector.h"
|
||||
#include "ResourceManager.h"
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| LianLi USB Controller specific includes |
|
||||
\*-----------------------------------------------------*/
|
||||
#include "RGBController_LianLiUniHub.h"
|
||||
#include "RGBController_LianLiStrimerLConnect.h"
|
||||
#include "LianLiUniHubController.h"
|
||||
#include "RGBController_LianLiUniHub.h"
|
||||
#include "LianLiUniHubSLController.h"
|
||||
#include "RGBController_LianLiUniHubSL.h"
|
||||
#include "LianLiUniHubALController.h"
|
||||
#include "RGBController_LianLiUniHubAL.h"
|
||||
#include "LianLiUniHub_AL10Controller.h"
|
||||
#include "RGBController_LianLiUniHub_AL10.h"
|
||||
#include "LianLiUniHubSLV2Controller.h"
|
||||
#include "RGBController_LianLiUniHubSLV2.h"
|
||||
#include "LianLiUniHubSLInfinityController.h"
|
||||
#include "RGBController_LianLiUniHubSLInfinity.h"
|
||||
#include "LianLiGAIITrinityController.h"
|
||||
#include "RGBController_LianLiGAIITrinity.h"
|
||||
#include "LianLiUniversalScreenController.h"
|
||||
#include "RGBController_LianLiUniversalScreen.h"
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| USB vendor IDs |
|
||||
\*-----------------------------------------------------*/
|
||||
#define ENE_USB_VID 0x0CF2
|
||||
#define NUVOTON_USB_VID 0x0416
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Keyboard product IDs |
|
||||
\*-----------------------------------------------------*/
|
||||
#define STRIMER_L_CONNECT_PID 0xA200
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Fan controller product IDs |
|
||||
\*-----------------------------------------------------*/
|
||||
#define UNI_HUB_PID 0x7750
|
||||
#define UNI_HUB_SL_PID 0xA100
|
||||
#define UNI_HUB_AL_PID 0xA101
|
||||
#define UNI_HUB_SLINF_PID 0xA102
|
||||
#define UNI_HUB_SLV2_PID 0xA103
|
||||
#define UNI_HUB_ALV2_PID 0xA104
|
||||
#define UNI_HUB_SLV2_V05_PID 0xA105
|
||||
#define GAII_USB_PID 0x7373
|
||||
#define GAII_Perf_USB_PID 0x7371
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Screen product IDs |
|
||||
\*-----------------------------------------------------*/
|
||||
#define UNIVERSAL_SCREEN_LED_PID 0x8050
|
||||
|
||||
/*----------------------------------------------------------------------------*\
|
||||
| The Uni Hub is controlled by sending control transfers to various wIndex |
|
||||
| addresses, allthough it announces some kind of hid interface. Hence it |
|
||||
| requires libusb as hidapi provides no wIndex customization. |
|
||||
\*----------------------------------------------------------------------------*/
|
||||
|
||||
void DetectLianLiUniHub()
|
||||
{
|
||||
libusb_device** devices = nullptr;
|
||||
|
||||
ssize_t ret;
|
||||
|
||||
ret = libusb_init(NULL);
|
||||
if(ret < 0)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
ret = libusb_get_device_list(NULL, &devices);
|
||||
if(ret < 0)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
ssize_t deviceCount = ret;
|
||||
|
||||
for(int i = 0; i < deviceCount; i++)
|
||||
{
|
||||
libusb_device* device = devices[i];
|
||||
libusb_device_descriptor descriptor;
|
||||
ret = libusb_get_device_descriptor(device, &descriptor);
|
||||
|
||||
if(ret < 0)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
if( descriptor.idVendor == ENE_USB_VID
|
||||
&& descriptor.idProduct == UNI_HUB_PID)
|
||||
{
|
||||
LianLiUniHubController* controller = new LianLiUniHubController(device, &descriptor);
|
||||
RGBController_LianLiUniHub* rgb_controller = new RGBController_LianLiUniHub(controller);
|
||||
ResourceManager::get()->RegisterRGBController(rgb_controller);
|
||||
}
|
||||
}
|
||||
|
||||
if(devices != nullptr)
|
||||
{
|
||||
libusb_free_device_list(devices, 1);
|
||||
}
|
||||
}
|
||||
|
||||
void DetectLianLiUniHub_AL10()
|
||||
{
|
||||
libusb_device** devices = nullptr;
|
||||
|
||||
ssize_t ret;
|
||||
|
||||
ret = libusb_init(NULL);
|
||||
if(ret < 0)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
ret = libusb_get_device_list(NULL, &devices);
|
||||
if(ret < 0)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
ssize_t deviceCount = ret;
|
||||
|
||||
for(int i = 0; i < deviceCount; i++)
|
||||
{
|
||||
libusb_device* device = devices[i];
|
||||
libusb_device_descriptor descriptor;
|
||||
ret = libusb_get_device_descriptor(device, &descriptor);
|
||||
|
||||
if(ret < 0)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
if( descriptor.idVendor == ENE_USB_VID
|
||||
&& descriptor.idProduct == UNI_HUB_AL_PID)
|
||||
{
|
||||
LianLiUniHub_AL10Controller* controller = new LianLiUniHub_AL10Controller(device, &descriptor);
|
||||
RGBController_LianLiUniHub_AL10* rgb_controller = new RGBController_LianLiUniHub_AL10(controller);
|
||||
ResourceManager::get()->RegisterRGBController(rgb_controller);
|
||||
}
|
||||
}
|
||||
|
||||
if(devices != nullptr)
|
||||
{
|
||||
libusb_free_device_list(devices, 1);
|
||||
}
|
||||
} /* DetectLianLiUniHub_AL10() */
|
||||
|
||||
void DetectLianLiUniHubSL(hid_device_info* info, const std::string& name)
|
||||
{
|
||||
hid_device* device = hid_open_path(info->path);
|
||||
if (!device)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
LianLiUniHubSLController* controller = new LianLiUniHubSLController(device, info->path);
|
||||
std::string version = controller->ReadVersion();
|
||||
|
||||
if (version != "v1.8")
|
||||
{
|
||||
delete controller;
|
||||
return;
|
||||
}
|
||||
|
||||
RGBController_LianLiUniHubSL* rgb_controller = new RGBController_LianLiUniHubSL(controller, name);
|
||||
ResourceManager::get()->RegisterRGBController(rgb_controller);
|
||||
} /* DetectLianLiUniHubSL() */
|
||||
|
||||
void DetectLianLiUniHubAL(hid_device_info* info, const std::string& name)
|
||||
{
|
||||
hid_device* dev = hid_open_path(info->path);
|
||||
|
||||
if(dev)
|
||||
{
|
||||
LianLiUniHubALController* controller = new LianLiUniHubALController(dev, info->path, info->product_id, name);
|
||||
|
||||
std::string firmwareVersion = controller->GetFirmwareVersionString();
|
||||
|
||||
if(firmwareVersion == "v1.7")
|
||||
{
|
||||
RGBController_LianLiUniHubAL* rgb_controller = new RGBController_LianLiUniHubAL(controller);
|
||||
ResourceManager::get()->RegisterRGBController(rgb_controller);
|
||||
}
|
||||
else if(firmwareVersion == "v1.0")
|
||||
{
|
||||
delete controller;
|
||||
REGISTER_DETECTOR("Lian Li Uni Hub - AL", DetectLianLiUniHub_AL10);
|
||||
}
|
||||
else
|
||||
{
|
||||
delete controller;
|
||||
return;
|
||||
}
|
||||
|
||||
}
|
||||
} /* DetectLianLiUniHubAL() */
|
||||
|
||||
void DetectLianLiUniHubSLV2(hid_device_info* info, const std::string& name)
|
||||
{
|
||||
hid_device* dev = hid_open_path(info->path);
|
||||
|
||||
if(dev)
|
||||
{
|
||||
LianLiUniHubSLV2Controller* controller = new LianLiUniHubSLV2Controller(dev, info->path, name);
|
||||
|
||||
RGBController_LianLiUniHubSLV2* rgb_controller = new RGBController_LianLiUniHubSLV2(controller);
|
||||
ResourceManager::get()->RegisterRGBController(rgb_controller);
|
||||
}
|
||||
} /* DetectLianLiUniHubSLV2() */
|
||||
|
||||
void DetectLianLiUniHubSLInfinity(hid_device_info* info, const std::string& name)
|
||||
{
|
||||
hid_device* dev = hid_open_path(info->path);
|
||||
|
||||
if(dev)
|
||||
{
|
||||
LianLiUniHubSLInfinityController* controller = new LianLiUniHubSLInfinityController(dev, info->path, name);
|
||||
|
||||
RGBController_LianLiUniHubSLInfinity* rgb_controller = new RGBController_LianLiUniHubSLInfinity(controller);
|
||||
ResourceManager::get()->RegisterRGBController(rgb_controller);
|
||||
}
|
||||
} /* DetectLianLiUniHubSLInfinity() */
|
||||
|
||||
void DetectLianLiStrimerControllers(hid_device_info* info, const std::string& /*name*/)
|
||||
{
|
||||
hid_device* dev = hid_open_path(info->path);
|
||||
|
||||
if(dev)
|
||||
{
|
||||
LianLiStrimerLConnectController* controller = new LianLiStrimerLConnectController(dev, info->path);
|
||||
RGBController_LianLiStrimerLConnect* rgb_controller = new RGBController_LianLiStrimerLConnect(controller);
|
||||
|
||||
ResourceManager::get()->RegisterRGBController(rgb_controller);
|
||||
}
|
||||
}
|
||||
|
||||
void DetectLianLiGAIITrinity(hid_device_info* info, const std::string& /*name*/)
|
||||
{
|
||||
hid_device* dev = hid_open_path(info->path);
|
||||
|
||||
if(dev)
|
||||
{
|
||||
LianLiGAIITrinityController* controller = new LianLiGAIITrinityController(dev, info->path);
|
||||
RGBController_LianLiGAIITrinity* rgb_controller = new RGBController_LianLiGAIITrinity(controller);
|
||||
|
||||
ResourceManager::get()->RegisterRGBController(rgb_controller);
|
||||
}
|
||||
}
|
||||
|
||||
void DetectLianLiUniversalScreen()
|
||||
{
|
||||
libusb_init(NULL);
|
||||
|
||||
#ifdef _WIN32
|
||||
libusb_set_option(NULL, LIBUSB_OPTION_USE_USBDK);
|
||||
#endif
|
||||
|
||||
libusb_device_handle * dev = libusb_open_device_with_vid_pid(NULL, NUVOTON_USB_VID, UNIVERSAL_SCREEN_LED_PID);
|
||||
|
||||
if(dev)
|
||||
{
|
||||
libusb_detach_kernel_driver(dev, 0);
|
||||
libusb_claim_interface(dev, 0);
|
||||
|
||||
LianLiUniversalScreenController* controller = new LianLiUniversalScreenController(dev);
|
||||
RGBController_LianLiUniversalScreen* rgb_controller = new RGBController_LianLiUniversalScreen(controller);
|
||||
|
||||
ResourceManager::get()->RegisterRGBController(rgb_controller);
|
||||
}
|
||||
}
|
||||
|
||||
/*---------------------------------------------------------------------------------------------------------*\
|
||||
| Entries for dynamic UDEV rules for libusb devices |
|
||||
| |
|
||||
| DUMMY_DEVICE_DETECTOR("Lian Li Uni Hub", DetectLianLiUniHub, 0x0CF2, 0x7750 ) |
|
||||
| DUMMY_DEVICE_DETECTOR("Lian Li Universal Screen", DetectLianLiUniversalScreen, 0x0416, 0x8050 ) |
|
||||
\*---------------------------------------------------------------------------------------------------------*/
|
||||
REGISTER_DETECTOR("Lian Li Uni Hub", DetectLianLiUniHub);
|
||||
REGISTER_DETECTOR("Lian Li Universal Screen", DetectLianLiUniversalScreen);
|
||||
|
||||
REGISTER_HID_DETECTOR_IPU("Lian Li Uni Hub - SL", DetectLianLiUniHubSL, ENE_USB_VID, UNI_HUB_SL_PID, 0x01, 0xFF72, 0xA1);
|
||||
REGISTER_HID_DETECTOR_IPU("Lian Li Uni Hub - AL", DetectLianLiUniHubAL, ENE_USB_VID, UNI_HUB_AL_PID, 0x01, 0xFF72, 0xA1);
|
||||
REGISTER_HID_DETECTOR_IPU("Lian Li Uni Hub - SL V2", DetectLianLiUniHubSLV2, ENE_USB_VID, UNI_HUB_SLV2_PID, 0x01, 0xFF72, 0xA1);
|
||||
REGISTER_HID_DETECTOR_IPU("Lian Li Uni Hub - AL V2", DetectLianLiUniHubSLV2, ENE_USB_VID, UNI_HUB_ALV2_PID, 0x01, 0xFF72, 0xA1);
|
||||
REGISTER_HID_DETECTOR_IPU("Lian Li Uni Hub - SL V2 v0.5", DetectLianLiUniHubSLV2, ENE_USB_VID, UNI_HUB_SLV2_V05_PID, 0x01, 0xFF72, 0xA1);
|
||||
REGISTER_HID_DETECTOR_IPU("Lian Li Uni Hub - SL Infinity", DetectLianLiUniHubSLInfinity, ENE_USB_VID, UNI_HUB_SLINF_PID, 0x01, 0xFF72, 0xA1);
|
||||
REGISTER_HID_DETECTOR_IPU("Lian Li Strimer L Connect", DetectLianLiStrimerControllers, ENE_USB_VID, STRIMER_L_CONNECT_PID, 1, 0xFF72, 0xA1);
|
||||
REGISTER_HID_DETECTOR_I("Lian Li GA II Trinity", DetectLianLiGAIITrinity, NUVOTON_USB_VID, GAII_USB_PID, 0x02);
|
||||
REGISTER_HID_DETECTOR_I("Lian Li GA II Trinity Performance", DetectLianLiGAIITrinity, NUVOTON_USB_VID, GAII_Perf_USB_PID, 0x02);
|
||||
+306
@@ -0,0 +1,306 @@
|
||||
/*---------------------------------------------------------*\
|
||||
| LianLiGAIITrinityController.cpp |
|
||||
| |
|
||||
| Driver for Lian Li GAII Trinity |
|
||||
| |
|
||||
| Michael Losert 27 Oct 2023 |
|
||||
| |
|
||||
| This file is part of the OpenRGB project |
|
||||
| SPDX-License-Identifier: GPL-2.0-or-later |
|
||||
\*---------------------------------------------------------*/
|
||||
|
||||
#include <algorithm>
|
||||
#include <cstring>
|
||||
#include <iomanip>
|
||||
#include <sstream>
|
||||
#include "LianLiGAIITrinityController.h"
|
||||
#include "StringUtils.h"
|
||||
|
||||
LianLiGAIITrinityController::LianLiGAIITrinityController(hid_device* dev_handle, char* path)
|
||||
{
|
||||
dev = dev_handle;
|
||||
location = path;
|
||||
}
|
||||
|
||||
LianLiGAIITrinityController::~LianLiGAIITrinityController()
|
||||
{
|
||||
if(dev)
|
||||
{
|
||||
hid_close(dev);
|
||||
}
|
||||
}
|
||||
|
||||
std::string LianLiGAIITrinityController::GetLocation()
|
||||
{
|
||||
return("HID: " + location);
|
||||
}
|
||||
|
||||
LianLiGAIITrinityController::GAII_Info LianLiGAIITrinityController::GetControllerInfo()
|
||||
{
|
||||
GAII_Info controllerInfo;
|
||||
|
||||
// get serial number
|
||||
const uint8_t sz = 255;
|
||||
wchar_t tmp[sz];
|
||||
|
||||
hid_get_serial_number_string(dev, tmp, sz);
|
||||
controllerInfo.serial = StringUtils::wstring_to_string(tmp);
|
||||
|
||||
// get firmware version
|
||||
unsigned char data[64] = "";
|
||||
data[0x00] = 0x01;
|
||||
data[GAII_ByteAddress::BA_PACKET_TYPE] = GAII_PacketType::PT_FIRMWARE_INFO;
|
||||
hid_write(dev, data, sizeof(data));
|
||||
memset(data, 0, sizeof(data));
|
||||
hid_read(dev, data, sizeof(data));
|
||||
data[sizeof(data) - 1] = 0;
|
||||
std::string response(reinterpret_cast<char*>(&data[0x06]));
|
||||
memset(data, 0, sizeof(data));
|
||||
hid_read(dev, data, sizeof(data));
|
||||
data[sizeof(data) - 1] = 0;
|
||||
response += " (" + std::string(reinterpret_cast<char*>(&data[0x06])) + ")";
|
||||
std::replace( response.begin(), response.end(), ',', ' ');
|
||||
controllerInfo.version = response.substr(0, 100);
|
||||
|
||||
return controllerInfo;
|
||||
}
|
||||
|
||||
unsigned char* LianLiGAIITrinityController::GetRGBControlPacketTemplate()
|
||||
{
|
||||
static unsigned char usb_buf[64];
|
||||
memset(usb_buf, 0, sizeof(usb_buf));
|
||||
|
||||
usb_buf[0x00] = 0x01;
|
||||
usb_buf[GAII_ByteAddress::BA_PACKET_TYPE] = GAII_PacketType::PT_RGB_CONTROL;
|
||||
usb_buf[0x05] = 0x13;
|
||||
|
||||
return usb_buf;
|
||||
}
|
||||
|
||||
void LianLiGAIITrinityController::SetRGB(unsigned char* usb_buf, RGBColor* rgb0, RGBColor* rgb1, RGBColor* rgb2, RGBColor* rgb3)
|
||||
{
|
||||
if(rgb0)
|
||||
{
|
||||
usb_buf[GAII_ByteAddress::BA_R0] = RGBGetRValue(*rgb0);
|
||||
usb_buf[GAII_ByteAddress::BA_G0] = RGBGetGValue(*rgb0);
|
||||
usb_buf[GAII_ByteAddress::BA_B0] = RGBGetBValue(*rgb0);
|
||||
}
|
||||
|
||||
if(rgb1)
|
||||
{
|
||||
usb_buf[GAII_ByteAddress::BA_R1] = RGBGetRValue(*rgb1);
|
||||
usb_buf[GAII_ByteAddress::BA_G1] = RGBGetGValue(*rgb1);
|
||||
usb_buf[GAII_ByteAddress::BA_B1] = RGBGetBValue(*rgb1);
|
||||
}
|
||||
|
||||
if(rgb2)
|
||||
{
|
||||
usb_buf[GAII_ByteAddress::BA_R2] = RGBGetRValue(*rgb2);
|
||||
usb_buf[GAII_ByteAddress::BA_G2] = RGBGetGValue(*rgb2);
|
||||
usb_buf[GAII_ByteAddress::BA_B2] = RGBGetBValue(*rgb2);
|
||||
}
|
||||
|
||||
if(rgb3)
|
||||
{
|
||||
usb_buf[GAII_ByteAddress::BA_R3] = RGBGetRValue(*rgb3);
|
||||
usb_buf[GAII_ByteAddress::BA_G3] = RGBGetGValue(*rgb3);
|
||||
usb_buf[GAII_ByteAddress::BA_B3] = RGBGetBValue(*rgb3);
|
||||
}
|
||||
}
|
||||
|
||||
void LianLiGAIITrinityController::SetMode_Rainbow(GAII_Brightness brightness, GAII_Speed speed, GAII_Direction direction)
|
||||
{
|
||||
unsigned char *usb_buf = GetRGBControlPacketTemplate();
|
||||
|
||||
usb_buf[GAII_ByteAddress::BA_MODE] = GAII_Modes::M_RAINBOW;
|
||||
usb_buf[GAII_ByteAddress::BA_RING] = GAII_Ring::R_BOTH;
|
||||
usb_buf[GAII_ByteAddress::BA_BRIGHTNESS] = brightness;
|
||||
usb_buf[GAII_ByteAddress::BA_SPEED] = speed;
|
||||
usb_buf[GAII_ByteAddress::BA_DIRECTION] = direction;
|
||||
|
||||
hid_write(dev, usb_buf, 64);
|
||||
}
|
||||
|
||||
void LianLiGAIITrinityController::SetMode_RainbowMorph(GAII_Brightness brightness, GAII_Speed speed)
|
||||
{
|
||||
unsigned char *usb_buf = GetRGBControlPacketTemplate();
|
||||
|
||||
usb_buf[GAII_ByteAddress::BA_MODE] = GAII_Modes::M_RAINBOW_MORPH;
|
||||
usb_buf[GAII_ByteAddress::BA_RING] = GAII_Ring::R_BOTH;
|
||||
usb_buf[GAII_ByteAddress::BA_BRIGHTNESS] = brightness;
|
||||
usb_buf[GAII_ByteAddress::BA_SPEED] = speed;
|
||||
|
||||
hid_write(dev, usb_buf, 64);
|
||||
}
|
||||
|
||||
void LianLiGAIITrinityController::SetMode_StaticColor(GAII_Brightness brightness, RGBColor rgb0, RGBColor rgb1)
|
||||
{
|
||||
unsigned char *usb_buf = GetRGBControlPacketTemplate();
|
||||
|
||||
usb_buf[GAII_ByteAddress::BA_MODE] = GAII_Modes::M_STATIC_COLOR;
|
||||
usb_buf[GAII_ByteAddress::BA_RING] = GAII_Ring::R_BOTH;
|
||||
usb_buf[GAII_ByteAddress::BA_BRIGHTNESS] = brightness;
|
||||
SetRGB(usb_buf, rgb0, rgb1);
|
||||
|
||||
hid_write(dev, usb_buf, 64);
|
||||
}
|
||||
|
||||
void LianLiGAIITrinityController::SetMode_BreathingColor(GAII_Brightness brightness, GAII_Speed speed, RGBColor rgb0, RGBColor rgb1)
|
||||
{
|
||||
unsigned char *usb_buf = GetRGBControlPacketTemplate();
|
||||
|
||||
usb_buf[GAII_ByteAddress::BA_MODE] = GAII_Modes::M_BREATHING_COLOR;
|
||||
usb_buf[GAII_ByteAddress::BA_RING] = GAII_Ring::R_BOTH;
|
||||
usb_buf[GAII_ByteAddress::BA_BRIGHTNESS] = brightness;
|
||||
usb_buf[GAII_ByteAddress::BA_SPEED] = speed;
|
||||
SetRGB(usb_buf, rgb0, rgb1);
|
||||
|
||||
hid_write(dev, usb_buf, 64);
|
||||
}
|
||||
|
||||
void LianLiGAIITrinityController::SetMode_Runway(GAII_Brightness brightness, GAII_Speed speed, RGBColor rgb0, RGBColor rgb1)
|
||||
{
|
||||
unsigned char *usb_buf = GetRGBControlPacketTemplate();
|
||||
|
||||
usb_buf[GAII_ByteAddress::BA_MODE] = GAII_Modes::M_RUNWAY;
|
||||
usb_buf[GAII_ByteAddress::BA_RING] = GAII_Ring::R_BOTH;
|
||||
usb_buf[GAII_ByteAddress::BA_BRIGHTNESS] = brightness;
|
||||
usb_buf[GAII_ByteAddress::BA_SPEED] = speed;
|
||||
SetRGB(usb_buf, rgb0, rgb1);
|
||||
|
||||
hid_write(dev, usb_buf, 64);
|
||||
}
|
||||
|
||||
void LianLiGAIITrinityController::SetMode_Meteor(GAII_Brightness brightness, GAII_Speed speed, GAII_Direction direction, RGBColor rgb0, RGBColor rgb1, RGBColor rgb2, RGBColor rgb3)
|
||||
{
|
||||
unsigned char *usb_buf = GetRGBControlPacketTemplate();
|
||||
|
||||
usb_buf[GAII_ByteAddress::BA_MODE] = GAII_Modes::M_METEOR;
|
||||
usb_buf[GAII_ByteAddress::BA_RING] = GAII_Ring::R_BOTH;
|
||||
usb_buf[GAII_ByteAddress::BA_BRIGHTNESS] = brightness;
|
||||
usb_buf[GAII_ByteAddress::BA_SPEED] = speed;
|
||||
usb_buf[GAII_ByteAddress::BA_DIRECTION] = direction;
|
||||
SetRGB(usb_buf, rgb0, rgb1, rgb2, rgb3);
|
||||
|
||||
hid_write(dev, usb_buf, 64);
|
||||
}
|
||||
|
||||
void LianLiGAIITrinityController::SetMode_Vortex(GAII_Brightness brightness, GAII_Speed speed, GAII_Direction direction, RGBColor rgb0, RGBColor rgb1, RGBColor rgb2, RGBColor rgb3)
|
||||
{
|
||||
unsigned char *usb_buf = GetRGBControlPacketTemplate();
|
||||
|
||||
usb_buf[GAII_ByteAddress::BA_MODE] = GAII_Modes::M_VORTEX;
|
||||
usb_buf[GAII_ByteAddress::BA_RING] = GAII_Ring::R_BOTH;
|
||||
usb_buf[GAII_ByteAddress::BA_BRIGHTNESS] = brightness;
|
||||
usb_buf[GAII_ByteAddress::BA_SPEED] = speed;
|
||||
usb_buf[GAII_ByteAddress::BA_DIRECTION] = direction;
|
||||
SetRGB(usb_buf, rgb0, rgb1, rgb2, rgb3);
|
||||
|
||||
hid_write(dev, usb_buf, 64);
|
||||
}
|
||||
|
||||
void LianLiGAIITrinityController::SetMode_CrossingOver(GAII_Brightness brightness, GAII_Speed speed, GAII_Direction direction, RGBColor rgb0, RGBColor rgb1, RGBColor rgb2, RGBColor rgb3)
|
||||
{
|
||||
unsigned char *usb_buf = GetRGBControlPacketTemplate();
|
||||
|
||||
usb_buf[GAII_ByteAddress::BA_MODE] = GAII_Modes::M_CROSSING_OVER;
|
||||
usb_buf[GAII_ByteAddress::BA_RING] = GAII_Ring::R_BOTH;
|
||||
usb_buf[GAII_ByteAddress::BA_BRIGHTNESS] = brightness;
|
||||
usb_buf[GAII_ByteAddress::BA_SPEED] = speed;
|
||||
usb_buf[GAII_ByteAddress::BA_DIRECTION] = direction;
|
||||
SetRGB(usb_buf, rgb0, rgb1, rgb2, rgb3);
|
||||
|
||||
hid_write(dev, usb_buf, 64);
|
||||
}
|
||||
|
||||
void LianLiGAIITrinityController::SetMode_TaiChi(GAII_Brightness brightness, GAII_Speed speed, GAII_Direction direction, RGBColor rgb0, RGBColor rgb1)
|
||||
{
|
||||
unsigned char *usb_buf = GetRGBControlPacketTemplate();
|
||||
|
||||
usb_buf[GAII_ByteAddress::BA_MODE] = GAII_Modes::M_TAI_CHI;
|
||||
usb_buf[GAII_ByteAddress::BA_RING] = GAII_Ring::R_BOTH;
|
||||
usb_buf[GAII_ByteAddress::BA_BRIGHTNESS] = brightness;
|
||||
usb_buf[GAII_ByteAddress::BA_SPEED] = speed;
|
||||
usb_buf[GAII_ByteAddress::BA_DIRECTION] = direction;
|
||||
SetRGB(usb_buf, rgb0, rgb1);
|
||||
|
||||
hid_write(dev, usb_buf, 64);
|
||||
}
|
||||
|
||||
void LianLiGAIITrinityController::SetMode_ColorfulStarryNight(GAII_Brightness brightness, GAII_Speed speed)
|
||||
{
|
||||
unsigned char *usb_buf = GetRGBControlPacketTemplate();
|
||||
|
||||
usb_buf[GAII_ByteAddress::BA_MODE] = GAII_Modes::M_COLORFUL_STARRY_NIGHT;
|
||||
usb_buf[GAII_ByteAddress::BA_RING] = GAII_Ring::R_BOTH;
|
||||
usb_buf[GAII_ByteAddress::BA_BRIGHTNESS] = brightness;
|
||||
usb_buf[GAII_ByteAddress::BA_SPEED] = speed;
|
||||
|
||||
hid_write(dev, usb_buf, 64);
|
||||
}
|
||||
|
||||
void LianLiGAIITrinityController::SetMode_StaticStarryNight(GAII_Brightness brightness, GAII_Speed speed, RGBColor rgb0)
|
||||
{
|
||||
unsigned char *usb_buf = GetRGBControlPacketTemplate();
|
||||
|
||||
usb_buf[GAII_ByteAddress::BA_MODE] = GAII_Modes::M_STATIC_STARRY_NIGHT;
|
||||
usb_buf[GAII_ByteAddress::BA_RING] = GAII_Ring::R_BOTH;
|
||||
usb_buf[GAII_ByteAddress::BA_BRIGHTNESS] = brightness;
|
||||
usb_buf[GAII_ByteAddress::BA_SPEED] = speed;
|
||||
SetRGB(usb_buf, rgb0);
|
||||
|
||||
hid_write(dev, usb_buf, 64);
|
||||
}
|
||||
|
||||
void LianLiGAIITrinityController::SetMode_Voice(GAII_Brightness brightness, GAII_Speed speed, RGBColor rgb0, RGBColor rgb1)
|
||||
{
|
||||
unsigned char *usb_buf = GetRGBControlPacketTemplate();
|
||||
|
||||
usb_buf[GAII_ByteAddress::BA_MODE] = GAII_Modes::M_VOICE;
|
||||
usb_buf[GAII_ByteAddress::BA_RING] = GAII_Ring::R_BOTH;
|
||||
usb_buf[GAII_ByteAddress::BA_BRIGHTNESS] = brightness;
|
||||
usb_buf[GAII_ByteAddress::BA_SPEED] = speed;
|
||||
SetRGB(usb_buf, rgb0, rgb1);
|
||||
|
||||
hid_write(dev, usb_buf, 64);
|
||||
}
|
||||
|
||||
void LianLiGAIITrinityController::SetMode_BigBang(GAII_Brightness brightness, GAII_Speed speed, RGBColor rgb0, RGBColor rgb1, RGBColor rgb2, RGBColor rgb3)
|
||||
{
|
||||
unsigned char *usb_buf = GetRGBControlPacketTemplate();
|
||||
|
||||
usb_buf[GAII_ByteAddress::BA_MODE] = GAII_Modes::M_BIG_BANG;
|
||||
usb_buf[GAII_ByteAddress::BA_RING] = GAII_Ring::R_BOTH;
|
||||
usb_buf[GAII_ByteAddress::BA_BRIGHTNESS] = brightness;
|
||||
usb_buf[GAII_ByteAddress::BA_SPEED] = speed;
|
||||
SetRGB(usb_buf, rgb0, rgb1, rgb2, rgb3);
|
||||
|
||||
hid_write(dev, usb_buf, 64);
|
||||
}
|
||||
|
||||
void LianLiGAIITrinityController::SetMode_Pump(GAII_Brightness brightness, GAII_Speed speed, GAII_Direction direction, RGBColor rgb0, RGBColor rgb1)
|
||||
{
|
||||
unsigned char *usb_buf = GetRGBControlPacketTemplate();
|
||||
|
||||
usb_buf[GAII_ByteAddress::BA_MODE] = GAII_Modes::M_PUMP;
|
||||
usb_buf[GAII_ByteAddress::BA_RING] = GAII_Ring::R_BOTH;
|
||||
usb_buf[GAII_ByteAddress::BA_BRIGHTNESS] = brightness;
|
||||
usb_buf[GAII_ByteAddress::BA_SPEED] = speed;
|
||||
usb_buf[GAII_ByteAddress::BA_DIRECTION] = direction;
|
||||
SetRGB(usb_buf, rgb0, rgb1);
|
||||
|
||||
hid_write(dev, usb_buf, 64);
|
||||
}
|
||||
|
||||
void LianLiGAIITrinityController::SetMode_ColorsMorph(GAII_Brightness brightness, GAII_Speed speed, GAII_Direction direction)
|
||||
{
|
||||
unsigned char *usb_buf = GetRGBControlPacketTemplate();
|
||||
|
||||
usb_buf[GAII_ByteAddress::BA_MODE] = GAII_Modes::M_COLORS_MORPH;
|
||||
usb_buf[GAII_ByteAddress::BA_RING] = GAII_Ring::R_BOTH;
|
||||
usb_buf[GAII_ByteAddress::BA_BRIGHTNESS] = brightness;
|
||||
usb_buf[GAII_ByteAddress::BA_SPEED] = speed;
|
||||
usb_buf[GAII_ByteAddress::BA_DIRECTION] = direction;
|
||||
|
||||
hid_write(dev, usb_buf, 64);
|
||||
}
|
||||
+147
@@ -0,0 +1,147 @@
|
||||
/*---------------------------------------------------------*\
|
||||
| LianLiGAIITrinityController.h |
|
||||
| |
|
||||
| Driver for Lian Li GAII Trinity |
|
||||
| |
|
||||
| Michael Losert 27 Oct 2023 |
|
||||
| |
|
||||
| This file is part of the OpenRGB project |
|
||||
| SPDX-License-Identifier: GPL-2.0-or-later |
|
||||
\*---------------------------------------------------------*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <string>
|
||||
#include <vector>
|
||||
#include <hidapi.h>
|
||||
#include "RGBController.h"
|
||||
|
||||
/*----------------------------------------------------------------------------*\
|
||||
| Definitions related to LED configuration. |
|
||||
\*----------------------------------------------------------------------------*/
|
||||
|
||||
class LianLiGAIITrinityController
|
||||
{
|
||||
public:
|
||||
struct GAII_Info
|
||||
{
|
||||
std::string serial;
|
||||
std::string version;
|
||||
};
|
||||
|
||||
enum GAII_PacketType : unsigned char
|
||||
{
|
||||
PT_RGB_CONTROL = 0x83,
|
||||
PT_FIRMWARE_INFO = 0x86
|
||||
};
|
||||
|
||||
enum GAII_Modes : unsigned char
|
||||
{
|
||||
M_RAINBOW = 0x01,
|
||||
M_RAINBOW_MORPH,
|
||||
M_STATIC_COLOR,
|
||||
M_BREATHING_COLOR,
|
||||
M_RUNWAY,
|
||||
M_METEOR,
|
||||
M_VORTEX,
|
||||
M_CROSSING_OVER,
|
||||
M_TAI_CHI,
|
||||
M_COLORFUL_STARRY_NIGHT,
|
||||
M_STATIC_STARRY_NIGHT,
|
||||
M_VOICE,
|
||||
M_BIG_BANG,
|
||||
M_PUMP,
|
||||
M_COLORS_MORPH,
|
||||
/* M_BOUNCE, */ // TODO: requires zone-specific modes
|
||||
};
|
||||
|
||||
enum GAII_Ring : unsigned char
|
||||
{
|
||||
R_INNER,
|
||||
R_OUTER,
|
||||
R_BOTH,
|
||||
};
|
||||
|
||||
enum GAII_Brightness : unsigned char
|
||||
{
|
||||
B_OFF,
|
||||
B_25,
|
||||
B_50,
|
||||
B_75,
|
||||
B_100,
|
||||
};
|
||||
|
||||
enum GAII_Speed : unsigned char
|
||||
{
|
||||
S_VERY_SLOW,
|
||||
S_SLOW,
|
||||
S_MODERATE,
|
||||
S_FAST,
|
||||
S_VERY_FAST,
|
||||
};
|
||||
|
||||
enum GAII_Direction : unsigned char
|
||||
{
|
||||
D_RIGHT,
|
||||
D_LEFT
|
||||
};
|
||||
|
||||
enum GAII_ByteAddress : unsigned char
|
||||
{
|
||||
BA_PACKET_TYPE = 0x01,
|
||||
|
||||
BA_RING = 0x06,
|
||||
BA_MODE,
|
||||
BA_BRIGHTNESS,
|
||||
BA_SPEED,
|
||||
|
||||
BA_R0 = 0x0A,
|
||||
BA_G0,
|
||||
BA_B0,
|
||||
BA_R1,
|
||||
BA_G1,
|
||||
BA_B1,
|
||||
BA_R2,
|
||||
BA_G2,
|
||||
BA_B2,
|
||||
BA_R3,
|
||||
BA_G3,
|
||||
BA_B3,
|
||||
|
||||
BA_DIRECTION = 0x16,
|
||||
};
|
||||
|
||||
LianLiGAIITrinityController(hid_device* dev_handle, char* path);
|
||||
~LianLiGAIITrinityController();
|
||||
|
||||
std::string GetLocation();
|
||||
|
||||
GAII_Info GetControllerInfo();
|
||||
|
||||
void SetMode_Rainbow(GAII_Brightness brightness, GAII_Speed speed, GAII_Direction direction);
|
||||
void SetMode_RainbowMorph(GAII_Brightness brightness, GAII_Speed speed);
|
||||
void SetMode_StaticColor(GAII_Brightness brightness, RGBColor rgb0, RGBColor rgb1);
|
||||
void SetMode_BreathingColor(GAII_Brightness brightness, GAII_Speed speed, RGBColor rgb0, RGBColor rgb1);
|
||||
void SetMode_Runway(GAII_Brightness brightness, GAII_Speed speed, RGBColor rgb0, RGBColor rgb1);
|
||||
void SetMode_Meteor(GAII_Brightness brightness, GAII_Speed speed, GAII_Direction direction, RGBColor rgb0, RGBColor rgb1, RGBColor rgb2, RGBColor rgb3);
|
||||
void SetMode_Vortex(GAII_Brightness brightness, GAII_Speed speed, GAII_Direction direction, RGBColor rgb0, RGBColor rgb1, RGBColor rgb2, RGBColor rgb3);
|
||||
void SetMode_CrossingOver(GAII_Brightness brightness, GAII_Speed speed, GAII_Direction direction, RGBColor rgb0, RGBColor rgb1, RGBColor rgb2, RGBColor rgb3);
|
||||
void SetMode_TaiChi(GAII_Brightness brightness, GAII_Speed speed, GAII_Direction direction, RGBColor rgb0, RGBColor rgb1);
|
||||
void SetMode_ColorfulStarryNight(GAII_Brightness brightness, GAII_Speed speed);
|
||||
void SetMode_StaticStarryNight(GAII_Brightness brightness, GAII_Speed speed, RGBColor rgb0);
|
||||
void SetMode_Voice(GAII_Brightness brightness, GAII_Speed speed, RGBColor rgb0, RGBColor rgb1);
|
||||
void SetMode_BigBang(GAII_Brightness brightness, GAII_Speed speed, RGBColor rgb0, RGBColor rgb1, RGBColor rgb2, RGBColor rgb3);
|
||||
void SetMode_Pump(GAII_Brightness brightness, GAII_Speed speed, GAII_Direction direction, RGBColor rgb0, RGBColor rgb1);
|
||||
void SetMode_ColorsMorph(GAII_Brightness brightness, GAII_Speed speed, GAII_Direction direction);
|
||||
|
||||
private:
|
||||
std::string location;
|
||||
unsigned char* GetRGBControlPacketTemplate();
|
||||
void SetRGB(unsigned char* usb_buf, RGBColor rgb0) { SetRGB(usb_buf, &rgb0, nullptr, nullptr, nullptr); };
|
||||
void SetRGB(unsigned char* usb_buf, RGBColor rgb0, RGBColor rgb1) { SetRGB(usb_buf, &rgb0, &rgb1, nullptr, nullptr); };
|
||||
void SetRGB(unsigned char* usb_buf, RGBColor rgb0, RGBColor rgb1, RGBColor rgb2) { SetRGB(usb_buf, &rgb0, &rgb1, &rgb2, nullptr); };
|
||||
void SetRGB(unsigned char* usb_buf, RGBColor rgb0, RGBColor rgb1, RGBColor rgb2, RGBColor rgb3) { SetRGB(usb_buf, &rgb0, &rgb1, &rgb2, &rgb3); };
|
||||
void SetRGB(unsigned char* usb_buf, RGBColor* rgb0, RGBColor* rgb1, RGBColor* rgb2, RGBColor* rgb3);
|
||||
|
||||
hid_device* dev;
|
||||
};
|
||||
+418
@@ -0,0 +1,418 @@
|
||||
/*---------------------------------------------------------*\
|
||||
| RGBController_LianLiGAIITrinity.cpp |
|
||||
| |
|
||||
| RGBController for Lian Li GAII Trinity |
|
||||
| |
|
||||
| Michael Losert 27 Oct 2023 |
|
||||
| |
|
||||
| This file is part of the OpenRGB project |
|
||||
| SPDX-License-Identifier: GPL-2.0-or-later |
|
||||
\*---------------------------------------------------------*/
|
||||
|
||||
#include <string>
|
||||
#include "RGBController_LianLiGAIITrinity.h"
|
||||
|
||||
/**------------------------------------------------------------------*\
|
||||
@name Lian Li GAII Trinity
|
||||
@type USB
|
||||
@save :x:
|
||||
@direct :white_check_mark:
|
||||
@effects :white_check_mark:
|
||||
@detectors DetectLianLiGAIITrinity
|
||||
@comment
|
||||
\*-------------------------------------------------------------------*/
|
||||
|
||||
RGBController_LianLiGAIITrinity::RGBController_LianLiGAIITrinity(LianLiGAIITrinityController* controller_ptr)
|
||||
{
|
||||
controller = controller_ptr;
|
||||
|
||||
name = "Lian Li GAII Trinity";
|
||||
vendor = "Lian Li";
|
||||
type = DEVICE_TYPE_COOLER;
|
||||
description = "Lian Li Galahad II Trinity AIO";
|
||||
location = controller->GetLocation();
|
||||
|
||||
LianLiGAIITrinityController::GAII_Info controllerInfo = controller->GetControllerInfo();
|
||||
version = controllerInfo.version;
|
||||
serial = controllerInfo.serial;
|
||||
|
||||
mode Rainbow;
|
||||
Rainbow.name = "Rainbow";
|
||||
Rainbow.value = LianLiGAIITrinityController::GAII_Modes::M_RAINBOW;
|
||||
Rainbow.flags = MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
|
||||
Rainbow.color_mode = MODE_COLORS_RANDOM;
|
||||
Rainbow.brightness_min = LianLiGAIITrinityController::GAII_Brightness::B_OFF;
|
||||
Rainbow.brightness_max = LianLiGAIITrinityController::GAII_Brightness::B_100;
|
||||
Rainbow.brightness = LianLiGAIITrinityController::GAII_Brightness::B_75;
|
||||
Rainbow.speed_min = LianLiGAIITrinityController::GAII_Speed::S_VERY_SLOW;
|
||||
Rainbow.speed_max = LianLiGAIITrinityController::GAII_Speed::S_VERY_FAST;
|
||||
Rainbow.speed = LianLiGAIITrinityController::GAII_Speed::S_FAST;
|
||||
Rainbow.direction = MODE_DIRECTION_RIGHT;
|
||||
modes.push_back(Rainbow);
|
||||
|
||||
mode RainbowMorph;
|
||||
RainbowMorph.name = "Rainbow Morph";
|
||||
RainbowMorph.value = LianLiGAIITrinityController::GAII_Modes::M_RAINBOW_MORPH;
|
||||
RainbowMorph.flags = MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
|
||||
RainbowMorph.color_mode = MODE_COLORS_RANDOM;
|
||||
RainbowMorph.brightness_min = LianLiGAIITrinityController::GAII_Brightness::B_OFF;
|
||||
RainbowMorph.brightness_max = LianLiGAIITrinityController::GAII_Brightness::B_100;
|
||||
RainbowMorph.brightness = LianLiGAIITrinityController::GAII_Brightness::B_75;
|
||||
RainbowMorph.speed_min = LianLiGAIITrinityController::GAII_Speed::S_VERY_SLOW;
|
||||
RainbowMorph.speed_max = LianLiGAIITrinityController::GAII_Speed::S_VERY_FAST;
|
||||
RainbowMorph.speed = LianLiGAIITrinityController::GAII_Speed::S_SLOW;
|
||||
modes.push_back(RainbowMorph);
|
||||
|
||||
mode Direct;
|
||||
Direct.name = "Direct";
|
||||
Direct.value = LianLiGAIITrinityController::GAII_Modes::M_STATIC_COLOR;
|
||||
Direct.flags = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
|
||||
Direct.color_mode = MODE_COLORS_PER_LED;
|
||||
Direct.brightness_min = LianLiGAIITrinityController::GAII_Brightness::B_OFF;
|
||||
Direct.brightness_max = LianLiGAIITrinityController::GAII_Brightness::B_100;
|
||||
Direct.brightness = LianLiGAIITrinityController::GAII_Brightness::B_50;
|
||||
modes.push_back(Direct);
|
||||
|
||||
mode BreathingColor;
|
||||
BreathingColor.name = "Breathing Color";
|
||||
BreathingColor.value = LianLiGAIITrinityController::GAII_Modes::M_BREATHING_COLOR;
|
||||
BreathingColor.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
|
||||
BreathingColor.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
BreathingColor.colors.resize(2);
|
||||
BreathingColor.colors[0] = ToRGBColor(255, 255, 255);
|
||||
BreathingColor.colors[1] = ToRGBColor(255, 0, 0);
|
||||
BreathingColor.brightness_min = LianLiGAIITrinityController::GAII_Brightness::B_OFF;
|
||||
BreathingColor.brightness_max = LianLiGAIITrinityController::GAII_Brightness::B_100;
|
||||
BreathingColor.brightness = LianLiGAIITrinityController::GAII_Brightness::B_100;
|
||||
BreathingColor.speed_min = LianLiGAIITrinityController::GAII_Speed::S_VERY_SLOW;
|
||||
BreathingColor.speed_max = LianLiGAIITrinityController::GAII_Speed::S_VERY_FAST;
|
||||
BreathingColor.speed = LianLiGAIITrinityController::GAII_Speed::S_MODERATE;
|
||||
modes.push_back(BreathingColor);
|
||||
|
||||
mode Runway;
|
||||
Runway.name = "Runway";
|
||||
Runway.value = LianLiGAIITrinityController::GAII_Modes::M_RUNWAY;
|
||||
Runway.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
|
||||
Runway.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Runway.colors.resize(2);
|
||||
Runway.colors[0] = ToRGBColor(0, 0, 0);
|
||||
Runway.colors[1] = ToRGBColor(255, 255, 255);
|
||||
Runway.brightness_min = LianLiGAIITrinityController::GAII_Brightness::B_OFF;
|
||||
Runway.brightness_max = LianLiGAIITrinityController::GAII_Brightness::B_100;
|
||||
Runway.brightness = LianLiGAIITrinityController::GAII_Brightness::B_50;
|
||||
Runway.speed_min = LianLiGAIITrinityController::GAII_Speed::S_VERY_SLOW;
|
||||
Runway.speed_max = LianLiGAIITrinityController::GAII_Speed::S_VERY_FAST;
|
||||
Runway.speed = LianLiGAIITrinityController::GAII_Speed::S_FAST;
|
||||
modes.push_back(Runway);
|
||||
|
||||
mode Meteor;
|
||||
Meteor.name = "Meteor";
|
||||
Meteor.value = LianLiGAIITrinityController::GAII_Modes::M_METEOR;
|
||||
Meteor.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
|
||||
Meteor.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Meteor.colors.resize(4);
|
||||
Meteor.colors[0] = ToRGBColor(50, 50, 50);
|
||||
Meteor.colors[1] = ToRGBColor(100, 100, 100);
|
||||
Meteor.colors[2] = ToRGBColor(180, 180, 180);
|
||||
Meteor.colors[3] = ToRGBColor(255, 0, 0);
|
||||
Meteor.brightness_min = LianLiGAIITrinityController::GAII_Brightness::B_OFF;
|
||||
Meteor.brightness_max = LianLiGAIITrinityController::GAII_Brightness::B_100;
|
||||
Meteor.brightness = LianLiGAIITrinityController::GAII_Brightness::B_100;
|
||||
Meteor.speed_min = LianLiGAIITrinityController::GAII_Speed::S_VERY_SLOW;
|
||||
Meteor.speed_max = LianLiGAIITrinityController::GAII_Speed::S_VERY_FAST;
|
||||
Meteor.speed = LianLiGAIITrinityController::GAII_Speed::S_VERY_FAST;
|
||||
Meteor.direction = MODE_DIRECTION_RIGHT;
|
||||
modes.push_back(Meteor);
|
||||
|
||||
mode Vortex;
|
||||
Vortex.name = "Vortex";
|
||||
Vortex.value = LianLiGAIITrinityController::GAII_Modes::M_VORTEX;
|
||||
Vortex.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
|
||||
Vortex.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Vortex.colors.resize(4);
|
||||
Vortex.colors[0] = ToRGBColor(100, 100, 100);
|
||||
Vortex.colors[1] = ToRGBColor(0, 100, 0);
|
||||
Vortex.colors[2] = ToRGBColor(255, 255, 255);
|
||||
Vortex.colors[3] = ToRGBColor(255, 0, 0);
|
||||
Vortex.brightness_min = LianLiGAIITrinityController::GAII_Brightness::B_OFF;
|
||||
Vortex.brightness_max = LianLiGAIITrinityController::GAII_Brightness::B_100;
|
||||
Vortex.brightness = LianLiGAIITrinityController::GAII_Brightness::B_75;
|
||||
Vortex.speed_min = LianLiGAIITrinityController::GAII_Speed::S_VERY_SLOW;
|
||||
Vortex.speed_max = LianLiGAIITrinityController::GAII_Speed::S_VERY_FAST;
|
||||
Vortex.speed = LianLiGAIITrinityController::GAII_Speed::S_VERY_FAST;
|
||||
Vortex.direction = MODE_DIRECTION_RIGHT;
|
||||
modes.push_back(Vortex);
|
||||
|
||||
mode CrossingOver;
|
||||
CrossingOver.name = "Crossing Over";
|
||||
CrossingOver.value = LianLiGAIITrinityController::GAII_Modes::M_CROSSING_OVER;
|
||||
CrossingOver.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
|
||||
CrossingOver.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
CrossingOver.colors.resize(4);
|
||||
CrossingOver.colors[0] = ToRGBColor(255, 0, 0);
|
||||
CrossingOver.colors[1] = ToRGBColor(0, 255, 0);
|
||||
CrossingOver.colors[2] = ToRGBColor(0, 0, 255);
|
||||
CrossingOver.colors[3] = ToRGBColor(255, 255, 0);
|
||||
CrossingOver.brightness_min = LianLiGAIITrinityController::GAII_Brightness::B_OFF;
|
||||
CrossingOver.brightness_max = LianLiGAIITrinityController::GAII_Brightness::B_100;
|
||||
CrossingOver.brightness = LianLiGAIITrinityController::GAII_Brightness::B_75;
|
||||
CrossingOver.speed_min = LianLiGAIITrinityController::GAII_Speed::S_VERY_SLOW;
|
||||
CrossingOver.speed_max = LianLiGAIITrinityController::GAII_Speed::S_VERY_FAST;
|
||||
CrossingOver.speed = LianLiGAIITrinityController::GAII_Speed::S_FAST;
|
||||
CrossingOver.direction = MODE_DIRECTION_RIGHT;
|
||||
modes.push_back(CrossingOver);
|
||||
|
||||
mode TaiChi;
|
||||
TaiChi.name = "Tai Chi";
|
||||
TaiChi.value = LianLiGAIITrinityController::GAII_Modes::M_TAI_CHI;
|
||||
TaiChi.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
|
||||
TaiChi.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
TaiChi.colors.resize(2);
|
||||
TaiChi.colors[0] = ToRGBColor(255, 0, 0);
|
||||
TaiChi.colors[1] = ToRGBColor(0, 255, 0);
|
||||
TaiChi.brightness_min = LianLiGAIITrinityController::GAII_Brightness::B_OFF;
|
||||
TaiChi.brightness_max = LianLiGAIITrinityController::GAII_Brightness::B_100;
|
||||
TaiChi.brightness = LianLiGAIITrinityController::GAII_Brightness::B_75;
|
||||
TaiChi.speed_min = LianLiGAIITrinityController::GAII_Speed::S_VERY_SLOW;
|
||||
TaiChi.speed_max = LianLiGAIITrinityController::GAII_Speed::S_VERY_FAST;
|
||||
TaiChi.speed = LianLiGAIITrinityController::GAII_Speed::S_MODERATE;
|
||||
TaiChi.direction = MODE_DIRECTION_RIGHT;
|
||||
modes.push_back(TaiChi);
|
||||
|
||||
mode ColorfulStarryNight;
|
||||
ColorfulStarryNight.name = "Colorful Starry Night";
|
||||
ColorfulStarryNight.value = LianLiGAIITrinityController::GAII_Modes::M_COLORFUL_STARRY_NIGHT;
|
||||
ColorfulStarryNight.flags = MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
|
||||
ColorfulStarryNight.color_mode = MODE_COLORS_RANDOM;
|
||||
ColorfulStarryNight.brightness_min = LianLiGAIITrinityController::GAII_Brightness::B_OFF;
|
||||
ColorfulStarryNight.brightness_max = LianLiGAIITrinityController::GAII_Brightness::B_100;
|
||||
ColorfulStarryNight.brightness = LianLiGAIITrinityController::GAII_Brightness::B_50;
|
||||
ColorfulStarryNight.speed_min = LianLiGAIITrinityController::GAII_Speed::S_VERY_SLOW;
|
||||
ColorfulStarryNight.speed_max = LianLiGAIITrinityController::GAII_Speed::S_VERY_FAST;
|
||||
ColorfulStarryNight.speed = LianLiGAIITrinityController::GAII_Speed::S_SLOW;
|
||||
modes.push_back(ColorfulStarryNight);
|
||||
|
||||
mode StaticStarryNight;
|
||||
StaticStarryNight.name = "Static Starry Night";
|
||||
StaticStarryNight.value = LianLiGAIITrinityController::GAII_Modes::M_STATIC_STARRY_NIGHT;
|
||||
StaticStarryNight.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
|
||||
StaticStarryNight.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
StaticStarryNight.colors.resize(1);
|
||||
StaticStarryNight.colors[0] = ToRGBColor(255, 255, 0);
|
||||
StaticStarryNight.brightness_min = LianLiGAIITrinityController::GAII_Brightness::B_OFF;
|
||||
StaticStarryNight.brightness_max = LianLiGAIITrinityController::GAII_Brightness::B_100;
|
||||
StaticStarryNight.brightness = LianLiGAIITrinityController::GAII_Brightness::B_50;
|
||||
StaticStarryNight.speed_min = LianLiGAIITrinityController::GAII_Speed::S_VERY_SLOW;
|
||||
StaticStarryNight.speed_max = LianLiGAIITrinityController::GAII_Speed::S_VERY_FAST;
|
||||
StaticStarryNight.speed = LianLiGAIITrinityController::GAII_Speed::S_VERY_SLOW;
|
||||
modes.push_back(StaticStarryNight);
|
||||
|
||||
mode Voice;
|
||||
Voice.name = "Voice";
|
||||
Voice.value = LianLiGAIITrinityController::GAII_Modes::M_VOICE;
|
||||
Voice.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
|
||||
Voice.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Voice.colors.resize(2);
|
||||
Voice.colors[0] = ToRGBColor(255, 255, 255);
|
||||
Voice.colors[1] = ToRGBColor(130, 130, 130);
|
||||
Voice.brightness_min = LianLiGAIITrinityController::GAII_Brightness::B_OFF;
|
||||
Voice.brightness_max = LianLiGAIITrinityController::GAII_Brightness::B_100;
|
||||
Voice.brightness = LianLiGAIITrinityController::GAII_Brightness::B_100;
|
||||
Voice.speed_min = LianLiGAIITrinityController::GAII_Speed::S_VERY_SLOW;
|
||||
Voice.speed_max = LianLiGAIITrinityController::GAII_Speed::S_VERY_FAST;
|
||||
Voice.speed = LianLiGAIITrinityController::GAII_Speed::S_SLOW;
|
||||
modes.push_back(Voice);
|
||||
|
||||
|
||||
mode BigBang;
|
||||
BigBang.name = "Big Bang";
|
||||
BigBang.value = LianLiGAIITrinityController::GAII_Modes::M_BIG_BANG;
|
||||
BigBang.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
|
||||
BigBang.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
BigBang.colors.resize(4);
|
||||
BigBang.colors[0] = ToRGBColor(255, 255, 255);
|
||||
BigBang.colors[1] = ToRGBColor(255, 0, 0);
|
||||
BigBang.colors[2] = ToRGBColor(255, 255, 255);
|
||||
BigBang.colors[3] = ToRGBColor(0, 255, 0);
|
||||
BigBang.brightness_min = LianLiGAIITrinityController::GAII_Brightness::B_OFF;
|
||||
BigBang.brightness_max = LianLiGAIITrinityController::GAII_Brightness::B_100;
|
||||
BigBang.brightness = LianLiGAIITrinityController::GAII_Brightness::B_75;
|
||||
BigBang.speed_min = LianLiGAIITrinityController::GAII_Speed::S_VERY_SLOW;
|
||||
BigBang.speed_max = LianLiGAIITrinityController::GAII_Speed::S_VERY_FAST;
|
||||
BigBang.speed = LianLiGAIITrinityController::GAII_Speed::S_FAST;
|
||||
modes.push_back(BigBang);
|
||||
|
||||
mode Pump;
|
||||
Pump.name = "Pump";
|
||||
Pump.value = LianLiGAIITrinityController::GAII_Modes::M_PUMP;
|
||||
Pump.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
|
||||
Pump.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Pump.colors.resize(2);
|
||||
Pump.colors[0] = ToRGBColor(0, 255, 0);
|
||||
Pump.colors[1] = ToRGBColor(150, 150, 150);
|
||||
Pump.brightness_min = LianLiGAIITrinityController::GAII_Brightness::B_OFF;
|
||||
Pump.brightness_max = LianLiGAIITrinityController::GAII_Brightness::B_100;
|
||||
Pump.brightness = LianLiGAIITrinityController::GAII_Brightness::B_75;
|
||||
Pump.speed_min = LianLiGAIITrinityController::GAII_Speed::S_VERY_SLOW;
|
||||
Pump.speed_max = LianLiGAIITrinityController::GAII_Speed::S_VERY_FAST;
|
||||
Pump.speed = LianLiGAIITrinityController::GAII_Speed::S_FAST;
|
||||
Pump.direction = MODE_DIRECTION_RIGHT;
|
||||
modes.push_back(Pump);
|
||||
|
||||
mode ColorsMorph;
|
||||
ColorsMorph.name = "Colors Morph";
|
||||
ColorsMorph.value = LianLiGAIITrinityController::GAII_Modes::M_COLORS_MORPH;
|
||||
ColorsMorph.flags = MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
|
||||
ColorsMorph.color_mode = MODE_COLORS_RANDOM;
|
||||
ColorsMorph.brightness_min = LianLiGAIITrinityController::GAII_Brightness::B_OFF;
|
||||
ColorsMorph.brightness_max = LianLiGAIITrinityController::GAII_Brightness::B_100;
|
||||
ColorsMorph.brightness = LianLiGAIITrinityController::GAII_Brightness::B_100;
|
||||
ColorsMorph.speed_min = LianLiGAIITrinityController::GAII_Speed::S_VERY_SLOW;
|
||||
ColorsMorph.speed_max = LianLiGAIITrinityController::GAII_Speed::S_VERY_FAST;
|
||||
ColorsMorph.speed = LianLiGAIITrinityController::GAII_Speed::S_MODERATE;
|
||||
ColorsMorph.direction = MODE_DIRECTION_RIGHT;
|
||||
modes.push_back(ColorsMorph);
|
||||
|
||||
SetupZones();
|
||||
}
|
||||
|
||||
RGBController_LianLiGAIITrinity::~RGBController_LianLiGAIITrinity()
|
||||
{
|
||||
delete controller;
|
||||
}
|
||||
|
||||
void RGBController_LianLiGAIITrinity::SetupZones()
|
||||
{
|
||||
/*-------------------------------------------------*\
|
||||
| Set zones and leds |
|
||||
\*-------------------------------------------------*/
|
||||
|
||||
zone gaii_trinity;
|
||||
gaii_trinity.name = "GAII Trinity";
|
||||
gaii_trinity.type = ZONE_TYPE_SINGLE;
|
||||
gaii_trinity.leds_min = 2;
|
||||
gaii_trinity.leds_max = 2;
|
||||
gaii_trinity.leds_count = 2;
|
||||
gaii_trinity.matrix_map = NULL;
|
||||
zones.push_back(gaii_trinity);
|
||||
|
||||
led inner_led;
|
||||
inner_led.name = "Inner Ring LEDs";
|
||||
leds.push_back(inner_led);
|
||||
|
||||
led outer_led;
|
||||
outer_led.name = "Outer Ring LEDs";
|
||||
leds.push_back(outer_led);
|
||||
|
||||
SetupColors();
|
||||
|
||||
// set default color values
|
||||
zones[0].colors[0] = ToRGBColor(255, 255, 255);
|
||||
zones[0].colors[1] = ToRGBColor(0, 0, 255);
|
||||
}
|
||||
|
||||
void RGBController_LianLiGAIITrinity::ResizeZone(int /* zone */, int /* new_size */)
|
||||
{
|
||||
/*---------------------------------------------------------*\
|
||||
| This device does not support resizing zones |
|
||||
\*---------------------------------------------------------*/
|
||||
}
|
||||
|
||||
void RGBController_LianLiGAIITrinity::DeviceUpdateLEDs()
|
||||
{
|
||||
switch(modes[active_mode].value)
|
||||
{
|
||||
case LianLiGAIITrinityController::GAII_Modes::M_RAINBOW:
|
||||
controller->SetMode_Rainbow(static_cast<LianLiGAIITrinityController::GAII_Brightness>(modes[active_mode].brightness),
|
||||
static_cast<LianLiGAIITrinityController::GAII_Speed>(modes[active_mode].speed),
|
||||
OpenRGBDirection2GAIIDirection(modes[active_mode].direction));
|
||||
break;
|
||||
case LianLiGAIITrinityController::GAII_Modes::M_RAINBOW_MORPH:
|
||||
controller->SetMode_RainbowMorph(static_cast<LianLiGAIITrinityController::GAII_Brightness>(modes[active_mode].brightness),
|
||||
static_cast<LianLiGAIITrinityController::GAII_Speed>(modes[active_mode].speed));
|
||||
break;
|
||||
case LianLiGAIITrinityController::GAII_Modes::M_STATIC_COLOR:
|
||||
controller->SetMode_StaticColor(static_cast<LianLiGAIITrinityController::GAII_Brightness>(modes[active_mode].brightness),
|
||||
zones[0].colors[0], zones[0].colors[1]);
|
||||
break;
|
||||
case LianLiGAIITrinityController::GAII_Modes::M_BREATHING_COLOR:
|
||||
controller->SetMode_BreathingColor(static_cast<LianLiGAIITrinityController::GAII_Brightness>(modes[active_mode].brightness),
|
||||
static_cast<LianLiGAIITrinityController::GAII_Speed>(modes[active_mode].speed),
|
||||
modes[active_mode].colors[0], modes[active_mode].colors[1]);
|
||||
break;
|
||||
case LianLiGAIITrinityController::GAII_Modes::M_RUNWAY:
|
||||
controller->SetMode_Runway(static_cast<LianLiGAIITrinityController::GAII_Brightness>(modes[active_mode].brightness),
|
||||
static_cast<LianLiGAIITrinityController::GAII_Speed>(modes[active_mode].speed),
|
||||
modes[active_mode].colors[0], modes[active_mode].colors[1]);
|
||||
break;
|
||||
case LianLiGAIITrinityController::GAII_Modes::M_METEOR:
|
||||
controller->SetMode_Meteor(static_cast<LianLiGAIITrinityController::GAII_Brightness>(modes[active_mode].brightness),
|
||||
static_cast<LianLiGAIITrinityController::GAII_Speed>(modes[active_mode].speed),
|
||||
OpenRGBDirection2GAIIDirection(modes[active_mode].direction),
|
||||
modes[active_mode].colors[0], modes[active_mode].colors[1], modes[active_mode].colors[2], modes[active_mode].colors[3]);
|
||||
break;
|
||||
case LianLiGAIITrinityController::GAII_Modes::M_VORTEX:
|
||||
controller->SetMode_Vortex(static_cast<LianLiGAIITrinityController::GAII_Brightness>(modes[active_mode].brightness),
|
||||
static_cast<LianLiGAIITrinityController::GAII_Speed>(modes[active_mode].speed),
|
||||
OpenRGBDirection2GAIIDirection(modes[active_mode].direction),
|
||||
modes[active_mode].colors[0], modes[active_mode].colors[1], modes[active_mode].colors[2], modes[active_mode].colors[3]);
|
||||
break;
|
||||
case LianLiGAIITrinityController::GAII_Modes::M_CROSSING_OVER:
|
||||
controller->SetMode_CrossingOver(static_cast<LianLiGAIITrinityController::GAII_Brightness>(modes[active_mode].brightness),
|
||||
static_cast<LianLiGAIITrinityController::GAII_Speed>(modes[active_mode].speed),
|
||||
OpenRGBDirection2GAIIDirection(modes[active_mode].direction),
|
||||
modes[active_mode].colors[0], modes[active_mode].colors[1], modes[active_mode].colors[2], modes[active_mode].colors[3]);
|
||||
break;
|
||||
case LianLiGAIITrinityController::GAII_Modes::M_TAI_CHI:
|
||||
controller->SetMode_TaiChi(static_cast<LianLiGAIITrinityController::GAII_Brightness>(modes[active_mode].brightness),
|
||||
static_cast<LianLiGAIITrinityController::GAII_Speed>(modes[active_mode].speed),
|
||||
OpenRGBDirection2GAIIDirection(modes[active_mode].direction),
|
||||
modes[active_mode].colors[0], modes[active_mode].colors[1]);
|
||||
break;
|
||||
case LianLiGAIITrinityController::GAII_Modes::M_COLORFUL_STARRY_NIGHT:
|
||||
controller->SetMode_ColorfulStarryNight(static_cast<LianLiGAIITrinityController::GAII_Brightness>(modes[active_mode].brightness),
|
||||
static_cast<LianLiGAIITrinityController::GAII_Speed>(modes[active_mode].speed));
|
||||
break;
|
||||
case LianLiGAIITrinityController::GAII_Modes::M_STATIC_STARRY_NIGHT:
|
||||
controller->SetMode_StaticStarryNight(static_cast<LianLiGAIITrinityController::GAII_Brightness>(modes[active_mode].brightness),
|
||||
static_cast<LianLiGAIITrinityController::GAII_Speed>(modes[active_mode].speed),
|
||||
modes[active_mode].colors[0]);
|
||||
break;
|
||||
case LianLiGAIITrinityController::GAII_Modes::M_VOICE:
|
||||
controller->SetMode_Voice(static_cast<LianLiGAIITrinityController::GAII_Brightness>(modes[active_mode].brightness),
|
||||
static_cast<LianLiGAIITrinityController::GAII_Speed>(modes[active_mode].speed),
|
||||
modes[active_mode].colors[0], modes[active_mode].colors[1]);
|
||||
break;
|
||||
case LianLiGAIITrinityController::GAII_Modes::M_BIG_BANG:
|
||||
controller->SetMode_BigBang(static_cast<LianLiGAIITrinityController::GAII_Brightness>(modes[active_mode].brightness),
|
||||
static_cast<LianLiGAIITrinityController::GAII_Speed>(modes[active_mode].speed),
|
||||
modes[active_mode].colors[0], modes[active_mode].colors[1], modes[active_mode].colors[2], modes[active_mode].colors[3]);
|
||||
break;
|
||||
case LianLiGAIITrinityController::GAII_Modes::M_PUMP:
|
||||
controller->SetMode_Pump(static_cast<LianLiGAIITrinityController::GAII_Brightness>(modes[active_mode].brightness),
|
||||
static_cast<LianLiGAIITrinityController::GAII_Speed>(modes[active_mode].speed),
|
||||
OpenRGBDirection2GAIIDirection(modes[active_mode].direction),
|
||||
modes[active_mode].colors[0], modes[active_mode].colors[1]);
|
||||
break;
|
||||
case LianLiGAIITrinityController::GAII_Modes::M_COLORS_MORPH:
|
||||
controller->SetMode_ColorsMorph(static_cast<LianLiGAIITrinityController::GAII_Brightness>(modes[active_mode].brightness),
|
||||
static_cast<LianLiGAIITrinityController::GAII_Speed>(modes[active_mode].speed),
|
||||
OpenRGBDirection2GAIIDirection(modes[active_mode].direction));
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
void RGBController_LianLiGAIITrinity::UpdateZoneLEDs(int /* zone */)
|
||||
{
|
||||
DeviceUpdateLEDs();
|
||||
}
|
||||
|
||||
void RGBController_LianLiGAIITrinity::UpdateSingleLED(int /* led */)
|
||||
{
|
||||
DeviceUpdateLEDs();
|
||||
}
|
||||
|
||||
void RGBController_LianLiGAIITrinity::DeviceUpdateMode()
|
||||
{
|
||||
DeviceUpdateLEDs();
|
||||
}
|
||||
+43
@@ -0,0 +1,43 @@
|
||||
/*---------------------------------------------------------*\
|
||||
| RGBController_LianLiGAIITrinity.h |
|
||||
| |
|
||||
| RGBController for Lian Li GAII Trinity |
|
||||
| |
|
||||
| Michael Losert 27 Oct 2023 |
|
||||
| |
|
||||
| This file is part of the OpenRGB project |
|
||||
| SPDX-License-Identifier: GPL-2.0-or-later |
|
||||
\*---------------------------------------------------------*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include "LianLiGAIITrinityController.h"
|
||||
#include "RGBController.h"
|
||||
|
||||
class RGBController_LianLiGAIITrinity : public RGBController
|
||||
{
|
||||
public:
|
||||
RGBController_LianLiGAIITrinity(LianLiGAIITrinityController* controller_ptr);
|
||||
~RGBController_LianLiGAIITrinity();
|
||||
|
||||
void SetupZones();
|
||||
|
||||
void ResizeZone(int zone, int new_size);
|
||||
|
||||
void DeviceUpdateLEDs();
|
||||
void UpdateZoneLEDs(int zone);
|
||||
void UpdateSingleLED(int led);
|
||||
|
||||
void DeviceUpdateMode();
|
||||
|
||||
LianLiGAIITrinityController::GAII_Direction OpenRGBDirection2GAIIDirection(unsigned int openrgb_direction)
|
||||
{
|
||||
if(openrgb_direction == MODE_DIRECTION_LEFT)
|
||||
return LianLiGAIITrinityController::GAII_Direction::D_LEFT;
|
||||
|
||||
return LianLiGAIITrinityController::GAII_Direction::D_RIGHT;
|
||||
}
|
||||
|
||||
private:
|
||||
LianLiGAIITrinityController* controller;
|
||||
};
|
||||
+107
@@ -0,0 +1,107 @@
|
||||
/*---------------------------------------------------------*\
|
||||
| LianLiStrimerLConnectController.cpp |
|
||||
| |
|
||||
| Driver for Lian Li Strimer L Connect |
|
||||
| |
|
||||
| Chris M (Dr_No) 03 Jul 2022 |
|
||||
| |
|
||||
| This file is part of the OpenRGB project |
|
||||
| SPDX-License-Identifier: GPL-2.0-or-later |
|
||||
\*---------------------------------------------------------*/
|
||||
|
||||
#include "LianLiStrimerLConnectController.h"
|
||||
#include "StringUtils.h"
|
||||
|
||||
static uint8_t speed_data[5] =
|
||||
{
|
||||
0x02, 0x01, 0x00, 0xFE, 0xFF /* Slow to fast */
|
||||
};
|
||||
|
||||
static uint8_t brightness_data[5] =
|
||||
{
|
||||
0x08, 0x03, 0x02, 0x01, 0x00 /* 0%, 25%, 50%, 75%, 100% */
|
||||
};
|
||||
|
||||
LianLiStrimerLConnectController::LianLiStrimerLConnectController(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));
|
||||
}
|
||||
|
||||
LianLiStrimerLConnectController::~LianLiStrimerLConnectController()
|
||||
{
|
||||
hid_close(dev);
|
||||
}
|
||||
|
||||
std::string LianLiStrimerLConnectController::GetDeviceName()
|
||||
{
|
||||
return device_name;
|
||||
}
|
||||
|
||||
std::string LianLiStrimerLConnectController::GetSerial()
|
||||
{
|
||||
wchar_t serial_string[HID_MAX_STR];
|
||||
int ret = hid_get_serial_number_string(dev, serial_string, HID_MAX_STR);
|
||||
|
||||
if(ret != 0)
|
||||
{
|
||||
return("");
|
||||
}
|
||||
|
||||
return(StringUtils::wstring_to_string(serial_string));
|
||||
}
|
||||
|
||||
std::string LianLiStrimerLConnectController::GetLocation()
|
||||
{
|
||||
return("HID: " + location);
|
||||
}
|
||||
|
||||
void LianLiStrimerLConnectController::SendApply()
|
||||
{
|
||||
uint8_t buffer[STRIMERLCONNECT_PACKET_SIZE] = { STRIMERLCONNECT_REPORT_ID, 0x2C, 0x0F, 0xFF, 0x00, 0x00, 0x00, 0x00 };
|
||||
|
||||
hid_write(dev, buffer, STRIMERLCONNECT_PACKET_SIZE);
|
||||
}
|
||||
|
||||
void LianLiStrimerLConnectController::SetMode(uint8_t mode, uint8_t zone, uint8_t speed, uint8_t brightness, uint8_t direction, bool /*random_colours*/)
|
||||
{
|
||||
uint8_t buffer[STRIMERLCONNECT_PACKET_SIZE] = { STRIMERLCONNECT_REPORT_ID, STRIMERLCONNECT_MODE_COMMAND, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
|
||||
|
||||
buffer[STRIMERLCONNECT_COMMAND_BYTE] |= zone;
|
||||
|
||||
buffer[STRIMERLCONNECT_DATA_BYTE] = mode;
|
||||
buffer[STRIMERLCONNECT_SPEED_BYTE] = speed_data[speed];
|
||||
buffer[STRIMERLCONNECT_DIRECTION_BYTE] = (direction == 0) ? 1 : 0;
|
||||
buffer[STRIMERLCONNECT_BRIGHTNESS_BYTE] = brightness_data[brightness];
|
||||
|
||||
hid_write(dev, buffer, STRIMERLCONNECT_PACKET_SIZE);
|
||||
}
|
||||
|
||||
void LianLiStrimerLConnectController::SetLedsDirect(uint8_t zone, RGBColor * led_colours, uint8_t led_count)
|
||||
{
|
||||
uint8_t buffer[STRIMERLCONNECT_PACKET_SIZE] = { STRIMERLCONNECT_REPORT_ID, STRIMERLCONNECT_COLOUR_COMMAND, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
|
||||
|
||||
buffer[STRIMERLCONNECT_COMMAND_BYTE] |= zone;
|
||||
|
||||
for(size_t i = 0; i < led_count; i++)
|
||||
{
|
||||
uint8_t offset = (3 * (uint8_t)i) + STRIMERLCONNECT_DATA_BYTE;
|
||||
|
||||
buffer[offset] = RGBGetRValue(led_colours[i]);
|
||||
buffer[offset + 1] = RGBGetBValue(led_colours[i]);
|
||||
buffer[offset + 2] = RGBGetGValue(led_colours[i]);
|
||||
}
|
||||
|
||||
hid_write(dev, buffer, STRIMERLCONNECT_PACKET_SIZE);
|
||||
}
|
||||
+95
@@ -0,0 +1,95 @@
|
||||
/*---------------------------------------------------------*\
|
||||
| LianLiStrimerLConnectController.h |
|
||||
| |
|
||||
| Driver for Lian Li Strimer L Connect |
|
||||
| |
|
||||
| Chris M (Dr_No) 03 Jul 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 "LogManager.h"
|
||||
#include "RGBController.h"
|
||||
|
||||
#define HID_MAX_STR 255
|
||||
#define STRIMERLCONNECT_PACKET_SIZE 255 //Buffer requires a prepended ReportID hence + 1
|
||||
|
||||
#define STRIMERLCONNECT_BRIGHTNESS_MIN 0 //Brightness indexes not values
|
||||
#define STRIMERLCONNECT_BRIGHTNESS_MAX 4
|
||||
#define STRIMERLCONNECT_STRIP_COUNT 12
|
||||
|
||||
enum
|
||||
{
|
||||
STRIMERLCONNECT_MODE_OFF = 0x00, //Turn off - All leds off
|
||||
STRIMERLCONNECT_MODE_DIRECT = 0x01, //Direct Led Control - Independently set LEDs in zone
|
||||
STRIMERLCONNECT_MODE_BREATHING = 0x02, //Breathing Mode - Fades between fully off and fully on.
|
||||
STRIMERLCONNECT_MODE_FLASHING = 0x03, //Flashing Mode - Abruptly changing between fully off and fully on.
|
||||
STRIMERLCONNECT_MODE_RAINBOWMORPH = 0x04, //Rainbow Morph Mode
|
||||
STRIMERLCONNECT_MODE_RAINBOW = 0x05, //Rainbow Wave Mode - Cycle thru the color spectrum as a wave across all LEDs
|
||||
STRIMERLCONNECT_MODE_BREATHCYCLE = 0x06, //Spectrum Cycle Mode - Cycles through the color spectrum on all lights on the device
|
||||
|
||||
STRIMERLCONNECT_MODE_SNOOKER = 0x19, //Snooker Mode
|
||||
STRIMERLCONNECT_MODE_MIXING = 0x1A, //Mixing Mode
|
||||
STRIMERLCONNECT_MODE_PINGPONG = 0x1B, //Ping Pong Mode
|
||||
STRIMERLCONNECT_MODE_RUNWAY = 0x1C, //Runway Mode
|
||||
STRIMERLCONNECT_MODE_PAINTING = 0x1D, //Painting Mode
|
||||
STRIMERLCONNECT_MODE_TIDE = 0x1E, //Tide Mode
|
||||
STRIMERLCONNECT_MODE_BLOWUP = 0x1F, //Blow Up Mode
|
||||
STRIMERLCONNECT_MODE_METEOR = 0x20, //Meteor Mode
|
||||
|
||||
STRIMERLCONNECT_MODE_SHOCKWAVE = 0x21, //Shock Wave Mode
|
||||
STRIMERLCONNECT_MODE_RIPPLE = 0x22, //Ripple Mode
|
||||
STRIMERLCONNECT_MODE_VOICE = 0x23, //Voice Mode
|
||||
STRIMERLCONNECT_MODE_BULLETSTACK = 0x24, //Bullet Stack Mode
|
||||
STRIMERLCONNECT_MODE_DRIZZLING = 0x25, //Drizzling Mode
|
||||
STRIMERLCONNECT_MODE_FADEOUT = 0x26, //Fade Out Mode
|
||||
STRIMERLCONNECT_MODE_COLORTRANSFER = 0x27, //Color Transfer Mode
|
||||
STRIMERLCONNECT_MODE_CROSSOVER = 0x28, //Cross Over Mode
|
||||
STRIMERLCONNECT_MODE_TWINKLE = 0x29, //Twinkle Mode
|
||||
STRIMERLCONNECT_MODE_CONTEST = 0x2A, //Contest Mode
|
||||
STRIMERLCONNECT_MODE_PARALLEL = 0x2B, //Parallel Mode
|
||||
};
|
||||
|
||||
enum
|
||||
{
|
||||
STRIMERLCONNECT_COMMAND_BYTE = 1,
|
||||
STRIMERLCONNECT_DATA_BYTE = 2,
|
||||
STRIMERLCONNECT_SPEED_BYTE = 3,
|
||||
STRIMERLCONNECT_DIRECTION_BYTE = 4,
|
||||
STRIMERLCONNECT_BRIGHTNESS_BYTE = 5,
|
||||
|
||||
STRIMERLCONNECT_MODE_COMMAND = 0x10,
|
||||
STRIMERLCONNECT_COLOUR_COMMAND = 0x30,
|
||||
STRIMERLCONNECT_REPORT_ID = 0xE0,
|
||||
};
|
||||
|
||||
enum
|
||||
{
|
||||
STRIMERLCONNECT_SPEED_SLOWEST = 0,
|
||||
STRIMERLCONNECT_SPEED_NORMAL = 2,
|
||||
STRIMERLCONNECT_SPEED_FASTEST = 4,
|
||||
};
|
||||
|
||||
class LianLiStrimerLConnectController
|
||||
{
|
||||
public:
|
||||
LianLiStrimerLConnectController(hid_device* dev_handle, const char* path);
|
||||
~LianLiStrimerLConnectController();
|
||||
|
||||
std::string GetDeviceName();
|
||||
std::string GetSerial();
|
||||
std::string GetLocation();
|
||||
|
||||
void SendApply();
|
||||
void SetMode(uint8_t mode, uint8_t zone, uint8_t speed, uint8_t brightness, uint8_t direction, bool random_colours);
|
||||
void SetLedsDirect(uint8_t zone, RGBColor *led_colours, uint8_t led_count);
|
||||
private:
|
||||
std::string device_name;
|
||||
std::string location;
|
||||
hid_device* dev;
|
||||
};
|
||||
+336
@@ -0,0 +1,336 @@
|
||||
/*---------------------------------------------------------*\
|
||||
| RGBController_LianLiStrimerLConnect.cpp |
|
||||
| |
|
||||
| RGBController for Lian Li Strimer L Connect |
|
||||
| |
|
||||
| Chris M (Dr_No) 03 Jul 2022 |
|
||||
| |
|
||||
| This file is part of the OpenRGB project |
|
||||
| SPDX-License-Identifier: GPL-2.0-or-later |
|
||||
\*---------------------------------------------------------*/
|
||||
|
||||
#include "RGBController_LianLiStrimerLConnect.h"
|
||||
|
||||
/**------------------------------------------------------------------*\
|
||||
@name Lian Li Strimer L Connect
|
||||
@category LEDStrip
|
||||
@type USB
|
||||
@save :x:
|
||||
@direct :rotating_light:
|
||||
@effects :white_check_mark:
|
||||
@detectors DetectLianLiStrimerControllers
|
||||
@comment The Lian Li Strimer L Connect `Direct` mode stutters at high frame rates and
|
||||
and has been rate limited to ~10FPS.
|
||||
\*-------------------------------------------------------------------*/
|
||||
|
||||
RGBController_LianLiStrimerLConnect::RGBController_LianLiStrimerLConnect(LianLiStrimerLConnectController *controller_ptr)
|
||||
{
|
||||
controller = controller_ptr;
|
||||
|
||||
name = "Lian Li Strimer L Connect";
|
||||
vendor = "Lian Li";
|
||||
type = DEVICE_TYPE_LEDSTRIP;
|
||||
description = controller->GetDeviceName();
|
||||
serial = controller->GetSerial();
|
||||
location = controller->GetLocation();
|
||||
|
||||
mode Off;
|
||||
Off.name = "Off";
|
||||
Off.value = STRIMERLCONNECT_MODE_DIRECT;
|
||||
Off.brightness = STRIMERLCONNECT_BRIGHTNESS_MIN;
|
||||
Off.color_mode = MODE_COLORS_NONE;
|
||||
modes.push_back(Off);
|
||||
|
||||
mode Direct;
|
||||
Direct.name = "Direct";
|
||||
Direct.value = STRIMERLCONNECT_MODE_DIRECT;
|
||||
Direct.flags = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_SPEED;
|
||||
Direct.color_mode = MODE_COLORS_PER_LED;
|
||||
modes.push_back(Direct);
|
||||
|
||||
mode Breathing = CreateMode("Breathing", STRIMERLCONNECT_MODE_BREATHING, 0, MODE_COLORS_PER_LED);
|
||||
Breathing.flags |= MODE_FLAG_HAS_PER_LED_COLOR;
|
||||
modes.push_back(Breathing);
|
||||
|
||||
mode Flashing = CreateMode("Flashing", STRIMERLCONNECT_MODE_FLASHING, 0, MODE_COLORS_PER_LED);
|
||||
Flashing.flags |= MODE_FLAG_HAS_PER_LED_COLOR;
|
||||
modes.push_back(Flashing);
|
||||
|
||||
mode BreathCycle = CreateMode("Breathing Cycle", STRIMERLCONNECT_MODE_BREATHCYCLE, 0, MODE_COLORS_NONE);
|
||||
modes.push_back(BreathCycle);
|
||||
|
||||
mode Rainbow = CreateMode("Rainbow", STRIMERLCONNECT_MODE_RAINBOW, 0, MODE_COLORS_NONE);
|
||||
Rainbow.flags |= MODE_FLAG_HAS_DIRECTION_LR;
|
||||
modes.push_back(Rainbow);
|
||||
|
||||
mode RainbowMorph = CreateMode("Rainbow Morph", STRIMERLCONNECT_MODE_RAINBOWMORPH, 0, MODE_COLORS_NONE);
|
||||
modes.push_back(RainbowMorph);
|
||||
|
||||
mode Snooker = CreateMode("Snooker", STRIMERLCONNECT_MODE_SNOOKER, 6, MODE_COLORS_MODE_SPECIFIC);
|
||||
Snooker.flags |= MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
|
||||
modes.push_back(Snooker);
|
||||
|
||||
mode Mixing = CreateMode("Mixing", STRIMERLCONNECT_MODE_MIXING, 2, MODE_COLORS_MODE_SPECIFIC);
|
||||
Mixing.flags |= MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
|
||||
modes.push_back(Mixing);
|
||||
|
||||
mode PingPong = CreateMode("Ping Pong", STRIMERLCONNECT_MODE_PINGPONG, 6, MODE_COLORS_MODE_SPECIFIC);
|
||||
PingPong.flags |= MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
|
||||
modes.push_back(PingPong);
|
||||
|
||||
mode Runway = CreateMode("Runway", STRIMERLCONNECT_MODE_RUNWAY, 2, MODE_COLORS_MODE_SPECIFIC);
|
||||
Runway.flags |= MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
|
||||
modes.push_back(Runway);
|
||||
|
||||
mode Painting = CreateMode("Painting", STRIMERLCONNECT_MODE_PAINTING, 6, MODE_COLORS_MODE_SPECIFIC);
|
||||
Painting.flags |= MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
|
||||
modes.push_back(Painting);
|
||||
|
||||
mode Tide = CreateMode("Tide", STRIMERLCONNECT_MODE_TIDE, 6, MODE_COLORS_MODE_SPECIFIC);
|
||||
Tide.flags |= MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
|
||||
modes.push_back(Tide);
|
||||
|
||||
mode BlowUp = CreateMode("Blow Up", STRIMERLCONNECT_MODE_BLOWUP, 6, MODE_COLORS_MODE_SPECIFIC);
|
||||
BlowUp.flags |= MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
|
||||
modes.push_back(BlowUp);
|
||||
|
||||
mode Meteor = CreateMode("Meteor", STRIMERLCONNECT_MODE_METEOR, 6, MODE_COLORS_MODE_SPECIFIC);
|
||||
Meteor.flags |= MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_DIRECTION_LR;
|
||||
modes.push_back(Meteor);
|
||||
|
||||
mode ColorTransfer = CreateMode("Color Transfer", STRIMERLCONNECT_MODE_COLORTRANSFER, 6, MODE_COLORS_MODE_SPECIFIC);
|
||||
ColorTransfer.flags |= MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_DIRECTION_LR;
|
||||
modes.push_back(ColorTransfer);
|
||||
|
||||
mode FadeOut = CreateMode("Fade Out", STRIMERLCONNECT_MODE_FADEOUT, 6, MODE_COLORS_MODE_SPECIFIC);
|
||||
FadeOut.flags |= MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
|
||||
modes.push_back(FadeOut);
|
||||
|
||||
mode Contest = CreateMode("Contest", STRIMERLCONNECT_MODE_CONTEST, 6, MODE_COLORS_MODE_SPECIFIC);
|
||||
Contest.flags |= MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_DIRECTION_LR;
|
||||
modes.push_back(Contest);
|
||||
|
||||
mode CrossOver = CreateMode("Cross Over", STRIMERLCONNECT_MODE_CROSSOVER, 6, MODE_COLORS_MODE_SPECIFIC);
|
||||
CrossOver.flags |= MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_DIRECTION_LR;
|
||||
modes.push_back(CrossOver);
|
||||
|
||||
mode BulletStack = CreateMode("Bullet Stack", STRIMERLCONNECT_MODE_BULLETSTACK, 0, MODE_COLORS_NONE);
|
||||
BulletStack.flags |= MODE_FLAG_HAS_DIRECTION_LR;
|
||||
modes.push_back(BulletStack);
|
||||
|
||||
mode Twinkle = CreateMode("Twinkle", STRIMERLCONNECT_MODE_TWINKLE, 0, MODE_COLORS_NONE);
|
||||
modes.push_back(Twinkle);
|
||||
|
||||
mode Parallel = CreateMode("Parallel", STRIMERLCONNECT_MODE_PARALLEL, 6, MODE_COLORS_MODE_SPECIFIC);
|
||||
Parallel.flags |= MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_DIRECTION_LR;
|
||||
modes.push_back(Parallel);
|
||||
|
||||
mode ShockWave = CreateMode("Shock Wave", STRIMERLCONNECT_MODE_SHOCKWAVE, 6, MODE_COLORS_MODE_SPECIFIC);
|
||||
ShockWave.flags |= MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_DIRECTION_LR;
|
||||
modes.push_back(ShockWave);
|
||||
|
||||
mode Ripple = CreateMode("Ripple", STRIMERLCONNECT_MODE_RIPPLE, 6, MODE_COLORS_MODE_SPECIFIC);
|
||||
Ripple.flags |= MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
|
||||
modes.push_back(Ripple);
|
||||
|
||||
mode Voice = CreateMode("Voice", STRIMERLCONNECT_MODE_VOICE, 6, MODE_COLORS_MODE_SPECIFIC);
|
||||
Voice.flags |= MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
|
||||
modes.push_back(Voice);
|
||||
|
||||
mode Drizzling = CreateMode("Drizzling", STRIMERLCONNECT_MODE_DRIZZLING, 6, MODE_COLORS_MODE_SPECIFIC);
|
||||
Drizzling.flags |= MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_DIRECTION_LR;
|
||||
modes.push_back(Drizzling);
|
||||
|
||||
Init_Controller();
|
||||
SetupZones();
|
||||
}
|
||||
|
||||
RGBController_LianLiStrimerLConnect::~RGBController_LianLiStrimerLConnect()
|
||||
{
|
||||
delete controller;
|
||||
}
|
||||
|
||||
void RGBController_LianLiStrimerLConnect::Init_Controller()
|
||||
{
|
||||
const uint8_t zone_split = STRIMERLCONNECT_STRIP_COUNT / 2;
|
||||
|
||||
/*-------------------------------------------------*\
|
||||
| Create the device's controllable zones |
|
||||
\*-------------------------------------------------*/
|
||||
for(std::size_t zone_idx = 0; zone_idx < zone_split; zone_idx++)
|
||||
{
|
||||
zone new_zone;
|
||||
new_zone.name = "24 Pin ATX Strip ";
|
||||
new_zone.name.append(std::to_string(zone_idx));
|
||||
new_zone.type = ZONE_TYPE_LINEAR;
|
||||
new_zone.leds_min = 20;
|
||||
new_zone.leds_max = 20;
|
||||
new_zone.leds_count = new_zone.leds_max;
|
||||
new_zone.matrix_map = NULL;
|
||||
zones.push_back(new_zone);
|
||||
}
|
||||
|
||||
for(std::size_t zone_idx = zone_split; zone_idx < STRIMERLCONNECT_STRIP_COUNT; zone_idx++)
|
||||
{
|
||||
zone new_zone;
|
||||
new_zone.name = "8 Pin GPU Strip ";
|
||||
new_zone.name.append(std::to_string(zone_idx - zone_split));
|
||||
new_zone.type = ZONE_TYPE_LINEAR;
|
||||
new_zone.leds_min = 27;
|
||||
new_zone.leds_max = 27;
|
||||
new_zone.leds_count = new_zone.leds_max;
|
||||
new_zone.matrix_map = NULL;
|
||||
zones.push_back(new_zone);
|
||||
}
|
||||
}
|
||||
|
||||
void RGBController_LianLiStrimerLConnect::SetupZones()
|
||||
{
|
||||
/*-------------------------------------------------*\
|
||||
| Clear any existing color/LED configuration |
|
||||
\*-------------------------------------------------*/
|
||||
leds.clear();
|
||||
colors.clear();
|
||||
|
||||
/*---------------------------------------------------------*\
|
||||
| Set up zones |
|
||||
\*---------------------------------------------------------*/
|
||||
for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
|
||||
{
|
||||
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));
|
||||
|
||||
leds.push_back(new_led);
|
||||
}
|
||||
}
|
||||
|
||||
SetupColors();
|
||||
}
|
||||
|
||||
void RGBController_LianLiStrimerLConnect::ResizeZone(int /*zone*/, int /*new_size*/)
|
||||
{
|
||||
/*---------------------------------------------------------*\
|
||||
| This device does not support resizing zones |
|
||||
\*---------------------------------------------------------*/
|
||||
}
|
||||
|
||||
bool RGBController_LianLiStrimerLConnect::TimeToSend()
|
||||
{
|
||||
/*-----------------------------------------------------*\
|
||||
| Rate limit is 1000(ms) / wait_time in Frames Per Sec |
|
||||
\*-----------------------------------------------------*/
|
||||
const uint8_t wait_time = 90;
|
||||
|
||||
return (std::chrono::steady_clock::now() - last_commit_time) > std::chrono::milliseconds(wait_time);
|
||||
}
|
||||
|
||||
void RGBController_LianLiStrimerLConnect::DeviceUpdateLEDs()
|
||||
{
|
||||
if(TimeToSend())
|
||||
{
|
||||
|
||||
for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
|
||||
{
|
||||
UpdateZoneLEDs((int)zone_idx);
|
||||
}
|
||||
|
||||
controller->SendApply();
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Update last commit time |
|
||||
\*-----------------------------------------------------*/
|
||||
last_commit_time = std::chrono::steady_clock::now();
|
||||
}
|
||||
}
|
||||
|
||||
void RGBController_LianLiStrimerLConnect::UpdateZoneLEDs(int zone)
|
||||
{
|
||||
mode current_mode = modes[active_mode];
|
||||
|
||||
controller->SetLedsDirect(zone, zones[zone].colors, zones[zone].leds_count);
|
||||
controller->SetMode(current_mode.value, zone, current_mode.speed, current_mode.brightness, current_mode.direction, false);
|
||||
}
|
||||
|
||||
void RGBController_LianLiStrimerLConnect::UpdateSingleLED(int led)
|
||||
{
|
||||
UpdateZoneLEDs(GetLED_Zone(led));
|
||||
controller->SendApply();
|
||||
}
|
||||
|
||||
void RGBController_LianLiStrimerLConnect::DeviceUpdateMode()
|
||||
{
|
||||
if(TimeToSend())
|
||||
{
|
||||
mode current_mode = modes[active_mode];
|
||||
|
||||
if(current_mode.color_mode == MODE_COLORS_PER_LED)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
bool random_colours = (modes[active_mode].color_mode == MODE_COLORS_RANDOM);
|
||||
|
||||
if(current_mode.color_mode == MODE_COLORS_NONE)
|
||||
{
|
||||
for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
|
||||
{
|
||||
controller->SetMode((uint8_t)current_mode.value, (uint8_t)zone_idx, current_mode.speed, current_mode.brightness, current_mode.direction, random_colours);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
|
||||
{
|
||||
controller->SetLedsDirect((uint8_t)zone_idx, ¤t_mode.colors[0], (uint8_t)current_mode.colors.size());
|
||||
controller->SetMode((uint8_t)current_mode.value, (uint8_t)zone_idx, current_mode.speed, current_mode.brightness, current_mode.direction, random_colours);
|
||||
}
|
||||
}
|
||||
|
||||
controller->SendApply();
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Update last commit time |
|
||||
\*-----------------------------------------------------*/
|
||||
last_commit_time = std::chrono::steady_clock::now();
|
||||
}
|
||||
}
|
||||
|
||||
int RGBController_LianLiStrimerLConnect::GetLED_Zone(int led_idx)
|
||||
{
|
||||
for(size_t 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((int)zone_idx);
|
||||
}
|
||||
}
|
||||
|
||||
return(-1);
|
||||
}
|
||||
|
||||
mode RGBController_LianLiStrimerLConnect::CreateMode(std::string name, int value, uint8_t colour_count, uint8_t colour_mode)
|
||||
{
|
||||
mode new_mode;
|
||||
new_mode.name = name;
|
||||
new_mode.value = value;
|
||||
new_mode.colors_min = colour_count;
|
||||
new_mode.colors_max = colour_count;
|
||||
new_mode.colors.resize(colour_count);
|
||||
new_mode.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
|
||||
new_mode.brightness_min = STRIMERLCONNECT_BRIGHTNESS_MIN;
|
||||
new_mode.brightness_max = STRIMERLCONNECT_BRIGHTNESS_MAX;
|
||||
new_mode.brightness = STRIMERLCONNECT_BRIGHTNESS_MAX;
|
||||
new_mode.speed_min = STRIMERLCONNECT_SPEED_SLOWEST;
|
||||
new_mode.speed_max = STRIMERLCONNECT_SPEED_FASTEST;
|
||||
new_mode.speed = STRIMERLCONNECT_SPEED_NORMAL;
|
||||
new_mode.color_mode = colour_mode;
|
||||
|
||||
return new_mode;
|
||||
}
|
||||
+44
@@ -0,0 +1,44 @@
|
||||
/*---------------------------------------------------------*\
|
||||
| RGBController_LianLiStrimerLConnect.h |
|
||||
| |
|
||||
| RGBController for Lian Li Strimer L Connect |
|
||||
| |
|
||||
| Chris M (Dr_No) 03 Jul 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 "LianLiStrimerLConnectController.h"
|
||||
|
||||
class RGBController_LianLiStrimerLConnect : public RGBController
|
||||
{
|
||||
public:
|
||||
RGBController_LianLiStrimerLConnect(LianLiStrimerLConnectController* controller_ptr);
|
||||
~RGBController_LianLiStrimerLConnect();
|
||||
|
||||
void SetupZones();
|
||||
void ResizeZone(int zone, int new_size);
|
||||
|
||||
void DeviceUpdateLEDs();
|
||||
void UpdateZoneLEDs(int zone);
|
||||
void UpdateSingleLED(int led);
|
||||
|
||||
void DeviceUpdateMode();
|
||||
|
||||
private:
|
||||
void Init_Controller();
|
||||
int GetDeviceMode();
|
||||
int GetLED_Zone(int led_idx);
|
||||
|
||||
mode CreateMode(std::string name, int value, uint8_t colour_count, uint8_t colour_mode);
|
||||
bool TimeToSend();
|
||||
|
||||
LianLiStrimerLConnectController* controller;
|
||||
std::chrono::time_point<std::chrono::steady_clock> last_commit_time;
|
||||
};
|
||||
@@ -0,0 +1,402 @@
|
||||
/*---------------------------------------------------------*\
|
||||
| LianLiUniHubALController.cpp |
|
||||
| |
|
||||
| Driver for Lian Li AL Uni Hub |
|
||||
| |
|
||||
| Oliver P 26 Apr 2022 |
|
||||
| Credit to Luca Lovisa for original work |
|
||||
| |
|
||||
| This file is part of the OpenRGB project |
|
||||
| SPDX-License-Identifier: GPL-2.0-or-later |
|
||||
\*---------------------------------------------------------*/
|
||||
|
||||
#include <string.h>
|
||||
#include "LianLiUniHubALController.h"
|
||||
#include "StringUtils.h"
|
||||
|
||||
using namespace std::chrono_literals;
|
||||
|
||||
LianLiUniHubALController::LianLiUniHubALController(hid_device* dev_handle, const char* path, unsigned short pid, std::string dev_name)
|
||||
{
|
||||
dev = dev_handle;
|
||||
dev_pid = pid;
|
||||
location = path;
|
||||
name = dev_name;
|
||||
}
|
||||
|
||||
LianLiUniHubALController::~LianLiUniHubALController()
|
||||
{
|
||||
hid_close(dev);
|
||||
}
|
||||
|
||||
std::string LianLiUniHubALController::GetDeviceLocation()
|
||||
{
|
||||
return("HID: " + location);
|
||||
}
|
||||
|
||||
std::string LianLiUniHubALController::GetFirmwareVersionString()
|
||||
{
|
||||
wchar_t product_string[40];
|
||||
int ret = hid_get_product_string(dev, product_string, 40);
|
||||
|
||||
if (ret != 0)
|
||||
{
|
||||
return ("");
|
||||
}
|
||||
|
||||
std::string return_string = StringUtils::wstring_to_string(product_string);
|
||||
|
||||
return(return_string.substr(return_string.find_last_of("-")+1,4).c_str());
|
||||
}
|
||||
|
||||
std::string LianLiUniHubALController::GetName()
|
||||
{
|
||||
return(name);
|
||||
}
|
||||
|
||||
std::string LianLiUniHubALController::GetSerialString()
|
||||
{
|
||||
wchar_t serial_string[20];
|
||||
int ret = hid_get_serial_number_string(dev, serial_string, 20);
|
||||
|
||||
if (ret != 0)
|
||||
{
|
||||
return ("");
|
||||
}
|
||||
|
||||
std::string return_string = StringUtils::wstring_to_string(serial_string);
|
||||
|
||||
return(return_string);
|
||||
|
||||
}
|
||||
|
||||
void LianLiUniHubALController::SetChannelLEDs(unsigned char channel, RGBColor * colors, unsigned int num_colors, float brightness)
|
||||
{
|
||||
unsigned char fan_led_data[96];
|
||||
unsigned char edge_led_data[144];
|
||||
int fan_idx = 0;
|
||||
int mod_led_idx;
|
||||
int cur_led_idx;
|
||||
|
||||
if(num_colors == 0)
|
||||
{
|
||||
return; // Do nothing, channel isn't in use
|
||||
}
|
||||
|
||||
for(unsigned int led_idx = 0; led_idx < num_colors; led_idx++)
|
||||
{
|
||||
mod_led_idx = (led_idx % 20);
|
||||
|
||||
if((mod_led_idx == 0) && (led_idx != 0))
|
||||
{
|
||||
fan_idx++;
|
||||
}
|
||||
|
||||
/*---------------------------------------------------------*\
|
||||
| Limiter to protect LEDs |
|
||||
\*---------------------------------------------------------*/
|
||||
if(UNIHUB_AL_LED_LIMITER && RGBGetRValue(colors[led_idx]) > 153 && (RGBGetRValue(colors[led_idx]) == RGBGetBValue(colors[led_idx])) && (RGBGetRValue(colors[led_idx]) == RGBGetGValue(colors[led_idx])) )
|
||||
{
|
||||
colors[led_idx] = ToRGBColor(153,153,153);
|
||||
}
|
||||
|
||||
if(mod_led_idx < 8) // Fan LEDs, 8 LEDs per fan
|
||||
{
|
||||
//Determine current position of led_data array from colors array
|
||||
cur_led_idx = ((mod_led_idx + (fan_idx * 8)) * 3);
|
||||
|
||||
fan_led_data[cur_led_idx + 0] = (unsigned char)(RGBGetRValue(colors[led_idx]) * brightness);
|
||||
fan_led_data[cur_led_idx + 1] = (unsigned char)(RGBGetBValue(colors[led_idx]) * brightness);
|
||||
fan_led_data[cur_led_idx + 2] = (unsigned char)(RGBGetGValue(colors[led_idx]) * brightness);
|
||||
}
|
||||
else // Edge LEDs, 12 LEDs per fan
|
||||
{
|
||||
//Determine current position of led_data array from colors array
|
||||
cur_led_idx = (((mod_led_idx - 8) + (fan_idx * 12)) * 3);
|
||||
|
||||
edge_led_data[cur_led_idx + 0] = (unsigned char)(RGBGetRValue(colors[led_idx]) * brightness);
|
||||
edge_led_data[cur_led_idx + 1] = (unsigned char)(RGBGetBValue(colors[led_idx]) * brightness);
|
||||
edge_led_data[cur_led_idx + 2] = (unsigned char)(RGBGetGValue(colors[led_idx]) * brightness);
|
||||
}
|
||||
}
|
||||
|
||||
/*---------------------------------------------------------*\
|
||||
| Send fan LED data |
|
||||
\*---------------------------------------------------------*/
|
||||
|
||||
SendStartAction
|
||||
(
|
||||
channel, // Current channel
|
||||
(fan_idx + 1) // Number of fans
|
||||
);
|
||||
|
||||
SendColorData
|
||||
(
|
||||
channel, // Channel
|
||||
0, // 0 = Fan, 1 = Edge
|
||||
(fan_idx + 1)*8,
|
||||
fan_led_data
|
||||
);
|
||||
|
||||
SendCommitAction
|
||||
(
|
||||
channel, // Channel
|
||||
0, // 0 = Fan, 1 = Edge
|
||||
UNIHUB_AL_LED_MODE_STATIC_COLOR, // Effect
|
||||
UNIHUB_AL_LED_SPEED_000, // Speed
|
||||
UNIHUB_AL_LED_DIRECTION_LTR, // Direction
|
||||
UNIHUB_AL_LED_BRIGHTNESS_100 // Brightness
|
||||
);
|
||||
|
||||
/*---------------------------------------------------------*\
|
||||
| Send edge LED data |
|
||||
\*---------------------------------------------------------*/
|
||||
SendStartAction
|
||||
(
|
||||
channel, // Current channel
|
||||
(fan_idx + 1) // Number of fans
|
||||
);
|
||||
|
||||
SendColorData
|
||||
(
|
||||
channel, // Channel
|
||||
1, // 0 = Fan, 1 = Edge
|
||||
(fan_idx + 1)*12,
|
||||
edge_led_data
|
||||
);
|
||||
|
||||
SendCommitAction
|
||||
(
|
||||
channel, // Channel
|
||||
1, // 0 = Fan, 1 = Edge
|
||||
UNIHUB_AL_LED_MODE_STATIC_COLOR, // Effect
|
||||
UNIHUB_AL_LED_SPEED_000, // Speed
|
||||
UNIHUB_AL_LED_DIRECTION_LTR, // Direction
|
||||
UNIHUB_AL_LED_BRIGHTNESS_100 // Brightness
|
||||
);
|
||||
|
||||
}
|
||||
|
||||
void LianLiUniHubALController::SetChannelMode(unsigned char channel, unsigned int mode_value, std::vector<RGBColor> colors, unsigned int num_colors, unsigned int num_fans, bool upd_both_fan_edge, unsigned int brightness, unsigned int speed, unsigned int direction)
|
||||
{
|
||||
static unsigned int brightness_code[5] =
|
||||
{
|
||||
UNIHUB_AL_LED_BRIGHTNESS_000,
|
||||
UNIHUB_AL_LED_BRIGHTNESS_025,
|
||||
UNIHUB_AL_LED_BRIGHTNESS_050,
|
||||
UNIHUB_AL_LED_BRIGHTNESS_075,
|
||||
UNIHUB_AL_LED_BRIGHTNESS_100
|
||||
};
|
||||
|
||||
static unsigned int speed_code[5] =
|
||||
{
|
||||
UNIHUB_AL_LED_SPEED_000,
|
||||
UNIHUB_AL_LED_SPEED_025,
|
||||
UNIHUB_AL_LED_SPEED_050,
|
||||
UNIHUB_AL_LED_SPEED_075,
|
||||
UNIHUB_AL_LED_SPEED_100
|
||||
};
|
||||
|
||||
unsigned char fan_led_data[96];
|
||||
unsigned char edge_led_data[144];
|
||||
int cur_led_idx;
|
||||
float brightness_scale;
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Zero out buffer |
|
||||
\*-----------------------------------------------------*/
|
||||
memset(fan_led_data, 0x00, sizeof(fan_led_data));
|
||||
memset(edge_led_data, 0x00, sizeof(edge_led_data));
|
||||
|
||||
if(num_colors) // Update led_data if there's colors
|
||||
{
|
||||
switch(mode_value)
|
||||
{
|
||||
case UNIHUB_AL_LED_MODE_STATIC_COLOR: // Static mode requires a full data array
|
||||
case UNIHUB_AL_LED_MODE_BREATHING:
|
||||
brightness_scale = static_cast<float>(brightness)/4;
|
||||
for(unsigned int i = 0; i < 4; i++)
|
||||
{
|
||||
/*---------------------------------------------------------*\
|
||||
| Limiter to protect LEDs |
|
||||
\*---------------------------------------------------------*/
|
||||
if(UNIHUB_AL_LED_LIMITER && RGBGetRValue(colors[i]) > 153 && (RGBGetRValue(colors[i]) == RGBGetBValue(colors[i])) && (RGBGetRValue(colors[i]) == RGBGetGValue(colors[i])) )
|
||||
{
|
||||
colors[i] = ToRGBColor(153,153,153);
|
||||
}
|
||||
|
||||
for(unsigned int led_idx = 0; led_idx < 22; led_idx += 3)
|
||||
{
|
||||
cur_led_idx = (i * 8 * 3) + led_idx;
|
||||
fan_led_data[cur_led_idx + 0] = (unsigned char)(RGBGetRValue(colors[i]) * brightness_scale);
|
||||
fan_led_data[cur_led_idx + 1] = (unsigned char)(RGBGetBValue(colors[i]) * brightness_scale);
|
||||
fan_led_data[cur_led_idx + 2] = (unsigned char)(RGBGetGValue(colors[i]) * brightness_scale);
|
||||
}
|
||||
|
||||
for(unsigned int led_idx = 0; led_idx < 34; led_idx += 3)
|
||||
{
|
||||
cur_led_idx = (i * 12 * 3) + led_idx;
|
||||
edge_led_data[cur_led_idx + 0] = (unsigned char)(RGBGetRValue(colors[i]) * brightness_scale);
|
||||
edge_led_data[cur_led_idx + 1] = (unsigned char)(RGBGetBValue(colors[i]) * brightness_scale);
|
||||
edge_led_data[cur_led_idx + 2] = (unsigned char)(RGBGetGValue(colors[i]) * brightness_scale);
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
||||
default:
|
||||
colors.resize(4);
|
||||
for(unsigned int i = num_colors; i < 4; i++)
|
||||
{
|
||||
colors[i] = 0x00;
|
||||
}
|
||||
|
||||
// needs a 48 length array of 4 colors, even if less are defined
|
||||
for(unsigned int i = 0; i < 4; i++)
|
||||
{
|
||||
for(unsigned int j = 0; j < 4; j++)
|
||||
{
|
||||
cur_led_idx = (i * 12) + (j * 3);
|
||||
fan_led_data[cur_led_idx + 0] = RGBGetRValue(colors[j]);
|
||||
fan_led_data[cur_led_idx + 1] = RGBGetBValue(colors[j]);
|
||||
fan_led_data[cur_led_idx + 2] = RGBGetGValue(colors[j]);
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
SendStartAction
|
||||
(
|
||||
channel, // Current channel
|
||||
(num_fans + 1) // Number of fans
|
||||
);
|
||||
|
||||
SendColorData
|
||||
(
|
||||
channel, // Channel
|
||||
0, // 0 = Fan, 1 = Edge
|
||||
(num_fans + 1)*8,
|
||||
fan_led_data // Data
|
||||
);
|
||||
|
||||
SendCommitAction
|
||||
(
|
||||
channel, // Channel
|
||||
0, // 0 = Fan, 1 = Edge
|
||||
mode_value, // Effect
|
||||
speed_code[speed], // Speed
|
||||
direction, // Direction
|
||||
brightness_code[brightness] // Brightness
|
||||
);
|
||||
|
||||
if(upd_both_fan_edge)
|
||||
{
|
||||
SendStartAction
|
||||
(
|
||||
channel, // Current channel
|
||||
(num_fans + 1) // Number of fans
|
||||
);
|
||||
|
||||
SendColorData
|
||||
(
|
||||
channel, // Channel
|
||||
1, // 0 = Fan, 1 = Edge
|
||||
(num_fans + 1)*12,
|
||||
edge_led_data
|
||||
);
|
||||
|
||||
SendCommitAction
|
||||
(
|
||||
channel, // Channel
|
||||
1, // 0 = Fan, 1 = Edge
|
||||
mode_value, // Effect
|
||||
speed_code[speed], // Speed
|
||||
direction, // Direction
|
||||
brightness_code[brightness] // Brightness
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
void LianLiUniHubALController::SendStartAction(unsigned char channel, unsigned int num_fans)
|
||||
{
|
||||
unsigned char usb_buf[65];
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Zero out buffer |
|
||||
\*-----------------------------------------------------*/
|
||||
memset(usb_buf, 0x00, sizeof(usb_buf));
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Set up message packet |
|
||||
\*-----------------------------------------------------*/
|
||||
usb_buf[0x00] = UNIHUB_AL_TRANSACTION_ID;
|
||||
usb_buf[0x01] = 0x10;
|
||||
usb_buf[0x02] = 0x40;
|
||||
usb_buf[0x03] = channel + 1;
|
||||
usb_buf[0x04] = num_fans;
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Send packet |
|
||||
\*-----------------------------------------------------*/
|
||||
hid_write(dev, usb_buf, 65);
|
||||
std::this_thread::sleep_for(5ms);
|
||||
|
||||
}
|
||||
|
||||
void LianLiUniHubALController::SendColorData(unsigned char channel, unsigned int fan_or_edge, unsigned int num_leds, unsigned char* led_data)
|
||||
{
|
||||
/*---------------------------------------------------------*\
|
||||
| Send edge LED data |
|
||||
\*---------------------------------------------------------*/
|
||||
|
||||
unsigned char usb_buf[146];
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Zero out buffer |
|
||||
\*-----------------------------------------------------*/
|
||||
memset(usb_buf, 0x00, sizeof(usb_buf));
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Set up message packet |
|
||||
\*-----------------------------------------------------*/
|
||||
usb_buf[0x00] = UNIHUB_AL_TRANSACTION_ID;
|
||||
usb_buf[0x01] = 0x30 + fan_or_edge + (channel * 2); // Channel+device (30 = channel 1 edge, 31 = channel 1 edge, 32 = channel 2 fan, 33 = channel 2 edge, etc.)
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Copy in color data bytes |
|
||||
\*-----------------------------------------------------*/
|
||||
memcpy(&usb_buf[0x02], led_data, num_leds * 3);
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Send packet |
|
||||
\*-----------------------------------------------------*/
|
||||
hid_write(dev, usb_buf, 146);
|
||||
std::this_thread::sleep_for(5ms);
|
||||
}
|
||||
|
||||
void LianLiUniHubALController::SendCommitAction(unsigned char channel, unsigned int fan_or_edge, unsigned char effect, unsigned char speed, unsigned int direction, unsigned int brightness)
|
||||
{
|
||||
unsigned char usb_buf[65];
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Zero out buffer |
|
||||
\*-----------------------------------------------------*/
|
||||
memset(usb_buf, 0x00, sizeof(usb_buf));
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Set up message packet |
|
||||
\*-----------------------------------------------------*/
|
||||
usb_buf[0x00] = UNIHUB_AL_TRANSACTION_ID;
|
||||
usb_buf[0x01] = 0x10 + fan_or_edge + (channel*2); // Channel+device (10 = channel 1 fan, 11 = channel 1 edge, 12 = channel 2 fan, 13 = chanell 2 edge, etc.)
|
||||
usb_buf[0x02] = effect; // Effect
|
||||
usb_buf[0x03] = speed; // Speed, 02=0%, 01=25%, 00=50%, ff=75%, fe=100%
|
||||
usb_buf[0x04] = direction; // Direction, right=00, left=01
|
||||
usb_buf[0x05] = brightness; // Brightness, 0=100%, 1= 75%, 2 = 50%, 3 = 25%, 8 = 0%
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Send packet |
|
||||
\*-----------------------------------------------------*/
|
||||
hid_write(dev, usb_buf, 65);
|
||||
std::this_thread::sleep_for(5ms);
|
||||
}
|
||||
@@ -0,0 +1,217 @@
|
||||
/*---------------------------------------------------------*\
|
||||
| LianLiUniHubALController.h |
|
||||
| |
|
||||
| Driver for Lian Li AL Uni Hub |
|
||||
| |
|
||||
| Oliver P 26 Apr 2022 |
|
||||
| Credit to Luca Lovisa for original work |
|
||||
| |
|
||||
| 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"
|
||||
|
||||
/*----------------------------------------------------------------------------*\
|
||||
| Global definitions. |
|
||||
\*----------------------------------------------------------------------------*/
|
||||
|
||||
/*----------------------------------------------------------------------------*\
|
||||
| Definitions related to zone Sizes |
|
||||
\*----------------------------------------------------------------------------*/
|
||||
|
||||
|
||||
enum
|
||||
{
|
||||
UNIHUB_AL_CHANNEL_COUNT = 0x04, /* Channel count */
|
||||
UNIHUB_AL_CHAN_FANLED_COUNT = 0x20, /* Max-LED per channel count - 32 */
|
||||
UNIHUB_AL_CHAN_EDGELED_COUNT = 0x30, /* Max-LED per channel count - 48 */
|
||||
UNIHUB_AL_CHAN_LED_COUNT = 0x50, /* Max-LED per channel count - 80 */
|
||||
};
|
||||
|
||||
/*----------------------------------------------------------------------------*\
|
||||
| Definitions related to LED configuration. |
|
||||
\*----------------------------------------------------------------------------*/
|
||||
|
||||
// Used for sync'd mode between Fan and Edge
|
||||
|
||||
enum
|
||||
{
|
||||
UNIHUB_AL_LED_MODE_RAINBOW = 0x28, /* Rainbow mode - Calls Fan only */
|
||||
UNIHUB_AL_LED_MODE_RAINBOW_MORPH = 0x35, /* Rainbow Morph mode - Calls Fan only */
|
||||
UNIHUB_AL_LED_MODE_STATIC_COLOR = 0x01, /* Static Color mode */
|
||||
UNIHUB_AL_LED_MODE_BREATHING = 0x02, /* Breathing mode */
|
||||
UNIHUB_AL_LED_MODE_TAICHI = 0x2C, /* Neon mode - Calls Fan only */
|
||||
UNIHUB_AL_LED_MODE_COLOR_CYCLE = 0x2B, /* Color Cycle mode - Calls Fan only */
|
||||
UNIHUB_AL_LED_MODE_RUNWAY = 0x1A, /* Runway mode */
|
||||
UNIHUB_AL_LED_MODE_METEOR = 0x19, /* Meteor mode */
|
||||
UNIHUB_AL_LED_MODE_WARNING = 0x2D, /* Warning mode - Calls Fan only */
|
||||
UNIHUB_AL_LED_MODE_VOICE = 0x2E, /* Voice mode - Calls Fan only */
|
||||
UNIHUB_AL_LED_MODE_SPINNING_TEACUP = 0x38, /* Spinning Teacup mode - Calls Fan only */
|
||||
UNIHUB_AL_LED_MODE_TORNADO = 0x36, /* Tornado mode - Calls Fan only */
|
||||
UNIHUB_AL_LED_MODE_MIXING = 0x2F, /* Mixing mode - Calls Fan only */
|
||||
UNIHUB_AL_LED_MODE_STACK = 0x30, /* Stack mode - Calls Fan only */
|
||||
UNIHUB_AL_LED_MODE_STAGGGERED = 0x37, /* Stagggered mode - Calls Fan only */
|
||||
UNIHUB_AL_LED_MODE_TIDE = 0x31, /* Tide mode - Calls Fan only */
|
||||
UNIHUB_AL_LED_MODE_SCAN = 0x32, /* Scan mode - Calls Fan only */
|
||||
UNIHUB_AL_LED_MODE_CONTEST = 0x33, /* Contest mode - Calls Fan only */
|
||||
|
||||
};
|
||||
|
||||
enum
|
||||
{
|
||||
UNIHUB_AL_LED_SPEED_000 = 0x02, /* Very slow speed */
|
||||
UNIHUB_AL_LED_SPEED_025 = 0x01, /* Rather slow speed */
|
||||
UNIHUB_AL_LED_SPEED_050 = 0x00, /* Medium speed */
|
||||
UNIHUB_AL_LED_SPEED_075 = 0xFF, /* Rather fast speed */
|
||||
UNIHUB_AL_LED_SPEED_100 = 0xFE, /* Very fast speed */
|
||||
};
|
||||
|
||||
enum
|
||||
{
|
||||
UNIHUB_AL_LED_DIRECTION_LTR = 0x00, /* Left-to-Right direction */
|
||||
UNIHUB_AL_LED_DIRECTION_RTL = 0x01, /* Right-to-Left direction */
|
||||
};
|
||||
|
||||
enum
|
||||
{
|
||||
UNIHUB_AL_LED_BRIGHTNESS_000 = 0x08, /* Very dark (off) */
|
||||
UNIHUB_AL_LED_BRIGHTNESS_025 = 0x03, /* Rather dark */
|
||||
UNIHUB_AL_LED_BRIGHTNESS_050 = 0x02, /* Medium bright */
|
||||
UNIHUB_AL_LED_BRIGHTNESS_075 = 0x01, /* Rather bright */
|
||||
UNIHUB_AL_LED_BRIGHTNESS_100 = 0x00, /* Very bright */
|
||||
};
|
||||
|
||||
enum
|
||||
{
|
||||
UNIHUB_AL_LED_LIMITER = 0x01 /* Limit the color white to 999999 as per manufacturer limits */
|
||||
};
|
||||
|
||||
|
||||
/*----------------------------------------------------------------------------*\
|
||||
| Definitions related to packet configuration. |
|
||||
\*----------------------------------------------------------------------------*/
|
||||
|
||||
enum
|
||||
{
|
||||
UNIHUB_AL_TRANSACTION_ID = 0xE0, /* Command value to start all packets */
|
||||
};
|
||||
|
||||
/*----------------------------------------------------------------------------*\
|
||||
| Uni Hub AL controller. |
|
||||
\*----------------------------------------------------------------------------*/
|
||||
|
||||
class LianLiUniHubALController
|
||||
{
|
||||
|
||||
|
||||
public:
|
||||
LianLiUniHubALController(hid_device* dev_handle, const char* path, unsigned short pid, std::string dev_name);
|
||||
~LianLiUniHubALController();
|
||||
|
||||
std::string GetDeviceLocation();
|
||||
std::string GetFirmwareVersionString();
|
||||
std::string GetName();
|
||||
std::string GetSerialString();
|
||||
|
||||
void SetChannelMode
|
||||
(
|
||||
unsigned char channel,
|
||||
unsigned int mode_value,
|
||||
std::vector<RGBColor> colors, // Not a pointer because the copy gets resized
|
||||
unsigned int num_colors,
|
||||
unsigned int num_fans,
|
||||
bool upd_both_fan_edge,
|
||||
unsigned int brightness,
|
||||
unsigned int speed,
|
||||
unsigned int direction
|
||||
);
|
||||
|
||||
void SetChannelLEDs
|
||||
(
|
||||
unsigned char channel,
|
||||
RGBColor * colors,
|
||||
unsigned int num_colors,
|
||||
float brightness
|
||||
);
|
||||
|
||||
void SendStartAction
|
||||
(
|
||||
unsigned char channel,
|
||||
unsigned int num_fans
|
||||
);
|
||||
|
||||
void SendColorData
|
||||
(
|
||||
unsigned char channel, // Zone index
|
||||
unsigned int fan_or_edge, // 1 (Fan) or 0 (Edge) modifer to channel
|
||||
unsigned int num_leds,
|
||||
unsigned char* led_data // Color data payload
|
||||
);
|
||||
|
||||
void SendCommitAction
|
||||
(
|
||||
unsigned char channel, // Zone index
|
||||
unsigned int fan_or_edge, // 1 (Fan) or 0 (Edge) modifer to channel
|
||||
unsigned char effect,
|
||||
unsigned char speed,
|
||||
unsigned int direction,
|
||||
unsigned int brightness
|
||||
);
|
||||
|
||||
private:
|
||||
/* The Uni Hub requires colors in RBG order */
|
||||
struct Color
|
||||
{
|
||||
uint8_t r;
|
||||
uint8_t b;
|
||||
uint8_t g;
|
||||
};
|
||||
|
||||
/* The values correspond to the definitions above */
|
||||
struct Channel
|
||||
{
|
||||
uint8_t index;
|
||||
|
||||
uint8_t anyFanCountOffset;
|
||||
uint8_t anyFanCount;
|
||||
|
||||
uint16_t ledActionAddress;
|
||||
uint16_t ledCommitAddress;
|
||||
uint16_t ledModeAddress;
|
||||
uint16_t ledSpeedAddress;
|
||||
uint16_t ledDirectionAddress;
|
||||
uint16_t ledBrightnessAddress;
|
||||
|
||||
Color colors[UNIHUB_AL_CHAN_FANLED_COUNT];
|
||||
|
||||
uint8_t ledMode;
|
||||
uint8_t ledSpeed;
|
||||
uint8_t ledDirection;
|
||||
uint8_t ledBrightness;
|
||||
|
||||
uint16_t fanHubActionAddress;
|
||||
uint16_t fanHubCommitAddress;
|
||||
|
||||
uint16_t fanPwmActionAddress;
|
||||
uint16_t fanPwmCommitAddress;
|
||||
uint16_t fanRpmActionAddress;
|
||||
|
||||
uint16_t fanSpeed;
|
||||
};
|
||||
|
||||
private:
|
||||
hid_device* dev;
|
||||
unsigned short dev_pid;
|
||||
|
||||
/*---------------------------------------------------------*\
|
||||
| Device information strings |
|
||||
\*---------------------------------------------------------*/
|
||||
std::string firmware_version;
|
||||
std::string location;
|
||||
std::string name;
|
||||
};
|
||||
+524
@@ -0,0 +1,524 @@
|
||||
/*---------------------------------------------------------*\
|
||||
| RGBController_LianLiUniHubAL.cpp |
|
||||
| |
|
||||
| RGBController for Lian Li AL Uni Hub |
|
||||
| |
|
||||
| Oliver P 26 Apr 2022 |
|
||||
| Credit to Luca Lovisa for original work |
|
||||
| |
|
||||
| This file is part of the OpenRGB project |
|
||||
| SPDX-License-Identifier: GPL-2.0-or-later |
|
||||
\*---------------------------------------------------------*/
|
||||
|
||||
#include <string>
|
||||
#include "RGBController_LianLiUniHubAL.h"
|
||||
|
||||
//0xFFFFFFFF indicates an unused entry in matrix
|
||||
#define NA 0xFFFFFFFF
|
||||
|
||||
static unsigned int matrix_map[8][35] =
|
||||
{ { NA, NA, 10, NA, NA, 11, NA, NA, NA, NA, NA, 30, NA, NA, 31, NA, NA, NA, NA, NA, 50, NA, NA, 51, NA, NA, NA, NA, NA, 70, NA, NA, 71, NA, NA},
|
||||
{ NA, 9, NA, NA, NA, NA, 12, NA, NA, NA, 29, NA, NA, NA, NA, 32, NA, NA, NA, 49, NA, NA, NA, NA, 52, NA, NA, NA, 69, NA, NA, NA, NA, 72, NA},
|
||||
{ 8, NA, NA, 1, 2, NA, NA, 13, NA, 28, NA, NA, 21, 22, NA, NA, 33, NA, 48, NA, NA, 41, 42, NA, NA, 53, NA, 68, NA, NA, 61, 62, NA, NA, 73},
|
||||
{ NA, NA, 0, NA, NA, 3, NA, NA, NA, NA, NA, 20, NA, NA, 23, NA, NA, NA, NA, NA, 40, NA, NA, 43, NA, NA, NA, NA, NA, 60, NA, NA, 63, NA, NA},
|
||||
{ NA, NA, 7, NA, NA, 4, NA, NA, NA, NA, NA, 27, NA, NA, 24, NA, NA, NA, NA, NA, 47, NA, NA, 44, NA, NA, NA, NA, NA, 67, NA, NA, 64, NA, NA},
|
||||
{ 19, NA, NA, 6, 5, NA, NA, 14, NA, 39, NA, NA, 26, 25, NA, NA, 34, NA, 59, NA, NA, 46, 45, NA, NA, 54, NA, 79, NA, NA, 66, 65, NA, NA, 74},
|
||||
{ NA, 18, NA, NA, NA, NA, 15, NA, NA, NA, 38, NA, NA, NA, NA, 35, NA, NA, NA, 58, NA, NA, NA, NA, 55, NA, NA, NA, 78, NA, NA, NA, NA, 75, NA},
|
||||
{ NA, NA, 17, NA, NA, 16, NA, NA, NA, NA, NA, 37, NA, NA, 36, NA, NA, NA, NA, NA, 57, NA, NA, 56, NA, NA, NA, NA, NA, 77, NA, NA, 76, NA, NA}
|
||||
};
|
||||
|
||||
/**------------------------------------------------------------------*\
|
||||
@name Lian Li Uni Hub AL
|
||||
@type USB
|
||||
@save :x:
|
||||
@direct :rotating_light:
|
||||
@effects :white_check_mark:
|
||||
@detectors DetectLianLiUniHubAL
|
||||
@comment
|
||||
\*-------------------------------------------------------------------*/
|
||||
|
||||
RGBController_LianLiUniHubAL::RGBController_LianLiUniHubAL(LianLiUniHubALController* controller_ptr)
|
||||
{
|
||||
controller = controller_ptr;
|
||||
|
||||
name = controller->GetName();
|
||||
vendor = "Lian Li";
|
||||
type = DEVICE_TYPE_COOLER;
|
||||
description = "Lian Li Uni Hub - AL";
|
||||
version = controller->GetFirmwareVersionString();
|
||||
location = controller->GetDeviceLocation();
|
||||
serial = controller->GetSerialString();
|
||||
|
||||
|
||||
initializedMode = false;
|
||||
|
||||
mode Custom;
|
||||
Custom.name = "Custom";
|
||||
Custom.value = UNIHUB_AL_LED_MODE_STATIC_COLOR;
|
||||
Custom.flags = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_PER_LED_COLOR;
|
||||
Custom.brightness_min = 0;
|
||||
Custom.brightness_max = 50;
|
||||
Custom.brightness = 37;
|
||||
Custom.color_mode = MODE_COLORS_PER_LED;
|
||||
modes.push_back(Custom);
|
||||
|
||||
mode RainbowWave;
|
||||
RainbowWave.name = "Rainbow Wave";
|
||||
RainbowWave.value = UNIHUB_AL_LED_MODE_RAINBOW;
|
||||
RainbowWave.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_DIRECTION_LR;
|
||||
RainbowWave.speed_min = 0;
|
||||
RainbowWave.speed_max = 4;
|
||||
RainbowWave.brightness_min = 0;
|
||||
RainbowWave.brightness_max = 4;
|
||||
RainbowWave.speed = 3;
|
||||
RainbowWave.brightness = 3;
|
||||
RainbowWave.direction = UNIHUB_AL_LED_DIRECTION_LTR;
|
||||
RainbowWave.color_mode = MODE_COLORS_NONE;
|
||||
modes.push_back(RainbowWave);
|
||||
|
||||
mode RainbowMorph;
|
||||
RainbowMorph.name = "Rainbow Morph";
|
||||
RainbowMorph.value = UNIHUB_AL_LED_MODE_RAINBOW_MORPH;
|
||||
RainbowMorph.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
|
||||
RainbowMorph.speed_min = 0;
|
||||
RainbowMorph.speed_max = 4;
|
||||
RainbowMorph.brightness_min = 0;
|
||||
RainbowMorph.brightness_max = 4;
|
||||
RainbowMorph.speed = 3;
|
||||
RainbowMorph.brightness = 3;
|
||||
RainbowMorph.color_mode = MODE_COLORS_NONE;
|
||||
modes.push_back(RainbowMorph);
|
||||
|
||||
mode StaticColor;
|
||||
StaticColor.name = "Static Color";
|
||||
StaticColor.value = UNIHUB_AL_LED_MODE_STATIC_COLOR;
|
||||
StaticColor.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
|
||||
StaticColor.brightness_min = 0;
|
||||
StaticColor.brightness_max = 4;
|
||||
StaticColor.colors_min = 0;
|
||||
StaticColor.colors_max = 4;
|
||||
StaticColor.brightness = 3;
|
||||
StaticColor.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
StaticColor.colors.resize(4);
|
||||
modes.push_back(StaticColor);
|
||||
|
||||
mode Breathing;
|
||||
Breathing.name = "Breathing";
|
||||
Breathing.value = UNIHUB_AL_LED_MODE_BREATHING;
|
||||
Breathing.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
|
||||
Breathing.speed_min = 0;
|
||||
Breathing.speed_max = 4;
|
||||
Breathing.brightness_min = 0;
|
||||
Breathing.brightness_max = 4;
|
||||
Breathing.colors_min = 0;
|
||||
Breathing.colors_max = 4;
|
||||
Breathing.speed = 3;
|
||||
Breathing.brightness = 3;
|
||||
Breathing.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Breathing.colors.resize(4);
|
||||
modes.push_back(Breathing);
|
||||
|
||||
mode Taichi;
|
||||
Taichi.name = "Taichi";
|
||||
Taichi.value = UNIHUB_AL_LED_MODE_TAICHI;
|
||||
Taichi.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_DIRECTION_LR;
|
||||
Taichi.speed_min = 0;
|
||||
Taichi.speed_max = 4;
|
||||
Taichi.brightness_min = 0;
|
||||
Taichi.brightness_max = 4;
|
||||
Taichi.colors_min = 0;
|
||||
Taichi.colors_max = 2;
|
||||
Taichi.speed = 3;
|
||||
Taichi.brightness = 3;
|
||||
Taichi.direction = UNIHUB_AL_LED_DIRECTION_LTR;
|
||||
Taichi.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Taichi.colors.resize(2);
|
||||
modes.push_back(Taichi);
|
||||
|
||||
mode ColorCycle;
|
||||
ColorCycle.name = "ColorCycle";
|
||||
ColorCycle.value = UNIHUB_AL_LED_MODE_COLOR_CYCLE;
|
||||
ColorCycle.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_DIRECTION_LR;
|
||||
ColorCycle.speed_min = 0;
|
||||
ColorCycle.speed_max = 4;
|
||||
ColorCycle.brightness_min = 0;
|
||||
ColorCycle.brightness_max = 4;
|
||||
ColorCycle.colors_min = 0;
|
||||
ColorCycle.colors_max = 4;
|
||||
ColorCycle.speed = 3;
|
||||
ColorCycle.brightness = 3;
|
||||
ColorCycle.direction = UNIHUB_AL_LED_DIRECTION_LTR;
|
||||
ColorCycle.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
ColorCycle.colors.resize(4);
|
||||
modes.push_back(ColorCycle);
|
||||
|
||||
mode Runway;
|
||||
Runway.name = "Runway";
|
||||
Runway.value = UNIHUB_AL_LED_MODE_RUNWAY;
|
||||
Runway.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
|
||||
Runway.speed_min = 0;
|
||||
Runway.speed_max = 4;
|
||||
Runway.brightness_min = 0;
|
||||
Runway.brightness_max = 4;
|
||||
Runway.colors_min = 0;
|
||||
Runway.colors_max = 2;
|
||||
Runway.speed = 3;
|
||||
Runway.brightness = 3;
|
||||
Runway.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Runway.colors.resize(2);
|
||||
modes.push_back(Runway);
|
||||
|
||||
mode Meteor;
|
||||
Meteor.name = "Meteor";
|
||||
Meteor.value = UNIHUB_AL_LED_MODE_METEOR;
|
||||
Meteor.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_DIRECTION_LR;
|
||||
Meteor.speed_min = 0;
|
||||
Meteor.speed_max = 4;
|
||||
Meteor.brightness_min = 0;
|
||||
Meteor.brightness_max = 4;
|
||||
Meteor.colors_min = 0;
|
||||
Meteor.colors_max = 4;
|
||||
Meteor.speed = 3;
|
||||
Meteor.brightness = 3;
|
||||
Meteor.direction = UNIHUB_AL_LED_DIRECTION_LTR;
|
||||
Meteor.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Meteor.colors.resize(4);
|
||||
modes.push_back(Meteor);
|
||||
|
||||
mode Warning;
|
||||
Warning.name = "Warning";
|
||||
Warning.value = UNIHUB_AL_LED_MODE_WARNING;
|
||||
Warning.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
|
||||
Warning.speed_min = 0;
|
||||
Warning.speed_max = 4;
|
||||
Warning.brightness_min = 0;
|
||||
Warning.brightness_max = 4;
|
||||
Warning.colors_min = 0;
|
||||
Warning.colors_max = 4;
|
||||
Warning.speed = 3;
|
||||
Warning.brightness = 3;
|
||||
Warning.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Warning.colors.resize(4);
|
||||
modes.push_back(Warning);
|
||||
|
||||
mode Voice;
|
||||
Voice.name = "Voice";
|
||||
Voice.value = UNIHUB_AL_LED_MODE_VOICE;
|
||||
Voice.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_DIRECTION_LR;
|
||||
Voice.speed_min = 0;
|
||||
Voice.speed_max = 4;
|
||||
Voice.brightness_min = 0;
|
||||
Voice.brightness_max = 4;
|
||||
Voice.colors_min = 0;
|
||||
Voice.colors_max = 4;
|
||||
Voice.speed = 3;
|
||||
Voice.brightness = 3;
|
||||
Voice.direction = UNIHUB_AL_LED_DIRECTION_LTR;
|
||||
Voice.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Voice.colors.resize(4);
|
||||
modes.push_back(Voice);
|
||||
|
||||
mode SpinningTeacup;
|
||||
SpinningTeacup.name = "SpinningTeacup";
|
||||
SpinningTeacup.value = UNIHUB_AL_LED_MODE_SPINNING_TEACUP;
|
||||
SpinningTeacup.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_DIRECTION_LR;
|
||||
SpinningTeacup.speed_min = 0;
|
||||
SpinningTeacup.speed_max = 4;
|
||||
SpinningTeacup.brightness_min = 0;
|
||||
SpinningTeacup.brightness_max = 4;
|
||||
SpinningTeacup.colors_min = 0;
|
||||
SpinningTeacup.colors_max = 4;
|
||||
SpinningTeacup.speed = 3;
|
||||
SpinningTeacup.brightness = 3;
|
||||
SpinningTeacup.direction = UNIHUB_AL_LED_DIRECTION_LTR;
|
||||
SpinningTeacup.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
SpinningTeacup.colors.resize(4);
|
||||
modes.push_back(SpinningTeacup);
|
||||
|
||||
mode Tornado;
|
||||
Tornado.name = "Tornado";
|
||||
Tornado.value = UNIHUB_AL_LED_MODE_TORNADO;
|
||||
Tornado.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_DIRECTION_LR;
|
||||
Tornado.speed_min = 0;
|
||||
Tornado.speed_max = 4;
|
||||
Tornado.brightness_min = 0;
|
||||
Tornado.brightness_max = 4;
|
||||
Tornado.colors_min = 0;
|
||||
Tornado.colors_max = 4;
|
||||
Tornado.speed = 3;
|
||||
Tornado.brightness = 3;
|
||||
Tornado.direction = UNIHUB_AL_LED_DIRECTION_LTR;
|
||||
Tornado.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Tornado.colors.resize(4);
|
||||
modes.push_back(Tornado);
|
||||
|
||||
mode Mixing;
|
||||
Mixing.name = "Mixing";
|
||||
Mixing.value = UNIHUB_AL_LED_MODE_MIXING;
|
||||
Mixing.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
|
||||
Mixing.speed_min = 0;
|
||||
Mixing.speed_max = 4;
|
||||
Mixing.brightness_min = 0;
|
||||
Mixing.brightness_max = 4;
|
||||
Mixing.colors_min = 0;
|
||||
Mixing.colors_max = 2;
|
||||
Mixing.speed = 3;
|
||||
Mixing.brightness = 3;
|
||||
Mixing.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Mixing.colors.resize(2);
|
||||
modes.push_back(Mixing);
|
||||
|
||||
mode Stack;
|
||||
Stack.name = "Stack";
|
||||
Stack.value = UNIHUB_AL_LED_MODE_STACK;
|
||||
Stack.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_DIRECTION_LR;
|
||||
Stack.speed_min = 0;
|
||||
Stack.speed_max = 4;
|
||||
Stack.brightness_min = 0;
|
||||
Stack.brightness_max = 4;
|
||||
Stack.colors_min = 0;
|
||||
Stack.colors_max = 2;
|
||||
Stack.speed = 3;
|
||||
Stack.brightness = 3;
|
||||
Stack.direction = UNIHUB_AL_LED_DIRECTION_LTR;
|
||||
Stack.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Stack.colors.resize(2);
|
||||
modes.push_back(Stack);
|
||||
|
||||
mode Staggered;
|
||||
Staggered.name = "Staggered";
|
||||
Staggered.value = UNIHUB_AL_LED_MODE_STAGGGERED;
|
||||
Staggered.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
|
||||
Staggered.speed_min = 0;
|
||||
Staggered.speed_max = 4;
|
||||
Staggered.brightness_min = 0;
|
||||
Staggered.brightness_max = 4;
|
||||
Staggered.colors_min = 0;
|
||||
Staggered.colors_max = 4;
|
||||
Staggered.speed = 3;
|
||||
Staggered.brightness = 3;
|
||||
Staggered.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Staggered.colors.resize(4);
|
||||
modes.push_back(Staggered);
|
||||
|
||||
mode Tide;
|
||||
Tide.name = "Tide";
|
||||
Tide.value = UNIHUB_AL_LED_MODE_TIDE;
|
||||
Tide.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
|
||||
Tide.speed_min = 0;
|
||||
Tide.speed_max = 4;
|
||||
Tide.brightness_min = 0;
|
||||
Tide.brightness_max = 4;
|
||||
Tide.colors_min = 0;
|
||||
Tide.colors_max = 4;
|
||||
Tide.speed = 3;
|
||||
Tide.brightness = 3;
|
||||
Tide.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Tide.colors.resize(4);
|
||||
modes.push_back(Tide);
|
||||
|
||||
mode Scan;
|
||||
Scan.name = "Scan";
|
||||
Scan.value = UNIHUB_AL_LED_MODE_SCAN;
|
||||
Scan.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
|
||||
Scan.speed_min = 0;
|
||||
Scan.speed_max = 4;
|
||||
Scan.brightness_min = 0;
|
||||
Scan.brightness_max = 4;
|
||||
Scan.colors_min = 0;
|
||||
Scan.colors_max = 2;
|
||||
Scan.speed = 3;
|
||||
Scan.brightness = 3;
|
||||
Scan.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Scan.colors.resize(2);
|
||||
modes.push_back(Scan);
|
||||
|
||||
mode Contest;
|
||||
Contest.name = "Contest";
|
||||
Contest.value = UNIHUB_AL_LED_MODE_CONTEST;
|
||||
Contest.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_DIRECTION_LR;
|
||||
Contest.speed_min = 0;
|
||||
Contest.speed_max = 4;
|
||||
Contest.brightness_min = 0;
|
||||
Contest.brightness_max = 4;
|
||||
Contest.colors_min = 0;
|
||||
Contest.colors_max = 2;
|
||||
Contest.speed = 3;
|
||||
Contest.brightness = 3;
|
||||
Contest.direction = UNIHUB_AL_LED_DIRECTION_LTR;
|
||||
Contest.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Contest.colors.resize(3);
|
||||
modes.push_back(Contest);
|
||||
|
||||
RGBController_LianLiUniHubAL::SetupZones();
|
||||
}
|
||||
|
||||
RGBController_LianLiUniHubAL::~RGBController_LianLiUniHubAL()
|
||||
{
|
||||
/*---------------------------------------------------------*\
|
||||
| Delete the matrix map |
|
||||
\*---------------------------------------------------------*/
|
||||
for(unsigned int zone_index = 0; zone_index < zones.size(); zone_index++)
|
||||
{
|
||||
if(zones[zone_index].matrix_map != NULL)
|
||||
{
|
||||
delete zones[zone_index].matrix_map;
|
||||
}
|
||||
}
|
||||
|
||||
delete controller;
|
||||
}
|
||||
|
||||
void RGBController_LianLiUniHubAL::SetupZones()
|
||||
{
|
||||
/*-------------------------------------------------*\
|
||||
| Only set LED count on the first run |
|
||||
\*-------------------------------------------------*/
|
||||
bool first_run = false;
|
||||
|
||||
if(zones.size() == 0)
|
||||
{
|
||||
first_run = true;
|
||||
zones.resize(UNIHUB_AL_CHANNEL_COUNT);
|
||||
}
|
||||
|
||||
/*-------------------------------------------------*\
|
||||
| Clear any existing color/LED configuration |
|
||||
\*-------------------------------------------------*/
|
||||
leds.clear();
|
||||
colors.clear();
|
||||
|
||||
/*-------------------------------------------------*\
|
||||
| Set zones and leds |
|
||||
\*-------------------------------------------------*/
|
||||
for(unsigned int channel_idx = 0; channel_idx < zones.size(); channel_idx++)
|
||||
{
|
||||
zones[channel_idx].name = "Channel ";
|
||||
zones[channel_idx].name.append(std::to_string(channel_idx + 1));
|
||||
|
||||
// Note: Matrix types won't get loaded from the sizes.ors as the default zone type in this RGBController is ZONE_TYPE_LINEAR
|
||||
// This will require augmentation on the ProfileManager.cpp to be able to override zone types but this is probably not wanted in general
|
||||
if (zones[channel_idx].leds_count == 60 || zones[channel_idx].leds_count == 40 || zones[channel_idx].leds_count == 20 || zones[channel_idx].leds_count == 80) // Assume they're AL120 Fans
|
||||
{
|
||||
zones[channel_idx].type = ZONE_TYPE_MATRIX;
|
||||
zones[channel_idx].leds_min = 0;
|
||||
zones[channel_idx].leds_max = UNIHUB_AL_CHAN_LED_COUNT;
|
||||
zones[channel_idx].matrix_map = new matrix_map_type;
|
||||
zones[channel_idx].matrix_map->height = 8;
|
||||
zones[channel_idx].matrix_map->width = 35;
|
||||
zones[channel_idx].matrix_map->map = (unsigned int *)&matrix_map;
|
||||
}
|
||||
else // Treat as regular LED strip
|
||||
{
|
||||
zones[channel_idx].type = ZONE_TYPE_LINEAR;
|
||||
zones[channel_idx].leds_min = 0;
|
||||
zones[channel_idx].leds_max = UNIHUB_AL_CHAN_LED_COUNT;
|
||||
}
|
||||
|
||||
if(first_run)
|
||||
{
|
||||
zones[channel_idx].leds_count = zones[channel_idx].leds_min;
|
||||
}
|
||||
|
||||
for(unsigned int led_ch_idx = 0; led_ch_idx < zones[channel_idx].leds_count; led_ch_idx++)
|
||||
{
|
||||
led new_led;
|
||||
new_led.name = zones[channel_idx].name;
|
||||
new_led.name.append(", LED ");
|
||||
new_led.name.append(std::to_string(led_ch_idx + 1));
|
||||
new_led.value = channel_idx;
|
||||
|
||||
leds.push_back(new_led);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
SetupColors();
|
||||
}
|
||||
|
||||
void RGBController_LianLiUniHubAL::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_LianLiUniHubAL::DeviceUpdateLEDs()
|
||||
{
|
||||
|
||||
if(!initializedMode)
|
||||
{
|
||||
DeviceUpdateMode();
|
||||
}
|
||||
|
||||
float brightness_scale = static_cast<float>(modes[active_mode].brightness)/modes[active_mode].brightness_max;
|
||||
|
||||
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, brightness_scale);
|
||||
}
|
||||
}
|
||||
|
||||
void RGBController_LianLiUniHubAL::UpdateZoneLEDs(int zone)
|
||||
{
|
||||
if(!initializedMode)
|
||||
{
|
||||
DeviceUpdateMode();
|
||||
}
|
||||
|
||||
float brightness_scale = static_cast<float>(modes[active_mode].brightness)/modes[active_mode].brightness_max;
|
||||
|
||||
controller->SetChannelLEDs(zone, zones[zone].colors, zones[zone].leds_count, brightness_scale);
|
||||
}
|
||||
|
||||
void RGBController_LianLiUniHubAL::UpdateSingleLED(int /* led */)
|
||||
{
|
||||
DeviceUpdateMode();
|
||||
|
||||
}
|
||||
|
||||
void RGBController_LianLiUniHubAL::DeviceUpdateMode()
|
||||
{
|
||||
if(!active_mode)
|
||||
{
|
||||
return; // Do nothing, custom mode should go through DeviceUpdateLEDs() to avoid flooding controller
|
||||
}
|
||||
|
||||
initializedMode = true;
|
||||
|
||||
int fan_idx = 0;
|
||||
bool upd_both_fan_edge = false;
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Check modes that requires updating both arrays |
|
||||
\*-----------------------------------------------------*/
|
||||
|
||||
switch(modes[active_mode].value)
|
||||
{
|
||||
case UNIHUB_AL_LED_MODE_STATIC_COLOR:
|
||||
case UNIHUB_AL_LED_MODE_BREATHING:
|
||||
case UNIHUB_AL_LED_MODE_RUNWAY:
|
||||
case UNIHUB_AL_LED_MODE_METEOR:
|
||||
upd_both_fan_edge = true;
|
||||
break;
|
||||
}
|
||||
|
||||
for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
|
||||
{
|
||||
if(zones[zone_idx].leds_count == 0)
|
||||
{
|
||||
return; // Do nothing, channel isn't in use
|
||||
}
|
||||
fan_idx = ((zones[zone_idx].leds_count / 20) - 1); // Indexes start at 0
|
||||
|
||||
controller->SetChannelMode((unsigned char)zone_idx, modes[active_mode].value,modes[active_mode].colors, (unsigned int)modes[active_mode].colors.size(), (fan_idx >= 0 ? fan_idx : 0), upd_both_fan_edge, modes[active_mode].brightness, modes[active_mode].speed, modes[active_mode].direction);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,39 @@
|
||||
/*---------------------------------------------------------*\
|
||||
| RGBController_LianLiUniHub_AL.h |
|
||||
| |
|
||||
| RGBController for Lian Li AL Uni Hub |
|
||||
| |
|
||||
| Oliver P 26 Apr 2022 |
|
||||
| Credit to Luca Lovisa for original work |
|
||||
| |
|
||||
| This file is part of the OpenRGB project |
|
||||
| SPDX-License-Identifier: GPL-2.0-or-later |
|
||||
\*---------------------------------------------------------*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <cstdint>
|
||||
#include <vector>
|
||||
#include "LianLiUniHubALController.h"
|
||||
#include "RGBController.h"
|
||||
|
||||
class RGBController_LianLiUniHubAL : public RGBController
|
||||
{
|
||||
public:
|
||||
RGBController_LianLiUniHubAL(LianLiUniHubALController* controller_ptr);
|
||||
~RGBController_LianLiUniHubAL();
|
||||
|
||||
void SetupZones();
|
||||
|
||||
void ResizeZone(int zone, int new_size);
|
||||
|
||||
void DeviceUpdateLEDs();
|
||||
void UpdateZoneLEDs(int zone);
|
||||
void UpdateSingleLED(int led);
|
||||
|
||||
void DeviceUpdateMode();
|
||||
|
||||
private:
|
||||
LianLiUniHubALController* controller;
|
||||
bool initializedMode;
|
||||
};
|
||||
@@ -0,0 +1,701 @@
|
||||
/*---------------------------------------------------------*\
|
||||
| LianLiUniHubController.cpp |
|
||||
| |
|
||||
| Driver for Lian Li Uni Hub |
|
||||
| |
|
||||
| Luca Lovisa 20 Feb 2021 |
|
||||
| |
|
||||
| This file is part of the OpenRGB project |
|
||||
| SPDX-License-Identifier: GPL-2.0-or-later |
|
||||
\*---------------------------------------------------------*/
|
||||
|
||||
#include <cstring>
|
||||
#include "LianLiUniHubController.h"
|
||||
|
||||
using namespace std::chrono_literals;
|
||||
|
||||
/*----------------------------------------------------------------------------*\
|
||||
| The Uni Hub is controlled by sending control transfers to various wIndex |
|
||||
| addresses, allthough it announces some kind of hid interface. Hence it |
|
||||
| requires libusb as hidapi provides no wIndex customization. |
|
||||
\*----------------------------------------------------------------------------*/
|
||||
|
||||
LianLiUniHubController::LianLiUniHubController
|
||||
(
|
||||
libusb_device* device,
|
||||
libusb_device_descriptor* descriptor
|
||||
)
|
||||
{
|
||||
int ret;
|
||||
|
||||
/*--------------------------------------------------------------------*\
|
||||
| Open the libusb device. |
|
||||
\*--------------------------------------------------------------------*/
|
||||
ret = libusb_open(device, &handle);
|
||||
|
||||
if(ret < 0)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
/*--------------------------------------------------------------------*\
|
||||
| Fill in the location string from USB port numbers. |
|
||||
\*--------------------------------------------------------------------*/
|
||||
uint8_t ports[7];
|
||||
|
||||
ret = libusb_get_port_numbers(device, ports, sizeof(ports));
|
||||
|
||||
if(ret > 0)
|
||||
{
|
||||
location = "USB: ";
|
||||
|
||||
for (int i = 0; i < ret; i ++)
|
||||
{
|
||||
location += std::to_string(ports[i]);
|
||||
location.push_back(':');
|
||||
}
|
||||
|
||||
location.pop_back();
|
||||
}
|
||||
|
||||
/*--------------------------------------------------------------------*\
|
||||
| Fill in the serial string from the string descriptor |
|
||||
\*--------------------------------------------------------------------*/
|
||||
char serialStr[64];
|
||||
|
||||
ret = libusb_get_string_descriptor_ascii(handle, descriptor->iSerialNumber, reinterpret_cast<unsigned char*>(serialStr), sizeof(serialStr));
|
||||
|
||||
if(ret > 0)
|
||||
{
|
||||
serial = std::string(serialStr, ret);
|
||||
}
|
||||
|
||||
/*--------------------------------------------------------------------*\
|
||||
| Fill in the version string by reading version from device. |
|
||||
\*--------------------------------------------------------------------*/
|
||||
version = ReadVersion();
|
||||
|
||||
/*--------------------------------------------------------------------*\
|
||||
| Create channels with their static configuration and "sane" defaults. |
|
||||
\*--------------------------------------------------------------------*/
|
||||
Channel channel1;
|
||||
channel1.index = 0;
|
||||
channel1.anyFanCountOffset = UNIHUB_ANY_C1_FAN_COUNT_OFFSET;
|
||||
channel1.anyFanCount = UNIHUB_ANY_FAN_COUNT_001;
|
||||
channel1.ledActionAddress = UNIHUB_LED_C1_ACTION_ADDRESS;
|
||||
channel1.ledCommitAddress = UNIHUB_LED_C1_COMMIT_ADDRESS;
|
||||
channel1.ledModeAddress = UNIHUB_LED_C1_MODE_ADDRESS;
|
||||
channel1.ledSpeedAddress = UNIHUB_LED_C1_SPEED_ADDRESS;
|
||||
channel1.ledDirectionAddress = UNIHUB_LED_C1_DIRECTION_ADDRESS;
|
||||
channel1.ledBrightnessAddress = UNIHUB_LED_C1_BRIGHTNESS_ADDRESS;
|
||||
channel1.ledMode = UNIHUB_LED_MODE_RAINBOW;
|
||||
channel1.ledSpeed = UNIHUB_LED_SPEED_100;
|
||||
channel1.ledDirection = UNIHUB_LED_DIRECTION_LTR;
|
||||
channel1.ledBrightness = UNIHUB_LED_BRIGHTNESS_100;
|
||||
channel1.fanHubActionAddress = UNIHUB_FAN_C1_HUB_ACTION_ADDRESS;
|
||||
channel1.fanHubCommitAddress = UNIHUB_FAN_C1_HUB_COMMIT_ADDRESS;
|
||||
channel1.fanPwmActionAddress = UNIHUB_FAN_C1_PWM_ACTION_ADDRESS;
|
||||
channel1.fanPwmCommitAddress = UNIHUB_FAN_C1_PWM_COMMIT_ADDRESS;
|
||||
channel1.fanRpmActionAddress = UNIHUB_FAN_C1_RPM_ACTION_ADDRESS;
|
||||
channel1.fanSpeed = UNIHUB_FAN_SPEED_QUIET;
|
||||
channels[0] = channel1;
|
||||
|
||||
Channel channel2;
|
||||
channel2.index = 1;
|
||||
channel2.anyFanCountOffset = UNIHUB_ANY_C2_FAN_COUNT_OFFSET;
|
||||
channel2.anyFanCount = UNIHUB_ANY_FAN_COUNT_001;
|
||||
channel2.ledActionAddress = UNIHUB_LED_C2_ACTION_ADDRESS;
|
||||
channel2.ledCommitAddress = UNIHUB_LED_C2_COMMIT_ADDRESS;
|
||||
channel2.ledModeAddress = UNIHUB_LED_C2_MODE_ADDRESS;
|
||||
channel2.ledSpeedAddress = UNIHUB_LED_C2_SPEED_ADDRESS;
|
||||
channel2.ledDirectionAddress = UNIHUB_LED_C2_DIRECTION_ADDRESS;
|
||||
channel2.ledBrightnessAddress = UNIHUB_LED_C2_BRIGHTNESS_ADDRESS;
|
||||
channel2.ledMode = UNIHUB_LED_MODE_RAINBOW;
|
||||
channel2.ledSpeed = UNIHUB_LED_SPEED_100;
|
||||
channel2.ledDirection = UNIHUB_LED_DIRECTION_LTR;
|
||||
channel2.ledBrightness = UNIHUB_LED_BRIGHTNESS_100;
|
||||
channel2.fanHubActionAddress = UNIHUB_FAN_C2_HUB_ACTION_ADDRESS;
|
||||
channel2.fanHubCommitAddress = UNIHUB_FAN_C2_HUB_COMMIT_ADDRESS;
|
||||
channel2.fanPwmActionAddress = UNIHUB_FAN_C2_PWM_ACTION_ADDRESS;
|
||||
channel2.fanPwmCommitAddress = UNIHUB_FAN_C2_PWM_COMMIT_ADDRESS;
|
||||
channel2.fanRpmActionAddress = UNIHUB_FAN_C2_RPM_ACTION_ADDRESS;
|
||||
channel2.fanSpeed = UNIHUB_FAN_SPEED_QUIET;
|
||||
channels[1] = channel2;
|
||||
|
||||
Channel channel3;
|
||||
channel3.index = 2;
|
||||
channel3.anyFanCountOffset = UNIHUB_ANY_C3_FAN_COUNT_OFFSET;
|
||||
channel3.anyFanCount = UNIHUB_ANY_FAN_COUNT_001;
|
||||
channel3.ledActionAddress = UNIHUB_LED_C3_ACTION_ADDRESS;
|
||||
channel3.ledCommitAddress = UNIHUB_LED_C3_COMMIT_ADDRESS;
|
||||
channel3.ledModeAddress = UNIHUB_LED_C3_MODE_ADDRESS;
|
||||
channel3.ledSpeedAddress = UNIHUB_LED_C3_SPEED_ADDRESS;
|
||||
channel3.ledDirectionAddress = UNIHUB_LED_C3_DIRECTION_ADDRESS;
|
||||
channel3.ledBrightnessAddress = UNIHUB_LED_C3_BRIGHTNESS_ADDRESS;
|
||||
channel3.ledMode = UNIHUB_LED_MODE_RAINBOW;
|
||||
channel3.ledSpeed = UNIHUB_LED_SPEED_100;
|
||||
channel3.ledDirection = UNIHUB_LED_DIRECTION_LTR;
|
||||
channel3.ledBrightness = UNIHUB_LED_BRIGHTNESS_100;
|
||||
channel3.fanHubActionAddress = UNIHUB_FAN_C3_HUB_ACTION_ADDRESS;
|
||||
channel3.fanHubCommitAddress = UNIHUB_FAN_C3_HUB_COMMIT_ADDRESS;
|
||||
channel3.fanPwmActionAddress = UNIHUB_FAN_C3_PWM_ACTION_ADDRESS;
|
||||
channel3.fanPwmCommitAddress = UNIHUB_FAN_C3_PWM_COMMIT_ADDRESS;
|
||||
channel3.fanRpmActionAddress = UNIHUB_FAN_C3_RPM_ACTION_ADDRESS;
|
||||
channel3.fanSpeed = UNIHUB_FAN_SPEED_QUIET;
|
||||
channels[2] = channel3;
|
||||
|
||||
Channel channel4;
|
||||
channel4.index = 3;
|
||||
channel4.anyFanCountOffset = UNIHUB_ANY_C4_FAN_COUNT_OFFSET;
|
||||
channel4.anyFanCount = UNIHUB_ANY_FAN_COUNT_001;
|
||||
channel4.ledActionAddress = UNIHUB_LED_C4_ACTION_ADDRESS;
|
||||
channel4.ledCommitAddress = UNIHUB_LED_C4_COMMIT_ADDRESS;
|
||||
channel4.ledModeAddress = UNIHUB_LED_C4_MODE_ADDRESS;
|
||||
channel4.ledSpeedAddress = UNIHUB_LED_C4_SPEED_ADDRESS;
|
||||
channel4.ledDirectionAddress = UNIHUB_LED_C4_DIRECTION_ADDRESS;
|
||||
channel4.ledBrightnessAddress = UNIHUB_LED_C4_BRIGHTNESS_ADDRESS;
|
||||
channel4.ledMode = UNIHUB_LED_MODE_RAINBOW;
|
||||
channel4.ledSpeed = UNIHUB_LED_SPEED_100;
|
||||
channel4.ledDirection = UNIHUB_LED_DIRECTION_LTR;
|
||||
channel4.ledBrightness = UNIHUB_LED_BRIGHTNESS_100;
|
||||
channel4.fanHubActionAddress = UNIHUB_FAN_C4_HUB_ACTION_ADDRESS;
|
||||
channel4.fanHubCommitAddress = UNIHUB_FAN_C4_HUB_COMMIT_ADDRESS;
|
||||
channel4.fanPwmActionAddress = UNIHUB_FAN_C4_PWM_ACTION_ADDRESS;
|
||||
channel4.fanPwmCommitAddress = UNIHUB_FAN_C4_PWM_COMMIT_ADDRESS;
|
||||
channel4.fanRpmActionAddress = UNIHUB_FAN_C4_RPM_ACTION_ADDRESS;
|
||||
channel4.fanSpeed = UNIHUB_FAN_SPEED_QUIET;
|
||||
channels[3] = channel4;
|
||||
}
|
||||
|
||||
LianLiUniHubController::~LianLiUniHubController()
|
||||
{
|
||||
CloseLibusb();
|
||||
}
|
||||
|
||||
std::string LianLiUniHubController::GetVersion()
|
||||
{
|
||||
return version;
|
||||
}
|
||||
|
||||
std::string LianLiUniHubController::GetLocation()
|
||||
{
|
||||
return location;
|
||||
}
|
||||
|
||||
std::string LianLiUniHubController::GetSerial()
|
||||
{
|
||||
return serial;
|
||||
}
|
||||
|
||||
void LianLiUniHubController::SetAnyFanCount(size_t channel, uint8_t count)
|
||||
{
|
||||
/*-------------------------------------*\
|
||||
| Check for invalid channel |
|
||||
\*-------------------------------------*/
|
||||
if(channel >= UNIHUB_CHANNEL_COUNT)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
channels[channel].anyFanCount = count;
|
||||
}
|
||||
|
||||
void LianLiUniHubController::SetLedColors(size_t channel, RGBColor* colors, size_t count)
|
||||
{
|
||||
/*-------------------------------------*\
|
||||
| Check for invalid channel |
|
||||
\*-------------------------------------*/
|
||||
if(channel >= UNIHUB_CHANNEL_COUNT)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
/*-------------------------------------*\
|
||||
| Check for invalid count |
|
||||
\*-------------------------------------*/
|
||||
if(count > UNIHUB_CHANLED_COUNT)
|
||||
{
|
||||
count = UNIHUB_CHANLED_COUNT;
|
||||
}
|
||||
|
||||
size_t i = 0;
|
||||
for(; i < count; i++)
|
||||
{
|
||||
channels[channel].colors[i].r = RGBGetRValue(colors[i]);
|
||||
channels[channel].colors[i].b = RGBGetBValue(colors[i]);
|
||||
channels[channel].colors[i].g = RGBGetGValue(colors[i]);
|
||||
}
|
||||
|
||||
/* Set all remaining leds to black */
|
||||
for(; i < UNIHUB_CHANLED_COUNT; i++)
|
||||
{
|
||||
channels[channel].colors[i].r = 0x00;
|
||||
channels[channel].colors[i].b = 0x00;
|
||||
channels[channel].colors[i].g = 0x00;
|
||||
}
|
||||
}
|
||||
|
||||
void LianLiUniHubController::SetLedMode(size_t channel, uint8_t mode)
|
||||
{
|
||||
/*-------------------------------------*\
|
||||
| Check for invalid channel |
|
||||
\*-------------------------------------*/
|
||||
if(channel >= UNIHUB_CHANNEL_COUNT)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
channels[channel].ledMode = mode;
|
||||
}
|
||||
|
||||
void LianLiUniHubController::SetLedSpeed(size_t channel, uint8_t speed)
|
||||
{
|
||||
/*-------------------------------------*\
|
||||
| Check for invalid channel |
|
||||
\*-------------------------------------*/
|
||||
if(channel >= UNIHUB_CHANNEL_COUNT)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
channels[channel].ledSpeed = speed;
|
||||
}
|
||||
|
||||
void LianLiUniHubController::SetLedDirection(size_t channel, uint8_t direction)
|
||||
{
|
||||
/*-------------------------------------*\
|
||||
| Check for invalid channel |
|
||||
\*-------------------------------------*/
|
||||
if(channel >= UNIHUB_CHANNEL_COUNT)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
channels[channel].ledDirection = direction;
|
||||
}
|
||||
|
||||
void LianLiUniHubController::SetLedBrightness(size_t channel, uint8_t brightness)
|
||||
{
|
||||
/*-------------------------------------*\
|
||||
| Check for invalid channel |
|
||||
\*-------------------------------------*/
|
||||
if(channel >= UNIHUB_CHANNEL_COUNT)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
channels[channel].ledBrightness = brightness;
|
||||
}
|
||||
|
||||
uint16_t LianLiUniHubController::GetFanSpeed(size_t channel)
|
||||
{
|
||||
/*-------------------------------------*\
|
||||
| Check for invalid channel |
|
||||
\*-------------------------------------*/
|
||||
if(channel >= UNIHUB_CHANNEL_COUNT)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
return channels[channel].fanSpeed;
|
||||
}
|
||||
|
||||
void LianLiUniHubController::SetFanSpeed(size_t channel, uint16_t speed)
|
||||
{
|
||||
/*-------------------------------------*\
|
||||
| Check for invalid channel |
|
||||
\*-------------------------------------*/
|
||||
if(channel >= UNIHUB_CHANNEL_COUNT)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
channels[channel].fanSpeed = speed;
|
||||
}
|
||||
|
||||
void LianLiUniHubController::EnableRgbhMode()
|
||||
{
|
||||
rgbhModeEnabled = true;
|
||||
}
|
||||
|
||||
void LianLiUniHubController::DisableRgbhMode()
|
||||
{
|
||||
rgbhModeEnabled = false;
|
||||
}
|
||||
|
||||
void LianLiUniHubController::EnableSyncMode()
|
||||
{
|
||||
syncModeEnabled = true;
|
||||
}
|
||||
|
||||
void LianLiUniHubController::DisableSyncMode()
|
||||
{
|
||||
syncModeEnabled = false;
|
||||
}
|
||||
|
||||
/*----------------------------------------------------------------------------*\
|
||||
| The Uni Hub is a PWM and LED controller designed specifically for the Lian |
|
||||
| Li Uni Fans. It can control them by itself using the built-in effect engine |
|
||||
| can also be connected to the mainboard via 4-pin PWM and 3-pin RGB cables |
|
||||
| and forward these signals. The protocol implementation below was build as |
|
||||
| close a possible to the Lian Li L-Connect software. |
|
||||
| |
|
||||
| The commands to control the fan speeds and to switch between controller and |
|
||||
| mainboard control is already included, but currently deactivated as OpenRGB |
|
||||
| had no fan control module or controller specific configuration at the time |
|
||||
| of writing. |
|
||||
\*----------------------------------------------------------------------------*/
|
||||
void LianLiUniHubController::Synchronize()
|
||||
{
|
||||
/*---------------------------------------------------------------------*\
|
||||
| Configure common settings. |
|
||||
\*---------------------------------------------------------------------*/
|
||||
|
||||
/*---------------------------------------------------------------------*\
|
||||
| Still unsure about this. Probably some sort of configuration |
|
||||
| initialization |
|
||||
\*---------------------------------------------------------------------*/
|
||||
uint8_t config_initialization[1] = { 0x34 };
|
||||
|
||||
SendConfig(UNIHUB_ACTION_ADDRESS, config_initialization, sizeof(config_initialization));
|
||||
SendCommit(UNIHUB_COMMIT_ADDRESS);
|
||||
|
||||
for(const Channel& channel : channels)
|
||||
{
|
||||
/*-------------------------------------*\
|
||||
| The Uni Hub doesn't know zero fans |
|
||||
\*-------------------------------------*/
|
||||
uint8_t anyFanCount = channel.anyFanCount;
|
||||
|
||||
if(anyFanCount == UNIHUB_ANY_FAN_COUNT_000)
|
||||
{
|
||||
anyFanCount = UNIHUB_ANY_FAN_COUNT_001;
|
||||
}
|
||||
|
||||
/*-------------------------------------*\
|
||||
| Configure the physical fan count |
|
||||
\*-------------------------------------*/
|
||||
uint8_t config_fan_count[2] = { 0x32, (uint8_t)(channel.anyFanCountOffset | anyFanCount) };
|
||||
|
||||
SendConfig(UNIHUB_ACTION_ADDRESS, config_fan_count, sizeof(config_fan_count));
|
||||
SendCommit(UNIHUB_COMMIT_ADDRESS);
|
||||
}
|
||||
|
||||
/*--------------------------------------------------------------------*\
|
||||
| Configure channels for sync effects |
|
||||
\*--------------------------------------------------------------------*/
|
||||
if(syncModeEnabled)
|
||||
{
|
||||
uint8_t config_sync[6];
|
||||
uint8_t config_sync_index = 0;
|
||||
|
||||
config_sync[config_sync_index++] = 0x33;
|
||||
|
||||
for(const Channel& channel : channels)
|
||||
{
|
||||
if(channel.anyFanCount != UNIHUB_ANY_FAN_COUNT_000)
|
||||
{
|
||||
config_sync[config_sync_index++] = channel.index;
|
||||
}
|
||||
}
|
||||
|
||||
config_sync[config_sync_index++] = 0x08;
|
||||
|
||||
SendConfig(UNIHUB_ACTION_ADDRESS, config_sync, config_sync_index);
|
||||
SendCommit(UNIHUB_COMMIT_ADDRESS);
|
||||
}
|
||||
|
||||
/*--------------------------------------------------------------------*\
|
||||
| Configure led settings. |
|
||||
\*--------------------------------------------------------------------*/
|
||||
for(const Channel& channel : channels)
|
||||
{
|
||||
if(channel.anyFanCount != UNIHUB_ANY_FAN_COUNT_000)
|
||||
{
|
||||
/*-----------------------------*\
|
||||
| Configure led colors |
|
||||
\*-----------------------------*/
|
||||
uint8_t config_colors[192];
|
||||
memcpy(config_colors, channel.colors, sizeof(config_colors));
|
||||
|
||||
/*-----------------------------*\
|
||||
| No idea what this does ... |
|
||||
\*-----------------------------*/
|
||||
if (syncModeEnabled)
|
||||
{
|
||||
config_colors[0x06] = 0x66;
|
||||
config_colors[0x07] = 0x33;
|
||||
config_colors[0x08] = 0xCC;
|
||||
|
||||
memset(config_colors + 0x09, 0x00, sizeof(config_colors) - 0x09);
|
||||
}
|
||||
|
||||
SendConfig(channel.ledActionAddress, config_colors, sizeof(config_colors));
|
||||
|
||||
/*-----------------------------*\
|
||||
| Configure led mode |
|
||||
\*-----------------------------*/
|
||||
uint8_t config_mode[1] = { channel.ledMode };
|
||||
|
||||
SendConfig(channel.ledModeAddress, config_mode, sizeof(config_mode));
|
||||
}
|
||||
/*-----------------------------------------------------------------*\
|
||||
| The Uni Hub doesn't know zero fans so we set them to black |
|
||||
\*-----------------------------------------------------------------*/
|
||||
else
|
||||
{
|
||||
/*-----------------------------*\
|
||||
| Configure led colors |
|
||||
\*-----------------------------*/
|
||||
uint8_t config_colors[192];
|
||||
memset(config_colors, 0x00, sizeof(config_colors));
|
||||
|
||||
SendConfig(channel.ledActionAddress, config_colors, sizeof(config_colors));
|
||||
|
||||
/*-----------------------------*\
|
||||
| Configure led mode |
|
||||
\*-----------------------------*/
|
||||
uint8_t config_mode[1] = { UNIHUB_LED_MODE_STATIC_COLOR };
|
||||
|
||||
SendConfig(channel.ledModeAddress, config_mode, sizeof(config_mode));
|
||||
}
|
||||
|
||||
/*---------------------------------*\
|
||||
| Configure led speed |
|
||||
\*---------------------------------*/
|
||||
uint8_t config_speed[1] = { channel.ledSpeed };
|
||||
|
||||
SendConfig(channel.ledSpeedAddress, config_speed, sizeof(config_speed));
|
||||
|
||||
/*---------------------------------*\
|
||||
| Configure led direction |
|
||||
\*---------------------------------*/
|
||||
uint8_t config_direction[1] = { channel.ledDirection };
|
||||
|
||||
SendConfig(channel.ledDirectionAddress, config_direction, sizeof(config_direction));
|
||||
|
||||
/*---------------------------------*\
|
||||
| Configure led brightness |
|
||||
\*---------------------------------*/
|
||||
uint8_t config_brightness[1] = { channel.ledBrightness };
|
||||
|
||||
SendConfig(channel.ledBrightnessAddress, config_brightness, sizeof(config_brightness));
|
||||
|
||||
/*---------------------------------*\
|
||||
| Commit only once for all led |
|
||||
| settings |
|
||||
\*---------------------------------*/
|
||||
SendCommit(channel.ledCommitAddress);
|
||||
}
|
||||
|
||||
/*--------------------------------------------------------------------*\
|
||||
| Configure fan settings. Comment out until enabling fan control |
|
||||
\*--------------------------------------------------------------------*/
|
||||
// uint8_t control = 0;
|
||||
|
||||
/*-------------------------------------*\
|
||||
| Configure fan settings |
|
||||
\*-------------------------------------*/
|
||||
// for(const Channel& channel : channels)
|
||||
// {
|
||||
// if(channel.fanSpeed == UNIHUB_FAN_SPEED_PWM)
|
||||
// {
|
||||
/*-----------------------------*\
|
||||
| Configure the fan to pwm |
|
||||
| control |
|
||||
\*-----------------------------*/
|
||||
// uint8_t config_pwm[1] = { 0x00 };
|
||||
|
||||
// control |= (0x01 << channel.index);
|
||||
|
||||
// SendConfig(channel.fanPwmActionAddress, config_pwm, sizeof(config_pwm));
|
||||
// SendCommit(channel.fanPwmCommitAddress);
|
||||
// }
|
||||
// else
|
||||
// {
|
||||
/*-----------------------------*\
|
||||
| Configure the fan to hub |
|
||||
| control and set speed |
|
||||
\*-----------------------------*/
|
||||
// uint8_t config_hub[2] = { (uint8_t)(channel.fanSpeed >> 0x08), (uint8_t)(channel.fanSpeed & 0xFF) };
|
||||
|
||||
// SendConfig(channel.fanHubActionAddress, config_hub, sizeof(config_hub));
|
||||
// SendCommit(channel.fanHubCommitAddress);
|
||||
// }
|
||||
// }
|
||||
|
||||
/*-------------------------------------*\
|
||||
| Configure fan control modes |
|
||||
\*-------------------------------------*/
|
||||
// uint8_t config_fan_mode[2] = { 0x31, (uint8_t)(0xF0 | control) };
|
||||
|
||||
// SendConfig(UNIHUB_ACTION_ADDRESS, config_fan_mode, sizeof(config_fan_mode));
|
||||
// SendCommit(UNIHUB_COMMIT_ADDRESS);
|
||||
|
||||
/*--------------------------------------------------------------------*\
|
||||
| Configure led settings. |
|
||||
\*--------------------------------------------------------------------*/
|
||||
if(rgbhModeEnabled)
|
||||
{
|
||||
/*-------------------------------------*\
|
||||
| Configure the leds to hdr control. |
|
||||
\*-------------------------------------*/
|
||||
uint8_t config_hdr[2] = { 0x30, 0x01 };
|
||||
|
||||
SendConfig(UNIHUB_ACTION_ADDRESS, config_hdr, sizeof(config_hdr));
|
||||
SendCommit(UNIHUB_COMMIT_ADDRESS);
|
||||
}
|
||||
else
|
||||
{
|
||||
/*-------------------------------------*\
|
||||
| Configure the leds to hub control |
|
||||
\*-------------------------------------*/
|
||||
uint8_t config_hub[2] = { 0x30, 0x00 };
|
||||
|
||||
SendConfig(UNIHUB_ACTION_ADDRESS, config_hub, sizeof(config_hub));
|
||||
SendCommit(UNIHUB_COMMIT_ADDRESS);
|
||||
}
|
||||
}
|
||||
|
||||
uint16_t LianLiUniHubController::ReadFanSpeed(size_t channel)
|
||||
{
|
||||
/*-------------------------------------*\
|
||||
| Check for invalid handle |
|
||||
\*-------------------------------------*/
|
||||
if(handle == nullptr)
|
||||
{
|
||||
return(0);
|
||||
}
|
||||
|
||||
/*-------------------------------------*\
|
||||
| Check for invalid channel |
|
||||
\*-------------------------------------*/
|
||||
if(channel > UNIHUB_CHANNEL_COUNT)
|
||||
{
|
||||
return(0);
|
||||
}
|
||||
|
||||
uint8_t buffer[2];
|
||||
uint8_t length = sizeof(buffer);
|
||||
|
||||
uint16_t wIndex = channels[channel].fanRpmActionAddress;
|
||||
|
||||
/*-------------------------------------*\
|
||||
| Send packet |
|
||||
\*-------------------------------------*/
|
||||
size_t ret = libusb_control_transfer(handle, /* dev_handle */
|
||||
0xC0, /* bmRequestType */
|
||||
0x81, /* bRequest */
|
||||
0x00, /* wValue */
|
||||
wIndex, /* wIndex */
|
||||
buffer, /* data */
|
||||
length, /* wLength */
|
||||
1000); /* timeout */
|
||||
|
||||
/*-------------------------------------*\
|
||||
| Check for communication error |
|
||||
\*-------------------------------------*/
|
||||
if(ret != length)
|
||||
{
|
||||
return(0);
|
||||
}
|
||||
|
||||
return(*(uint16_t*)buffer);
|
||||
}
|
||||
|
||||
void LianLiUniHubController::CloseLibusb()
|
||||
{
|
||||
if (handle != nullptr)
|
||||
{
|
||||
libusb_close(handle);
|
||||
handle = nullptr;
|
||||
}
|
||||
}
|
||||
|
||||
std::string LianLiUniHubController::ReadVersion()
|
||||
{
|
||||
/*-------------------------------------*\
|
||||
| Check for invalid handle |
|
||||
\*-------------------------------------*/
|
||||
if(handle == nullptr)
|
||||
{
|
||||
return("");
|
||||
}
|
||||
|
||||
uint8_t buffer[5];
|
||||
uint8_t length = sizeof(buffer);
|
||||
|
||||
/*-------------------------------------*\
|
||||
| Send packet |
|
||||
\*-------------------------------------*/
|
||||
size_t ret = libusb_control_transfer(handle, /* dev_handle */
|
||||
0xC0, /* bmRequestType */
|
||||
0x81, /* bRequest */
|
||||
0x00, /* wValue */
|
||||
0xB500, /* wIndex */
|
||||
buffer, /* data */
|
||||
length, /* wLength */
|
||||
1000); /* timeout */
|
||||
|
||||
/*-------------------------------------*\
|
||||
| Check for communication error |
|
||||
\*-------------------------------------*/
|
||||
if(ret != length)
|
||||
{
|
||||
return("");
|
||||
}
|
||||
|
||||
/*-------------------------------------*\
|
||||
| Format version string |
|
||||
\*-------------------------------------*/
|
||||
char version[15];
|
||||
int vlength = std::snprintf(version, sizeof(version), "%x.%x.%x.%x.%x", buffer[0], buffer[1], buffer[2], buffer[3], buffer[4]);
|
||||
|
||||
return(std::string(version, vlength));
|
||||
}
|
||||
|
||||
void LianLiUniHubController::SendConfig(uint16_t wIndex, uint8_t *config, size_t length)
|
||||
{
|
||||
/*-------------------------------------*\
|
||||
| Check for invalid handle |
|
||||
\*-------------------------------------*/
|
||||
if(handle == nullptr)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
/*-------------------------------------*\
|
||||
| Send packet |
|
||||
\*-------------------------------------*/
|
||||
size_t ret = libusb_control_transfer(handle, /* dev_handle */
|
||||
0x40, /* bmRequestType */
|
||||
0x80, /* bRequest */
|
||||
0x00, /* wValue */
|
||||
wIndex, /* wIndex */
|
||||
config, /* data */
|
||||
(uint16_t)length, /* wLength */
|
||||
1000); /* timeout */
|
||||
|
||||
/*-------------------------------------*\
|
||||
| Check for communication error |
|
||||
\*-------------------------------------*/
|
||||
if(ret != length)
|
||||
{
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
void LianLiUniHubController::SendCommit(uint16_t wIndex)
|
||||
{
|
||||
/*-------------------------------------*\
|
||||
| Set up config packet |
|
||||
\*-------------------------------------*/
|
||||
uint8_t config[1] = { 0x01 };
|
||||
|
||||
/*-------------------------------------*\
|
||||
| Send packet |
|
||||
\*-------------------------------------*/
|
||||
SendConfig(wIndex, config, sizeof(config));
|
||||
|
||||
std::this_thread::sleep_for(5ms);
|
||||
}
|
||||
@@ -0,0 +1,263 @@
|
||||
/*---------------------------------------------------------*\
|
||||
| LianLiUniHubController.h |
|
||||
| |
|
||||
| Driver for Lian Li Uni Hub |
|
||||
| |
|
||||
| Luca Lovisa 20 Feb 2021 |
|
||||
| |
|
||||
| This file is part of the OpenRGB project |
|
||||
| SPDX-License-Identifier: GPL-2.0-or-later |
|
||||
\*---------------------------------------------------------*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <cstdint>
|
||||
#include <mutex>
|
||||
#include <string>
|
||||
#include <libusb.h>
|
||||
#include "RGBController.h"
|
||||
|
||||
/*----------------------------------------------------------------------------*\
|
||||
| Global definitions. |
|
||||
\*----------------------------------------------------------------------------*/
|
||||
|
||||
enum
|
||||
{
|
||||
UNIHUB_CHANNEL_COUNT = 0x04, /* Channel count */
|
||||
UNIHUB_CHANLED_COUNT = 0x40, /* Max-LED per channel count */
|
||||
};
|
||||
|
||||
enum
|
||||
{
|
||||
UNIHUB_ACTION_ADDRESS = 0xe021, /* Global action address */
|
||||
UNIHUB_COMMIT_ADDRESS = 0xe02f, /* Global commit address */
|
||||
};
|
||||
|
||||
enum
|
||||
{
|
||||
UNIHUB_ANY_C1_FAN_COUNT_OFFSET = 0x00, /* Channel 1 fan count offset */
|
||||
UNIHUB_ANY_C2_FAN_COUNT_OFFSET = 0x10, /* Channel 2 fan count offset */
|
||||
UNIHUB_ANY_C3_FAN_COUNT_OFFSET = 0x20, /* Channel 3 fan count offset */
|
||||
UNIHUB_ANY_C4_FAN_COUNT_OFFSET = 0x30, /* Channel 4 fan count offset */
|
||||
};
|
||||
|
||||
enum
|
||||
{
|
||||
UNIHUB_ANY_FAN_COUNT_000 = 0xFF, /* Fan count for 0 fans (dummy value) */
|
||||
UNIHUB_ANY_FAN_COUNT_001 = 0x00, /* Fan count for 1 fan */
|
||||
UNIHUB_ANY_FAN_COUNT_002 = 0x01, /* Fan count for 2 fans */
|
||||
UNIHUB_ANY_FAN_COUNT_003 = 0x02, /* Fan count for 3 fans */
|
||||
UNIHUB_ANY_FAN_COUNT_004 = 0x03, /* Fan count for 4 fans */
|
||||
};
|
||||
|
||||
/*----------------------------------------------------------------------------*\
|
||||
| Definitions related to led configuration. |
|
||||
\*----------------------------------------------------------------------------*/
|
||||
|
||||
enum
|
||||
{
|
||||
UNIHUB_LED_C1_ACTION_ADDRESS = 0xe300, /* Channel 1 led action address */
|
||||
UNIHUB_LED_C1_COMMIT_ADDRESS = 0xe02f, /* Channel 1 led commit address */
|
||||
UNIHUB_LED_C1_MODE_ADDRESS = 0xe021, /* Channel 1 led mode address */
|
||||
UNIHUB_LED_C1_SPEED_ADDRESS = 0xe022, /* Channel 1 led speed address */
|
||||
UNIHUB_LED_C1_DIRECTION_ADDRESS = 0xe023, /* Channel 1 led direction address */
|
||||
UNIHUB_LED_C1_BRIGHTNESS_ADDRESS = 0xe029, /* Channel 1 led brightness address */
|
||||
|
||||
UNIHUB_LED_C2_ACTION_ADDRESS = 0xe3c0, /* Channel 2 led action address */
|
||||
UNIHUB_LED_C2_COMMIT_ADDRESS = 0xe03f, /* Channel 2 led commit address */
|
||||
UNIHUB_LED_C2_MODE_ADDRESS = 0xe031, /* Channel 2 led mode address */
|
||||
UNIHUB_LED_C2_SPEED_ADDRESS = 0xe032, /* Channel 2 led speed address */
|
||||
UNIHUB_LED_C2_DIRECTION_ADDRESS = 0xe033, /* Channel 2 led direction address */
|
||||
UNIHUB_LED_C2_BRIGHTNESS_ADDRESS = 0xe039, /* Channel 2 led brightness address */
|
||||
|
||||
UNIHUB_LED_C3_ACTION_ADDRESS = 0xe480, /* Channel 3 led action address */
|
||||
UNIHUB_LED_C3_COMMIT_ADDRESS = 0xe04f, /* Channel 3 led commit address */
|
||||
UNIHUB_LED_C3_MODE_ADDRESS = 0xe041, /* Channel 3 led mode address */
|
||||
UNIHUB_LED_C3_SPEED_ADDRESS = 0xe042, /* Channel 3 led speed address */
|
||||
UNIHUB_LED_C3_DIRECTION_ADDRESS = 0xe043, /* Channel 3 led direction address */
|
||||
UNIHUB_LED_C3_BRIGHTNESS_ADDRESS = 0xe049, /* Channel 3 led brightness address */
|
||||
|
||||
UNIHUB_LED_C4_ACTION_ADDRESS = 0xe540, /* Channel 4 led action address */
|
||||
UNIHUB_LED_C4_COMMIT_ADDRESS = 0xe05f, /* Channel 4 led commit address */
|
||||
UNIHUB_LED_C4_MODE_ADDRESS = 0xe051, /* Channel 4 led mode address */
|
||||
UNIHUB_LED_C4_SPEED_ADDRESS = 0xe052, /* Channel 4 led speed address */
|
||||
UNIHUB_LED_C4_DIRECTION_ADDRESS = 0xe053, /* Channel 4 led direction address */
|
||||
UNIHUB_LED_C4_BRIGHTNESS_ADDRESS = 0xe059, /* Channel 4 led brightness address */
|
||||
};
|
||||
|
||||
enum
|
||||
{
|
||||
UNIHUB_LED_MODE_RAINBOW = 0x05, /* Rainbow mode */
|
||||
UNIHUB_LED_MODE_STATIC_COLOR = 0x01, /* Static Color mode */
|
||||
UNIHUB_LED_MODE_BREATHING = 0x02, /* Breathing mode */
|
||||
UNIHUB_LED_MODE_COLOR_CYCLE = 0x04, /* Color Cycle mode */
|
||||
UNIHUB_LED_MODE_RUNWAY = 0x1c, /* Runway mode */
|
||||
UNIHUB_LED_MODE_RUNWAY_SYNC = 0x1c, /* Runway Sync mode */
|
||||
UNIHUB_LED_MODE_STAGGGERED = 0x18, /* Stagggered mode */
|
||||
UNIHUB_LED_MODE_MIXING = 0x1a, /* Mixing mode */
|
||||
UNIHUB_LED_MODE_METEOR = 0x07, /* Meteor mode */
|
||||
UNIHUB_LED_MODE_METEOR_SYNC = 0x07, /* Meteor Sync mode */
|
||||
UNIHUB_LED_MODE_FIREWORK = 0x1f, /* Firework mode */
|
||||
UNIHUB_LED_MODE_STACK = 0x21, /* Stack mode */
|
||||
UNIHUB_LED_MODE_STACK_MULTI_COLOR = 0x22, /* Stack Multi Color mode */
|
||||
UNIHUB_LED_MODE_NEON = 0x23, /* Neon mode */
|
||||
};
|
||||
|
||||
enum
|
||||
{
|
||||
UNIHUB_LED_SPEED_000 = 0x04, /* Very slow speed */
|
||||
UNIHUB_LED_SPEED_025 = 0x03, /* Rather slow speed */
|
||||
UNIHUB_LED_SPEED_050 = 0x02, /* Medium speed */
|
||||
UNIHUB_LED_SPEED_075 = 0x01, /* Rather fast speed */
|
||||
UNIHUB_LED_SPEED_100 = 0x00, /* Very fast speed */
|
||||
};
|
||||
|
||||
enum
|
||||
{
|
||||
UNIHUB_LED_DIRECTION_LTR = 0x00, /* Left-to-Right direction */
|
||||
UNIHUB_LED_DIRECTION_RTL = 0x01, /* Right-to-Left direction */
|
||||
};
|
||||
|
||||
enum
|
||||
{
|
||||
UNIHUB_LED_BRIGHTNESS_000 = 0x08, /* Very dark (off) */
|
||||
UNIHUB_LED_BRIGHTNESS_025 = 0x03, /* Rather dark */
|
||||
UNIHUB_LED_BRIGHTNESS_050 = 0x02, /* Medium bright */
|
||||
UNIHUB_LED_BRIGHTNESS_075 = 0x01, /* Rather bright */
|
||||
UNIHUB_LED_BRIGHTNESS_100 = 0x00, /* Very bright */
|
||||
};
|
||||
|
||||
/*----------------------------------------------------------------------------*\
|
||||
| Definitions related to fan configuration. |
|
||||
\*----------------------------------------------------------------------------*/
|
||||
|
||||
enum
|
||||
{
|
||||
UNIHUB_FAN_C1_HUB_ACTION_ADDRESS = 0xe8a0, /* Channel 1 fan action address for hub control */
|
||||
UNIHUB_FAN_C1_HUB_COMMIT_ADDRESS = 0xe890, /* Channel 1 fan commit address for hub control */
|
||||
UNIHUB_FAN_C1_PWM_ACTION_ADDRESS = 0xe890, /* Channel 1 fan action address for pwm control */
|
||||
UNIHUB_FAN_C1_PWM_COMMIT_ADDRESS = 0xe818, /* Channel 1 fan commit address for pwm control */
|
||||
UNIHUB_FAN_C1_RPM_ACTION_ADDRESS = 0xe800, /* Channel 1 fan pwm read address */
|
||||
|
||||
UNIHUB_FAN_C2_HUB_ACTION_ADDRESS = 0xe8a2, /* Channel 2 fan action address for hub control */
|
||||
UNIHUB_FAN_C2_HUB_COMMIT_ADDRESS = 0xe891, /* Channel 2 fan commit address for hub control */
|
||||
UNIHUB_FAN_C2_PWM_ACTION_ADDRESS = 0xe891, /* Channel 2 fan action address for pwm control */
|
||||
UNIHUB_FAN_C2_PWM_COMMIT_ADDRESS = 0xe81a, /* Channel 2 fan commit address for pwm control */
|
||||
UNIHUB_FAN_C2_RPM_ACTION_ADDRESS = 0xe802, /* Channel 1 fan pwm read address */
|
||||
|
||||
UNIHUB_FAN_C3_HUB_ACTION_ADDRESS = 0xe8a4, /* Channel 3 fan action address for hub control */
|
||||
UNIHUB_FAN_C3_HUB_COMMIT_ADDRESS = 0xe892, /* Channel 3 fan commit address for hub control */
|
||||
UNIHUB_FAN_C3_PWM_ACTION_ADDRESS = 0xe892, /* Channel 3 fan action address for pwm control */
|
||||
UNIHUB_FAN_C3_PWM_COMMIT_ADDRESS = 0xe81c, /* Channel 3 fan commit address for pwm control */
|
||||
UNIHUB_FAN_C3_RPM_ACTION_ADDRESS = 0xe804, /* Channel 1 fan pwm read address */
|
||||
|
||||
UNIHUB_FAN_C4_HUB_ACTION_ADDRESS = 0xe8a6, /* Channel 4 fan action address for hub control */
|
||||
UNIHUB_FAN_C4_HUB_COMMIT_ADDRESS = 0xe893, /* Channel 4 fan commit address for hub control */
|
||||
UNIHUB_FAN_C4_PWM_ACTION_ADDRESS = 0xe893, /* Channel 4 fan action address for pwm control */
|
||||
UNIHUB_FAN_C4_PWM_COMMIT_ADDRESS = 0xe81e, /* Channel 4 fan commit address for pwm control */
|
||||
UNIHUB_FAN_C4_RPM_ACTION_ADDRESS = 0xe806, /* Channel 1 fan pwm read address */
|
||||
};
|
||||
|
||||
enum
|
||||
{
|
||||
UNIHUB_FAN_SPEED_QUIET = 0x2003, /* Rather slow */
|
||||
UNIHUB_FAN_SPEED_HIGH_SPEED = 0x2206, /* Rather fast */
|
||||
UNIHUB_FAN_SPEED_FULL_SPEED = 0x6c07, /* BRRRRRRRRRR */
|
||||
UNIHUB_FAN_SPEED_PWM = 0xffff, /* PWM Control */
|
||||
};
|
||||
|
||||
/*----------------------------------------------------------------------------*\
|
||||
| Uni Hub controller. |
|
||||
\*----------------------------------------------------------------------------*/
|
||||
|
||||
class LianLiUniHubController
|
||||
{
|
||||
private:
|
||||
/* The Uni Hub requires colors in RBG order */
|
||||
struct Color
|
||||
{
|
||||
uint8_t r;
|
||||
uint8_t b;
|
||||
uint8_t g;
|
||||
};
|
||||
|
||||
/* The values correspond to the definitions above */
|
||||
struct Channel
|
||||
{
|
||||
uint8_t index;
|
||||
|
||||
uint8_t anyFanCountOffset;
|
||||
uint8_t anyFanCount;
|
||||
|
||||
uint16_t ledActionAddress;
|
||||
uint16_t ledCommitAddress;
|
||||
uint16_t ledModeAddress;
|
||||
uint16_t ledSpeedAddress;
|
||||
uint16_t ledDirectionAddress;
|
||||
uint16_t ledBrightnessAddress;
|
||||
|
||||
Color colors[UNIHUB_CHANLED_COUNT];
|
||||
|
||||
uint8_t ledMode;
|
||||
uint8_t ledSpeed;
|
||||
uint8_t ledDirection;
|
||||
uint8_t ledBrightness;
|
||||
|
||||
uint16_t fanHubActionAddress;
|
||||
uint16_t fanHubCommitAddress;
|
||||
|
||||
uint16_t fanPwmActionAddress;
|
||||
uint16_t fanPwmCommitAddress;
|
||||
uint16_t fanRpmActionAddress;
|
||||
|
||||
uint16_t fanSpeed;
|
||||
};
|
||||
|
||||
public:
|
||||
LianLiUniHubController
|
||||
(
|
||||
libusb_device* device,
|
||||
libusb_device_descriptor* descriptor
|
||||
);
|
||||
~LianLiUniHubController();
|
||||
|
||||
std::string GetVersion();
|
||||
std::string GetLocation();
|
||||
std::string GetSerial();
|
||||
|
||||
void SetAnyFanCount(size_t channel, uint8_t count);
|
||||
void SetLedColors(size_t channel, RGBColor* colors, size_t count);
|
||||
void SetLedMode(size_t channel, uint8_t mode);
|
||||
void SetLedSpeed(size_t channel, uint8_t speed);
|
||||
void SetLedDirection(size_t channel, uint8_t direction);
|
||||
void SetLedBrightness(size_t channel, uint8_t brightness);
|
||||
uint16_t GetFanSpeed(size_t channel);
|
||||
void SetFanSpeed(size_t channel, uint16_t speed);
|
||||
void EnableRgbhMode();
|
||||
void DisableRgbhMode();
|
||||
void EnableSyncMode();
|
||||
void DisableSyncMode();
|
||||
uint16_t ReadFanSpeed(size_t channel);
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Synchronize the current configuration to the Uni Hub. |
|
||||
\*-----------------------------------------------------*/
|
||||
void Synchronize();
|
||||
|
||||
private:
|
||||
libusb_device_handle* handle = nullptr;
|
||||
|
||||
std::string version;
|
||||
std::string location;
|
||||
std::string serial;
|
||||
|
||||
bool rgbhModeEnabled = false;
|
||||
bool syncModeEnabled = false;
|
||||
|
||||
Channel channels[UNIHUB_CHANNEL_COUNT];
|
||||
|
||||
void CloseLibusb();
|
||||
std::string ReadVersion();
|
||||
void SendConfig(uint16_t wIndex, uint8_t *config, size_t length);
|
||||
void SendCommit(uint16_t wIndex);
|
||||
};
|
||||
@@ -0,0 +1,479 @@
|
||||
/*---------------------------------------------------------*\
|
||||
| RGBController_LianLiUniHub.cpp |
|
||||
| |
|
||||
| RGBController for Lian Li Uni Hub |
|
||||
| |
|
||||
| Luca Lovisa 20 Feb 2021 |
|
||||
| |
|
||||
| This file is part of the OpenRGB project |
|
||||
| SPDX-License-Identifier: GPL-2.0-or-later |
|
||||
\*---------------------------------------------------------*/
|
||||
|
||||
#include <string>
|
||||
#include "RGBController_LianLiUniHub.h"
|
||||
|
||||
mode makeMode()
|
||||
{
|
||||
mode Mode;
|
||||
|
||||
Mode.value = 0;
|
||||
Mode.flags = 0;
|
||||
Mode.speed_min = 0;
|
||||
Mode.speed_max = 0;
|
||||
Mode.colors_min = 0;
|
||||
Mode.colors_max = 0;
|
||||
Mode.speed = 0;
|
||||
Mode.direction = 0;
|
||||
Mode.color_mode = 0;
|
||||
|
||||
return Mode;
|
||||
}
|
||||
|
||||
/**------------------------------------------------------------------*\
|
||||
@name Lian Li Uni Hub
|
||||
@category Cooler
|
||||
@type USB
|
||||
@save :x:
|
||||
@direct :rotating_light:
|
||||
@effects :white_check_mark:
|
||||
@detectors DetectLianLiUniHub
|
||||
@comment
|
||||
\*-------------------------------------------------------------------*/
|
||||
|
||||
RGBController_LianLiUniHub::RGBController_LianLiUniHub(LianLiUniHubController* controller_ptr)
|
||||
{
|
||||
controller = controller_ptr;
|
||||
|
||||
name = "Lian Li Uni Hub";
|
||||
vendor = "Lian Li";
|
||||
version = controller->GetVersion();
|
||||
type = DEVICE_TYPE_COOLER;
|
||||
description = "Lian Li Uni Hub";
|
||||
location = controller->GetLocation();
|
||||
serial = controller->GetSerial();
|
||||
|
||||
initializedMode = false;
|
||||
|
||||
mode StaticColor = makeMode();
|
||||
StaticColor.name = "Custom";
|
||||
StaticColor.value = UNIHUB_LED_MODE_STATIC_COLOR;
|
||||
StaticColor.flags = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_PER_LED_COLOR;
|
||||
StaticColor.color_mode = MODE_COLORS_PER_LED;
|
||||
modes.push_back(StaticColor);
|
||||
|
||||
mode Rainbow = makeMode();
|
||||
Rainbow.name = "Rainbow Wave";
|
||||
Rainbow.value = UNIHUB_LED_MODE_RAINBOW;
|
||||
Rainbow.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_DIRECTION_LR;
|
||||
Rainbow.speed_min = 1;
|
||||
Rainbow.speed_max = 5;
|
||||
Rainbow.color_mode = MODE_COLORS_NONE;
|
||||
modes.push_back(Rainbow);
|
||||
|
||||
mode Breathing = makeMode();
|
||||
Breathing.name = "Breathing";
|
||||
Breathing.value = UNIHUB_LED_MODE_BREATHING;
|
||||
Breathing.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_PER_LED_COLOR;
|
||||
Breathing.speed_min = 1;
|
||||
Breathing.speed_max = 5;
|
||||
Breathing.color_mode = MODE_COLORS_PER_LED;
|
||||
modes.push_back(Breathing);
|
||||
|
||||
mode ColorCycle = makeMode();
|
||||
ColorCycle.name = "Color Cycle";
|
||||
ColorCycle.value = UNIHUB_LED_MODE_COLOR_CYCLE;
|
||||
ColorCycle.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
|
||||
ColorCycle.speed_min = 1;
|
||||
ColorCycle.speed_max = 5;
|
||||
ColorCycle.colors_min = 3;
|
||||
ColorCycle.colors_max = 3;
|
||||
ColorCycle.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
ColorCycle.colors.resize(3);
|
||||
modes.push_back(ColorCycle);
|
||||
|
||||
mode Runway = makeMode();
|
||||
Runway.name = "Runway";
|
||||
Runway.value = UNIHUB_LED_MODE_RUNWAY;
|
||||
Runway.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
|
||||
Runway.speed_min = 1;
|
||||
Runway.speed_max = 5;
|
||||
Runway.colors_min = 2;
|
||||
Runway.colors_max = 2;
|
||||
Runway.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Runway.colors.resize(2);
|
||||
modes.push_back(Runway);
|
||||
|
||||
mode RunwaySync = makeMode();
|
||||
RunwaySync.name = "Runway Sync";
|
||||
RunwaySync.value = UNIHUB_LED_MODE_RUNWAY_SYNC | 0x0100;
|
||||
RunwaySync.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
|
||||
RunwaySync.speed_min = 1;
|
||||
RunwaySync.speed_max = 5;
|
||||
RunwaySync.colors_min = 2;
|
||||
RunwaySync.colors_max = 2;
|
||||
RunwaySync.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
RunwaySync.colors.resize(2);
|
||||
modes.push_back(RunwaySync);
|
||||
|
||||
mode Staggered = makeMode();
|
||||
Staggered.name = "Staggered";
|
||||
Staggered.value = UNIHUB_LED_MODE_STAGGGERED;
|
||||
Staggered.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
|
||||
Staggered.speed_min = 1;
|
||||
Staggered.speed_max = 5;
|
||||
Staggered.colors_min = 2;
|
||||
Staggered.colors_max = 2;
|
||||
Staggered.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Staggered.colors.resize(2);
|
||||
modes.push_back(Staggered);
|
||||
|
||||
mode Mixing = makeMode();
|
||||
Mixing.name = "Mixing";
|
||||
Mixing.value = UNIHUB_LED_MODE_MIXING;
|
||||
Mixing.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
|
||||
Mixing.speed_min = 1;
|
||||
Mixing.speed_max = 5;
|
||||
Mixing.colors_min = 2;
|
||||
Mixing.colors_max = 2;
|
||||
Mixing.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Mixing.colors.resize(2);
|
||||
modes.push_back(Mixing);
|
||||
|
||||
mode Meteor = makeMode();
|
||||
Meteor.name = "Meteor";
|
||||
Meteor.value = UNIHUB_LED_MODE_METEOR;
|
||||
Meteor.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
|
||||
Meteor.speed_min = 1;
|
||||
Meteor.speed_max = 5;
|
||||
Meteor.colors_min = 2;
|
||||
Meteor.colors_max = 2;
|
||||
Meteor.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Meteor.colors.resize(2);
|
||||
modes.push_back(Meteor);
|
||||
|
||||
mode MeteorSync = makeMode();
|
||||
MeteorSync.name = "Meteor Sync";
|
||||
MeteorSync.value = UNIHUB_LED_MODE_METEOR_SYNC | 0x0100;
|
||||
MeteorSync.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
|
||||
MeteorSync.speed_min = 1;
|
||||
MeteorSync.speed_max = 5;
|
||||
MeteorSync.colors_min = 2;
|
||||
MeteorSync.colors_max = 2;
|
||||
MeteorSync.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
MeteorSync.colors.resize(2);
|
||||
modes.push_back(MeteorSync);
|
||||
|
||||
mode Firework = makeMode();
|
||||
Firework.name = "Firework";
|
||||
Firework.value = UNIHUB_LED_MODE_FIREWORK;
|
||||
Firework.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
|
||||
Firework.speed_min = 1;
|
||||
Firework.speed_max = 5;
|
||||
Firework.colors_min = 2;
|
||||
Firework.colors_max = 2;
|
||||
Firework.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Firework.colors.resize(2);
|
||||
modes.push_back(Firework);
|
||||
|
||||
mode Stack = makeMode();
|
||||
Stack.name = "Stack";
|
||||
Stack.value = UNIHUB_LED_MODE_STACK;
|
||||
Stack.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
|
||||
Stack.speed_min = 1;
|
||||
Stack.speed_max = 5;
|
||||
Stack.colors_min = 1;
|
||||
Stack.colors_max = 1;
|
||||
Stack.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Stack.colors.resize(1);
|
||||
modes.push_back(Stack);
|
||||
|
||||
mode StackMultiColor = makeMode();
|
||||
StackMultiColor.name = "Stack Multi Color";
|
||||
StackMultiColor.value = UNIHUB_LED_MODE_STACK_MULTI_COLOR;
|
||||
StackMultiColor.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_DIRECTION_LR;
|
||||
StackMultiColor.speed_min = 1;
|
||||
StackMultiColor.speed_max = 5;
|
||||
StackMultiColor.color_mode = MODE_COLORS_NONE;
|
||||
modes.push_back(StackMultiColor);
|
||||
|
||||
mode Neon = makeMode();
|
||||
Neon.name = "Neon";
|
||||
Neon.value = UNIHUB_LED_MODE_NEON;
|
||||
Neon.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
|
||||
Neon.speed_min = 1;
|
||||
Neon.speed_max = 5;
|
||||
Neon.color_mode = MODE_COLORS_NONE;
|
||||
modes.push_back(Neon);
|
||||
|
||||
mode Rgbh = makeMode();
|
||||
Rgbh.name = "RGB Header";
|
||||
Rgbh.value = UNIHUB_LED_MODE_STATIC_COLOR | 0x0200;
|
||||
Rgbh.flags = 0;
|
||||
Rgbh.color_mode = MODE_COLORS_NONE;
|
||||
modes.push_back(Rgbh);
|
||||
|
||||
RGBController_LianLiUniHub::SetupZones();
|
||||
}
|
||||
|
||||
void RGBController_LianLiUniHub::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(UNIHUB_CHANNEL_COUNT);
|
||||
|
||||
/*-------------------------------------------------*\
|
||||
| Set zones and leds |
|
||||
\*-------------------------------------------------*/
|
||||
int addressableCounter = 1;
|
||||
for(unsigned int channel_idx = 0; channel_idx < zones.size(); channel_idx++)
|
||||
{
|
||||
zones[channel_idx].name = "Channel ";
|
||||
zones[channel_idx].name.append(std::to_string(addressableCounter));
|
||||
|
||||
addressableCounter++;
|
||||
|
||||
zones[channel_idx].type = ZONE_TYPE_LINEAR;
|
||||
|
||||
zones[channel_idx].leds_min = 0;
|
||||
zones[channel_idx].leds_max = UNIHUB_CHANLED_COUNT;
|
||||
|
||||
if(first_run)
|
||||
{
|
||||
zones[channel_idx].leds_count = zones[channel_idx].leds_min;
|
||||
}
|
||||
|
||||
for(unsigned int led_ch_idx = 0; led_ch_idx < zones[channel_idx].leds_count; led_ch_idx++)
|
||||
{
|
||||
led new_led;
|
||||
new_led.name = zones[channel_idx].name;
|
||||
new_led.name.append(", LED ");
|
||||
new_led.name.append(std::to_string(led_ch_idx + 1));
|
||||
new_led.value = channel_idx;
|
||||
|
||||
leds.push_back(new_led);
|
||||
}
|
||||
|
||||
zones[channel_idx].matrix_map = NULL;
|
||||
}
|
||||
|
||||
SetupColors();
|
||||
}
|
||||
|
||||
void RGBController_LianLiUniHub::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_LianLiUniHub::DeviceUpdateLEDs()
|
||||
{
|
||||
if(!initializedMode)
|
||||
{
|
||||
DeviceUpdateMode();
|
||||
}
|
||||
for(size_t channel = 0; channel < zones.size(); channel++)
|
||||
{
|
||||
uint8_t fanCount = convertLedCountToFanCount(zones[channel].leds_count);
|
||||
controller->SetAnyFanCount(channel, convertAnyFanCount(fanCount));
|
||||
controller->SetLedColors(channel, zones[channel].colors, zones[channel].leds_count);
|
||||
}
|
||||
|
||||
controller->Synchronize();
|
||||
}
|
||||
|
||||
void RGBController_LianLiUniHub::UpdateZoneLEDs(int zone)
|
||||
{
|
||||
if(!initializedMode)
|
||||
{
|
||||
DeviceUpdateMode();
|
||||
}
|
||||
unsigned int channel = zone;
|
||||
|
||||
uint8_t fanCount = convertLedCountToFanCount(zones[channel].leds_count);
|
||||
controller->SetAnyFanCount(channel, convertAnyFanCount(fanCount));
|
||||
controller->SetLedColors(channel, zones[channel].colors, zones[channel].leds_count);
|
||||
|
||||
controller->Synchronize();
|
||||
}
|
||||
|
||||
void RGBController_LianLiUniHub::UpdateSingleLED(int led)
|
||||
{
|
||||
if(!initializedMode)
|
||||
{
|
||||
DeviceUpdateMode();
|
||||
}
|
||||
unsigned int channel = leds[led].value;
|
||||
|
||||
uint8_t fanCount = convertLedCountToFanCount(zones[channel].leds_count);
|
||||
controller->SetAnyFanCount(channel, convertAnyFanCount(fanCount));
|
||||
controller->SetLedColors(channel, zones[channel].colors, zones[channel].leds_count);
|
||||
|
||||
controller->Synchronize();
|
||||
}
|
||||
|
||||
void RGBController_LianLiUniHub::DeviceUpdateMode()
|
||||
{
|
||||
initializedMode = true;
|
||||
|
||||
for (size_t channel = 0; channel < zones.size(); channel++)
|
||||
{
|
||||
uint8_t fanCount = convertLedCountToFanCount(zones[channel].leds_count);
|
||||
controller->SetAnyFanCount(channel, convertAnyFanCount(fanCount));
|
||||
|
||||
switch (modes[active_mode].color_mode)
|
||||
{
|
||||
case MODE_COLORS_PER_LED:
|
||||
controller->SetLedColors(channel, zones[channel].colors, zones[channel].leds_count);
|
||||
break;
|
||||
|
||||
case MODE_COLORS_MODE_SPECIFIC:
|
||||
controller->SetLedColors(channel, modes[active_mode].colors.data(), modes[active_mode].colors.size());
|
||||
break;
|
||||
|
||||
default:
|
||||
controller->SetLedColors(channel, nullptr, 0);
|
||||
break;
|
||||
}
|
||||
|
||||
controller->SetLedMode(channel, modes[active_mode].value);
|
||||
|
||||
if(modes[active_mode].flags & MODE_FLAG_HAS_SPEED)
|
||||
{
|
||||
controller->SetLedSpeed(channel, convertLedSpeed(modes[active_mode].speed));
|
||||
}
|
||||
else
|
||||
{
|
||||
controller->SetLedSpeed(channel, UNIHUB_LED_SPEED_000);
|
||||
}
|
||||
|
||||
if(modes[active_mode].flags & MODE_FLAG_HAS_DIRECTION_LR)
|
||||
{
|
||||
controller->SetLedDirection(channel, convertLedDirection(modes[active_mode].direction));
|
||||
}
|
||||
else
|
||||
{
|
||||
controller->SetLedDirection(channel, UNIHUB_LED_DIRECTION_LTR);
|
||||
}
|
||||
}
|
||||
|
||||
if(modes[active_mode].value & 0x0200)
|
||||
{
|
||||
controller->EnableRgbhMode();
|
||||
controller->DisableSyncMode();
|
||||
}
|
||||
else if (modes[active_mode].value & 0x0100)
|
||||
{
|
||||
controller->DisableRgbhMode();
|
||||
controller->EnableSyncMode();
|
||||
}
|
||||
else
|
||||
{
|
||||
controller->DisableRgbhMode();
|
||||
controller->DisableSyncMode();
|
||||
}
|
||||
|
||||
controller->Synchronize();
|
||||
}
|
||||
|
||||
uint8_t RGBController_LianLiUniHub::convertAnyFanCount(uint8_t count)
|
||||
{
|
||||
switch (count)
|
||||
{
|
||||
case 0:
|
||||
return UNIHUB_ANY_FAN_COUNT_000;
|
||||
|
||||
case 1:
|
||||
return UNIHUB_ANY_FAN_COUNT_001;
|
||||
|
||||
case 2:
|
||||
return UNIHUB_ANY_FAN_COUNT_002;
|
||||
|
||||
case 3:
|
||||
return UNIHUB_ANY_FAN_COUNT_003;
|
||||
|
||||
case 4:
|
||||
return UNIHUB_ANY_FAN_COUNT_004;
|
||||
|
||||
default:
|
||||
return UNIHUB_ANY_FAN_COUNT_001;
|
||||
}
|
||||
}
|
||||
|
||||
uint8_t RGBController_LianLiUniHub::convertLedSpeed(uint8_t speed)
|
||||
{
|
||||
switch (speed)
|
||||
{
|
||||
case 1:
|
||||
return UNIHUB_LED_SPEED_000;
|
||||
|
||||
case 2:
|
||||
return UNIHUB_LED_SPEED_025;
|
||||
|
||||
case 3:
|
||||
return UNIHUB_LED_SPEED_050;
|
||||
|
||||
case 4:
|
||||
return UNIHUB_LED_SPEED_075;
|
||||
|
||||
case 5:
|
||||
return UNIHUB_LED_SPEED_100;
|
||||
|
||||
default:
|
||||
return UNIHUB_LED_SPEED_050;
|
||||
}
|
||||
}
|
||||
|
||||
uint8_t RGBController_LianLiUniHub::convertLedDirection(uint8_t direction)
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
case 0:
|
||||
return UNIHUB_LED_DIRECTION_LTR;
|
||||
|
||||
case 1:
|
||||
return UNIHUB_LED_DIRECTION_RTL;
|
||||
|
||||
default:
|
||||
return UNIHUB_LED_DIRECTION_LTR;
|
||||
}
|
||||
}
|
||||
|
||||
uint8_t RGBController_LianLiUniHub::convertLedCountToFanCount(uint8_t count)
|
||||
{
|
||||
/*-------------------------------------------------*\
|
||||
| Converts 0 to 0, 1-16 to 1, 17-32 to 2, 33-48 to |
|
||||
| 3 and 49-64+ to 4 |
|
||||
\*-------------------------------------------------*/
|
||||
if (count == 0x00)
|
||||
{
|
||||
return 0x00;
|
||||
}
|
||||
if (count >= 0x40)
|
||||
{
|
||||
count = 0x40;
|
||||
}
|
||||
|
||||
return((count -1) / 16 + 1);
|
||||
}
|
||||
@@ -0,0 +1,43 @@
|
||||
/*---------------------------------------------------------*\
|
||||
| RGBController_LianLiUniHub.h |
|
||||
| |
|
||||
| RGBController for Lian Li Uni Hub |
|
||||
| |
|
||||
| Luca Lovisa 20 Feb 2021 |
|
||||
| |
|
||||
| This file is part of the OpenRGB project |
|
||||
| SPDX-License-Identifier: GPL-2.0-or-later |
|
||||
\*---------------------------------------------------------*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <cstdint>
|
||||
#include <vector>
|
||||
#include "LianLiUniHubController.h"
|
||||
#include "RGBController.h"
|
||||
|
||||
class RGBController_LianLiUniHub : public RGBController
|
||||
{
|
||||
public:
|
||||
RGBController_LianLiUniHub(LianLiUniHubController* controller_ptr);
|
||||
|
||||
void SetupZones();
|
||||
void ResizeZone(int zone, int new_size);
|
||||
|
||||
void DeviceUpdateLEDs();
|
||||
void UpdateZoneLEDs(int zone);
|
||||
void UpdateSingleLED(int led);
|
||||
|
||||
void DeviceUpdateMode();
|
||||
|
||||
private:
|
||||
uint8_t convertAnyFanCount(uint8_t count);
|
||||
uint8_t convertLedSpeed(uint8_t speed);
|
||||
uint8_t convertLedDirection(uint8_t direction);
|
||||
|
||||
uint8_t convertLedCountToFanCount(uint8_t count);
|
||||
|
||||
private:
|
||||
LianLiUniHubController* controller;
|
||||
bool initializedMode;
|
||||
};
|
||||
@@ -0,0 +1,375 @@
|
||||
/*---------------------------------------------------------*\
|
||||
| LianLiUniHubSLController.cpp |
|
||||
| |
|
||||
| Driver for Lian Li Uni Hub - SL |
|
||||
| |
|
||||
| Muhamad Visat 26 Jul 2025 |
|
||||
| Original work by Luca Lovisa & Oliver P |
|
||||
| |
|
||||
| This file is part of the OpenRGB project |
|
||||
| SPDX-License-Identifier: GPL-2.0-only |
|
||||
\*---------------------------------------------------------*/
|
||||
|
||||
#include "LogManager.h"
|
||||
#include "StringUtils.h"
|
||||
#include "LianLiUniHubSLController.h"
|
||||
|
||||
using namespace std::chrono_literals;
|
||||
|
||||
LianLiUniHubSLController::LianLiUniHubSLController(hid_device *dev, const char *path)
|
||||
{
|
||||
if(dev == nullptr)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
device = dev;
|
||||
location = "HID: " + std::string(path);
|
||||
is_merged_mode = false;
|
||||
}
|
||||
|
||||
LianLiUniHubSLController::~LianLiUniHubSLController()
|
||||
{
|
||||
if(device != nullptr)
|
||||
{
|
||||
hid_close(device);
|
||||
device = nullptr;
|
||||
}
|
||||
}
|
||||
|
||||
std::string LianLiUniHubSLController::ReadVersion()
|
||||
{
|
||||
wchar_t buf[40];
|
||||
int ret = hid_get_product_string(this->device, buf, 40);
|
||||
if(ret != 0)
|
||||
{
|
||||
return "";
|
||||
}
|
||||
|
||||
/*------------------------------ -*\
|
||||
| Example: LianLi-UNI FAN-SL-v1.8 |
|
||||
| We just want the v1.8 part |
|
||||
| without trailing spaces |
|
||||
\*--------------------------------*/
|
||||
std::string version = StringUtils::wstring_to_string(buf);
|
||||
version = version.substr(version.find_last_of('-') + 1);
|
||||
return version.substr(0, version.find_last_not_of(' ') + 1);
|
||||
}
|
||||
|
||||
std::string LianLiUniHubSLController::ReadSerial()
|
||||
{
|
||||
wchar_t buf[20];
|
||||
int ret = hid_get_serial_number_string(this->device, buf, 20);
|
||||
if(ret != 0)
|
||||
{
|
||||
return "";
|
||||
}
|
||||
|
||||
std::string serial = StringUtils::wstring_to_string(buf);
|
||||
return serial;
|
||||
}
|
||||
|
||||
void LianLiUniHubSLController::UpdateMode(const std::vector<zone> &zones, const mode &active)
|
||||
{
|
||||
/*---------------------------------*\
|
||||
| Activate all channels |
|
||||
\*---------------------------------*/
|
||||
for(size_t channel = 0; channel < zones.size(); channel++)
|
||||
{
|
||||
this->SendActivate(channel, zones[channel].leds_count);
|
||||
}
|
||||
|
||||
/*---------------------------------*\
|
||||
| Set merge mode if requested |
|
||||
\*---------------------------------*/
|
||||
is_merged_mode = active.name.find("Merged") != std::string::npos;
|
||||
this->SendMerge();
|
||||
|
||||
for (size_t channel = 0; channel < zones.size(); channel++)
|
||||
{
|
||||
UpdateZoneLEDs(channel, zones[channel], active);
|
||||
}
|
||||
}
|
||||
|
||||
void LianLiUniHubSLController::UpdateZoneLEDs(size_t channel, const zone &z, const mode &active)
|
||||
{
|
||||
/*---------------------------------*\
|
||||
| Handle per-LED color mode |
|
||||
\*---------------------------------*/
|
||||
if(active.color_mode == MODE_COLORS_PER_LED)
|
||||
{
|
||||
this->SetPerLEDColor(channel, z, active);
|
||||
return;
|
||||
}
|
||||
|
||||
/*-------------------------------------------------*\
|
||||
| In merged mode, only first channel takes control |
|
||||
\*-------------------------------------------------*/
|
||||
if(is_merged_mode && channel > 0)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
/*---------------------------------*\
|
||||
| Handle mode-specific color |
|
||||
\*---------------------------------*/
|
||||
this->SetModeSpecificColor(channel, active);
|
||||
}
|
||||
|
||||
|
||||
void LianLiUniHubSLController::SetPerLEDColor(size_t channel, const zone &z, const mode &active)
|
||||
{
|
||||
unsigned char color_buf[UNIHUB_SL_MAX_LED_PER_CHANNEL * 3];
|
||||
float brightness_scale = (float)(active.brightness) / active.brightness_max;
|
||||
|
||||
memset(color_buf, 0, sizeof(color_buf));
|
||||
this->FillStaticColorBuffer(color_buf, z.colors, z.leds_count, brightness_scale);
|
||||
this->SendColor(channel, color_buf, sizeof(color_buf));
|
||||
this->SendMode(channel, active);
|
||||
}
|
||||
|
||||
void LianLiUniHubSLController::SetModeSpecificColor(size_t channel, const mode &active)
|
||||
{
|
||||
unsigned char color_buf[UNIHUB_SL_MAX_LED_PER_CHANNEL * 3];
|
||||
memset(color_buf, 0, sizeof(color_buf));
|
||||
|
||||
float brightness_scale = (float)(active.brightness) / active.brightness_max;
|
||||
|
||||
switch(active.value)
|
||||
{
|
||||
case UNIHUB_SL_LED_MODE_RAINBOW:
|
||||
case UNIHUB_SL_LED_MODE_RAINBOW_MORPH:
|
||||
case UNIHUB_SL_LED_MODE_STACK_MULTI_COLOR:
|
||||
case UNIHUB_SL_LED_MODE_NEON:
|
||||
/*-------------------------*\
|
||||
| No need to set any value |
|
||||
\*-------------------------*/
|
||||
break;
|
||||
|
||||
case UNIHUB_SL_LED_MODE_STATIC:
|
||||
case UNIHUB_SL_LED_MODE_BREATHING:
|
||||
this->FillStaticColorBuffer(color_buf, active.colors.data(), active.colors.size(), brightness_scale);
|
||||
break;
|
||||
|
||||
case UNIHUB_SL_LED_MODE_COLOR_CYCLE:
|
||||
case UNIHUB_SL_LED_MODE_RUNWAY:
|
||||
case UNIHUB_SL_LED_MODE_STAGGERED:
|
||||
case UNIHUB_SL_LED_MODE_TIDE:
|
||||
case UNIHUB_SL_LED_MODE_METEOR:
|
||||
case UNIHUB_SL_LED_MODE_MIXING:
|
||||
case UNIHUB_SL_LED_MODE_STACK:
|
||||
this->FillDynamicColorBuffer(color_buf, active.colors.data(), active.colors.size(), brightness_scale);
|
||||
break;
|
||||
|
||||
default:
|
||||
LOG_WARNING("[Lian Li Uni Hub - SL] Unknown mode value: %d", active.value);
|
||||
break;
|
||||
}
|
||||
|
||||
this->SendColor(channel, color_buf, sizeof(color_buf));
|
||||
this->SendMode(channel, active);
|
||||
}
|
||||
|
||||
void LianLiUniHubSLController::FillStaticColorBuffer(unsigned char *color_buf, const RGBColor *colors, size_t num_colors, float brightness_scale)
|
||||
{
|
||||
size_t max_fans = (size_t)UNIHUB_SL_MAX_FAN_PER_CHANNEL;
|
||||
size_t max_idx = num_colors < max_fans ? num_colors : max_fans;
|
||||
|
||||
for(size_t fan_idx = 0; fan_idx < max_idx; fan_idx++)
|
||||
{
|
||||
RGBColor color = colors[fan_idx];
|
||||
unsigned char r = (unsigned char)(RGBGetRValue(color) * brightness_scale);
|
||||
unsigned char g = (unsigned char)(RGBGetGValue(color) * brightness_scale);
|
||||
unsigned char b = (unsigned char)(RGBGetBValue(color) * brightness_scale);
|
||||
|
||||
for(size_t led_idx = 0; led_idx < UNIHUB_SL_LED_PER_FAN; led_idx++)
|
||||
{
|
||||
size_t absolute_led_idx = fan_idx * UNIHUB_SL_LED_PER_FAN + led_idx;
|
||||
size_t idx = absolute_led_idx * 3;
|
||||
|
||||
/*------------------------*\
|
||||
| The protocol uses R B G |
|
||||
\*------------------------*/
|
||||
color_buf[idx + 0] = r;
|
||||
color_buf[idx + 1] = b;
|
||||
color_buf[idx + 2] = g;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void LianLiUniHubSLController::FillDynamicColorBuffer(unsigned char *color_buf, const RGBColor *colors, size_t num_colors, float brightness_scale)
|
||||
{
|
||||
size_t max_fans = (size_t)UNIHUB_SL_MAX_FAN_PER_CHANNEL;
|
||||
size_t max_idx = num_colors < max_fans ? num_colors : max_fans;
|
||||
|
||||
for(size_t color_idx = 0; color_idx < max_idx; color_idx++)
|
||||
{
|
||||
RGBColor color = colors[color_idx];
|
||||
unsigned char r = (unsigned char)(RGBGetRValue(color) * brightness_scale);
|
||||
unsigned char g = (unsigned char)(RGBGetGValue(color) * brightness_scale);
|
||||
unsigned char b = (unsigned char)(RGBGetBValue(color) * brightness_scale);
|
||||
|
||||
size_t idx = (color_idx * 3);
|
||||
|
||||
/*------------------------*\
|
||||
| The protocol uses R B G |
|
||||
\*------------------------*/
|
||||
color_buf[idx + 0] = r;
|
||||
color_buf[idx + 1] = b;
|
||||
color_buf[idx + 2] = g;
|
||||
}
|
||||
}
|
||||
|
||||
unsigned char LianLiUniHubSLController::ConvertBrightness(unsigned int brightness)
|
||||
{
|
||||
switch(brightness)
|
||||
{
|
||||
case 0:
|
||||
return UNIHUB_SL_LED_BRIGHTNESS_000;
|
||||
|
||||
case 1:
|
||||
return UNIHUB_SL_LED_BRIGHTNESS_025;
|
||||
|
||||
case 2:
|
||||
return UNIHUB_SL_LED_BRIGHTNESS_050;
|
||||
|
||||
case 3:
|
||||
return UNIHUB_SL_LED_BRIGHTNESS_075;
|
||||
|
||||
case 4:
|
||||
return UNIHUB_SL_LED_BRIGHTNESS_100;
|
||||
|
||||
default:
|
||||
return UNIHUB_SL_LED_BRIGHTNESS_100;
|
||||
}
|
||||
}
|
||||
|
||||
unsigned char LianLiUniHubSLController::ConvertSpeed(unsigned int speed)
|
||||
{
|
||||
switch(speed)
|
||||
{
|
||||
case 0:
|
||||
return UNIHUB_SL_LED_SPEED_000;
|
||||
|
||||
case 1:
|
||||
return UNIHUB_SL_LED_SPEED_025;
|
||||
|
||||
case 2:
|
||||
return UNIHUB_SL_LED_SPEED_050;
|
||||
|
||||
case 3:
|
||||
return UNIHUB_SL_LED_SPEED_075;
|
||||
|
||||
case 4:
|
||||
return UNIHUB_SL_LED_SPEED_100;
|
||||
|
||||
default:
|
||||
return UNIHUB_SL_LED_SPEED_050;
|
||||
}
|
||||
}
|
||||
|
||||
unsigned char LianLiUniHubSLController::ConvertDirection(unsigned int direction)
|
||||
{
|
||||
switch(direction)
|
||||
{
|
||||
case MODE_DIRECTION_LEFT:
|
||||
return UNIHUB_SL_LED_DIRECTION_LTR;
|
||||
|
||||
case MODE_DIRECTION_RIGHT:
|
||||
return UNIHUB_SL_LED_DIRECTION_RTL;
|
||||
|
||||
default:
|
||||
return UNIHUB_SL_LED_DIRECTION_LTR;
|
||||
}
|
||||
}
|
||||
|
||||
void LianLiUniHubSLController::SendActivate(size_t channel, unsigned char num_fans)
|
||||
{
|
||||
unsigned char buf[11];
|
||||
memset(buf, 0x00, sizeof(buf));
|
||||
|
||||
buf[0x00] = UNIHUB_SL_REPORT_ID;
|
||||
buf[0x01] = 0x10;
|
||||
buf[0x02] = 0x32;
|
||||
buf[0x03] = 0x10 * (unsigned char)channel + num_fans;
|
||||
|
||||
this->LogBuffer("SendActivate", buf, sizeof(buf));
|
||||
|
||||
hid_write(this->device, buf, sizeof(buf));
|
||||
std::this_thread::sleep_for(5ms);
|
||||
}
|
||||
|
||||
void LianLiUniHubSLController::SendMerge()
|
||||
{
|
||||
unsigned char buf[11];
|
||||
memset(buf, 0x00, sizeof(buf));
|
||||
|
||||
buf[0x00] = UNIHUB_SL_REPORT_ID;
|
||||
buf[0x01] = 0x10;
|
||||
if(is_merged_mode)
|
||||
{
|
||||
buf[0x02] = 0x33;
|
||||
buf[0x03] = 0x00;
|
||||
buf[0x04] = 0x01;
|
||||
buf[0x05] = 0x02;
|
||||
buf[0x06] = 0x03;
|
||||
buf[0x07] = 0x08;
|
||||
}
|
||||
else
|
||||
{
|
||||
buf[0x02] = 0x34;
|
||||
}
|
||||
|
||||
this->LogBuffer("SendMerge", buf, sizeof(buf));
|
||||
|
||||
hid_write(this->device, buf, sizeof(buf));
|
||||
std::this_thread::sleep_for(5ms);
|
||||
}
|
||||
|
||||
void LianLiUniHubSLController::SendColor(size_t channel, const unsigned char *colors, size_t num_colors)
|
||||
{
|
||||
unsigned char* buf = new unsigned char[2 + num_colors];
|
||||
memset(buf, 0x00, (2 + num_colors));
|
||||
|
||||
buf[0x00] = UNIHUB_SL_REPORT_ID;
|
||||
buf[0x01] = 0x30 + (unsigned char)channel; // Channel 1: 0x30, Channel 2: 0x31, etc.
|
||||
|
||||
memcpy(&buf[0x02], colors, num_colors);
|
||||
|
||||
this->LogBuffer("SendColor", buf, sizeof(buf));
|
||||
|
||||
hid_write(this->device, buf, sizeof(buf));
|
||||
std::this_thread::sleep_for(5ms);
|
||||
|
||||
delete[] buf;
|
||||
}
|
||||
|
||||
void LianLiUniHubSLController::SendMode(size_t channel, const mode &active)
|
||||
{
|
||||
unsigned char buf[11];
|
||||
memset(buf, 0x00, sizeof(buf));
|
||||
|
||||
buf[0x00] = UNIHUB_SL_REPORT_ID;
|
||||
buf[0x01] = 0x10 + (unsigned char)channel; // Channel 1: 0x10, Channel 2: 0x11, etc.
|
||||
buf[0x02] = active.value;
|
||||
buf[0x03] = this->ConvertSpeed(active.speed);
|
||||
buf[0x04] = this->ConvertDirection(active.direction);
|
||||
buf[0x05] = this->ConvertBrightness(active.brightness);
|
||||
|
||||
this->LogBuffer("SendMode", buf, sizeof(buf));
|
||||
|
||||
hid_write(this->device, buf, sizeof(buf));
|
||||
std::this_thread::sleep_for(5ms);
|
||||
}
|
||||
|
||||
void LianLiUniHubSLController::LogBuffer(const char *operation, const unsigned char *buf, size_t buf_len)
|
||||
{
|
||||
std::string hex_string;
|
||||
for(size_t i = 0; i < buf_len; i++)
|
||||
{
|
||||
char hex_byte[3];
|
||||
snprintf(hex_byte, sizeof(hex_byte), "%02X", buf[i]);
|
||||
hex_string += hex_byte;
|
||||
}
|
||||
LOG_DEBUG("[Lian Li Uni Hub - SL] %s buffer: %s", operation, hex_string.c_str());
|
||||
}
|
||||
@@ -0,0 +1,119 @@
|
||||
/*---------------------------------------------------------*\
|
||||
| LianLiUniHubSLController.h |
|
||||
| |
|
||||
| Driver for Lian Li Uni Hub - SL |
|
||||
| |
|
||||
| Muhamad Visat 26 Jul 2025 |
|
||||
| Original work by Luca Lovisa & Oliver P |
|
||||
| |
|
||||
| This file is part of the OpenRGB project |
|
||||
| SPDX-License-Identifier: GPL-2.0-only |
|
||||
\*---------------------------------------------------------*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <string>
|
||||
#include <vector>
|
||||
#include <hidapi.h>
|
||||
#include "RGBController.h"
|
||||
|
||||
enum
|
||||
{
|
||||
UNIHUB_SL_REPORT_ID = 0xE0,
|
||||
};
|
||||
|
||||
enum
|
||||
{
|
||||
UNIHUB_SL_MAX_CHANNEL = 4,
|
||||
UNIHUB_SL_MAX_FAN_PER_CHANNEL = 4,
|
||||
UNIHUB_SL_LED_PER_FAN = 16,
|
||||
UNIHUB_SL_MAX_LED_PER_CHANNEL = 64,
|
||||
};
|
||||
|
||||
enum
|
||||
{
|
||||
UNIHUB_SL_LED_BRIGHTNESS_MIN = 0x00, // 0%
|
||||
UNIHUB_SL_LED_BRIGHTNESS_MAX = 0x04, // 100%
|
||||
UNIHUB_SL_LED_BRIGHTNESS_DEFAULT = 0x04, // 100%
|
||||
|
||||
UNIHUB_SL_LED_BRIGHTNESS_000 = 0x08, // Black (turned off)
|
||||
UNIHUB_SL_LED_BRIGHTNESS_025 = 0x03, // Dark
|
||||
UNIHUB_SL_LED_BRIGHTNESS_050 = 0x02, // Medium
|
||||
UNIHUB_SL_LED_BRIGHTNESS_075 = 0x01, // Bright
|
||||
UNIHUB_SL_LED_BRIGHTNESS_100 = 0x00, // Brightest
|
||||
};
|
||||
|
||||
enum
|
||||
{
|
||||
UNIHUB_SL_LED_SPEED_MIN = 0x00, // Slowest
|
||||
UNIHUB_SL_LED_SPEED_MAX = 0x04, // Fastest
|
||||
UNIHUB_SL_LED_SPEED_DEFAULT = 0x00, // Slowest
|
||||
|
||||
UNIHUB_SL_LED_SPEED_000 = 0x02, // Slowest
|
||||
UNIHUB_SL_LED_SPEED_025 = 0x01, // Slow
|
||||
UNIHUB_SL_LED_SPEED_050 = 0x00, // Medium
|
||||
UNIHUB_SL_LED_SPEED_075 = 0xff, // Fast
|
||||
UNIHUB_SL_LED_SPEED_100 = 0xfe, // Fastest
|
||||
};
|
||||
|
||||
enum
|
||||
{
|
||||
UNIHUB_SL_LED_DIRECTION_LTR = 0x00, // Left to right
|
||||
UNIHUB_SL_LED_DIRECTION_RTL = 0x01, // Right to left
|
||||
};
|
||||
|
||||
enum
|
||||
{
|
||||
UNIHUB_SL_LED_MODE_RAINBOW = 0x05,
|
||||
UNIHUB_SL_LED_MODE_RAINBOW_MORPH = 0x04,
|
||||
UNIHUB_SL_LED_MODE_STATIC = 0x01,
|
||||
UNIHUB_SL_LED_MODE_BREATHING = 0x02,
|
||||
UNIHUB_SL_LED_MODE_COLOR_CYCLE = 0x23,
|
||||
UNIHUB_SL_LED_MODE_RUNWAY = 0x1c,
|
||||
UNIHUB_SL_LED_MODE_RUNWAY_MERGED = 0x1c,
|
||||
UNIHUB_SL_LED_MODE_STAGGERED = 0x18,
|
||||
UNIHUB_SL_LED_MODE_TIDE = 0x1a,
|
||||
UNIHUB_SL_LED_MODE_METEOR = 0x24,
|
||||
UNIHUB_SL_LED_MODE_METEOR_MERGED = 0x24,
|
||||
UNIHUB_SL_LED_MODE_MIXING = 0x1e,
|
||||
UNIHUB_SL_LED_MODE_STACK = 0x20,
|
||||
UNIHUB_SL_LED_MODE_STACK_MULTI_COLOR = 0x21,
|
||||
UNIHUB_SL_LED_MODE_NEON = 0x22,
|
||||
};
|
||||
|
||||
class LianLiUniHubSLController
|
||||
{
|
||||
public:
|
||||
LianLiUniHubSLController(hid_device *device, const char *path);
|
||||
~LianLiUniHubSLController();
|
||||
|
||||
std::string ReadVersion();
|
||||
std::string ReadSerial();
|
||||
|
||||
std::string GetLocation() { return this->location; };
|
||||
|
||||
void UpdateMode(const std::vector<zone> &zones, const mode &active);
|
||||
void UpdateZoneLEDs(size_t channel, const zone &z, const mode &active);
|
||||
|
||||
private:
|
||||
hid_device *device;
|
||||
std::string location;
|
||||
|
||||
bool is_merged_mode;
|
||||
|
||||
void SetPerLEDColor(size_t channel, const zone &z, const mode &active);
|
||||
void SetModeSpecificColor(size_t channel, const mode &active);
|
||||
void FillStaticColorBuffer(unsigned char *color_buf, const RGBColor *colors, size_t num_colors, float brightness_scale);
|
||||
void FillDynamicColorBuffer(unsigned char *color_buf, const RGBColor *colors, size_t num_colors, float brightness_scale);
|
||||
|
||||
unsigned char ConvertBrightness(unsigned int brightness);
|
||||
unsigned char ConvertSpeed(unsigned int speed);
|
||||
unsigned char ConvertDirection(unsigned int direction);
|
||||
|
||||
void SendActivate(size_t channel, unsigned char num_fans);
|
||||
void SendMerge();
|
||||
void SendColor(size_t channel, const unsigned char *color_buf, size_t color_buf_len);
|
||||
void SendMode(size_t channel, const mode &active);
|
||||
|
||||
void LogBuffer(const char *operation, const unsigned char *buf, size_t len);
|
||||
};
|
||||
+381
@@ -0,0 +1,381 @@
|
||||
/*---------------------------------------------------------*\
|
||||
| RGBController_LianLiUniHubSL.cpp |
|
||||
| |
|
||||
| RGBController for Lian Li Uni Hub - SL |
|
||||
| |
|
||||
| Muhamad Visat 26 Jul 2025 |
|
||||
| Original work by Luca Lovisa & Oliver P |
|
||||
| |
|
||||
| This file is part of the OpenRGB project |
|
||||
| SPDX-License-Identifier: GPL-2.0-only |
|
||||
\*---------------------------------------------------------*/
|
||||
|
||||
#include "RGBController_LianLiUniHubSL.h"
|
||||
|
||||
/**------------------------------------------------------------------*\
|
||||
@name Lian Li Uni Hub - SL
|
||||
@category Cooler
|
||||
@type USB
|
||||
@save :x:
|
||||
@direct :rotating_light:
|
||||
@effects :white_check_mark:
|
||||
@detectors DetectLianLiUniHubSL
|
||||
@comment
|
||||
\*-------------------------------------------------------------------*/
|
||||
|
||||
RGBController_LianLiUniHubSL::RGBController_LianLiUniHubSL(LianLiUniHubSLController *controller, std::string name)
|
||||
{
|
||||
this->controller = controller;
|
||||
this->name = name;
|
||||
this->vendor = "Lian Li";
|
||||
this->description = "Lian Li Uni Hub - SL";
|
||||
this->version = controller->ReadVersion();
|
||||
this->serial = controller->ReadSerial();
|
||||
this->location = controller->GetLocation();
|
||||
this->type = DEVICE_TYPE_COOLER;
|
||||
|
||||
initialized = false;
|
||||
|
||||
mode Custom;
|
||||
Custom.name = "Custom";
|
||||
Custom.value = UNIHUB_SL_LED_MODE_STATIC;
|
||||
Custom.flags = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_PER_LED_COLOR;
|
||||
Custom.brightness_min = UNIHUB_SL_LED_BRIGHTNESS_MIN;
|
||||
Custom.brightness_max = UNIHUB_SL_LED_BRIGHTNESS_MAX;
|
||||
Custom.brightness = UNIHUB_SL_LED_BRIGHTNESS_DEFAULT;
|
||||
Custom.color_mode = MODE_COLORS_PER_LED;
|
||||
modes.push_back(Custom);
|
||||
|
||||
mode Rainbow;
|
||||
Rainbow.name = "Rainbow";
|
||||
Rainbow.value = UNIHUB_SL_LED_MODE_RAINBOW;
|
||||
Rainbow.flags = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
|
||||
Rainbow.speed_min = UNIHUB_SL_LED_SPEED_MIN;
|
||||
Rainbow.speed_max = UNIHUB_SL_LED_SPEED_MAX;
|
||||
Rainbow.brightness_min = UNIHUB_SL_LED_BRIGHTNESS_MIN;
|
||||
Rainbow.brightness_max = UNIHUB_SL_LED_BRIGHTNESS_MAX;
|
||||
Rainbow.speed = UNIHUB_SL_LED_SPEED_DEFAULT;
|
||||
Rainbow.brightness = UNIHUB_SL_LED_BRIGHTNESS_DEFAULT;
|
||||
Rainbow.direction = UNIHUB_SL_LED_DIRECTION_LTR;
|
||||
Rainbow.color_mode = MODE_COLORS_NONE;
|
||||
modes.push_back(Rainbow);
|
||||
|
||||
mode RainbowMorph;
|
||||
RainbowMorph.name = "Rainbow Morph";
|
||||
RainbowMorph.value = UNIHUB_SL_LED_MODE_RAINBOW_MORPH;
|
||||
RainbowMorph.flags = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
|
||||
RainbowMorph.speed_min = UNIHUB_SL_LED_SPEED_MIN;
|
||||
RainbowMorph.speed_max = UNIHUB_SL_LED_SPEED_MAX;
|
||||
RainbowMorph.brightness_min = UNIHUB_SL_LED_BRIGHTNESS_MIN;
|
||||
RainbowMorph.brightness_max = UNIHUB_SL_LED_BRIGHTNESS_MAX;
|
||||
RainbowMorph.speed = UNIHUB_SL_LED_SPEED_DEFAULT;
|
||||
RainbowMorph.brightness = UNIHUB_SL_LED_BRIGHTNESS_DEFAULT;
|
||||
RainbowMorph.direction = UNIHUB_SL_LED_DIRECTION_LTR;
|
||||
RainbowMorph.color_mode = MODE_COLORS_NONE;
|
||||
modes.push_back(RainbowMorph);
|
||||
|
||||
mode Static;
|
||||
Static.name = "Static";
|
||||
Static.value = UNIHUB_SL_LED_MODE_STATIC;
|
||||
Static.flags = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_PER_LED_COLOR;
|
||||
Static.brightness_min = UNIHUB_SL_LED_BRIGHTNESS_MIN;
|
||||
Static.brightness_max = UNIHUB_SL_LED_BRIGHTNESS_MAX;
|
||||
Static.brightness = UNIHUB_SL_LED_BRIGHTNESS_DEFAULT;
|
||||
Static.color_mode = MODE_COLORS_PER_LED;
|
||||
modes.push_back(Static);
|
||||
|
||||
mode Breathing;
|
||||
Breathing.name = "Breathing";
|
||||
Breathing.value = UNIHUB_SL_LED_MODE_BREATHING;
|
||||
Breathing.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_PER_LED_COLOR;
|
||||
Breathing.speed_min = UNIHUB_SL_LED_SPEED_MIN;
|
||||
Breathing.speed_max = UNIHUB_SL_LED_SPEED_MAX;
|
||||
Breathing.brightness_min = UNIHUB_SL_LED_BRIGHTNESS_MIN;
|
||||
Breathing.brightness_max = UNIHUB_SL_LED_BRIGHTNESS_MAX;
|
||||
Breathing.speed = UNIHUB_SL_LED_SPEED_DEFAULT;
|
||||
Breathing.brightness = UNIHUB_SL_LED_BRIGHTNESS_DEFAULT;
|
||||
Breathing.color_mode = MODE_COLORS_PER_LED;
|
||||
modes.push_back(Breathing);
|
||||
|
||||
mode ColorCycle;
|
||||
ColorCycle.name = "Color Cycle";
|
||||
ColorCycle.value = UNIHUB_SL_LED_MODE_COLOR_CYCLE;
|
||||
ColorCycle.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_DIRECTION_LR;
|
||||
ColorCycle.speed_min = UNIHUB_SL_LED_SPEED_MIN;
|
||||
ColorCycle.speed_max = UNIHUB_SL_LED_SPEED_MAX;
|
||||
ColorCycle.brightness_min = UNIHUB_SL_LED_BRIGHTNESS_MIN;
|
||||
ColorCycle.brightness_max = UNIHUB_SL_LED_BRIGHTNESS_MAX;
|
||||
ColorCycle.colors_min = 3;
|
||||
ColorCycle.colors_max = 3;
|
||||
ColorCycle.speed = UNIHUB_SL_LED_SPEED_DEFAULT;
|
||||
ColorCycle.brightness = UNIHUB_SL_LED_BRIGHTNESS_DEFAULT;
|
||||
ColorCycle.direction = UNIHUB_SL_LED_DIRECTION_LTR;
|
||||
ColorCycle.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
modes.push_back(ColorCycle);
|
||||
|
||||
mode Runway;
|
||||
Runway.name = "Runway";
|
||||
Runway.value = UNIHUB_SL_LED_MODE_RUNWAY;
|
||||
Runway.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
|
||||
Runway.speed_min = UNIHUB_SL_LED_SPEED_MIN;
|
||||
Runway.speed_max = UNIHUB_SL_LED_SPEED_MAX;
|
||||
Runway.brightness_min = UNIHUB_SL_LED_BRIGHTNESS_MIN;
|
||||
Runway.brightness_max = UNIHUB_SL_LED_BRIGHTNESS_MAX;
|
||||
Runway.colors_min = 2;
|
||||
Runway.colors_max = 2;
|
||||
Runway.speed = UNIHUB_SL_LED_SPEED_DEFAULT;
|
||||
Runway.brightness = UNIHUB_SL_LED_BRIGHTNESS_DEFAULT;
|
||||
Runway.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
modes.push_back(Runway);
|
||||
|
||||
mode RunwayMerged;
|
||||
RunwayMerged.name = "Runway Merged";
|
||||
RunwayMerged.value = UNIHUB_SL_LED_MODE_RUNWAY;
|
||||
RunwayMerged.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
|
||||
RunwayMerged.speed_min = UNIHUB_SL_LED_SPEED_MIN;
|
||||
RunwayMerged.speed_max = UNIHUB_SL_LED_SPEED_MAX;
|
||||
RunwayMerged.brightness_min = UNIHUB_SL_LED_BRIGHTNESS_MIN;
|
||||
RunwayMerged.brightness_max = UNIHUB_SL_LED_BRIGHTNESS_MAX;
|
||||
RunwayMerged.colors_min = 2;
|
||||
RunwayMerged.colors_max = 2;
|
||||
RunwayMerged.speed = UNIHUB_SL_LED_SPEED_DEFAULT;
|
||||
RunwayMerged.brightness = UNIHUB_SL_LED_BRIGHTNESS_DEFAULT;
|
||||
RunwayMerged.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
modes.push_back(RunwayMerged);
|
||||
|
||||
mode Staggered;
|
||||
Staggered.name = "Staggered";
|
||||
Staggered.value = UNIHUB_SL_LED_MODE_STAGGERED;
|
||||
Staggered.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
|
||||
Staggered.speed_min = UNIHUB_SL_LED_SPEED_MIN;
|
||||
Staggered.speed_max = UNIHUB_SL_LED_SPEED_MAX;
|
||||
Staggered.brightness_min = UNIHUB_SL_LED_BRIGHTNESS_MIN;
|
||||
Staggered.brightness_max = UNIHUB_SL_LED_BRIGHTNESS_MAX;
|
||||
Staggered.colors_min = 2;
|
||||
Staggered.colors_max = 2;
|
||||
Staggered.speed = UNIHUB_SL_LED_SPEED_DEFAULT;
|
||||
Staggered.brightness = UNIHUB_SL_LED_BRIGHTNESS_DEFAULT;
|
||||
Staggered.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
modes.push_back(Staggered);
|
||||
|
||||
mode Tide;
|
||||
Tide.name = "Tide";
|
||||
Tide.value = UNIHUB_SL_LED_MODE_TIDE;
|
||||
Tide.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
|
||||
Tide.speed_min = UNIHUB_SL_LED_SPEED_MIN;
|
||||
Tide.speed_max = UNIHUB_SL_LED_SPEED_MAX;
|
||||
Tide.brightness_min = UNIHUB_SL_LED_BRIGHTNESS_MIN;
|
||||
Tide.brightness_max = UNIHUB_SL_LED_BRIGHTNESS_MAX;
|
||||
Tide.colors_min = 2;
|
||||
Tide.colors_max = 2;
|
||||
Tide.speed = UNIHUB_SL_LED_SPEED_DEFAULT;
|
||||
Tide.brightness = UNIHUB_SL_LED_BRIGHTNESS_DEFAULT;
|
||||
Tide.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
modes.push_back(Tide);
|
||||
|
||||
mode Meteor;
|
||||
Meteor.name = "Meteor";
|
||||
Meteor.value = UNIHUB_SL_LED_MODE_METEOR;
|
||||
Meteor.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_DIRECTION_LR;
|
||||
Meteor.speed_min = UNIHUB_SL_LED_SPEED_MIN;
|
||||
Meteor.speed_max = UNIHUB_SL_LED_SPEED_MAX;
|
||||
Meteor.brightness_min = UNIHUB_SL_LED_BRIGHTNESS_MIN;
|
||||
Meteor.brightness_max = UNIHUB_SL_LED_BRIGHTNESS_MAX;
|
||||
Meteor.colors_min = 2;
|
||||
Meteor.colors_max = 2;
|
||||
Meteor.speed = UNIHUB_SL_LED_SPEED_DEFAULT;
|
||||
Meteor.brightness = UNIHUB_SL_LED_BRIGHTNESS_DEFAULT;
|
||||
Meteor.direction = UNIHUB_SL_LED_DIRECTION_LTR;
|
||||
Meteor.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
modes.push_back(Meteor);
|
||||
|
||||
mode MeteorMerged;
|
||||
MeteorMerged.name = "Meteor Merged";
|
||||
MeteorMerged.value = UNIHUB_SL_LED_MODE_METEOR_MERGED;
|
||||
MeteorMerged.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_DIRECTION_LR;
|
||||
MeteorMerged.speed_min = UNIHUB_SL_LED_SPEED_MIN;
|
||||
MeteorMerged.speed_max = UNIHUB_SL_LED_SPEED_MAX;
|
||||
MeteorMerged.brightness_min = UNIHUB_SL_LED_BRIGHTNESS_MIN;
|
||||
MeteorMerged.brightness_max = UNIHUB_SL_LED_BRIGHTNESS_MAX;
|
||||
MeteorMerged.colors_min = 2;
|
||||
MeteorMerged.colors_max = 2;
|
||||
MeteorMerged.speed = UNIHUB_SL_LED_SPEED_DEFAULT;
|
||||
MeteorMerged.brightness = UNIHUB_SL_LED_BRIGHTNESS_DEFAULT;
|
||||
MeteorMerged.direction = UNIHUB_SL_LED_DIRECTION_LTR;
|
||||
MeteorMerged.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
modes.push_back(MeteorMerged);
|
||||
|
||||
mode Mixing;
|
||||
Mixing.name = "Mixing";
|
||||
Mixing.value = UNIHUB_SL_LED_MODE_MIXING;
|
||||
Mixing.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
|
||||
Mixing.speed_min = UNIHUB_SL_LED_SPEED_MIN;
|
||||
Mixing.speed_max = UNIHUB_SL_LED_SPEED_MAX;
|
||||
Mixing.brightness_min = UNIHUB_SL_LED_BRIGHTNESS_MIN;
|
||||
Mixing.brightness_max = UNIHUB_SL_LED_BRIGHTNESS_MAX;
|
||||
Mixing.colors_min = 2;
|
||||
Mixing.colors_max = 2;
|
||||
Mixing.speed = UNIHUB_SL_LED_SPEED_DEFAULT;
|
||||
Mixing.brightness = UNIHUB_SL_LED_BRIGHTNESS_DEFAULT;
|
||||
Mixing.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
modes.push_back(Mixing);
|
||||
|
||||
mode Stack;
|
||||
Stack.name = "Stack";
|
||||
Stack.value = UNIHUB_SL_LED_MODE_STACK;
|
||||
Stack.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_DIRECTION_LR;
|
||||
Stack.speed_min = UNIHUB_SL_LED_SPEED_MIN;
|
||||
Stack.speed_max = UNIHUB_SL_LED_SPEED_MAX;
|
||||
Stack.brightness_min = UNIHUB_SL_LED_BRIGHTNESS_MIN;
|
||||
Stack.brightness_max = UNIHUB_SL_LED_BRIGHTNESS_MAX;
|
||||
Stack.colors_min = 1;
|
||||
Stack.colors_max = 1;
|
||||
Stack.speed = UNIHUB_SL_LED_SPEED_DEFAULT;
|
||||
Stack.brightness = UNIHUB_SL_LED_BRIGHTNESS_DEFAULT;
|
||||
Stack.direction = UNIHUB_SL_LED_DIRECTION_LTR;
|
||||
Stack.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
modes.push_back(Stack);
|
||||
|
||||
mode StackMultiColor;
|
||||
StackMultiColor.name = "Stack Multi Color";
|
||||
StackMultiColor.value = UNIHUB_SL_LED_MODE_STACK_MULTI_COLOR;
|
||||
StackMultiColor.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_DIRECTION_LR;
|
||||
StackMultiColor.speed_min = UNIHUB_SL_LED_SPEED_MIN;
|
||||
StackMultiColor.speed_max = UNIHUB_SL_LED_SPEED_MAX;
|
||||
StackMultiColor.brightness_min = UNIHUB_SL_LED_BRIGHTNESS_MIN;
|
||||
StackMultiColor.brightness_max = UNIHUB_SL_LED_BRIGHTNESS_MAX;
|
||||
StackMultiColor.speed = UNIHUB_SL_LED_SPEED_DEFAULT;
|
||||
StackMultiColor.brightness = UNIHUB_SL_LED_BRIGHTNESS_DEFAULT;
|
||||
StackMultiColor.direction = UNIHUB_SL_LED_DIRECTION_LTR;
|
||||
StackMultiColor.color_mode = MODE_COLORS_NONE;
|
||||
modes.push_back(StackMultiColor);
|
||||
|
||||
mode Neon;
|
||||
Neon.name = "Neon";
|
||||
Neon.value = UNIHUB_SL_LED_MODE_NEON;
|
||||
Neon.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
|
||||
Neon.speed_min = UNIHUB_SL_LED_SPEED_MIN;
|
||||
Neon.speed_max = UNIHUB_SL_LED_SPEED_MAX;
|
||||
Neon.brightness_min = UNIHUB_SL_LED_BRIGHTNESS_MIN;
|
||||
Neon.brightness_max = UNIHUB_SL_LED_BRIGHTNESS_MAX;
|
||||
Neon.speed = UNIHUB_SL_LED_SPEED_DEFAULT;
|
||||
Neon.brightness = UNIHUB_SL_LED_BRIGHTNESS_DEFAULT;
|
||||
Neon.color_mode = MODE_COLORS_NONE;
|
||||
modes.push_back(Neon);
|
||||
|
||||
RGBColor default_colors[] =
|
||||
{
|
||||
ToRGBColor(255, 0, 0), // Red
|
||||
ToRGBColor(0, 255, 0), // Green
|
||||
ToRGBColor(0, 0, 255), // Blue
|
||||
ToRGBColor(255, 255, 255), // White
|
||||
};
|
||||
|
||||
for(size_t mode_idx = 0; mode_idx < modes.size(); mode_idx++)
|
||||
{
|
||||
mode &m = modes[mode_idx];
|
||||
m.colors.resize(m.colors_max);
|
||||
for (unsigned int color_idx = 0; color_idx < m.colors_max; color_idx++)
|
||||
{
|
||||
m.colors[color_idx] = default_colors[color_idx % sizeof(default_colors)];
|
||||
}
|
||||
}
|
||||
|
||||
RGBController_LianLiUniHubSL::SetupZones();
|
||||
}
|
||||
|
||||
RGBController_LianLiUniHubSL::~RGBController_LianLiUniHubSL()
|
||||
{
|
||||
delete this->controller;
|
||||
}
|
||||
|
||||
void RGBController_LianLiUniHubSL::SetupZones()
|
||||
{
|
||||
bool first_run = zones.size() == 0;
|
||||
|
||||
leds.clear();
|
||||
colors.clear();
|
||||
if(first_run)
|
||||
{
|
||||
zones.resize(UNIHUB_SL_MAX_CHANNEL);
|
||||
}
|
||||
|
||||
for(size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
|
||||
{
|
||||
zones[zone_idx].name = "Channel ";
|
||||
zones[zone_idx].name.append(std::to_string(zone_idx + 1));
|
||||
zones[zone_idx].type = ZONE_TYPE_LINEAR;
|
||||
zones[zone_idx].matrix_map = NULL;
|
||||
|
||||
zones[zone_idx].leds_min = 0;
|
||||
zones[zone_idx].leds_max = UNIHUB_SL_MAX_FAN_PER_CHANNEL;
|
||||
|
||||
if(first_run)
|
||||
{
|
||||
zones[zone_idx].leds_count = zones[zone_idx].leds_min;
|
||||
}
|
||||
|
||||
for(unsigned int led_idx = 0; led_idx < zones[zone_idx].leds_count; led_idx++)
|
||||
{
|
||||
led new_led;
|
||||
new_led.name = zones[zone_idx].name;
|
||||
new_led.name.append(", Fan ");
|
||||
new_led.name.append(std::to_string(led_idx + 1));
|
||||
new_led.value = (unsigned int)zone_idx;
|
||||
|
||||
leds.push_back(new_led);
|
||||
}
|
||||
}
|
||||
|
||||
SetupColors();
|
||||
}
|
||||
|
||||
void RGBController_LianLiUniHubSL::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_LianLiUniHubSL::DeviceUpdateLEDs()
|
||||
{
|
||||
DeviceUpdateMode();
|
||||
}
|
||||
|
||||
void RGBController_LianLiUniHubSL::UpdateZoneLEDs(int zone)
|
||||
{
|
||||
if(!initialized)
|
||||
{
|
||||
return DeviceUpdateMode();
|
||||
}
|
||||
controller->UpdateZoneLEDs(zone, zones[zone], modes[active_mode]);
|
||||
}
|
||||
|
||||
void RGBController_LianLiUniHubSL::UpdateSingleLED(int /* led */)
|
||||
{
|
||||
DeviceUpdateMode();
|
||||
}
|
||||
|
||||
void RGBController_LianLiUniHubSL::DeviceUpdateMode()
|
||||
{
|
||||
if(active_mode == 0)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
controller->UpdateMode(zones, modes[active_mode]);
|
||||
initialized = true;
|
||||
}
|
||||
|
||||
void RGBController_LianLiUniHubSL::SetCustomMode()
|
||||
{
|
||||
active_mode = 0;
|
||||
}
|
||||
@@ -0,0 +1,39 @@
|
||||
/*---------------------------------------------------------*\
|
||||
| RGBController_LianLiUniHubSL.h |
|
||||
| |
|
||||
| RGBController for Lian Li Uni Hub - SL |
|
||||
| |
|
||||
| Muhamad Visat 26 Jul 2025 |
|
||||
| Original work by Luca Lovisa & Oliver P |
|
||||
| |
|
||||
| This file is part of the OpenRGB project |
|
||||
| SPDX-License-Identifier: GPL-2.0-only |
|
||||
\*---------------------------------------------------------*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include "RGBController.h"
|
||||
#include "LianLiUniHubSLController.h"
|
||||
|
||||
class RGBController_LianLiUniHubSL : public RGBController
|
||||
{
|
||||
public:
|
||||
RGBController_LianLiUniHubSL(LianLiUniHubSLController *controller, std::string name);
|
||||
~RGBController_LianLiUniHubSL();
|
||||
|
||||
void SetupZones();
|
||||
|
||||
void ResizeZone(int zone, int new_size);
|
||||
|
||||
void DeviceUpdateLEDs();
|
||||
void UpdateZoneLEDs(int zone);
|
||||
void UpdateSingleLED(int led);
|
||||
|
||||
void DeviceUpdateMode();
|
||||
|
||||
void SetCustomMode();
|
||||
|
||||
private:
|
||||
LianLiUniHubSLController *controller;
|
||||
bool initialized;
|
||||
};
|
||||
+319
@@ -0,0 +1,319 @@
|
||||
/*---------------------------------------------------------*\
|
||||
| LianLiUniHubSLInfinityController.cpp |
|
||||
| |
|
||||
| Driver for Lian Li SL Infinity Uni Hub |
|
||||
| |
|
||||
| Simon McKenna 21 Oct 2023 |
|
||||
| Will Kennedy 17 Jan 2023 |
|
||||
| Oliver P 26 Apr 2022 |
|
||||
| Credit to Luca Lovisa for original work. |
|
||||
| |
|
||||
| This file is part of the OpenRGB project |
|
||||
| SPDX-License-Identifier: GPL-2.0-or-later |
|
||||
\*---------------------------------------------------------*/
|
||||
|
||||
#include <string.h>
|
||||
#include "LianLiUniHubSLInfinityController.h"
|
||||
#include "StringUtils.h"
|
||||
|
||||
using namespace std::chrono_literals;
|
||||
|
||||
LianLiUniHubSLInfinityController::LianLiUniHubSLInfinityController(hid_device* dev_handle, const char* path, std::string dev_name)
|
||||
{
|
||||
dev = dev_handle;
|
||||
location = path;
|
||||
name = dev_name;
|
||||
}
|
||||
|
||||
LianLiUniHubSLInfinityController::~LianLiUniHubSLInfinityController()
|
||||
{
|
||||
hid_close(dev);
|
||||
}
|
||||
|
||||
std::string LianLiUniHubSLInfinityController::GetDeviceLocation()
|
||||
{
|
||||
return("HID: " + location);
|
||||
}
|
||||
|
||||
std::string LianLiUniHubSLInfinityController::GetFirmwareVersionString()
|
||||
{
|
||||
wchar_t product_string[40];
|
||||
int ret = hid_get_product_string(dev, product_string, 40);
|
||||
|
||||
if (ret != 0)
|
||||
{
|
||||
return ("");
|
||||
}
|
||||
|
||||
std::string return_string = StringUtils::wstring_to_string(product_string);
|
||||
|
||||
return(return_string.substr(return_string.find_last_of("-")+1,4).c_str());
|
||||
}
|
||||
|
||||
std::string LianLiUniHubSLInfinityController::GetName()
|
||||
{
|
||||
return(name);
|
||||
}
|
||||
|
||||
std::string LianLiUniHubSLInfinityController::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));
|
||||
}
|
||||
|
||||
float infinityBrightnessLimit(RGBColor color)
|
||||
{
|
||||
/*---------------------------------------------------------*\
|
||||
| Limiter to protect LEDs |
|
||||
\*---------------------------------------------------------*/
|
||||
if(UNIHUB_SLINF_LED_LIMITER && (RGBGetRValue(color) + RGBGetBValue(color) + RGBGetGValue(color) > 460))
|
||||
{
|
||||
return 460.f / (RGBGetRValue(color) + RGBGetBValue(color) + RGBGetGValue(color));
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
void LianLiUniHubSLInfinityController::SetChannelLEDs(unsigned char channel, RGBColor * colors, unsigned int num_colors, float brightness)
|
||||
{
|
||||
unsigned char led_data[16 * 6 * 3];
|
||||
int fan_idx = 0;
|
||||
int mod_led_idx;
|
||||
int cur_led_idx;
|
||||
|
||||
if(num_colors == 0)
|
||||
{
|
||||
return; // Do nothing, channel isn't in use
|
||||
}
|
||||
|
||||
for(unsigned int led_idx = 0; led_idx < num_colors; led_idx++)
|
||||
{
|
||||
mod_led_idx = (led_idx % 16);
|
||||
|
||||
if((mod_led_idx == 0) && (led_idx != 0))
|
||||
{
|
||||
fan_idx++;
|
||||
}
|
||||
|
||||
float brightness_scale = brightness * infinityBrightnessLimit(colors[led_idx]);
|
||||
|
||||
//Determine current position of led_data array from colors array
|
||||
cur_led_idx = ((mod_led_idx + (fan_idx * 16)) * 3);
|
||||
|
||||
led_data[cur_led_idx + 0] = (unsigned char)(RGBGetRValue(colors[led_idx]) * brightness_scale);
|
||||
led_data[cur_led_idx + 1] = (unsigned char)(RGBGetBValue(colors[led_idx]) * brightness_scale);
|
||||
led_data[cur_led_idx + 2] = (unsigned char)(RGBGetGValue(colors[led_idx]) * brightness_scale);
|
||||
}
|
||||
|
||||
/*---------------------------------------------------------*\
|
||||
| Send fan LED data |
|
||||
\*---------------------------------------------------------*/
|
||||
|
||||
SendStartAction
|
||||
(
|
||||
channel, // Current channel
|
||||
(fan_idx + 1) // Number of fans
|
||||
);
|
||||
|
||||
SendColorData
|
||||
(
|
||||
channel, // Channel
|
||||
(fan_idx + 1)*16,
|
||||
led_data
|
||||
);
|
||||
|
||||
SendCommitAction
|
||||
(
|
||||
channel, // Channel
|
||||
UNIHUB_SLINF_LED_MODE_STATIC_COLOR, // Effect
|
||||
UNIHUB_SLINF_LED_SPEED_000, // Speed
|
||||
UNIHUB_SLINF_LED_DIRECTION_LTR, // Direction
|
||||
UNIHUB_SLINF_LED_BRIGHTNESS_100 // Brightness
|
||||
);
|
||||
|
||||
}
|
||||
|
||||
void LianLiUniHubSLInfinityController::SetChannelMode(unsigned char channel, const mode active_mode, unsigned int num_fans)
|
||||
{
|
||||
static unsigned int brightness_code[5] =
|
||||
{
|
||||
UNIHUB_SLINF_LED_BRIGHTNESS_000,
|
||||
UNIHUB_SLINF_LED_BRIGHTNESS_025,
|
||||
UNIHUB_SLINF_LED_BRIGHTNESS_050,
|
||||
UNIHUB_SLINF_LED_BRIGHTNESS_075,
|
||||
UNIHUB_SLINF_LED_BRIGHTNESS_100
|
||||
};
|
||||
|
||||
static unsigned int speed_code[5] =
|
||||
{
|
||||
UNIHUB_SLINF_LED_SPEED_000,
|
||||
UNIHUB_SLINF_LED_SPEED_025,
|
||||
UNIHUB_SLINF_LED_SPEED_050,
|
||||
UNIHUB_SLINF_LED_SPEED_075,
|
||||
UNIHUB_SLINF_LED_SPEED_100
|
||||
};
|
||||
|
||||
unsigned char fan_led_data[16 * 6 * 3];
|
||||
int cur_led_idx;
|
||||
float brightness;
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Zero out buffer |
|
||||
\*-----------------------------------------------------*/
|
||||
memset(fan_led_data, 0x00, sizeof(fan_led_data));
|
||||
|
||||
std::vector<RGBColor> colors = active_mode.colors;
|
||||
unsigned int num_colors = (unsigned int)colors.size();
|
||||
|
||||
if(!colors.empty()) // Update led_data if there's colors
|
||||
{
|
||||
brightness = static_cast<float>(active_mode.brightness)/4;
|
||||
if(num_colors == 6)
|
||||
{
|
||||
for(unsigned int i = 0; i < 6; i++)
|
||||
{
|
||||
float brightness_scale = brightness * infinityBrightnessLimit(colors[i]);
|
||||
for(unsigned int led_idx = 0; led_idx < 16 * 3; led_idx += 3)
|
||||
{
|
||||
cur_led_idx = (i * 16 * 3) + led_idx;
|
||||
fan_led_data[cur_led_idx + 0] = (unsigned char)(RGBGetRValue(colors[i]) * brightness_scale);
|
||||
fan_led_data[cur_led_idx + 1] = (unsigned char)(RGBGetBValue(colors[i]) * brightness_scale);
|
||||
fan_led_data[cur_led_idx + 2] = (unsigned char)(RGBGetGValue(colors[i]) * brightness_scale);
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
colors.resize(4);
|
||||
for(unsigned int i = num_colors; i < 4; i++)
|
||||
{
|
||||
colors[i] = 0x00;
|
||||
}
|
||||
|
||||
// needs a 72 length array of 4 colors, even if less are defined
|
||||
for(unsigned int j = 0; j < 4; j++)
|
||||
{
|
||||
float brightness_scale = brightness * infinityBrightnessLimit(colors[j]);
|
||||
for(unsigned int i = 0; i < 6; i++)
|
||||
{
|
||||
cur_led_idx = (i * 12) + (j * 3);
|
||||
fan_led_data[cur_led_idx + 0] = (unsigned char)(RGBGetRValue(colors[j]) * brightness_scale);
|
||||
fan_led_data[cur_led_idx + 1] = (unsigned char)(RGBGetBValue(colors[j]) * brightness_scale);
|
||||
fan_led_data[cur_led_idx + 2] = (unsigned char)(RGBGetGValue(colors[j]) * brightness_scale);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
SendStartAction
|
||||
(
|
||||
channel, // Current channel
|
||||
(num_fans + 1) // Number of fans
|
||||
);
|
||||
|
||||
SendColorData
|
||||
(
|
||||
channel, // Channel
|
||||
(num_fans + 1)*16,
|
||||
fan_led_data // Data
|
||||
);
|
||||
|
||||
SendCommitAction
|
||||
(
|
||||
channel, // Channel
|
||||
active_mode.value, // Effect
|
||||
speed_code[active_mode.speed], // Speed
|
||||
active_mode.direction, // Direction
|
||||
brightness_code[active_mode.brightness] // Brightness
|
||||
);
|
||||
}
|
||||
|
||||
void LianLiUniHubSLInfinityController::SendStartAction(unsigned char channel, unsigned int /*num_fans*/)
|
||||
{
|
||||
unsigned char usb_buf[65];
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Zero out buffer |
|
||||
\*-----------------------------------------------------*/
|
||||
memset(usb_buf, 0x00, sizeof(usb_buf));
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Set up message packet |
|
||||
\*-----------------------------------------------------*/
|
||||
usb_buf[0x00] = UNIHUB_SLINF_TRANSACTION_ID;
|
||||
usb_buf[0x01] = 0x10;
|
||||
usb_buf[0x02] = 0x60;
|
||||
usb_buf[0x03] = 1 + (channel / 2); // every fan-array uses two channels (one for the spinner and one for the led-band on the side)
|
||||
usb_buf[0x04] = 0x04; // TODO: number of fans (1-4) on this channel, hardcoding this to 4 for now
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Send packet |
|
||||
\*-----------------------------------------------------*/
|
||||
hid_write(dev, usb_buf, sizeof(usb_buf));
|
||||
std::this_thread::sleep_for(5ms);
|
||||
|
||||
}
|
||||
|
||||
void LianLiUniHubSLInfinityController::SendColorData(unsigned char channel, unsigned int num_leds, unsigned char* led_data)
|
||||
{
|
||||
/*---------------------------------------------------------*\
|
||||
| Send LED data |
|
||||
\*---------------------------------------------------------*/
|
||||
|
||||
unsigned char usb_buf[353];
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Zero out buffer |
|
||||
\*-----------------------------------------------------*/
|
||||
memset(usb_buf, 0x00, sizeof(usb_buf));
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Set up message packet |
|
||||
\*-----------------------------------------------------*/
|
||||
usb_buf[0x00] = UNIHUB_SLINF_TRANSACTION_ID;
|
||||
usb_buf[0x01] = 0x30 + channel; // action + channel(30 = channel 1, 31 = channel 2, etc.)
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Copy in color data bytes |
|
||||
\*-----------------------------------------------------*/
|
||||
memcpy(&usb_buf[0x02], led_data, num_leds * 3);
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Send packet |
|
||||
\*-----------------------------------------------------*/
|
||||
hid_write(dev, usb_buf, sizeof(usb_buf));
|
||||
std::this_thread::sleep_for(5ms);
|
||||
}
|
||||
|
||||
void LianLiUniHubSLInfinityController::SendCommitAction(unsigned char channel, unsigned char effect, unsigned char speed, unsigned int direction, unsigned int brightness)
|
||||
{
|
||||
unsigned char usb_buf[65];
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Zero out buffer |
|
||||
\*-----------------------------------------------------*/
|
||||
memset(usb_buf, 0x00, sizeof(usb_buf));
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Set up message packet |
|
||||
\*-----------------------------------------------------*/
|
||||
usb_buf[0x00] = UNIHUB_SLINF_TRANSACTION_ID;
|
||||
usb_buf[0x01] = 0x10 + channel; // Channel+device (10 = channel 1, 11 = channel 2, etc.)
|
||||
usb_buf[0x02] = effect; // Effect
|
||||
usb_buf[0x03] = speed; // Speed, 02=0%, 01=25%, 00=50%, ff=75%, fe=100%
|
||||
usb_buf[0x04] = direction; // Direction, right=00, left=01
|
||||
usb_buf[0x05] = brightness; // Brightness, 0=100%, 1= 75%, 2 = 50%, 3 = 25%, 8 = 0%
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Send packet |
|
||||
\*-----------------------------------------------------*/
|
||||
hid_write(dev, usb_buf, sizeof(usb_buf));
|
||||
std::this_thread::sleep_for(5ms);
|
||||
}
|
||||
+211
@@ -0,0 +1,211 @@
|
||||
/*---------------------------------------------------------*\
|
||||
| LianLiUniHubSLInfinityController.h |
|
||||
| |
|
||||
| Driver for Lian Li SL Infinity Uni Hub |
|
||||
| |
|
||||
| Simon McKenna 21 Oct 2023 |
|
||||
| Will Kennedy 17 Jan 2023 |
|
||||
| Oliver P 26 Apr 2022 |
|
||||
| Credit to Luca Lovisa for original work. |
|
||||
| |
|
||||
| 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"
|
||||
|
||||
/*----------------------------------------------------------------------------*\
|
||||
| Global definitions. |
|
||||
\*----------------------------------------------------------------------------*/
|
||||
|
||||
/*----------------------------------------------------------------------------*\
|
||||
| Definitions related to zone Sizes |
|
||||
\*----------------------------------------------------------------------------*/
|
||||
|
||||
enum
|
||||
{
|
||||
UNIHUB_SLINF_CHANNEL_COUNT = 0x08, /* Channel count */
|
||||
UNIHUB_SLINF_CHAN_LED_COUNT = 0x10 * 6, /* Max-LED per channel count - 96 */
|
||||
};
|
||||
|
||||
/*----------------------------------------------------------------------------*\
|
||||
| Definitions related to LED configuration. |
|
||||
\*----------------------------------------------------------------------------*/
|
||||
|
||||
// Used for sync'd mode between Fan and Edge
|
||||
|
||||
enum
|
||||
{
|
||||
UNIHUB_SLINF_LED_MODE_STATIC_COLOR = 0x01, // full data array
|
||||
UNIHUB_SLINF_LED_MODE_BREATHING = 0x02, // full data array
|
||||
UNIHUB_SLINF_LED_MODE_RAINBOW_MORPH = 0x04, // no array
|
||||
UNIHUB_SLINF_LED_MODE_RAINBOW = 0x05, // no array
|
||||
UNIHUB_SLINF_LED_MODE_STAGGERED = 0x18, // size 2
|
||||
UNIHUB_SLINF_LED_MODE_TIDE = 0x1A, // size 2
|
||||
UNIHUB_SLINF_LED_MODE_RUNWAY = 0x1C, // size 2
|
||||
UNIHUB_SLINF_LED_MODE_MIXING = 0x1E, // size 2
|
||||
UNIHUB_SLINF_LED_MODE_STACK = 0x20, // size 1
|
||||
UNIHUB_SLINF_LED_MODE_STACK_MULTI_COLOR = 0x21, // no array
|
||||
UNIHUB_SLINF_LED_MODE_NEON = 0x22, // no array
|
||||
UNIHUB_SLINF_LED_MODE_COLOR_CYCLE = 0x23, // size 3
|
||||
UNIHUB_SLINF_LED_MODE_METEOR = 0x24, // size 2
|
||||
UNIHUB_SLINF_LED_MODE_VOICE = 0x26, // no array
|
||||
UNIHUB_SLINF_LED_MODE_GROOVE = 0x27, // size 2
|
||||
UNIHUB_SLINF_LED_MODE_RENDER = 0x28, // size 4
|
||||
UNIHUB_SLINF_LED_MODE_TUNNEL = 0x29, // size 4
|
||||
// merged modes
|
||||
UNIHUB_SLINF_LED_MODE_METEOR_MERGED = 0x2A,
|
||||
UNIHUB_SLINF_LED_MODE_RUNWAY_MERGED = 0x2B,
|
||||
UNIHUB_SLINF_LED_MODE_TIDE_MERGED = 0x2C,
|
||||
UNIHUB_SLINF_LED_MODE_MIXING_MERGED = 0x2D,
|
||||
UNIHUB_SLINF_LED_MODE_STACK_MULTI_COLOR_MERGED = 0x2E
|
||||
};
|
||||
|
||||
enum
|
||||
{
|
||||
UNIHUB_SLINF_LED_SPEED_000 = 0x02, /* Very slow speed */
|
||||
UNIHUB_SLINF_LED_SPEED_025 = 0x01, /* Rather slow speed */
|
||||
UNIHUB_SLINF_LED_SPEED_050 = 0x00, /* Medium speed */
|
||||
UNIHUB_SLINF_LED_SPEED_075 = 0xFF, /* Rather fast speed */
|
||||
UNIHUB_SLINF_LED_SPEED_100 = 0xFE, /* Very fast speed */
|
||||
};
|
||||
|
||||
enum
|
||||
{
|
||||
UNIHUB_SLINF_LED_DIRECTION_LTR = 0x00, /* Left-to-Right direction */
|
||||
UNIHUB_SLINF_LED_DIRECTION_RTL = 0x01, /* Right-to-Left direction */
|
||||
};
|
||||
|
||||
enum
|
||||
{
|
||||
UNIHUB_SLINF_LED_BRIGHTNESS_000 = 0x08, /* Very dark (off) */
|
||||
UNIHUB_SLINF_LED_BRIGHTNESS_025 = 0x03, /* Rather dark */
|
||||
UNIHUB_SLINF_LED_BRIGHTNESS_050 = 0x02, /* Medium bright */
|
||||
UNIHUB_SLINF_LED_BRIGHTNESS_075 = 0x01, /* Rather bright */
|
||||
UNIHUB_SLINF_LED_BRIGHTNESS_100 = 0x00, /* Very bright */
|
||||
};
|
||||
|
||||
enum
|
||||
{
|
||||
UNIHUB_SLINF_LED_LIMITER = 0x01 /* Limit the color white to 999999 as per manufacturer limits */
|
||||
};
|
||||
|
||||
|
||||
/*----------------------------------------------------------------------------*\
|
||||
| Definitions related to packet configuration. |
|
||||
\*----------------------------------------------------------------------------*/
|
||||
|
||||
enum
|
||||
{
|
||||
UNIHUB_SLINF_TRANSACTION_ID = 0xE0, /* Command value to start all packets */
|
||||
};
|
||||
|
||||
/*----------------------------------------------------------------------------*\
|
||||
| Uni Hub SL Infinity controller. |
|
||||
\*----------------------------------------------------------------------------*/
|
||||
|
||||
class LianLiUniHubSLInfinityController
|
||||
{
|
||||
|
||||
|
||||
public:
|
||||
LianLiUniHubSLInfinityController(hid_device* dev_handle, const char* path, std::string dev_name);
|
||||
~LianLiUniHubSLInfinityController();
|
||||
|
||||
std::string GetDeviceLocation();
|
||||
std::string GetFirmwareVersionString();
|
||||
std::string GetName();
|
||||
std::string GetSerialString();
|
||||
|
||||
void SetChannelMode
|
||||
(
|
||||
unsigned char channel,
|
||||
const mode active_mode,
|
||||
unsigned int num_fans
|
||||
);
|
||||
|
||||
void SetChannelLEDs
|
||||
(
|
||||
unsigned char channel,
|
||||
RGBColor * colors,
|
||||
unsigned int num_colors,
|
||||
float brightness
|
||||
);
|
||||
|
||||
void SendStartAction
|
||||
(
|
||||
unsigned char channel,
|
||||
unsigned int num_fans
|
||||
);
|
||||
|
||||
void SendColorData
|
||||
(
|
||||
unsigned char channel, // Zone index
|
||||
unsigned int num_leds,
|
||||
unsigned char* led_data // Color data payload
|
||||
);
|
||||
|
||||
void SendCommitAction
|
||||
(
|
||||
unsigned char channel, // Zone index
|
||||
unsigned char effect,
|
||||
unsigned char speed,
|
||||
unsigned int direction,
|
||||
unsigned int brightness
|
||||
);
|
||||
|
||||
private:
|
||||
/* The Uni Hub requires colors in RBG order */
|
||||
struct Color
|
||||
{
|
||||
uint8_t r;
|
||||
uint8_t b;
|
||||
uint8_t g;
|
||||
};
|
||||
|
||||
/* The values correspond to the definitions above */
|
||||
struct Channel
|
||||
{
|
||||
uint8_t index;
|
||||
|
||||
uint8_t anyFanCountOffset;
|
||||
uint8_t anyFanCount;
|
||||
|
||||
uint16_t ledActionAddress;
|
||||
uint16_t ledCommitAddress;
|
||||
uint16_t ledModeAddress;
|
||||
uint16_t ledSpeedAddress;
|
||||
uint16_t ledDirectionAddress;
|
||||
uint16_t ledBrightnessAddress;
|
||||
|
||||
Color colors[UNIHUB_SLINF_CHAN_LED_COUNT];
|
||||
|
||||
uint8_t ledMode;
|
||||
uint8_t ledSpeed;
|
||||
uint8_t ledDirection;
|
||||
uint8_t ledBrightness;
|
||||
|
||||
uint16_t fanHubActionAddress;
|
||||
uint16_t fanHubCommitAddress;
|
||||
|
||||
uint16_t fanPwmActionAddress;
|
||||
uint16_t fanPwmCommitAddress;
|
||||
uint16_t fanRpmActionAddress;
|
||||
|
||||
uint16_t fanSpeed;
|
||||
};
|
||||
|
||||
private:
|
||||
hid_device* dev;
|
||||
|
||||
/*---------------------------------------------------------*\
|
||||
| Device information strings |
|
||||
\*---------------------------------------------------------*/
|
||||
std::string firmware_version;
|
||||
std::string location;
|
||||
std::string name;
|
||||
};
|
||||
+445
@@ -0,0 +1,445 @@
|
||||
/*---------------------------------------------------------*\
|
||||
| RGBController_LianLiUniHubSLInfinity.cpp |
|
||||
| |
|
||||
| RGBController for Lian Li SL Infinity Uni Hub |
|
||||
| |
|
||||
| Simon McKenna 21 Oct 2023 |
|
||||
| Will Kennedy 17 Jan 2023 |
|
||||
| Oliver P 26 Apr 2022 |
|
||||
| Credit to Luca Lovisa for original work. |
|
||||
| |
|
||||
| This file is part of the OpenRGB project |
|
||||
| SPDX-License-Identifier: GPL-2.0-or-later |
|
||||
\*---------------------------------------------------------*/
|
||||
|
||||
#include <string>
|
||||
#include "RGBController_LianLiUniHubSLInfinity.h"
|
||||
|
||||
/**------------------------------------------------------------------*\
|
||||
@name Lian Li Uni Hub SL Infinity
|
||||
@type USB
|
||||
@save :x:
|
||||
@direct :rotating_light:
|
||||
@effects :white_check_mark:
|
||||
@detectors DetectLianLiUniHubSLInfinity
|
||||
@comment
|
||||
\*-------------------------------------------------------------------*/
|
||||
|
||||
RGBController_LianLiUniHubSLInfinity::RGBController_LianLiUniHubSLInfinity(LianLiUniHubSLInfinityController* controller_ptr)
|
||||
{
|
||||
controller = controller_ptr;
|
||||
|
||||
name = controller->GetName();
|
||||
vendor = "Lian Li";
|
||||
type = DEVICE_TYPE_COOLER;
|
||||
description = "Lian Li Uni Hub - SL Infinity";
|
||||
version = controller->GetFirmwareVersionString();
|
||||
location = controller->GetDeviceLocation();
|
||||
serial = controller->GetSerialString();
|
||||
|
||||
initializedMode = false;
|
||||
|
||||
mode Custom;
|
||||
Custom.name = "Custom";
|
||||
Custom.value = UNIHUB_SLINF_LED_MODE_STATIC_COLOR;
|
||||
Custom.flags = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_PER_LED_COLOR;
|
||||
Custom.brightness_min = 0;
|
||||
Custom.brightness_max = 50;
|
||||
Custom.brightness = 37;
|
||||
Custom.color_mode = MODE_COLORS_PER_LED;
|
||||
modes.push_back(Custom);
|
||||
|
||||
mode StaticColor;
|
||||
StaticColor.name = "Static";
|
||||
StaticColor.value = UNIHUB_SLINF_LED_MODE_STATIC_COLOR;
|
||||
StaticColor.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
|
||||
StaticColor.brightness_min = 0;
|
||||
StaticColor.brightness_max = 4;
|
||||
StaticColor.colors_min = 0;
|
||||
StaticColor.colors_max = 6;
|
||||
StaticColor.brightness = 4;
|
||||
StaticColor.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
StaticColor.colors.resize(6);
|
||||
modes.push_back(StaticColor);
|
||||
|
||||
mode Breathing;
|
||||
Breathing.name = "Breathing";
|
||||
Breathing.value = UNIHUB_SLINF_LED_MODE_BREATHING;
|
||||
Breathing.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
|
||||
Breathing.speed_min = 0;
|
||||
Breathing.speed_max = 4;
|
||||
Breathing.brightness_min = 0;
|
||||
Breathing.brightness_max = 4;
|
||||
Breathing.colors_min = 0;
|
||||
Breathing.colors_max = 6;
|
||||
Breathing.speed = 2;
|
||||
Breathing.brightness = 4;
|
||||
Breathing.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Breathing.colors.resize(6);
|
||||
modes.push_back(Breathing);
|
||||
|
||||
mode RainbowMorph;
|
||||
RainbowMorph.name = "Spectrum Cycle";
|
||||
RainbowMorph.value = UNIHUB_SLINF_LED_MODE_RAINBOW_MORPH;
|
||||
RainbowMorph.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
|
||||
RainbowMorph.speed_min = 0;
|
||||
RainbowMorph.speed_max = 4;
|
||||
RainbowMorph.brightness_min = 0;
|
||||
RainbowMorph.brightness_max = 4;
|
||||
RainbowMorph.speed = 2;
|
||||
RainbowMorph.brightness = 4;
|
||||
RainbowMorph.color_mode = MODE_COLORS_NONE;
|
||||
modes.push_back(RainbowMorph);
|
||||
|
||||
mode RainbowWave;
|
||||
RainbowWave.name = "Rainbow Wave";
|
||||
RainbowWave.value = UNIHUB_SLINF_LED_MODE_RAINBOW;
|
||||
RainbowWave.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_DIRECTION_LR;
|
||||
RainbowWave.speed_min = 0;
|
||||
RainbowWave.speed_max = 4;
|
||||
RainbowWave.brightness_min = 0;
|
||||
RainbowWave.brightness_max = 4;
|
||||
RainbowWave.speed = 2;
|
||||
RainbowWave.brightness = 4;
|
||||
RainbowWave.direction = UNIHUB_SLINF_LED_DIRECTION_LTR;
|
||||
RainbowWave.color_mode = MODE_COLORS_NONE;
|
||||
modes.push_back(RainbowWave);
|
||||
|
||||
mode Staggered;
|
||||
Staggered.name = "Staggered";
|
||||
Staggered.value = UNIHUB_SLINF_LED_MODE_STAGGERED;
|
||||
Staggered.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
|
||||
Staggered.speed_min = 0;
|
||||
Staggered.speed_max = 4;
|
||||
Staggered.brightness_min = 0;
|
||||
Staggered.brightness_max = 4;
|
||||
Staggered.colors_min = 0;
|
||||
Staggered.colors_max = 2;
|
||||
Staggered.speed = 2;
|
||||
Staggered.brightness = 4;
|
||||
Staggered.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Staggered.colors.resize(2);
|
||||
modes.push_back(Staggered);
|
||||
|
||||
mode Tide; // TODO: Has merge
|
||||
Tide.name = "Tide";
|
||||
Tide.value = UNIHUB_SLINF_LED_MODE_TIDE;
|
||||
Tide.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
|
||||
Tide.speed_min = 0;
|
||||
Tide.speed_max = 4;
|
||||
Tide.brightness_min = 0;
|
||||
Tide.brightness_max = 4;
|
||||
Tide.colors_min = 0;
|
||||
Tide.colors_max = 2;
|
||||
Tide.speed = 2;
|
||||
Tide.brightness = 4;
|
||||
Tide.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Tide.colors.resize(2);
|
||||
modes.push_back(Tide);
|
||||
|
||||
mode Runway; //TODO: Has merge
|
||||
Runway.name = "Runway";
|
||||
Runway.value = UNIHUB_SLINF_LED_MODE_RUNWAY;
|
||||
Runway.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
|
||||
Runway.speed_min = 0;
|
||||
Runway.speed_max = 4;
|
||||
Runway.brightness_min = 0;
|
||||
Runway.brightness_max = 4;
|
||||
Runway.colors_min = 0;
|
||||
Runway.colors_max = 2;
|
||||
Runway.speed = 2;
|
||||
Runway.brightness = 4;
|
||||
Runway.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Runway.colors.resize(2);
|
||||
modes.push_back(Runway);
|
||||
|
||||
mode Mixing; //TODO: Has merge
|
||||
Mixing.name = "Mixing";
|
||||
Mixing.value = UNIHUB_SLINF_LED_MODE_MIXING;
|
||||
Mixing.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
|
||||
Mixing.speed_min = 0;
|
||||
Mixing.speed_max = 4;
|
||||
Mixing.brightness_min = 0;
|
||||
Mixing.brightness_max = 4;
|
||||
Mixing.colors_min = 0;
|
||||
Mixing.colors_max = 2;
|
||||
Mixing.speed = 2;
|
||||
Mixing.brightness = 4;
|
||||
Mixing.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Mixing.colors.resize(2);
|
||||
modes.push_back(Mixing);
|
||||
|
||||
mode Stack;
|
||||
Stack.name = "Stack";
|
||||
Stack.value = UNIHUB_SLINF_LED_MODE_STACK;
|
||||
Stack.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_DIRECTION_LR;
|
||||
Stack.speed_min = 0;
|
||||
Stack.speed_max = 4;
|
||||
Stack.brightness_min = 0;
|
||||
Stack.brightness_max = 4;
|
||||
Stack.colors_min = 0;
|
||||
Stack.colors_max = 1;
|
||||
Stack.speed = 2;
|
||||
Stack.brightness = 4;
|
||||
Stack.direction = UNIHUB_SLINF_LED_DIRECTION_LTR;
|
||||
Stack.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Stack.colors.resize(1);
|
||||
modes.push_back(Stack);
|
||||
|
||||
mode StackMultiColor; //TODO: Has merge
|
||||
Stack.name = "Stack Multi Color";
|
||||
Stack.value = UNIHUB_SLINF_LED_MODE_STACK_MULTI_COLOR;
|
||||
Stack.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_DIRECTION_LR;
|
||||
Stack.speed_min = 0;
|
||||
Stack.speed_max = 4;
|
||||
Stack.brightness_min = 0;
|
||||
Stack.brightness_max = 4;
|
||||
Stack.speed = 2;
|
||||
Stack.brightness = 4;
|
||||
Stack.direction = UNIHUB_SLINF_LED_DIRECTION_LTR;
|
||||
Stack.color_mode = MODE_COLORS_NONE;
|
||||
modes.push_back(Stack);
|
||||
|
||||
mode Neon;
|
||||
Neon.name = "Neon";
|
||||
Neon.value = UNIHUB_SLINF_LED_MODE_NEON;
|
||||
Neon.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
|
||||
Neon.speed_min = 0;
|
||||
Neon.speed_max = 4;
|
||||
Neon.brightness_min = 0;
|
||||
Neon.brightness_max = 4;
|
||||
Neon.speed = 2;
|
||||
Neon.brightness = 4;
|
||||
Neon.color_mode = MODE_COLORS_NONE;
|
||||
modes.push_back(Neon);
|
||||
|
||||
mode ColorCycle;
|
||||
ColorCycle.name = "ColorCycle";
|
||||
ColorCycle.value = UNIHUB_SLINF_LED_MODE_COLOR_CYCLE;
|
||||
ColorCycle.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_DIRECTION_LR;
|
||||
ColorCycle.speed_min = 0;
|
||||
ColorCycle.speed_max = 4;
|
||||
ColorCycle.brightness_min = 0;
|
||||
ColorCycle.brightness_max = 4;
|
||||
ColorCycle.colors_min = 0;
|
||||
ColorCycle.colors_max = 3;
|
||||
ColorCycle.speed = 2;
|
||||
ColorCycle.brightness = 4;
|
||||
ColorCycle.direction = UNIHUB_SLINF_LED_DIRECTION_LTR;
|
||||
ColorCycle.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
ColorCycle.colors.resize(3);
|
||||
modes.push_back(ColorCycle);
|
||||
|
||||
mode Meteor; //TODO: Has merge
|
||||
Meteor.name = "Meteor";
|
||||
Meteor.value = UNIHUB_SLINF_LED_MODE_METEOR;
|
||||
Meteor.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
|
||||
Meteor.speed_min = 0;
|
||||
Meteor.speed_max = 4;
|
||||
Meteor.brightness_min = 0;
|
||||
Meteor.brightness_max = 4;
|
||||
Meteor.colors_min = 0;
|
||||
Meteor.colors_max = 2;
|
||||
Meteor.speed = 2;
|
||||
Meteor.brightness = 4;
|
||||
Meteor.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Meteor.colors.resize(2);
|
||||
modes.push_back(Meteor);
|
||||
|
||||
mode Voice;
|
||||
Voice.name = "Voice";
|
||||
Voice.value = UNIHUB_SLINF_LED_MODE_VOICE;
|
||||
Voice.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
|
||||
Voice.speed_min = 0;
|
||||
Voice.speed_max = 4;
|
||||
Voice.brightness_min = 0;
|
||||
Voice.brightness_max = 4;
|
||||
Voice.speed = 2;
|
||||
Voice.brightness = 4;
|
||||
modes.push_back(Voice);
|
||||
|
||||
mode Groove;
|
||||
Groove.name = "Groove";
|
||||
Groove.value = UNIHUB_SLINF_LED_MODE_GROOVE;
|
||||
Groove.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_DIRECTION_LR;
|
||||
Groove.speed_min = 0;
|
||||
Groove.speed_max = 4;
|
||||
Groove.brightness_min = 0;
|
||||
Groove.brightness_max = 4;
|
||||
Groove.colors_min = 0;
|
||||
Groove.colors_max = 1;
|
||||
Groove.speed = 2;
|
||||
Groove.brightness = 4;
|
||||
Groove.direction = UNIHUB_SLINF_LED_DIRECTION_LTR;
|
||||
Groove.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Groove.colors.resize(1);
|
||||
modes.push_back(Groove);
|
||||
|
||||
mode Render;
|
||||
Render.name = "Render";
|
||||
Render.value = UNIHUB_SLINF_LED_MODE_RENDER;
|
||||
Render.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_DIRECTION_LR;
|
||||
Render.speed_min = 0;
|
||||
Render.speed_max = 4;
|
||||
Render.brightness_min = 0;
|
||||
Render.brightness_max = 4;
|
||||
Render.colors_min = 0;
|
||||
Render.colors_max = 4;
|
||||
Render.speed = 2;
|
||||
Render.brightness = 4;
|
||||
Render.direction = UNIHUB_SLINF_LED_DIRECTION_LTR;
|
||||
Render.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Render.colors.resize(4);
|
||||
modes.push_back(Render);
|
||||
|
||||
mode Tunnel;
|
||||
Tunnel.name = "Tunnel";
|
||||
Tunnel.value = UNIHUB_SLINF_LED_MODE_TUNNEL;
|
||||
Tunnel.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_DIRECTION_LR;
|
||||
Tunnel.speed_min = 0;
|
||||
Tunnel.speed_max = 4;
|
||||
Tunnel.brightness_min = 0;
|
||||
Tunnel.brightness_max = 4;
|
||||
Tunnel.colors_min = 0;
|
||||
Tunnel.colors_max = 4;
|
||||
Tunnel.speed = 2;
|
||||
Tunnel.brightness = 4;
|
||||
Tunnel.direction = UNIHUB_SLINF_LED_DIRECTION_LTR;
|
||||
Tunnel.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Tunnel.colors.resize(4);
|
||||
modes.push_back(Tunnel);
|
||||
|
||||
RGBController_LianLiUniHubSLInfinity::SetupZones();
|
||||
}
|
||||
|
||||
RGBController_LianLiUniHubSLInfinity::~RGBController_LianLiUniHubSLInfinity()
|
||||
{
|
||||
delete controller;
|
||||
}
|
||||
|
||||
void RGBController_LianLiUniHubSLInfinity::SetupZones()
|
||||
{
|
||||
/*-------------------------------------------------*\
|
||||
| Only set LED count on the first run |
|
||||
\*-------------------------------------------------*/
|
||||
bool first_run = false;
|
||||
|
||||
if(zones.size() == 0)
|
||||
{
|
||||
first_run = true;
|
||||
zones.resize(UNIHUB_SLINF_CHANNEL_COUNT);
|
||||
}
|
||||
|
||||
/*-------------------------------------------------*\
|
||||
| Clear any existing color/LED configuration |
|
||||
\*-------------------------------------------------*/
|
||||
leds.clear();
|
||||
colors.clear();
|
||||
|
||||
/*-------------------------------------------------*\
|
||||
| Set zones and leds |
|
||||
\*-------------------------------------------------*/
|
||||
for(unsigned int channel_idx = 0; channel_idx < zones.size(); channel_idx++)
|
||||
{
|
||||
zones[channel_idx].name = "Channel ";
|
||||
zones[channel_idx].name.append(std::to_string(channel_idx + 1));
|
||||
|
||||
zones[channel_idx].type = ZONE_TYPE_LINEAR;
|
||||
zones[channel_idx].leds_min = 0;
|
||||
zones[channel_idx].leds_max = UNIHUB_SLINF_CHAN_LED_COUNT;
|
||||
|
||||
if(first_run)
|
||||
{
|
||||
zones[channel_idx].leds_count = zones[channel_idx].leds_min;
|
||||
}
|
||||
|
||||
for(unsigned int led_ch_idx = 0; led_ch_idx < zones[channel_idx].leds_count; led_ch_idx++)
|
||||
{
|
||||
led new_led;
|
||||
new_led.name = zones[channel_idx].name;
|
||||
new_led.name.append(", LED ");
|
||||
new_led.name.append(std::to_string(led_ch_idx + 1));
|
||||
new_led.value = channel_idx;
|
||||
|
||||
leds.push_back(new_led);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
SetupColors();
|
||||
}
|
||||
|
||||
void RGBController_LianLiUniHubSLInfinity::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_LianLiUniHubSLInfinity::DeviceUpdateLEDs()
|
||||
{
|
||||
|
||||
if(!initializedMode)
|
||||
{
|
||||
DeviceUpdateMode();
|
||||
}
|
||||
|
||||
float brightness_scale = static_cast<float>(modes[active_mode].brightness)/modes[active_mode].brightness_max;
|
||||
|
||||
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, brightness_scale);
|
||||
}
|
||||
}
|
||||
|
||||
void RGBController_LianLiUniHubSLInfinity::UpdateZoneLEDs(int zone)
|
||||
{
|
||||
if(!initializedMode)
|
||||
{
|
||||
DeviceUpdateMode();
|
||||
}
|
||||
|
||||
float brightness_scale = static_cast<float>(modes[active_mode].brightness)/modes[active_mode].brightness_max;
|
||||
|
||||
controller->SetChannelLEDs(zone, zones[zone].colors, zones[zone].leds_count, brightness_scale);
|
||||
}
|
||||
|
||||
void RGBController_LianLiUniHubSLInfinity::UpdateSingleLED(int /* led */)
|
||||
{
|
||||
DeviceUpdateMode();
|
||||
|
||||
}
|
||||
|
||||
void RGBController_LianLiUniHubSLInfinity::DeviceUpdateMode()
|
||||
{
|
||||
if(!active_mode)
|
||||
{
|
||||
return; // Do nothing, custom mode should go through DeviceUpdateLEDs() to avoid flooding controller
|
||||
}
|
||||
|
||||
initializedMode = true;
|
||||
|
||||
int fan_idx = 0;
|
||||
|
||||
for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
|
||||
{
|
||||
if(zones[zone_idx].leds_count == 0)
|
||||
{
|
||||
return; // Do nothing, channel isn't in use
|
||||
}
|
||||
fan_idx = ((zones[zone_idx].leds_count / 16) - 1); // Indexes start at 0
|
||||
|
||||
controller->SetChannelMode((unsigned char)zone_idx,
|
||||
modes[active_mode],
|
||||
fan_idx);
|
||||
|
||||
}
|
||||
}
|
||||
+41
@@ -0,0 +1,41 @@
|
||||
/*---------------------------------------------------------*\
|
||||
| RGBController_LianLiUniHubSLInfinity.h |
|
||||
| |
|
||||
| RGBController for Lian Li SL Infinity Uni Hub |
|
||||
| |
|
||||
| Simon McKenna 21 Oct 2023 |
|
||||
| Will Kennedy 17 Jan 2023 |
|
||||
| Oliver P 26 Apr 2022 |
|
||||
| Credit to Luca Lovisa for original work. |
|
||||
| |
|
||||
| This file is part of the OpenRGB project |
|
||||
| SPDX-License-Identifier: GPL-2.0-or-later |
|
||||
\*---------------------------------------------------------*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <cstdint>
|
||||
#include <vector>
|
||||
#include "LianLiUniHubSLInfinityController.h"
|
||||
#include "RGBController.h"
|
||||
|
||||
class RGBController_LianLiUniHubSLInfinity : public RGBController
|
||||
{
|
||||
public:
|
||||
RGBController_LianLiUniHubSLInfinity(LianLiUniHubSLInfinityController* controller_ptr);
|
||||
~RGBController_LianLiUniHubSLInfinity();
|
||||
|
||||
void SetupZones();
|
||||
|
||||
void ResizeZone(int zone, int new_size);
|
||||
|
||||
void DeviceUpdateLEDs();
|
||||
void UpdateZoneLEDs(int zone);
|
||||
void UpdateSingleLED(int led);
|
||||
|
||||
void DeviceUpdateMode();
|
||||
|
||||
private:
|
||||
LianLiUniHubSLInfinityController* controller;
|
||||
bool initializedMode;
|
||||
};
|
||||
+316
@@ -0,0 +1,316 @@
|
||||
/*---------------------------------------------------------*\
|
||||
| LianLiUniHubSLV2Controller.cpp |
|
||||
| |
|
||||
| Driver for Lian Li SLV2 Uni Hub |
|
||||
| |
|
||||
| Will Kennedy 17 Jan 2023 |
|
||||
| Oliver P 26 Apr 2022 |
|
||||
| Credit to Luca Lovisa for original work. |
|
||||
| |
|
||||
| This file is part of the OpenRGB project |
|
||||
| SPDX-License-Identifier: GPL-2.0-or-later |
|
||||
\*---------------------------------------------------------*/
|
||||
|
||||
#include <string.h>
|
||||
#include "LianLiUniHubSLV2Controller.h"
|
||||
#include "StringUtils.h"
|
||||
|
||||
using namespace std::chrono_literals;
|
||||
|
||||
LianLiUniHubSLV2Controller::LianLiUniHubSLV2Controller(hid_device* dev_handle, const char* path, std::string dev_name)
|
||||
{
|
||||
dev = dev_handle;
|
||||
location = path;
|
||||
name = dev_name;
|
||||
}
|
||||
|
||||
LianLiUniHubSLV2Controller::~LianLiUniHubSLV2Controller()
|
||||
{
|
||||
hid_close(dev);
|
||||
}
|
||||
|
||||
std::string LianLiUniHubSLV2Controller::GetDeviceLocation()
|
||||
{
|
||||
return("HID: " + location);
|
||||
}
|
||||
|
||||
std::string LianLiUniHubSLV2Controller::GetFirmwareVersionString()
|
||||
{
|
||||
wchar_t product_string[40];
|
||||
int ret = hid_get_product_string(dev, product_string, 40);
|
||||
|
||||
if (ret != 0)
|
||||
{
|
||||
return ("");
|
||||
}
|
||||
|
||||
std::string return_string = StringUtils::wstring_to_string(product_string);
|
||||
|
||||
return(return_string.substr(return_string.find_last_of("-")+1,4).c_str());
|
||||
}
|
||||
|
||||
std::string LianLiUniHubSLV2Controller::GetName()
|
||||
{
|
||||
return(name);
|
||||
}
|
||||
|
||||
std::string LianLiUniHubSLV2Controller::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));
|
||||
}
|
||||
|
||||
float brightnessLimit(RGBColor color)
|
||||
{
|
||||
/*---------------------------------------------------------*\
|
||||
| Limiter to protect LEDs |
|
||||
\*---------------------------------------------------------*/
|
||||
if(UNIHUB_SLV2_LED_LIMITER && (RGBGetRValue(color) + RGBGetBValue(color) + RGBGetGValue(color) > 460))
|
||||
{
|
||||
return 460.f / (RGBGetRValue(color) + RGBGetBValue(color) + RGBGetGValue(color));
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
void LianLiUniHubSLV2Controller::SetChannelLEDs(unsigned char channel, RGBColor * colors, unsigned int num_colors, float brightness)
|
||||
{
|
||||
unsigned char led_data[16 * 6 * 3];
|
||||
int fan_idx = 0;
|
||||
int mod_led_idx;
|
||||
int cur_led_idx;
|
||||
|
||||
if(num_colors == 0)
|
||||
{
|
||||
return; // Do nothing, channel isn't in use
|
||||
}
|
||||
|
||||
for(unsigned int led_idx = 0; led_idx < num_colors; led_idx++)
|
||||
{
|
||||
mod_led_idx = (led_idx % 16);
|
||||
|
||||
if((mod_led_idx == 0) && (led_idx != 0))
|
||||
{
|
||||
fan_idx++;
|
||||
}
|
||||
|
||||
float brightness_scale = brightness * brightnessLimit(colors[led_idx]);
|
||||
|
||||
//Determine current position of led_data array from colors array
|
||||
cur_led_idx = ((mod_led_idx + (fan_idx * 16)) * 3);
|
||||
|
||||
led_data[cur_led_idx + 0] = (unsigned char)(RGBGetRValue(colors[led_idx]) * brightness_scale);
|
||||
led_data[cur_led_idx + 1] = (unsigned char)(RGBGetBValue(colors[led_idx]) * brightness_scale);
|
||||
led_data[cur_led_idx + 2] = (unsigned char)(RGBGetGValue(colors[led_idx]) * brightness_scale);
|
||||
}
|
||||
|
||||
/*---------------------------------------------------------*\
|
||||
| Send fan LED data |
|
||||
\*---------------------------------------------------------*/
|
||||
|
||||
SendStartAction
|
||||
(
|
||||
channel, // Current channel
|
||||
(fan_idx + 1) // Number of fans
|
||||
);
|
||||
|
||||
SendColorData
|
||||
(
|
||||
channel, // Channel
|
||||
(fan_idx + 1)*16,
|
||||
led_data
|
||||
);
|
||||
|
||||
SendCommitAction
|
||||
(
|
||||
channel, // Channel
|
||||
UNIHUB_SLV2_LED_MODE_STATIC_COLOR, // Effect
|
||||
UNIHUB_SLV2_LED_SPEED_000, // Speed
|
||||
UNIHUB_SLV2_LED_DIRECTION_LTR, // Direction
|
||||
UNIHUB_SLV2_LED_BRIGHTNESS_100 // Brightness
|
||||
);
|
||||
|
||||
}
|
||||
|
||||
void LianLiUniHubSLV2Controller::SetChannelMode(unsigned char channel, const mode active_mode, unsigned int num_fans)
|
||||
{
|
||||
static unsigned int brightness_code[5] =
|
||||
{
|
||||
UNIHUB_SLV2_LED_BRIGHTNESS_000,
|
||||
UNIHUB_SLV2_LED_BRIGHTNESS_025,
|
||||
UNIHUB_SLV2_LED_BRIGHTNESS_050,
|
||||
UNIHUB_SLV2_LED_BRIGHTNESS_075,
|
||||
UNIHUB_SLV2_LED_BRIGHTNESS_100
|
||||
};
|
||||
|
||||
static unsigned int speed_code[5] =
|
||||
{
|
||||
UNIHUB_SLV2_LED_SPEED_000,
|
||||
UNIHUB_SLV2_LED_SPEED_025,
|
||||
UNIHUB_SLV2_LED_SPEED_050,
|
||||
UNIHUB_SLV2_LED_SPEED_075,
|
||||
UNIHUB_SLV2_LED_SPEED_100
|
||||
};
|
||||
|
||||
unsigned char fan_led_data[16 * 6 * 3];
|
||||
int cur_led_idx;
|
||||
float brightness;
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Zero out buffer |
|
||||
\*-----------------------------------------------------*/
|
||||
memset(fan_led_data, 0x00, sizeof(fan_led_data));
|
||||
|
||||
std::vector<RGBColor> colors = active_mode.colors;
|
||||
unsigned int num_colors = (unsigned int)colors.size();
|
||||
|
||||
if(!colors.empty()) // Update led_data if there's colors
|
||||
{
|
||||
brightness = static_cast<float>(active_mode.brightness)/4;
|
||||
if (num_colors == 6)
|
||||
{
|
||||
for(unsigned int i = 0; i < 6; i++)
|
||||
{
|
||||
float brightness_scale = brightness * brightnessLimit(colors[i]);
|
||||
for(unsigned int led_idx = 0; led_idx < 16 * 3; led_idx += 3)
|
||||
{
|
||||
cur_led_idx = (i * 16 * 3) + led_idx;
|
||||
fan_led_data[cur_led_idx + 0] = (unsigned char)(RGBGetRValue(colors[i]) * brightness_scale);
|
||||
fan_led_data[cur_led_idx + 1] = (unsigned char)(RGBGetBValue(colors[i]) * brightness_scale);
|
||||
fan_led_data[cur_led_idx + 2] = (unsigned char)(RGBGetGValue(colors[i]) * brightness_scale);
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
colors.resize(4);
|
||||
for(unsigned int i = num_colors; i < 4; i++)
|
||||
{
|
||||
colors[i] = 0x00;
|
||||
}
|
||||
|
||||
// needs a 72 length array of 4 colors, even if less are defined
|
||||
for(unsigned int j = 0; j < 4; j++)
|
||||
{
|
||||
float brightness_scale = brightness * brightnessLimit(colors[j]);
|
||||
for(unsigned int i = 0; i < 6; i++)
|
||||
{
|
||||
cur_led_idx = (i * 12) + (j * 3);
|
||||
fan_led_data[cur_led_idx + 0] = (unsigned char)(RGBGetRValue(colors[j]) * brightness_scale);
|
||||
fan_led_data[cur_led_idx + 1] = (unsigned char)(RGBGetBValue(colors[j]) * brightness_scale);
|
||||
fan_led_data[cur_led_idx + 2] = (unsigned char)(RGBGetGValue(colors[j]) * brightness_scale);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
SendStartAction
|
||||
(
|
||||
channel, // Current channel
|
||||
(num_fans + 1) // Number of fans
|
||||
);
|
||||
|
||||
SendColorData
|
||||
(
|
||||
channel, // Channel
|
||||
(num_fans + 1)*16,
|
||||
fan_led_data // Data
|
||||
);
|
||||
|
||||
SendCommitAction
|
||||
(
|
||||
channel, // Channel
|
||||
active_mode.value, // Effect
|
||||
speed_code[active_mode.speed], // Speed
|
||||
active_mode.direction, // Direction
|
||||
brightness_code[active_mode.brightness] // Brightness
|
||||
);
|
||||
}
|
||||
|
||||
void LianLiUniHubSLV2Controller::SendStartAction(unsigned char channel, unsigned int num_fans)
|
||||
{
|
||||
unsigned char usb_buf[353];
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Zero out buffer |
|
||||
\*-----------------------------------------------------*/
|
||||
memset(usb_buf, 0x00, sizeof(usb_buf));
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Set up message packet |
|
||||
\*-----------------------------------------------------*/
|
||||
usb_buf[0x00] = UNIHUB_SLV2_TRANSACTION_ID;
|
||||
usb_buf[0x01] = 0x10;
|
||||
usb_buf[0x02] = 0x60;
|
||||
usb_buf[0x03] = (channel << 4) + num_fans;
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Send packet |
|
||||
\*-----------------------------------------------------*/
|
||||
hid_write(dev, usb_buf, sizeof(usb_buf));
|
||||
std::this_thread::sleep_for(5ms);
|
||||
|
||||
}
|
||||
|
||||
void LianLiUniHubSLV2Controller::SendColorData(unsigned char channel, unsigned int num_leds, unsigned char* led_data)
|
||||
{
|
||||
/*---------------------------------------------------------*\
|
||||
| Send LED data |
|
||||
\*---------------------------------------------------------*/
|
||||
|
||||
unsigned char usb_buf[353];
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Zero out buffer |
|
||||
\*-----------------------------------------------------*/
|
||||
memset(usb_buf, 0x00, sizeof(usb_buf));
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Set up message packet |
|
||||
\*-----------------------------------------------------*/
|
||||
usb_buf[0x00] = UNIHUB_SLV2_TRANSACTION_ID;
|
||||
usb_buf[0x01] = 0x30 + channel; // action + channel(30 = channel 1, 31 = channel 2, etc.)
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Copy in color data bytes |
|
||||
\*-----------------------------------------------------*/
|
||||
memcpy(&usb_buf[0x02], led_data, num_leds * 3);
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Send packet |
|
||||
\*-----------------------------------------------------*/
|
||||
hid_write(dev, usb_buf, sizeof(usb_buf));
|
||||
std::this_thread::sleep_for(5ms);
|
||||
}
|
||||
|
||||
void LianLiUniHubSLV2Controller::SendCommitAction(unsigned char channel, unsigned char effect, unsigned char speed, unsigned int direction, unsigned int brightness)
|
||||
{
|
||||
unsigned char usb_buf[353];
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Zero out buffer |
|
||||
\*-----------------------------------------------------*/
|
||||
memset(usb_buf, 0x00, sizeof(usb_buf));
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Set up message packet |
|
||||
\*-----------------------------------------------------*/
|
||||
usb_buf[0x00] = UNIHUB_SLV2_TRANSACTION_ID;
|
||||
usb_buf[0x01] = 0x10 + channel; // Channel+device (10 = channel 1, 11 = channel 2, etc.)
|
||||
usb_buf[0x02] = effect; // Effect
|
||||
usb_buf[0x03] = speed; // Speed, 02=0%, 01=25%, 00=50%, ff=75%, fe=100%
|
||||
usb_buf[0x04] = direction; // Direction, right=00, left=01
|
||||
usb_buf[0x05] = brightness; // Brightness, 0=100%, 1= 75%, 2 = 50%, 3 = 25%, 8 = 0%
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Send packet |
|
||||
\*-----------------------------------------------------*/
|
||||
hid_write(dev, usb_buf, sizeof(usb_buf));
|
||||
std::this_thread::sleep_for(5ms);
|
||||
}
|
||||
@@ -0,0 +1,211 @@
|
||||
/*---------------------------------------------------------*\
|
||||
| LianLiUniHubSLV2Controller.h |
|
||||
| |
|
||||
| Driver for Lian Li SLV2 Uni Hub |
|
||||
| |
|
||||
| Will Kennedy 17 Jan 2023 |
|
||||
| Oliver P 26 Apr 2022 |
|
||||
| Credit to Luca Lovisa for original work. |
|
||||
| |
|
||||
| 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"
|
||||
|
||||
/*----------------------------------------------------------------------------*\
|
||||
| Global definitions. |
|
||||
\*----------------------------------------------------------------------------*/
|
||||
|
||||
/*----------------------------------------------------------------------------*\
|
||||
| Definitions related to zone Sizes |
|
||||
\*----------------------------------------------------------------------------*/
|
||||
|
||||
|
||||
enum
|
||||
{
|
||||
UNIHUB_SLV2_CHANNEL_COUNT = 0x04, /* Channel count */
|
||||
UNIHUB_SLV2_CHAN_LED_COUNT = 0x10 * 6, /* Max-LED per channel count - 96 */
|
||||
};
|
||||
|
||||
/*----------------------------------------------------------------------------*\
|
||||
| Definitions related to LED configuration. |
|
||||
\*----------------------------------------------------------------------------*/
|
||||
|
||||
// Used for sync'd mode between Fan and Edge
|
||||
|
||||
enum
|
||||
{
|
||||
UNIHUB_SLV2_LED_MODE_STATIC_COLOR = 0x01, // full data array
|
||||
UNIHUB_SLV2_LED_MODE_BREATHING = 0x02, // full data array
|
||||
UNIHUB_SLV2_LED_MODE_RAINBOW_MORPH = 0x04, // no array
|
||||
UNIHUB_SLV2_LED_MODE_RAINBOW = 0x05, // no array
|
||||
UNIHUB_SLV2_LED_MODE_STAGGERED = 0x18, // size 2
|
||||
UNIHUB_SLV2_LED_MODE_TIDE = 0x1A, // size 2
|
||||
UNIHUB_SLV2_LED_MODE_RUNWAY = 0x1C, // size 2
|
||||
UNIHUB_SLV2_LED_MODE_MIXING = 0x1E, // size 2
|
||||
UNIHUB_SLV2_LED_MODE_STACK = 0x20, // size 1
|
||||
UNIHUB_SLV2_LED_MODE_STACK_MULTI_COLOR = 0x21, // no array
|
||||
UNIHUB_SLV2_LED_MODE_NEON = 0x22, // no array
|
||||
UNIHUB_SLV2_LED_MODE_COLOR_CYCLE = 0x23, // size 3
|
||||
UNIHUB_SLV2_LED_MODE_METEOR = 0x24, // size 2
|
||||
UNIHUB_SLV2_LED_MODE_VOICE = 0x26, // no array
|
||||
UNIHUB_SLV2_LED_MODE_GROOVE = 0x27, // size 2
|
||||
UNIHUB_SLV2_LED_MODE_RENDER = 0x28, // size 4
|
||||
UNIHUB_SLV2_LED_MODE_TUNNEL = 0x29, // size 4
|
||||
// merged modes
|
||||
UNIHUB_SLV2_LED_MODE_METEOR_MERGED = 0x2A,
|
||||
UNIHUB_SLV2_LED_MODE_RUNWAY_MERGED = 0x2B,
|
||||
UNIHUB_SLV2_LED_MODE_TIDE_MERGED = 0x2C,
|
||||
UNIHUB_SLV2_LED_MODE_MIXING_MERGED = 0x2D,
|
||||
UNIHUB_SLV2_LED_MODE_STACK_MULTI_COLOR_MERGED = 0x2E
|
||||
};
|
||||
|
||||
enum
|
||||
{
|
||||
UNIHUB_SLV2_LED_SPEED_000 = 0x02, /* Very slow speed */
|
||||
UNIHUB_SLV2_LED_SPEED_025 = 0x01, /* Rather slow speed */
|
||||
UNIHUB_SLV2_LED_SPEED_050 = 0x00, /* Medium speed */
|
||||
UNIHUB_SLV2_LED_SPEED_075 = 0xFF, /* Rather fast speed */
|
||||
UNIHUB_SLV2_LED_SPEED_100 = 0xFE, /* Very fast speed */
|
||||
};
|
||||
|
||||
enum
|
||||
{
|
||||
UNIHUB_SLV2_LED_DIRECTION_LTR = 0x00, /* Left-to-Right direction */
|
||||
UNIHUB_SLV2_LED_DIRECTION_RTL = 0x01, /* Right-to-Left direction */
|
||||
};
|
||||
|
||||
enum
|
||||
{
|
||||
UNIHUB_SLV2_LED_BRIGHTNESS_000 = 0x08, /* Very dark (off) */
|
||||
UNIHUB_SLV2_LED_BRIGHTNESS_025 = 0x03, /* Rather dark */
|
||||
UNIHUB_SLV2_LED_BRIGHTNESS_050 = 0x02, /* Medium bright */
|
||||
UNIHUB_SLV2_LED_BRIGHTNESS_075 = 0x01, /* Rather bright */
|
||||
UNIHUB_SLV2_LED_BRIGHTNESS_100 = 0x00, /* Very bright */
|
||||
};
|
||||
|
||||
enum
|
||||
{
|
||||
UNIHUB_SLV2_LED_LIMITER = 0x01 /* Limit the color white to 999999 as per manufacturer limits */
|
||||
};
|
||||
|
||||
|
||||
/*----------------------------------------------------------------------------*\
|
||||
| Definitions related to packet configuration. |
|
||||
\*----------------------------------------------------------------------------*/
|
||||
|
||||
enum
|
||||
{
|
||||
UNIHUB_SLV2_TRANSACTION_ID = 0xE0, /* Command value to start all packets */
|
||||
};
|
||||
|
||||
/*----------------------------------------------------------------------------*\
|
||||
| Uni Hub SLV2 controller. |
|
||||
\*----------------------------------------------------------------------------*/
|
||||
|
||||
class LianLiUniHubSLV2Controller
|
||||
{
|
||||
|
||||
|
||||
public:
|
||||
LianLiUniHubSLV2Controller(hid_device* dev_handle, const char* path, std::string dev_name);
|
||||
~LianLiUniHubSLV2Controller();
|
||||
|
||||
std::string GetDeviceLocation();
|
||||
std::string GetFirmwareVersionString();
|
||||
std::string GetName();
|
||||
std::string GetSerialString();
|
||||
|
||||
void SetChannelMode
|
||||
(
|
||||
unsigned char channel,
|
||||
const mode active_mode,
|
||||
unsigned int num_fans
|
||||
);
|
||||
|
||||
void SetChannelLEDs
|
||||
(
|
||||
unsigned char channel,
|
||||
RGBColor * colors,
|
||||
unsigned int num_colors,
|
||||
float brightness
|
||||
);
|
||||
|
||||
void SendStartAction
|
||||
(
|
||||
unsigned char channel,
|
||||
unsigned int num_fans
|
||||
);
|
||||
|
||||
void SendColorData
|
||||
(
|
||||
unsigned char channel, // Zone index
|
||||
unsigned int num_leds,
|
||||
unsigned char* led_data // Color data payload
|
||||
);
|
||||
|
||||
void SendCommitAction
|
||||
(
|
||||
unsigned char channel, // Zone index
|
||||
unsigned char effect,
|
||||
unsigned char speed,
|
||||
unsigned int direction,
|
||||
unsigned int brightness
|
||||
);
|
||||
|
||||
private:
|
||||
/* The Uni Hub requires colors in RBG order */
|
||||
struct Color
|
||||
{
|
||||
uint8_t r;
|
||||
uint8_t b;
|
||||
uint8_t g;
|
||||
};
|
||||
|
||||
/* The values correspond to the definitions above */
|
||||
struct Channel
|
||||
{
|
||||
uint8_t index;
|
||||
|
||||
uint8_t anyFanCountOffset;
|
||||
uint8_t anyFanCount;
|
||||
|
||||
uint16_t ledActionAddress;
|
||||
uint16_t ledCommitAddress;
|
||||
uint16_t ledModeAddress;
|
||||
uint16_t ledSpeedAddress;
|
||||
uint16_t ledDirectionAddress;
|
||||
uint16_t ledBrightnessAddress;
|
||||
|
||||
Color colors[UNIHUB_SLV2_CHAN_LED_COUNT];
|
||||
|
||||
uint8_t ledMode;
|
||||
uint8_t ledSpeed;
|
||||
uint8_t ledDirection;
|
||||
uint8_t ledBrightness;
|
||||
|
||||
uint16_t fanHubActionAddress;
|
||||
uint16_t fanHubCommitAddress;
|
||||
|
||||
uint16_t fanPwmActionAddress;
|
||||
uint16_t fanPwmCommitAddress;
|
||||
uint16_t fanRpmActionAddress;
|
||||
|
||||
uint16_t fanSpeed;
|
||||
};
|
||||
|
||||
private:
|
||||
hid_device* dev;
|
||||
|
||||
/*---------------------------------------------------------*\
|
||||
| Device information strings |
|
||||
\*---------------------------------------------------------*/
|
||||
std::string firmware_version;
|
||||
std::string location;
|
||||
std::string name;
|
||||
};
|
||||
+444
@@ -0,0 +1,444 @@
|
||||
/*---------------------------------------------------------*\
|
||||
| RGBController_LianLiUniHubSLV2.cpp |
|
||||
| |
|
||||
| RGBController for Lian Li SLV2 Uni Hub |
|
||||
| |
|
||||
| Will Kennedy 17 Jan 2023 |
|
||||
| Oliver P 26 Apr 2022 |
|
||||
| Credit to Luca Lovisa for original work. |
|
||||
| |
|
||||
| This file is part of the OpenRGB project |
|
||||
| SPDX-License-Identifier: GPL-2.0-or-later |
|
||||
\*---------------------------------------------------------*/
|
||||
|
||||
#include <string>
|
||||
#include "RGBController_LianLiUniHubSLV2.h"
|
||||
|
||||
/**------------------------------------------------------------------*\
|
||||
@name Lian Li Uni Hub SLV2
|
||||
@type USB
|
||||
@save :x:
|
||||
@direct :rotating_light:
|
||||
@effects :white_check_mark:
|
||||
@detectors DetectLianLiUniHubSLV2
|
||||
@comment
|
||||
\*-------------------------------------------------------------------*/
|
||||
|
||||
RGBController_LianLiUniHubSLV2::RGBController_LianLiUniHubSLV2(LianLiUniHubSLV2Controller* controller_ptr)
|
||||
{
|
||||
controller = controller_ptr;
|
||||
|
||||
name = controller->GetName();
|
||||
vendor = "Lian Li";
|
||||
type = DEVICE_TYPE_COOLER;
|
||||
description = "Lian Li Uni Hub - SL V2";
|
||||
version = controller->GetFirmwareVersionString();
|
||||
location = controller->GetDeviceLocation();
|
||||
serial = controller->GetSerialString();
|
||||
|
||||
initializedMode = false;
|
||||
|
||||
mode Custom;
|
||||
Custom.name = "Custom";
|
||||
Custom.value = UNIHUB_SLV2_LED_MODE_STATIC_COLOR;
|
||||
Custom.flags = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_PER_LED_COLOR;
|
||||
Custom.brightness_min = 0;
|
||||
Custom.brightness_max = 50;
|
||||
Custom.brightness = 50;
|
||||
Custom.color_mode = MODE_COLORS_PER_LED;
|
||||
modes.push_back(Custom);
|
||||
|
||||
mode StaticColor;
|
||||
StaticColor.name = "Static";
|
||||
StaticColor.value = UNIHUB_SLV2_LED_MODE_STATIC_COLOR;
|
||||
StaticColor.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
|
||||
StaticColor.brightness_min = 0;
|
||||
StaticColor.brightness_max = 4;
|
||||
StaticColor.colors_min = 0;
|
||||
StaticColor.colors_max = 6;
|
||||
StaticColor.brightness = 4;
|
||||
StaticColor.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
StaticColor.colors.resize(6);
|
||||
modes.push_back(StaticColor);
|
||||
|
||||
mode Breathing;
|
||||
Breathing.name = "Breathing";
|
||||
Breathing.value = UNIHUB_SLV2_LED_MODE_BREATHING;
|
||||
Breathing.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
|
||||
Breathing.speed_min = 0;
|
||||
Breathing.speed_max = 4;
|
||||
Breathing.brightness_min = 0;
|
||||
Breathing.brightness_max = 4;
|
||||
Breathing.colors_min = 0;
|
||||
Breathing.colors_max = 6;
|
||||
Breathing.speed = 2;
|
||||
Breathing.brightness = 4;
|
||||
Breathing.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Breathing.colors.resize(6);
|
||||
modes.push_back(Breathing);
|
||||
|
||||
mode RainbowMorph;
|
||||
RainbowMorph.name = "Spectrum Cycle";
|
||||
RainbowMorph.value = UNIHUB_SLV2_LED_MODE_RAINBOW_MORPH;
|
||||
RainbowMorph.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
|
||||
RainbowMorph.speed_min = 0;
|
||||
RainbowMorph.speed_max = 4;
|
||||
RainbowMorph.brightness_min = 0;
|
||||
RainbowMorph.brightness_max = 4;
|
||||
RainbowMorph.speed = 2;
|
||||
RainbowMorph.brightness = 4;
|
||||
RainbowMorph.color_mode = MODE_COLORS_NONE;
|
||||
modes.push_back(RainbowMorph);
|
||||
|
||||
mode RainbowWave;
|
||||
RainbowWave.name = "Rainbow Wave";
|
||||
RainbowWave.value = UNIHUB_SLV2_LED_MODE_RAINBOW;
|
||||
RainbowWave.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_DIRECTION_LR;
|
||||
RainbowWave.speed_min = 0;
|
||||
RainbowWave.speed_max = 4;
|
||||
RainbowWave.brightness_min = 0;
|
||||
RainbowWave.brightness_max = 4;
|
||||
RainbowWave.speed = 2;
|
||||
RainbowWave.brightness = 4;
|
||||
RainbowWave.direction = UNIHUB_SLV2_LED_DIRECTION_LTR;
|
||||
RainbowWave.color_mode = MODE_COLORS_NONE;
|
||||
modes.push_back(RainbowWave);
|
||||
|
||||
mode Staggered;
|
||||
Staggered.name = "Staggered";
|
||||
Staggered.value = UNIHUB_SLV2_LED_MODE_STAGGERED;
|
||||
Staggered.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
|
||||
Staggered.speed_min = 0;
|
||||
Staggered.speed_max = 4;
|
||||
Staggered.brightness_min = 0;
|
||||
Staggered.brightness_max = 4;
|
||||
Staggered.colors_min = 0;
|
||||
Staggered.colors_max = 2;
|
||||
Staggered.speed = 2;
|
||||
Staggered.brightness = 4;
|
||||
Staggered.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Staggered.colors.resize(2);
|
||||
modes.push_back(Staggered);
|
||||
|
||||
mode Tide; // TODO: Has merge
|
||||
Tide.name = "Tide";
|
||||
Tide.value = UNIHUB_SLV2_LED_MODE_TIDE;
|
||||
Tide.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
|
||||
Tide.speed_min = 0;
|
||||
Tide.speed_max = 4;
|
||||
Tide.brightness_min = 0;
|
||||
Tide.brightness_max = 4;
|
||||
Tide.colors_min = 0;
|
||||
Tide.colors_max = 2;
|
||||
Tide.speed = 2;
|
||||
Tide.brightness = 4;
|
||||
Tide.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Tide.colors.resize(2);
|
||||
modes.push_back(Tide);
|
||||
|
||||
mode Runway; //TODO: Has merge
|
||||
Runway.name = "Runway";
|
||||
Runway.value = UNIHUB_SLV2_LED_MODE_RUNWAY;
|
||||
Runway.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
|
||||
Runway.speed_min = 0;
|
||||
Runway.speed_max = 4;
|
||||
Runway.brightness_min = 0;
|
||||
Runway.brightness_max = 4;
|
||||
Runway.colors_min = 0;
|
||||
Runway.colors_max = 2;
|
||||
Runway.speed = 2;
|
||||
Runway.brightness = 4;
|
||||
Runway.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Runway.colors.resize(2);
|
||||
modes.push_back(Runway);
|
||||
|
||||
mode Mixing; //TODO: Has merge
|
||||
Mixing.name = "Mixing";
|
||||
Mixing.value = UNIHUB_SLV2_LED_MODE_MIXING;
|
||||
Mixing.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
|
||||
Mixing.speed_min = 0;
|
||||
Mixing.speed_max = 4;
|
||||
Mixing.brightness_min = 0;
|
||||
Mixing.brightness_max = 4;
|
||||
Mixing.colors_min = 0;
|
||||
Mixing.colors_max = 2;
|
||||
Mixing.speed = 2;
|
||||
Mixing.brightness = 4;
|
||||
Mixing.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Mixing.colors.resize(2);
|
||||
modes.push_back(Mixing);
|
||||
|
||||
mode Stack;
|
||||
Stack.name = "Stack";
|
||||
Stack.value = UNIHUB_SLV2_LED_MODE_STACK;
|
||||
Stack.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_DIRECTION_LR;
|
||||
Stack.speed_min = 0;
|
||||
Stack.speed_max = 4;
|
||||
Stack.brightness_min = 0;
|
||||
Stack.brightness_max = 4;
|
||||
Stack.colors_min = 0;
|
||||
Stack.colors_max = 1;
|
||||
Stack.speed = 2;
|
||||
Stack.brightness = 4;
|
||||
Stack.direction = UNIHUB_SLV2_LED_DIRECTION_LTR;
|
||||
Stack.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Stack.colors.resize(1);
|
||||
modes.push_back(Stack);
|
||||
|
||||
mode StackMultiColor; //TODO: Has merge
|
||||
Stack.name = "Stack Multi Color";
|
||||
Stack.value = UNIHUB_SLV2_LED_MODE_STACK_MULTI_COLOR;
|
||||
Stack.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_DIRECTION_LR;
|
||||
Stack.speed_min = 0;
|
||||
Stack.speed_max = 4;
|
||||
Stack.brightness_min = 0;
|
||||
Stack.brightness_max = 4;
|
||||
Stack.speed = 2;
|
||||
Stack.brightness = 4;
|
||||
Stack.direction = UNIHUB_SLV2_LED_DIRECTION_LTR;
|
||||
Stack.color_mode = MODE_COLORS_NONE;
|
||||
modes.push_back(Stack);
|
||||
|
||||
mode Neon;
|
||||
Neon.name = "Neon";
|
||||
Neon.value = UNIHUB_SLV2_LED_MODE_NEON;
|
||||
Neon.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
|
||||
Neon.speed_min = 0;
|
||||
Neon.speed_max = 4;
|
||||
Neon.brightness_min = 0;
|
||||
Neon.brightness_max = 4;
|
||||
Neon.speed = 2;
|
||||
Neon.brightness = 4;
|
||||
Neon.color_mode = MODE_COLORS_NONE;
|
||||
modes.push_back(Neon);
|
||||
|
||||
mode ColorCycle;
|
||||
ColorCycle.name = "ColorCycle";
|
||||
ColorCycle.value = UNIHUB_SLV2_LED_MODE_COLOR_CYCLE;
|
||||
ColorCycle.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_DIRECTION_LR;
|
||||
ColorCycle.speed_min = 0;
|
||||
ColorCycle.speed_max = 4;
|
||||
ColorCycle.brightness_min = 0;
|
||||
ColorCycle.brightness_max = 4;
|
||||
ColorCycle.colors_min = 0;
|
||||
ColorCycle.colors_max = 3;
|
||||
ColorCycle.speed = 2;
|
||||
ColorCycle.brightness = 4;
|
||||
ColorCycle.direction = UNIHUB_SLV2_LED_DIRECTION_LTR;
|
||||
ColorCycle.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
ColorCycle.colors.resize(3);
|
||||
modes.push_back(ColorCycle);
|
||||
|
||||
mode Meteor; //TODO: Has merge
|
||||
Meteor.name = "Meteor";
|
||||
Meteor.value = UNIHUB_SLV2_LED_MODE_METEOR;
|
||||
Meteor.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
|
||||
Meteor.speed_min = 0;
|
||||
Meteor.speed_max = 4;
|
||||
Meteor.brightness_min = 0;
|
||||
Meteor.brightness_max = 4;
|
||||
Meteor.colors_min = 0;
|
||||
Meteor.colors_max = 2;
|
||||
Meteor.speed = 2;
|
||||
Meteor.brightness = 4;
|
||||
Meteor.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Meteor.colors.resize(2);
|
||||
modes.push_back(Meteor);
|
||||
|
||||
mode Voice;
|
||||
Voice.name = "Voice";
|
||||
Voice.value = UNIHUB_SLV2_LED_MODE_VOICE;
|
||||
Voice.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
|
||||
Voice.speed_min = 0;
|
||||
Voice.speed_max = 4;
|
||||
Voice.brightness_min = 0;
|
||||
Voice.brightness_max = 4;
|
||||
Voice.speed = 2;
|
||||
Voice.brightness = 4;
|
||||
modes.push_back(Voice);
|
||||
|
||||
mode Groove;
|
||||
Groove.name = "Groove";
|
||||
Groove.value = UNIHUB_SLV2_LED_MODE_GROOVE;
|
||||
Groove.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_DIRECTION_LR;
|
||||
Groove.speed_min = 0;
|
||||
Groove.speed_max = 4;
|
||||
Groove.brightness_min = 0;
|
||||
Groove.brightness_max = 4;
|
||||
Groove.colors_min = 0;
|
||||
Groove.colors_max = 1;
|
||||
Groove.speed = 2;
|
||||
Groove.brightness = 4;
|
||||
Groove.direction = UNIHUB_SLV2_LED_DIRECTION_LTR;
|
||||
Groove.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Groove.colors.resize(1);
|
||||
modes.push_back(Groove);
|
||||
|
||||
mode Render;
|
||||
Render.name = "Render";
|
||||
Render.value = UNIHUB_SLV2_LED_MODE_RENDER;
|
||||
Render.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_DIRECTION_LR;
|
||||
Render.speed_min = 0;
|
||||
Render.speed_max = 4;
|
||||
Render.brightness_min = 0;
|
||||
Render.brightness_max = 4;
|
||||
Render.colors_min = 0;
|
||||
Render.colors_max = 4;
|
||||
Render.speed = 2;
|
||||
Render.brightness = 4;
|
||||
Render.direction = UNIHUB_SLV2_LED_DIRECTION_LTR;
|
||||
Render.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Render.colors.resize(4);
|
||||
modes.push_back(Render);
|
||||
|
||||
mode Tunnel;
|
||||
Tunnel.name = "Tunnel";
|
||||
Tunnel.value = UNIHUB_SLV2_LED_MODE_TUNNEL;
|
||||
Tunnel.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_DIRECTION_LR;
|
||||
Tunnel.speed_min = 0;
|
||||
Tunnel.speed_max = 4;
|
||||
Tunnel.brightness_min = 0;
|
||||
Tunnel.brightness_max = 4;
|
||||
Tunnel.colors_min = 0;
|
||||
Tunnel.colors_max = 4;
|
||||
Tunnel.speed = 2;
|
||||
Tunnel.brightness = 4;
|
||||
Tunnel.direction = UNIHUB_SLV2_LED_DIRECTION_LTR;
|
||||
Tunnel.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Tunnel.colors.resize(4);
|
||||
modes.push_back(Tunnel);
|
||||
|
||||
RGBController_LianLiUniHubSLV2::SetupZones();
|
||||
}
|
||||
|
||||
RGBController_LianLiUniHubSLV2::~RGBController_LianLiUniHubSLV2()
|
||||
{
|
||||
delete controller;
|
||||
}
|
||||
|
||||
void RGBController_LianLiUniHubSLV2::SetupZones()
|
||||
{
|
||||
/*-------------------------------------------------*\
|
||||
| Only set LED count on the first run |
|
||||
\*-------------------------------------------------*/
|
||||
bool first_run = false;
|
||||
|
||||
if(zones.size() == 0)
|
||||
{
|
||||
first_run = true;
|
||||
zones.resize(UNIHUB_SLV2_CHANNEL_COUNT);
|
||||
}
|
||||
|
||||
/*-------------------------------------------------*\
|
||||
| Clear any existing color/LED configuration |
|
||||
\*-------------------------------------------------*/
|
||||
leds.clear();
|
||||
colors.clear();
|
||||
|
||||
/*-------------------------------------------------*\
|
||||
| Set zones and leds |
|
||||
\*-------------------------------------------------*/
|
||||
for(unsigned int channel_idx = 0; channel_idx < zones.size(); channel_idx++)
|
||||
{
|
||||
zones[channel_idx].name = "Channel ";
|
||||
zones[channel_idx].name.append(std::to_string(channel_idx + 1));
|
||||
|
||||
zones[channel_idx].type = ZONE_TYPE_LINEAR;
|
||||
zones[channel_idx].leds_min = 0;
|
||||
zones[channel_idx].leds_max = UNIHUB_SLV2_CHAN_LED_COUNT;
|
||||
|
||||
if(first_run)
|
||||
{
|
||||
zones[channel_idx].leds_count = zones[channel_idx].leds_min;
|
||||
}
|
||||
|
||||
for(unsigned int led_ch_idx = 0; led_ch_idx < zones[channel_idx].leds_count; led_ch_idx++)
|
||||
{
|
||||
led new_led;
|
||||
new_led.name = zones[channel_idx].name;
|
||||
new_led.name.append(", LED ");
|
||||
new_led.name.append(std::to_string(led_ch_idx + 1));
|
||||
new_led.value = channel_idx;
|
||||
|
||||
leds.push_back(new_led);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
SetupColors();
|
||||
}
|
||||
|
||||
void RGBController_LianLiUniHubSLV2::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_LianLiUniHubSLV2::DeviceUpdateLEDs()
|
||||
{
|
||||
|
||||
if(!initializedMode)
|
||||
{
|
||||
DeviceUpdateMode();
|
||||
}
|
||||
|
||||
float brightness_scale = static_cast<float>(modes[active_mode].brightness)/modes[active_mode].brightness_max;
|
||||
|
||||
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, brightness_scale);
|
||||
}
|
||||
}
|
||||
|
||||
void RGBController_LianLiUniHubSLV2::UpdateZoneLEDs(int zone)
|
||||
{
|
||||
if(!initializedMode)
|
||||
{
|
||||
DeviceUpdateMode();
|
||||
}
|
||||
|
||||
float brightness_scale = static_cast<float>(modes[active_mode].brightness)/modes[active_mode].brightness_max;
|
||||
|
||||
controller->SetChannelLEDs(zone, zones[zone].colors, zones[zone].leds_count, brightness_scale);
|
||||
}
|
||||
|
||||
void RGBController_LianLiUniHubSLV2::UpdateSingleLED(int /* led */)
|
||||
{
|
||||
DeviceUpdateMode();
|
||||
|
||||
}
|
||||
|
||||
void RGBController_LianLiUniHubSLV2::DeviceUpdateMode()
|
||||
{
|
||||
if(!active_mode)
|
||||
{
|
||||
return; // Do nothing, custom mode should go through DeviceUpdateLEDs() to avoid flooding controller
|
||||
}
|
||||
|
||||
initializedMode = true;
|
||||
|
||||
int fan_idx = 0;
|
||||
|
||||
for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
|
||||
{
|
||||
if(zones[zone_idx].leds_count == 0)
|
||||
{
|
||||
return; // Do nothing, channel isn't in use
|
||||
}
|
||||
fan_idx = ((zones[zone_idx].leds_count / 16) - 1); // Indexes start at 0
|
||||
|
||||
controller->SetChannelMode((unsigned char)zone_idx,
|
||||
modes[active_mode],
|
||||
fan_idx);
|
||||
|
||||
}
|
||||
}
|
||||
+40
@@ -0,0 +1,40 @@
|
||||
/*---------------------------------------------------------*\
|
||||
| RGBController_LianLiUniHubSLV2.h |
|
||||
| |
|
||||
| RGBController for Lian Li SLV2 Uni Hub |
|
||||
| |
|
||||
| Will Kennedy 17 Jan 2023 |
|
||||
| Oliver P 26 Apr 2022 |
|
||||
| Credit to Luca Lovisa for original work. |
|
||||
| |
|
||||
| This file is part of the OpenRGB project |
|
||||
| SPDX-License-Identifier: GPL-2.0-or-later |
|
||||
\*---------------------------------------------------------*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <cstdint>
|
||||
#include <vector>
|
||||
#include "LianLiUniHubSLV2Controller.h"
|
||||
#include "RGBController.h"
|
||||
|
||||
class RGBController_LianLiUniHubSLV2 : public RGBController
|
||||
{
|
||||
public:
|
||||
RGBController_LianLiUniHubSLV2(LianLiUniHubSLV2Controller* controller_ptr);
|
||||
~RGBController_LianLiUniHubSLV2();
|
||||
|
||||
void SetupZones();
|
||||
|
||||
void ResizeZone(int zone, int new_size);
|
||||
|
||||
void DeviceUpdateLEDs();
|
||||
void UpdateZoneLEDs(int zone);
|
||||
void UpdateSingleLED(int led);
|
||||
|
||||
void DeviceUpdateMode();
|
||||
|
||||
private:
|
||||
LianLiUniHubSLV2Controller* controller;
|
||||
bool initializedMode;
|
||||
};
|
||||
+789
@@ -0,0 +1,789 @@
|
||||
/*---------------------------------------------------------*\
|
||||
| LianLiUniHub_AL10Controller.cpp |
|
||||
| |
|
||||
| Driver for Lian Li AL10 Uni Hub |
|
||||
| |
|
||||
| Oliver P 05 May 2022 |
|
||||
| Credit to Luca Lovisa for original work |
|
||||
| |
|
||||
| This file is part of the OpenRGB project |
|
||||
| SPDX-License-Identifier: GPL-2.0-or-later |
|
||||
\*---------------------------------------------------------*/
|
||||
|
||||
#include <cstring>
|
||||
#include "LianLiUniHub_AL10Controller.h"
|
||||
|
||||
using namespace std::chrono_literals;
|
||||
|
||||
/*----------------------------------------------------------------------------*\
|
||||
| The Uni Hub is controlled by sending control transfers to various wIndex |
|
||||
| addresses, allthough it announces some kind of hid interface. Hence it |
|
||||
| requires libusb as hidapi provides no wIndex customization. |
|
||||
\*----------------------------------------------------------------------------*/
|
||||
|
||||
LianLiUniHub_AL10Controller::LianLiUniHub_AL10Controller
|
||||
(
|
||||
libusb_device* device,
|
||||
libusb_device_descriptor* descriptor
|
||||
)
|
||||
{
|
||||
int ret;
|
||||
|
||||
/*--------------------------------------------------------------------*\
|
||||
| Open the libusb device. |
|
||||
\*--------------------------------------------------------------------*/
|
||||
ret = libusb_open(device, &handle);
|
||||
|
||||
if(ret < 0)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
/*--------------------------------------------------------------------*\
|
||||
| Fill in the location string from USB port numbers. |
|
||||
\*--------------------------------------------------------------------*/
|
||||
uint8_t ports[7];
|
||||
|
||||
ret = libusb_get_port_numbers(device, ports, sizeof(ports));
|
||||
|
||||
if(ret > 0)
|
||||
{
|
||||
location = "USB: ";
|
||||
|
||||
for (int i = 0; i < ret; i ++)
|
||||
{
|
||||
location += std::to_string(ports[i]);
|
||||
location.push_back(':');
|
||||
}
|
||||
|
||||
location.pop_back();
|
||||
}
|
||||
|
||||
/*--------------------------------------------------------------------*\
|
||||
| Fill in the serial string from the string descriptor |
|
||||
\*--------------------------------------------------------------------*/
|
||||
char serialStr[64];
|
||||
|
||||
ret = libusb_get_string_descriptor_ascii(handle, descriptor->iSerialNumber, reinterpret_cast<unsigned char*>(serialStr), sizeof(serialStr));
|
||||
|
||||
if(ret > 0)
|
||||
{
|
||||
serial = std::string(serialStr, ret);
|
||||
}
|
||||
|
||||
/*--------------------------------------------------------------------*\
|
||||
| Fill in the version string by reading version from device. |
|
||||
\*--------------------------------------------------------------------*/
|
||||
version = ReadVersion();
|
||||
|
||||
/*--------------------------------------------------------------------*\
|
||||
| Create channels with their static configuration and "sane" defaults. |
|
||||
\*--------------------------------------------------------------------*/
|
||||
Channel channel1;
|
||||
channel1.index = 0;
|
||||
channel1.anyFanCountOffset = UNIHUB_AL10_ANY_C1_FAN_COUNT_OFFSET;
|
||||
channel1.anyFanCount = UNIHUB_AL10_ANY_FAN_COUNT_001;
|
||||
channel1.ledActionAddress = UNIHUB_AL10_LED_C1_ACTION_ADDRESS;
|
||||
channel1.ledCommitAddress = UNIHUB_AL10_LED_C1_COMMIT_ADDRESS;
|
||||
channel1.ledModeAddress = UNIHUB_AL10_LED_C1_MODE_ADDRESS;
|
||||
channel1.ledSpeedAddress = UNIHUB_AL10_LED_C1_SPEED_ADDRESS;
|
||||
channel1.ledDirectionAddress = UNIHUB_AL10_LED_C1_DIRECTION_ADDRESS;
|
||||
channel1.ledBrightnessAddress = UNIHUB_AL10_LED_C1_BRIGHTNESS_ADDRESS;
|
||||
channel1.ledMode = UNIHUB_AL10_LED_MODE_RAINBOW;
|
||||
channel1.ledSpeed = UNIHUB_AL10_LED_SPEED_100;
|
||||
channel1.ledDirection = UNIHUB_AL10_LED_DIRECTION_LTR;
|
||||
channel1.ledBrightness = UNIHUB_AL10_LED_BRIGHTNESS_100;
|
||||
channel1.fanHubActionAddress = UNIHUB_AL10_FAN_C1_HUB_ACTION_ADDRESS;
|
||||
channel1.fanHubCommitAddress = UNIHUB_AL10_FAN_C1_HUB_COMMIT_ADDRESS;
|
||||
channel1.fanPwmActionAddress = UNIHUB_AL10_FAN_C1_PWM_ACTION_ADDRESS;
|
||||
channel1.fanPwmCommitAddress = UNIHUB_AL10_FAN_C1_PWM_COMMIT_ADDRESS;
|
||||
channel1.fanRpmActionAddress = UNIHUB_AL10_FAN_C1_RPM_ACTION_ADDRESS;
|
||||
channel1.fanSpeed = UNIHUB_AL10_FAN_SPEED_QUIET;
|
||||
channels[0] = channel1;
|
||||
|
||||
Channel channel2;
|
||||
channel2.index = 1;
|
||||
channel2.anyFanCountOffset = UNIHUB_AL10_ANY_C2_FAN_COUNT_OFFSET;
|
||||
channel2.anyFanCount = UNIHUB_AL10_ANY_FAN_COUNT_001;
|
||||
channel2.ledActionAddress = UNIHUB_AL10_LED_C2_ACTION_ADDRESS;
|
||||
channel2.ledCommitAddress = UNIHUB_AL10_LED_C2_COMMIT_ADDRESS;
|
||||
channel2.ledModeAddress = UNIHUB_AL10_LED_C2_MODE_ADDRESS;
|
||||
channel2.ledSpeedAddress = UNIHUB_AL10_LED_C2_SPEED_ADDRESS;
|
||||
channel2.ledDirectionAddress = UNIHUB_AL10_LED_C2_DIRECTION_ADDRESS;
|
||||
channel2.ledBrightnessAddress = UNIHUB_AL10_LED_C2_BRIGHTNESS_ADDRESS;
|
||||
channel2.ledMode = UNIHUB_AL10_LED_MODE_RAINBOW;
|
||||
channel2.ledSpeed = UNIHUB_AL10_LED_SPEED_100;
|
||||
channel2.ledDirection = UNIHUB_AL10_LED_DIRECTION_LTR;
|
||||
channel2.ledBrightness = UNIHUB_AL10_LED_BRIGHTNESS_100;
|
||||
channel2.fanHubActionAddress = UNIHUB_AL10_FAN_C2_HUB_ACTION_ADDRESS;
|
||||
channel2.fanHubCommitAddress = UNIHUB_AL10_FAN_C2_HUB_COMMIT_ADDRESS;
|
||||
channel2.fanPwmActionAddress = UNIHUB_AL10_FAN_C2_PWM_ACTION_ADDRESS;
|
||||
channel2.fanPwmCommitAddress = UNIHUB_AL10_FAN_C2_PWM_COMMIT_ADDRESS;
|
||||
channel2.fanRpmActionAddress = UNIHUB_AL10_FAN_C2_RPM_ACTION_ADDRESS;
|
||||
channel2.fanSpeed = UNIHUB_AL10_FAN_SPEED_QUIET;
|
||||
channels[1] = channel2;
|
||||
|
||||
Channel channel3;
|
||||
channel3.index = 2;
|
||||
channel3.anyFanCountOffset = UNIHUB_AL10_ANY_C3_FAN_COUNT_OFFSET;
|
||||
channel3.anyFanCount = UNIHUB_AL10_ANY_FAN_COUNT_001;
|
||||
channel3.ledActionAddress = UNIHUB_AL10_LED_C3_ACTION_ADDRESS;
|
||||
channel3.ledCommitAddress = UNIHUB_AL10_LED_C3_COMMIT_ADDRESS;
|
||||
channel3.ledModeAddress = UNIHUB_AL10_LED_C3_MODE_ADDRESS;
|
||||
channel3.ledSpeedAddress = UNIHUB_AL10_LED_C3_SPEED_ADDRESS;
|
||||
channel3.ledDirectionAddress = UNIHUB_AL10_LED_C3_DIRECTION_ADDRESS;
|
||||
channel3.ledBrightnessAddress = UNIHUB_AL10_LED_C3_BRIGHTNESS_ADDRESS;
|
||||
channel3.ledMode = UNIHUB_AL10_LED_MODE_RAINBOW;
|
||||
channel3.ledSpeed = UNIHUB_AL10_LED_SPEED_100;
|
||||
channel3.ledDirection = UNIHUB_AL10_LED_DIRECTION_LTR;
|
||||
channel3.ledBrightness = UNIHUB_AL10_LED_BRIGHTNESS_100;
|
||||
channel3.fanHubActionAddress = UNIHUB_AL10_FAN_C3_HUB_ACTION_ADDRESS;
|
||||
channel3.fanHubCommitAddress = UNIHUB_AL10_FAN_C3_HUB_COMMIT_ADDRESS;
|
||||
channel3.fanPwmActionAddress = UNIHUB_AL10_FAN_C3_PWM_ACTION_ADDRESS;
|
||||
channel3.fanPwmCommitAddress = UNIHUB_AL10_FAN_C3_PWM_COMMIT_ADDRESS;
|
||||
channel3.fanRpmActionAddress = UNIHUB_AL10_FAN_C3_RPM_ACTION_ADDRESS;
|
||||
channel3.fanSpeed = UNIHUB_AL10_FAN_SPEED_QUIET;
|
||||
channels[2] = channel3;
|
||||
|
||||
Channel channel4;
|
||||
channel4.index = 3;
|
||||
channel4.anyFanCountOffset = UNIHUB_AL10_ANY_C4_FAN_COUNT_OFFSET;
|
||||
channel4.anyFanCount = UNIHUB_AL10_ANY_FAN_COUNT_001;
|
||||
channel4.ledActionAddress = UNIHUB_AL10_LED_C4_ACTION_ADDRESS;
|
||||
channel4.ledCommitAddress = UNIHUB_AL10_LED_C4_COMMIT_ADDRESS;
|
||||
channel4.ledModeAddress = UNIHUB_AL10_LED_C4_MODE_ADDRESS;
|
||||
channel4.ledSpeedAddress = UNIHUB_AL10_LED_C4_SPEED_ADDRESS;
|
||||
channel4.ledDirectionAddress = UNIHUB_AL10_LED_C4_DIRECTION_ADDRESS;
|
||||
channel4.ledBrightnessAddress = UNIHUB_AL10_LED_C4_BRIGHTNESS_ADDRESS;
|
||||
channel4.ledMode = UNIHUB_AL10_LED_MODE_RAINBOW;
|
||||
channel4.ledSpeed = UNIHUB_AL10_LED_SPEED_100;
|
||||
channel4.ledDirection = UNIHUB_AL10_LED_DIRECTION_LTR;
|
||||
channel4.ledBrightness = UNIHUB_AL10_LED_BRIGHTNESS_100;
|
||||
channel4.fanHubActionAddress = UNIHUB_AL10_FAN_C4_HUB_ACTION_ADDRESS;
|
||||
channel4.fanHubCommitAddress = UNIHUB_AL10_FAN_C4_HUB_COMMIT_ADDRESS;
|
||||
channel4.fanPwmActionAddress = UNIHUB_AL10_FAN_C4_PWM_ACTION_ADDRESS;
|
||||
channel4.fanPwmCommitAddress = UNIHUB_AL10_FAN_C4_PWM_COMMIT_ADDRESS;
|
||||
channel4.fanRpmActionAddress = UNIHUB_AL10_FAN_C4_RPM_ACTION_ADDRESS;
|
||||
channel4.fanSpeed = UNIHUB_AL10_FAN_SPEED_QUIET;
|
||||
channels[3] = channel4;
|
||||
}
|
||||
|
||||
LianLiUniHub_AL10Controller::~LianLiUniHub_AL10Controller()
|
||||
{
|
||||
CloseLibusb();
|
||||
}
|
||||
|
||||
std::string LianLiUniHub_AL10Controller::GetVersion()
|
||||
{
|
||||
return version;
|
||||
}
|
||||
|
||||
std::string LianLiUniHub_AL10Controller::GetLocation()
|
||||
{
|
||||
return location;
|
||||
}
|
||||
|
||||
std::string LianLiUniHub_AL10Controller::GetSerial()
|
||||
{
|
||||
return serial;
|
||||
}
|
||||
|
||||
void LianLiUniHub_AL10Controller::SetAnyFanCount(size_t channel, uint8_t count)
|
||||
{
|
||||
/*-------------------------------------*\
|
||||
| Check for invalid channel |
|
||||
\*-------------------------------------*/
|
||||
if(channel >= UNIHUB_AL10_CHANNEL_COUNT)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
channels[channel].anyFanCount = count;
|
||||
}
|
||||
|
||||
void LianLiUniHub_AL10Controller::SetLedColors(size_t channel, RGBColor* colors, size_t count)
|
||||
{
|
||||
/*-------------------------------------*\
|
||||
| Check for invalid channel |
|
||||
\*-------------------------------------*/
|
||||
if(channel >= UNIHUB_AL10_CHANNEL_COUNT)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
/*-------------------------------------*\
|
||||
| Check for invalid count |
|
||||
\*-------------------------------------*/
|
||||
if(count > UNIHUB_AL10_CHANLED_COUNT)
|
||||
{
|
||||
count = UNIHUB_AL10_CHANLED_COUNT;
|
||||
}
|
||||
|
||||
/*-------------------------------------*\
|
||||
| Check for mode colors |
|
||||
\*-------------------------------------*/
|
||||
size_t i = 0;
|
||||
switch(channels[channel].ledMode)
|
||||
{
|
||||
case UNIHUB_AL10_LED_MODE_RAINBOW:
|
||||
channels[channel].colors[0].r = 0xFC;
|
||||
channels[channel].colors[0].b = 0xFC;
|
||||
channels[channel].colors[0].g = 0xFC;
|
||||
i = 1;
|
||||
break;
|
||||
case UNIHUB_AL10_LED_MODE_BREATHING:
|
||||
for(unsigned int color_idx = 0; color_idx < count; color_idx++)
|
||||
{
|
||||
for(unsigned int led_idx = 0; led_idx < 20; led_idx++)
|
||||
{
|
||||
channels[channel].colors[led_idx + (color_idx * 20)].r = RGBGetRValue(colors[color_idx]);
|
||||
channels[channel].colors[led_idx + (color_idx * 20)].b = RGBGetBValue(colors[color_idx]);
|
||||
channels[channel].colors[led_idx + (color_idx * 20)].g = RGBGetGValue(colors[color_idx]);
|
||||
i++;
|
||||
}
|
||||
}
|
||||
break;
|
||||
case UNIHUB_AL10_LED_MODE_SCAN:
|
||||
for(; i < 20; i++)
|
||||
{
|
||||
channels[channel].colors[i].r = 0x00;
|
||||
channels[channel].colors[i].b = 0x00;
|
||||
channels[channel].colors[i].g = 0x00;
|
||||
}
|
||||
|
||||
channels[channel].colors[0x00].r = RGBGetRValue(colors[0]);
|
||||
channels[channel].colors[0x00].b = RGBGetBValue(colors[0]);
|
||||
channels[channel].colors[0x00].g = RGBGetGValue(colors[0]);
|
||||
|
||||
channels[channel].colors[0x08].r = RGBGetRValue(colors[1]);
|
||||
channels[channel].colors[0x08].b = RGBGetBValue(colors[1]);
|
||||
channels[channel].colors[0x08].g = RGBGetGValue(colors[1]);
|
||||
|
||||
break;
|
||||
default:
|
||||
for(; i < count; i++)
|
||||
{
|
||||
channels[channel].colors[i].r = (RGBGetRValue(colors[i]));
|
||||
channels[channel].colors[i].b = (RGBGetBValue(colors[i]));
|
||||
channels[channel].colors[i].g = (RGBGetGValue(colors[i]));
|
||||
|
||||
// Limiter to protect LEDs
|
||||
if(UNIHUB_AL10_LED_LIMITER && (channels[channel].colors[i].r > 153) && (channels[channel].colors[i].r == channels[channel].colors[i].b) && (channels[channel].colors[i].r == channels[channel].colors[i].g))
|
||||
{
|
||||
channels[channel].colors[i].r = 153;
|
||||
channels[channel].colors[i].b = 153;
|
||||
channels[channel].colors[i].g = 153;
|
||||
}
|
||||
}
|
||||
}
|
||||
/* Set all remaining leds to black */
|
||||
for(; i < UNIHUB_AL10_CHANLED_COUNT; i++)
|
||||
{
|
||||
channels[channel].colors[i].r = 0x00;
|
||||
channels[channel].colors[i].b = 0x00;
|
||||
channels[channel].colors[i].g = 0x00;
|
||||
}
|
||||
|
||||
|
||||
|
||||
}
|
||||
|
||||
void LianLiUniHub_AL10Controller::SetLedMode(size_t channel, uint8_t mode)
|
||||
{
|
||||
/*-------------------------------------*\
|
||||
| Check for invalid channel |
|
||||
\*-------------------------------------*/
|
||||
if(channel >= UNIHUB_AL10_CHANNEL_COUNT)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
channels[channel].ledMode = mode;
|
||||
}
|
||||
|
||||
void LianLiUniHub_AL10Controller::SetLedSpeed(size_t channel, uint8_t speed)
|
||||
{
|
||||
/*-------------------------------------*\
|
||||
| Check for invalid channel |
|
||||
\*-------------------------------------*/
|
||||
if(channel >= UNIHUB_AL10_CHANNEL_COUNT)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
channels[channel].ledSpeed = speed;
|
||||
}
|
||||
|
||||
void LianLiUniHub_AL10Controller::SetLedDirection(size_t channel, uint8_t direction)
|
||||
{
|
||||
/*-------------------------------------*\
|
||||
| Check for invalid channel |
|
||||
\*-------------------------------------*/
|
||||
if(channel >= UNIHUB_AL10_CHANNEL_COUNT)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
channels[channel].ledDirection = direction;
|
||||
}
|
||||
|
||||
void LianLiUniHub_AL10Controller::SetLedBrightness(size_t channel, uint8_t brightness)
|
||||
{
|
||||
/*-------------------------------------*\
|
||||
| Check for invalid channel |
|
||||
\*-------------------------------------*/
|
||||
if(channel >= UNIHUB_AL10_CHANNEL_COUNT)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
channels[channel].ledBrightness = brightness;
|
||||
}
|
||||
|
||||
uint16_t LianLiUniHub_AL10Controller::GetFanSpeed(size_t channel)
|
||||
{
|
||||
/*-------------------------------------*\
|
||||
| Check for invalid channel |
|
||||
\*-------------------------------------*/
|
||||
if(channel >= UNIHUB_AL10_CHANNEL_COUNT)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
return channels[channel].fanSpeed;
|
||||
}
|
||||
|
||||
void LianLiUniHub_AL10Controller::SetFanSpeed(size_t channel, uint16_t speed)
|
||||
{
|
||||
/*-------------------------------------*\
|
||||
| Check for invalid channel |
|
||||
\*-------------------------------------*/
|
||||
if(channel >= UNIHUB_AL10_CHANNEL_COUNT)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
channels[channel].fanSpeed = speed;
|
||||
}
|
||||
|
||||
void LianLiUniHub_AL10Controller::EnableRgbhMode()
|
||||
{
|
||||
rgbhModeEnabled = true;
|
||||
}
|
||||
|
||||
void LianLiUniHub_AL10Controller::DisableRgbhMode()
|
||||
{
|
||||
rgbhModeEnabled = false;
|
||||
}
|
||||
|
||||
void LianLiUniHub_AL10Controller::EnableSyncMode()
|
||||
{
|
||||
syncModeEnabled = true;
|
||||
}
|
||||
|
||||
void LianLiUniHub_AL10Controller::DisableSyncMode()
|
||||
{
|
||||
syncModeEnabled = false;
|
||||
}
|
||||
|
||||
/*----------------------------------------------------------------------------*\
|
||||
| The Uni Hub is a PWM and LED controller designed specifically for the Lian |
|
||||
| Li Uni Fans. It can control them by itself using the built-in effect engine |
|
||||
| can also be connected to the mainboard via 4-pin PWM and 3-pin RGB cables |
|
||||
| and forward these signals. The protocol implementation below was build as |
|
||||
| close a possible to the Lian Li L-Connect software. |
|
||||
| |
|
||||
| The commands to control the fan speeds and to switch between controller and |
|
||||
| mainboard control is already included, but currently deactivated as OpenRGB |
|
||||
| had no fan control module or controller specific configuration at the time |
|
||||
| of writing. |
|
||||
\*----------------------------------------------------------------------------*/
|
||||
void LianLiUniHub_AL10Controller::Synchronize()
|
||||
{
|
||||
/*---------------------------------------------------------------------*\
|
||||
| Configure common settings. |
|
||||
\*---------------------------------------------------------------------*/
|
||||
|
||||
/*---------------------------------------------------------------------*\
|
||||
| Still unsure about this. Probably some sort of configuration |
|
||||
| initialization |
|
||||
\*---------------------------------------------------------------------*/
|
||||
uint8_t config_initialization[16];
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Zero out buffer |
|
||||
\*-----------------------------------------------------*/
|
||||
memset(config_initialization, 0x00, sizeof(config_initialization));
|
||||
|
||||
config_initialization[0x0F] = 0x43; // Control data
|
||||
config_initialization[0x0F] = 0x01; // Ending data
|
||||
|
||||
SendConfig(UNIHUB_AL10_ACTION_ADDRESS, config_initialization, sizeof(config_initialization));
|
||||
|
||||
for(const Channel& channel : channels)
|
||||
{
|
||||
/*-------------------------------------*\
|
||||
| The Uni Hub doesn't know zero fans |
|
||||
\*-------------------------------------*/
|
||||
uint8_t anyFanCount = channel.anyFanCount;
|
||||
|
||||
if(anyFanCount == UNIHUB_AL10_ANY_FAN_COUNT_000)
|
||||
{
|
||||
anyFanCount = UNIHUB_AL10_ANY_FAN_COUNT_001;
|
||||
}
|
||||
|
||||
/*-------------------------------------*\
|
||||
| Configure the physical fan count |
|
||||
\*-------------------------------------*/
|
||||
uint8_t config_fan_count[16];
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Zero out buffer |
|
||||
\*-----------------------------------------------------*/
|
||||
memset(config_fan_count, 0x00, sizeof(config_fan_count));
|
||||
|
||||
config_fan_count[0x01] = 0x40; // Control data
|
||||
config_fan_count[0x02] = channel.index + 1; // Channel
|
||||
config_fan_count[0x03] = anyFanCount + 1; // Number of fans
|
||||
config_fan_count[0x0F] = 0x01; // Ending data
|
||||
|
||||
SendConfig(UNIHUB_AL10_ACTION_ADDRESS, config_fan_count, sizeof(config_fan_count));
|
||||
//SendCommit(UNIHUB_AL10_COMMIT_ADDRESS);
|
||||
}
|
||||
|
||||
/*--------------------------------------------------------------------*\
|
||||
| Configure channels for sync effects |
|
||||
\*--------------------------------------------------------------------*/
|
||||
|
||||
/*
|
||||
if(syncModeEnabled)
|
||||
{
|
||||
uint8_t config_sync[6];
|
||||
uint8_t config_sync_index = 0;
|
||||
|
||||
config_sync[config_sync_index++] = 0x33;
|
||||
|
||||
for(const Channel& channel : channels)
|
||||
{
|
||||
if(channel.anyFanCount != UNIHUB_AL10_ANY_FAN_COUNT_000)
|
||||
{
|
||||
config_sync[config_sync_index++] = channel.index;
|
||||
}
|
||||
}
|
||||
|
||||
config_sync[config_sync_index++] = 0x08;
|
||||
|
||||
SendConfig(UNIHUB_AL10_ACTION_ADDRESS, config_sync, config_sync_index);
|
||||
SendCommit(UNIHUB_AL10_COMMIT_ADDRESS);
|
||||
}
|
||||
|
||||
*/
|
||||
|
||||
/*--------------------------------------------------------------------*\
|
||||
| Configure led settings. |
|
||||
\*--------------------------------------------------------------------*/
|
||||
for(const Channel& channel : channels)
|
||||
{
|
||||
if(channel.anyFanCount != UNIHUB_AL10_ANY_FAN_COUNT_000)
|
||||
{
|
||||
for(unsigned int fan_idx = 0; fan_idx <= UNIHUB_AL10_ANY_FAN_COUNT_004; fan_idx++)
|
||||
{
|
||||
/*-----------------------------*\
|
||||
| Configure fan colors |
|
||||
\*-----------------------------*/
|
||||
uint8_t fan_config_colors[24];
|
||||
memcpy(fan_config_colors, channel.colors + (fan_idx * 20), sizeof(fan_config_colors));
|
||||
|
||||
SendConfig(channel.ledActionAddress + (60 * fan_idx), fan_config_colors, sizeof(fan_config_colors));
|
||||
}
|
||||
|
||||
/*-----------------------------*\
|
||||
| Configure led mode |
|
||||
\*-----------------------------*/
|
||||
uint8_t led_config[16];
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Zero out buffer |
|
||||
\*-----------------------------------------------------*/
|
||||
memset(led_config, 0x00, sizeof(led_config));
|
||||
|
||||
led_config[0x01] = channel.ledMode; // Effect
|
||||
led_config[0x02] = channel.ledSpeed; // Speed
|
||||
led_config[0x03] = channel.ledDirection; // Direction
|
||||
led_config[0x09] = channel.ledBrightness; // Brightness?
|
||||
led_config[0x0F] = 0x01; // Ending data
|
||||
|
||||
SendConfig(UNIHUB_AL10_ACTION_ADDRESS + (channel.index * 32 ), led_config, sizeof(led_config));
|
||||
|
||||
for(unsigned int fan_idx = 0; fan_idx <= UNIHUB_AL10_ANY_FAN_COUNT_004; fan_idx++)
|
||||
{
|
||||
/*-----------------------------*\
|
||||
| Configure rim colors |
|
||||
\*-----------------------------*/
|
||||
uint8_t rim_config_colors[36];
|
||||
memcpy(rim_config_colors, channel.colors + (fan_idx * 20) + 8, sizeof(rim_config_colors));
|
||||
|
||||
SendConfig(channel.ledActionAddress + 24 + (60 * fan_idx), rim_config_colors, sizeof(rim_config_colors));
|
||||
}
|
||||
|
||||
SendConfig(UNIHUB_AL10_ACTION_ADDRESS + 16 + (channel.index * 32 ), led_config, sizeof(led_config));
|
||||
}
|
||||
/*-----------------------------------------------------------------*\
|
||||
| The Uni Hub doesn't know zero fans so we set them to black |
|
||||
\*-----------------------------------------------------------------*/
|
||||
else
|
||||
{
|
||||
for(unsigned int fan_idx = 0; fan_idx <= UNIHUB_AL10_ANY_FAN_COUNT_004; fan_idx++)
|
||||
{
|
||||
/*-----------------------------*\
|
||||
| Configure fan colors |
|
||||
\*-----------------------------*/
|
||||
uint8_t fan_config_colors[24];
|
||||
memset(fan_config_colors, 0x00, sizeof(fan_config_colors));
|
||||
|
||||
SendConfig(channel.ledActionAddress + (60 * fan_idx), fan_config_colors, sizeof(fan_config_colors));
|
||||
}
|
||||
|
||||
/*-----------------------------*\
|
||||
| Configure led mode |
|
||||
\*-----------------------------*/
|
||||
uint8_t led_config[16];
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Zero out buffer |
|
||||
\*-----------------------------------------------------*/
|
||||
memset(led_config, 0x00, sizeof(led_config));
|
||||
|
||||
led_config[0x01] = UNIHUB_AL10_LED_MODE_STATIC_COLOR; // Effect
|
||||
led_config[0x02] = channel.ledSpeed; // Speed?
|
||||
led_config[0x03] = channel.ledDirection; // direction
|
||||
led_config[0x0F] = 0x01; // Ending data
|
||||
|
||||
SendConfig(UNIHUB_AL10_ACTION_ADDRESS + (channel.index * 32 ), led_config, sizeof(led_config));
|
||||
|
||||
for(unsigned int fan_idx = 0; fan_idx <= UNIHUB_AL10_ANY_FAN_COUNT_004; fan_idx++)
|
||||
{
|
||||
/*-----------------------------*\
|
||||
| Configure rim colors |
|
||||
\*-----------------------------*/
|
||||
uint8_t rim_config_colors[36];
|
||||
memset(rim_config_colors, 0x00, sizeof(rim_config_colors));
|
||||
|
||||
SendConfig(channel.ledActionAddress + 24 + (60 * fan_idx), rim_config_colors, sizeof(rim_config_colors));
|
||||
}
|
||||
|
||||
SendConfig(UNIHUB_AL10_ACTION_ADDRESS + 16 + (channel.index * 32 ), led_config, sizeof(led_config));
|
||||
}
|
||||
}
|
||||
|
||||
/*--------------------------------------------------------------------*\
|
||||
| Configure fan settings. Comment out until enabling fan control |
|
||||
\*--------------------------------------------------------------------*/
|
||||
// uint8_t control = 0;
|
||||
|
||||
/*-------------------------------------*\
|
||||
| Configure fan settings |
|
||||
\*-------------------------------------*/
|
||||
// for(const Channel& channel : channels)
|
||||
// {
|
||||
// if(channel.fanSpeed == UNIHUB_AL10_FAN_SPEED_PWM)
|
||||
// {
|
||||
/*-----------------------------*\
|
||||
| Configure the fan to pwm |
|
||||
| control |
|
||||
\*-----------------------------*/
|
||||
// uint8_t config_pwm[1] = { 0x00 };
|
||||
|
||||
// control |= (0x01 << channel.index);
|
||||
|
||||
// SendConfig(channel.fanPwmActionAddress, config_pwm, sizeof(config_pwm));
|
||||
// SendCommit(channel.fanPwmCommitAddress);
|
||||
// }
|
||||
// else
|
||||
// {
|
||||
/*-----------------------------*\
|
||||
| Configure the fan to hub |
|
||||
| control and set speed |
|
||||
\*-----------------------------*/
|
||||
// uint8_t config_hub[2] = { (uint8_t)(channel.fanSpeed >> 0x08), (uint8_t)(channel.fanSpeed & 0xFF) };
|
||||
|
||||
// SendConfig(channel.fanHubActionAddress, config_hub, sizeof(config_hub));
|
||||
// SendCommit(channel.fanHubCommitAddress);
|
||||
// }
|
||||
// }
|
||||
|
||||
/*-------------------------------------*\
|
||||
| Configure fan control modes |
|
||||
\*-------------------------------------*/
|
||||
// uint8_t config_fan_mode[2] = { 0x31, (uint8_t)(0xF0 | control) };
|
||||
|
||||
// SendConfig(UNIHUB_AL10_ACTION_ADDRESS, config_fan_mode, sizeof(config_fan_mode));
|
||||
// SendCommit(UNIHUB_AL10_COMMIT_ADDRESS);
|
||||
|
||||
/*--------------------------------------------------------------------*\
|
||||
| Configure led settings. |
|
||||
\*--------------------------------------------------------------------*/
|
||||
// if(rgbhModeEnabled)
|
||||
// {
|
||||
/*-------------------------------------*\
|
||||
| Configure the leds to hdr control. |
|
||||
\*-------------------------------------*/
|
||||
// uint8_t config_hdr[2] = { 0x30, 0x01 };
|
||||
|
||||
// SendConfig(UNIHUB_AL10_ACTION_ADDRESS, config_hdr, sizeof(config_hdr));
|
||||
// SendCommit(UNIHUB_AL10_COMMIT_ADDRESS);
|
||||
// }
|
||||
// else
|
||||
// {
|
||||
/*-------------------------------------*\
|
||||
| Configure the leds to hub control |
|
||||
\*-------------------------------------*/
|
||||
// uint8_t config_hub[2] = { 0x30, 0x00 };
|
||||
|
||||
// SendConfig(UNIHUB_AL10_ACTION_ADDRESS, config_hub, sizeof(config_hub));
|
||||
// SendCommit(UNIHUB_AL10_COMMIT_ADDRESS);
|
||||
// }
|
||||
}
|
||||
|
||||
uint16_t LianLiUniHub_AL10Controller::ReadFanSpeed(size_t channel)
|
||||
{
|
||||
/*-------------------------------------*\
|
||||
| Check for invalid handle |
|
||||
\*-------------------------------------*/
|
||||
if(handle == nullptr)
|
||||
{
|
||||
return(0);
|
||||
}
|
||||
|
||||
/*-------------------------------------*\
|
||||
| Check for invalid channel |
|
||||
\*-------------------------------------*/
|
||||
if(channel > UNIHUB_AL10_CHANNEL_COUNT)
|
||||
{
|
||||
return(0);
|
||||
}
|
||||
|
||||
uint8_t buffer[2];
|
||||
uint8_t length = sizeof(buffer);
|
||||
|
||||
uint16_t wIndex = channels[channel].fanRpmActionAddress;
|
||||
|
||||
/*-------------------------------------*\
|
||||
| Send packet |
|
||||
\*-------------------------------------*/
|
||||
size_t ret = libusb_control_transfer(handle, /* dev_handle */
|
||||
0xC0, /* bmRequestType */
|
||||
0x81, /* bRequest */
|
||||
0x00, /* wValue */
|
||||
wIndex, /* wIndex */
|
||||
buffer, /* data */
|
||||
length, /* wLength */
|
||||
1000); /* timeout */
|
||||
|
||||
/*-------------------------------------*\
|
||||
| Check for communication error |
|
||||
\*-------------------------------------*/
|
||||
if(ret != length)
|
||||
{
|
||||
return(0);
|
||||
}
|
||||
|
||||
return(*(uint16_t*)buffer);
|
||||
}
|
||||
|
||||
void LianLiUniHub_AL10Controller::CloseLibusb()
|
||||
{
|
||||
if (handle != nullptr)
|
||||
{
|
||||
libusb_close(handle);
|
||||
handle = nullptr;
|
||||
}
|
||||
}
|
||||
|
||||
std::string LianLiUniHub_AL10Controller::ReadVersion()
|
||||
{
|
||||
/*-------------------------------------*\
|
||||
| Check for invalid handle |
|
||||
\*-------------------------------------*/
|
||||
if(handle == nullptr)
|
||||
{
|
||||
return("");
|
||||
}
|
||||
|
||||
uint8_t buffer[5];
|
||||
uint8_t length = sizeof(buffer);
|
||||
|
||||
/*-------------------------------------*\
|
||||
| Send packet |
|
||||
\*-------------------------------------*/
|
||||
size_t ret = libusb_control_transfer(handle, /* dev_handle */
|
||||
0xC0, /* bmRequestType */
|
||||
0x81, /* bRequest */
|
||||
0x00, /* wValue */
|
||||
0xB500, /* wIndex */
|
||||
buffer, /* data */
|
||||
length, /* wLength */
|
||||
1000); /* timeout */
|
||||
|
||||
/*-------------------------------------*\
|
||||
| Check for communication error |
|
||||
\*-------------------------------------*/
|
||||
if(ret != length)
|
||||
{
|
||||
return("");
|
||||
}
|
||||
|
||||
/*-------------------------------------*\
|
||||
| Format version string |
|
||||
\*-------------------------------------*/
|
||||
char version[15];
|
||||
int vlength = std::snprintf(version, sizeof(version), "%x.%x.%x.%x.%x", buffer[0], buffer[1], buffer[2], buffer[3], buffer[4]);
|
||||
|
||||
return(std::string(version, vlength));
|
||||
}
|
||||
|
||||
void LianLiUniHub_AL10Controller::SendConfig(uint16_t wIndex, uint8_t *config, size_t length)
|
||||
{
|
||||
/*-------------------------------------*\
|
||||
| Check for invalid handle |
|
||||
\*-------------------------------------*/
|
||||
if(handle == nullptr)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
/*-------------------------------------*\
|
||||
| Send packet |
|
||||
\*-------------------------------------*/
|
||||
size_t ret = libusb_control_transfer(handle, /* dev_handle */
|
||||
0x40, /* bmRequestType */
|
||||
0x80, /* bRequest */
|
||||
0x00, /* wValue */
|
||||
wIndex, /* wIndex */
|
||||
config, /* data */
|
||||
(uint16_t)length, /* wLength */
|
||||
1000); /* timeout */
|
||||
std::this_thread::sleep_for(5ms);
|
||||
/*-------------------------------------*\
|
||||
| Check for communication error |
|
||||
\*-------------------------------------*/
|
||||
if(ret != length)
|
||||
{
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
void LianLiUniHub_AL10Controller::SendCommit(uint16_t wIndex)
|
||||
{
|
||||
/*-------------------------------------*\
|
||||
| Set up config packet |
|
||||
\*-------------------------------------*/
|
||||
uint8_t config[1] = { 0x01 };
|
||||
|
||||
/*-------------------------------------*\
|
||||
| Send packet |
|
||||
\*-------------------------------------*/
|
||||
SendConfig(wIndex, config, sizeof(config));
|
||||
|
||||
std::this_thread::sleep_for(5ms);
|
||||
}
|
||||
+273
@@ -0,0 +1,273 @@
|
||||
/*---------------------------------------------------------*\
|
||||
| LianLiUniHub_AL10Controller.h |
|
||||
| |
|
||||
| Driver for Lian Li AL10 Uni Hub |
|
||||
| |
|
||||
| Oliver P 05 May 2022 |
|
||||
| Credit to Luca Lovisa for original work |
|
||||
| |
|
||||
| This file is part of the OpenRGB project |
|
||||
| SPDX-License-Identifier: GPL-2.0-or-later |
|
||||
\*---------------------------------------------------------*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <cstdint>
|
||||
#include <mutex>
|
||||
#include <string>
|
||||
#include <libusb.h>
|
||||
#include "RGBController.h"
|
||||
|
||||
/*----------------------------------------------------------------------------*\
|
||||
| Global definitions. |
|
||||
\*----------------------------------------------------------------------------*/
|
||||
|
||||
enum
|
||||
{
|
||||
UNIHUB_AL10_CHANNEL_COUNT = 0x04, /* Channel count */
|
||||
UNIHUB_AL10_CHANLED_COUNT = 0x50, /* Max-LED per channel count */
|
||||
};
|
||||
|
||||
enum
|
||||
{
|
||||
UNIHUB_AL10_ACTION_ADDRESS = 0xE020, /* Global action address */
|
||||
UNIHUB_AL10_COMMIT_ADDRESS = 0xE02F, /* Global commit address */
|
||||
};
|
||||
|
||||
enum
|
||||
{
|
||||
UNIHUB_AL10_ANY_C1_FAN_COUNT_OFFSET = 0x00, /* Channel 1 fan count offset */
|
||||
UNIHUB_AL10_ANY_C2_FAN_COUNT_OFFSET = 0x14, /* Channel 2 fan count offset */
|
||||
UNIHUB_AL10_ANY_C3_FAN_COUNT_OFFSET = 0x28, /* Channel 3 fan count offset */
|
||||
UNIHUB_AL10_ANY_C4_FAN_COUNT_OFFSET = 0x3C, /* Channel 4 fan count offset */
|
||||
};
|
||||
|
||||
enum
|
||||
{
|
||||
UNIHUB_AL10_ANY_FAN_COUNT_000 = 0xFF, /* Fan count for 0 fans (dummy value) */
|
||||
UNIHUB_AL10_ANY_FAN_COUNT_001 = 0x00, /* Fan count for 1 fan */
|
||||
UNIHUB_AL10_ANY_FAN_COUNT_002 = 0x01, /* Fan count for 2 fans */
|
||||
UNIHUB_AL10_ANY_FAN_COUNT_003 = 0x02, /* Fan count for 3 fans */
|
||||
UNIHUB_AL10_ANY_FAN_COUNT_004 = 0x03, /* Fan count for 4 fans */
|
||||
};
|
||||
|
||||
enum
|
||||
{
|
||||
UNIHUB_AL10_LED_LIMITER = 1, /* Limit the color white to 999999 as per manufacturer limits in v1.7 */
|
||||
};
|
||||
|
||||
/*----------------------------------------------------------------------------*\
|
||||
| Definitions related to led configuration. |
|
||||
\*----------------------------------------------------------------------------*/
|
||||
|
||||
enum
|
||||
{
|
||||
UNIHUB_AL10_LED_C1_ACTION_ADDRESS = 0xE500, /* Channel 1 led action address */
|
||||
UNIHUB_AL10_LED_C1_COMMIT_ADDRESS = 0xE02F, /* Channel 1 led commit address */
|
||||
UNIHUB_AL10_LED_C1_MODE_ADDRESS = 0xE021, /* Channel 1 led mode address */
|
||||
UNIHUB_AL10_LED_C1_SPEED_ADDRESS = 0xE022, /* Channel 1 led speed address */
|
||||
UNIHUB_AL10_LED_C1_DIRECTION_ADDRESS = 0xE023, /* Channel 1 led direction address */
|
||||
UNIHUB_AL10_LED_C1_BRIGHTNESS_ADDRESS = 0xE029, /* Channel 1 led brightness address */
|
||||
|
||||
UNIHUB_AL10_LED_C2_ACTION_ADDRESS = 0xE5F0, /* Channel 2 led action address */
|
||||
UNIHUB_AL10_LED_C2_COMMIT_ADDRESS = 0xE03F, /* Channel 2 led commit address */
|
||||
UNIHUB_AL10_LED_C2_MODE_ADDRESS = 0xE031, /* Channel 2 led mode address */
|
||||
UNIHUB_AL10_LED_C2_SPEED_ADDRESS = 0xE032, /* Channel 2 led speed address */
|
||||
UNIHUB_AL10_LED_C2_DIRECTION_ADDRESS = 0xE033, /* Channel 2 led direction address */
|
||||
UNIHUB_AL10_LED_C2_BRIGHTNESS_ADDRESS = 0xE039, /* Channel 2 led brightness address */
|
||||
|
||||
UNIHUB_AL10_LED_C3_ACTION_ADDRESS = 0xE6E0, /* Channel 3 led action address */
|
||||
UNIHUB_AL10_LED_C3_COMMIT_ADDRESS = 0xE04F, /* Channel 3 led commit address */
|
||||
UNIHUB_AL10_LED_C3_MODE_ADDRESS = 0xE041, /* Channel 3 led mode address */
|
||||
UNIHUB_AL10_LED_C3_SPEED_ADDRESS = 0xE042, /* Channel 3 led speed address */
|
||||
UNIHUB_AL10_LED_C3_DIRECTION_ADDRESS = 0xE043, /* Channel 3 led direction address */
|
||||
UNIHUB_AL10_LED_C3_BRIGHTNESS_ADDRESS = 0xE049, /* Channel 3 led brightness address */
|
||||
|
||||
UNIHUB_AL10_LED_C4_ACTION_ADDRESS = 0xE7D0, /* Channel 4 led action address */
|
||||
UNIHUB_AL10_LED_C4_COMMIT_ADDRESS = 0xE05F, /* Channel 4 led commit address */
|
||||
UNIHUB_AL10_LED_C4_MODE_ADDRESS = 0xE051, /* Channel 4 led mode address */
|
||||
UNIHUB_AL10_LED_C4_SPEED_ADDRESS = 0xE052, /* Channel 4 led speed address */
|
||||
UNIHUB_AL10_LED_C4_DIRECTION_ADDRESS = 0xE053, /* Channel 4 led direction address */
|
||||
UNIHUB_AL10_LED_C4_BRIGHTNESS_ADDRESS = 0xE059, /* Channel 4 led brightness address */
|
||||
};
|
||||
|
||||
enum
|
||||
{
|
||||
UNIHUB_AL10_LED_MODE_RAINBOW = 0x05, /* Rainbow mode */
|
||||
UNIHUB_AL10_LED_MODE_RAINBOW_MORPH = 0xFF, /* Runway mode - Needs updated code */
|
||||
UNIHUB_AL10_LED_MODE_STATIC_COLOR = 0x01, /* Static Color mode */
|
||||
UNIHUB_AL10_LED_MODE_BREATHING = 0x02, /* Breathing mode */
|
||||
UNIHUB_AL10_LED_MODE_TAICHI = 0x2C, /* Neon mode */
|
||||
UNIHUB_AL10_LED_MODE_COLOR_CYCLE = 0x2B, /* Color Cycle mode */
|
||||
UNIHUB_AL10_LED_MODE_RUNWAY = 0xFF, /* Runway mode - Needs updated code */
|
||||
UNIHUB_AL10_LED_MODE_METEOR = 0xFF, /* Meteor mode - Needs updated code */
|
||||
UNIHUB_AL10_LED_MODE_WARNING = 0x2D, /* Warning mode */
|
||||
UNIHUB_AL10_LED_MODE_VOICE = 0x22, /* Voice mode */
|
||||
UNIHUB_AL10_LED_MODE_SPINNING_TEACUP = 0x36, /* Spinning Teacup mode */
|
||||
UNIHUB_AL10_LED_MODE_TORNADO = 0x34, /* Tornado mode */
|
||||
UNIHUB_AL10_LED_MODE_MIXING = 0x23, /* Mixing mode */
|
||||
UNIHUB_AL10_LED_MODE_STACK = 0xFF, /* Stack mode - Needs updated code */
|
||||
UNIHUB_AL10_LED_MODE_STAGGGERED = 0x35, /* Stagggered mode */
|
||||
UNIHUB_AL10_LED_MODE_TIDE = 0x25, /* Tide mode */
|
||||
UNIHUB_AL10_LED_MODE_SCAN = 0x26, /* Scan mode */
|
||||
UNIHUB_AL10_LED_MODE_CONTEST = 0x33, /* Contest mode */
|
||||
};
|
||||
|
||||
enum
|
||||
{
|
||||
UNIHUB_AL10_LED_SPEED_000 = 0x02, /* Very slow speed */
|
||||
UNIHUB_AL10_LED_SPEED_025 = 0x01, /* Rather slow speed */
|
||||
UNIHUB_AL10_LED_SPEED_050 = 0x00, /* Medium speed */
|
||||
UNIHUB_AL10_LED_SPEED_075 = 0xFF, /* Rather fast speed */
|
||||
UNIHUB_AL10_LED_SPEED_100 = 0xFE, /* Very fast speed */
|
||||
};
|
||||
|
||||
enum
|
||||
{
|
||||
UNIHUB_AL10_LED_DIRECTION_LTR = 0x00, /* Left-to-Right direction */
|
||||
UNIHUB_AL10_LED_DIRECTION_RTL = 0x01, /* Right-to-Left direction */
|
||||
};
|
||||
|
||||
enum
|
||||
{
|
||||
UNIHUB_AL10_LED_BRIGHTNESS_000 = 0x08, /* Very dark (off) */
|
||||
UNIHUB_AL10_LED_BRIGHTNESS_025 = 0x03, /* Rather dark */
|
||||
UNIHUB_AL10_LED_BRIGHTNESS_050 = 0x02, /* Medium bright */
|
||||
UNIHUB_AL10_LED_BRIGHTNESS_075 = 0x01, /* Rather bright */
|
||||
UNIHUB_AL10_LED_BRIGHTNESS_100 = 0x00, /* Very bright */
|
||||
};
|
||||
|
||||
/*----------------------------------------------------------------------------*\
|
||||
| Definitions related to fan configuration. |
|
||||
\*----------------------------------------------------------------------------*/
|
||||
|
||||
enum
|
||||
{
|
||||
UNIHUB_AL10_FAN_C1_HUB_ACTION_ADDRESS = 0xE8A0, /* Channel 1 fan action address for hub control */
|
||||
UNIHUB_AL10_FAN_C1_HUB_COMMIT_ADDRESS = 0xE890, /* Channel 1 fan commit address for hub control */
|
||||
UNIHUB_AL10_FAN_C1_PWM_ACTION_ADDRESS = 0xE890, /* Channel 1 fan action address for pwm control */
|
||||
UNIHUB_AL10_FAN_C1_PWM_COMMIT_ADDRESS = 0xE818, /* Channel 1 fan commit address for pwm control */
|
||||
UNIHUB_AL10_FAN_C1_RPM_ACTION_ADDRESS = 0xE800, /* Channel 1 fan pwm read address */
|
||||
|
||||
UNIHUB_AL10_FAN_C2_HUB_ACTION_ADDRESS = 0xE8A2, /* Channel 2 fan action address for hub control */
|
||||
UNIHUB_AL10_FAN_C2_HUB_COMMIT_ADDRESS = 0xE891, /* Channel 2 fan commit address for hub control */
|
||||
UNIHUB_AL10_FAN_C2_PWM_ACTION_ADDRESS = 0xE891, /* Channel 2 fan action address for pwm control */
|
||||
UNIHUB_AL10_FAN_C2_PWM_COMMIT_ADDRESS = 0xE81A, /* Channel 2 fan commit address for pwm control */
|
||||
UNIHUB_AL10_FAN_C2_RPM_ACTION_ADDRESS = 0xE802, /* Channel 1 fan pwm read address */
|
||||
|
||||
UNIHUB_AL10_FAN_C3_HUB_ACTION_ADDRESS = 0xE8A4, /* Channel 3 fan action address for hub control */
|
||||
UNIHUB_AL10_FAN_C3_HUB_COMMIT_ADDRESS = 0xE892, /* Channel 3 fan commit address for hub control */
|
||||
UNIHUB_AL10_FAN_C3_PWM_ACTION_ADDRESS = 0xE892, /* Channel 3 fan action address for pwm control */
|
||||
UNIHUB_AL10_FAN_C3_PWM_COMMIT_ADDRESS = 0xE81C, /* Channel 3 fan commit address for pwm control */
|
||||
UNIHUB_AL10_FAN_C3_RPM_ACTION_ADDRESS = 0xE804, /* Channel 1 fan pwm read address */
|
||||
|
||||
UNIHUB_AL10_FAN_C4_HUB_ACTION_ADDRESS = 0xE8A6, /* Channel 4 fan action address for hub control */
|
||||
UNIHUB_AL10_FAN_C4_HUB_COMMIT_ADDRESS = 0xE893, /* Channel 4 fan commit address for hub control */
|
||||
UNIHUB_AL10_FAN_C4_PWM_ACTION_ADDRESS = 0xE893, /* Channel 4 fan action address for pwm control */
|
||||
UNIHUB_AL10_FAN_C4_PWM_COMMIT_ADDRESS = 0xE81E, /* Channel 4 fan commit address for pwm control */
|
||||
UNIHUB_AL10_FAN_C4_RPM_ACTION_ADDRESS = 0xE806, /* Channel 1 fan pwm read address */
|
||||
};
|
||||
|
||||
enum
|
||||
{
|
||||
UNIHUB_AL10_FAN_SPEED_QUIET = 0x2003, /* Rather slow */
|
||||
UNIHUB_AL10_FAN_SPEED_HIGH_SPEED = 0x2206, /* Rather fast */
|
||||
UNIHUB_AL10_FAN_SPEED_FULL_SPEED = 0x6C07, /* BRRRRRRRRRR */
|
||||
UNIHUB_AL10_FAN_SPEED_PWM = 0xFFFF, /* PWM Control */
|
||||
};
|
||||
|
||||
/*----------------------------------------------------------------------------*\
|
||||
| Uni Hub controller. |
|
||||
\*----------------------------------------------------------------------------*/
|
||||
|
||||
class LianLiUniHub_AL10Controller
|
||||
{
|
||||
private:
|
||||
/* The Uni Hub requires colors in RBG order */
|
||||
struct Color
|
||||
{
|
||||
uint8_t r;
|
||||
uint8_t b;
|
||||
uint8_t g;
|
||||
};
|
||||
|
||||
/* The values correspond to the definitions above */
|
||||
struct Channel
|
||||
{
|
||||
uint8_t index;
|
||||
|
||||
uint8_t anyFanCountOffset;
|
||||
uint8_t anyFanCount;
|
||||
|
||||
uint16_t ledActionAddress;
|
||||
uint16_t ledCommitAddress;
|
||||
uint16_t ledModeAddress;
|
||||
uint16_t ledSpeedAddress;
|
||||
uint16_t ledDirectionAddress;
|
||||
uint16_t ledBrightnessAddress;
|
||||
|
||||
Color colors[UNIHUB_AL10_CHANLED_COUNT];
|
||||
|
||||
uint8_t ledMode;
|
||||
uint8_t ledSpeed;
|
||||
uint8_t ledDirection;
|
||||
uint8_t ledBrightness;
|
||||
|
||||
uint16_t fanHubActionAddress;
|
||||
uint16_t fanHubCommitAddress;
|
||||
|
||||
uint16_t fanPwmActionAddress;
|
||||
uint16_t fanPwmCommitAddress;
|
||||
uint16_t fanRpmActionAddress;
|
||||
|
||||
uint16_t fanSpeed;
|
||||
};
|
||||
|
||||
public:
|
||||
LianLiUniHub_AL10Controller
|
||||
(
|
||||
libusb_device* device,
|
||||
libusb_device_descriptor* descriptor
|
||||
);
|
||||
~LianLiUniHub_AL10Controller();
|
||||
|
||||
std::string GetVersion();
|
||||
std::string GetLocation();
|
||||
std::string GetSerial();
|
||||
|
||||
void SetAnyFanCount(size_t channel, uint8_t count);
|
||||
void SetLedColors(size_t channel, RGBColor* colors, size_t count);
|
||||
void SetLedMode(size_t channel, uint8_t mode);
|
||||
void SetLedSpeed(size_t channel, uint8_t speed);
|
||||
void SetLedDirection(size_t channel, uint8_t direction);
|
||||
void SetLedBrightness(size_t channel, uint8_t brightness);
|
||||
uint16_t GetFanSpeed(size_t channel);
|
||||
void SetFanSpeed(size_t channel, uint16_t speed);
|
||||
void EnableRgbhMode();
|
||||
void DisableRgbhMode();
|
||||
void EnableSyncMode();
|
||||
void DisableSyncMode();
|
||||
uint16_t ReadFanSpeed(size_t channel);
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Synchronize the current configuration to the Uni Hub. |
|
||||
\*-----------------------------------------------------*/
|
||||
void Synchronize();
|
||||
|
||||
private:
|
||||
libusb_device_handle* handle = nullptr;
|
||||
|
||||
std::string version;
|
||||
std::string location;
|
||||
std::string serial;
|
||||
|
||||
bool rgbhModeEnabled = false;
|
||||
bool syncModeEnabled = false;
|
||||
|
||||
Channel channels[UNIHUB_AL10_CHANNEL_COUNT];
|
||||
|
||||
void CloseLibusb();
|
||||
std::string ReadVersion();
|
||||
void SendConfig(uint16_t wIndex, uint8_t *config, size_t length);
|
||||
void SendCommit(uint16_t wIndex);
|
||||
};
|
||||
+661
@@ -0,0 +1,661 @@
|
||||
/*---------------------------------------------------------*\
|
||||
| RGBController_LianLiUniHub_AL10.cpp |
|
||||
| |
|
||||
| RGBController for Lian Li AL10 Uni Hub |
|
||||
| |
|
||||
| Oliver P 05 May 2022 |
|
||||
| Credit to Luca Lovisa for original work |
|
||||
| |
|
||||
| This file is part of the OpenRGB project |
|
||||
| SPDX-License-Identifier: GPL-2.0-or-later |
|
||||
\*---------------------------------------------------------*/
|
||||
|
||||
#include <string>
|
||||
#include "RGBController_LianLiUniHub_AL10.h"
|
||||
|
||||
/**------------------------------------------------------------------*\
|
||||
@name Lian Li Uni Hub
|
||||
@type USB
|
||||
@save :x:
|
||||
@direct :rotating_light:
|
||||
@effects :white_check_mark:
|
||||
@detectors DetectLianLiUniHub
|
||||
@comment
|
||||
\*-------------------------------------------------------------------*/
|
||||
|
||||
RGBController_LianLiUniHub_AL10::RGBController_LianLiUniHub_AL10(LianLiUniHub_AL10Controller* controller_ptr)
|
||||
{
|
||||
controller = controller_ptr;
|
||||
|
||||
name = "Lian Li Uni Hub - AL";
|
||||
vendor = "Lian Li";
|
||||
version = controller->GetVersion();
|
||||
type = DEVICE_TYPE_COOLER;
|
||||
description = "Lian Li Uni Hub - AL v1.0";
|
||||
location = controller->GetLocation();
|
||||
serial = controller->GetSerial();
|
||||
|
||||
initializedMode = false;
|
||||
|
||||
mode Custom;
|
||||
Custom.name = "Custom";
|
||||
Custom.value = UNIHUB_AL10_LED_MODE_STATIC_COLOR;
|
||||
Custom.flags = MODE_FLAG_HAS_PER_LED_COLOR;
|
||||
Custom.color_mode = MODE_COLORS_PER_LED;
|
||||
modes.push_back(Custom);
|
||||
|
||||
mode RainbowWave;
|
||||
RainbowWave.name = "Rainbow Wave";
|
||||
RainbowWave.value = UNIHUB_AL10_LED_MODE_RAINBOW;
|
||||
RainbowWave.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_DIRECTION_LR;
|
||||
RainbowWave.speed_min = 0;
|
||||
RainbowWave.speed_max = 4;
|
||||
RainbowWave.brightness_min = 0;
|
||||
RainbowWave.brightness_max = 4;
|
||||
RainbowWave.speed = 3;
|
||||
RainbowWave.brightness = 3;
|
||||
RainbowWave.direction = UNIHUB_AL10_LED_DIRECTION_LTR;
|
||||
RainbowWave.color_mode = MODE_COLORS_NONE;
|
||||
//RainbowWave.colors[0] = ToRGBColor(253,253,253);
|
||||
modes.push_back(RainbowWave);
|
||||
|
||||
/* Needs updated code
|
||||
mode RainbowMorph;
|
||||
RainbowMorph.name = "Rainbow Morph";
|
||||
RainbowMorph.value = UNIHUB_AL10_LED_MODE_RAINBOW_MORPH;
|
||||
RainbowMorph.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
|
||||
RainbowMorph.speed_min = 0;
|
||||
RainbowMorph.speed_max = 4;
|
||||
RainbowMorph.brightness_min = 0;
|
||||
RainbowMorph.brightness_max = 4;
|
||||
RainbowMorph.speed = 3;
|
||||
RainbowMorph.brightness = 3;
|
||||
RainbowMorph.color_mode = MODE_COLORS_NONE;
|
||||
modes.push_back(RainbowMorph);
|
||||
*/
|
||||
|
||||
mode StaticColor;
|
||||
StaticColor.name = "Static Color";
|
||||
StaticColor.value = UNIHUB_AL10_LED_MODE_STATIC_COLOR;
|
||||
StaticColor.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
|
||||
StaticColor.brightness_min = 0;
|
||||
StaticColor.brightness_max = 4;
|
||||
StaticColor.colors_min = 0;
|
||||
StaticColor.colors_max = 4;
|
||||
StaticColor.brightness = 3;
|
||||
StaticColor.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
StaticColor.colors.resize(4);
|
||||
modes.push_back(StaticColor);
|
||||
|
||||
mode Breathing;
|
||||
Breathing.name = "Breathing";
|
||||
Breathing.value = UNIHUB_AL10_LED_MODE_BREATHING;
|
||||
Breathing.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
|
||||
Breathing.speed_min = 0;
|
||||
Breathing.speed_max = 4;
|
||||
Breathing.brightness_min = 0;
|
||||
Breathing.brightness_max = 4;
|
||||
Breathing.colors_min = 0;
|
||||
Breathing.colors_max = 4;
|
||||
Breathing.speed = 3;
|
||||
Breathing.brightness = 3;
|
||||
Breathing.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Breathing.colors.resize(4);
|
||||
modes.push_back(Breathing);
|
||||
|
||||
mode Taichi;
|
||||
Taichi.name = "Taichi";
|
||||
Taichi.value = UNIHUB_AL10_LED_MODE_TAICHI;
|
||||
Taichi.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_DIRECTION_LR;
|
||||
Taichi.speed_min = 0;
|
||||
Taichi.speed_max = 4;
|
||||
Taichi.brightness_min = 0;
|
||||
Taichi.brightness_max = 4;
|
||||
Taichi.colors_min = 0;
|
||||
Taichi.colors_max = 2;
|
||||
Taichi.speed = 3;
|
||||
Taichi.brightness = 3;
|
||||
Taichi.direction = UNIHUB_AL10_LED_DIRECTION_LTR;
|
||||
Taichi.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Taichi.colors.resize(2);
|
||||
modes.push_back(Taichi);
|
||||
|
||||
mode ColorCycle;
|
||||
ColorCycle.name = "ColorCycle";
|
||||
ColorCycle.value = UNIHUB_AL10_LED_MODE_COLOR_CYCLE;
|
||||
ColorCycle.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_DIRECTION_LR;
|
||||
ColorCycle.speed_min = 0;
|
||||
ColorCycle.speed_max = 4;
|
||||
ColorCycle.brightness_min = 0;
|
||||
ColorCycle.brightness_max = 4;
|
||||
ColorCycle.colors_min = 0;
|
||||
ColorCycle.colors_max = 4;
|
||||
ColorCycle.speed = 3;
|
||||
ColorCycle.brightness = 3;
|
||||
ColorCycle.direction = UNIHUB_AL10_LED_DIRECTION_LTR;
|
||||
ColorCycle.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
ColorCycle.colors.resize(4);
|
||||
modes.push_back(ColorCycle);
|
||||
|
||||
/* Needs updated code
|
||||
mode Runway;
|
||||
Runway.name = "Runway";
|
||||
Runway.value = UNIHUB_AL10_LED_MODE_RUNWAY;
|
||||
Runway.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
|
||||
Runway.speed_min = 0;
|
||||
Runway.speed_max = 4;
|
||||
Runway.brightness_min = 0;
|
||||
Runway.brightness_max = 4;
|
||||
Runway.colors_min = 0;
|
||||
Runway.colors_max = 2;
|
||||
Runway.speed = 3;
|
||||
Runway.brightness = 3;
|
||||
Runway.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Runway.colors.resize(2);
|
||||
modes.push_back(Runway);
|
||||
*/
|
||||
|
||||
/* Needs updated code
|
||||
mode Meteor;
|
||||
Meteor.name = "Meteor";
|
||||
Meteor.value = UNIHUB_AL10_LED_MODE_METEOR;
|
||||
Meteor.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_DIRECTION_LR;
|
||||
Meteor.speed_min = 0;
|
||||
Meteor.speed_max = 4;
|
||||
Meteor.brightness_min = 0;
|
||||
Meteor.brightness_max = 4;
|
||||
Meteor.colors_min = 0;
|
||||
Meteor.colors_max = 4;
|
||||
Meteor.speed = 3;
|
||||
Meteor.brightness = 3;
|
||||
Meteor.direction = UNIHUB_AL10_LED_DIRECTION_LTR;
|
||||
Meteor.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Meteor.colors.resize(4);
|
||||
modes.push_back(Meteor);
|
||||
*/
|
||||
|
||||
mode Warning;
|
||||
Warning.name = "Warning";
|
||||
Warning.value = UNIHUB_AL10_LED_MODE_WARNING;
|
||||
Warning.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
|
||||
Warning.speed_min = 0;
|
||||
Warning.speed_max = 4;
|
||||
Warning.brightness_min = 0;
|
||||
Warning.brightness_max = 4;
|
||||
Warning.colors_min = 0;
|
||||
Warning.colors_max = 4;
|
||||
Warning.speed = 3;
|
||||
Warning.brightness = 3;
|
||||
Warning.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Warning.colors.resize(4);
|
||||
modes.push_back(Warning);
|
||||
|
||||
mode Voice;
|
||||
Voice.name = "Voice";
|
||||
Voice.value = UNIHUB_AL10_LED_MODE_VOICE;
|
||||
Voice.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_DIRECTION_LR;
|
||||
Voice.speed_min = 0;
|
||||
Voice.speed_max = 4;
|
||||
Voice.brightness_min = 0;
|
||||
Voice.brightness_max = 4;
|
||||
Voice.colors_min = 0;
|
||||
Voice.colors_max = 4;
|
||||
Voice.speed = 3;
|
||||
Voice.brightness = 3;
|
||||
Voice.direction = UNIHUB_AL10_LED_DIRECTION_LTR;
|
||||
Voice.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Voice.colors.resize(4);
|
||||
modes.push_back(Voice);
|
||||
|
||||
mode SpinningTeacup;
|
||||
SpinningTeacup.name = "SpinningTeacup";
|
||||
SpinningTeacup.value = UNIHUB_AL10_LED_MODE_SPINNING_TEACUP;
|
||||
SpinningTeacup.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_DIRECTION_LR;
|
||||
SpinningTeacup.speed_min = 0;
|
||||
SpinningTeacup.speed_max = 4;
|
||||
SpinningTeacup.brightness_min = 0;
|
||||
SpinningTeacup.brightness_max = 4;
|
||||
SpinningTeacup.colors_min = 0;
|
||||
SpinningTeacup.colors_max = 4;
|
||||
SpinningTeacup.speed = 3;
|
||||
SpinningTeacup.brightness = 3;
|
||||
SpinningTeacup.direction = UNIHUB_AL10_LED_DIRECTION_LTR;
|
||||
SpinningTeacup.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
SpinningTeacup.colors.resize(4);
|
||||
modes.push_back(SpinningTeacup);
|
||||
|
||||
mode Tornado;
|
||||
Tornado.name = "Tornado";
|
||||
Tornado.value = UNIHUB_AL10_LED_MODE_TORNADO;
|
||||
Tornado.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_DIRECTION_LR;
|
||||
Tornado.speed_min = 0;
|
||||
Tornado.speed_max = 4;
|
||||
Tornado.brightness_min = 0;
|
||||
Tornado.brightness_max = 4;
|
||||
Tornado.colors_min = 0;
|
||||
Tornado.colors_max = 4;
|
||||
Tornado.speed = 3;
|
||||
Tornado.brightness = 3;
|
||||
Tornado.direction = UNIHUB_AL10_LED_DIRECTION_LTR;
|
||||
Tornado.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Tornado.colors.resize(4);
|
||||
modes.push_back(Tornado);
|
||||
|
||||
mode Mixing;
|
||||
Mixing.name = "Mixing";
|
||||
Mixing.value = UNIHUB_AL10_LED_MODE_MIXING;
|
||||
Mixing.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
|
||||
Mixing.speed_min = 0;
|
||||
Mixing.speed_max = 4;
|
||||
Mixing.brightness_min = 0;
|
||||
Mixing.brightness_max = 4;
|
||||
Mixing.colors_min = 0;
|
||||
Mixing.colors_max = 2;
|
||||
Mixing.speed = 3;
|
||||
Mixing.brightness = 3;
|
||||
Mixing.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Mixing.colors.resize(2);
|
||||
modes.push_back(Mixing);
|
||||
|
||||
/* Needs updated code
|
||||
mode Stack;
|
||||
Stack.name = "Stack";
|
||||
Stack.value = UNIHUB_AL10_LED_MODE_STACK;
|
||||
Stack.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_DIRECTION_LR;
|
||||
Stack.speed_min = 0;
|
||||
Stack.speed_max = 4;
|
||||
Stack.brightness_min = 0;
|
||||
Stack.brightness_max = 4;
|
||||
Stack.colors_min = 0;
|
||||
Stack.colors_max = 2;
|
||||
Stack.speed = 3;
|
||||
Stack.brightness = 3;
|
||||
Stack.direction = UNIHUB_AL10_LED_DIRECTION_LTR;
|
||||
Stack.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Stack.colors.resize(2);
|
||||
modes.push_back(Stack);
|
||||
*/
|
||||
|
||||
mode Staggered;
|
||||
Staggered.name = "Staggered";
|
||||
Staggered.value = UNIHUB_AL10_LED_MODE_STAGGGERED;
|
||||
Staggered.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
|
||||
Staggered.speed_min = 0;
|
||||
Staggered.speed_max = 4;
|
||||
Staggered.brightness_min = 0;
|
||||
Staggered.brightness_max = 4;
|
||||
Staggered.colors_min = 0;
|
||||
Staggered.colors_max = 4;
|
||||
Staggered.speed = 3;
|
||||
Staggered.brightness = 3;
|
||||
Staggered.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Staggered.colors.resize(4);
|
||||
modes.push_back(Staggered);
|
||||
|
||||
mode Tide;
|
||||
Tide.name = "Tide";
|
||||
Tide.value = UNIHUB_AL10_LED_MODE_TIDE;
|
||||
Tide.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
|
||||
Tide.speed_min = 0;
|
||||
Tide.speed_max = 4;
|
||||
Tide.brightness_min = 0;
|
||||
Tide.brightness_max = 4;
|
||||
Tide.colors_min = 0;
|
||||
Tide.colors_max = 4;
|
||||
Tide.speed = 3;
|
||||
Tide.brightness = 3;
|
||||
Tide.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Tide.colors.resize(4);
|
||||
modes.push_back(Tide);
|
||||
|
||||
mode Scan;
|
||||
Scan.name = "Scan";
|
||||
Scan.value = UNIHUB_AL10_LED_MODE_SCAN;
|
||||
Scan.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
|
||||
Scan.speed_min = 0;
|
||||
Scan.speed_max = 4;
|
||||
Scan.brightness_min = 0;
|
||||
Scan.brightness_max = 4;
|
||||
Scan.colors_min = 0;
|
||||
Scan.colors_max = 2;
|
||||
Scan.speed = 3;
|
||||
Scan.brightness = 3;
|
||||
Scan.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Scan.colors.resize(2);
|
||||
modes.push_back(Scan);
|
||||
|
||||
mode Contest;
|
||||
Contest.name = "Contest";
|
||||
Contest.value = UNIHUB_AL10_LED_MODE_CONTEST;
|
||||
Contest.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_DIRECTION_LR;
|
||||
Contest.speed_min = 0;
|
||||
Contest.speed_max = 4;
|
||||
Contest.brightness_min = 0;
|
||||
Contest.brightness_max = 4;
|
||||
Contest.colors_min = 0;
|
||||
Contest.colors_max = 2;
|
||||
Contest.speed = 3;
|
||||
Contest.brightness = 3;
|
||||
Contest.direction = UNIHUB_AL10_LED_DIRECTION_LTR;
|
||||
Contest.color_mode = MODE_COLORS_MODE_SPECIFIC;
|
||||
Contest.colors.resize(3);
|
||||
modes.push_back(Contest);
|
||||
|
||||
/* Motherboard header mode? Not implemented yet
|
||||
mode Rgbh = makeModeAL();
|
||||
Rgbh.name = "RGB Header";
|
||||
Rgbh.value = UNIHUB_AL10_LED_MODE_STATIC_COLOR | 0x0200;
|
||||
Rgbh.flags = 0;
|
||||
Rgbh.color_mode = MODE_COLORS_NONE;
|
||||
modes.push_back(Rgbh);
|
||||
*/
|
||||
|
||||
RGBController_LianLiUniHub_AL10::SetupZones();
|
||||
}
|
||||
|
||||
void RGBController_LianLiUniHub_AL10::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(UNIHUB_AL10_CHANNEL_COUNT);
|
||||
|
||||
/*-------------------------------------------------*\
|
||||
| Set zones and leds |
|
||||
\*-------------------------------------------------*/
|
||||
int addressableCounter = 1;
|
||||
for(unsigned int channel_idx = 0; channel_idx < zones.size(); channel_idx++)
|
||||
{
|
||||
zones[channel_idx].name = "Channel ";
|
||||
zones[channel_idx].name.append(std::to_string(addressableCounter));
|
||||
|
||||
addressableCounter++;
|
||||
|
||||
zones[channel_idx].type = ZONE_TYPE_LINEAR;
|
||||
|
||||
zones[channel_idx].leds_min = 0;
|
||||
zones[channel_idx].leds_max = UNIHUB_AL10_CHANLED_COUNT;
|
||||
|
||||
if(first_run)
|
||||
{
|
||||
zones[channel_idx].leds_count = zones[channel_idx].leds_min;
|
||||
}
|
||||
|
||||
for(unsigned int led_ch_idx = 0; led_ch_idx < zones[channel_idx].leds_count; led_ch_idx++)
|
||||
{
|
||||
led new_led;
|
||||
new_led.name = zones[channel_idx].name;
|
||||
new_led.name.append(", LED ");
|
||||
new_led.name.append(std::to_string(led_ch_idx + 1));
|
||||
new_led.value = channel_idx;
|
||||
|
||||
leds.push_back(new_led);
|
||||
}
|
||||
|
||||
zones[channel_idx].matrix_map = NULL;
|
||||
}
|
||||
|
||||
SetupColors();
|
||||
}
|
||||
|
||||
void RGBController_LianLiUniHub_AL10::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_LianLiUniHub_AL10::DeviceUpdateLEDs()
|
||||
{
|
||||
if(!initializedMode)
|
||||
{
|
||||
DeviceUpdateMode();
|
||||
}
|
||||
for(size_t channel = 0; channel < zones.size(); channel++)
|
||||
{
|
||||
uint8_t fanCount = convertLedCountToFanCount(zones[channel].leds_count);
|
||||
controller->SetAnyFanCount(channel, convertAnyFanCount(fanCount));
|
||||
controller->SetLedColors(channel, zones[channel].colors, zones[channel].leds_count);
|
||||
}
|
||||
|
||||
controller->Synchronize();
|
||||
}
|
||||
|
||||
void RGBController_LianLiUniHub_AL10::UpdateZoneLEDs(int zone)
|
||||
{
|
||||
if(!initializedMode)
|
||||
{
|
||||
DeviceUpdateMode();
|
||||
}
|
||||
unsigned int channel = zone;
|
||||
|
||||
uint8_t fanCount = convertLedCountToFanCount(zones[channel].leds_count);
|
||||
controller->SetAnyFanCount(channel, convertAnyFanCount(fanCount));
|
||||
controller->SetLedColors(channel, zones[channel].colors, zones[channel].leds_count);
|
||||
|
||||
controller->Synchronize();
|
||||
}
|
||||
|
||||
void RGBController_LianLiUniHub_AL10::UpdateSingleLED(int led)
|
||||
{
|
||||
if(!initializedMode)
|
||||
{
|
||||
DeviceUpdateMode();
|
||||
}
|
||||
unsigned int channel = leds[led].value;
|
||||
|
||||
uint8_t fanCount = convertLedCountToFanCount(zones[channel].leds_count);
|
||||
controller->SetAnyFanCount(channel, convertAnyFanCount(fanCount));
|
||||
controller->SetLedColors(channel, zones[channel].colors, zones[channel].leds_count);
|
||||
|
||||
controller->Synchronize();
|
||||
}
|
||||
|
||||
void RGBController_LianLiUniHub_AL10::DeviceUpdateMode()
|
||||
{
|
||||
initializedMode = true;
|
||||
|
||||
for (size_t channel = 0; channel < zones.size(); channel++)
|
||||
{
|
||||
uint8_t fanCount = convertLedCountToFanCount(zones[channel].leds_count);
|
||||
controller->SetAnyFanCount(channel, convertAnyFanCount(fanCount));
|
||||
|
||||
switch (modes[active_mode].color_mode)
|
||||
{
|
||||
case MODE_COLORS_PER_LED:
|
||||
controller->SetLedColors(channel, zones[channel].colors, zones[channel].leds_count);
|
||||
break;
|
||||
|
||||
case MODE_COLORS_MODE_SPECIFIC:
|
||||
controller->SetLedColors(channel, modes[active_mode].colors.data(), modes[active_mode].colors.size());
|
||||
break;
|
||||
|
||||
default:
|
||||
controller->SetLedColors(channel, nullptr, 0);
|
||||
break;
|
||||
}
|
||||
|
||||
controller->SetLedMode(channel, modes[active_mode].value);
|
||||
|
||||
if(modes[active_mode].flags & MODE_FLAG_HAS_SPEED)
|
||||
{
|
||||
controller->SetLedSpeed(channel, convertLedSpeed(modes[active_mode].speed));
|
||||
}
|
||||
else
|
||||
{
|
||||
controller->SetLedSpeed(channel, UNIHUB_AL10_LED_SPEED_075);
|
||||
}
|
||||
|
||||
if(modes[active_mode].flags & MODE_FLAG_HAS_DIRECTION_LR)
|
||||
{
|
||||
controller->SetLedDirection(channel, convertLedDirection(modes[active_mode].direction));
|
||||
}
|
||||
else
|
||||
{
|
||||
controller->SetLedDirection(channel, UNIHUB_AL10_LED_DIRECTION_LTR);
|
||||
}
|
||||
|
||||
if(modes[active_mode].flags & MODE_FLAG_HAS_BRIGHTNESS)
|
||||
{
|
||||
controller->SetLedBrightness(channel, convertLedBrightness(modes[active_mode].brightness));
|
||||
}
|
||||
else
|
||||
{
|
||||
controller->SetLedBrightness(channel, UNIHUB_AL10_LED_BRIGHTNESS_100);
|
||||
}
|
||||
}
|
||||
|
||||
if(modes[active_mode].value & 0x0200)
|
||||
{
|
||||
controller->EnableRgbhMode();
|
||||
controller->DisableSyncMode();
|
||||
}
|
||||
else if (modes[active_mode].value & 0x0100)
|
||||
{
|
||||
controller->DisableRgbhMode();
|
||||
controller->EnableSyncMode();
|
||||
}
|
||||
else
|
||||
{
|
||||
controller->DisableRgbhMode();
|
||||
controller->DisableSyncMode();
|
||||
}
|
||||
|
||||
controller->Synchronize();
|
||||
}
|
||||
|
||||
uint8_t RGBController_LianLiUniHub_AL10::convertAnyFanCount(uint8_t count)
|
||||
{
|
||||
switch (count)
|
||||
{
|
||||
case 0:
|
||||
return UNIHUB_AL10_ANY_FAN_COUNT_000;
|
||||
|
||||
case 1:
|
||||
return UNIHUB_AL10_ANY_FAN_COUNT_001;
|
||||
|
||||
case 2:
|
||||
return UNIHUB_AL10_ANY_FAN_COUNT_002;
|
||||
|
||||
case 3:
|
||||
return UNIHUB_AL10_ANY_FAN_COUNT_003;
|
||||
|
||||
case 4:
|
||||
return UNIHUB_AL10_ANY_FAN_COUNT_004;
|
||||
|
||||
default:
|
||||
return UNIHUB_AL10_ANY_FAN_COUNT_001;
|
||||
}
|
||||
}
|
||||
|
||||
uint8_t RGBController_LianLiUniHub_AL10::convertLedSpeed(uint8_t speed)
|
||||
{
|
||||
switch (speed)
|
||||
{
|
||||
case 0:
|
||||
return UNIHUB_AL10_LED_SPEED_000;
|
||||
|
||||
case 1:
|
||||
return UNIHUB_AL10_LED_SPEED_025;
|
||||
|
||||
case 2:
|
||||
return UNIHUB_AL10_LED_SPEED_050;
|
||||
|
||||
case 3:
|
||||
return UNIHUB_AL10_LED_SPEED_075;
|
||||
|
||||
case 4:
|
||||
return UNIHUB_AL10_LED_SPEED_100;
|
||||
|
||||
default:
|
||||
return UNIHUB_AL10_LED_SPEED_050;
|
||||
}
|
||||
}
|
||||
|
||||
uint8_t RGBController_LianLiUniHub_AL10::convertLedDirection(uint8_t direction)
|
||||
{
|
||||
switch (direction)
|
||||
{
|
||||
case 0:
|
||||
return UNIHUB_AL10_LED_DIRECTION_LTR;
|
||||
|
||||
case 1:
|
||||
return UNIHUB_AL10_LED_DIRECTION_RTL;
|
||||
|
||||
default:
|
||||
return UNIHUB_AL10_LED_DIRECTION_LTR;
|
||||
}
|
||||
}
|
||||
|
||||
uint8_t RGBController_LianLiUniHub_AL10::convertLedBrightness(uint8_t brightness)
|
||||
{
|
||||
switch (brightness)
|
||||
{
|
||||
case 0:
|
||||
return UNIHUB_AL10_LED_BRIGHTNESS_000;
|
||||
|
||||
case 1:
|
||||
return UNIHUB_AL10_LED_BRIGHTNESS_025;
|
||||
|
||||
case 2:
|
||||
return UNIHUB_AL10_LED_BRIGHTNESS_050;
|
||||
|
||||
case 3:
|
||||
return UNIHUB_AL10_LED_BRIGHTNESS_075;
|
||||
|
||||
case 4:
|
||||
return UNIHUB_AL10_LED_BRIGHTNESS_100;
|
||||
|
||||
default:
|
||||
return UNIHUB_AL10_LED_BRIGHTNESS_100;
|
||||
}
|
||||
}
|
||||
uint8_t RGBController_LianLiUniHub_AL10::convertLedCountToFanCount(uint8_t count)
|
||||
{
|
||||
/*-------------------------------------------------*\
|
||||
| Converts <20 to 0, 20-39 to 1, 40-59 to 2, 60=79 |
|
||||
| to 3 and 80+ to 4 |
|
||||
\*-------------------------------------------------*/
|
||||
// Sets lower and upper limits
|
||||
if (count == 0x00)
|
||||
{
|
||||
return 0x00;
|
||||
}
|
||||
if (count >= 0x50)
|
||||
{
|
||||
count = 0x50;
|
||||
}
|
||||
|
||||
/*---------------------------------------------------------*\
|
||||
| Returns regular count if it's not in multiples of 20s |
|
||||
| (AL120 has 20 LEDs per fan, LED strip scenario) |
|
||||
\*---------------------------------------------------------*/
|
||||
if (count % 20)
|
||||
{
|
||||
return(count);
|
||||
}
|
||||
else
|
||||
{
|
||||
return(count / 20);
|
||||
}
|
||||
}
|
||||
+46
@@ -0,0 +1,46 @@
|
||||
/*---------------------------------------------------------*\
|
||||
| RGBController_LianLiUniHub_AL10.h |
|
||||
| |
|
||||
| RGBController for Lian Li AL Uni Hub |
|
||||
| |
|
||||
| Oliver P 05 May 2022 |
|
||||
| Credit to Luca Lovisa for original work |
|
||||
| |
|
||||
| This file is part of the OpenRGB project |
|
||||
| SPDX-License-Identifier: GPL-2.0-or-later |
|
||||
\*---------------------------------------------------------*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <cstdint>
|
||||
#include <vector>
|
||||
#include "LianLiUniHub_AL10Controller.h"
|
||||
#include "RGBController.h"
|
||||
|
||||
class RGBController_LianLiUniHub_AL10 : public RGBController
|
||||
{
|
||||
public:
|
||||
RGBController_LianLiUniHub_AL10(LianLiUniHub_AL10Controller* controller_ptr);
|
||||
|
||||
void SetupZones();
|
||||
|
||||
void ResizeZone(int zone, int new_size);
|
||||
|
||||
void DeviceUpdateLEDs();
|
||||
void UpdateZoneLEDs(int zone);
|
||||
void UpdateSingleLED(int led);
|
||||
|
||||
void DeviceUpdateMode();
|
||||
|
||||
private:
|
||||
uint8_t convertAnyFanCount(uint8_t count);
|
||||
uint8_t convertLedSpeed(uint8_t speed);
|
||||
uint8_t convertLedDirection(uint8_t direction);
|
||||
uint8_t convertLedBrightness(uint8_t brightness);
|
||||
|
||||
uint8_t convertLedCountToFanCount(uint8_t count);
|
||||
|
||||
private:
|
||||
LianLiUniHub_AL10Controller* controller;
|
||||
bool initializedMode;
|
||||
};
|
||||
+99
@@ -0,0 +1,99 @@
|
||||
/*---------------------------------------------------------*\
|
||||
| LianLiUniversalScreenController.cpp |
|
||||
| |
|
||||
| Driver for Lian Li 8.8" Universal Screen LEDs |
|
||||
| |
|
||||
| Adam Honse <calcprogrammer1@gmail.com> 17 Dec 2025 |
|
||||
| |
|
||||
| This file is part of the OpenRGB project |
|
||||
| SPDX-License-Identifier: GPL-2.0-or-later |
|
||||
\*---------------------------------------------------------*/
|
||||
|
||||
#include <cstring>
|
||||
#include <iomanip>
|
||||
#include <sstream>
|
||||
#include "LianLiUniversalScreenController.h"
|
||||
|
||||
LianLiUniversalScreenController::LianLiUniversalScreenController(libusb_device_handle* device)
|
||||
{
|
||||
dev = device;
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Fill in location string with USB ID |
|
||||
\*-----------------------------------------------------*/
|
||||
libusb_device_descriptor descriptor;
|
||||
libusb_get_device_descriptor(libusb_get_device(dev), &descriptor);
|
||||
|
||||
std::stringstream location_stream;
|
||||
location_stream << std::hex << std::setfill('0') << std::setw(4) << descriptor.idVendor << ":" << std::hex << std::setfill('0') << std::setw(4) << descriptor.idProduct;
|
||||
location = location_stream.str();
|
||||
|
||||
/*-----------------------------------------------------*\
|
||||
| Fill in the serial string from the string descriptor |
|
||||
\*-----------------------------------------------------*/
|
||||
char serialStr[64];
|
||||
|
||||
int ret = libusb_get_string_descriptor_ascii(dev, descriptor.iSerialNumber, reinterpret_cast<unsigned char*>(serialStr), sizeof(serialStr));
|
||||
|
||||
if(ret > 0)
|
||||
{
|
||||
serial = std::string(serialStr, ret);
|
||||
}
|
||||
}
|
||||
|
||||
LianLiUniversalScreenController::~LianLiUniversalScreenController()
|
||||
{
|
||||
if(dev)
|
||||
{
|
||||
libusb_close(dev);
|
||||
}
|
||||
}
|
||||
|
||||
std::string LianLiUniversalScreenController::GetLocation()
|
||||
{
|
||||
return("USB: " + location);
|
||||
}
|
||||
|
||||
std::string LianLiUniversalScreenController::GetSerial()
|
||||
{
|
||||
return(serial);
|
||||
}
|
||||
|
||||
std::string LianLiUniversalScreenController::GetVersion()
|
||||
{
|
||||
return("");
|
||||
}
|
||||
|
||||
void LianLiUniversalScreenController::SetLedColors(RGBColor* colors, size_t count)
|
||||
{
|
||||
std::size_t leds_in_packet = 20;
|
||||
unsigned char offset = 0;
|
||||
unsigned char usb_buf[64];
|
||||
|
||||
memset(usb_buf, 0, sizeof(usb_buf));
|
||||
|
||||
do
|
||||
{
|
||||
usb_buf[0] = 0x11;
|
||||
usb_buf[1] = offset;
|
||||
usb_buf[2] = 0;
|
||||
usb_buf[3] = 0;
|
||||
|
||||
if((count - offset) < leds_in_packet)
|
||||
{
|
||||
leds_in_packet = count - offset;
|
||||
}
|
||||
|
||||
for(std::size_t led_idx = 0; led_idx < leds_in_packet; led_idx++)
|
||||
{
|
||||
usb_buf[4 + (led_idx * 3)] = RGBGetRValue(colors[offset + led_idx]);
|
||||
usb_buf[5 + (led_idx * 3)] = RGBGetGValue(colors[offset + led_idx]);
|
||||
usb_buf[6 + (led_idx * 3)] = RGBGetBValue(colors[offset + led_idx]);
|
||||
}
|
||||
|
||||
offset += (unsigned char)leds_in_packet;
|
||||
|
||||
int actual_length = sizeof(usb_buf);
|
||||
libusb_bulk_transfer(dev, 1, usb_buf, sizeof(usb_buf), &actual_length, 25);
|
||||
} while( offset < count );
|
||||
}
|
||||
+36
@@ -0,0 +1,36 @@
|
||||
/*---------------------------------------------------------*\
|
||||
| LianLiUniversalScreenController.h |
|
||||
| |
|
||||
| Driver for Lian Li 8.8" Universal Screen LEDs |
|
||||
| |
|
||||
| Adam Honse <calcprogrammer1@gmail.com> 17 Dec 2025 |
|
||||
| |
|
||||
| This file is part of the OpenRGB project |
|
||||
| SPDX-License-Identifier: GPL-2.0-or-later |
|
||||
\*---------------------------------------------------------*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <string>
|
||||
#include <libusb.h>
|
||||
#include "RGBController.h"
|
||||
|
||||
class LianLiUniversalScreenController
|
||||
{
|
||||
public:
|
||||
LianLiUniversalScreenController(libusb_device_handle* device);
|
||||
~LianLiUniversalScreenController();
|
||||
|
||||
std::string GetVersion();
|
||||
std::string GetLocation();
|
||||
std::string GetSerial();
|
||||
|
||||
void SetLedColors(RGBColor* colors, size_t count);
|
||||
|
||||
private:
|
||||
libusb_device_handle* dev;
|
||||
|
||||
std::string version;
|
||||
std::string location;
|
||||
std::string serial;
|
||||
};
|
||||
+95
@@ -0,0 +1,95 @@
|
||||
/*---------------------------------------------------------*\
|
||||
| RGBController_LianLiUniversalScreen.cpp |
|
||||
| |
|
||||
| RGBController for Lian Li 8.8" Universal Screen LEDs |
|
||||
| |
|
||||
| Adam Honse <calcprogrammer1@gmail.com> 17 Dec 2025 |
|
||||
| |
|
||||
| This file is part of the OpenRGB project |
|
||||
| SPDX-License-Identifier: GPL-2.0-or-later |
|
||||
\*---------------------------------------------------------*/
|
||||
|
||||
#include "RGBController_LianLiUniversalScreen.h"
|
||||
|
||||
/**------------------------------------------------------------------*\
|
||||
@name Lian Li Universal Screen
|
||||
@category Monitor
|
||||
@type USB
|
||||
@save :x:
|
||||
@direct :white_check_mark:
|
||||
@effects :x:
|
||||
@detectors DetectLianLiUniversalScreenControllers
|
||||
@comment Only controls the LEDs around the screen, not the screen
|
||||
itself.
|
||||
\*-------------------------------------------------------------------*/
|
||||
|
||||
RGBController_LianLiUniversalScreen::RGBController_LianLiUniversalScreen(LianLiUniversalScreenController* controller_ptr)
|
||||
{
|
||||
controller = controller_ptr;
|
||||
|
||||
name = "Lian Li Universal Screen";
|
||||
type = DEVICE_TYPE_MONITOR;
|
||||
vendor = "Lian Li";
|
||||
description = "Lian Li Universal Screen Device";
|
||||
location = controller->GetLocation();
|
||||
serial = controller->GetSerial();
|
||||
version = controller->GetVersion();
|
||||
|
||||
mode Direct;
|
||||
Direct.name = "Direct";
|
||||
Direct.value = 0;
|
||||
Direct.flags = MODE_FLAG_HAS_PER_LED_COLOR;
|
||||
Direct.color_mode = MODE_COLORS_PER_LED;
|
||||
modes.push_back(Direct);
|
||||
|
||||
SetupZones();
|
||||
}
|
||||
|
||||
void RGBController_LianLiUniversalScreen::SetupZones()
|
||||
{
|
||||
zone Screen;
|
||||
Screen.name = "Screen Lighting";
|
||||
Screen.type = ZONE_TYPE_LINEAR;
|
||||
Screen.leds_min = 60;
|
||||
Screen.leds_max = 60;
|
||||
Screen.leds_count = 60;
|
||||
Screen.matrix_map = NULL;
|
||||
zones.push_back(Screen);
|
||||
|
||||
for(std::size_t led_idx = 0; led_idx < Screen.leds_count; led_idx++)
|
||||
{
|
||||
led ScreenLED;
|
||||
|
||||
ScreenLED.name = "Screen Lighting LED " + std::to_string(led_idx);
|
||||
ScreenLED.value = 0;
|
||||
|
||||
leds.push_back(ScreenLED);
|
||||
}
|
||||
|
||||
SetupColors();
|
||||
}
|
||||
|
||||
void RGBController_LianLiUniversalScreen::ResizeZone(int /*zone*/, int /*new_size*/)
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
void RGBController_LianLiUniversalScreen::DeviceUpdateLEDs()
|
||||
{
|
||||
controller->SetLedColors(colors.data(), colors.size());
|
||||
}
|
||||
|
||||
void RGBController_LianLiUniversalScreen::UpdateZoneLEDs(int /*zone*/)
|
||||
{
|
||||
DeviceUpdateLEDs();
|
||||
}
|
||||
|
||||
void RGBController_LianLiUniversalScreen::UpdateSingleLED(int /*led*/)
|
||||
{
|
||||
DeviceUpdateLEDs();
|
||||
}
|
||||
|
||||
void RGBController_LianLiUniversalScreen::DeviceUpdateMode()
|
||||
{
|
||||
DeviceUpdateLEDs();
|
||||
}
|
||||
+33
@@ -0,0 +1,33 @@
|
||||
/*---------------------------------------------------------*\
|
||||
| RGBController_LianLiUniversalScreen.h |
|
||||
| |
|
||||
| RGBController for Lian Li 8.8" Universal Screen LEDs |
|
||||
| |
|
||||
| Adam Honse <calcprogrammer1@gmail.com> 17 Dec 2025 |
|
||||
| |
|
||||
| This file is part of the OpenRGB project |
|
||||
| SPDX-License-Identifier: GPL-2.0-or-later |
|
||||
\*---------------------------------------------------------*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include "LianLiUniversalScreenController.h"
|
||||
#include "RGBController.h"
|
||||
|
||||
class RGBController_LianLiUniversalScreen : public RGBController
|
||||
{
|
||||
public:
|
||||
RGBController_LianLiUniversalScreen(LianLiUniversalScreenController* controller_ptr);
|
||||
|
||||
void SetupZones();
|
||||
void ResizeZone(int zone, int new_size);
|
||||
|
||||
void DeviceUpdateLEDs();
|
||||
void UpdateZoneLEDs(int zone);
|
||||
void UpdateSingleLED(int led);
|
||||
|
||||
void DeviceUpdateMode();
|
||||
|
||||
private:
|
||||
LianLiUniversalScreenController* controller;
|
||||
};
|
||||
Reference in New Issue
Block a user