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

Initial driver for NZXT Hue 2

Browse source
This commit is contained in:
Adam Honse 2019-12-29 12:09:04 -06:00
parent fd9134c911
commit 60531bbf07
7 changed files with 477 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

188
Controllers/Hue2Controller/Hue2Controller.cpp Normal file
View file

@ -0,0 +1,188 @@
/*---------------------------------------------------------*\
| Processing Code for NZXT Hue 2 |
| |
| Adam Honse (calcprogrammer1@gmail.com), 12/29/2016 |
\*---------------------------------------------------------*/
#include "Hue2Controller.h"
#include <fstream>
#include <iostream>
#include <string>
#ifdef WIN32
#include <Windows.h>
#else
#include <unistd.h>
static void Sleep(unsigned int milliseconds)
{
usleep(1000 * milliseconds);
}
#endif
Hue2Controller::Hue2Controller(libusb_device_handle* dev_handle)
{
dev = dev_handle;
GetStripsOnChannel(HUE_2_CHANNEL_1);
}
Hue2Controller::~Hue2Controller()
{
}
unsigned int Hue2Controller::GetStripsOnChannel(unsigned int channel)
{
unsigned int ret_val = 0;
unsigned char usb_buf[] =
{
0x20, 0x03, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00
};
int actual = 0;
libusb_interrupt_transfer(dev, 0x01, usb_buf, 64, &actual, 0);
libusb_interrupt_transfer(dev, 0x81, usb_buf, 64, &actual, 0);
for(int chan = 0; chan < 4; chan++)
{
unsigned int start = 0x0F + (6 * chan);
unsigned int num_leds_on_channel = 0;
for(int dev = 0; dev < 6; dev++)
{
switch(usb_buf[start + dev])
{
case 0x04: //Hue 2 strip
num_leds_on_channel += 10;
break;
default:
break;
}
}
channel_leds[chan] = num_leds_on_channel;
}
return(ret_val);
}
void Hue2Controller::SetChannelLEDs(unsigned int channel, std::vector<RGBColor> colors)
{
unsigned char usb_buf[] =
{
0x22, 0x10, 0x01, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00
};
unsigned char usb_apply[] =
{
0x22, 0xA0, 0x01, 0x00,
0x01, 0x00, 0x00, 0x28,
0x00, 0x00, 0x80, 0x00,
0x32, 0x00, 0x00, 0x01,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00
};
int actual;
int pkt_max = 20;
/*-----------------------------------------------------*\
| Set channel in USB packets |
\*-----------------------------------------------------*/
usb_buf[0x02] = channel;
usb_apply[0x02] = channel;
/*-----------------------------------------------------*\
| Send first packet for first 20 LEDs |
\*-----------------------------------------------------*/
if(pkt_max > colors.size())
{
pkt_max = colors.size();
}
for (int idx = 0; idx < pkt_max; idx++)
{
int pixel_idx = idx * 3;
RGBColor color = colors[idx];
usb_buf[pixel_idx + 4] = RGBGetGValue(color);
usb_buf[pixel_idx + 5] = RGBGetRValue(color);
usb_buf[pixel_idx + 6] = RGBGetBValue(color);
}
libusb_interrupt_transfer(dev, 0x01, usb_buf, 64, &actual, 0);
/*-----------------------------------------------------*\
| Send second packet for second 20 LEDs if necessary |
\*-----------------------------------------------------*/
for(int idx = 4; idx < 64; idx++)
{
usb_buf[idx] = 0;
}
usb_buf[0x01] = 0x11;
pkt_max = 20;
if(pkt_max > (colors.size() - 20))
{
pkt_max = colors.size() - 20;
}
if(pkt_max > 0)
{
for (int idx = 0; idx < pkt_max; idx++)
{
int pixel_idx = idx * 3;
RGBColor color = colors[idx + 20];
usb_buf[pixel_idx + 4] = RGBGetGValue(color);
usb_buf[pixel_idx + 5] = RGBGetRValue(color);
usb_buf[pixel_idx + 6] = RGBGetBValue(color);
}
libusb_interrupt_transfer(dev, 0x01, usb_buf, 64, &actual, 0);
}
/*-----------------------------------------------------*\
| Send apply packet |
\*-----------------------------------------------------*/
libusb_interrupt_transfer(dev, 0x01, usb_apply, 64, &actual, 0);
}

58
Controllers/Hue2Controller/Hue2Controller.h Normal file
View file

@ -0,0 +1,58 @@
/*---------------------------------------------------------*\
| Definitions for NZXT Hue 2 |
| |
| Adam Honse (calcprogrammer1@gmail.com), 12/29/2016 |
\*---------------------------------------------------------*/
#include "RGBController.h"
#include <vector>
#include <libusb-1.0/libusb.h>
#pragma once
enum
{
HUE_2_CHANNEL_ALL = 0x00, /* All channels */
HUE_2_CHANNEL_1 = 0x01, /* Channel 1 */
HUE_2_CHANNEL_2 = 0x02, /* Channel 2 */
HUE_2_CHANNEL_3 = 0x03, /* Channel 3 */
HUE_2_CHANNEL_4 = 0x04, /* Channel 4 */
HUE_2_NUM_CHANNELS = 0x04 /* Number of channels */
};
enum
{
HUE_2_CHANNEL_1_IDX = 0x00, /* Channel 1 array index */
HUE_2_CHANNEL_2_IDX = 0x01, /* Channel 2 array index */
HUE_2_CHANNEL_3_IDX = 0x01, /* Channel 3 array index */
HUE_2_CHANNEL_4_IDX = 0x01, /* Channel 4 array index */
};
enum
{
HUE_2_MODE_FIXED = 0x00, /* Fixed colors mode */
HUE_2_MODE_FADING = 0x01, /* Fading mode */
HUE_2_MODE_SPECTRUM = 0x02, /* Spectrum cycle mode */
HUE_2_MODE_MARQUEE = 0x03, /* Marquee mode */
HUE_2_MODE_COVER_MARQUEE = 0x04, /* Cover marquee mode */
HUE_2_MODE_ALTERNATING = 0x05, /* Alternating mode */
HUE_2_MODE_PULSING = 0x06, /* Pulsing mode */
HUE_2_MODE_BREATHING = 0x07, /* Breathing mode */
HUE_2_NUM_MODES /* Number of Hue 2 modes */
};
class Hue2Controller
{
public:
Hue2Controller(libusb_device_handle* dev_handle);
~Hue2Controller();
char* GetLEDString();
unsigned int GetStripsOnChannel(unsigned int channel);
void SetChannelLEDs(unsigned int channel, std::vector<RGBColor> colors);
unsigned int channel_leds[HUE_2_NUM_CHANNELS];
private:
libusb_device_handle* dev;
};

37
Controllers/Hue2Controller/Hue2ControllerDetect.cpp Normal file
View file

@ -0,0 +1,37 @@
#include "Hue2Controller.h"
#include "RGBController.h"
#include "RGBController_Hue2.h"
#include <vector>
#include <libusb-1.0/libusb.h>
#define NZXT_HUE_2_VID 0x1E71
#define NZXT_HUE_2_PID 0x2001
/******************************************************************************************\
* *
* DetectHue2Controllers *
* *
* Detect devices supported by the Hue2 driver *
* * *
\******************************************************************************************/
void DetectHue2Controllers(std::vector<RGBController*> &rgb_controllers)
{
libusb_context * ctx;
libusb_init(&ctx);
//Look for NZXT Hue 2
libusb_device_handle * dev = libusb_open_device_with_vid_pid(ctx, NZXT_HUE_2_VID, NZXT_HUE_2_PID);
if( dev )
{
libusb_detach_kernel_driver(dev, 0);
libusb_claim_interface(dev, 0);
Hue2Controller* controller = new Hue2Controller(dev);
RGBController_Hue2* rgb_controller = new RGBController_Hue2(controller);
rgb_controllers.push_back(rgb_controller);
}
} /* DetectHuePlusControllers() */

2
OpenRGB.cpp
View file

@ -324,6 +324,7 @@ void DetectHyperXControllers(std::vector<i2c_smbus_interface*> &busses, std::vec
void DetectPolychromeControllers(std::vector<i2c_smbus_interface*>& busses, std::vector<RGBController*>& rgb_controllers);
void DetectRGBFusionControllers(std::vector<i2c_smbus_interface*>& busses, std::vector<RGBController*>& rgb_controllers);
void DetectLEDStripControllers(std::vector<RGBController*> &rgb_controllers);
void DetectHue2Controllers(std::vector<RGBController*> &rgb_controllers);
void DetectHuePlusControllers(std::vector<RGBController*> &rgb_controllers);
void DetectOpenRazerControllers(std::vector<RGBController*> &rgb_controllers);
void DetectRazerChromaSDKControllers(std::vector<RGBController*>& rgb_controllers);
@ -351,6 +352,7 @@ void DetectRGBControllers(void)
DetectRGBFusionControllers(busses, rgb_controllers);
DetectLEDStripControllers(rgb_controllers);
DetectHue2Controllers(rgb_controllers);
DetectHuePlusControllers(rgb_controllers);
DetectAMDWraithPrismControllers(rgb_controllers);

6
OpenRGB.pro
View file

@ -14,6 +14,7 @@ INCLUDEPATH += \
Controllers/AuraController/ \
Controllers/CorsairController/ \
Controllers/CorsairProController/ \
Controllers/Hue2Controller/ \
Controllers/HuePlusController/ \
Controllers/HyperXController/ \
Controllers/LEDStripController/ \
@ -43,6 +44,8 @@ SOURCES += \
Controllers/CorsairController/CorsairControllerDetect.cpp \
Controllers/CorsairProController/CorsairProController.cpp \
Controllers/CorsairProController/CorsairProControllerDetect.cpp \
Controllers/Hue2Controller/Hue2Controller.cpp \
Controllers/Hue2Controller/Hue2ControllerDetect.cpp \
Controllers/HuePlusController/HuePlusController.cpp \
Controllers/HuePlusController/HuePlusControllerDetect.cpp \
Controllers/HyperXController/HyperXController.cpp \
@ -57,6 +60,7 @@ SOURCES += \
RGBController/RGBController_Aura.cpp \
RGBController/RGBController_Corsair.cpp \
RGBController/RGBController_CorsairPro.cpp \
RGBController/RGBController_Hue2.cpp \
RGBController/RGBController_HuePlus.cpp \
RGBController/RGBController_HyperX.cpp \
RGBController/RGBController_LEDStrip.cpp \
@ -78,6 +82,7 @@ HEADERS += \
Controllers/AuraController/AuraController.h \
Controllers/CorsairController/CorsairController.h \
Controllers/CorsairProController/CorsairProController.h \
Controllers/Hue2Controller/Hue2Controller.h \
Controllers/HuePlusController/HuePlusController.h \
Controllers/HyperXController/HyperXController.h \
Controllers/LEDStripController/LEDStripController.h \
@ -86,6 +91,7 @@ HEADERS += \
RGBController/RGBController_Aura.h \
RGBController/RGBController_Corsair.h \
RGBController/RGBController_CorsairPro.h \
RGBController/RGBController_Hue2.h \
RGBController/RGBController_HuePlus.h \
RGBController/RGBController_HyperX.h \
RGBController/RGBController_Polychrome.h \

156
RGBController/RGBController_Hue2.cpp Normal file
View file

@ -0,0 +1,156 @@
/*-----------------------------------------*\
| RGBController_Hue2.cpp |
| |
| Generic RGB Interface for NZXT Hue 2 |
| |
| Adam Honse (CalcProgrammer1) 12/29/2019 |
\*-----------------------------------------*/
#include "RGBController_Hue2.h"
RGBController_Hue2::RGBController_Hue2(Hue2Controller* hue2_ptr)
{
hue2 = hue2_ptr;
name = "NZXT Hue 2";
type = DEVICE_TYPE_LEDSTRIP;
mode led_mode;
led_mode.name = "Custom";
modes.push_back(led_mode);
unsigned int led_idx = 0;
for (int channel_idx = 0; channel_idx < HUE_2_NUM_CHANNELS; channel_idx++)
{
if(hue2->channel_leds[channel_idx] > 0)
{
zone* new_zone = new zone;
char ch_idx_string[2];
sprintf(ch_idx_string, "%d", channel_idx + 1);
new_zone->name = "Hue 2 Channel ";
new_zone->name.append(ch_idx_string);
new_zone->type = ZONE_TYPE_LINEAR;
std::vector<int> *new_zone_map = new std::vector<int>();
for (int led_ch_idx = 0; led_ch_idx < hue2->channel_leds[channel_idx]; led_ch_idx++)
{
colors.push_back(0x00000000);
char led_idx_string[3];
sprintf(led_idx_string, "%d", led_ch_idx + 1);
led new_led;
new_led.name = "Hue 2 Channel ";
new_led.name.append(ch_idx_string);
new_led.name.append(", LED ");
new_led.name.append(led_idx_string);
leds.push_back(new_led);
leds_channel.push_back(channel_idx + 1);
new_zone_map->push_back(led_idx);
led_idx++;
}
new_zone->map.push_back(*new_zone_map);
zones.push_back(*new_zone);
zones_channel.push_back(channel_idx + 1);
}
}
}
int RGBController_Hue2::GetMode()
{
return 0;
}
void RGBController_Hue2::SetMode(int mode)
{
}
void RGBController_Hue2::SetCustomMode()
{
}
void RGBController_Hue2::SetAllLEDs(RGBColor color)
{
for (int i = 0; i < colors.size(); i++)
{
colors[i] = color;
}
UpdateLEDs();
}
void RGBController_Hue2::SetAllZoneLEDs(int zone, RGBColor color)
{
int channel = zones_channel[zone];
for (int x = 0; x < zones[zone].map.size(); x++)
{
for (int y = 0; y < zones[zone].map[x].size(); y++)
{
colors[zones[zone].map[x][y]] = color;
}
}
std::vector<RGBColor> channel_colors;
for(int color = 0; color < colors.size(); color++)
{
if(leds_channel[color] == channel)
{
channel_colors.push_back(colors[color]);
}
}
hue2->SetChannelLEDs(channel, channel_colors);
}
void RGBController_Hue2::SetLED(int led, RGBColor color)
{
int channel = leds_channel[led];
colors[led] = color;
std::vector<RGBColor> channel_colors;
for(int color = 0; color < colors.size(); color++)
{
if(leds_channel[color] == channel)
{
channel_colors.push_back(colors[color]);
}
}
hue2->SetChannelLEDs(channel, channel_colors);
}
void RGBController_Hue2::UpdateLEDs()
{
std::vector<RGBColor> channel_colors;
for(int channel = 0; channel < HUE_2_NUM_CHANNELS; channel++)
{
for(int color = 0; color < colors.size(); color++)
{
if(leds_channel[color] == channel)
{
channel_colors.push_back(colors[color]);
}
}
if(channel_colors.size() > 0)
{
hue2->SetChannelLEDs(channel, channel_colors);
}
channel_colors.clear();
}
}

30
RGBController/RGBController_Hue2.h Normal file
View file

@ -0,0 +1,30 @@
/*-----------------------------------------*\
| RGBController_Hue2.h |
| |
| Generic RGB Interface for NZXT Hue 2 |
| |
| Adam Honse (CalcProgrammer1) 12/29/2019 |
\*-----------------------------------------*/
#pragma once
#include "RGBController.h"
#include "serial_port.h"
#include "Hue2Controller.h"
class RGBController_Hue2 : public RGBController
{
public:
RGBController_Hue2(Hue2Controller* hue2_ptr);
int GetMode();
void SetMode(int mode);
void SetCustomMode();
void SetAllLEDs(RGBColor color);
void SetAllZoneLEDs(int zone, RGBColor color);
void SetLED(int led, RGBColor color);
void UpdateLEDs();
private:
Hue2Controller* hue2;
std::vector<unsigned int> leds_channel;
std::vector<unsigned int> zones_channel;
};