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

Initial support for Corsair Hydro Series devices (only H100i Pro RGB for now)

Browse source
This commit is contained in:
Adam Honse 2020-08-18 00:28:05 -05:00
parent 4f5cf83e47
commit 68a16fadc2
7 changed files with 317 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

7
60-openrgb.rules
View file

@ -43,6 +43,13 @@ SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="18f3", TAG+="uacces
#---------------------------------------------------------------#
SUBSYSTEMS=="usb", ATTR{idVendor}=="2516", ATTR{idProduct}=="0109", TAG+="uaccess"
#---------------------------------------------------------------#
# Corsair Hydro Series Devices #
# #
# Corsair H100i Pro RGB #
#---------------------------------------------------------------#
SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="0c15", TAG+="uaccess"
#---------------------------------------------------------------#
# Corsair Lighting Node Devices #
# #

69
Controllers/CorsairHydroController/CorsairHydroController.cpp Normal file
View file

@ -0,0 +1,69 @@
/*---------------------------------------------------------*\
| Processing Code for Corsair Hydro Series |
| |
| Adam Honse (calcprogrammer1@gmail.com), 8/17/2020 |
\*---------------------------------------------------------*/
#include "CorsairHydroController.h"
CorsairHydroController::CorsairHydroController(libusb_device_handle* dev_handle)
{
dev = dev_handle;
SendFirmwareRequest();
}
std::string CorsairHydroController::GetFirmwareString()
{
return(firmware_version);
}
void CorsairHydroController::SendFirmwareRequest()
{
unsigned char usb_buf[8];
int actual;
usb_buf[0] = 0xAA;
libusb_bulk_transfer(dev, 0x01, usb_buf, 1, &actual, 1000);
libusb_bulk_transfer(dev, 0x81, usb_buf, 7, &actual, 1000);
firmware_version = std::to_string(usb_buf[3]) + "." + std::to_string(usb_buf[4]) + "." + std::to_string(usb_buf[5]) + "." + std::to_string(usb_buf[6]);
}
void CorsairHydroController::SetFixed
(
unsigned char red,
unsigned char green,
unsigned char blue
)
{
unsigned char usb_buf[8];
int actual;
usb_buf[0] = 0x56;
usb_buf[1] = 0x02;
usb_buf[2] = red;
usb_buf[3] = green;
usb_buf[4] = blue;
usb_buf[5] = red;
usb_buf[6] = green;
usb_buf[7] = blue;
libusb_bulk_transfer(dev, 0x01, usb_buf, 8, &actual, 1000);
libusb_bulk_transfer(dev, 0x81, usb_buf, 3, &actual, 1000);
SendApply();
}
void CorsairHydroController::SendApply()
{
unsigned char usb_buf[3];
int actual;
usb_buf[0] = 0x55;
usb_buf[1] = 0x01;
libusb_bulk_transfer(dev, 0x01, usb_buf, 2, &actual, 1000);
libusb_bulk_transfer(dev, 0x81, usb_buf, 3, &actual, 1000);
}

55
Controllers/CorsairHydroController/CorsairHydroController.h Normal file
View file

@ -0,0 +1,55 @@
/*---------------------------------------------------------*\
| Definitions for Corsair Hydro Series |
| |
| Adam Honse (calcprogrammer1@gmail.com), 8/17/2020 |
\*---------------------------------------------------------*/
#include "RGBController.h"
#include <vector>
#include <libusb-1.0/libusb.h>
#pragma once
enum
{
CORSAIR_HYDRO_CMD_READ_PUMP_SPEED = 0x31,
CORSAIR_HYDRO_CMD_WRITE_PUMP_MODE = 0x32,
CORSAIR_HYDRO_CMD_READ_PUMP_MODE = 0x33,
CORSAIR_HYDRO_CMD_READ_FAN_SPEED = 0x41,
CORSAIR_HYDRO_CMD_READ_AIO_TEMP = 0xA9,
CORSAIR_HYDRO_CMD_READ_FIRMWARE = 0xAA,
};
enum
{
CORSAIR_HYDRO_PUMP_MODE_QUIET = 0x00,
CORSAIR_HYDRO_PUMP_MODE_BALANCED = 0x01,
CORSAIR_HYDRO_PUMP_MODE_PERFORMANCE = 0x02,
};
class CorsairHydroController
{
public:
CorsairHydroController(libusb_device_handle* dev_handle);
~CorsairHydroController();
unsigned char GetFanPercent(unsigned char fan_channel);
unsigned short GetFanRPM(unsigned char fan_channel);
std::string GetFirmwareString();
void SetFixed
(
unsigned char red,
unsigned char green,
unsigned char blue
);
private:
libusb_device_handle* dev;
std::string firmware_version;
void SendApply();
void SendFirmwareRequest();
};

70
Controllers/CorsairHydroController/CorsairHydroControllerDetect.cpp Normal file
View file

@ -0,0 +1,70 @@
#include "Detector.h"
#include "CorsairHydroController.h"
#include "RGBController.h"
#include "RGBController_CorsairHydro.h"
#include <vector>
#include <libusb-1.0/libusb.h>
/*-----------------------------------------------------*\
| Corsair vendor ID |
\*-----------------------------------------------------*/
#define CORSAIR_VID 0x1B1C
/*-----------------------------------------------------*\
| Keyboard Hydro Series product IDs |
\*-----------------------------------------------------*/
#define CORSAIR_H100I_PRO_RGB_PID 0x0C15
typedef struct
{
unsigned short usb_vid;
unsigned short usb_pid;
unsigned char usb_interface;
const char * name;
} corsair_hydro_device;
#define CORSAIR_NUM_DEVICES (sizeof(device_list) / sizeof(device_list[ 0 ]))
static const corsair_hydro_device device_list[] =
{
/*-----------------------------------------------------------------------------------------------------*\
| Coolers |
\*-----------------------------------------------------------------------------------------------------*/
{ CORSAIR_VID, CORSAIR_H100I_PRO_RGB_PID, 0, "Corsair H100i PRO RGB" }
};
/******************************************************************************************\
* *
* DetectCorsairHydroControllers *
* *
* Tests the USB address to see if a Corsair RGB Cooler controller exists there. *
* *
\******************************************************************************************/
void DetectCorsairHydroControllers(std::vector<RGBController*>& rgb_controllers)
{
libusb_context * ctx;
libusb_init(&ctx);
for(std::size_t device_idx = 0; device_idx < CORSAIR_NUM_DEVICES; device_idx++)
{
libusb_device_handle * dev = libusb_open_device_with_vid_pid(ctx, device_list[device_idx].usb_vid, device_list[device_idx].usb_pid);
//Look for Corsair RGB Peripheral
if(dev)
{
libusb_detach_kernel_driver(dev, 0);
libusb_claim_interface(dev, 0);
CorsairHydroController* controller = new CorsairHydroController(dev);//, device_list[device_idx].usb_endpoint);
RGBController_CorsairHydro* rgb_controller = new RGBController_CorsairHydro(controller);
rgb_controller->name = device_list[device_idx].name;
rgb_controllers.push_back(rgb_controller);
}
}
} /* DetectCorsairHydroControllers() */
REGISTER_DETECTOR("Corsair Hydro Series", DetectCorsairHydroControllers);

6
OpenRGB.pro
View file

@ -53,6 +53,7 @@ INCLUDEPATH += \
Controllers/AuraGPUController/ \
Controllers/AuraSMBusController/ \
Controllers/CoolerMasterController/ \
Controllers/CorsairHydroController/ \
Controllers/CorsairPeripheralController/ \
Controllers/CorsairLightingNodeController/ \
Controllers/CorsairVengeanceController/ \
@ -123,6 +124,7 @@ HEADERS += \
Controllers/AuraGPUController/AuraGPUController.h \
Controllers/AuraSMBusController/AuraSMBusController.h \
Controllers/CoolerMasterController/CMMP750Controller.h \
Controllers/CorsairHydroController/CorsairHydroController.h \
Controllers/CorsairLightingNodeController/CorsairLightingNodeController.h \
Controllers/CorsairPeripheralController/CorsairPeripheralController.h \
Controllers/CorsairVengeanceController/CorsairVengeanceController.h \
@ -174,6 +176,7 @@ HEADERS += \
RGBController/RGBController_AuraGPU.h \
RGBController/RGBController_AuraSMBus.h \
RGBController/RGBController_CMMP750Controller.h \
RGBController/RGBController_CorsairHydro.h \
RGBController/RGBController_CorsairLightingNode.h \
RGBController/RGBController_CorsairPeripheral.h \
RGBController/RGBController_CorsairVengeance.h \
@ -263,6 +266,8 @@ SOURCES += \
Controllers/AuraSMBusController/AuraSMBusControllerDetect.cpp \
Controllers/CoolerMasterController/CMMP750Controller.cpp \
Controllers/CoolerMasterController/CoolerMasterControllerDetect.cpp \
Controllers/CorsairHydroController/CorsairHydroController.cpp \
Controllers/CorsairHydroController/CorsairHydroControllerDetect.cpp \
Controllers/CorsairLightingNodeController/CorsairLightingNodeController.cpp \
Controllers/CorsairLightingNodeController/CorsairLightingNodeControllerDetect.cpp \
Controllers/CorsairPeripheralController/CorsairPeripheralController.cpp \
@ -350,6 +355,7 @@ SOURCES += \
RGBController/RGBController_AuraGPU.cpp \
RGBController/RGBController_AuraSMBus.cpp \
RGBController/RGBController_CMMP750Controller.cpp \
RGBController/RGBController_CorsairHydro.cpp \
RGBController/RGBController_CorsairLightingNode.cpp \
RGBController/RGBController_CorsairPeripheral.cpp \
RGBController/RGBController_CorsairVengeance.cpp \

78
RGBController/RGBController_CorsairHydro.cpp Normal file
View file

@ -0,0 +1,78 @@
/*-----------------------------------------*\
| RGBController_CorsairHydro.cpp |
| |
| Generic RGB Interface for Corsair |
| Hydro Series |
| |
| Adam Honse (CalcProgrammer1) 8/18/2020 |
\*-----------------------------------------*/
#include "RGBController_CorsairHydro.h"
RGBController_CorsairHydro::RGBController_CorsairHydro(CorsairHydroController* corsair_ptr)
{
corsair = corsair_ptr;
description = "Corsair Hydro Series Device";
version = corsair->GetFirmwareString();
type = DEVICE_TYPE_COOLER;
mode Direct;
Direct.name = "Direct";
Direct.value = 0;
Direct.flags = MODE_FLAG_HAS_PER_LED_COLOR;
Direct.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Direct);
SetupZones();
}
void RGBController_CorsairHydro::SetupZones()
{
zone new_zone;
new_zone.name = "Pump Zone";
new_zone.type = ZONE_TYPE_SINGLE;
new_zone.leds_min = 1;
new_zone.leds_max = 1;
new_zone.leds_count = 1;
new_zone.matrix_map = NULL;
zones.push_back(new_zone);
led new_led;
new_led.name = "Pump LED";
leds.push_back(new_led);
SetupColors();
}
void RGBController_CorsairHydro::ResizeZone(int /*zone*/, int /*new_size*/)
{
}
void RGBController_CorsairHydro::DeviceUpdateLEDs()
{
corsair->SetFixed(RGBGetRValue(colors[0]), RGBGetGValue(colors[0]), RGBGetBValue(colors[0]));
}
void RGBController_CorsairHydro::UpdateZoneLEDs(int zone)
{
DeviceUpdateLEDs();
}
void RGBController_CorsairHydro::UpdateSingleLED(int led)
{
DeviceUpdateLEDs();
}
void RGBController_CorsairHydro::SetCustomMode()
{
active_mode = 0;
}
void RGBController_CorsairHydro::DeviceUpdateMode()
{
DeviceUpdateLEDs();
}

32
RGBController/RGBController_CorsairHydro.h Normal file
View file

@ -0,0 +1,32 @@
/*-----------------------------------------*\
| RGBController_CorsairHydro.h |
| |
| Generic RGB Interface for Corsair |
| Hydro Series |
| |
| Adam Honse (CalcProgrammer1) 8/17/2020 |
\*-----------------------------------------*/
#pragma once
#include "RGBController.h"
#include "CorsairHydroController.h"
class RGBController_CorsairHydro : public RGBController
{
public:
RGBController_CorsairHydro(CorsairHydroController* corsair_ptr);
void SetupZones();
void ResizeZone(int zone, int new_size);
void DeviceUpdateLEDs();
void UpdateZoneLEDs(int zone);
void UpdateSingleLED(int led);
void SetCustomMode();
void DeviceUpdateMode();
private:
CorsairHydroController* corsair;
};