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

Publish LumaOps source

Browse Source
This commit is contained in:
LumaOps release export
2026-09-03 01:18:36 +02:00
commit 7f1c0e5f71
2363 changed files with 501543 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Controllers/DRGBController/DRGBController.cpp
+155
View File
@@ -0,0 +1,155 @@
/*---------------------------------------------------------*\
| DRGBController.cpp |
| |
| Driver for DRGBmods |
| |
| Zhi Yan 25 Jun 2024 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include <cstring>
#include "DRGBController.h"
#include "StringUtils.h"
using namespace std::chrono_literals;
DRGBController::DRGBController(hid_device* dev_handle, const char* path, unsigned short pid, std::string dev_name)
{
dev = dev_handle;
location = path;
name = dev_name;
device_pid = pid;
/*-----------------------------------------------------*\
| Exit hardware effects. Start a thread to continuously|
| send a keepalive packet every 500ms |
\*-----------------------------------------------------*/
keepalive_thread_run = 1;
keepalive_thread = new std::thread(&DRGBController::KeepaliveThread, this);
}
DRGBController::~DRGBController()
{
keepalive_thread_run = 0;
keepalive_thread->join();
delete keepalive_thread;
hid_close(dev);
}
void DRGBController::KeepaliveThread()
{
unsigned char sleep_buf[65];
sleep_buf[0] = 0x65;
while(keepalive_thread_run.load())
{
if((std::chrono::steady_clock::now() - last_commit_time) > std::chrono::milliseconds(500))
{
SendPacketFS(sleep_buf, 1, 0);
}
std::this_thread::sleep_for(300ms);
}
}
std::string DRGBController::GetFirmwareString()
{
return "v"+std::to_string(version[0]) + "." + std::to_string(version[1]) + "." + std::to_string(version[2]) + "." + std::to_string(version[3]);
}
std::string DRGBController::GetLocationString()
{
return("HID: " + location);
}
std::string DRGBController::GetNameString()
{
return(name);
}
std::string DRGBController::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));
}
unsigned short DRGBController::GetDevicePID()
{
return(device_pid);
}
void DRGBController::SetChannelLEDs(unsigned char /*channel*/, RGBColor* /*colors*/, unsigned int /*num_colors*/)
{
}
void DRGBController::SendPacket(unsigned char* colors, unsigned int buf_packets , unsigned int LEDtotal)
{
unsigned char usb_buf[1025];
unsigned int buf_idx = 0;
memset(usb_buf, 0x00, sizeof(usb_buf));
usb_buf[0x00] = 0x00;
/*-----------------------------------------------------*\
| Update last commit time |
\*-----------------------------------------------------*/
last_commit_time = std::chrono::steady_clock::now();
unsigned int HigCount = LEDtotal / 256 >= 1 ? 1 : 0;
unsigned int LowCount = LEDtotal >= DRGB_V4_ONE_PACKAGE_SIZE ? 60 : (LEDtotal % 256) ;
LEDtotal = LEDtotal <= DRGB_V4_ONE_PACKAGE_SIZE ? 0 : (LEDtotal-DRGB_V4_ONE_PACKAGE_SIZE);
for(unsigned int i = 0; i < buf_packets; i++)
{
usb_buf[1] = i + 100 ;
usb_buf[2] = buf_packets + 99 ;
usb_buf[3] = HigCount;
usb_buf[4] = LowCount;
buf_idx = i*1020;
memcpy(usb_buf + 5, colors + buf_idx, 1020);
hid_write(dev, usb_buf, 1025);
if(LEDtotal)
{
HigCount = LEDtotal / 256 >= 1 ? 1 : 0;
LowCount = LEDtotal >= DRGB_V4_PACKAGE_SIZE ? 84 : (LEDtotal % 256) ;
LEDtotal = LEDtotal <= DRGB_V4_PACKAGE_SIZE ? 0 : (LEDtotal-DRGB_V4_PACKAGE_SIZE);
}
}
}
void DRGBController::SendPacketFS(unsigned char* colors, unsigned int buf_packets , unsigned int Array)
{
unsigned char usb_buf[65] = {0};
unsigned int current_index = 0;
/*-----------------------------------------------------*\
| Update last commit time |
\*-----------------------------------------------------*/
last_commit_time = std::chrono::steady_clock::now();
if(Array == 0x64 || Array == 0x47)
{
const unsigned int offset = (Array == 0x64) ? 100 : 92;
for(unsigned int i = 0; i < buf_packets; i++)
{
const bool is_last_packet = (i == buf_packets - 1);
usb_buf[1] = is_last_packet ? (Array + offset + i) : (Array + i);
current_index = i * 63;
memcpy(usb_buf + 2, colors + current_index, 63);
hid_write(dev, usb_buf, 65);
}
}
else
{
memcpy(usb_buf + 1, colors, 64);
hid_write(dev, usb_buf, 65);
}
}
Controllers/DRGBController/DRGBController.h
+48
View File
@@ -0,0 +1,48 @@
/*---------------------------------------------------------*\
| DRGBController.h |
| |
| Driver for DRGBmods |
| |
| Zhi Yan 25 Jun 2024 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#pragma once
#include <chrono>
#include <vector>
#include <hidapi.h>
#include "RGBController.h"
#define DRGB_V4_ONE_PACKAGE_SIZE 316
#define DRGB_V4_PACKAGE_SIZE 340
#define DRGB_V3_PACKAGE_SIZE 21
#define DRGB_V2_PACKAGE_SIZE 20
class DRGBController
{
public:
DRGBController(hid_device* dev_handle, const char* path, unsigned short pid, std::string dev_name);
~DRGBController();
void KeepaliveThread();
std::string GetFirmwareString();
std::string GetLocationString();
std::string GetNameString();
std::string GetSerialString();
unsigned short GetDevicePID();
void SetChannelLEDs(unsigned char channel, RGBColor * colors, unsigned int num_colors);
void SendPacket(unsigned char* colors,unsigned int buf_packets ,unsigned int LEDtotal);
void SendPacketFS(unsigned char* colors,unsigned int buf_packets ,unsigned int Array);
private:
hid_device* dev;
std::string location;
std::string name;
std::thread* keepalive_thread;
std::atomic<bool> keepalive_thread_run;
std::chrono::time_point<std::chrono::steady_clock> last_commit_time;
unsigned char version[4] = {0, 0, 0,0};
unsigned short device_pid;
};
Controllers/DRGBController/DRGBControllerDetect.cpp
+72
View File
@@ -0,0 +1,72 @@
/*---------------------------------------------------------*\
| DRGBControllerDetect.cpp |
| |
| Driver for DRGBmods |
| |
| Zhi Yan 25 Jun 2024 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include <hidapi.h>
#include "Detector.h"
#include "DRGBController.h"
#include "RGBController_DRGB.h"
void DetectDRGBControllers(hid_device_info* info, const std::string& name)
{
hid_device* dev = hid_open_path(info->path);
if(dev)
{
wchar_t product[128];
hid_get_product_string(dev, product, 128);
std::wstring product_str(product);
DRGBController* controller = new DRGBController(dev, info->path, info->product_id, name);
RGBController_DRGB* rgb_controller = new RGBController_DRGB(controller);
ResourceManager::get()->RegisterRGBController(rgb_controller);
}
}
REGISTER_HID_DETECTOR("DeepRGB LED V4", DetectDRGBControllers, DRGBV4_VID, DRGB_LED_V4_PID);
REGISTER_HID_DETECTOR("DeepRGB ULTRA V4F", DetectDRGBControllers, DRGBV4_VID, DRGB_ULTRA_V4F_PID);
REGISTER_HID_DETECTOR("DeepRGB CORE V4F", DetectDRGBControllers, DRGBV4_VID, DRGB_CORE_V4F_PID);
REGISTER_HID_DETECTOR("DeepRGB SIG V4F", DetectDRGBControllers, DRGBV4_VID, DRGB_SIG_V4F_PID);
REGISTER_HID_DETECTOR("Airgoo AG-DRGB04", DetectDRGBControllers, DRGBV4_VID, DRGB_AG_04_V4F_PID);
REGISTER_HID_DETECTOR("Airgoo AG-DRGB16", DetectDRGBControllers, DRGBV4_VID, DRGB_AG_16_V4F_PID);
REGISTER_HID_DETECTOR("Airgoo AG-DRGB08", DetectDRGBControllers, DRGBV4_VID, DRGB_AG_08_PID);
REGISTER_HID_DETECTOR("Airgoo AG-F8-DRGB08", DetectDRGBControllers, DRGBV4_VID, DRGB_AG_08_F08_PID);
REGISTER_HID_DETECTOR("Airgoo AG-F12-DRGB16", DetectDRGBControllers, DRGBV4_VID, DRGB_AG_16_F12_PID);
REGISTER_HID_DETECTOR("DeepRGB L8 V5", DetectDRGBControllers, DRGBV4_VID, DRGB_L8_V5_PID);
REGISTER_HID_DETECTOR("DeepRGB U16 V5", DetectDRGBControllers, DRGBV4_VID, DRGB_U16_V5_PID);
REGISTER_HID_DETECTOR("DeepRGB U16 V5F", DetectDRGBControllers, DRGBV4_VID, DRGB_U16_V5F_PID);
REGISTER_HID_DETECTOR("DeepRGB C16 V5", DetectDRGBControllers, DRGBV4_VID, DRGB_C16_V5_PID);
REGISTER_HID_DETECTOR("DeepRGB C16 V5F", DetectDRGBControllers, DRGBV4_VID, DRGB_C16_V5F_PID);
REGISTER_HID_DETECTOR("DeepRGB S16 V5F", DetectDRGBControllers, DRGBV4_VID, DRGB_S16_V5F_PID);
REGISTER_HID_DETECTOR("DeepRGB LED", DetectDRGBControllers, DRGBV3_VID, DRGB_LED_V3_PID);
REGISTER_HID_DETECTOR("DeepRGB Ultra V3", DetectDRGBControllers, DRGBV3_VID, DRGB_Ultra_V3_PID);
REGISTER_HID_DETECTOR("DeepRGB CORE V3", DetectDRGBControllers, DRGBV3_VID, DRGB_CORE_V3_PID);
REGISTER_HID_DETECTOR("DeepRGB E8 F", DetectDRGBControllers, DRGBV3_VID, DRGB_E8_F_PID);
REGISTER_HID_DETECTOR("DeepRGB E8", DetectDRGBControllers, DRGBV3_VID, DRGB_E8_PID);
REGISTER_HID_DETECTOR("DeepRGB E16", DetectDRGBControllers, DRGBV3_VID, DRGB_E16_PID);
REGISTER_HID_DETECTOR("NEEDMAX 10 ELITE", DetectDRGBControllers, DRGBV3_VID, DM_10_PID);
REGISTER_HID_DETECTOR("JPU ELITE", DetectDRGBControllers, DRGBV3_VID, JPU_12_PID);
REGISTER_HID_DETECTOR("DeepRGB LED Controller", DetectDRGBControllers, DRGBV2_VID, DRGB_LED_PID);
REGISTER_HID_DETECTOR("DeepRGB ULTRA", DetectDRGBControllers, DRGBV2_VID, DRGB_ULTRA_PID);
REGISTER_HID_DETECTOR("DeepRGB SIG AB", DetectDRGBControllers, DRGBV2_VID, DRGB_SIG_AB_PID);
REGISTER_HID_DETECTOR("DeepRGB SIG CD", DetectDRGBControllers, DRGBV2_VID, DRGB_SIG_CD_PID);
REGISTER_HID_DETECTOR("DeepRGB Strimer Controller", DetectDRGBControllers, DRGBV2_VID, DRGB_Strimer_PID);
REGISTER_HID_DETECTOR("YICO 8 ELITE", DetectDRGBControllers, YICO_VID, YICO_8_PID);
REGISTER_HID_DETECTOR("YICO 08 ELITE", DetectDRGBControllers, YICO_VID, YICO_08_PID);
REGISTER_HID_DETECTOR("YICO 08 ELITE", DetectDRGBControllers, YICO_VID, YICO_08_1_PID);
REGISTER_HID_DETECTOR("YICO 14 LCD", DetectDRGBControllers, DRGBV3_VID, YICO_14_PID);
REGISTER_HID_DETECTOR("YICO 16 ELITE", DetectDRGBControllers, DRGBV4_VID, YICO_16_PID);
Controllers/DRGBController/RGBController_DRGB.cpp
+522
View File
@@ -0,0 +1,522 @@
/*---------------------------------------------------------*\
| RGBController_DRGB.cpp |
| |
| Driver for DRGBmods |
| |
| Zhi Yan 25 Jun 2024 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include <algorithm>
#include <iostream>
#include "RGBController_DRGB.h"
/**------------------------------------------------------------------*\
@name DRGB Controller
@category LEDStrip
@type USB
@save :x:
@direct :white_check_mark:
@effects :white_check_mark:
@detectors DetectDRGBControllers
@comment
\*-------------------------------------------------------------------*/
RGBController_DRGB::RGBController_DRGB(DRGBController* controller_ptr)
{
controller = controller_ptr;
name = controller->GetNameString();
vendor = "DRGB";
description = "DRGB Controller Device";
type = DEVICE_TYPE_LEDSTRIP;
version = controller->GetFirmwareString();
location = controller->GetLocationString();
serial = controller->GetSerialString();
mode Direct;
Direct.name = "Direct";
Direct.value = 0xFFFF;
Direct.flags = MODE_FLAG_HAS_PER_LED_COLOR;
Direct.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Direct);
SetupZones();
}
RGBController_DRGB::~RGBController_DRGB()
{
delete controller;
}
void RGBController_DRGB::SetupZones()
{
/*-------------------------------------------------*\
| Only set LED count on the first run |
\*-------------------------------------------------*/
bool first_run = false;
if(zones.size() == 0)
{
first_run = true;
}
leds.clear();
colors.clear();
unsigned int NUM_CHANNELS = 0;
unsigned int NUM_Channel_led = 0;
switch(controller->GetDevicePID())
{
case DRGB_LED_V4_PID:
NUM_CHANNELS = 8;
NUM_Channel_led = 512;
Version = 4;
break;
case DRGB_ULTRA_V4F_PID:
NUM_CHANNELS = 16;
NUM_Channel_led = 256;
Version = 4;
break;
case DRGB_CORE_V4F_PID:
NUM_CHANNELS = 32;
NUM_Channel_led = 256;
Version = 4;
break;
case DRGB_SIG_V4F_PID:
NUM_CHANNELS = 36;
NUM_Channel_led = 256;
Version = 4;
break;
case DRGB_AG_04_V4F_PID:
NUM_CHANNELS = 4;
NUM_Channel_led = 256;
Version = 4;
break;
case DRGB_AG_08_PID:
NUM_CHANNELS = 8;
NUM_Channel_led = 256;
Version = 4;
break;
case DRGB_AG_08_F08_PID:
NUM_CHANNELS = 8;
NUM_Channel_led = 256;
Version = 4;
break;
case DRGB_AG_16_V4F_PID:
NUM_CHANNELS = 16;
NUM_Channel_led = 256;
Version = 4;
break;
case DRGB_AG_16_F12_PID:
NUM_CHANNELS = 16;
NUM_Channel_led = 256;
Version = 4;
break;
case DRGB_L8_V5_PID:
NUM_CHANNELS = 8;
NUM_Channel_led = 512;
Version = 4;
break;
case DRGB_U16_V5_PID:
NUM_CHANNELS = 16;
NUM_Channel_led = 256;
Version = 4;
break;
case DRGB_U16_V5F_PID:
NUM_CHANNELS = 16;
NUM_Channel_led = 256;
Version = 4;
break;
case DRGB_C16_V5_PID:
NUM_CHANNELS = 32;
NUM_Channel_led = 256;
Version = 4;
break;
case DRGB_C16_V5F_PID:
NUM_CHANNELS = 32;
NUM_Channel_led = 256;
Version = 4;
break;
case DRGB_S16_V5F_PID:
NUM_CHANNELS = 32;
NUM_Channel_led = 256;
Version = 4;
break;
case DRGB_LED_V3_PID:
NUM_CHANNELS = 8;
NUM_Channel_led = 256;
Version = 3;
break;
case DRGB_Ultra_V3_PID:
NUM_CHANNELS = 16;
NUM_Channel_led = 256;
Version = 3;
break;
case DRGB_CORE_V3_PID:
NUM_CHANNELS = 30;
NUM_Channel_led = 256;
Version = 3;
break;
case DRGB_E8_F_PID:
NUM_CHANNELS = 8;
NUM_Channel_led = 132;
Version = 1;
break;
case DRGB_E8_PID:
NUM_CHANNELS = 8;
NUM_Channel_led = 132;
Version = 1;
break;
case DRGB_E16_PID:
NUM_CHANNELS = 16;
NUM_Channel_led = 132;
Version = 1;
break;
case DM_10_PID:
NUM_CHANNELS = 10;
NUM_Channel_led = 132;
Version = 1;
break;
case JPU_12_PID:
NUM_CHANNELS = 12;
NUM_Channel_led = 60;
Version = 1;
break;
case DRGB_LED_PID:
NUM_CHANNELS = 8;
NUM_Channel_led = 256;
Version = 2;
break;
case DRGB_ULTRA_PID:
NUM_CHANNELS = 16;
NUM_Channel_led = 256;
Version = 2;
break;
case DRGB_SIG_AB_PID:
NUM_CHANNELS = 16;
NUM_Channel_led = 256;
Version = 2;
break;
case DRGB_SIG_CD_PID:
NUM_CHANNELS = 6;
NUM_Channel_led = 256;
Version = 2;
break;
case DRGB_Strimer_PID:
NUM_CHANNELS = 6;
NUM_Channel_led = 256;
Version = 2;
break;
case YICO_8_PID:
NUM_CHANNELS = 8;
NUM_Channel_led = 256;
Version = 3;
break;
case YICO_08_PID:
NUM_CHANNELS = 8;
NUM_Channel_led = 256;
Version = 3;
break;
case YICO_08_1_PID:
NUM_CHANNELS = 8;
NUM_Channel_led = 132;
Version = 3;
break;
case YICO_14_PID:
NUM_CHANNELS = 14;
NUM_Channel_led = 132;
Version = 1;
break;
case YICO_16_PID:
NUM_CHANNELS = 16;
NUM_Channel_led = 256;
Version = 4;
break;
}
zones.resize(NUM_CHANNELS);
for(unsigned int channel_idx = 0; channel_idx < NUM_CHANNELS; channel_idx++)
{
char ch_idx_string[4];
if(NUM_CHANNELS == 6)
{
if(channel_idx==0)
{
snprintf(ch_idx_string, 2, "%d", channel_idx+1 );
zones[channel_idx].name = "Strimer ATX";
}
else if(channel_idx<3)
{
snprintf(ch_idx_string, 2, "%d", channel_idx );
zones[channel_idx].name = "Channel C";
}
else if(channel_idx==3)
{
snprintf(ch_idx_string, 2, "%d", channel_idx-2 );
zones[channel_idx].name = "Strimer GPU";
}
else if(channel_idx<6)
{
snprintf(ch_idx_string, 2, "%d", channel_idx -3);
zones[channel_idx].name = "Channel D";
}
}
else if(NUM_CHANNELS == 10 || NUM_CHANNELS == 12)
{
snprintf(ch_idx_string, 4, "%d", channel_idx+1 );
zones[channel_idx].name = "Channel ";
}
else if(NUM_CHANNELS == 14)
{
if(channel_idx<4)
{
snprintf(ch_idx_string, 3, "%d", channel_idx+1 );
zones[channel_idx].name = "LCD ";
}
else if(channel_idx<6)
{
snprintf(ch_idx_string, 3, "%d", channel_idx+1 );
zones[channel_idx].name = "LED ";
}
else if(channel_idx<16)
{
snprintf(ch_idx_string, 3, "%d", channel_idx-5 );
zones[channel_idx].name = "ARGB ";
}
}
else if(channel_idx<8)
{
snprintf(ch_idx_string, 3, "%d", channel_idx + 1);
zones[channel_idx].name = "Channel A";
}
else if(channel_idx<16)
{
snprintf(ch_idx_string, 2, "%d", channel_idx -7);
zones[channel_idx].name = "Channel B";
}
else if(NUM_CHANNELS == 30)
{
if(channel_idx<24)
{
snprintf(ch_idx_string, 2, "%d", channel_idx -15);
zones[channel_idx].name = "Channel C";
}
else if(channel_idx<30)
{
snprintf(ch_idx_string, 2, "%d", channel_idx -23);
zones[channel_idx].name = "Channel D";
}
}
else if(channel_idx<22)
{
snprintf(ch_idx_string, 2, "%d", channel_idx -15);
zones[channel_idx].name = "Channel C";
}
else if(channel_idx<28)
{
snprintf(ch_idx_string, 2, "%d", channel_idx -21);
zones[channel_idx].name = "Channel D";
}
else if(channel_idx<36)
{
snprintf(ch_idx_string, 2, "%d", channel_idx -27);
zones[channel_idx].name = "Channel E";
}
zones[channel_idx].name.append(ch_idx_string);
zones[channel_idx].type = ZONE_TYPE_LINEAR;
zones[channel_idx].leds_min = 0;
zones[channel_idx].leds_max = NUM_Channel_led;
if(first_run)
{
zones[channel_idx].leds_count = 0;
}
zones[channel_idx].matrix_map = NULL;
for(unsigned int led_ch_idx = 0; led_ch_idx < zones[channel_idx].leds_count; led_ch_idx++)
{
char led_idx_string[4];
snprintf(led_idx_string, 4, "%d", led_ch_idx + 1);
led new_led;
new_led.name = "LED ";
new_led.name.append(led_idx_string);
leds.push_back(new_led);
leds_channel.push_back(channel_idx);
}
}
SetupColors();
}
void RGBController_DRGB::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_DRGB::DeviceUpdateLEDs()
{
switch(Version)
{
case 4:
{
unsigned int led_index = 0;
unsigned char RGBData[8192*3 + 72] = {0};
for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
{
unsigned char LEDnum = zones[zone_idx].leds_count;
unsigned int HighCount = (LEDnum & 0xFFFF)>>8;
unsigned int LowCount = LEDnum & 0xFF;
RGBData[zone_idx * 2 ] = HighCount;
RGBData[zone_idx * 2 + 1] = LowCount;
for(unsigned int i=0; i<LEDnum;i++)
{
unsigned int RGBcolors = zones[zone_idx].colors[i];
RGBData[led_index * 3 +72] = RGBcolors & 0xFF;
RGBData[led_index * 3 +73] = (RGBcolors >> 8) & 0xFF;
RGBData[led_index * 3 +74] = (RGBcolors >> 16) & 0xFF;
led_index++;
}
if(led_index>8192)
{
break;
}
}
unsigned int col_packets = 1 ;
if(led_index > DRGB_V4_ONE_PACKAGE_SIZE)
{
col_packets = 1 + ((led_index - DRGB_V4_ONE_PACKAGE_SIZE) / DRGB_V4_PACKAGE_SIZE) + (((led_index - DRGB_V4_ONE_PACKAGE_SIZE) % DRGB_V4_PACKAGE_SIZE) > 0);
}
controller->SendPacket(&RGBData[0], col_packets,led_index);
break;
}
case 3:
{
unsigned int led_index = 0;
unsigned char RGBData[1801*3] = {0};
unsigned char ArrayData[64] = {0};
ArrayData[0] = 0x60;
ArrayData[1] = 0xBB;
for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
{
unsigned char LEDnum = zones[zone_idx].leds_count;
unsigned int HighCount = (LEDnum & 0xFFFF)>>8;
unsigned int LowCount = LEDnum & 0xFF;
ArrayData[zone_idx * 2 + 2] = HighCount;
ArrayData[zone_idx * 2 + 3] = LowCount;
for(unsigned int i=0; i<LEDnum;i++)
{
unsigned int RGBcolors = zones[zone_idx].colors[i];
RGBData[led_index * 3] = RGBcolors & 0xFF;
RGBData[led_index * 3 +1] = (RGBcolors >> 8) & 0xFF;
RGBData[led_index * 3 +2] = (RGBcolors >> 16) & 0xFF;
led_index++;
}
if(led_index>1800)
{
break;
}
}
unsigned int col_packets = (led_index / DRGB_V3_PACKAGE_SIZE) + ((led_index % DRGB_V3_PACKAGE_SIZE) > 0);
controller->SendPacketFS(&ArrayData[0], 1,0);
controller->SendPacketFS(&RGBData[0], col_packets,0x64);
break;
}
case 2:
for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
{
unsigned char RGBData[256*3] = {0};
unsigned char ArrayData[64] = {0};
unsigned char LEDnum = zones[zone_idx].leds_count;
for(unsigned int i = 0; i < LEDnum; i++)
{
unsigned int RGBcolors = zones[zone_idx].colors[i];
RGBData[i * 3] = RGBcolors & 0xFF;
RGBData[i * 3 +1] = (RGBcolors >> 8) & 0xFF;
RGBData[i * 3 +2] = (RGBcolors >> 16) & 0xFF;
}
unsigned char NumPackets = LEDnum / DRGB_V2_PACKAGE_SIZE + ((LEDnum % DRGB_V2_PACKAGE_SIZE) > 0);
for(unsigned char CurrPacket = 1; CurrPacket <= NumPackets; CurrPacket++)
{
ArrayData[0] = CurrPacket;
ArrayData[1] = NumPackets;
ArrayData[2] = (unsigned char)zone_idx;
ArrayData[3] = 0xBB;
for(unsigned int i=0; i<60;i++)
{
ArrayData[4+i] = RGBData[(CurrPacket -1)*60 + i];
}
controller->SendPacketFS(&ArrayData[0], 1,0);
}
}
break;
case 1:
{
unsigned int led_index = 0;
unsigned char RGBData[1801*3] = {0};
unsigned char ArrayData[64] = {0};
ArrayData[0] = 0x46;
ArrayData[1] = 0xBB;
for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
{
unsigned char LEDnum = zones[zone_idx].leds_count;
unsigned int HighCount = (LEDnum & 0xFFFF)>>8;
unsigned int LowCount = LEDnum & 0xFF;
ArrayData[zone_idx * 2 + 2] = HighCount;
ArrayData[zone_idx * 2 + 3] = LowCount;
for(unsigned int i=0; i<LEDnum;i++)
{
unsigned int RGBcolors = zones[zone_idx].colors[i];
RGBData[led_index * 3] = RGBcolors & 0xFF;
RGBData[led_index * 3 +1] = (RGBcolors >> 8) & 0xFF;
RGBData[led_index * 3 +2] = (RGBcolors >> 16) & 0xFF;
led_index++;
}
if(led_index>1800)
{
break;
}
}
unsigned int col_packets = (led_index / DRGB_V3_PACKAGE_SIZE) + ((led_index % DRGB_V3_PACKAGE_SIZE) > 0);
controller->SendPacketFS(&ArrayData[0], 1,0);
controller->SendPacketFS(&RGBData[0], col_packets,0x47);
break;
}
}
}
void RGBController_DRGB::UpdateZoneLEDs(int zone)
{
controller->SetChannelLEDs(zone, zones[zone].colors, zones[zone].leds_count);
}
void RGBController_DRGB::UpdateSingleLED(int led)
{
unsigned int channel = leds_channel[led];
controller->SetChannelLEDs(channel, zones[channel].colors, zones[channel].leds_count);
}
void RGBController_DRGB::DeviceUpdateMode()
{
DeviceUpdateLEDs();
}
Controllers/DRGBController/RGBController_DRGB.h
+77
View File
@@ -0,0 +1,77 @@
/*---------------------------------------------------------*\
| RGBController_DRGB.h |
| |
| Driver for DRGBmods |
| |
| Zhi Yan 25 Jun 2024 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#pragma once
#include "RGBController.h"
#include "DRGBController.h"
#define DRGBV4_VID 0x2486
#define DRGB_LED_V4_PID 0x3608
#define DRGB_ULTRA_V4F_PID 0x3616
#define DRGB_CORE_V4F_PID 0x3628
#define DRGB_SIG_V4F_PID 0x3636
#define DRGB_AG_04_V4F_PID 0x3204
#define DRGB_AG_16_V4F_PID 0x3216
#define DRGB_AG_08_PID 0x3F08
#define DRGB_AG_08_F08_PID 0x3F16
#define DRGB_AG_16_F12_PID 0x3F28
#define DRGB_L8_V5_PID 0x3208
#define DRGB_U16_V5_PID 0x3215
#define DRGB_U16_V5F_PID 0x3217
#define DRGB_C16_V5_PID 0x3228
#define DRGB_C16_V5F_PID 0x3229
#define DRGB_S16_V5F_PID 0x3232
#define DRGBV3_VID 0x2023
#define DRGB_LED_V3_PID 0x1209
#define DRGB_Ultra_V3_PID 0x1221
#define DRGB_CORE_V3_PID 0x1226
#define DRGB_E8_F_PID 0x1408
#define DRGB_E8_PID 0x1407
#define DRGB_E16_PID 0x1416
#define DM_10_PID 0x1410
#define JPU_12_PID 0x1412
#define DRGBV2_VID 0x2023
#define DRGB_LED_PID 0x1208
#define DRGB_ULTRA_PID 0x1220
#define DRGB_SIG_AB_PID 0x1210
#define DRGB_SIG_CD_PID 0x1211
#define DRGB_Strimer_PID 0x1215
#define YICO_VID 0x1368
#define YICO_8_PID 0x6077
#define YICO_08_PID 0x6078
#define YICO_08_1_PID 0x6079
#define YICO_14_PID 0x1614
#define YICO_16_PID 0x1616
class RGBController_DRGB : public RGBController
{
public:
RGBController_DRGB(DRGBController* controller_ptr);
~RGBController_DRGB();
void SetupZones();
void ResizeZone(int zone, int new_size);
void DeviceUpdateLEDs();
void UpdateZoneLEDs(int zone);
void UpdateSingleLED(int led);
void DeviceUpdateMode();
private:
DRGBController* controller;
std::vector<unsigned int> leds_channel;
std::vector<unsigned int> zones_channel;
unsigned int Version = 4;
};