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

Initial implementation of NZXT Hue 1 (Smart Device V1)

Browse source
This commit is contained in:
Adam Honse 2023-04-16 20:06:43 -07:00
parent d2b8ff79a4
commit d4ce474016
6 changed files with 801 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

303
Controllers/NZXTHue1Controller/NZXTHue1Controller.cpp Normal file
View file

@ -0,0 +1,303 @@
/*---------------------------------------------------------*\
| Processing Code for NZXT Hue 1 (Smart Device V1) |
| |
| Adam Honse (calcprogrammer1@gmail.com), 4/16/2023 |
\*---------------------------------------------------------*/
#include "NZXTHue1Controller.h"
#include <cstring>
NZXTHue1Controller::NZXTHue1Controller(hid_device* dev_handle, unsigned int rgb_channels, unsigned int fan_channels, const char* path)
{
dev = dev_handle;
location = path;
num_rgb_channels = rgb_channels;
Initialize();
}
NZXTHue1Controller::~NZXTHue1Controller()
{
}
std::string NZXTHue1Controller::GetFirmwareVersion()
{
return(firmware_version);
}
std::string NZXTHue1Controller::GetLocation()
{
return("HID: " + location);
}
std::string NZXTHue1Controller::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 int NZXTHue1Controller::GetAccessoryType()
{
return(accessory_type);
}
unsigned int NZXTHue1Controller::GetNumRGBChannels()
{
return(num_rgb_channels);
}
void NZXTHue1Controller::SetChannelEffect
(
unsigned char channel,
unsigned char mode,
unsigned char speed,
bool direction,
RGBColor * colors,
unsigned int num_colors
)
{
unsigned char color_data[120];
/*-----------------------------------------------------*\
| If mode requires no colors, send packet |
\*-----------------------------------------------------*/
if(num_colors == 0)
{
/*-----------------------------------------------------*\
| Send mode without color data |
\*-----------------------------------------------------*/
SendPacket(channel, mode, direction, 0, speed, 0, NULL);
}
/*-----------------------------------------------------*\
| If mode requires indexed colors, send color index |
| packets for each mode color |
\*-----------------------------------------------------*/
else if(num_colors <= 8)
{
for(std::size_t color_idx = 0; color_idx < num_colors; color_idx++)
{
/*-----------------------------------------------------*\
| Fill in color data (40 entries per color) |
\*-----------------------------------------------------*/
for (std::size_t idx = 0; idx < 40; idx++)
{
int pixel_idx = idx * 3;
RGBColor color = colors[color_idx];
color_data[pixel_idx + 0x00] = RGBGetGValue(color);
color_data[pixel_idx + 0x01] = RGBGetRValue(color);
color_data[pixel_idx + 0x02] = RGBGetBValue(color);
}
/*-----------------------------------------------------*\
| Send mode and color data |
\*-----------------------------------------------------*/
SendPacket(channel, mode, direction, color_idx, speed, 40, &color_data[0]);
}
}
/*-----------------------------------------------------*\
| If mode requires per-LED colors, fill colors array |
\*-----------------------------------------------------*/
else
{
/*-----------------------------------------------------*\
| Fill in color data (up to 40 colors) |
\*-----------------------------------------------------*/
for (std::size_t idx = 0; idx < num_colors; idx++)
{
int pixel_idx = idx * 3;
RGBColor color = colors[idx];
color_data[pixel_idx + 0x00] = RGBGetGValue(color);
color_data[pixel_idx + 0x01] = RGBGetRValue(color);
color_data[pixel_idx + 0x02] = RGBGetBValue(color);
}
/*-----------------------------------------------------*\
| Send mode and color data |
\*-----------------------------------------------------*/
SendPacket(channel, mode, direction, 0, speed, num_colors, &color_data[0]);
}
}
void NZXTHue1Controller::SetChannelLEDs
(
unsigned char channel,
RGBColor * colors,
unsigned int num_colors
)
{
unsigned char color_data[120];
/*-----------------------------------------------------*\
| Fill in color data (up to 40 colors) |
\*-----------------------------------------------------*/
for (std::size_t idx = 0; idx < num_colors; idx++)
{
int pixel_idx = idx * 3;
RGBColor color = colors[idx];
color_data[pixel_idx + 0x00] = RGBGetGValue(color);
color_data[pixel_idx + 0x01] = RGBGetRValue(color);
color_data[pixel_idx + 0x02] = RGBGetBValue(color);
}
/*-----------------------------------------------------*\
| Send color data |
\*-----------------------------------------------------*/
SendPacket(channel, HUE_1_MODE_FIXED, false, 0, 0, num_colors, &color_data[0]);
}
/*-------------------------------------------------------------------------------------------------*\
| Private packet sending functions. |
\*-------------------------------------------------------------------------------------------------*/
void NZXTHue1Controller::Initialize()
{
unsigned char usb_buf[65];
unsigned int ret_val = 0;
/*-----------------------------------------------------*\
| Zero out buffer |
\*-----------------------------------------------------*/
memset(usb_buf, 0x00, sizeof(usb_buf));
/*-----------------------------------------------------*\
| Send Initialize command |
\*-----------------------------------------------------*/
usb_buf[0x00] = 0x01;
usb_buf[0x01] = 0x5C;
hid_write(dev, usb_buf, 65);
/*-----------------------------------------------------*\
| Send Start Reporting command |
\*-----------------------------------------------------*/
usb_buf[0x00] = 0x01;
usb_buf[0x01] = 0x5D;
hid_write(dev, usb_buf, 65);
/*-----------------------------------------------------*\
| Receive packets until a valid read has occurred |
\*-----------------------------------------------------*/
do
{
ret_val = hid_read(dev, usb_buf, 21);
} while( (ret_val != 21) );
/*-----------------------------------------------------*\
| Determine firmware version |
| |
| 0x0B is the major value |
| 0x0E is the minor value |
\*-----------------------------------------------------*/
snprintf(firmware_version, 16, "%u.%u", usb_buf[0x0B], usb_buf[0x0E]);
/*-----------------------------------------------------*\
| Determine device count and type |
| |
| 0x11 defines the number of devices (strip, fan) |
| 0x10 defines the type (strip or fan) |
| 0: Hue+ RGB Strip (10 LEDs) |
| 1: Aer RGB Fan (8 LEDs) |
| All connected devices must be of the same type |
\*-----------------------------------------------------*/
unsigned char dev_count = usb_buf[0x11];
accessory_type = (usb_buf[0x10] >> 3);
if(accessory_type == HUE_1_ACCESSORY_STRIP)
{
channel_leds[HUE_1_CHANNEL_1_IDX] = dev_count * 10;
}
else
{
channel_leds[HUE_1_CHANNEL_1_IDX] = dev_count * 8;
}
}
void NZXTHue1Controller::SendPacket
(
unsigned char channel,
unsigned char mode,
bool direction,
unsigned char color_idx,
unsigned char speed,
unsigned char color_count,
unsigned char* color_data
)
{
unsigned char usb_buf[65];
/*-----------------------------------------------------*\
| Zero out buffer |
\*-----------------------------------------------------*/
memset(usb_buf, 0x00, sizeof(usb_buf));
/*-----------------------------------------------------*\
| Set up RGB packet 1 |
\*-----------------------------------------------------*/
usb_buf[0x00] = 0x02;
usb_buf[0x01] = 0x4B;
/*-----------------------------------------------------*\
| Set mode in RGB packet |
\*-----------------------------------------------------*/
usb_buf[0x02] = mode;
/*-----------------------------------------------------*\
| Set options bitfield in RGB packet |
\*-----------------------------------------------------*/
usb_buf[0x03] = direction ? ( 1 << 4 ) : 0;
/*-----------------------------------------------------*\
| Set color index and speed in RGB packet |
\*-----------------------------------------------------*/
usb_buf[0x04] = ( color_idx << 5 ) | speed;
/*-----------------------------------------------------*\
| Copy in color data bytes |
\*-----------------------------------------------------*/
unsigned int colors_in_packet = 20;
if(color_count < 20)
{
colors_in_packet = color_count;
}
memcpy(&usb_buf[0x05], color_data, colors_in_packet * 3);
/*-----------------------------------------------------*\
| Write RGB packet |
\*-----------------------------------------------------*/
hid_write(dev, usb_buf, 65);
/*-----------------------------------------------------*\
| Zero out buffer |
\*-----------------------------------------------------*/
memset(usb_buf, 0x00, sizeof(usb_buf));
/*-----------------------------------------------------*\
| Set up RGB packet 2 |
\*-----------------------------------------------------*/
usb_buf[0x00] = 0x03;
/*-----------------------------------------------------*\
| Copy in color data bytes |
\*-----------------------------------------------------*/
colors_in_packet = color_count - colors_in_packet;
memcpy(&usb_buf[0x01], color_data, colors_in_packet * 3);
hid_write(dev, usb_buf, 65);
}

106
Controllers/NZXTHue1Controller/NZXTHue1Controller.h Normal file
View file

@ -0,0 +1,106 @@
/*---------------------------------------------------------*\
| Definitions for NZXT Hue 1 (Smart Device V1) |
| |
| Adam Honse (calcprogrammer1@gmail.com), 4/16/2023 |
\*---------------------------------------------------------*/
#include "RGBController.h"
#include <hidapi/hidapi.h>
#pragma once
enum
{
HUE_1_CHANNEL_1 = 0x01, /* Channel 1 */
HUE_1_NUM_CHANNELS = 0x01 /* Number of channels */
};
enum
{
HUE_1_CHANNEL_1_IDX = 0x00, /* Channel 1 array index */
};
enum
{
HUE_1_ACCESSORY_STRIP = 0x00, /* NZXT Hue+ LED Strip (10 LEDs)*/
HUE_1_ACCESSORY_FAN = 0x01 /* NZXT Aer RGB Fan (8 LEDs) */
};
enum
{
HUE_1_SPEED_SLOWEST = 0x00, /* Slowest speed */
HUE_1_SPEED_SLOW = 0x01, /* Slow speed */
HUE_1_SPEED_NORMAL = 0x02, /* Normal speed */
HUE_1_SPEED_FAST = 0x03, /* Fast speed */
HUE_1_SPEED_FASTEST = 0x04, /* Fastest speed */
};
enum
{
HUE_1_MODE_FIXED = 0x00, /* Fixed colors mode */
HUE_1_MODE_FADING = 0x01, /* Fading mode */
HUE_1_MODE_SPECTRUM = 0x02, /* Spectrum cycle mode */
HUE_1_MODE_MARQUEE = 0x03, /* Marquee mode */
HUE_1_MODE_COVER_MARQUEE = 0x04, /* Cover marquee mode */
HUE_1_MODE_ALTERNATING = 0x05, /* Alternating mode */
HUE_1_MODE_PULSING = 0x06, /* Pulsing mode */
HUE_1_MODE_BREATHING = 0x07, /* Breathing mode */
HUE_1_MODE_ALERT = 0x08, /* Alert mode */
HUE_1_MODE_CANDLELIGHT = 0x09, /* Candlelight mode */
HUE_1_MODE_WINGS = 0x0C, /* Wings mode */
HUE_1_MODE_WAVE = 0x0D, /* Wave mode */
};
class NZXTHue1Controller
{
public:
NZXTHue1Controller(hid_device* dev_handle, unsigned int rgb_channels, unsigned int fan_channels, const char* path);
~NZXTHue1Controller();
std::string GetFirmwareVersion();
std::string GetLocation();
std::string GetSerialString();
unsigned int GetAccessoryType();
unsigned int GetNumRGBChannels();
void SetChannelEffect
(
unsigned char channel,
unsigned char mode,
unsigned char speed,
bool direction,
RGBColor * colors,
unsigned int num_colors
);
void SetChannelLEDs
(
unsigned char channel,
RGBColor * colors,
unsigned int num_colors
);
unsigned int channel_leds[HUE_1_NUM_CHANNELS];
private:
hid_device* dev;
char firmware_version[16];
std::string location;
unsigned int num_rgb_channels;
unsigned int accessory_type;
void Initialize();
void SendPacket
(
unsigned char channel,
unsigned char mode,
bool direction,
unsigned char color_idx,
unsigned char speed,
unsigned char color_count,
unsigned char* color_data
);
};

35
Controllers/NZXTHue1Controller/NZXTHue1ControllerDetect.cpp Normal file
View file

@ -0,0 +1,35 @@
#include "Detector.h"
#include "NZXTHue1Controller.h"
#include "RGBController.h"
#include "RGBController_NZXTHue1.h"
#include <hidapi/hidapi.h>
/*-----------------------------------------------------*\
| NZXT USB IDs |
\*-----------------------------------------------------*/
#define NZXT_VID 0x1E71
#define NZXT_SMART_DEVICE_V1_PID 0x1714
/******************************************************************************************\
* *
* DetectNZXTHue1Controllers *
* *
* Detect devices supported by the NZXTHue1 driver *
* *
\******************************************************************************************/
void DetectNZXTHue1Controllers(hid_device_info* info, const std::string& name)
{
hid_device* dev = hid_open_path(info->path);
if(dev)
{
NZXTHue1Controller* controller = new NZXTHue1Controller(dev, 1, 3, info->path);
RGBController_NZXTHue1* rgb_controller = new RGBController_NZXTHue1(controller);
rgb_controller->name = name;
ResourceManager::get()->RegisterRGBController(rgb_controller);
}
} /* DetectNZXTHue1Controllers() */
REGISTER_HID_DETECTOR("NZXT Smart Device V1", DetectNZXTHue1Controllers, NZXT_VID, NZXT_SMART_DEVICE_V1_PID);

319
Controllers/NZXTHue1Controller/RGBController_NZXTHue1.cpp Normal file
View file

@ -0,0 +1,319 @@
/*-----------------------------------------*\
| RGBController_NZXTHue1.cpp |
| |
| Generic RGB Interface for NZXT Hue1 |
| |
| Adam Honse (CalcProgrammer1) 4/16/2023 |
\*-----------------------------------------*/
#include "RGBController_NZXTHue1.h"
/**------------------------------------------------------------------*\
@name NZXT Hue 1
@category LEDStrip
@type USB
@save :robot:
@direct :white_check_mark:
@effects :white_check_mark:
@detectors DetectNZXTHue1Controllers
@comment
\*-------------------------------------------------------------------*/
RGBController_NZXTHue1::RGBController_NZXTHue1(NZXTHue1Controller* controller_ptr)
{
controller = controller_ptr;
name = "NZXT Hue 1";
vendor = "NZXT";
type = DEVICE_TYPE_LEDSTRIP;
description = "NZXT Hue 1 Device";
version = controller->GetFirmwareVersion();
location = controller->GetLocation();
serial = controller->GetSerialString();
mode Direct;
Direct.name = "Direct";
Direct.value = HUE_1_MODE_FIXED;
Direct.flags = MODE_FLAG_HAS_PER_LED_COLOR;
Direct.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Direct);
mode Fading;
Fading.name = "Fading";
Fading.value = HUE_1_MODE_FADING;
Fading.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
Fading.speed_min = HUE_1_SPEED_SLOWEST;
Fading.speed_max = HUE_1_SPEED_FASTEST;
Fading.colors_min = 1;
Fading.colors_max = 8;
Fading.speed = HUE_1_SPEED_NORMAL;
Fading.color_mode = MODE_COLORS_MODE_SPECIFIC;
Fading.colors.resize(2);
modes.push_back(Fading);
mode SpectrumCycle;
SpectrumCycle.name = "Rainbow Wave";
SpectrumCycle.value = HUE_1_MODE_SPECTRUM;
SpectrumCycle.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
SpectrumCycle.speed_min = HUE_1_SPEED_SLOWEST;
SpectrumCycle.speed_max = HUE_1_SPEED_FASTEST;
SpectrumCycle.speed = HUE_1_SPEED_NORMAL;
SpectrumCycle.direction = MODE_DIRECTION_RIGHT;
SpectrumCycle.color_mode = MODE_COLORS_NONE;
modes.push_back(SpectrumCycle);
mode Marquee;
Marquee.name = "Marquee";
Marquee.value = HUE_1_MODE_MARQUEE;
Marquee.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
Marquee.speed_min = HUE_1_SPEED_SLOWEST;
Marquee.speed_max = HUE_1_SPEED_FASTEST;
Marquee.colors_min = 1;
Marquee.colors_max = 1;
Marquee.speed = HUE_1_SPEED_NORMAL;
Marquee.direction = MODE_DIRECTION_RIGHT;
Marquee.color_mode = MODE_COLORS_MODE_SPECIFIC;
Marquee.colors.resize(1);
modes.push_back(Marquee);
mode CoverMarquee;
CoverMarquee.name = "Cover Marquee";
CoverMarquee.value = HUE_1_MODE_COVER_MARQUEE;
CoverMarquee.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
CoverMarquee.speed_min = HUE_1_SPEED_SLOWEST;
CoverMarquee.speed_max = HUE_1_SPEED_FASTEST;
CoverMarquee.colors_min = 1;
CoverMarquee.colors_max = 8;
CoverMarquee.speed = HUE_1_SPEED_NORMAL;
CoverMarquee.direction = MODE_DIRECTION_RIGHT;
CoverMarquee.color_mode = MODE_COLORS_MODE_SPECIFIC;
CoverMarquee.colors.resize(2);
modes.push_back(CoverMarquee);
mode Alternating;
Alternating.name = "Alternating";
Alternating.value = HUE_1_MODE_ALTERNATING;
Alternating.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
Alternating.speed_min = HUE_1_SPEED_SLOWEST;
Alternating.speed_max = HUE_1_SPEED_FASTEST;
Alternating.colors_min = 1;
Alternating.colors_max = 2;
Alternating.speed = HUE_1_SPEED_NORMAL;
Alternating.direction = MODE_DIRECTION_RIGHT;
Alternating.color_mode = MODE_COLORS_MODE_SPECIFIC;
Alternating.colors.resize(2);
modes.push_back(Alternating);
mode Pulsing;
Pulsing.name = "Pulsing";
Pulsing.value = HUE_1_MODE_PULSING;
Pulsing.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
Pulsing.speed_min = HUE_1_SPEED_SLOWEST;
Pulsing.speed_max = HUE_1_SPEED_FASTEST;
Pulsing.colors_min = 1;
Pulsing.colors_max = 8;
Pulsing.speed = HUE_1_SPEED_NORMAL;
Pulsing.color_mode = MODE_COLORS_MODE_SPECIFIC;
Pulsing.colors.resize(2);
modes.push_back(Pulsing);
mode Breathing;
Breathing.name = "Breathing";
Breathing.value = HUE_1_MODE_BREATHING;
Breathing.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_PER_LED_COLOR;
Breathing.speed_min = HUE_1_SPEED_SLOWEST;
Breathing.speed_max = HUE_1_SPEED_FASTEST;
Breathing.colors_min = 1;
Breathing.colors_max = 8;
Breathing.speed = HUE_1_SPEED_NORMAL;
Breathing.color_mode = MODE_COLORS_MODE_SPECIFIC;
Breathing.colors.resize(2);
modes.push_back(Breathing);
mode Alert;
Alert.name = "Alert";
Alert.value = HUE_1_MODE_ALERT;
Alert.flags = 0;
Alert.color_mode = MODE_COLORS_NONE;
modes.push_back(Alert);
mode Candlelight;
Candlelight.name = "Candlelight";
Candlelight.value = HUE_1_MODE_CANDLELIGHT;
Candlelight.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
Candlelight.colors_min = 1;
Candlelight.colors_max = 1;
Candlelight.color_mode = MODE_COLORS_MODE_SPECIFIC;
Candlelight.colors.resize(1);
modes.push_back(Candlelight);
mode Wings;
Wings.name = "Wings";
Wings.value = HUE_1_MODE_WINGS;
Wings.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
Wings.speed_min = HUE_1_SPEED_SLOWEST;
Wings.speed_max = HUE_1_SPEED_FASTEST;
Wings.colors_min = 1;
Wings.colors_max = 1;
Wings.speed = HUE_1_SPEED_NORMAL;
Wings.color_mode = MODE_COLORS_MODE_SPECIFIC;
Wings.colors.resize(1);
modes.push_back(Wings);
mode Wave;
Wave.name = "Wave";
Wave.value = HUE_1_MODE_WAVE;
Wave.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
Wave.speed_min = HUE_1_SPEED_SLOWEST;
Wave.speed_max = HUE_1_SPEED_FASTEST;
Wave.speed = HUE_1_SPEED_NORMAL;
Wave.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Wave);
SetupZones();
}
RGBController_NZXTHue1::~RGBController_NZXTHue1()
{
delete controller;
}
void RGBController_NZXTHue1::SetupZones()
{
/*-------------------------------------------------*\
| Set up zones |
\*-------------------------------------------------*/
for(unsigned int zone_idx = 0; zone_idx < controller->GetNumRGBChannels(); zone_idx++)
{
zone* new_zone = new zone;
new_zone->name = "Hue 1 Channel ";
new_zone->name.append(std::to_string(zone_idx + 1));
new_zone->type = ZONE_TYPE_LINEAR;
new_zone->leds_min = 0;
new_zone->leds_max = 40;
new_zone->leds_count = controller->channel_leds[zone_idx];
new_zone->matrix_map = NULL;
zones.push_back(*new_zone);
}
/*-------------------------------------------------*\
| Set up LEDs |
\*-------------------------------------------------*/
for(unsigned int zone_idx = 0; zone_idx < zones.size(); zone_idx++)
{
for(unsigned int led_idx = 0; led_idx < zones[zone_idx].leds_count; led_idx++)
{
led new_led;
new_led.name = "Hue 1 Channel ";
new_led.name.append(std::to_string(zone_idx + 1));
new_led.name.append(", LED ");
new_led.name.append(std::to_string(led_idx + 1));
new_led.value = zone_idx;
leds.push_back(new_led);
}
}
/*-------------------------------------------------*\
| Set up Segments |
\*-------------------------------------------------*/
for(unsigned int zone_idx = 0; zone_idx < zones.size(); zone_idx++)
{
unsigned int num_segments = 0;
unsigned int segment_size = 0;
std::string segment_name = "";
switch(controller->GetAccessoryType())
{
case HUE_1_ACCESSORY_STRIP:
segment_size = 10;
num_segments = zones[zone_idx].leds_count / segment_size;
segment_name = "Hue+ Strip";
break;
case HUE_1_ACCESSORY_FAN:
segment_size = 8;
num_segments = zones[zone_idx].leds_count / segment_size;
segment_name = "Aer RGB Fan";
break;
}
if(segment_name != "")
{
for(unsigned int segment_idx = 0; segment_idx < num_segments; segment_idx++)
{
segment new_segment;
new_segment.name = segment_name;
new_segment.type = ZONE_TYPE_LINEAR;
new_segment.start_idx = segment_idx * segment_size;
new_segment.leds_count = segment_size;
zones[zone_idx].segments.push_back(new_segment);
}
}
}
SetupColors();
}
void RGBController_NZXTHue1::ResizeZone(int zone, int new_size)
{
}
void RGBController_NZXTHue1::DeviceUpdateLEDs()
{
for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
{
controller->SetChannelLEDs(zone_idx, zones[zone_idx].colors, zones[zone_idx].leds_count);
}
}
void RGBController_NZXTHue1::UpdateZoneLEDs(int zone)
{
controller->SetChannelLEDs(zone, zones[zone].colors, zones[zone].leds_count);
}
void RGBController_NZXTHue1::UpdateSingleLED(int led)
{
unsigned int zone_idx = leds[led].value;
controller->SetChannelLEDs(zone_idx, zones[zone_idx].colors, zones[zone_idx].leds_count);
}
void RGBController_NZXTHue1::DeviceUpdateMode()
{
if(modes[active_mode].value == HUE_1_MODE_FIXED)
{
DeviceUpdateLEDs();
}
else
{
for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
{
RGBColor* colors = NULL;
bool direction = false;
if(modes[active_mode].direction == MODE_DIRECTION_LEFT)
{
direction = true;
}
if(modes[active_mode].colors.size() > 0)
{
colors = &modes[active_mode].colors[0];
}
controller->SetChannelEffect
(
zone_idx,
modes[active_mode].value,
modes[active_mode].speed,
direction,
colors,
modes[active_mode].colors.size()
);
}
}
}

32
Controllers/NZXTHue1Controller/RGBController_NZXTHue1.h Normal file
View file

@ -0,0 +1,32 @@
/*-----------------------------------------*\
| RGBController_NZXTHue1.h |
| |
| Generic RGB Interface for NZXT Hue+ |
| |
| Adam Honse (CalcProgrammer1) 6/20/2019 |
\*-----------------------------------------*/
#pragma once
#include "RGBController.h"
#include "NZXTHue1Controller.h"
class RGBController_NZXTHue1 : public RGBController
{
public:
RGBController_NZXTHue1(NZXTHue1Controller* controller_ptr);
~RGBController_NZXTHue1();
void SetupZones();
void ResizeZone(int zone, int new_size);
void DeviceUpdateLEDs();
void UpdateZoneLEDs(int zone);
void UpdateSingleLED(int led);
void DeviceUpdateMode();
private:
NZXTHue1Controller* controller;
std::vector<unsigned int> leds_channel;
std::vector<unsigned int> zones_channel;
};

6
OpenRGB.pro
View file

@ -153,6 +153,7 @@ INCLUDEPATH +=
Controllers/MSIRGBController/ \
Controllers/MSIVigorController/ \
Controllers/NanoleafController/ \
Controllers/NZXTHue1Controller/ \
Controllers/NZXTHue2Controller/ \
Controllers/NZXTHuePlusController/ \
Controllers/NZXTKrakenController/ \
@ -566,6 +567,8 @@ HEADERS +=
Controllers/NvidiaESAController/NvidiaESAController.h \
Controllers/NanoleafController/RGBController_Nanoleaf.h \
Controllers/NvidiaESAController/RGBController_NvidiaESA.h \
Controllers/NZXTHue1Controller/NZXTHue1Controller.h \
Controllers/NZXTHue1Controller/RGBController_NZXTHue1.h \
Controllers/NZXTHue2Controller/NZXTHue2Controller.h \
Controllers/NZXTHue2Controller/RGBController_NZXTHue2.h \
Controllers/NZXTHuePlusController/NZXTHuePlusController.h \
@ -1197,6 +1200,9 @@ SOURCES +=
Controllers/NvidiaESAController/NvidiaESAController.cpp \
Controllers/NvidiaESAController/NvidiaESAControllerDetect.cpp \
Controllers/NvidiaESAController/RGBController_NvidiaESA.cpp \
Controllers/NZXTHue1Controller/NZXTHue1Controller.cpp \
Controllers/NZXTHue1Controller/NZXTHue1ControllerDetect.cpp \
Controllers/NZXTHue1Controller/RGBController_NZXTHue1.cpp \
Controllers/NZXTHue2Controller/NZXTHue2Controller.cpp \
Controllers/NZXTHue2Controller/NZXTHue2ControllerDetect.cpp \
Controllers/NZXTHue2Controller/RGBController_NZXTHue2.cpp \