diff --git a/Controllers/DRGBController/.gitkeep b/Controllers/DRGBController/.gitkeep new file mode 100644 index 00000000..e69de29b diff --git a/Controllers/DRGBController/DRGBController.cpp b/Controllers/DRGBController/DRGBController.cpp new file mode 100644 index 00000000..971e63ed --- /dev/null +++ b/Controllers/DRGBController/DRGBController.cpp @@ -0,0 +1,104 @@ +/*---------------------------------------------------------*\ +| DRGBController.cpp | +| | +| Driver for DRGBmods | +| | +| Zhi Yan 25 Jun 2024 | +| | +| This file is part of the OpenRGB project | +| SPDX-License-Identifier: GPL-2.0-only | +\*---------------------------------------------------------*/ + +#include +#include "DRGBController.h" + +using namespace std::chrono_literals; + +DRGBController::DRGBController(hid_device* dev_handle, const char* path, unsigned short pid) +{ + dev = dev_handle; + location = path; + device_pid = pid; +} + +std::string DRGBController::GetLocationString() +{ + return("HID: " + location); +} + +std::string DRGBController::GetSerialString() +{ + wchar_t serial_string[128]; + int ret = hid_get_serial_number_string(dev, serial_string, 128); + if(ret != 0) + { + return(""); + } + std::wstring return_wstring = serial_string; + std::string return_string(return_wstring.begin(), return_wstring.end()); + return(return_string); +} + +unsigned short DRGBController::GetDevicePID() +{ + return(device_pid); +} + +void DRGBController::SendPacket(unsigned char* colors, unsigned int buf_packets , unsigned int Array) +{ + unsigned char usb_buf[1025]; + unsigned int buf_idx = 0; + memset(usb_buf, 0x00, sizeof(usb_buf)); + usb_buf[0x00] = 0x00; + unsigned int HigCount = Array / 256 >= 1 ? 1 : 0; + unsigned int LowCount = Array >= 316 ? 60 : (Array % 256) ; + Array = Array <= 316 ? 0 : (Array-316); + 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; + for(unsigned int k=0;k<1020;k++) + { + usb_buf[k+5] = colors[buf_idx + k]; + } + hid_write(dev, usb_buf, 1025); + if(Array) + { + HigCount = Array / 256 >= 1 ? 1 : 0; + LowCount = Array >= 340 ? 84 : (Array % 256) ; + Array = Array <= 340 ? 0 : (Array-316); + } + } +} + +void DRGBController::SendPacketFS(unsigned char* colors, unsigned int buf_packets , bool Array) +{ + unsigned char usb_buf[65]; + unsigned int buf_idx = 0; + memset(usb_buf, 0x00, sizeof(usb_buf)); + usb_buf[0x00] = 0x00; + if(Array) + { + for(unsigned int i = 0; i < buf_packets; i++) + { + usb_buf[1] = i == buf_packets - 1 ? 200 + i : 100 + i; + buf_idx = i*63; + for(unsigned int k=0;k<63;k++) + { + usb_buf[k+2] = colors[buf_idx + k]; + } + hid_write(dev, usb_buf, 65); + } + } + else + { + for(unsigned int e=0;e<64;e++) + { + usb_buf[e+1] = colors[e]; + } + hid_write(dev, usb_buf, 65); + } +} diff --git a/Controllers/DRGBController/DRGBController.h b/Controllers/DRGBController/DRGBController.h new file mode 100644 index 00000000..3589399a --- /dev/null +++ b/Controllers/DRGBController/DRGBController.h @@ -0,0 +1,34 @@ +/*---------------------------------------------------------*\ +| DRGBController.h | +| | +| Driver for DRGBmods | +| | +| Zhi Yan 25 Jun 2024 | +| | +| This file is part of the OpenRGB project | +| SPDX-License-Identifier: GPL-2.0-only | +\*---------------------------------------------------------*/ + +#pragma once + +#include +#include +#include +#include "RGBController.h" + +class DRGBController +{ +public: + DRGBController(hid_device* dev_handle, const char* path, unsigned short pid); + ~DRGBController(); + std::string GetLocationString(); + 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 Array); + void SendPacketFS(unsigned char* colors,unsigned int buf_packets ,bool Array); +private: + hid_device* dev; + unsigned short device_pid; + std::string location; +}; diff --git a/Controllers/DRGBController/DRGBControllerDetect.cpp b/Controllers/DRGBController/DRGBControllerDetect.cpp new file mode 100644 index 00000000..eeb85a16 --- /dev/null +++ b/Controllers/DRGBController/DRGBControllerDetect.cpp @@ -0,0 +1,47 @@ +/*---------------------------------------------------------*\ +| DRGBControllerDetect.cpp | +| | +| Driver for DRGBmods | +| | +| Zhi Yan 25 Jun 2024 | +| | +| This file is part of the OpenRGB project | +| SPDX-License-Identifier: GPL-2.0-only | +\*---------------------------------------------------------*/ + +#include +#include +#include "Detector.h" +#include "DRGBController.h" +#include "RGBController.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); + RGBController_DRGB* rgb_controller = new RGBController_DRGB(controller); + rgb_controller->name = name; + ResourceManager::get()->RegisterRGBController(rgb_controller); + } +} + +REGISTER_HID_DETECTOR("DRGB LED V4", DetectDRGBControllers, DRGBV4_VID, DRGB_LED_V4_PID); +REGISTER_HID_DETECTOR("DRGB ULTRA V4F", DetectDRGBControllers, DRGBV4_VID, DRGB_ULTRA_V4F_PID); +REGISTER_HID_DETECTOR("DRGB CORE V4F", DetectDRGBControllers, DRGBV4_VID, DRGB_CORE_V4F_PID); +REGISTER_HID_DETECTOR("DRGB SIG V4F", DetectDRGBControllers, DRGBV4_VID, DRGB_SIG_V4F_PID); + +REGISTER_HID_DETECTOR("DRGB LED", DetectDRGBControllers, DRGBV3_VID, DRGB_LED_V3_PID); +REGISTER_HID_DETECTOR("DRGB Ultra V3", DetectDRGBControllers, DRGBV3_VID, DRGB_Ultra_V3_PID); +REGISTER_HID_DETECTOR("DRGB CORE V3", DetectDRGBControllers, DRGBV3_VID, DRGB_CORE_V3_PID); + +REGISTER_HID_DETECTOR("DRGB LED Controller", DetectDRGBControllers, DRGBV2_VID, DRGB_LED_PID); +REGISTER_HID_DETECTOR("DRGB ULTRA", DetectDRGBControllers, DRGBV2_VID, DRGB_ULTRA_PID); +REGISTER_HID_DETECTOR("DRGB SIG AB", DetectDRGBControllers, DRGBV2_VID, DRGB_SIG_AB_PID); +REGISTER_HID_DETECTOR("DRGB SIG CD", DetectDRGBControllers, DRGBV2_VID, DRGB_SIG_CD_PID); +REGISTER_HID_DETECTOR("DRGB Strimer Controller", DetectDRGBControllers, DRGBV2_VID, DRGB_Strimer_PID); diff --git a/Controllers/DRGBController/RGBController_DRGB.cpp b/Controllers/DRGBController/RGBController_DRGB.cpp new file mode 100644 index 00000000..bd2fc376 --- /dev/null +++ b/Controllers/DRGBController/RGBController_DRGB.cpp @@ -0,0 +1,380 @@ +/*---------------------------------------------------------*\ +| 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-only | +\*---------------------------------------------------------*/ + +#include +#include +#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 = "DRGB Controller"; + vendor = "DRGB"; + description = "DRGB Controller Device"; + type = DEVICE_TYPE_LEDSTRIP; + 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 = 256; + break; + case DRGB_ULTRA_V4F_PID: + NUM_CHANNELS = 16; + NUM_Channel_led = 256; + break; + case DRGB_CORE_V4F_PID: + NUM_CHANNELS = 32; + NUM_Channel_led = 256; + break; + case DRGB_SIG_V4F_PID: + NUM_CHANNELS = 36; + NUM_Channel_led = 256; + 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_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; + } + + zones.resize(NUM_CHANNELS); + + for(unsigned int channel_idx = 0; channel_idx < NUM_CHANNELS; channel_idx++) + { + char ch_idx_string[2]; + 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(channel_idx<8) + { + snprintf(ch_idx_string, 2, "%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(); + + /*-----------------------------------------------------*\ + | Turn off hardware effects | + \*-----------------------------------------------------*/ + + if(Version > 2) + { + unsigned char HWLData[64] = {0}; + HWLData[0] = 0x35; + HWLData[4] = 0x00; + HWLData[5] = 0x01; + HWLData[6] = 0x01; + HWLData[7] = 0x00; + HWLData[8] = 0x00; + HWLData[9] = 0xFF; + HWLData[10] = 0x00; + HWLData[11] = 0x00; + HWLData[12] = 0x00; + HWLData[13] = 0xFF; + HWLData[14] = 0x00; + HWLData[20] = 0xF0; + HWLData[21] = 0x00; + + if(Version == 4) + { + controller->SendPacketFS(&HWLData[0], 1,0); + } + else if(Version == 3) + { + controller->SendPacketFS(&HWLData[0], 1,0); + } + } +} + +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 QLedCount = (LEDnum & 0xFFFF)>>8; + unsigned int PLedCount = LEDnum & 0xFF; + RGBData[zone_idx * 2 ] = QLedCount; + RGBData[zone_idx * 2 + 1] = PLedCount; + for(unsigned int i=0; i> 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 > 316) + { + col_packets = ((led_index - 316) / 340) + (((led_index - 316) % 340) > 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> 8) & 0xFF; + RGBData[led_index * 3 +2] = (RGBcolors >> 16) & 0xFF; + led_index++; + } + if(led_index>1800) + { + break; + } + } + unsigned int col_packets = (led_index / 21) + ((led_index % 64) > 0); + controller->SendPacketFS(&ArrayData[0], 1,0); + controller->SendPacketFS(&RGBData[0], col_packets,1); + 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> 8) & 0xFF; + RGBData[i * 3 +2] = (RGBcolors >> 16) & 0xFF; + } + unsigned char NumPackets = LEDnum / 20 + (LEDnum % 20) > 0; + for (unsigned int CurrPacket = 1 ; CurrPacket <= NumPackets; CurrPacket++) + { + ArrayData[0] = CurrPacket; + ArrayData[1] = NumPackets; + ArrayData[2] = 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; + } +} + +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(); +} diff --git a/Controllers/DRGBController/RGBController_DRGB.h b/Controllers/DRGBController/RGBController_DRGB.h new file mode 100644 index 00000000..fafb4ae6 --- /dev/null +++ b/Controllers/DRGBController/RGBController_DRGB.h @@ -0,0 +1,53 @@ +/*---------------------------------------------------------*\ +| 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-only | +\*---------------------------------------------------------*/ + +#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 DRGBV3_VID 0x2023 +#define DRGB_LED_V3_PID 0x1209 +#define DRGB_Ultra_V3_PID 0x1221 +#define DRGB_CORE_V3_PID 0x1226 + +#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 + +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 leds_channel; + std::vector zones_channel; + unsigned int Version = 4; +};