mirror/OpenRGB
1
0
Fork 0
mirror of https://github.com/CalcProgrammer1/OpenRGB.git synced 2026-04-04 22:24:12 -04:00
Code Issues Packages Projects Releases Wiki Activity

Add speed control to Hue 2

Browse Source
This commit is contained in:
Adam Honse
2020-01-16 20:46:46 -06:00
parent 4b8668e0ef
commit cf2c2d6b93
6 changed files with 106 additions and 163 deletions
Download Patch File Download Diff File Expand all files Collapse all files

124
Controllers/Hue2Controller/Hue2Controller.cpp
View File

@@ -19,6 +19,8 @@ Hue2Controller::Hue2Controller(libusb_device_handle* dev_handle)
Hue2Controller::~Hue2Controller()
{
current_mode = HUE_2_MODE_FIXED;
current_speed = HUE_2_SPEED_NORMAL;
}
unsigned int Hue2Controller::GetStripsOnChannel(unsigned int /*channel*/)
@@ -82,7 +84,13 @@ unsigned int Hue2Controller::GetStripsOnChannel(unsigned int /*channel*/)
return(ret_val);
}
void Hue2Controller::SetChannelEffect(unsigned int channel, unsigned int mode, std::vector<RGBColor> colors)
void Hue2Controller::SetMode(unsigned char mode, unsigned char speed)
{
current_mode = mode;
current_speed = speed;
}
void Hue2Controller::SetChannelLEDs(unsigned char channel, std::vector<RGBColor> colors)
{
unsigned char usb_buf[] =
{
@@ -113,8 +121,12 @@ void Hue2Controller::SetChannelEffect(unsigned int channel, unsigned int mode, s
/*-----------------------------------------------------*\
| Set mode in USB packet |
\*-----------------------------------------------------*/
usb_buf[0x04] = mode;
usb_buf[0x04] = current_mode;
/*-----------------------------------------------------*\
| Set speed in USB packet |
\*-----------------------------------------------------*/
usb_buf[0x05] = current_speed;
/*-----------------------------------------------------*\
| Set color count in USB packet |
\*-----------------------------------------------------*/
@@ -134,110 +146,4 @@ void Hue2Controller::SetChannelEffect(unsigned int channel, unsigned int mode, s
libusb_interrupt_transfer(dev, 0x01, usb_buf, 64, &actual, 0);
libusb_interrupt_transfer(dev, 0x81, usb_buf, 64, &actual, 0);
}
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;
std::size_t pkt_max = 20;
/*-----------------------------------------------------*\
| Set channel in USB packets |
\*-----------------------------------------------------*/
usb_buf[0x02] = 1 << channel;
usb_apply[0x02] = 1 << channel;
/*-----------------------------------------------------*\
| Send first packet for first 20 LEDs |
\*-----------------------------------------------------*/
if(pkt_max > colors.size())
{
pkt_max = colors.size();
}
for (std::size_t 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 = 0;
if (colors.size() > 20)
{
pkt_max = colors.size() - 20;
}
if(pkt_max > 0)
{
for (std::size_t 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);
}
}

16
Controllers/Hue2Controller/Hue2Controller.h
View File

@@ -28,6 +28,15 @@ enum
HUE_2_CHANNEL_4_IDX = 0x01, /* Channel 4 array index */
};
enum
{
HUE_2_SPEED_SLOWEST = 0x00, /* Slowest speed */
HUE_2_SPEED_SLOW = 0x01, /* Slow speed */
HUE_2_SPEED_NORMAL = 0x02, /* Normal speed */
HUE_2_SPEED_FAST = 0x03, /* Fast speed */
HUE_2_SPEED_FASTEST = 0x04, /* Fastest speed */
};
enum
{
HUE_2_MODE_FIXED = 0x00, /* Fixed colors mode */
@@ -49,11 +58,14 @@ public:
char* GetLEDString();
unsigned int GetStripsOnChannel(unsigned int channel);
void SetChannelEffect(unsigned int channel, unsigned int mode, std::vector<RGBColor> colors);
void SetChannelLEDs(unsigned int channel, std::vector<RGBColor> colors);
void SetChannelLEDs(unsigned char channel, std::vector<RGBColor> colors);
void SetMode(unsigned char mode, unsigned char speed);
unsigned int channel_leds[HUE_2_NUM_CHANNELS];
private:
libusb_device_handle* dev;
unsigned char current_mode;
unsigned char current_speed;
};

2
Controllers/HuePlusController/HuePlusController.cpp
View File

@@ -25,7 +25,7 @@ static void Sleep(unsigned int milliseconds)
HuePlusController::HuePlusController()
{
current_mode = HUE_PLUS_MODE_FIXED;
current_speed = 0;
current_speed = HUE_PLUS_SPEED_NORMAL;
}
HuePlusController::~HuePlusController()

7
Controllers/HuePlusController/HuePlusController.h
View File

@@ -41,8 +41,11 @@ enum
enum
{
HUE_PLUS_SPEED_MIN = 0x00, /* Slowest speed */
HUE_PLUS_SPEED_MAX = 0x04, /* Fastest speed */
HUE_PLUS_SPEED_SLOWEST = 0x00, /* Slowest speed */
HUE_PLUS_SPEED_SLOW = 0x01, /* Slow speed */
HUE_PLUS_SPEED_NORMAL = 0x02, /* Normal speed */
HUE_PLUS_SPEED_FAST = 0x03, /* Fast speed */
HUE_PLUS_SPEED_FASTEST = 0x04, /* Fastest speed */
};
enum

66
RGBController/RGBController_Hue2.cpp
View File

@@ -24,45 +24,66 @@ RGBController_Hue2::RGBController_Hue2(Hue2Controller* hue2_ptr)
modes.push_back(Direct);
mode Fading;
Fading.name = "Fading";
Fading.value = HUE_2_MODE_FADING;
Fading.flags = MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR;
Fading.name = "Fading";
Fading.value = HUE_2_MODE_FADING;
Fading.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR;
Fading.speed_min = HUE_2_SPEED_SLOWEST;
Fading.speed_max = HUE_2_SPEED_FASTEST;
Fading.speed = HUE_2_SPEED_NORMAL;
modes.push_back(Fading);
mode SpectrumCycle;
SpectrumCycle.name = "Spectrum Cycle";
SpectrumCycle.value = HUE_2_MODE_SPECTRUM;
SpectrumCycle.flags = 0;
SpectrumCycle.name = "Spectrum Cycle";
SpectrumCycle.value = HUE_2_MODE_SPECTRUM;
SpectrumCycle.flags = MODE_FLAG_HAS_SPEED;
SpectrumCycle.speed_min = HUE_2_SPEED_SLOWEST;
SpectrumCycle.speed_max = HUE_2_SPEED_FASTEST;
SpectrumCycle.speed = HUE_2_SPEED_NORMAL;
modes.push_back(SpectrumCycle);
mode Marquee;
Marquee.name = "Marquee";
Marquee.value = HUE_2_MODE_MARQUEE;
Marquee.flags = MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR;
Marquee.name = "Marquee";
Marquee.value = HUE_2_MODE_MARQUEE;
Marquee.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR;
Marquee.speed_min = HUE_2_SPEED_SLOWEST;
Marquee.speed_max = HUE_2_SPEED_FASTEST;
Marquee.speed = HUE_2_SPEED_NORMAL;
modes.push_back(Marquee);
mode CoverMarquee;
CoverMarquee.name = "Cover Marquee";
CoverMarquee.value = HUE_2_MODE_COVER_MARQUEE;
CoverMarquee.flags = MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR;
CoverMarquee.name = "Cover Marquee";
CoverMarquee.value = HUE_2_MODE_COVER_MARQUEE;
CoverMarquee.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR;
CoverMarquee.speed_min = HUE_2_SPEED_SLOWEST;
CoverMarquee.speed_max = HUE_2_SPEED_FASTEST;
CoverMarquee.speed = HUE_2_SPEED_NORMAL;
modes.push_back(CoverMarquee);
mode Alternating;
Alternating.name = "Alternating";
Alternating.value = HUE_2_MODE_ALTERNATING;
Alternating.flags = MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR;
Alternating.name = "Alternating";
Alternating.value = HUE_2_MODE_ALTERNATING;
Alternating.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR;
Alternating.speed_min = HUE_2_SPEED_SLOWEST;
Alternating.speed_max = HUE_2_SPEED_FASTEST;
Alternating.speed = HUE_2_SPEED_NORMAL;
modes.push_back(Alternating);
mode Pulsing;
Pulsing.name = "Pulsing";
Pulsing.value = HUE_2_MODE_PULSING;
Pulsing.flags = MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR;
Pulsing.name = "Pulsing";
Pulsing.value = HUE_2_MODE_PULSING;
Pulsing.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR;
Pulsing.speed_min = HUE_2_SPEED_SLOWEST;
Pulsing.speed_max = HUE_2_SPEED_FASTEST;
Pulsing.speed = HUE_2_SPEED_NORMAL;
modes.push_back(Pulsing);
mode Breathing;
Breathing.name = "Breathing";
Breathing.value = HUE_2_MODE_BREATHING;
Breathing.flags = MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR;
Breathing.name = "Breathing";
Breathing.value = HUE_2_MODE_BREATHING;
Breathing.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR;
Breathing.speed_min = HUE_2_SPEED_SLOWEST;
Breathing.speed_max = HUE_2_SPEED_FASTEST;
Breathing.speed = HUE_2_SPEED_NORMAL;
modes.push_back(Breathing);
/*-------------------------------------------------*\
@@ -142,7 +163,8 @@ void RGBController_Hue2::SetMode(int mode)
if(channel_colors.size() > 0)
{
hue2->SetChannelEffect(channel, modes[mode].value, channel_colors);
hue2->SetMode(modes[mode].value, modes[mode].speed);
hue2->SetChannelLEDs(channel, channel_colors);
}
}
}

54
RGBController/RGBController_HuePlus.cpp
View File

@@ -30,63 +30,63 @@ RGBController_HuePlus::RGBController_HuePlus(HuePlusController* hueplus_ptr)
// Fading.name = "Fading";
// Fading.value = HUE_PLUS_MODE_FADING;
// Fading.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR;
// Fading.speed_min = HUE_PLUS_SPEED_MIN;
// Fading.speed_max = HUE_PLUS_SPEED_MAX;
// Fading.speed = HUE_PLUS_SPEED_MIN;
// Fading.speed_min = HUE_PLUS_SPEED_SLOWEST;
// Fading.speed_max = HUE_PLUS_SPEED_FASTEST;
// Fading.speed = HUE_PLUS_SPEED_NORMAL;
// modes.push_back(Fading);
mode SpectrumCycle;
SpectrumCycle.name = "Spectrum Cycle";
SpectrumCycle.value = HUE_PLUS_MODE_SPECTRUM;
SpectrumCycle.flags = MODE_FLAG_HAS_SPEED;
SpectrumCycle.speed_min = HUE_PLUS_SPEED_MIN;
SpectrumCycle.speed_max = HUE_PLUS_SPEED_MAX;
SpectrumCycle.speed = HUE_PLUS_SPEED_MIN;
SpectrumCycle.speed_min = HUE_PLUS_SPEED_SLOWEST;
SpectrumCycle.speed_max = HUE_PLUS_SPEED_FASTEST;
SpectrumCycle.speed = HUE_PLUS_SPEED_NORMAL;
modes.push_back(SpectrumCycle);
mode Marquee;
Marquee.name = "Marquee";
Marquee.value = HUE_PLUS_MODE_MARQUEE;
Marquee.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR;
Marquee.speed_min = HUE_PLUS_SPEED_MIN;
Marquee.speed_max = HUE_PLUS_SPEED_MAX;
Marquee.speed = HUE_PLUS_SPEED_MIN;
Marquee.speed_min = HUE_PLUS_SPEED_SLOWEST;
Marquee.speed_max = HUE_PLUS_SPEED_FASTEST;
Marquee.speed = HUE_PLUS_SPEED_NORMAL;
modes.push_back(Marquee);
mode CoverMarquee;
CoverMarquee.name = "Cover Marquee";
CoverMarquee.value = HUE_PLUS_MODE_COVER_MARQUEE;
CoverMarquee.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR;
CoverMarquee.speed_min = HUE_PLUS_SPEED_MIN;
CoverMarquee.speed_max = HUE_PLUS_SPEED_MAX;
CoverMarquee.speed = HUE_PLUS_SPEED_MIN;
CoverMarquee.speed_min = HUE_PLUS_SPEED_SLOWEST;
CoverMarquee.speed_max = HUE_PLUS_SPEED_FASTEST;
CoverMarquee.speed = HUE_PLUS_SPEED_NORMAL;
modes.push_back(CoverMarquee);
mode Alternating;
Alternating.name = "Alternating";
Alternating.value = HUE_PLUS_MODE_ALTERNATING;
Alternating.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR;
Alternating.speed_min = HUE_PLUS_SPEED_MIN;
Alternating.speed_max = HUE_PLUS_SPEED_MAX;
Alternating.speed = HUE_PLUS_SPEED_MIN;
Alternating.speed_min = HUE_PLUS_SPEED_SLOWEST;
Alternating.speed_max = HUE_PLUS_SPEED_FASTEST;
Alternating.speed = HUE_PLUS_SPEED_NORMAL;
modes.push_back(Alternating);
mode Pulsing;
Pulsing.name = "Pulsing";
Pulsing.value = HUE_PLUS_MODE_PULSING;
Pulsing.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR;
Pulsing.speed_min = HUE_PLUS_SPEED_MIN;
Pulsing.speed_max = HUE_PLUS_SPEED_MAX;
Pulsing.speed = HUE_PLUS_SPEED_MIN;
Pulsing.speed_min = HUE_PLUS_SPEED_SLOWEST;
Pulsing.speed_max = HUE_PLUS_SPEED_FASTEST;
Pulsing.speed = HUE_PLUS_SPEED_NORMAL;
modes.push_back(Pulsing);
mode Breathing;
Breathing.name = "Breathing";
Breathing.value = HUE_PLUS_MODE_BREATHING;
Breathing.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR;
Breathing.speed_min = HUE_PLUS_SPEED_MIN;
Breathing.speed_max = HUE_PLUS_SPEED_MAX;
Breathing.speed = HUE_PLUS_SPEED_MIN;
Breathing.speed_min = HUE_PLUS_SPEED_SLOWEST;
Breathing.speed_max = HUE_PLUS_SPEED_FASTEST;
Breathing.speed = HUE_PLUS_SPEED_NORMAL;
modes.push_back(Breathing);
mode Alert;
@@ -105,9 +105,9 @@ RGBController_HuePlus::RGBController_HuePlus(HuePlusController* hueplus_ptr)
Wings.name = "Wings";
Wings.value = HUE_PLUS_MODE_WINGS;
Wings.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR;
Wings.speed_min = HUE_PLUS_SPEED_MIN;
Wings.speed_max = HUE_PLUS_SPEED_MAX;
Wings.speed = HUE_PLUS_SPEED_MIN;
Wings.speed_min = HUE_PLUS_SPEED_SLOWEST;
Wings.speed_max = HUE_PLUS_SPEED_FASTEST;
Wings.speed = HUE_PLUS_SPEED_NORMAL;
modes.push_back(Wings);
// Wave mode is currently disabled because it doesn't appear to work
@@ -115,9 +115,9 @@ RGBController_HuePlus::RGBController_HuePlus(HuePlusController* hueplus_ptr)
// Wave.name = "Wave";
// Wave.value = HUE_PLUS_MODE_WAVE;
// Wave.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR;
// Wave.speed_min = HUE_PLUS_SPEED_MIN;
// Wave.speed_max = HUE_PLUS_SPEED_MAX;
// Wave.speed = HUE_PLUS_SPEED_MIN;
// Wave.speed_min = HUE_PLUS_SPEED_SLOWEST;
// Wave.speed_max = HUE_PLUS_SPEED_FASTEST;
// Wave.speed = HUE_PLUS_SPEED_NORMAL;
// modes.push_back(Wave);
/*-------------------------------------------------*\