mirror/OpenRGB
1
0
Fork 0
mirror of https://github.com/CalcProgrammer1/OpenRGB.git synced 2025-12-23 23:37:48 -05:00
Code Issues Packages Projects Releases Wiki Activity

Initial commit for Lian Li Universal Screen LED controller

Browse Source
This commit is contained in:
Adam Honse
2025-12-17 19:30:28 -06:00
parent 2a87e38f7a
commit d591cd638e
5 changed files with 300 additions and 6 deletions
Download Patch File Download Diff File Expand all files Collapse all files

43
Controllers/LianLiController/LianLiControllerDetect.cpp
View File

@@ -30,6 +30,8 @@
#include "RGBController_LianLiUniHubSLInfinity.h"
#include "LianLiGAIITrinityController.h"
#include "RGBController_LianLiGAIITrinity.h"
#include "LianLiUniversalScreenController.h"
#include "RGBController_LianLiUniversalScreen.h"
/*-----------------------------------------------------*\
| USB vendor IDs |
@@ -54,6 +56,11 @@
#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 |
@@ -233,18 +240,42 @@ void DetectLianLiGAIITrinity(hid_device_info* info, const std::string& /*name*/)
}
}
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 - 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);
/*---------------------------------------------------------------------------------------------------------*\
| Entries for dynamic UDEV rules |
| |
| DUMMY_DEVICE_DETECTOR("Lian Li Uni Hub", DetectLianLiUniHub, 0x0CF2, 0x7750 ) |
\*---------------------------------------------------------------------------------------------------------*/
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);

99
Controllers/LianLiController/LianLiUniversalScreenController/LianLiUniversalScreenController.cpp Normal file
View File

@@ -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)
{
unsigned char 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 += 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
Controllers/LianLiController/LianLiUniversalScreenController/LianLiUniversalScreenController.h Normal file
View File

@@ -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
Controllers/LianLiController/LianLiUniversalScreenController/RGBController_LianLiUniversalScreen.cpp Normal file
View File

@@ -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
Controllers/LianLiController/LianLiUniversalScreenController/RGBController_LianLiUniversalScreen.h Normal file
View File

@@ -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;
};