jalr/OpenRGB
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Initial commit for adding support to JGINYUE Motherboard Controller V2

Browse source
This commit is contained in:
SU wuyi 2024-10-20 19:54:04 +00:00 • committed by Adam Honse
parent 300abac9a8
commit 7dcdef28c8
6 changed files with 992 additions and 1 deletions
Download patch file Download diff file Expand all files Collapse all files

2
Controllers/JGINYUEInternalUSBController/RGBController_JGINYUEInternalUSB.cpp
View file

@ -222,7 +222,7 @@ void RGBController_JGINYUEInternalUSB::SetupZones()
{
led new_led;
new_led.name = "ARGB Header " + std::to_string(zone_idx + 1) + " LED " + std::to_string(led_idx + 1);
new_led.value = 0;
new_led.value = led_idx;
leds.push_back(new_led);
}
}

224
Controllers/JGINYUEInternalUSBV2Controller/JGINYUEInternalUSBV2Controller.cpp Normal file
View file

@ -0,0 +1,224 @@
/*---------------------------------------------------------*\
| JGINYUEInternalUSBV2Controller.cpp |
| |
| Driver for JGINYUE USB motherboard V2 |
| |
| Tong R (tcr020) 08 Aug 2024 |
| Liu ShiMeng(Moon dream stars) 09 Aug 2023 |
| Dongguan Yonghang Electronic Technology Co., Ltd |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-only |
\*---------------------------------------------------------*/
#include <cstring>
#include <string>
#include <stdio.h>
#include "RGBController.h"
#include "ResourceManager.h"
#include "SettingsManager.h"
#include "JGINYUEInternalUSBV2Controller.h"
#include "dmiinfo.h"
#define JGINYUE_V2_HID_GENERAL_COMMAND_HEADER 0x01
#define JGINYUE_V2_CDC_COMMAND_HEADER 0x10
#define JGINYUE_V2_HID_REQUEST_MCU_STATUS 0x21
#define JGINYUE_V2_HID_REQUEST_MCUID 0x22
#define JGINYUE_V2_HID_REQUEST_UNLOCK 0x23
#define JGINYUE_V2_HID_DOWNLOAD_SKU 0x24
#define JGINYUE_V2_HID_REQUEST_MCU_STATUS_EX 0x0F
#define JGINYUE_V2_HID_DOWNLOAD_ARGB_SETTING 0x01
#define JGINYUE_V2_HID_DOWNLOAD_GLOBAL_SETTING 0x02
#define JGINYUE_V2_HID_REQUEST_ARGB_SETTING 0x11
#define JGINYUE_V2_HID_REQUEST_GLOBAL_SETTING 0x12
#define FUNCTION_ID_CDC_ARGB 0x01
using namespace std::chrono_literals;
JGINYUEInternalUSBV2Controller::JGINYUEInternalUSBV2Controller(hid_device* jy_hid_device, const char* path,serial_port* jy_cdc_device)
{
DMIInfo dmi;
jy_hid_interface = jy_hid_device;
jy_cdc_interface = jy_cdc_device;
location = path;
device_name = "JGINYUE " + dmi.getMainboard() + " Internal USB Controller V2";
ZoneCount = 0;
support_Global_zone = false;
Init_device();
}
JGINYUEInternalUSBV2Controller::~JGINYUEInternalUSBV2Controller()
{
hid_close(jy_hid_interface);
delete jy_cdc_interface;
}
unsigned int JGINYUEInternalUSBV2Controller::GetZoneCount()
{
return(ZoneCount);
}
std::string JGINYUEInternalUSBV2Controller::GetDeviceLocation()
{
return("HID:" + location);
}
std::string JGINYUEInternalUSBV2Controller::GetDeviceName()
{
return(device_name);
}
std::string JGINYUEInternalUSBV2Controller::GetSerialString()
{
return("");
}
std::string JGINYUEInternalUSBV2Controller::GetDeviceFWVersion()
{
return("");
}
void JGINYUEInternalUSBV2Controller::Init_device()
{
unsigned char usb_buf[64];
memset(usb_buf, 0x00, sizeof(usb_buf));
usb_buf[0] = JGINYUE_V2_HID_GENERAL_COMMAND_HEADER;
usb_buf[1] = 0x0F;
hid_write(jy_hid_interface, usb_buf, 64);
std::this_thread::sleep_for(20ms);
hid_read(jy_hid_interface, usb_buf, 64);
if(usb_buf[1] != 0x0F)
{
ZoneCount = 0x00;
memset(device_config, 0x00, 8*sizeof(AreaConfigurationV2));
memset (&device_config_Global, 0x00, 8*sizeof(AreaConfigurationV2));
return;
}
unsigned char Zone_Info = usb_buf[4];
for(unsigned char i = 0; i < 8; i ++)
{
if(Zone_Info & (1<<i))
{
device_config[ZoneCount].Area_ID = (1<<i);
device_config[ZoneCount].Max_LED_numbers = usb_buf[5+i];
Init_Zone(ZoneCount);
ZoneCount++;
}
}
if(ZoneCount == 0)
{
return;
}
if(support_Global_zone == true)
{
ZoneCount++;
//TODO: Get Global zone information
}
}
void JGINYUEInternalUSBV2Controller::Init_Zone(int zone)
{
unsigned char usb_buf[64];
unsigned char Area_ID = device_config[zone].Area_ID;
memset(usb_buf, 0x00, sizeof(usb_buf));
usb_buf[0] = JGINYUE_V2_HID_GENERAL_COMMAND_HEADER;
usb_buf[1] = JGINYUE_V2_HID_REQUEST_ARGB_SETTING;
usb_buf[2] = Area_ID;
hid_write(jy_hid_interface, usb_buf, 64);
std::this_thread::sleep_for(20ms);
hid_read(jy_hid_interface, usb_buf, 64);
if((usb_buf[1] != JGINYUE_V2_HID_REQUEST_ARGB_SETTING)|(usb_buf[2] != Area_ID))
{
return;
}
device_config[zone].Mode_active = usb_buf[3];
device_config[zone].User_LED_numbers = usb_buf[4];
unsigned char Color_num = ((usb_buf[5] &0x0F)<8 ? (usb_buf[5] &0x0F): 8);
device_config[zone].Color_num = Color_num;
device_config[zone].Direction = (usb_buf[5]&0x10)>>4;
device_config[zone].Speed = usb_buf[6];
device_config[zone].Brightness = usb_buf[7];
memcpy(&(device_config[zone].Color_Array[0]),&(usb_buf[8]),Color_num*3);
return;
}
void JGINYUEInternalUSBV2Controller::WriteZoneMode
(
unsigned char Area,
unsigned char Mode,
unsigned char Num_LED,
std::vector<RGBColor> rgb,
unsigned char Speed,
unsigned char Brightness,
unsigned char Direction
)
{
unsigned char usb_buf[64];
memset(usb_buf, 0x00, sizeof(usb_buf));
unsigned char num_color = rgb.size();
num_color = (num_color < 8) ? num_color : 8;
usb_buf[0] = JGINYUE_V2_HID_GENERAL_COMMAND_HEADER;
usb_buf[1] = JGINYUE_V2_HID_DOWNLOAD_ARGB_SETTING;
usb_buf[2] = Area;
usb_buf[3] = Mode;
usb_buf[4] = Num_LED;
usb_buf[5] = (num_color&0x0F)|((Direction&0x01)<<4);
usb_buf[6] = Speed;
usb_buf[7] = Brightness;
for(unsigned char i = 0; i < num_color; i++)
{
RGBColor color = rgb[i];
usb_buf[8+i*3] = RGBGetRValue(color);
usb_buf[9+i*3] = RGBGetGValue(color);
usb_buf[10+i*3] = RGBGetBValue(color);
}
hid_write(jy_hid_interface, usb_buf, 64);
std::this_thread::sleep_for(10ms);
}
void JGINYUEInternalUSBV2Controller::DirectLEDControl
(
RGBColor* colors,
unsigned char num_LEDs,
unsigned char Area
)
{
unsigned char cdc_buf[512];
memset(cdc_buf, 0x00, sizeof(cdc_buf));
cdc_buf[0] = JGINYUE_V2_CDC_COMMAND_HEADER;
cdc_buf[1] = FUNCTION_ID_CDC_ARGB;
cdc_buf[2] = Area;
cdc_buf[3] = 0x20;
cdc_buf[4] = num_LEDs;
for(unsigned char i = 0; i < num_LEDs; i++)
{
cdc_buf[8+i*3] = RGBGetRValue(colors[i]);
cdc_buf[9+i*3] = RGBGetGValue(colors[i]);
cdc_buf[10+i*3] = RGBGetBValue(colors[i]);
}
int TX_len = 10 + num_LEDs*3;
if(TX_len%64 == 0)
{
TX_len = TX_len+2;
}
jy_cdc_interface->serial_write((char*)cdc_buf,TX_len);
}

144
Controllers/JGINYUEInternalUSBV2Controller/JGINYUEInternalUSBV2Controller.h Normal file
View file

@ -0,0 +1,144 @@
/*---------------------------------------------------------*\
| JGINYUEInternalUSBV2Controller.h |
| |
| Driver for JGINYUE USB motherboard V2 |
| |
| Tong R (tcr020) 09 Aug 2023 |
| Liu ShiMeng(Moon dream stars) 06 Aug 2024 |
| Dongguan Yonghang Electronic Technology Co., Ltd |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-only |
\*---------------------------------------------------------*/
#pragma once
#include <string>
#include <hidapi.h>
#include "serial_port.h"
#include "RGBController.h"
#define JGINYUE_MAX_ZONES 2
#define JGINYUE_ADDRESSABLE_MAX_LEDS 100
enum
{
JGINYUE_USB_V2_MODE_SYNC = 0x0F,
JGINYUE_USB_V2_MODE_OFF = 0x10,
JGINYUE_USB_V2_MODE_STATIC = 0x11,
JGINYUE_USB_V2_MODE_BREATHING = 0x12,
JGINYUE_USB_V2_MODE_CYCLING = 0x14,
JGINYUE_USB_V2_MODE_RANDOM = 0x15,
JGINYUE_USB_V2_MODE_SPRING = 0x16,
JGINYUE_USB_V2_MODE_WAVE = 0x17,
JGINYUE_USB_V2_MODE_WATER = 0x19,
JGINYUE_USB_V2_MODE_RAINBOW = 0x1A,
JGINYUE_USB_V2_MODE_MULTICOLOR_WAVE = 0x1B,
JGINYUE_USB_V2_MODE_MULTICOLOR_CYCLING = 0x1C,
JGINYUE_USB_V2_MODE_SUNRISE = 0x1D,
JGINYUE_USB_V2_MODE_ROTATE_STAR = 0x1E,
JGINYUE_USB_V2_MODE_METEOR = 0x1F,
JGINYUE_USB_V2_MODE_DIRECT = 0x20,
JGINYUE_USB_V2_MODE_CYCLING_BREATHING = 0x21,
JGINYUE_USB_V2_MODE_CYCLING_RAINING = 0x22,
JGINYUE_USB_V2_MODE_MULTICOLOR_WATER_2 = 0x23,
JGINYUE_USB_V2_MODE_MULTICOLOR_WATER_1 = 0x24,
JGINYUE_USB_V2_MODE_HOURGLASS = 0x25
};
enum
{
JGINYUE_USB_SPEED_MAX = 0xFF,
JGINYUE_USB_SPEED_MIN = 0x00,
JGINYUE_USB_SPEED_DEFAULT = 0x80
};
enum
{
JGINYUE_DIRECTION_RIGHT = 0x00,
JGINYUE_DIRECTION_LEFT = 0x01
};
enum
{
JGINYUE_USB_BRIGHTNESS_MAX = 0xFF,
JGINYUE_USB_BRIGHTNESS_MIN = 0x00,
JGINYUE_USB_BRIGHTNESS_DEFAULT = 0xFF
};
enum
{
JGINYUE_USB_V2_ARGB_STRIP_1 = 0x01,
JGINYUE_USB_V2_ARGB_STRIP_2 = 0x02,
JGINYUE_USB_V2_ARGB_FAN_1 = 0x04,
JGINYUE_USB_V2_ARGB_FAN_2 = 0x08,
JGINYUE_USB_V2_ARGB_FAN_3 = 0x10,
JGINYUE_USB_V2_ARGB_FAN_4 = 0x20,
JGINYUE_USB_V2_ARGB_FAN_5 = 0x40,
};
struct AreaConfigurationV2
{
unsigned char Area_ID;
unsigned char Max_LED_numbers;
unsigned char User_LED_numbers;
unsigned char Direction;
unsigned char Direct_Mode_control; /* 0x00 = Disabled, 0x01 = Enabled */
unsigned char Mode_active;
unsigned char Color_num;
unsigned char Color_Array[30];
unsigned char Brightness;
unsigned char Speed;
};
class JGINYUEInternalUSBV2Controller
{
public:
JGINYUEInternalUSBV2Controller(hid_device* jy_hid_device, const char* path,serial_port* jy_cdc_device);
~JGINYUEInternalUSBV2Controller();
unsigned int GetZoneCount();
std::string GetDeviceLocation();
std::string GetDeviceName();
std::string GetSerialString();
std::string GetDeviceFWVersion();
void WriteZoneMode
(
unsigned char Area,
unsigned char Mode,
unsigned char Num_LED,
std::vector<RGBColor> rgb,
unsigned char Speed,
unsigned char Brightness,
unsigned char Direction
);
void DirectLEDControl
(
RGBColor* colors,
unsigned char num_LEDs,
unsigned char Area
);
AreaConfigurationV2 device_config[8];
//TODO,When the perzone mode is supported, these parameters will be used to download device configuartion from the device
AreaConfigurationV2 device_config_Global;
//TODO,Can sync its data to other zones,will be used once the perzone mode is supported
bool support_Global_zone;
private:
void Init_device();
void Init_Zone(int zone);
unsigned char ZoneCount;
unsigned char SKUID;
unsigned char Major_version;
unsigned char Minor_version;
unsigned char FPS; //0x00 = 120FPS, 0x01 = 60FPS
hid_device* jy_hid_interface;
serial_port* jy_cdc_interface;
std::string location;
std::string device_name;
};

80
Controllers/JGINYUEInternalUSBV2Controller/JGINYUEInternalUSBV2ControllerDetect.cpp Normal file
View file

@ -0,0 +1,80 @@
/*---------------------------------------------------------*\
| JGINYUEInternalUSBV2ControllerDetect.cpp |
| |
| Detector for JGINYUE USB motherboard V2 |
| |
| Tong R (tcr020) 06 Aug 2024 |
| Liu ShiMeng(Moon dream stars) 09 Aug 2023 |
| Dongguan Yonghang Electronic Technology Co., Ltd |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-only |
\*---------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <vector>
#include <hidapi.h>
#include "serial_port.h"
#include "find_usb_serial_port.h"
#include "RGBController_JGINYUEInternalUSBV2.h"
#include "JGINYUEInternalUSBV2Controller.h"
#include "RGBController.h"
#include "Detector.h"
#include "dmiinfo.h"
#include "LogManager.h"
/*---------------------------------------------------------*\
| JGINYUE vendor ID |
\*---------------------------------------------------------*/
#define JGINYUE_VID_V2 0x1A86
/*---------------------------------------------------------*\
| JGINYUE product ID |
\*---------------------------------------------------------*/
#define JGINYUE_MOTHERBOARD_PID_V2 0xE30B
void DetectJGINYUEInternalUSBV2Controller(hid_device_info* info,const std::string& /*name*/)
{
hid_device* hid_dev = hid_open_path(info->path);
if(hid_dev == nullptr )
{
return;
}
DMIInfo dmi_info;
std::string manufacturer = dmi_info.getManufacturer();
std::transform(manufacturer.begin(), manufacturer.end(), manufacturer.begin(), ::toupper);
if(manufacturer.find("JGINYUE") == std::string::npos)
{
LOG_INFO("JGINYUE Internal USB ControllerV2 not found,error manufacturer name:%s",manufacturer.c_str());
return;
}
LOG_INFO("Pass manufacture name check.Start to init HID and CDC interface");
if(hid_dev != nullptr )
{
std::vector<std::string*> serial_ports = find_usb_serial_port(JGINYUE_VID_V2, JGINYUE_MOTHERBOARD_PID_V2);
if(serial_ports.size() ==1)
{
serial_port *port = new serial_port();
if(!port->serial_open(serial_ports[0]->c_str(), 115200))
{
LOG_ERROR("Failed to open serial port %s", serial_ports[0]->c_str());
delete port;
hid_close(hid_dev);
return;
}
JGINYUEInternalUSBV2Controller *controller = new JGINYUEInternalUSBV2Controller(hid_dev, info->path,port);
RGBController_JGINYUEInternalUSBV2 *rgb_controller = new RGBController_JGINYUEInternalUSBV2(controller);
ResourceManager::get()->RegisterRGBController(rgb_controller);
LOG_INFO("JGINYUE Internal USB ControllerV2 found");
}
}
}
#ifdef _WIN32
REGISTER_HID_DETECTOR("JGINYUE Internal USB ControllerV2", DetectJGINYUEInternalUSBV2Controller, JGINYUE_VID_V2, JGINYUE_MOTHERBOARD_PID_V2);
#else
REGISTER_HID_DETECTOR_IPU("JGINYUE Internal USB ControllerV2", DetectJGINYUEInternalUSBV2Controller, JGINYUE_VID_V2, JGINYUE_MOTHERBOARD_PID_V2, 0, 0xFF00, 1);
#endif

505
Controllers/JGINYUEInternalUSBV2Controller/RGBController_JGINYUEInternalUSBV2.cpp Normal file
View file

@ -0,0 +1,505 @@
/*---------------------------------------------------------*\
| RGBController_JGINYUEInternalUSBV2.cpp |
| |
| RGBController for JGINYUE USB motherboard V2 |
| |
| Tong R (tcr020) 03 July 2024 |
| Liu ShiMeng(Moon dream stars) 09 Aug 2023 |
| Dongguan Yonghang Electronic Technology Co., Ltd |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-only |
\*---------------------------------------------------------*/
#include <string.h>
#include "RGBController_JGINYUEInternalUSBV2.h"
#define JGINYUE_MAX_ZONES 2
#define JGINYUE_ADDRESSABLE_MAX_LEDS 100
/**------------------------------------------------------------------*\
@name JGINYUEInternalUSBV2
@category MotherBoard
@type USB
@save :x:
@direct :white_check_mark:
@effects :white_check_mark:
@detectors DetectJGINYUEInternalUSBV2
@comment Insert multiline JGINYUEInternalUSBV2 comment here
\*--------------------------------------------------------------------*/
RGBController_JGINYUEInternalUSBV2::RGBController_JGINYUEInternalUSBV2(JGINYUEInternalUSBV2Controller* controller_ptr)
{
controller = controller_ptr;
name = controller->GetDeviceName();
description = "JGINYUE USB ARGB Device";
vendor = "JGINYUE";
type = DEVICE_TYPE_MOTHERBOARD;
location = controller->GetDeviceLocation();
version = controller->GetDeviceFWVersion();
mode Direct;
Direct.name = "Direct";
Direct.value = JGINYUE_USB_V2_MODE_DIRECT;
Direct.flags = MODE_FLAG_HAS_PER_LED_COLOR;
Direct.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Direct);
mode Off;
Off.name = "Off";
Off.value = JGINYUE_USB_V2_MODE_OFF;
Off.flags = 0;
Off.color_mode = MODE_COLORS_NONE;
modes.push_back(Off);
mode Static;
Static.name = "Static";
Static.value = JGINYUE_USB_V2_MODE_STATIC;
Static.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR|MODE_FLAG_HAS_BRIGHTNESS;
Static.color_mode = MODE_COLORS_MODE_SPECIFIC;
Static.colors_max = 1;
Static.colors_min = 1;
Static.brightness = JGINYUE_USB_BRIGHTNESS_DEFAULT;
Static.brightness_max = JGINYUE_USB_BRIGHTNESS_MAX;
Static.brightness_min = JGINYUE_USB_BRIGHTNESS_MIN;
Static.colors.resize(1);
modes.push_back(Static);
mode Breathing;
Breathing.name = "Breathing";
Breathing.value = JGINYUE_USB_V2_MODE_BREATHING;
Breathing.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
Breathing.color_mode = MODE_COLORS_MODE_SPECIFIC;
Breathing.colors_max = 1;
Breathing.colors_min = 1;
Breathing.brightness = JGINYUE_USB_BRIGHTNESS_DEFAULT;
Breathing.brightness_max = JGINYUE_USB_BRIGHTNESS_MAX;
Breathing.brightness_min = JGINYUE_USB_BRIGHTNESS_MIN;
Breathing.speed = JGINYUE_USB_SPEED_DEFAULT;
Breathing.speed_max = JGINYUE_USB_SPEED_MAX;
Breathing.speed_min = JGINYUE_USB_SPEED_MIN;
Breathing.colors.resize(1);
modes.push_back(Breathing);
mode Cycling;
Cycling.name = "Cycling";
Cycling.value = JGINYUE_USB_V2_MODE_CYCLING;
Cycling.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_DIRECTION_LR;
Cycling.color_mode = MODE_COLORS_NONE;
Cycling.brightness = JGINYUE_USB_BRIGHTNESS_DEFAULT;
Cycling.brightness_max = JGINYUE_USB_BRIGHTNESS_MAX;
Cycling.brightness_min = JGINYUE_USB_BRIGHTNESS_MIN;
Cycling.speed = JGINYUE_USB_SPEED_DEFAULT;
Cycling.speed_max = JGINYUE_USB_SPEED_MAX;
Cycling.speed_min = JGINYUE_USB_SPEED_MIN;
Cycling.direction = JGINYUE_DIRECTION_RIGHT;
modes.push_back(Cycling);
mode Random;
Random.name = "Random";
Random.value = JGINYUE_USB_V2_MODE_RANDOM;
Random.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
Random.color_mode = MODE_COLORS_NONE;
Random.brightness = JGINYUE_USB_BRIGHTNESS_DEFAULT;
Random.brightness_max = JGINYUE_USB_BRIGHTNESS_MAX;
Random.brightness_min = JGINYUE_USB_BRIGHTNESS_MIN;
Random.speed = JGINYUE_USB_SPEED_DEFAULT;
Random.speed_max = JGINYUE_USB_SPEED_MAX;
Random.speed_min = JGINYUE_USB_SPEED_MIN;
modes.push_back(Random);
mode Wave;
Wave.name = "Wave";
Wave.value = JGINYUE_USB_V2_MODE_WAVE;
Wave.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS| MODE_FLAG_HAS_DIRECTION_LR;
Wave.color_mode = MODE_COLORS_MODE_SPECIFIC;
Wave.colors_max = 1;
Wave.colors_min = 1;
Wave.brightness = JGINYUE_USB_BRIGHTNESS_DEFAULT;
Wave.brightness_max = JGINYUE_USB_BRIGHTNESS_MAX;
Wave.brightness_min = JGINYUE_USB_BRIGHTNESS_MIN;
Wave.speed = JGINYUE_USB_SPEED_DEFAULT;
Wave.speed_max = JGINYUE_USB_SPEED_MAX;
Wave.speed_min = JGINYUE_USB_SPEED_MIN;
Wave.direction = JGINYUE_DIRECTION_LEFT;
Wave.colors.resize(1);
modes.push_back(Wave);
mode Spring;
Spring.name = "Spring";
Spring.value = JGINYUE_USB_V2_MODE_SPRING;
Spring.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS| MODE_FLAG_HAS_DIRECTION_LR;
Spring.color_mode = MODE_COLORS_MODE_SPECIFIC;
Spring.colors_max = 1;
Spring.colors_min = 1;
Spring.brightness = JGINYUE_USB_BRIGHTNESS_DEFAULT;
Spring.brightness_max = JGINYUE_USB_BRIGHTNESS_MAX;
Spring.brightness_min = JGINYUE_USB_BRIGHTNESS_MIN;
Spring.speed = JGINYUE_USB_SPEED_DEFAULT;
Spring.speed_max = JGINYUE_USB_SPEED_MAX;
Spring.speed_min = JGINYUE_USB_SPEED_MIN;
Spring.direction = JGINYUE_DIRECTION_RIGHT;
Spring.colors.resize(1);
//modes.push_back(Spring);
mode Water;
Water.name = "Water";
Water.value = JGINYUE_USB_V2_MODE_WATER;
Water.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR |MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_DIRECTION_LR;
Water.color_mode = MODE_COLORS_MODE_SPECIFIC;
Water.colors_max = 1;
Water.colors_min = 1;
Water.brightness = JGINYUE_USB_BRIGHTNESS_DEFAULT;
Water.brightness_max = JGINYUE_USB_BRIGHTNESS_MAX;
Water.brightness_min = JGINYUE_USB_BRIGHTNESS_MIN;
Water.speed = JGINYUE_USB_SPEED_DEFAULT;
Water.speed_max = JGINYUE_USB_SPEED_MAX;
Water.speed_min = JGINYUE_USB_SPEED_MIN;
Water.direction = MODE_DIRECTION_RIGHT;
Water.colors.resize(1);
modes.push_back(Water);
mode Rainbow;
Rainbow.name = "Rainbow";
Rainbow.value = JGINYUE_USB_V2_MODE_RAINBOW;
Rainbow.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_DIRECTION_LR;
Rainbow.color_mode = MODE_COLORS_NONE;
Rainbow.brightness = JGINYUE_USB_BRIGHTNESS_DEFAULT;
Rainbow.brightness_max = JGINYUE_USB_BRIGHTNESS_MAX;
Rainbow.brightness_min = JGINYUE_USB_BRIGHTNESS_MIN;
Rainbow.speed = JGINYUE_USB_SPEED_DEFAULT;
Rainbow.speed_max = JGINYUE_USB_SPEED_MAX;
Rainbow.speed_min = JGINYUE_USB_SPEED_MIN;
Rainbow.direction = MODE_DIRECTION_RIGHT;
modes.push_back(Rainbow);
mode MulticolorCycling;
MulticolorCycling.name = "Multicolor CYCLING";
MulticolorCycling.value = JGINYUE_USB_V2_MODE_MULTICOLOR_CYCLING;
MulticolorCycling.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_DIRECTION_LR;
MulticolorCycling.color_mode = MODE_COLORS_MODE_SPECIFIC;
MulticolorCycling.colors_max = 8;
MulticolorCycling.colors_min = 1;
MulticolorCycling.brightness = JGINYUE_USB_BRIGHTNESS_DEFAULT;
MulticolorCycling.brightness_max = JGINYUE_USB_BRIGHTNESS_MAX;
MulticolorCycling.brightness_min = JGINYUE_USB_BRIGHTNESS_MIN;
MulticolorCycling.speed = JGINYUE_USB_SPEED_DEFAULT;
MulticolorCycling.speed_max = JGINYUE_USB_SPEED_MAX;
MulticolorCycling.speed_min = JGINYUE_USB_SPEED_MIN;
MulticolorCycling.direction = MODE_DIRECTION_RIGHT;
MulticolorCycling.colors.resize(8);
modes.push_back(MulticolorCycling);
mode Sunrise;
Sunrise.name = "Sunrise";
Sunrise.value = JGINYUE_USB_V2_MODE_SUNRISE;
Sunrise.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_DIRECTION_LR;
Sunrise.color_mode = MODE_COLORS_MODE_SPECIFIC;
Sunrise.colors_max = 8;
Sunrise.colors_min = 1;
Sunrise.brightness = JGINYUE_USB_BRIGHTNESS_DEFAULT;
Sunrise.brightness_max = JGINYUE_USB_BRIGHTNESS_MAX;
Sunrise.brightness_min = JGINYUE_USB_BRIGHTNESS_MIN;
Sunrise.speed = JGINYUE_USB_SPEED_DEFAULT;
Sunrise.speed_max = JGINYUE_USB_SPEED_MAX;
Sunrise.speed_min = JGINYUE_USB_SPEED_MIN;
Sunrise.direction = MODE_DIRECTION_RIGHT;
Sunrise.colors.resize(8);
modes.push_back(Sunrise);
mode Rotate_star;
Rotate_star.name = "Rotate Star";
Rotate_star.value = JGINYUE_USB_V2_MODE_ROTATE_STAR;
Rotate_star.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_DIRECTION_LR;
Rotate_star.color_mode = MODE_COLORS_MODE_SPECIFIC;
Rotate_star.colors_max = 8;
Rotate_star.colors_min = 1;
Rotate_star.brightness = JGINYUE_USB_BRIGHTNESS_DEFAULT;
Rotate_star.brightness_max = JGINYUE_USB_BRIGHTNESS_MAX;
Rotate_star.brightness_min = JGINYUE_USB_BRIGHTNESS_MIN;
Rotate_star.speed = JGINYUE_USB_SPEED_DEFAULT;
Rotate_star.speed_max = JGINYUE_USB_SPEED_MAX;
Rotate_star.speed_min = JGINYUE_USB_SPEED_MIN;
Rotate_star.direction = MODE_DIRECTION_RIGHT;
Rotate_star.colors.resize(8);
modes.push_back(Rotate_star);
mode Meteor;
Meteor.name = "Meteor";
Meteor.value = JGINYUE_USB_V2_MODE_METEOR;
Meteor.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_DIRECTION_LR;
Meteor.color_mode = MODE_COLORS_MODE_SPECIFIC;
Meteor.colors_max = 1;
Meteor.colors_min = 1;
Meteor.brightness = JGINYUE_USB_BRIGHTNESS_DEFAULT;
Meteor.brightness_max = JGINYUE_USB_BRIGHTNESS_MAX;
Meteor.brightness_min = JGINYUE_USB_BRIGHTNESS_MIN;
Meteor.speed = JGINYUE_USB_SPEED_DEFAULT;
Meteor.speed_max = JGINYUE_USB_SPEED_MAX;
Meteor.speed_min = JGINYUE_USB_SPEED_MIN;
Meteor.direction = MODE_DIRECTION_RIGHT;
Meteor.colors.resize(8);
modes.push_back(Meteor);
mode Cycling_Breathing;
Cycling_Breathing.name = "Cycling Breathing";
Cycling_Breathing.value = JGINYUE_USB_V2_MODE_CYCLING_BREATHING;
Cycling_Breathing.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_DIRECTION_LR;
Cycling_Breathing.color_mode = MODE_COLORS_MODE_SPECIFIC;
Cycling_Breathing.colors_max = 8;
Cycling_Breathing.colors_min = 1;
Cycling_Breathing.brightness = JGINYUE_USB_BRIGHTNESS_DEFAULT;
Cycling_Breathing.brightness_max = JGINYUE_USB_BRIGHTNESS_MAX;
Cycling_Breathing.brightness_min = JGINYUE_USB_BRIGHTNESS_MIN;
Cycling_Breathing.speed = JGINYUE_USB_SPEED_DEFAULT;
Cycling_Breathing.speed_max = JGINYUE_USB_SPEED_MAX;
Cycling_Breathing.speed_min = JGINYUE_USB_SPEED_MIN;
Cycling_Breathing.direction = MODE_DIRECTION_RIGHT;
Cycling_Breathing.colors.resize(8);
modes.push_back(Cycling_Breathing);
mode Raining;
Raining.name = "Raining";
Raining.value = JGINYUE_USB_V2_MODE_CYCLING_RAINING;
Raining.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_DIRECTION_LR;
Raining.color_mode = MODE_COLORS_MODE_SPECIFIC;
Raining.colors_max = 1;
Raining.colors_min = 1;
Raining.brightness = JGINYUE_USB_BRIGHTNESS_DEFAULT;
Raining.brightness_max = JGINYUE_USB_BRIGHTNESS_MAX;
Raining.brightness_min = JGINYUE_USB_BRIGHTNESS_MIN;
Raining.speed = JGINYUE_USB_SPEED_DEFAULT;
Raining.speed_max = JGINYUE_USB_SPEED_MAX;
Raining.speed_min = JGINYUE_USB_SPEED_MIN;
Raining.direction = MODE_DIRECTION_RIGHT;
Raining.colors.resize(8);
modes.push_back(Raining);
mode MulticolorWater1;
MulticolorWater1.name = "Multicolor Water 1";
MulticolorWater1.value = JGINYUE_USB_V2_MODE_MULTICOLOR_WATER_1;
MulticolorWater1.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_DIRECTION_LR;
MulticolorWater1.color_mode = MODE_COLORS_MODE_SPECIFIC;
MulticolorWater1.colors_max = 8;
MulticolorWater1.colors_min = 1;
MulticolorWater1.brightness = JGINYUE_USB_BRIGHTNESS_DEFAULT;
MulticolorWater1.brightness_max = JGINYUE_USB_BRIGHTNESS_MAX;
MulticolorWater1.brightness_min = JGINYUE_USB_BRIGHTNESS_MIN;
MulticolorWater1.speed = JGINYUE_USB_SPEED_DEFAULT;
MulticolorWater1.speed_max = JGINYUE_USB_SPEED_MAX;
MulticolorWater1.speed_min = JGINYUE_USB_SPEED_MIN;
MulticolorWater1.direction = JGINYUE_DIRECTION_LEFT;
MulticolorWater1.colors.resize(8);
modes.push_back(MulticolorWater1);
mode MulticolorWater2;
MulticolorWater2.name = "Multicolor Water 2";
MulticolorWater2.value = JGINYUE_USB_V2_MODE_MULTICOLOR_WATER_2;
MulticolorWater2.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_DIRECTION_LR;
MulticolorWater2.color_mode = MODE_COLORS_MODE_SPECIFIC;
MulticolorWater2.colors_max = 8;
MulticolorWater2.colors_min = 1;
MulticolorWater2.brightness = JGINYUE_USB_BRIGHTNESS_DEFAULT;
MulticolorWater2.brightness_max = JGINYUE_USB_BRIGHTNESS_MAX;
MulticolorWater2.brightness_min = JGINYUE_USB_BRIGHTNESS_MIN;
MulticolorWater2.speed = JGINYUE_USB_SPEED_DEFAULT;
MulticolorWater2.speed_max = JGINYUE_USB_SPEED_MAX;
MulticolorWater2.speed_min = JGINYUE_USB_SPEED_MIN;
MulticolorWater2.direction = JGINYUE_DIRECTION_LEFT;
MulticolorWater2.colors.resize(8);
modes.push_back(MulticolorWater2);
mode Hourglass;
Hourglass.name = "Hourglass";
Hourglass.value = JGINYUE_USB_V2_MODE_HOURGLASS;
Hourglass.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_DIRECTION_LR;
Hourglass.color_mode = MODE_COLORS_MODE_SPECIFIC;
Hourglass.colors_max = 3;
Hourglass.colors_min = 3;
Hourglass.brightness = JGINYUE_USB_BRIGHTNESS_DEFAULT;
Hourglass.brightness_max = JGINYUE_USB_BRIGHTNESS_MAX;
Hourglass.brightness_min = JGINYUE_USB_BRIGHTNESS_MIN;
Hourglass.speed = JGINYUE_USB_SPEED_DEFAULT;
Hourglass.speed_max = JGINYUE_USB_SPEED_MAX;
Hourglass.speed_min = JGINYUE_USB_SPEED_MIN;
Hourglass.direction = MODE_DIRECTION_RIGHT;
Hourglass.colors.resize(8);
//modes.push_back(Hourglass);
InitZones();
}
void RGBController_JGINYUEInternalUSBV2::SetupZones()
{
/*-------------------------------------------------*\
| Clear any existing color/LED configuration |
\*-------------------------------------------------*/
leds.clear();
colors.clear();
/*-------------------------------------------------*\
| Set zones and leds |
\*-------------------------------------------------*/
unsigned char normal_zone_count = controller->GetZoneCount();
if((controller->support_Global_zone == true)&&(normal_zone_count>1))
{
normal_zone_count --;
//TODO support_Global_zone
}
for(unsigned int zone_idx = 0; zone_idx < normal_zone_count; zone_idx++)
{
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 + " LED#" + std::to_string(led_idx + 1);
new_led.value = 0;
leds.push_back(new_led);
}
}
SetupColors();
}
void RGBController_JGINYUEInternalUSBV2::ResizeZone(int zone, int new_size)
{
unsigned char area;
area = controller->device_config[zone].Area_ID;
zones[zone].leds_count = new_size;
SetupZones();
if(modes[active_mode].value == JGINYUE_USB_V2_MODE_DIRECT)
{
controller->DirectLEDControl(zones[zone].colors,new_size,area);
}
else
{
controller->WriteZoneMode(area,modes[active_mode].value,new_size,modes[active_mode].colors,modes[active_mode].speed,modes[active_mode].brightness,modes[active_mode].direction);
}
}
void RGBController_JGINYUEInternalUSBV2::DeviceUpdateLEDs()
{
unsigned char normal_zone_count = controller->GetZoneCount();
if((controller->support_Global_zone == true)&&(normal_zone_count>1))
{
normal_zone_count --;
//TODO support_Global_zone
}
for(int i = 0; i < normal_zone_count; i++)
{
UpdateZoneLEDs(i);
}
}
void RGBController_JGINYUEInternalUSBV2::UpdateZoneLEDs(int zone)
{
unsigned char area;
area = controller->device_config[zone].Area_ID;
controller->DirectLEDControl(zones[zone].colors,zones[zone].leds_count,area);
}
void RGBController_JGINYUEInternalUSBV2::UpdateSingleLED(int led)
{
int zone;
zone = leds[led].value;
UpdateZoneLEDs(zone);
}
void RGBController_JGINYUEInternalUSBV2::DeviceUpdateMode()
{
unsigned char area;
if(modes[active_mode].value == JGINYUE_USB_V2_MODE_DIRECT)
{
DeviceUpdateLEDs();
return;
}
unsigned char Area_num = 0;
if(controller->support_Global_zone == true)
{
Area_num = controller->GetZoneCount()-1;
}
else
{
Area_num = controller->GetZoneCount();
}
for(size_t i = 0; i < Area_num; i++)
{
DeviceUpdateZoneMode(i);
}
}
void RGBController_JGINYUEInternalUSBV2::DeviceUpdateZoneMode(int zone)
{
unsigned char Area_ID = controller->device_config[zone].Area_ID;
controller->WriteZoneMode(
Area_ID,
modes[active_mode].value,
zones[zone].leds_count,
modes[active_mode].colors,
modes[active_mode].speed,
modes[active_mode].brightness,
modes[active_mode].direction);
}
void RGBController_JGINYUEInternalUSBV2::InitZones()
{
unsigned char normal_zone_count = controller->GetZoneCount();
zones.clear();
zones.resize(normal_zone_count);
if((controller->support_Global_zone == true)&&(normal_zone_count>1))
{
normal_zone_count --;
//TODO support_Global_zone
}
for(size_t i = 0; i < normal_zone_count; i++)
{
zone * zone_to_init = &(zones[i]);
AreaConfigurationV2 * cfg = &(controller->device_config[i]);
zone_to_init->leds_min = 0;
zone_to_init->leds_max = cfg->Max_LED_numbers;
zone_to_init->leds_count = 0;
zone_to_init->type = ZONE_TYPE_LINEAR;
zone_to_init->matrix_map = NULL;
switch(cfg->Area_ID)
{
case JGINYUE_USB_V2_ARGB_STRIP_1:
zone_to_init->name = "ARGB Strip Header 1";
break;
case JGINYUE_USB_V2_ARGB_STRIP_2:
zone_to_init->name = "ARGB Strip Header 2";
break;
case JGINYUE_USB_V2_ARGB_FAN_1:
zone_to_init->name = "ARGB Fan Header 1";
break;
case JGINYUE_USB_V2_ARGB_FAN_2:
zone_to_init->name = "ARGB Fan Header 2";
break;
case JGINYUE_USB_V2_ARGB_FAN_3:
zone_to_init->name = "ARGB Fan Header 3";
break;
case JGINYUE_USB_V2_ARGB_FAN_4:
zone_to_init->name = "ARGB Fan Header 4";
break;
case JGINYUE_USB_V2_ARGB_FAN_5:
zone_to_init->name = "ARGB Fan Header 5";
break;
default:
zone_to_init->name = "Unknow Device";
break;
}
}
SetupZones();
}

38
Controllers/JGINYUEInternalUSBV2Controller/RGBController_JGINYUEInternalUSBV2.h Normal file
View file

@ -0,0 +1,38 @@
/*---------------------------------------------------------*\
| RGBController_JGINYUEInternalUSBV2.h |
| |
| RGBController for JGINYUE USB motherboard V2 |
| |
| Tong R (tcr020) 03 July 2023 |
| Liu ShiMeng(Moon dream stars) 06 Aug 2024 |
| Dongguan Yonghang Electronic Technology Co., Ltd |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-only |
\*---------------------------------------------------------*/
#pragma once
#include "RGBController.h"
#include "JGINYUEInternalUSBV2Controller.h"
class RGBController_JGINYUEInternalUSBV2 : public RGBController
{
public:
RGBController_JGINYUEInternalUSBV2(JGINYUEInternalUSBV2Controller* controller_ptr);
void SetupZones();
void ResizeZone(int zone, int new_size);
void DeviceUpdateLEDs();
void UpdateZoneLEDs(int zone);
void UpdateSingleLED(int led);
void DeviceUpdateMode();
void DeviceUpdateZoneMode(int zone);
private:
JGINYUEInternalUSBV2Controller* controller;
void InitZones();
};