diff --git a/Controllers/JGINYUEInternalUSBController/RGBController_JGINYUEInternalUSB.cpp b/Controllers/JGINYUEInternalUSBController/RGBController_JGINYUEInternalUSB.cpp index b1308956..353057a9 100644 --- a/Controllers/JGINYUEInternalUSBController/RGBController_JGINYUEInternalUSB.cpp +++ b/Controllers/JGINYUEInternalUSBController/RGBController_JGINYUEInternalUSB.cpp @@ -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); } } diff --git a/Controllers/JGINYUEInternalUSBV2Controller/JGINYUEInternalUSBV2Controller.cpp b/Controllers/JGINYUEInternalUSBV2Controller/JGINYUEInternalUSBV2Controller.cpp new file mode 100644 index 00000000..868c9553 --- /dev/null +++ b/Controllers/JGINYUEInternalUSBV2Controller/JGINYUEInternalUSBV2Controller.cpp @@ -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 +#include +#include +#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<>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 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); +} \ No newline at end of file diff --git a/Controllers/JGINYUEInternalUSBV2Controller/JGINYUEInternalUSBV2Controller.h b/Controllers/JGINYUEInternalUSBV2Controller/JGINYUEInternalUSBV2Controller.h new file mode 100644 index 00000000..acabd464 --- /dev/null +++ b/Controllers/JGINYUEInternalUSBV2Controller/JGINYUEInternalUSBV2Controller.h @@ -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 +#include +#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 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; +}; diff --git a/Controllers/JGINYUEInternalUSBV2Controller/JGINYUEInternalUSBV2ControllerDetect.cpp b/Controllers/JGINYUEInternalUSBV2Controller/JGINYUEInternalUSBV2ControllerDetect.cpp new file mode 100644 index 00000000..3bd16b1c --- /dev/null +++ b/Controllers/JGINYUEInternalUSBV2Controller/JGINYUEInternalUSBV2ControllerDetect.cpp @@ -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 +#include +#include +#include +#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 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 diff --git a/Controllers/JGINYUEInternalUSBV2Controller/RGBController_JGINYUEInternalUSBV2.cpp b/Controllers/JGINYUEInternalUSBV2Controller/RGBController_JGINYUEInternalUSBV2.cpp new file mode 100644 index 00000000..ddaf49df --- /dev/null +++ b/Controllers/JGINYUEInternalUSBV2Controller/RGBController_JGINYUEInternalUSBV2.cpp @@ -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 +#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(); +} diff --git a/Controllers/JGINYUEInternalUSBV2Controller/RGBController_JGINYUEInternalUSBV2.h b/Controllers/JGINYUEInternalUSBV2Controller/RGBController_JGINYUEInternalUSBV2.h new file mode 100644 index 00000000..765cae8e --- /dev/null +++ b/Controllers/JGINYUEInternalUSBV2Controller/RGBController_JGINYUEInternalUSBV2.h @@ -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(); +};