More poseidon z rework

Use GridLayout and allow app resize when user resize/expand the window
Also fixes some buttons size

TEST: compiled on KDE 5.17.90, after this commit all pages
      resize correctly when window is resized

Signed-off-by: Marco Zanin (B--B) <[email protected]>

.gitignore

@@ -0,0 +1 @@
+*.pro.user*

.gitmodules

@@ -1,3 +1,3 @@
 [submodule "dependencies/libe131"]
 	path = dependencies/libe131
-	url = https://github.com/hhromic/libe131
+	url = https://github.com/CalcProgrammer1/libe131

Controllers/AMDWraithPrismController/AMDWraithPrismController.cpp

@@ -0,0 +1,348 @@
+/*-----------------------------------------*\
+|  AMDWraithPrismController.h               |
+|                                           |
+|  Driver for AMD Wraith Prism RGB lighting |
+|  controller                               |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 12/6/2019   |
+\*-----------------------------------------*/
+
+#include "AMDWraithPrismController.h"
+#include <cstring>
+#include <stdio.h>
+#include <stdlib.h>
+
+AMDWraithPrismController::AMDWraithPrismController(libusb_device_handle* dev_handle)
+{
+    dev = dev_handle;
+
+    strcpy(device_name, "AMD Wraith Prism");
+
+    current_fan_mode = AMD_WRAITH_PRISM_FAN_LOGO_MODE_STATIC;
+    current_fan_speed = 0xFF;
+    current_fan_random_color = false;
+
+    current_logo_mode = AMD_WRAITH_PRISM_FAN_LOGO_MODE_STATIC;
+    current_logo_speed = 0xFF;
+    current_logo_random_color = false;
+
+    current_ring_mode = AMD_WRAITH_PRISM_EFFECT_CHANNEL_STATIC;
+    current_ring_speed = 0xFF;
+    current_ring_direction = false;
+
+    SendEnableCommand();
+}
+
+AMDWraithPrismController::~AMDWraithPrismController()
+{
+
+}
+
+char* AMDWraithPrismController::GetDeviceName()
+{
+    return device_name;
+}
+
+std::string AMDWraithPrismController::GetEffectChannelString(unsigned char channel)
+{
+    std::string ret_string = "";
+
+    unsigned char usb_buf[] =
+    {
+        0x40, 0x21, 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;
+
+    usb_buf[0x02] = channel;
+
+    libusb_interrupt_transfer(dev, 0x04, usb_buf, 64, &actual, 0);
+    libusb_interrupt_transfer(dev, 0x83, usb_buf, 64, &actual, 0);
+
+    ret_string.append((char *)&usb_buf[0x08]);
+
+    return(ret_string);
+}
+
+std::string AMDWraithPrismController::GetFirmwareVersionString()
+{
+    std::string ret_string = "";
+
+    unsigned char usb_buf[] =
+    {
+        0x12, 0x20, 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;
+    unsigned char   fw_buf[16] = {0x00};
+
+    libusb_interrupt_transfer(dev, 0x04, usb_buf, 64, &actual, 0);
+    libusb_interrupt_transfer(dev, 0x83, usb_buf, 64, &actual, 0);
+
+    for(int char_idx = 0; char_idx < 16; char_idx+=2)
+    {
+        if(usb_buf[char_idx + 0x08] != 0)
+        {
+            fw_buf[char_idx / 2] = usb_buf[char_idx + 0x08];
+        }
+        else
+        {
+            break;
+        }
+    }
+
+    ret_string.append((char *)fw_buf);
+
+    return(ret_string);
+}
+
+void AMDWraithPrismController::SetFanMode(unsigned char mode, unsigned char speed, bool random_color)
+{
+    current_fan_mode            = mode;
+    current_fan_speed           = speed_values_fan_logo[mode][speed];
+    current_fan_random_color    = random_color;
+}
+
+void AMDWraithPrismController::SetFanColor(unsigned char red, unsigned char green, unsigned char blue)
+{
+    SendEffectChannelUpdate
+    (
+        AMD_WRAITH_PRISM_EFFECT_CHANNEL_FAN_LED,
+        current_fan_speed,
+        false,
+        current_fan_random_color,
+        current_fan_mode,
+        max_brightness_fan_logo[current_fan_mode],
+        red,
+        green,
+        blue
+    );
+}
+
+void AMDWraithPrismController::SetLogoMode(unsigned char mode, unsigned char speed, bool random_color)
+{
+    current_logo_mode           = mode;
+    current_logo_speed          = speed_values_fan_logo[mode][speed];
+    current_logo_random_color   = random_color;
+}
+
+void AMDWraithPrismController::SetLogoColor(unsigned char red, unsigned char green, unsigned char blue)
+{
+    SendEffectChannelUpdate
+    (
+        AMD_WRAITH_PRISM_EFFECT_CHANNEL_LOGO_LED,
+        current_logo_speed,
+        false,
+        current_logo_random_color,
+        current_logo_mode,
+        max_brightness_fan_logo[current_logo_mode],
+        red,
+        green,
+        blue
+    );
+}
+
+void AMDWraithPrismController::SetRingMode(unsigned char mode, unsigned char speed, bool direction, bool random_color)
+{
+    current_ring_mode           = mode;
+    current_ring_speed          = speed_values_ring[mode][speed];
+    current_ring_direction      = direction;
+    current_ring_random_color   = random_color;
+}
+
+void AMDWraithPrismController::SetRingColor(unsigned char red, unsigned char green, unsigned char blue)
+{
+    SetRingEffectChannel(current_ring_mode);
+
+    SendEffectChannelUpdate
+    (
+        current_ring_mode,
+        current_ring_speed,
+        current_ring_direction,
+        current_ring_random_color,
+        mode_value_ring[current_ring_mode],
+        max_brightness_ring[current_ring_mode],
+        red,
+        green,
+        blue
+    );
+
+    SendApplyCommand();
+}
+
+void AMDWraithPrismController::SetRingEffectChannel(unsigned char channel)
+{
+    SendChannelRemap(channel, AMD_WRAITH_PRISM_EFFECT_CHANNEL_LOGO_LED, AMD_WRAITH_PRISM_EFFECT_CHANNEL_FAN_LED);
+}
+
+void AMDWraithPrismController::SendEnableCommand()
+{
+    unsigned char usb_buf[] =
+    {
+        0x41, 0x80, 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;
+
+    libusb_interrupt_transfer(dev, 0x04, usb_buf, 64, &actual, 0);
+    libusb_interrupt_transfer(dev, 0x83, usb_buf, 64, &actual, 0);
+}
+
+void AMDWraithPrismController::SendApplyCommand()
+{
+    unsigned char usb_buf[] =
+    {
+        0x51, 0x28, 0x00, 0x00,
+        0xE0, 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;
+
+    libusb_interrupt_transfer(dev, 0x04, usb_buf, 64, &actual, 0);
+    libusb_interrupt_transfer(dev, 0x83, usb_buf, 64, &actual, 0);
+}
+
+void AMDWraithPrismController::SendEffectChannelUpdate
+    (
+    unsigned char effect_channel,
+    unsigned char speed,
+    bool          direction,
+    bool          random_color,
+    unsigned char mode,
+    unsigned char brightness,
+    unsigned char red,
+    unsigned char green,
+    unsigned char blue
+    )
+{
+    unsigned char usb_buf[] =
+    {
+        0x51, 0x2C, 0x01, 0x00,
+        0x05, 0xFF, 0x00, 0x01,
+        0xFF, 0xFF, 0x00, 0xFF,
+        0x00, 0x00, 0x00, 0x00,
+        0xFF, 0xFF, 0xFF, 0xFF,
+        0xFF, 0xFF, 0xFF, 0xFF,
+        0xFF, 0xFF, 0xFF, 0xFF,
+        0xFF, 0xFF, 0xFF, 0xFF,
+        0xFF, 0xFF, 0xFF, 0xFF,
+        0xFF, 0xFF, 0xFF, 0xFF,
+        0xFF, 0xFF, 0xFF, 0xFF,
+        0xFF, 0xFF, 0xFF, 0xFF,
+        0xFF, 0xFF, 0xFF, 0xFF,
+        0xFF, 0xFF, 0xFF, 0xFF,
+        0xFF, 0xFF, 0xFF, 0xFF,
+        0xFF, 0xFF, 0xFF, 0xFF
+    };
+
+    int             actual;
+
+    usb_buf[0x04]   = effect_channel;
+    usb_buf[0x05]   = speed;
+    usb_buf[0x06]   = (direction ? 0x01 : 0x00) | (random_color ? 0x80 : 0x00);
+    usb_buf[0x07]   = mode;
+
+    usb_buf[0x09]   = brightness;
+
+    usb_buf[0x0A]   = red;
+    usb_buf[0x0B]   = green;
+    usb_buf[0x0C]   = blue;
+
+    libusb_interrupt_transfer(dev, 0x04, usb_buf, 64, &actual, 0);
+    libusb_interrupt_transfer(dev, 0x83, usb_buf, 64, &actual, 0);
+}
+
+void AMDWraithPrismController::SendChannelRemap(unsigned char ring_channel, unsigned char logo_channel, unsigned char fan_channel)
+{
+    unsigned char usb_buf[] =
+    {
+        0x51, 0xA0, 0x01, 0x00,
+        0x00, 0x03, 0x00, 0x00,
+        0x05, 0x06, 0x07, 0x07,
+        0x07, 0x07, 0x07, 0x07,
+        0x07, 0x07, 0x07, 0x07,
+        0x07, 0x07, 0x07, 0x07,
+        0x07, 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;
+
+    usb_buf[0x08] = logo_channel;
+    usb_buf[0x09] = fan_channel;
+
+    for(int led = 0x0A; led <= 0x18; led++)
+    {
+        usb_buf[led] = ring_channel;
+    }
+
+    libusb_interrupt_transfer(dev, 0x04, usb_buf, 64, &actual, 0);
+    libusb_interrupt_transfer(dev, 0x83, usb_buf, 64, &actual, 0);
+}

Controllers/AMDWraithPrismController/AMDWraithPrismController.h

@@ -0,0 +1,166 @@
+/*-----------------------------------------*\
+|  AMDWraithPrismController.h               |
+|                                           |
+|  Definitions and types for AMD Wraith     |
+|  Prism lighting controller                |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 12/6/2019   |
+\*-----------------------------------------*/
+
+#include <string>
+#include <libusb-1.0/libusb.h>
+
+#pragma once
+
+static const unsigned char max_brightness_fan_logo[] =
+{
+    0x00,
+    0xFF,
+    0x7F,
+    0xFF
+};
+
+static const unsigned char speed_values_fan_logo[][5] =
+{
+    { 0x00, 0x00, 0x00, 0x00, 0x00 },                  /*                              */
+    { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF },                  /* Static                       */
+    { 0x96, 0x8C, 0x80, 0x6E, 0x68 },                  /* Color Cycle                  */
+    { 0x3C, 0x37, 0x31, 0x2C, 0x26 },                  /* Breathing                    */
+};
+
+static const unsigned char max_brightness_ring[] =
+{
+    0xFF,
+    0xFF,
+    0x7F,
+    0x00,
+    0x00,
+    0x00,
+    0x00,
+    0xFF,
+    0xFF,
+    0xFF,
+    0xFF,
+    0xFF
+};
+
+static const unsigned char mode_value_ring[] =
+{
+    0xFF,
+    0x03,
+    0xFF,
+    0x00,
+    0x00,
+    0x00,
+    0x00,
+    0x05,
+    0xFF,
+    0xC3,
+    0x4A,
+    0x05
+};
+
+static const unsigned char speed_values_ring[][5] =
+{
+    { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF },                   /* Static                       */
+    { 0x3C, 0x37, 0x31, 0x2C, 0x26 },                   /* Breathing                    */
+    { 0x96, 0x8C, 0x80, 0x6E, 0x68 },                   /* Color Cycle                  */
+    { 0x00, 0x00, 0x00, 0x00, 0x00 },                   /*                              */
+    { 0x00, 0x00, 0x00, 0x00, 0x00 },                   /*                              */
+    { 0x00, 0x00, 0x00, 0x00, 0x00 },                   /*                              */
+    { 0x00, 0x00, 0x00, 0x00, 0x00 },                   /*                              */
+    { 0x72, 0x68, 0x64, 0x62, 0x61 },                   /* Rainbow                      */
+    { 0x00, 0x00, 0x00, 0x00, 0x00 },                   /* Bounce                       */
+    { 0x77, 0x74, 0x6E, 0x6B, 0x67 },                   /* Chase                        */
+    { 0x77, 0x74, 0x6E, 0x6B, 0x67 },                   /* Swirl                        */
+    { 0x00, 0x00, 0x00, 0x00, 0x00 },                   /* Morse Code                   */
+};
+
+enum
+{
+    AMD_WRAITH_PRISM_FAN_LOGO_MODE_STATIC       = 0x01, /* Fan/Logo Static Mode         */
+    AMD_WRAITH_PRISM_FAN_LOGO_MODE_COLOR_CYCLE  = 0x02, /* Fan/Logo Color Cycle Mode    */
+    AMD_WRAITH_PRISM_FAN_LOGO_MODE_BREATHING    = 0x03, /* Fan/Logo Breathing Mode      */
+};
+
+enum
+{
+    AMD_WRAITH_PRISM_EFFECT_CHANNEL_STATIC      = 0x00, /* Static effect channel        */
+    AMD_WRAITH_PRISM_EFFECT_CHANNEL_BREATHING   = 0x01, /* Breathing effect channel     */
+    AMD_WRAITH_PRISM_EFFECT_CHANNEL_COLOR_CYCLE = 0x02, /* Color cycle effect channel   */
+    AMD_WRAITH_PRISM_EFFECT_CHANNEL_LOGO_LED    = 0x05, /* Logo LED effect channel      */
+    AMD_WRAITH_PRISM_EFFECT_CHANNEL_FAN_LED     = 0x06, /* Fan LED effect channel       */
+    AMD_WRAITH_PRISM_EFFECT_CHANNEL_RAINBOW     = 0x07, /* Rainbow effect channel       */
+    AMD_WRAITH_PRISM_EFFECT_CHANNEL_BOUNCE      = 0x08, /* Bounce effect channel        */
+    AMD_WRAITH_PRISM_EFFECT_CHANNEL_CHASE       = 0x09, /* Chase effect channel         */
+    AMD_WRAITH_PRISM_EFFECT_CHANNEL_SWIRL       = 0x0A, /* Swirl effect channel         */
+    AMD_WRAITH_PRISM_EFFECT_CHANNEL_MORSE       = 0x0B, /* Morse code effect channel    */
+};
+
+enum
+{
+    AMD_WRAITH_PRISM_SPEED_SLOWEST              = 0x00, /* Slowest speed                */
+    AMD_WRAITH_PRISM_SPEED_SLOW                 = 0x01, /* Slow speed                   */
+    AMD_WRAITH_PRISM_SPEED_NORMAL               = 0x02, /* Normal speed                 */
+    AMD_WRAITH_PRISM_SPEED_FAST                 = 0x03, /* Fast speed                   */
+    AMD_WRAITH_PRISM_SPEED_FASTEST              = 0x04, /* Fastest speed                */
+};
+
+class AMDWraithPrismController
+{
+public:
+    AMDWraithPrismController(libusb_device_handle* dev_handle);
+    ~AMDWraithPrismController();
+
+    char* GetDeviceName();
+
+    std::string GetEffectChannelString(unsigned char channel);
+    std::string GetFirmwareVersionString();
+
+    void SetRingEffectChannel(unsigned char channel);
+
+    void SetFanMode(unsigned char mode, unsigned char speed, bool random_color);
+    void SetFanColor(unsigned char red, unsigned char green, unsigned char blue);
+
+    void SetLogoMode(unsigned char mode, unsigned char speed, bool random_color);
+    void SetLogoColor(unsigned char red, unsigned char green, unsigned char blue);
+
+    void SetRingMode(unsigned char mode, unsigned char speed, bool direction, bool random_color);
+    void SetRingColor(unsigned char red, unsigned char green, unsigned char blue);
+
+private:
+    char                    device_name[32];
+    libusb_device_handle*   dev;
+
+    unsigned char           current_fan_mode;
+    unsigned char           current_fan_speed;
+    bool                    current_fan_random_color;
+
+    unsigned char           current_logo_mode;
+    unsigned char           current_logo_speed;
+    bool                    current_logo_random_color;
+
+    unsigned char           current_ring_mode;
+    unsigned char           current_ring_speed;
+    bool                    current_ring_direction;
+    bool                    current_ring_random_color;
+
+    void SendEnableCommand();
+
+    void SendApplyCommand();
+
+    void SendEffectChannelUpdate
+        (
+        unsigned char effect_channel,
+        unsigned char speed,
+        bool          direction,
+        bool          random_color,
+        unsigned char mode,
+        unsigned char brightness,
+        unsigned char red,
+        unsigned char green,
+        unsigned char blue
+        );
+
+    void SendChannelRemap(unsigned char ring_channel, unsigned char logo_channel, unsigned char fan_channel);
+};

Controllers/AMDWraithPrismController/AMDWraithPrismControllerDetect.cpp

@@ -0,0 +1,37 @@
+#include "AMDWraithPrismController.h"
+#include "RGBController.h"
+#include "RGBController_AMDWraithPrism.h"
+#include <vector>
+#include <libusb-1.0/libusb.h>
+
+#define AMD_WRAITH_PRISM_VID 0x2516
+#define AMD_WRAITH_PRISM_PID 0x0051
+
+/******************************************************************************************\
+*                                                                                          *
+*   DetectAMDWraithPrismControllers                                                        *
+*                                                                                          *
+*       Tests the USB address to see if an AMD Wraith Prism controller exists there.       *
+*                                                                                          *
+\******************************************************************************************/
+
+void DetectAMDWraithPrismControllers(std::vector<RGBController*>& rgb_controllers)
+{
+    libusb_context * ctx;
+    libusb_init(&ctx);
+
+    //Look for AMD Wraith Prism
+    libusb_device_handle * dev = libusb_open_device_with_vid_pid(ctx, AMD_WRAITH_PRISM_VID, AMD_WRAITH_PRISM_PID);
+
+    if( dev )
+    {
+        libusb_detach_kernel_driver(dev, 1);
+        libusb_claim_interface(dev, 1);
+
+        AMDWraithPrismController* controller = new AMDWraithPrismController(dev);
+
+        RGBController_AMDWraithPrism* rgb_controller = new RGBController_AMDWraithPrism(controller);
+
+        rgb_controllers.push_back(rgb_controller);
+    }
+}

Controllers/AuraController/AuraController.cpp

@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  AuraController.h                         |
+|  AuraController.cpp                       |
 |                                           |
 |  Driver for ASUS Aura RGB lighting        |
 |  controller                               |
@@ -82,11 +82,21 @@ AuraController::~AuraController()
 
 }
 
-char * AuraController::GetDeviceName()
+std::string AuraController::GetDeviceName()
 {
     return(device_name);
 }
 
+std::string AuraController::GetDeviceLocation()
+{
+    std::string return_string(bus->device_name);
+    char addr[5];
+    snprintf(addr, 5, "0x%02X", dev);
+    return_string.append(", address ");
+    return_string.append(addr);
+    return(return_string);
+}
+
 unsigned char AuraController::GetChannel(unsigned int led)
 {
     return(config_table[channel_cfg + led]);
@@ -147,11 +157,26 @@ unsigned int AuraController::GetLEDCount()
     return(led_count);
 }
 
+unsigned char AuraController::GetLEDRed(unsigned int led)
+{
+    return(AuraRegisterRead(direct_reg + ( 3 * led )));
+}
+
+unsigned char AuraController::GetLEDGreen(unsigned int led)
+{
+    return(AuraRegisterRead(direct_reg + ( 3 * led ) + 2));
+}
+
+unsigned char AuraController::GetLEDBlue(unsigned int led)
+{
+    return(AuraRegisterRead(direct_reg + ( 3 * led ) + 1));
+}
+
 void AuraController::SetAllColorsDirect(unsigned char red, unsigned char green, unsigned char blue)
 {
     unsigned char* colors = new unsigned char[led_count * 3];
 
-    for (int i = 0; i < (led_count * 3); i += 3)
+    for (unsigned int i = 0; i < (led_count * 3); i += 3)
     {
         colors[i + 0] = red;
         colors[i + 1] = blue;
@@ -167,7 +192,7 @@ void AuraController::SetAllColorsEffect(unsigned char red, unsigned char green,
 {
     unsigned char* colors = new unsigned char[led_count * 3];
 
-    for (int i = 0; i < (led_count * 3); i += 3)
+    for (unsigned int i = 0; i < (led_count * 3); i += 3)
     {
         colors[i + 0] = red;
         colors[i + 1] = blue;
@@ -178,7 +203,7 @@ void AuraController::SetAllColorsEffect(unsigned char red, unsigned char green,
     
     AuraRegisterWrite(AURA_REG_APPLY, AURA_APPLY_VAL);
 
-    delete colors;
+    delete[] colors;
 }
 
 void AuraController::SetDirect(unsigned char direct)
@@ -245,4 +270,4 @@ void AuraController::AuraRegisterWriteBlock(aura_register reg, unsigned char * d
     //Write Aura block data
     bus->i2c_smbus_write_block_data(dev, 0x03, sz, data);
 
-}
+}

Controllers/AuraController/AuraController.h

@@ -7,6 +7,7 @@
 |  Adam Honse (CalcProgrammer1) 8/19/2018   |
 \*-----------------------------------------*/
 
+#include <string>
 #include "i2c_smbus.h"
 
 #pragma once
@@ -93,10 +94,14 @@ public:
     AuraController(i2c_smbus_interface* bus, aura_dev_id dev);
     ~AuraController();
 
-    char*         GetDeviceName();
+    std::string   GetDeviceName();
+    std::string   GetDeviceLocation();
     unsigned char GetChannel(unsigned int led);
     const char*   GetChannelName(unsigned int led);
     unsigned int  GetLEDCount();
+    unsigned char GetLEDRed(unsigned int led);
+    unsigned char GetLEDGreen(unsigned int led);
+    unsigned char GetLEDBlue(unsigned int led);
     void          SetAllColorsDirect(unsigned char red, unsigned char green, unsigned char blue);
     void          SetAllColorsEffect(unsigned char red, unsigned char green, unsigned char blue);
     void          SetDirect(unsigned char direct);
@@ -120,4 +125,4 @@ private:
     i2c_smbus_interface *   bus;
     aura_dev_id             dev;
 
-};
+};

Controllers/AuraController/AuraControllerDetect.cpp

@@ -6,6 +6,75 @@
 #include <stdio.h>
 #include <stdlib.h>
 
+#ifdef WIN32
+#include <Windows.h>
+#else
+#include <unistd.h>
+
+static void Sleep(unsigned int milliseconds)
+{
+    usleep(1000 * milliseconds);
+}
+#endif
+
+/*----------------------------------------------------------------------*\
+| This list contains the available SMBus addresses for mapping Aura RAM  |
+\*----------------------------------------------------------------------*/
+#define AURA_RAM_ADDRESS_COUNT  17
+
+static const unsigned char aura_ram_addresses[] =
+{
+    0x70,
+    0x71,
+    0x73,
+    0x74,
+    0x75,
+    0x76,
+    0x78,
+    0x79,
+    0x7A,
+    0x7B,
+    0x7C,
+    0x7D,
+    0x7E,
+    0x7F,
+    0x4F,
+    0x66,
+    0x67
+};
+
+/*---------------------------------------------------------------------------------*\
+| This list contains the available SMBus addresses for mapping Aura motherboards    |
+\*---------------------------------------------------------------------------------*/
+#define AURA_MOBO_ADDRESS_COUNT 4
+
+static const unsigned char aura_mobo_addresses[] =
+{
+    0x40,
+    0x4E,
+    0x4F,
+    0x66
+};
+
+/******************************************************************************************\
+*                                                                                          *
+*   AuraRegisterWrite                                                                      *
+*                                                                                          *
+*       A standalone version of the AuraController::AuraRegisterWrite function for access  *
+*       to Aura devices without instancing the AuraController class or reading the config  *
+*       table from the device.                                                             *
+*                                                                                          *
+\******************************************************************************************/
+
+void AuraRegisterWrite(i2c_smbus_interface* bus, aura_dev_id dev, aura_register reg, unsigned char val)
+{
+    //Write Aura register
+    bus->i2c_smbus_write_word_data(dev, 0x00, ((reg << 8) & 0xFF00) | ((reg >> 8) & 0x00FF));
+
+    //Write Aura value
+    bus->i2c_smbus_write_byte_data(dev, 0x01, val);
+}
+
 /******************************************************************************************\
 *                                                                                          *
 *   TestForAuraController                                                                  *
@@ -62,6 +131,8 @@ void DetectAuraControllers(std::vector<i2c_smbus_interface*> &busses, std::vecto
 
     for (unsigned int bus = 0; bus < busses.size(); bus++)
     {
+        int address_list_idx = 0;
+
         // Remap Aura-enabled RAM modules on 0x77
         for (unsigned int slot = 0; slot < 8; slot++)
         {
@@ -72,54 +143,48 @@ void DetectAuraControllers(std::vector<i2c_smbus_interface*> &busses, std::vecto
                 break;
             }
 
-            AuraController temp_controller(busses[bus], 0x77);
+            do
+            {
+                if(address_list_idx < AURA_RAM_ADDRESS_COUNT)
+                {
+                    res = busses[bus]->i2c_smbus_write_quick(aura_ram_addresses[address_list_idx], I2C_SMBUS_WRITE);
+                    address_list_idx++;
+                }
+                else
+                {
+                    break;
+                }
+            } while (res >= 0);
 
-            temp_controller.AuraRegisterWrite(AURA_REG_SLOT_INDEX, slot);
-            temp_controller.AuraRegisterWrite(AURA_REG_I2C_ADDRESS, 0xE0 + (slot << 1));
+            AuraRegisterWrite(busses[bus], 0x77, AURA_REG_SLOT_INDEX, slot);
+            AuraRegisterWrite(busses[bus], 0x77, AURA_REG_I2C_ADDRESS, (aura_ram_addresses[address_list_idx] << 1));
         }
 
         // Add Aura-enabled controllers at their remapped addresses
-        for (unsigned int slot = 0; slot < 8; slot++)
+        for (unsigned int address_list_idx = 0; address_list_idx < AURA_RAM_ADDRESS_COUNT; address_list_idx++)
         {
-            if (TestForAuraController(busses[bus], 0x70 + slot))
+            if (TestForAuraController(busses[bus], aura_ram_addresses[address_list_idx]))
             {
-                new_aura = new AuraController(busses[bus], 0x70 + slot);
+                new_aura = new AuraController(busses[bus], aura_ram_addresses[address_list_idx]);
                 new_controller = new RGBController_Aura(new_aura);
                 rgb_controllers.push_back(new_controller);
             }
+
+            Sleep(1);
         }
 
-        // Check for Aura controller at 0x40
-        if (TestForAuraController(busses[bus], 0x40))
+        // Add Aura-enabled motherboard controllers
+        for (unsigned int address_list_idx = 0; address_list_idx < AURA_MOBO_ADDRESS_COUNT; address_list_idx++)
         {
-            new_aura = new AuraController(busses[bus], 0x40);
-            new_controller = new RGBController_Aura(new_aura);
-            rgb_controllers.push_back(new_controller);
-        }
+            if (TestForAuraController(busses[bus], aura_mobo_addresses[address_list_idx]))
+            {
+                new_aura = new AuraController(busses[bus], aura_mobo_addresses[address_list_idx]);
+                new_controller = new RGBController_Aura(new_aura);
+                rgb_controllers.push_back(new_controller);
+            }
 
-        // Check for Aura controller at 0x4E
-        if (TestForAuraController(busses[bus], 0x4E))
-        {
-            new_aura = new AuraController(busses[bus], 0x4E);
-            new_controller = new RGBController_Aura(new_aura);
-            rgb_controllers.push_back(new_controller);
-        }
-
-        // Check for Aura controller at 0x4F
-        if (TestForAuraController(busses[bus], 0x4F))
-        {
-            new_aura = new AuraController(busses[bus], 0x4F);
-            new_controller = new RGBController_Aura(new_aura);
-            rgb_controllers.push_back(new_controller);
-        }
-
-        // Check for Aura controller at 0x66
-        if (TestForAuraController(busses[bus], 0x66))
-        {
-            new_aura = new AuraController(busses[bus], 0x66);
-            new_controller = new RGBController_Aura(new_aura);
-            rgb_controllers.push_back(new_controller);
+            Sleep(1);
         }
     }
 
-}   /* DetectAuraControllers() */
+}   /* DetectAuraControllers() */

Controllers/CorsairCmdrProController/CorsairCmdrProController.cpp

@@ -0,0 +1,504 @@
+/*---------------------------------------------------------*\
+|  Processing Code for Corsair Commander Pro                |
+|                                                           |
+|  Adam Honse ([email protected]), 1/16/2020        |
+\*---------------------------------------------------------*/
+
+#include "CorsairCmdrProController.h"
+
+#include <fstream>
+#include <iostream>
+#include <string>
+#include <cstring>
+
+//Include thread libraries for Windows or Linux
+#ifdef WIN32
+#include <process.h>
+#else
+#include "pthread.h"
+#include "unistd.h"
+#endif
+
+//Thread functions have different types in Windows and Linux
+#ifdef WIN32
+#define THREAD static void
+#define THREADRETURN
+#else
+#define THREAD static void*
+#define THREADRETURN return(NULL);
+#endif
+
+#ifdef WIN32
+#include <Windows.h>
+#else
+#include <unistd.h>
+
+static void Sleep(unsigned int milliseconds)
+{
+    usleep(1000 * milliseconds);
+}
+#endif
+
+THREAD keepalive_thread(void *param)
+{
+    CorsairCmdrProController* corsair = static_cast<CorsairCmdrProController*>(param);
+    corsair->KeepaliveThread();
+    THREADRETURN
+}
+
+CorsairCmdrProController::CorsairCmdrProController(libusb_device_handle* dev_handle)
+{
+    dev = dev_handle;
+    channel_leds[0] = 60;
+    channel_leds[1] = 60;
+
+    /*-----------------------------------------------------*\
+    | The Corsair Lighting Node Pro requires a packet within|
+    | 20 seconds of sending the lighting change in order    |
+    | to not revert back into rainbow mode.  Start a thread |
+    | to continuously send a keepalive packet every 5s      |
+    \*-----------------------------------------------------*/
+#ifdef WIN32
+    _beginthread(keepalive_thread, 0, this);
+#else
+    pthread_t thread;
+    pthread_create(&thread, NULL, &keepalive_thread, this);
+#endif
+}
+
+CorsairCmdrProController::~CorsairCmdrProController()
+{
+}
+
+void CorsairCmdrProController::KeepaliveThread()
+{
+    while(1)
+    {
+        SendCommit();
+        Sleep(5000);
+    }
+}
+
+void CorsairCmdrProController::SetChannelEffect(unsigned char channel,
+                                                unsigned char mode,
+                                                unsigned char speed,
+                                                unsigned char direction,
+                                                bool          random,
+                                                unsigned char red1,
+                                                unsigned char grn1,
+                                                unsigned char blu1,
+                                                unsigned char red2,
+                                                unsigned char grn2,
+                                                unsigned char blu2
+                                               )
+{
+    /*-----------------------------------------------------*\
+    | Send Reset packet                                     |
+    \*-----------------------------------------------------*/
+    SendReset(channel);
+
+    /*-----------------------------------------------------*\
+    | Send Begin packet                                     |
+    \*-----------------------------------------------------*/
+    SendBegin(channel);
+
+    /*-----------------------------------------------------*\
+    | Set Port State packet                                 |
+    \*-----------------------------------------------------*/
+    SendPortState(channel, CORSAIR_CMDR_PRO_PORT_STATE_HARDWARE);
+
+    /*-----------------------------------------------------*\
+    | Set Effect Configuration packet                       |
+    \*-----------------------------------------------------*/
+    SendEffectConfig
+    (
+        channel,
+        0,
+        CORSAIR_CMDR_PRO_LED_TYPE_LED_STRIP,
+        mode,
+        speed,
+        direction,
+        random,
+        red1,
+        grn1,
+        blu1,
+        red2,
+        grn2,
+        blu2,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0
+    );
+
+    /*-----------------------------------------------------*\
+    | Send Commit packet                                    |
+    \*-----------------------------------------------------*/
+    SendCommit();
+}
+
+void CorsairCmdrProController::SetChannelLEDs(unsigned char channel, std::vector<RGBColor> colors)
+{
+    unsigned char   color_data[50];
+    unsigned char   pkt_max;
+
+    /*-----------------------------------------------------*\
+    | Send Port State packet                                |
+    \*-----------------------------------------------------*/
+    SendPortState(channel, CORSAIR_CMDR_PRO_PORT_STATE_SOFTWARE);
+
+    /*-----------------------------------------------------*\
+    | Send red channel packet 1                             |
+    \*-----------------------------------------------------*/
+    pkt_max = 50;
+
+    if(pkt_max > colors.size())
+    {
+        pkt_max = (unsigned char)colors.size();
+    }
+
+    for(int idx = 0; idx < pkt_max; idx++)
+    {
+        color_data[idx] = RGBGetRValue(colors[idx]);
+    }
+
+    SendDirect(channel, 0, pkt_max, CORSAIR_CMDR_PRO_DIRECT_CHANNEL_RED, color_data);
+
+    /*-----------------------------------------------------*\
+    | Send red channel packet 2 if necessary                |
+    \*-----------------------------------------------------*/
+    pkt_max = 0;
+
+    if (colors.size() > 50)
+    {
+        pkt_max = (unsigned char)(colors.size() - 50);
+    }
+
+    if(pkt_max > 0)
+    {
+        for (std::size_t idx = 0; idx < pkt_max; idx++)
+        {
+            color_data[idx] = RGBGetRValue(colors[idx+50]);
+        }
+
+        SendDirect(channel, 50, pkt_max, CORSAIR_CMDR_PRO_DIRECT_CHANNEL_RED, color_data);
+    }
+
+    /*-----------------------------------------------------*\
+    | Send green channel packet 1                           |
+    \*-----------------------------------------------------*/
+    pkt_max = 50;
+
+    if(pkt_max > colors.size())
+    {
+        pkt_max = (unsigned char)colors.size();
+    }
+
+    for(int idx = 0; idx < pkt_max; idx++)
+    {
+        color_data[idx] = RGBGetGValue(colors[idx]);
+    }
+
+    SendDirect(channel, 0, pkt_max, CORSAIR_CMDR_PRO_DIRECT_CHANNEL_GREEN, color_data);
+
+    /*-----------------------------------------------------*\
+    | Send green channel packet 2 if necessary              |
+    \*-----------------------------------------------------*/
+    pkt_max = 0;
+
+    if (colors.size() > 50)
+    {
+        pkt_max = (unsigned char)(colors.size() - 50);
+    }
+
+    if(pkt_max > 0)
+    {
+        for (std::size_t idx = 0; idx < pkt_max; idx++)
+        {
+            color_data[idx] = RGBGetGValue(colors[idx+50]);
+        }
+
+        SendDirect(channel, 50, pkt_max, CORSAIR_CMDR_PRO_DIRECT_CHANNEL_GREEN, color_data);
+    }
+
+    /*-----------------------------------------------------*\
+    | Send blue channel packet 1                            |
+    \*-----------------------------------------------------*/
+    pkt_max = 50;
+
+    if(pkt_max > colors.size())
+    {
+        pkt_max = (unsigned char)colors.size();
+    }
+
+    for(int idx = 0; idx < pkt_max; idx++)
+    {
+        color_data[idx] = RGBGetBValue(colors[idx]);
+    }
+
+    SendDirect(channel, 0, pkt_max, CORSAIR_CMDR_PRO_DIRECT_CHANNEL_BLUE, color_data);
+
+    /*-----------------------------------------------------*\
+    | Send blue channel packet 2 if necessary               |
+    \*-----------------------------------------------------*/
+    pkt_max = 0;
+
+    if (colors.size() > 50)
+    {
+        pkt_max = (unsigned char)(colors.size() - 50);
+    }
+
+    if(pkt_max > 0)
+    {
+        for (std::size_t idx = 0; idx < pkt_max; idx++)
+        {
+            color_data[idx] = RGBGetBValue(colors[idx+50]);
+        }
+
+        SendDirect(channel, 50, pkt_max, CORSAIR_CMDR_PRO_DIRECT_CHANNEL_BLUE, color_data);
+    }
+
+    /*-----------------------------------------------------*\
+    | Send Commit packet                                    |
+    \*-----------------------------------------------------*/
+    SendCommit();
+}
+
+/*-------------------------------------------------------------------------------------------------*\
+| Private packet sending functions.                                                                 |
+\*-------------------------------------------------------------------------------------------------*/
+
+void CorsairCmdrProController::SendDirect
+    (
+    unsigned char   channel,
+    unsigned char   start,
+    unsigned char   count,
+    unsigned char   color_channel,
+    unsigned char*  color_data
+    )
+{
+    int             actual;
+    unsigned char   usb_buf[64];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up Direct packet                                  |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]   = CORSAIR_CMDR_PRO_PACKET_ID_DIRECT;
+    usb_buf[0x01]   = channel;
+    usb_buf[0x02]   = start;
+    usb_buf[0x03]   = count;
+    usb_buf[0x04]   = color_channel;
+
+    /*-----------------------------------------------------*\
+    | Copy in color data bytes                              |
+    \*-----------------------------------------------------*/
+    memcpy(&usb_buf[0x05], color_data, count);
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    libusb_interrupt_transfer(dev, 0x02, usb_buf, 64, &actual, 0);
+}
+
+void CorsairCmdrProController::SendCommit()
+{
+    int             actual;
+    unsigned char   usb_buf[64];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up Commit packet                                  |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]   = CORSAIR_CMDR_PRO_PACKET_ID_COMMIT;
+    usb_buf[0x01]   = 0xFF;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    libusb_interrupt_transfer(dev, 0x02, usb_buf, 64, &actual, 0);
+}
+
+void CorsairCmdrProController::SendBegin
+    (
+    unsigned char   channel
+    )
+{
+    int             actual;
+    unsigned char   usb_buf[64];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up Begin packet                                   |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]   = CORSAIR_CMDR_PRO_PACKET_ID_BEGIN;
+    usb_buf[0x01]   = channel;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    libusb_interrupt_transfer(dev, 0x02, usb_buf, 64, &actual, 0);
+}
+
+void CorsairCmdrProController::SendEffectConfig
+    (
+    unsigned char   channel,
+    unsigned char   count,
+    unsigned char   led_type,
+    unsigned char   mode,
+    unsigned char   speed,
+    unsigned char   direction,
+    unsigned char   change_style,
+    unsigned char   color_0_red,
+    unsigned char   color_0_green,
+    unsigned char   color_0_blue,
+    unsigned char   color_1_red,
+    unsigned char   color_1_green,
+    unsigned char   color_1_blue,
+    unsigned char   color_2_red,
+    unsigned char   color_2_green,
+    unsigned char   color_2_blue,
+    unsigned short  temperature_0,
+    unsigned short  temperature_1,
+    unsigned short  temperature_2
+    )
+{
+    int             actual;
+    unsigned char   usb_buf[64];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up Effect Config packet                           |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]   = CORSAIR_CMDR_PRO_PACKET_ID_EFFECT_CONFIG;
+    usb_buf[0x01]   = channel;
+    usb_buf[0x02]   = count * 10;
+    usb_buf[0x03]   = led_type;
+
+    /*-----------------------------------------------------*\
+    | Set up mode parameters                                |
+    \*-----------------------------------------------------*/
+    usb_buf[0x04]   = mode;
+    usb_buf[0x05]   = speed;
+    usb_buf[0x06]   = direction;
+    usb_buf[0x07]   = change_style;
+    usb_buf[0x08]   = 0;
+
+    /*-----------------------------------------------------*\
+    | Set up mode colors                                    |
+    \*-----------------------------------------------------*/
+    usb_buf[0x09]   = color_0_red;
+    usb_buf[0x10]   = color_0_green;
+    usb_buf[0x11]   = color_0_blue;
+    usb_buf[0x12]   = color_1_red;
+    usb_buf[0x13]   = color_1_green;
+    usb_buf[0x14]   = color_1_blue;
+    usb_buf[0x15]   = color_2_red;
+    usb_buf[0x16]   = color_2_green;
+    usb_buf[0x17]   = color_2_blue;
+
+    /*-----------------------------------------------------*\
+    | Set up temperatures                                   |
+    \*-----------------------------------------------------*/
+    usb_buf[0x12]   = (temperature_0 >> 8);
+    usb_buf[0x13]   = (temperature_0 & 0xFF);
+    usb_buf[0x14]   = (temperature_1 >> 8);
+    usb_buf[0x15]   = (temperature_1 & 0xFF);
+    usb_buf[0x16]   = (temperature_2 >> 8);
+    usb_buf[0x17]   = (temperature_2 & 0xFF);
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    libusb_interrupt_transfer(dev, 0x02, usb_buf, 64, &actual, 0);
+}
+
+void CorsairCmdrProController::SendTemperature()
+{
+
+}
+
+void CorsairCmdrProController::SendReset
+    (
+    unsigned char   channel
+    )
+{
+    int             actual;
+    unsigned char   usb_buf[64];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up Reset packet                                   |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]   = CORSAIR_CMDR_PRO_PACKET_ID_RESET;
+    usb_buf[0x01]   = channel;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    libusb_interrupt_transfer(dev, 0x02, usb_buf, 64, &actual, 0);
+}
+
+void CorsairCmdrProController::SendPortState
+    (
+    unsigned char   channel,
+    unsigned char   state
+    )
+{
+    int             actual;
+    unsigned char   usb_buf[64];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up Port State packet                              |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]   = CORSAIR_CMDR_PRO_PACKET_ID_PORT_STATE;
+    usb_buf[0x01]   = channel;
+    usb_buf[0x02]   = state;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    libusb_interrupt_transfer(dev, 0x02, usb_buf, 64, &actual, 0);
+}
+
+void CorsairCmdrProController::SendBrightness()
+{
+
+}
+
+void CorsairCmdrProController::SendLEDCount()
+{
+
+}
+
+void CorsairCmdrProController::SendProtocol()
+{
+
+}

Controllers/CorsairCmdrProController/CorsairCmdrProController.h

@@ -0,0 +1,164 @@
+/*---------------------------------------------------------*\
+|  Definitions for Corsair Commander Pro                    |
+|                                                           |
+|  Adam Honse ([email protected]), 1/16/2020        |
+\*---------------------------------------------------------*/
+
+#include "RGBController.h"
+#include <vector>
+#include <libusb-1.0/libusb.h>
+
+#pragma once
+
+enum
+{
+    CORSAIR_CMDR_PRO_PACKET_ID_DIRECT           = 0x32,     /* Direct mode LED update packet        */
+    CORSAIR_CMDR_PRO_PACKET_ID_COMMIT           = 0x33,     /* Commit changes packet                */
+    CORSAIR_CMDR_PRO_PACKET_ID_BEGIN            = 0x34,     /* Begin effect packet                  */
+    CORSAIR_CMDR_PRO_PACKET_ID_EFFECT_CONFIG    = 0x35,     /* Effect mode configuration packet     */
+    CORSAIR_CMDR_PRO_PACKET_ID_TEMPERATURE      = 0x36,     /* Update temperature value packet      */
+    CORSAIR_CMDR_PRO_PACKET_ID_RESET            = 0x37,     /* Reset channel packet                 */
+    CORSAIR_CMDR_PRO_PACKET_ID_PORT_STATE       = 0x38,     /* Set port state packet                */
+    CORSAIR_CMDR_PRO_PACKET_ID_BRIGHTNESS       = 0x39,     /* Set brightness packet                */
+    CORSAIR_CMDR_PRO_PACKET_ID_LED_COUNT        = 0x3A,     /* Set LED count packet                 */
+    CORSAIR_CMDR_PRO_PACKET_ID_PROTOCOL         = 0x3B,     /* Set protocol packet                  */
+};
+
+enum
+{
+    CORSAIR_CMDR_PRO_DIRECT_CHANNEL_RED         = 0x00,     /* Red channel for direct update        */
+    CORSAIR_CMDR_PRO_DIRECT_CHANNEL_GREEN       = 0x01,     /* Green channel for direct update      */
+    CORSAIR_CMDR_PRO_DIRECT_CHANNEL_BLUE        = 0x02,     /* Blue channel for direct update       */
+};
+
+enum
+{
+    CORSAIR_CMDR_PRO_PORT_STATE_HARDWARE        = 0x01,     /* Effect hardware control of channel   */
+    CORSAIR_CMDR_PRO_PORT_STATE_SOFTWARE        = 0x02,     /* Direct software control of channel   */
+};
+
+enum
+{
+    CORSAIR_CMDR_PRO_LED_TYPE_LED_STRIP         = 0x0A,     /* Corsair LED Strip Type               */
+    CORSAIR_CMDR_PRO_LED_TYPE_HD_FAN            = 0x0C,     /* Corsair HD-series Fan Type           */
+    CORSAIR_CMDR_PRO_LED_TYPE_SP_FAN            = 0x01,     /* Corsair SP-series Fan Type           */
+    CORSAIR_CMDR_PRO_LED_TYPE_ML_FAN            = 0x02,     /* Corsair ML-series Fan Type           */
+};
+
+enum
+{
+    CORSAIR_CMDR_PRO_CHANNEL_1                  = 0x00,     /* Channel 1                            */
+    CORSAIR_CMDR_PRO_CHANNEL_2                  = 0x01,     /* Channel 2                            */
+    CORSAIR_CMDR_PRO_NUM_CHANNELS               = 0x02,     /* Number of channels                   */
+};
+
+enum
+{
+    CORSAIR_CMDR_PRO_SPEED_FAST                 = 0x00,     /* Fast speed                           */
+    CORSAIR_CMDR_PRO_SPEED_MEDIUM               = 0x01,     /* Medium speed                         */
+    CORSAIR_CMDR_PRO_SPEED_SLOW                 = 0x02,     /* Slow speed                           */
+};
+
+enum
+{
+    CORSAIR_CMDR_PRO_MODE_RAINBOW_WAVE          = 0x00,     /* Rainbow Wave mode                    */
+    CORSAIR_CMDR_PRO_MODE_COLOR_SHIFT           = 0x01,     /* Color Shift mode                     */
+    CORSAIR_CMDR_PRO_MODE_COLOR_PULSE           = 0x02,     /* Color Pulse mode                     */
+    CORSAIR_CMDR_PRO_MODE_COLOR_WAVE            = 0x03,     /* Color Wave mode                      */
+    CORSAIR_CMDR_PRO_MODE_STATIC                = 0x04,     /* Static mode                          */
+    CORSAIR_CMDR_PRO_MODE_TEMPERATURE           = 0x05,     /* Temperature mode                     */
+    CORSAIR_CMDR_PRO_MODE_VISOR                 = 0x06,     /* Visor mode                           */
+    CORSAIR_CMDR_PRO_MODE_MARQUEE               = 0x07,     /* Marquee mode                         */
+    CORSAIR_CMDR_PRO_MODE_BLINK                 = 0x08,     /* Blink mode                           */
+    CORSAIR_CMDR_PRO_MODE_SEQUENTIAL            = 0x09,     /* Sequential mode                      */
+    CORSAIR_CMDR_PRO_MODE_RAINBOW               = 0x0A,     /* Rainbow mode                         */
+};
+
+class CorsairCmdrProController
+{
+public:
+    CorsairCmdrProController(libusb_device_handle* dev_handle);
+    ~CorsairCmdrProController();
+    
+    char*           GetLEDString();
+    unsigned int    GetStripsOnChannel(unsigned int channel);
+
+    void            SetChannelEffect(unsigned char channel,
+                                     unsigned char mode,
+                                     unsigned char speed,
+                                     unsigned char direction,
+                                     bool          random,
+                                     unsigned char red1,
+                                     unsigned char grn1,
+                                     unsigned char blu1,
+                                     unsigned char red2,
+                                     unsigned char grn2,
+                                     unsigned char blu2
+                                    );
+
+    void            SetChannelLEDs(unsigned char channel, std::vector<RGBColor> colors);
+    unsigned int    channel_leds[CORSAIR_CMDR_PRO_NUM_CHANNELS];
+
+    void            KeepaliveThread();
+
+private:
+    libusb_device_handle*   dev;
+
+    void            SendDirect
+                        (
+                        unsigned char   channel,
+                        unsigned char   start,
+                        unsigned char   count,
+                        unsigned char   color_channel,
+                        unsigned char*  color_data
+                        );
+
+    void            SendCommit();
+
+    void            SendBegin
+                        (
+                        unsigned char   channel
+                        );
+
+    void            SendEffectConfig
+                        (
+                        unsigned char   channel,
+                        unsigned char   count,
+                        unsigned char   led_type,
+                        unsigned char   mode,
+                        unsigned char   speed,
+                        unsigned char   direction,
+                        unsigned char   change_style,
+                        unsigned char   color_0_red,
+                        unsigned char   color_0_green,
+                        unsigned char   color_0_blue,
+                        unsigned char   color_1_red,
+                        unsigned char   color_1_green,
+                        unsigned char   color_1_blue,
+                        unsigned char   color_2_red,
+                        unsigned char   color_2_green,
+                        unsigned char   color_2_blue,
+                        unsigned short  temperature_0,
+                        unsigned short  temperature_1,
+                        unsigned short  temperature_2
+                        );
+
+    void            SendTemperature();
+
+    void            SendReset
+                        (
+                        unsigned char   channel
+                        );
+
+    void            SendPortState
+                        (
+                        unsigned char   channel,
+                        unsigned char   state
+                        );
+
+    void            SendBrightness();
+
+    void            SendLEDCount();
+
+    void            SendProtocol();
+};

Controllers/CorsairCmdrProController/CorsairCmdrProControllerDetect.cpp

@@ -0,0 +1,37 @@
+#include "CorsairCmdrProController.h"
+#include "RGBController.h"
+#include "RGBController_CorsairCmdrPro.h"
+#include <vector>
+#include <libusb-1.0/libusb.h>
+
+#define CORSAIR_COMMANDER_PRO_VID 0x1B1C
+#define CORSAIR_COMMANDER_PRO_PID 0x0C10
+
+/******************************************************************************************\
+*                                                                                          *
+*   DetectCorsairCmdrProControllers                                                        *
+*                                                                                          *
+*       Detect devices supported by the Corsair Commander Pro driver                       *
+*                                                                                          *                                                                                          *
+\******************************************************************************************/
+
+void DetectCorsairCmdrProControllers(std::vector<RGBController*> &rgb_controllers)
+{
+    libusb_context * ctx;
+    libusb_init(&ctx);
+
+    //Look for Corsair Commander Pro
+    libusb_device_handle * dev = libusb_open_device_with_vid_pid(ctx, CORSAIR_COMMANDER_PRO_VID, CORSAIR_COMMANDER_PRO_PID);
+
+    if( dev )
+    {
+        libusb_detach_kernel_driver(dev, 0);
+        libusb_claim_interface(dev, 0);
+
+        CorsairCmdrProController* controller = new CorsairCmdrProController(dev);
+
+        RGBController_CorsairCmdrPro* rgb_controller = new RGBController_CorsairCmdrPro(controller);
+
+        rgb_controllers.push_back(rgb_controller);
+    }
+}   /* DetectCorsairCmdrProControllers() */

Controllers/CorsairController/CorsairController.cpp

@@ -24,17 +24,27 @@ CorsairController::~CorsairController()
 
 }
 
-char * CorsairController::GetDeviceName()
+std::string CorsairController::GetDeviceName()
 {
     return(device_name);
 }
 
+std::string CorsairController::GetDeviceLocation()
+{
+    std::string return_string(bus->device_name);
+    char addr[5];
+    snprintf(addr, 5, "0x%02X", dev);
+    return_string.append(", address ");
+    return_string.append(addr);
+    return(return_string);
+}
+
 unsigned int CorsairController::GetLEDCount()
 {
     return(led_count);
 }
 
-void CorsairController::SetAllColors(unsigned char red, unsigned char green, unsigned char blue)
+void CorsairController::SetLEDColor(unsigned char red, unsigned char green, unsigned char blue)
 {
     bus->i2c_smbus_write_byte_data(dev, CORSAIR_VENGEANCE_RGB_CMD_FADE_TIME, 0x00);
     bus->i2c_smbus_write_byte_data(dev, CORSAIR_VENGEANCE_RGB_CMD_RED_VAL, red);
@@ -43,16 +53,7 @@ void CorsairController::SetAllColors(unsigned char red, unsigned char green, uns
     bus->i2c_smbus_write_byte_data(dev, CORSAIR_VENGEANCE_RGB_CMD_MODE, CORSAIR_VENGEANCE_RGB_MODE_SINGLE);
 }
 
-void CorsairController::SetLEDColor(unsigned int led, unsigned char red, unsigned char green, unsigned char blue)
+void CorsairController::SetMode(unsigned char /*mode*/)
 {
-    bus->i2c_smbus_write_byte_data(dev, CORSAIR_VENGEANCE_RGB_CMD_FADE_TIME, 0x00);
-    bus->i2c_smbus_write_byte_data(dev, CORSAIR_VENGEANCE_RGB_CMD_RED_VAL, red);
-    bus->i2c_smbus_write_byte_data(dev, CORSAIR_VENGEANCE_RGB_CMD_GREEN_VAL, green);
-    bus->i2c_smbus_write_byte_data(dev, CORSAIR_VENGEANCE_RGB_CMD_BLUE_VAL, blue);
     bus->i2c_smbus_write_byte_data(dev, CORSAIR_VENGEANCE_RGB_CMD_MODE, CORSAIR_VENGEANCE_RGB_MODE_SINGLE);
 }
-
-void CorsairController::SetMode(unsigned char mode)
-{
-    bus->i2c_smbus_write_byte_data(dev, CORSAIR_VENGEANCE_RGB_CMD_MODE, CORSAIR_VENGEANCE_RGB_MODE_SINGLE);
-}

Controllers/CorsairController/CorsairController.h

@@ -7,6 +7,7 @@
 |  Adam Honse (CalcProgrammer1) 3/8/2019    |
 \*-----------------------------------------*/
 
+#include <string>
 #include "i2c_smbus.h"
 
 #pragma once
@@ -38,16 +39,16 @@ public:
     CorsairController(i2c_smbus_interface* bus, corsair_dev_id dev);
     ~CorsairController();
 
-    char*           GetDeviceName();
+    std::string     GetDeviceName();
+    std::string     GetDeviceLocation();
     unsigned int    GetLEDCount();
     void            SetMode(unsigned char mode);
 
-    void            SetAllColors(unsigned char red, unsigned char green, unsigned char blue);
-    void            SetLEDColor(unsigned int led, unsigned char red, unsigned char green, unsigned char blue);
+    void            SetLEDColor(unsigned char red, unsigned char green, unsigned char blue);
 
 private:
     char                    device_name[32];
     unsigned int            led_count;
     i2c_smbus_interface *   bus;
     corsair_dev_id          dev;
-};
+};

Controllers/CorsairNodeProController/CorsairNodeProController.cpp

@@ -0,0 +1,504 @@
+/*---------------------------------------------------------*\
+|  Processing Code for Corsair Lighting Node Pro            |
+|                                                           |
+|  Adam Honse ([email protected]), 1/12/2020        |
+\*---------------------------------------------------------*/
+
+#include "CorsairNodeProController.h"
+
+#include <fstream>
+#include <iostream>
+#include <string>
+#include <cstring>
+
+//Include thread libraries for Windows or Linux
+#ifdef WIN32
+#include <process.h>
+#else
+#include "pthread.h"
+#include "unistd.h"
+#endif
+
+//Thread functions have different types in Windows and Linux
+#ifdef WIN32
+#define THREAD static void
+#define THREADRETURN
+#else
+#define THREAD static void*
+#define THREADRETURN return(NULL);
+#endif
+
+#ifdef WIN32
+#include <Windows.h>
+#else
+#include <unistd.h>
+
+static void Sleep(unsigned int milliseconds)
+{
+    usleep(1000 * milliseconds);
+}
+#endif
+
+THREAD keepalive_thread(void *param)
+{
+    CorsairNodeProController* corsair = static_cast<CorsairNodeProController*>(param);
+    corsair->KeepaliveThread();
+    THREADRETURN
+}
+
+CorsairNodeProController::CorsairNodeProController(libusb_device_handle* dev_handle)
+{
+    dev = dev_handle;
+    channel_leds[0] = 60;
+    channel_leds[1] = 60;
+
+    /*-----------------------------------------------------*\
+    | The Corsair Lighting Node Pro requires a packet within|
+    | 20 seconds of sending the lighting change in order    |
+    | to not revert back into rainbow mode.  Start a thread |
+    | to continuously send a keepalive packet every 5s      |
+    \*-----------------------------------------------------*/
+#ifdef WIN32
+    _beginthread(keepalive_thread, 0, this);
+#else
+    pthread_t thread;
+    pthread_create(&thread, NULL, &keepalive_thread, this);
+#endif
+}
+
+CorsairNodeProController::~CorsairNodeProController()
+{
+}
+
+void CorsairNodeProController::KeepaliveThread()
+{
+    while(1)
+    {
+        SendCommit();
+        Sleep(5000);
+    }
+}
+
+void CorsairNodeProController::SetChannelEffect(unsigned char channel,
+                                                unsigned char mode,
+                                                unsigned char speed,
+                                                unsigned char direction,
+                                                bool          random,
+                                                unsigned char red1,
+                                                unsigned char grn1,
+                                                unsigned char blu1,
+                                                unsigned char red2,
+                                                unsigned char grn2,
+                                                unsigned char blu2
+                                               )
+{
+    /*-----------------------------------------------------*\
+    | Send Reset packet                                     |
+    \*-----------------------------------------------------*/
+    SendReset(channel);
+
+    /*-----------------------------------------------------*\
+    | Send Begin packet                                     |
+    \*-----------------------------------------------------*/
+    SendBegin(channel);
+
+    /*-----------------------------------------------------*\
+    | Set Port State packet                                 |
+    \*-----------------------------------------------------*/
+    SendPortState(channel, CORSAIR_CMDR_PRO_PORT_STATE_HARDWARE);
+
+    /*-----------------------------------------------------*\
+    | Set Effect Configuration packet                       |
+    \*-----------------------------------------------------*/
+    SendEffectConfig
+    (
+        channel,
+        0,
+        CORSAIR_CMDR_PRO_LED_TYPE_LED_STRIP,
+        mode,
+        speed,
+        direction,
+        random,
+        red1,
+        grn1,
+        blu1,
+        red2,
+        grn2,
+        blu2,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0
+    );
+
+    /*-----------------------------------------------------*\
+    | Send Commit packet                                    |
+    \*-----------------------------------------------------*/
+    SendCommit();
+}
+
+void CorsairNodeProController::SetChannelLEDs(unsigned char channel, std::vector<RGBColor> colors)
+{
+    unsigned char   color_data[50];
+    unsigned char   pkt_max;
+
+    /*-----------------------------------------------------*\
+    | Send Port State packet                                |
+    \*-----------------------------------------------------*/
+    SendPortState(channel, CORSAIR_CMDR_PRO_PORT_STATE_SOFTWARE);
+
+    /*-----------------------------------------------------*\
+    | Send red channel packet 1                             |
+    \*-----------------------------------------------------*/
+    pkt_max = 50;
+
+    if(pkt_max > colors.size())
+    {
+        pkt_max = (unsigned char)colors.size();
+    }
+
+    for(int idx = 0; idx < pkt_max; idx++)
+    {
+        color_data[idx] = RGBGetRValue(colors[idx]);
+    }
+
+    SendDirect(channel, 0, pkt_max, CORSAIR_CMDR_PRO_DIRECT_CHANNEL_RED, color_data);
+
+    /*-----------------------------------------------------*\
+    | Send red channel packet 2 if necessary                |
+    \*-----------------------------------------------------*/
+    pkt_max = 0;
+
+    if (colors.size() > 50)
+    {
+        pkt_max = (unsigned char)(colors.size() - 50);
+    }
+
+    if(pkt_max > 0)
+    {
+        for (std::size_t idx = 0; idx < pkt_max; idx++)
+        {
+            color_data[idx] = RGBGetRValue(colors[idx+50]);
+        }
+
+        SendDirect(channel, 50, pkt_max, CORSAIR_CMDR_PRO_DIRECT_CHANNEL_RED, color_data);
+    }
+
+    /*-----------------------------------------------------*\
+    | Send green channel packet 1                           |
+    \*-----------------------------------------------------*/
+    pkt_max = 50;
+
+    if(pkt_max > colors.size())
+    {
+        pkt_max = (unsigned char)colors.size();
+    }
+
+    for(int idx = 0; idx < pkt_max; idx++)
+    {
+        color_data[idx] = RGBGetGValue(colors[idx]);
+    }
+
+    SendDirect(channel, 0, pkt_max, CORSAIR_CMDR_PRO_DIRECT_CHANNEL_GREEN, color_data);
+
+    /*-----------------------------------------------------*\
+    | Send green channel packet 2 if necessary              |
+    \*-----------------------------------------------------*/
+    pkt_max = 0;
+
+    if (colors.size() > 50)
+    {
+        pkt_max = (unsigned char)(colors.size() - 50);
+    }
+
+    if(pkt_max > 0)
+    {
+        for (std::size_t idx = 0; idx < pkt_max; idx++)
+        {
+            color_data[idx] = RGBGetGValue(colors[idx+50]);
+        }
+
+        SendDirect(channel, 50, pkt_max, CORSAIR_CMDR_PRO_DIRECT_CHANNEL_GREEN, color_data);
+    }
+
+    /*-----------------------------------------------------*\
+    | Send blue channel packet 1                            |
+    \*-----------------------------------------------------*/
+    pkt_max = 50;
+
+    if(pkt_max > colors.size())
+    {
+        pkt_max = (unsigned char)colors.size();
+    }
+
+    for(int idx = 0; idx < pkt_max; idx++)
+    {
+        color_data[idx] = RGBGetBValue(colors[idx]);
+    }
+
+    SendDirect(channel, 0, pkt_max, CORSAIR_CMDR_PRO_DIRECT_CHANNEL_BLUE, color_data);
+
+    /*-----------------------------------------------------*\
+    | Send blue channel packet 2 if necessary               |
+    \*-----------------------------------------------------*/
+    pkt_max = 0;
+
+    if (colors.size() > 50)
+    {
+        pkt_max = (unsigned char)(colors.size() - 50);
+    }
+
+    if(pkt_max > 0)
+    {
+        for (std::size_t idx = 0; idx < pkt_max; idx++)
+        {
+            color_data[idx] = RGBGetBValue(colors[idx+50]);
+        }
+
+        SendDirect(channel, 50, pkt_max, CORSAIR_CMDR_PRO_DIRECT_CHANNEL_BLUE, color_data);
+    }
+
+    /*-----------------------------------------------------*\
+    | Send Commit packet                                    |
+    \*-----------------------------------------------------*/
+    SendCommit();
+}
+
+/*-------------------------------------------------------------------------------------------------*\
+| Private packet sending functions.                                                                 |
+\*-------------------------------------------------------------------------------------------------*/
+
+void CorsairNodeProController::SendDirect
+    (
+    unsigned char   channel,
+    unsigned char   start,
+    unsigned char   count,
+    unsigned char   color_channel,
+    unsigned char*  color_data
+    )
+{
+    int             actual;
+    unsigned char   usb_buf[64];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up Direct packet                                  |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]   = CORSAIR_CMDR_PRO_PACKET_ID_DIRECT;
+    usb_buf[0x01]   = channel;
+    usb_buf[0x02]   = start;
+    usb_buf[0x03]   = count;
+    usb_buf[0x04]   = color_channel;
+
+    /*-----------------------------------------------------*\
+    | Copy in color data bytes                              |
+    \*-----------------------------------------------------*/
+    memcpy(&usb_buf[0x05], color_data, count);
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    libusb_interrupt_transfer(dev, 0x01, usb_buf, 64, &actual, 0);
+}
+
+void CorsairNodeProController::SendCommit()
+{
+    int             actual;
+    unsigned char   usb_buf[64];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up Commit packet                                  |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]   = CORSAIR_CMDR_PRO_PACKET_ID_COMMIT;
+    usb_buf[0x01]   = 0xFF;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    libusb_interrupt_transfer(dev, 0x01, usb_buf, 64, &actual, 0);
+}
+
+void CorsairNodeProController::SendBegin
+    (
+    unsigned char   channel
+    )
+{
+    int             actual;
+    unsigned char   usb_buf[64];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up Begin packet                                   |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]   = CORSAIR_CMDR_PRO_PACKET_ID_BEGIN;
+    usb_buf[0x01]   = channel;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    libusb_interrupt_transfer(dev, 0x01, usb_buf, 64, &actual, 0);
+}
+
+void CorsairNodeProController::SendEffectConfig
+    (
+    unsigned char   channel,
+    unsigned char   count,
+    unsigned char   led_type,
+    unsigned char   mode,
+    unsigned char   speed,
+    unsigned char   direction,
+    unsigned char   change_style,
+    unsigned char   color_0_red,
+    unsigned char   color_0_green,
+    unsigned char   color_0_blue,
+    unsigned char   color_1_red,
+    unsigned char   color_1_green,
+    unsigned char   color_1_blue,
+    unsigned char   color_2_red,
+    unsigned char   color_2_green,
+    unsigned char   color_2_blue,
+    unsigned short  temperature_0,
+    unsigned short  temperature_1,
+    unsigned short  temperature_2
+    )
+{
+    int             actual;
+    unsigned char   usb_buf[64];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up Effect Config packet                           |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]   = CORSAIR_CMDR_PRO_PACKET_ID_EFFECT_CONFIG;
+    usb_buf[0x01]   = channel;
+    usb_buf[0x02]   = count * 10;
+    usb_buf[0x03]   = led_type;
+
+    /*-----------------------------------------------------*\
+    | Set up mode parameters                                |
+    \*-----------------------------------------------------*/
+    usb_buf[0x04]   = mode;
+    usb_buf[0x05]   = speed;
+    usb_buf[0x06]   = direction;
+    usb_buf[0x07]   = change_style;
+    usb_buf[0x08]   = 0;
+
+    /*-----------------------------------------------------*\
+    | Set up mode colors                                    |
+    \*-----------------------------------------------------*/
+    usb_buf[0x09]   = color_0_red;
+    usb_buf[0x10]   = color_0_green;
+    usb_buf[0x11]   = color_0_blue;
+    usb_buf[0x12]   = color_1_red;
+    usb_buf[0x13]   = color_1_green;
+    usb_buf[0x14]   = color_1_blue;
+    usb_buf[0x15]   = color_2_red;
+    usb_buf[0x16]   = color_2_green;
+    usb_buf[0x17]   = color_2_blue;
+
+    /*-----------------------------------------------------*\
+    | Set up temperatures                                   |
+    \*-----------------------------------------------------*/
+    usb_buf[0x12]   = (temperature_0 >> 8);
+    usb_buf[0x13]   = (temperature_0 & 0xFF);
+    usb_buf[0x14]   = (temperature_1 >> 8);
+    usb_buf[0x15]   = (temperature_1 & 0xFF);
+    usb_buf[0x16]   = (temperature_2 >> 8);
+    usb_buf[0x17]   = (temperature_2 & 0xFF);
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    libusb_interrupt_transfer(dev, 0x01, usb_buf, 64, &actual, 0);
+}
+
+void CorsairNodeProController::SendTemperature()
+{
+
+}
+
+void CorsairNodeProController::SendReset
+    (
+    unsigned char   channel
+    )
+{
+    int             actual;
+    unsigned char   usb_buf[64];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up Reset packet                                   |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]   = CORSAIR_CMDR_PRO_PACKET_ID_RESET;
+    usb_buf[0x01]   = channel;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    libusb_interrupt_transfer(dev, 0x01, usb_buf, 64, &actual, 0);
+}
+
+void CorsairNodeProController::SendPortState
+    (
+    unsigned char   channel,
+    unsigned char   state
+    )
+{
+    int             actual;
+    unsigned char   usb_buf[64];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up Port State packet                              |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]   = CORSAIR_CMDR_PRO_PACKET_ID_PORT_STATE;
+    usb_buf[0x01]   = channel;
+    usb_buf[0x02]   = state;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    libusb_interrupt_transfer(dev, 0x01, usb_buf, 64, &actual, 0);
+}
+
+void CorsairNodeProController::SendBrightness()
+{
+
+}
+
+void CorsairNodeProController::SendLEDCount()
+{
+
+}
+
+void CorsairNodeProController::SendProtocol()
+{
+
+}

Controllers/CorsairNodeProController/CorsairNodeProController.h

@@ -0,0 +1,171 @@
+/*---------------------------------------------------------*\
+|  Definitions for Corsair Lighting Node Pro                |
+|                                                           |
+|  Adam Honse ([email protected]), 1/12/2020        |
+\*---------------------------------------------------------*/
+
+#include "RGBController.h"
+#include <vector>
+#include <libusb-1.0/libusb.h>
+
+#pragma once
+
+enum
+{
+    CORSAIR_CMDR_PRO_PACKET_ID_DIRECT           = 0x32,     /* Direct mode LED update packet        */
+    CORSAIR_CMDR_PRO_PACKET_ID_COMMIT           = 0x33,     /* Commit changes packet                */
+    CORSAIR_CMDR_PRO_PACKET_ID_BEGIN            = 0x34,     /* Begin effect packet                  */
+    CORSAIR_CMDR_PRO_PACKET_ID_EFFECT_CONFIG    = 0x35,     /* Effect mode configuration packet     */
+    CORSAIR_CMDR_PRO_PACKET_ID_TEMPERATURE      = 0x36,     /* Update temperature value packet      */
+    CORSAIR_CMDR_PRO_PACKET_ID_RESET            = 0x37,     /* Reset channel packet                 */
+    CORSAIR_CMDR_PRO_PACKET_ID_PORT_STATE       = 0x38,     /* Set port state packet                */
+    CORSAIR_CMDR_PRO_PACKET_ID_BRIGHTNESS       = 0x39,     /* Set brightness packet                */
+    CORSAIR_CMDR_PRO_PACKET_ID_LED_COUNT        = 0x3A,     /* Set LED count packet                 */
+    CORSAIR_CMDR_PRO_PACKET_ID_PROTOCOL         = 0x3B,     /* Set protocol packet                  */
+};
+
+enum
+{
+    CORSAIR_CMDR_PRO_DIRECT_CHANNEL_RED         = 0x00,     /* Red channel for direct update        */
+    CORSAIR_CMDR_PRO_DIRECT_CHANNEL_GREEN       = 0x01,     /* Green channel for direct update      */
+    CORSAIR_CMDR_PRO_DIRECT_CHANNEL_BLUE        = 0x02,     /* Blue channel for direct update       */
+};
+
+enum
+{
+    CORSAIR_CMDR_PRO_PORT_STATE_HARDWARE        = 0x01,     /* Effect hardware control of channel   */
+    CORSAIR_CMDR_PRO_PORT_STATE_SOFTWARE        = 0x02,     /* Direct software control of channel   */
+};
+
+enum
+{
+    CORSAIR_CMDR_PRO_LED_TYPE_LED_STRIP         = 0x0A,     /* Corsair LED Strip Type               */
+    CORSAIR_CMDR_PRO_LED_TYPE_HD_FAN            = 0x0C,     /* Corsair HD-series Fan Type           */
+    CORSAIR_CMDR_PRO_LED_TYPE_SP_FAN            = 0x01,     /* Corsair SP-series Fan Type           */
+    CORSAIR_CMDR_PRO_LED_TYPE_ML_FAN            = 0x02,     /* Corsair ML-series Fan Type           */
+};
+
+enum
+{
+    CORSAIR_CMDR_PRO_CHANNEL_1                  = 0x00,     /* Channel 1                            */
+    CORSAIR_CMDR_PRO_CHANNEL_2                  = 0x01,     /* Channel 2                            */
+    CORSAIR_CMDR_PRO_NUM_CHANNELS               = 0x02,     /* Number of channels                   */
+};
+
+enum
+{
+    CORSAIR_CMDR_PRO_SPEED_FAST                 = 0x00,     /* Fast speed                           */
+    CORSAIR_CMDR_PRO_SPEED_MEDIUM               = 0x01,     /* Medium speed                         */
+    CORSAIR_CMDR_PRO_SPEED_SLOW                 = 0x02,     /* Slow speed                           */
+};
+
+enum
+{
+    CORSAIR_CMDR_PRO_MODE_RAINBOW_WAVE          = 0x00,     /* Rainbow Wave mode                    */
+    CORSAIR_CMDR_PRO_MODE_COLOR_SHIFT           = 0x01,     /* Color Shift mode                     */
+    CORSAIR_CMDR_PRO_MODE_COLOR_PULSE           = 0x02,     /* Color Pulse mode                     */
+    CORSAIR_CMDR_PRO_MODE_COLOR_WAVE            = 0x03,     /* Color Wave mode                      */
+    CORSAIR_CMDR_PRO_MODE_STATIC                = 0x04,     /* Static mode                          */
+    CORSAIR_CMDR_PRO_MODE_TEMPERATURE           = 0x05,     /* Temperature mode                     */
+    CORSAIR_CMDR_PRO_MODE_VISOR                 = 0x06,     /* Visor mode                           */
+    CORSAIR_CMDR_PRO_MODE_MARQUEE               = 0x07,     /* Marquee mode                         */
+    CORSAIR_CMDR_PRO_MODE_BLINK                 = 0x08,     /* Blink mode                           */
+    CORSAIR_CMDR_PRO_MODE_SEQUENTIAL            = 0x09,     /* Sequential mode                      */
+    CORSAIR_CMDR_PRO_MODE_RAINBOW               = 0x0A,     /* Rainbow mode                         */
+};
+
+enum
+{
+    CORSAIR_NODE_PRO_CHANNEL_1      = 0x00,     /* Channel 1                    */
+    CORSAIR_NODE_PRO_CHANNEL_2      = 0x01,     /* Channel 2                    */
+    CORSAIR_NODE_PRO_NUM_CHANNELS   = 0x02      /* Number of channels           */
+};
+
+class CorsairNodeProController
+{
+public:
+    CorsairNodeProController(libusb_device_handle* dev_handle);
+    ~CorsairNodeProController();
+    
+    char*           GetLEDString();
+    unsigned int    GetStripsOnChannel(unsigned int channel);
+
+    void            SetChannelEffect(unsigned char channel,
+                                     unsigned char mode,
+                                     unsigned char speed,
+                                     unsigned char direction,
+                                     bool          random,
+                                     unsigned char red1,
+                                     unsigned char grn1,
+                                     unsigned char blu1,
+                                     unsigned char red2,
+                                     unsigned char grn2,
+                                     unsigned char blu2
+                                    );
+
+    void            SetChannelLEDs(unsigned char channel, std::vector<RGBColor> colors);
+    unsigned int    channel_leds[CORSAIR_NODE_PRO_NUM_CHANNELS];
+
+    void            KeepaliveThread();
+
+private:
+    libusb_device_handle*   dev;
+
+    void            SendDirect
+                        (
+                        unsigned char   channel,
+                        unsigned char   start,
+                        unsigned char   count,
+                        unsigned char   color_channel,
+                        unsigned char*  color_data
+                        );
+
+    void            SendCommit();
+
+    void            SendBegin
+                        (
+                        unsigned char   channel
+                        );
+
+    void            SendEffectConfig
+                        (
+                        unsigned char   channel,
+                        unsigned char   count,
+                        unsigned char   led_type,
+                        unsigned char   mode,
+                        unsigned char   speed,
+                        unsigned char   direction,
+                        unsigned char   change_style,
+                        unsigned char   color_0_red,
+                        unsigned char   color_0_green,
+                        unsigned char   color_0_blue,
+                        unsigned char   color_1_red,
+                        unsigned char   color_1_green,
+                        unsigned char   color_1_blue,
+                        unsigned char   color_2_red,
+                        unsigned char   color_2_green,
+                        unsigned char   color_2_blue,
+                        unsigned short  temperature_0,
+                        unsigned short  temperature_1,
+                        unsigned short  temperature_2
+                        );
+
+    void            SendTemperature();
+
+    void            SendReset
+                        (
+                        unsigned char   channel
+                        );
+
+    void            SendPortState
+                        (
+                        unsigned char   channel,
+                        unsigned char   state
+                        );
+
+    void            SendBrightness();
+
+    void            SendLEDCount();
+
+    void            SendProtocol();
+};

Controllers/CorsairNodeProController/CorsairNodeProControllerDetect.cpp

@@ -0,0 +1,37 @@
+#include "CorsairNodeProController.h"
+#include "RGBController.h"
+#include "RGBController_CorsairNodePro.h"
+#include <vector>
+#include <libusb-1.0/libusb.h>
+
+#define CORSAIR_LIGHTING_NODE_PRO_VID 0x1B1C
+#define CORSAIR_LIGHTING_NODE_PRO_PID 0x0C0B
+
+/******************************************************************************************\
+*                                                                                          *
+*   DetectCorsairNodeProControllers                                                        *
+*                                                                                          *
+*       Detect devices supported by the Corsair Lighting Node Pro driver                   *
+*                                                                                          *                                                                                          *
+\******************************************************************************************/
+
+void DetectCorsairNodeProControllers(std::vector<RGBController*> &rgb_controllers)
+{
+    libusb_context * ctx;
+    libusb_init(&ctx);
+
+    //Look for Corsair Lighting Node Pro
+    libusb_device_handle * dev = libusb_open_device_with_vid_pid(ctx, CORSAIR_LIGHTING_NODE_PRO_VID, CORSAIR_LIGHTING_NODE_PRO_PID);
+
+    if( dev )
+    {
+        libusb_detach_kernel_driver(dev, 0);
+        libusb_claim_interface(dev, 0);
+
+        CorsairNodeProController* controller = new CorsairNodeProController(dev);
+
+        RGBController_CorsairNodePro* rgb_controller = new RGBController_CorsairNodePro(controller);
+
+        rgb_controllers.push_back(rgb_controller);
+    }
+}   /* DetectCorsairNodeProControllers() */

Controllers/CorsairProController/CorsairProController.cpp

@@ -15,7 +15,7 @@
 #else
 #include <unistd.h>
 
-void Sleep(unsigned int milliseconds)
+static void Sleep(unsigned int milliseconds)
 {
     usleep(1000 * milliseconds);
 }
@@ -29,7 +29,9 @@ CorsairProController::CorsairProController(i2c_smbus_interface* bus, corsair_dev
     strcpy(device_name, "Corsair Vengeance Pro RGB");
     led_count = CORSAIR_PRO_LED_COUNT;
 
-    for (int i = 0; i < led_count; i++)
+    effect_mode = CORSAIR_PRO_MODE_STATIC;
+    
+    for (unsigned int i = 0; i < led_count; i++)
     {
         led_red[i]      = 0;
         led_green[i]    = 0;
@@ -42,19 +44,34 @@ CorsairProController::~CorsairProController()
 
 }
 
-char* CorsairProController::GetDeviceName()
+std::string CorsairProController::GetDeviceName()
 {
     return(device_name);
 }
 
+std::string CorsairProController::GetDeviceLocation()
+{
+    std::string return_string(bus->device_name);
+    char addr[5];
+    snprintf(addr, 5, "0x%02X", dev);
+    return_string.append(", address ");
+    return_string.append(addr);
+    return(return_string);
+}
+
 unsigned int CorsairProController::GetLEDCount()
 {
     return(led_count);
 }
 
+unsigned char CorsairProController::GetEffect()
+{
+    return(effect_mode);
+}
+
 void CorsairProController::SetAllColors(unsigned char red, unsigned char green, unsigned char blue)
 {
-    for (int i = 0; i < led_count; i++)
+    for (unsigned int i = 0; i < led_count; i++)
     {
         led_red[i]      = red;
         led_green[i]    = green;
@@ -87,24 +104,47 @@ void CorsairProController::ApplyColors()
     bus->i2c_smbus_write_byte_data(dev, 0x82, 0x02);
 }
 
-void CorsairProController::SetEffect(unsigned char mode)
+void CorsairProController::SetEffect(unsigned char mode,
+                                     unsigned char speed,
+                                     unsigned char direction,
+                                     bool          random,
+                                     unsigned char red1,
+                                     unsigned char grn1,
+                                     unsigned char blu1,
+                                     unsigned char red2,
+                                     unsigned char grn2,
+                                     unsigned char blu2
+                                    )
 {
+    effect_mode = mode;
+
     bus->i2c_smbus_write_byte_data(dev, 0x26, 0x01);
     Sleep(1);
     bus->i2c_smbus_write_byte_data(dev, 0x21, 0x00);
     Sleep(1);
 
-    bus->i2c_smbus_write_byte_data(dev, CORSAIR_PRO_REG_COMMAND, mode); //Mode
-    bus->i2c_smbus_write_byte_data(dev, CORSAIR_PRO_REG_COMMAND, CORSAIR_PRO_SPEED_MEDIUM); //Speed
-    bus->i2c_smbus_write_byte_data(dev, CORSAIR_PRO_REG_COMMAND, CORSAIR_PRO_EFFECT_RANDOM_COLORS); //Custom color
-    bus->i2c_smbus_write_byte_data(dev, CORSAIR_PRO_REG_COMMAND, CORSAIR_PRO_DIRECTION_UP); //Direction
-    bus->i2c_smbus_write_byte_data(dev, CORSAIR_PRO_REG_COMMAND, 0x00); // Custom color 1 red
-    bus->i2c_smbus_write_byte_data(dev, CORSAIR_PRO_REG_COMMAND, 0x00); // Custom color 1 green
-    bus->i2c_smbus_write_byte_data(dev, CORSAIR_PRO_REG_COMMAND, 0x00); // Custom color 1 blue
+    unsigned char random_byte;
+
+    if(random)
+    {
+        random_byte = CORSAIR_PRO_EFFECT_RANDOM_COLORS;
+    }
+    else
+    {
+        random_byte = CORSAIR_PRO_EFFECT_CUSTOM_COLORS;
+    }
+
+    bus->i2c_smbus_write_byte_data(dev, CORSAIR_PRO_REG_COMMAND, effect_mode);  //Mode
+    bus->i2c_smbus_write_byte_data(dev, CORSAIR_PRO_REG_COMMAND, speed);        //Speed
+    bus->i2c_smbus_write_byte_data(dev, CORSAIR_PRO_REG_COMMAND, random_byte);  //Custom color
+    bus->i2c_smbus_write_byte_data(dev, CORSAIR_PRO_REG_COMMAND, direction);    //Direction
+    bus->i2c_smbus_write_byte_data(dev, CORSAIR_PRO_REG_COMMAND, red1);         // Custom color 1 red
+    bus->i2c_smbus_write_byte_data(dev, CORSAIR_PRO_REG_COMMAND, grn1);         // Custom color 1 green
+    bus->i2c_smbus_write_byte_data(dev, CORSAIR_PRO_REG_COMMAND, blu1);         // Custom color 1 blue
     bus->i2c_smbus_write_byte_data(dev, CORSAIR_PRO_REG_COMMAND, 0xFF);
-    bus->i2c_smbus_write_byte_data(dev, CORSAIR_PRO_REG_COMMAND, 0x00); // Custom color 2 red
-    bus->i2c_smbus_write_byte_data(dev, CORSAIR_PRO_REG_COMMAND, 0x00); // Custom color 2 green
-    bus->i2c_smbus_write_byte_data(dev, CORSAIR_PRO_REG_COMMAND, 0x00); // Custom color 2 blue
+    bus->i2c_smbus_write_byte_data(dev, CORSAIR_PRO_REG_COMMAND, red2);         // Custom color 2 red
+    bus->i2c_smbus_write_byte_data(dev, CORSAIR_PRO_REG_COMMAND, grn2);         // Custom color 2 green
+    bus->i2c_smbus_write_byte_data(dev, CORSAIR_PRO_REG_COMMAND, blu2);         // Custom color 2 blue
     bus->i2c_smbus_write_byte_data(dev, CORSAIR_PRO_REG_COMMAND, 0xFF);
     bus->i2c_smbus_write_byte_data(dev, CORSAIR_PRO_REG_COMMAND, 0x00);
     bus->i2c_smbus_write_byte_data(dev, CORSAIR_PRO_REG_COMMAND, 0x00);
@@ -119,11 +159,6 @@ void CorsairProController::SetEffect(unsigned char mode)
     WaitReady();
 }
 
-void CorsairProController::SetCustom()
-{
-    SetEffect(CORSAIR_PRO_MODE_STATIC);
-}
-
 bool CorsairProController::WaitReady()
 {
     int i = 0;
@@ -134,4 +169,4 @@ bool CorsairProController::WaitReady()
     }
 
     return false;
-}
+}

Controllers/CorsairProController/CorsairProController.h

@@ -7,6 +7,7 @@
 |  Adam Honse (CalcProgrammer1) 6/30/2019   |
 \*-----------------------------------------*/
 
+#include <string>
 #include "i2c_smbus.h"
 
 #pragma once
@@ -65,10 +66,21 @@ public:
     CorsairProController(i2c_smbus_interface* bus, corsair_dev_id dev);
     ~CorsairProController();
 
-    char*           GetDeviceName();
+    std::string     GetDeviceName();
+    std::string     GetDeviceLocation();
     unsigned int    GetLEDCount();
-    void            SetEffect(unsigned char mode);
-    void            SetCustom();
+    unsigned char   GetEffect();
+    void            SetEffect(unsigned char mode,
+                              unsigned char speed,
+                              unsigned char direction,
+                              bool          random,
+                              unsigned char red1,
+                              unsigned char grn1,
+                              unsigned char blu1,
+                              unsigned char red2,
+                              unsigned char grn2,
+                              unsigned char blu2
+                             );
 
     void            SetAllColors(unsigned char red, unsigned char green, unsigned char blue);
     void            SetLEDColor(unsigned int led, unsigned char red, unsigned char green, unsigned char blue);
@@ -78,11 +90,11 @@ public:
 private:
     char                    device_name[32];
     unsigned int            led_count;
-
+    unsigned char           effect_mode;
     unsigned char           led_red[CORSAIR_PRO_LED_COUNT];
     unsigned char           led_green[CORSAIR_PRO_LED_COUNT];
     unsigned char           led_blue[CORSAIR_PRO_LED_COUNT];
 
     i2c_smbus_interface*    bus;
     corsair_dev_id          dev;
-};
+};

Controllers/CorsairProController/CorsairProControllerDetect.cpp

@@ -6,6 +6,17 @@
 #include <stdio.h>
 #include <stdlib.h>
 
+#ifdef WIN32
+#include <Windows.h>
+#else
+#include <unistd.h>
+
+static void Sleep(unsigned int milliseconds)
+{
+    usleep(1000 * milliseconds);
+}
+#endif
+
 /******************************************************************************************\
 *                                                                                          *
 *   TestForCorsairProController                                                            *
@@ -24,20 +35,6 @@ bool TestForCorsairProController(i2c_smbus_interface* bus, unsigned char address
     {
         pass = true;
 
-        res = bus->i2c_smbus_read_byte_data(address, 0x24);
-
-        if (res != 0x02)
-        {
-            pass = false;
-        }
-
-        res = bus->i2c_smbus_read_byte_data(address, 0x25);
-
-        if (res != 0x02)
-        {
-            pass = false;
-        }
-
         res = bus->i2c_smbus_read_byte_data(address, 0x43);
 
         if (res != 0x1C)
@@ -53,6 +50,8 @@ bool TestForCorsairProController(i2c_smbus_interface* bus, unsigned char address
         }
     }
 
+    Sleep(10);
+    
     return(pass);
 
 }   /* TestForCorsairProController() */

Controllers/Hue2Controller/Hue2Controller.cpp

@@ -0,0 +1,157 @@
+/*---------------------------------------------------------*\
+|  Processing Code for NZXT Hue 2                           |
+|                                                           |
+|  Adam Honse ([email protected]), 12/29/2016       |
+\*---------------------------------------------------------*/
+
+#include "Hue2Controller.h"
+
+#include <fstream>
+#include <iostream>
+#include <string>
+
+Hue2Controller::Hue2Controller(libusb_device_handle* dev_handle)
+{
+    dev = dev_handle;
+
+    GetStripsOnChannel(HUE_2_CHANNEL_1);
+}
+
+Hue2Controller::~Hue2Controller()
+{
+    current_mode        = HUE_2_MODE_FIXED;
+    current_speed       = HUE_2_SPEED_NORMAL;
+    current_direction   = false;
+}
+
+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 0x01: //Hue 1 strip
+                num_leds_on_channel += 10;
+                break;
+
+            case 0x02: //Aer 1 fan
+                num_leds_on_channel += 8;
+                break;
+
+            case 0x04: //Hue 2 strip
+                num_leds_on_channel += 10;
+                break;
+            
+            case 0x0B: //Aer 2 fan
+                num_leds_on_channel += 8;
+                break;
+
+            default:
+                break;
+            }
+        }
+        channel_leds[chan] = num_leds_on_channel;
+    }
+    return(ret_val);
+}
+
+void Hue2Controller::SetMode(unsigned char mode, unsigned char speed, bool direction)
+{
+    current_mode        = mode;
+    current_speed       = speed;
+    current_direction   = direction;
+}
+
+void Hue2Controller::SetChannelLEDs(unsigned char channel, std::vector<RGBColor> colors)
+{
+    unsigned char usb_buf[] =
+    {
+        0x28, 0x03, 0x00, 0x28,
+        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;
+
+    /*-----------------------------------------------------*\
+    | Set channel in USB packet                             |
+    \*-----------------------------------------------------*/
+    usb_buf[0x02]   = 1 << channel;
+
+    /*-----------------------------------------------------*\
+    | Set mode in USB packet                                |
+    \*-----------------------------------------------------*/
+    usb_buf[0x04]   = current_mode;
+
+    /*-----------------------------------------------------*\
+    | Set speed in USB packet                               |
+    \*-----------------------------------------------------*/
+    usb_buf[0x05]   = current_speed;
+
+    /*-----------------------------------------------------*\
+    | Set direction in USB packet                           |
+    \*-----------------------------------------------------*/
+    usb_buf[0x06]   = current_direction ? 0x01 : 0x00;
+    
+    /*-----------------------------------------------------*\
+    | Set color count in USB packet                         |
+    \*-----------------------------------------------------*/
+    usb_buf[0x08]   = colors.size();
+
+    /*-----------------------------------------------------*\
+    | Fill in color data                                    |
+    \*-----------------------------------------------------*/
+    for (std::size_t idx = 0; idx < colors.size(); idx++)
+    {
+        int pixel_idx = idx * 3;
+        RGBColor color = colors[idx];
+        usb_buf[pixel_idx + 0x0A] = RGBGetGValue(color);
+        usb_buf[pixel_idx + 0x0B] = RGBGetRValue(color);
+        usb_buf[pixel_idx + 0x0C] = RGBGetBValue(color);
+    }
+
+    libusb_interrupt_transfer(dev, 0x01, usb_buf, 64, &actual, 0);
+    libusb_interrupt_transfer(dev, 0x81, usb_buf, 64, &actual, 0);
+}

Controllers/Hue2Controller/Hue2Controller.h

@@ -0,0 +1,72 @@
+/*---------------------------------------------------------*\
+|  Definitions for NZXT Hue 2                               |
+|                                                           |
+|  Adam Honse ([email protected]), 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_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            */
+    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 char channel, std::vector<RGBColor> colors);
+    void            SetMode(unsigned char mode, unsigned char speed, bool direction);
+    
+    unsigned int    channel_leds[HUE_2_NUM_CHANNELS];
+
+private:
+    libusb_device_handle*   dev;
+
+    unsigned char   current_mode;
+    unsigned char   current_speed;
+    bool            current_direction;
+};

Controllers/Hue2Controller/Hue2ControllerDetect.cpp

@@ -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() */

Controllers/HuePlusController/HuePlusController.cpp

@@ -10,127 +10,161 @@
 #include <iostream>
 #include <string>
 
+
+#ifdef WIN32
+#include <Windows.h>
+#else
+#include <unistd.h>
+
+static void Sleep(unsigned int milliseconds)
+{
+    usleep(1000 * milliseconds);
+}
+#endif
+
 HuePlusController::HuePlusController()
 {
-
+    current_mode        = HUE_PLUS_MODE_FIXED;
+    current_speed       = HUE_PLUS_SPEED_NORMAL;
+    current_direction   = false;
 }
 
-
 HuePlusController::~HuePlusController()
 {
 }
 
-void HuePlusController::Initialize(char* ledstring)
+void HuePlusController::Initialize(char* port)
 {
-    strcpy(led_string, ledstring);
+    strcpy(port_name, port);
+    
+    serialport = new serial_port(port_name, HUE_PLUS_BAUD);
 
-    LPSTR   source = NULL;
-    LPSTR   channels = NULL;
-    LPSTR   numleds = NULL;
-    LPSTR   next = NULL;
-
-    source = strtok_s(ledstring, ",", &next);
-
-    //Check for selected channel 0=both, 1= Ch.1, 2= Ch.2
-    if (strlen(next))
-    {
-        channels = strtok_s(next, ",", &next);
-    }
-
-    switch (atoi(channels))
-    {
-        case 0:
-            channel = 0x00;
-            break;
-
-        case 1:
-            channel = 0x01;
-            break;
-
-        case 2:
-            channel = 0x02;
-            break;
-    }
-
-    //Check for the number of LEDs, sets the corresponding variable with the counter for the fans
-    if (strlen(next))
-    {
-        numleds = strtok_s(next, ",", &next);
-    }
-
-    switch (atoi(numleds) / 8)
-    {
-        case 1:
-            fans = 0x00;
-            break;
-
-        case 2:
-            fans = 0x01;
-            break;
-
-        case 3:
-            fans = 0x02;
-            break;
-
-        case 4:
-            fans = 0x03;
-            break;
-
-        case 5:
-            fans = 0x04;
-            break;
-    }
-
-    //Initialize with default baud rate
-    source = strtok(source, "\r");
-    strcpy(port_name, source);
-    baud_rate = 256000;
-    serialport = new serial_port(port_name, baud_rate);
-
-    if (numleds != NULL && strlen(numleds))
-    {
-        num_leds = atoi(numleds);
-    }
+    channel_leds[HUE_PLUS_CHANNEL_1_IDX] = GetLEDsOnChannel(HUE_PLUS_CHANNEL_1);
+    channel_leds[HUE_PLUS_CHANNEL_2_IDX] = GetLEDsOnChannel(HUE_PLUS_CHANNEL_2);
 }
 
-char* HuePlusController::GetLEDString()
+char* HuePlusController::GetLocation()
 {
-    return(led_string);
+    return(port_name);
 }
 
-void HuePlusController::SetLEDs(std::vector<RGBColor> colors)
+unsigned int HuePlusController::GetLEDsOnChannel(unsigned int channel)
 {
-    if (serialport != NULL)
+    unsigned char serial_buf[] =
     {
-        unsigned char *serial_buf;
+        0x8D, 0x00, 0x00, 0x00, 0x00
+    };
 
-        serial_buf = new unsigned char[hueSize];    //Size of Message always 5 XX Blocks (Mode Selection) +  3 XX for each LED (1 color) 
-                                                    //-> max of 40 LEDs per Channel (or 5 Fans a 8 LEDs) -> 125 Blocks (empty LEDs are written, too
-        serial_buf[0] = 0x4b;
-        serial_buf[1] = channel;
-        serial_buf[2] = 0x0e;				
-        serial_buf[3] = fans; 
-        serial_buf[4] = 0x00;
+    unsigned int ret_val = 0;
 
-        for (int i = 5; i < hueSize; i++)
+    /*-----------------------------------------------------*\
+    | Set channel in serial packet                          |
+    \*-----------------------------------------------------*/
+    serial_buf[0x01]   = channel;
+
+    serialport->serial_flush_rx();
+    serialport->serial_write((char *)serial_buf, 2);
+    serialport->serial_flush_tx();
+
+    Sleep(50);
+
+    int bytes_read = serialport->serial_read((char *)serial_buf, 5);
+
+    if(bytes_read == 5)
+    {
+        if(serial_buf[3] == 0x01)
         {
-            //clearing the buf otherwise sometimes strange things are written to the COM Port
-            serial_buf[i] = 0x00;
+            ret_val = serial_buf[4] * 8;
         }
-
-        for (int idx = 0; idx < (num_leds * 3); idx += 3)
+        else
         {
-            int pixel_idx = idx / 3;
-            RGBColor color = colors[pixel_idx];
-            serial_buf[idx + 5] = RGBGetGValue(color);
-            serial_buf[idx + 6] = RGBGetRValue(color);
-            serial_buf[idx + 7] = RGBGetBValue(color);
+            ret_val += serial_buf[4] * 10;
         }
-
-        serialport->serial_write((char *)serial_buf, hueSize);
-        serialport->serial_flush_tx();
-
-        delete[] serial_buf;
     }
 
+    return(ret_val);
+}
+
+void HuePlusController::SetMode(unsigned char mode, unsigned char speed, bool direction)
+{
+    current_mode        = mode;
+    current_speed       = speed;
+    current_direction   = direction;
+}
+
+void HuePlusController::SetChannelLEDs(unsigned char channel, std::vector<RGBColor> colors)
+{
+    unsigned char serial_buf[] =
+    {
+        0x4B, 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, 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
+    };
+
+    /*-----------------------------------------------------*\
+    | Set channel in serial packet                          |
+    \*-----------------------------------------------------*/
+    serial_buf[0x01]   = channel;
+
+    /*-----------------------------------------------------*\
+    | Set mode in serial packet                             |
+    \*-----------------------------------------------------*/
+    serial_buf[0x02]   = current_mode;
+
+    /*-----------------------------------------------------*\
+    | Set options bitfield in serial packet                 |
+    \*-----------------------------------------------------*/
+    serial_buf[0x03]   = 0;
+    serial_buf[0x03]   |= current_direction ? ( 1 << 4 ) : 0;
+
+    /*-----------------------------------------------------*\
+    | Set speed in serial packet                            |
+    \*-----------------------------------------------------*/
+    serial_buf[0x04]   = current_speed;
+
+    /*-----------------------------------------------------*\
+    | Fill in color data                                    |
+    \*-----------------------------------------------------*/
+    for (std::size_t idx = 0; idx < colors.size(); idx++)
+    {
+        int pixel_idx = idx * 3;
+        RGBColor color = colors[idx];
+        serial_buf[pixel_idx + 0x05] = RGBGetGValue(color);
+        serial_buf[pixel_idx + 0x06] = RGBGetRValue(color);
+        serial_buf[pixel_idx + 0x07] = RGBGetBValue(color);
+    }
+
+    serialport->serial_write((char *)serial_buf, HUE_PLUS_PACKET_SIZE);
+    serialport->serial_flush_tx();
+
+    Sleep(10);
 }

Controllers/HuePlusController/HuePlusController.h

@@ -22,27 +22,69 @@
 #define strtok_s        strtok_r
 #endif
 
+#define HUE_PLUS_BAUD           256000
+#define HUE_PLUS_PACKET_SIZE    125
+
+enum
+{
+    HUE_PLUS_CHANNEL_BOTH   = 0x00,     /* Both channels                */
+    HUE_PLUS_CHANNEL_1      = 0x01,     /* Channel 1                    */
+    HUE_PLUS_CHANNEL_2      = 0x02,     /* Channel 2                    */
+    HUE_PLUS_NUM_CHANNELS   = 0x02      /* Number of channels           */
+};
+
+enum
+{
+    HUE_PLUS_CHANNEL_1_IDX  = 0x00,     /* Channel 1 array index        */
+    HUE_PLUS_CHANNEL_2_IDX  = 0x01,     /* Channel 2 array index        */
+};
+
+enum
+{
+    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
+{
+    HUE_PLUS_MODE_FIXED         = 0x00, /* Fixed colors mode            */
+    HUE_PLUS_MODE_FADING        = 0x01, /* Fading mode                  */
+    HUE_PLUS_MODE_SPECTRUM      = 0x02, /* Spectrum cycle mode          */
+    HUE_PLUS_MODE_MARQUEE       = 0x03, /* Marquee mode                 */
+    HUE_PLUS_MODE_COVER_MARQUEE = 0x04, /* Cover marquee mode           */
+    HUE_PLUS_MODE_ALTERNATING   = 0x05, /* Alternating mode             */
+    HUE_PLUS_MODE_PULSING       = 0x06, /* Pulsing mode                 */
+    HUE_PLUS_MODE_BREATHING     = 0x07, /* Breathing mode               */
+    HUE_PLUS_MODE_ALERT         = 0x08, /* Alert mode                   */
+    HUE_PLUS_MODE_CANDLELIGHT   = 0x09, /* Candlelight mode             */
+    HUE_PLUS_MODE_WINGS         = 0x0C, /* Wings mode                   */
+    HUE_PLUS_MODE_WAVE          = 0x0D, /* Wave mode                    */
+};
+
 class HuePlusController
 {
 public:
     HuePlusController();
     ~HuePlusController();
 
-    void Initialize(char* ledstring);
-    char* GetLEDString();
-    void SetLEDs(std::vector<RGBColor> colors);
+    void            Initialize(char* port);
+    char*           GetLocation();
+    unsigned int    GetLEDsOnChannel(unsigned int channel);
+    void            SetChannelLEDs(unsigned char channel, std::vector<RGBColor> colors);
+    void            SetMode(unsigned char mode, unsigned char speed, bool direction);
 
-    int num_leds;
+    unsigned int    channel_leds[HUE_PLUS_NUM_CHANNELS];
 
 private:
-    int baud_rate;
-    int fans;
-    int channel;
-    const int hueSize = 125;
+    char            port_name[128];
+    serial_port     *serialport;
 
-    char led_string[1024];
-    char port_name[128];
-    serial_port *serialport;
+    unsigned char   current_mode;
+    unsigned char   current_speed;
+    bool            current_direction;
 };
 
 #endif

Controllers/HuePlusController/HuePlusControllerDetect.cpp

@@ -1,27 +1,18 @@
 #include "HuePlusController.h"
 #include "RGBController.h"
 #include "RGBController_HuePlus.h"
+#include "find_usb_serial_port.h"
 #include <vector>
-#include <stdio.h>
-#include <stdlib.h>
 
-#include <fcntl.h>
-#include <string.h>
-#include <fstream>
-#include <iostream>
-#include <string>
-
-#ifndef WIN32
-#include <unistd.h>
-#include <dirent.h>
-#endif
+#define NZXT_HUE_PLUS_VID 0x04D8
+#define NZXT_HUE_PLUS_PID 0x00DF
 
 /******************************************************************************************\
 *                                                                                          *
 *   DetectHuePlusControllers                                                               *
 *                                                                                          *
 *       Detect devices supported by the HuePlus driver                                     *
-*                                                                                          *                                                                                          *
+*                                                                                          *
 \******************************************************************************************/
 
 void DetectHuePlusControllers(std::vector<RGBController*> &rgb_controllers)
@@ -29,61 +20,13 @@ void DetectHuePlusControllers(std::vector<RGBController*> &rgb_controllers)
     HuePlusController* new_hueplus;
     RGBController_HuePlus* new_controller;
 
-    //Get file path in executable directory
-    std::ifstream infile;
-    char filename[2048];
-    char arg1[64];
-
-#ifdef WIN32
-    GetModuleFileName(NULL, filename, 2048);
-    strcpy(filename, std::string(filename).substr(0, std::string(filename).find_last_of("\\/")).c_str());
-    strcat(filename, "\\settings.txt");
-#else
-    snprintf(arg1, 64, "/proc/%d/exe", getpid());
-    readlink(arg1, filename, 1024);
-    strcpy(filename, std::string(filename).substr(0, std::string(filename).find_last_of("\\/")).c_str());
-#endif
-
-    strcat(filename, "/settings.txt");
-
-    //Open settings file
-    infile.open(filename);
-
-    if (infile.good())
+    std::string portname = find_usb_serial_port(NZXT_HUE_PLUS_VID, NZXT_HUE_PLUS_PID);
+    if( portname != "" )
     {
-        for (std::string line; std::getline(infile, line); )
-        {
-            if (line == "")
-            {
-                continue;
-            }
-            if ((line[0] != ';') && (line[0] != '#') && (line[0] != '/'))
-            {
-                char * argument;
-                char * value;
+        new_hueplus = new HuePlusController();
+        new_hueplus->Initialize((char *)portname.c_str());
 
-                value = (char *)line.c_str();
-
-                argument = strtok_s(value, "=", &value);
-
-                //Strip off new line characters if present
-                argument = strtok(argument, "\r\n");
-                value    = strtok(value, "\r\n");
-
-                if(argument)
-                {
-                    if (strcmp(argument, "hueplus") == 0)
-                    {
-                        new_hueplus = new HuePlusController();
-                        new_hueplus->Initialize(value);
-
-                        new_controller = new RGBController_HuePlus(new_hueplus);
-                        rgb_controllers.push_back(new_controller);
-                    }
-                }
-            }
-        }
+        new_controller = new RGBController_HuePlus(new_hueplus);
+        rgb_controllers.push_back(new_controller);
     }
-
-
-}   /* DetectHuePlusControllers() */
+}   /* DetectHuePlusControllers() */

Controllers/HyperXController/HyperXController.cpp

@@ -10,13 +10,25 @@
 #include "HyperXController.h"
 #include <cstring>
 
-HyperXController::HyperXController(i2c_smbus_interface* bus, hyperx_dev_id dev)
+HyperXController::HyperXController(i2c_smbus_interface* bus, hyperx_dev_id dev, unsigned char slots)
 {
-    this->bus = bus;
-    this->dev = dev;
+    this->bus   = bus;
+    this->dev   = dev;
+    slots_valid = slots;
 
     strcpy(device_name, "HyperX Predator RGB");
-    led_count = 1;
+
+    led_count = 0;
+
+    for(int i = 0; i < 8; i++)
+    {
+        if((slots_valid & (1 << i)) != 0)
+        {
+            led_count += 5;
+        }
+    }
+
+    mode = HYPERX_MODE_DIRECT;
 }
 
 HyperXController::~HyperXController()
@@ -24,23 +36,91 @@ HyperXController::~HyperXController()
 
 }
 
-char* HyperXController::GetDeviceName()
+std::string HyperXController::GetDeviceName()
 {
     return(device_name);
 }
 
+std::string HyperXController::GetDeviceLocation()
+{
+    std::string return_string(bus->device_name);
+    char addr[5];
+    snprintf(addr, 5, "0x%02X", dev);
+    return_string.append(", address ");
+    return_string.append(addr);
+    return(return_string);
+}
+
 unsigned int HyperXController::GetLEDCount()
 {
     return(led_count);
 }
 
+unsigned int HyperXController::GetSlotCount()
+{
+    unsigned int slot_count = 0;
+
+    for(int slot = 0; slot < 4; slot++)
+    {
+        if((slots_valid & (1 << slot)) != 0)
+        {
+            slot_count++;
+        }
+    }
+
+    return(slot_count);
+}
+
+unsigned int HyperXController::GetMode()
+{
+    return(mode);
+}
+
+void HyperXController::SetEffectColor(unsigned char red, unsigned char green, unsigned char blue)
+{
+    bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_APPLY, 0x01);
+
+    bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_EFFECT_RED,        red  );
+    bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_EFFECT_GREEN,      green);
+    bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_EFFECT_BLUE,       blue );
+    bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_EFFECT_BRIGHTNESS, 0x64 );
+
+    bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_APPLY, 0x02);
+    bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_APPLY, 0x03);
+}
+
 void HyperXController::SetAllColors(unsigned char red, unsigned char green, unsigned char blue)
 {
     bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_APPLY, 0x01);
 
-    bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_RED, red);
-    bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_GREEN, green);
-    bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_BLUE, blue);
+    /*-----------------------------------------------------*\
+    | Loop through all slots and only set those which are   |
+    | active.                                               |
+    \*-----------------------------------------------------*/
+    for(int slot = 0; slot < 4; slot++)
+    {
+        if((slots_valid & (1 << slot)) != 0)
+        {
+            unsigned char base        = slot_base[slot];
+            unsigned char red_base    = base + 0x00;
+            unsigned char green_base  = base + 0x01;
+            unsigned char blue_base   = base + 0x02;
+            unsigned char bright_base = base + 0x10;
+
+            if(mode == HYPERX_MODE_DIRECT)
+            {
+                bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_MODE_INDEPENDENT, HYPERX_MODE3_DIRECT);
+            }
+
+            for(int led = 0; led < 5; led++)
+            {
+                bus->i2c_smbus_write_byte_data(dev, red_base    + (3 * led), red  );
+                bus->i2c_smbus_write_byte_data(dev, green_base  + (3 * led), green);
+                bus->i2c_smbus_write_byte_data(dev, blue_base   + (3 * led), blue );
+                bus->i2c_smbus_write_byte_data(dev, bright_base + (3 * led), 0x64 );
+            }
+        }
+    }
 
     bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_APPLY, 0x02);
     bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_APPLY, 0x03);
@@ -48,55 +128,160 @@ void HyperXController::SetAllColors(unsigned char red, unsigned char green, unsi
 
 void HyperXController::SetLEDColor(unsigned int led, unsigned char red, unsigned char green, unsigned char blue)
 {
+    /*-----------------------------------------------------*\
+    | led_slot - the unmapped slot ID for the given LED     |
+    | led - the LED ID within that slot                     |
+    | slot_id - counts enabled slots                        |
+    | slot - the mapped slot ID for the given LED           |
+    \*-----------------------------------------------------*/
+    int led_slot    = led / 5;
+    int slot_id     = -1;
+    int slot;
+
+    led            -= (led_slot * 5);
+
+    /*-----------------------------------------------------*\
+    | Loop through all possible slots and only count those  |
+    | which are active.                                     |
+    \*-----------------------------------------------------*/
+    for(slot = 0; slot < 4; slot++)
+    {
+        if((slots_valid & ( 1 << slot)) != 0)
+        {
+            slot_id++;
+        }
+
+        if(slot_id == led_slot)
+        {
+            break;
+        }
+    }
+
+    unsigned char base        = slot_base[slot];
+    unsigned char red_base    = base + 0x00;
+    unsigned char green_base  = base + 0x01;
+    unsigned char blue_base   = base + 0x02;
+    unsigned char bright_base = base + 0x10;
+
     bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_APPLY, 0x01);
 
-    bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_RED, red);
-    bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_GREEN, green);
-    bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_BLUE, blue);
+    bus->i2c_smbus_write_byte_data(dev, red_base    + (3 * led), red  );
+    bus->i2c_smbus_write_byte_data(dev, green_base  + (3 * led), green);
+    bus->i2c_smbus_write_byte_data(dev, blue_base   + (3 * led), blue );
+    bus->i2c_smbus_write_byte_data(dev, bright_base + (3 * led), 0x64 );
 
     bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_APPLY, 0x02);
     bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_APPLY, 0x03);
 }
 
-void HyperXController::SetMode(unsigned char mode)
+
+void HyperXController::SetLEDColor(unsigned int slot, unsigned int led, unsigned char red, unsigned char green, unsigned char blue)
 {
+    unsigned char base        = slot_base[slot];
+    unsigned char red_base    = base + 0x00;
+    unsigned char green_base  = base + 0x01;
+    unsigned char blue_base   = base + 0x02;
+    unsigned char bright_base = base + 0x10;
+
     bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_APPLY, 0x01);
 
+    bus->i2c_smbus_write_byte_data(dev, red_base    + (3 * led), red  );
+    bus->i2c_smbus_write_byte_data(dev, green_base  + (3 * led), green);
+    bus->i2c_smbus_write_byte_data(dev, blue_base   + (3 * led), blue );
+    bus->i2c_smbus_write_byte_data(dev, bright_base + (3 * led), 0x64 );
+
+    bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_APPLY, 0x02);
+    bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_APPLY, 0x03);
+}
+
+void HyperXController::SetMode(unsigned char new_mode, bool random, unsigned short new_speed)
+{
+    mode  = new_mode;
+    speed = new_speed;
+    
+    bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_APPLY, 0x01);
+
+    /*-----------------------------------------------------*\
+    | Determine which mode register to use.                 |
+    | If set to random color mode, use Mode1.               |
+    | If set to fixed color mode, use Mode2.                |
+    \*-----------------------------------------------------*/
+    unsigned char mode_reg;
+
+    if(random)
+    {
+        mode_reg = HYPERX_REG_MODE_RANDOM;
+    }
+    else
+    {
+        mode_reg = HYPERX_REG_MODE_CUSTOM;
+    }
+    
     switch (mode)
     {
+    case HYPERX_MODE_DIRECT:
+        bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_MODE_INDEPENDENT, HYPERX_MODE3_DIRECT);
+        break;
+
     case HYPERX_MODE_STATIC:
-        bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_MODE2, HYPERX_MODE2_STATIC);
+        bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_MODE_CUSTOM, HYPERX_MODE2_STATIC);
         break;
 
     case HYPERX_MODE_RAINBOW:
-        bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_MODE1, HYPERX_MODE1_RAINBOW);
+        bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_MODE_RANDOM, HYPERX_MODE1_RAINBOW);
+        bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_TIMER_MSB, speed >> 8);
+        bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_TIMER_LSB, speed & 0xFF);
         break;
 
     case HYPERX_MODE_COMET:
-        bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_MODE2, HYPERX_MODE2_COMET);
+        bus->i2c_smbus_write_byte_data(dev, mode_reg, HYPERX_MODE2_COMET);
+        bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_TIMER_MSB, speed >> 8);
+        bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_TIMER_LSB, speed & 0xFF);
         break;
 
     case HYPERX_MODE_HEARTBEAT:
-        bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_MODE2, HYPERX_MODE2_HEARTBEAT);
+        bus->i2c_smbus_write_byte_data(dev, mode_reg, HYPERX_MODE2_HEARTBEAT);
+        bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_OFF_TIME_MSB, speed >> 8);
+        bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_OFF_TIME_LSB, speed & 0xFF);
+        bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_ON_TIME_MSB, speed >> 8);
+        bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_ON_TIME_LSB, speed & 0xFF);
+        bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_DELAY_TIME_MSB, 0x03);
+        bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_DELAY_TIME_LSB, 0xE8);
         break;
 
     case HYPERX_MODE_CYCLE:
-        bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_MODE1, HYPERX_MODE1_CYCLE);
+        bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_MODE_RANDOM, HYPERX_MODE1_CYCLE);
+        bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_ON_TIME_MSB, speed >> 8);
+        bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_ON_TIME_LSB, speed & 0xFF);
+        bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_CHANGE_TIME_MSB, speed >> 8);
+        bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_CHANGE_TIME_LSB, speed & 0xFF);
         break;
 
     case HYPERX_MODE_BREATHING:
-        bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_MODE2, HYPERX_MODE2_BREATHING);
+        bus->i2c_smbus_write_byte_data(dev, mode_reg, HYPERX_MODE2_BREATHING);
+        bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_FADE_IN_TIME_MSB, speed >> 8);
+        bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_FADE_IN_TIME_LSB, speed & 0xFF);
+        bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_FADE_OUT_TIME_MSB, speed >> 8);
+        bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_FADE_OUT_TIME_LSB, speed & 0xFF);
+        bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_OFF_TIME_MSB, 0x00);
+        bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_OFF_TIME_LSB, 0x00);
         break;
 
     case HYPERX_MODE_BOUNCE:
-        bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_MODE2, HYPERX_MODE2_BOUNCE);
+        bus->i2c_smbus_write_byte_data(dev, mode_reg, HYPERX_MODE2_BOUNCE);
+        bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_TIMER_MSB, speed >> 8);
+        bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_TIMER_LSB, speed & 0xFF);
         break;
 
     case HYPERX_MODE_BLINK:
-        bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_MODE2, HYPERX_MODE2_BLINK);
+        bus->i2c_smbus_write_byte_data(dev, mode_reg, HYPERX_MODE2_BLINK);
+        bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_OFF_TIME_MSB, speed >> 8);
+        bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_OFF_TIME_LSB, speed & 0xFF);
+        bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_ON_TIME_MSB, 0x07);
+        bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_ON_TIME_LSB, 0xD4);
         break;
     }
 
     bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_APPLY, 0x02);
     bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_APPLY, 0x03);
-}
+}

Controllers/HyperXController/HyperXController.h

@@ -7,6 +7,7 @@
 |  Adam Honse (CalcProgrammer1) 6/29/2019   |
 \*-----------------------------------------*/
 
+#include <string>
 #include "i2c_smbus.h"
 
 #pragma once
@@ -16,13 +17,112 @@ typedef unsigned short	hyperx_register;
 
 enum
 {
-    HYPERX_REG_BRIGHTNESS               = 0xDD,     /* Brightness control register (0-100)  */
+    HYPERX_REG_SLOT0_LED0_RED           = 0x11,     /* R color register for LED 0, Slot 0   */
+    HYPERX_REG_SLOT0_LED0_GREEN         = 0x12,     /* G color register for LED 0, Slot 0   */
+    HYPERX_REG_SLOT0_LED0_BLUE          = 0x13,     /* B color register for LED 0, Slot 0   */
+    HYPERX_REG_SLOT0_LED1_RED           = 0x14,     /* R color register for LED 1, Slot 0   */
+    HYPERX_REG_SLOT0_LED1_GREEN         = 0x15,     /* G color register for LED 1, Slot 0   */
+    HYPERX_REG_SLOT0_LED1_BLUE          = 0x16,     /* B color register for LED 1, Slot 0   */
+    HYPERX_REG_SLOT0_LED2_RED           = 0x17,     /* R color register for LED 2, Slot 0   */
+    HYPERX_REG_SLOT0_LED2_GREEN         = 0x18,     /* G color register for LED 2, Slot 0   */
+    HYPERX_REG_SLOT0_LED2_BLUE          = 0x19,     /* B color register for LED 2, Slot 0   */
+    HYPERX_REG_SLOT0_LED3_RED           = 0x1A,     /* R color register for LED 3, Slot 0   */
+    HYPERX_REG_SLOT0_LED3_GREEN         = 0x1B,     /* G color register for LED 3, Slot 0   */
+    HYPERX_REG_SLOT0_LED3_BLUE          = 0x1C,     /* B color register for LED 3, Slot 0   */
+    HYPERX_REG_SLOT0_LED4_RED           = 0x1D,     /* R color register for LED 4, Slot 0   */
+    HYPERX_REG_SLOT0_LED4_GREEN         = 0x1E,     /* G color register for LED 4, Slot 0   */
+    HYPERX_REG_SLOT0_LED4_BLUE          = 0x1F,     /* B color register for LED 4, Slot 0   */
+    HYPERX_REG_SLOT0_LED0_BRIGHTNESS    = 0x21,     /* Brightness for LED 0, Slot 0 (0-100) */
+    HYPERX_REG_SLOT0_LED1_BRIGHTNESS    = 0x24,     /* Brightness for LED 1, Slot 0 (0-100) */
+    HYPERX_REG_SLOT0_LED2_BRIGHTNESS    = 0x27,     /* Brightness for LED 2, Slot 0 (0-100) */
+    HYPERX_REG_SLOT0_LED3_BRIGHTNESS    = 0x2A,     /* Brightness for LED 3, Slot 0 (0-100) */
+    HYPERX_REG_SLOT0_LED4_BRIGHTNESS    = 0x2D,     /* Brightness for LED 4, Slot 0 (0-100) */
+
+    HYPERX_REG_SLOT1_LED0_RED           = 0x41,     /* R color register for LED 0, Slot 1   */
+    HYPERX_REG_SLOT1_LED0_GREEN         = 0x42,     /* G color register for LED 0, Slot 1   */
+    HYPERX_REG_SLOT1_LED0_BLUE          = 0x43,     /* B color register for LED 0, Slot 1   */
+    HYPERX_REG_SLOT1_LED1_RED           = 0x44,     /* R color register for LED 1, Slot 1   */
+    HYPERX_REG_SLOT1_LED1_GREEN         = 0x45,     /* G color register for LED 1, Slot 1   */
+    HYPERX_REG_SLOT1_LED1_BLUE          = 0x46,     /* B color register for LED 1, Slot 1   */
+    HYPERX_REG_SLOT1_LED2_RED           = 0x47,     /* R color register for LED 2, Slot 1   */
+    HYPERX_REG_SLOT1_LED2_GREEN         = 0x48,     /* G color register for LED 2, Slot 1   */
+    HYPERX_REG_SLOT1_LED2_BLUE          = 0x49,     /* B color register for LED 2, Slot 1   */
+    HYPERX_REG_SLOT1_LED3_RED           = 0x4A,     /* R color register for LED 3, Slot 1   */
+    HYPERX_REG_SLOT1_LED3_GREEN         = 0x4B,     /* G color register for LED 3, Slot 1   */
+    HYPERX_REG_SLOT1_LED3_BLUE          = 0x4C,     /* B color register for LED 3, Slot 1   */
+    HYPERX_REG_SLOT1_LED4_RED           = 0x4D,     /* R color register for LED 4, Slot 1   */
+    HYPERX_REG_SLOT1_LED4_GREEN         = 0x4E,     /* G color register for LED 4, Slot 1   */
+    HYPERX_REG_SLOT1_LED4_BLUE          = 0x4F,     /* B color register for LED 4, Slot 1   */
+    HYPERX_REG_SLOT1_LED0_BRIGHTNESS    = 0x51,     /* Brightness for LED 0, Slot 1 (0-100) */
+    HYPERX_REG_SLOT1_LED1_BRIGHTNESS    = 0x54,     /* Brightness for LED 1, Slot 1 (0-100) */
+    HYPERX_REG_SLOT1_LED2_BRIGHTNESS    = 0x57,     /* Brightness for LED 2, Slot 1 (0-100) */
+    HYPERX_REG_SLOT1_LED3_BRIGHTNESS    = 0x5A,     /* Brightness for LED 3, Slot 1 (0-100) */
+    HYPERX_REG_SLOT1_LED4_BRIGHTNESS    = 0x5D,     /* Brightness for LED 4, Slot 1 (0-100) */
+
+    HYPERX_REG_SLOT2_LED0_RED           = 0x71,     /* R color register for LED 0, Slot 2   */
+    HYPERX_REG_SLOT2_LED0_GREEN         = 0x72,     /* G color register for LED 0, Slot 2   */
+    HYPERX_REG_SLOT2_LED0_BLUE          = 0x73,     /* B color register for LED 0, Slot 2   */
+    HYPERX_REG_SLOT2_LED1_RED           = 0x74,     /* R color register for LED 1, Slot 2   */
+    HYPERX_REG_SLOT2_LED1_GREEN         = 0x75,     /* G color register for LED 1, Slot 2   */
+    HYPERX_REG_SLOT2_LED1_BLUE          = 0x76,     /* B color register for LED 1, Slot 2   */
+    HYPERX_REG_SLOT2_LED2_RED           = 0x77,     /* R color register for LED 2, Slot 2   */
+    HYPERX_REG_SLOT2_LED2_GREEN         = 0x78,     /* G color register for LED 2, Slot 2   */
+    HYPERX_REG_SLOT2_LED2_BLUE          = 0x79,     /* B color register for LED 2, Slot 2   */
+    HYPERX_REG_SLOT2_LED3_RED           = 0x7A,     /* R color register for LED 3, Slot 2   */
+    HYPERX_REG_SLOT2_LED3_GREEN         = 0x7B,     /* G color register for LED 3, Slot 2   */
+    HYPERX_REG_SLOT2_LED3_BLUE          = 0x7C,     /* B color register for LED 3, Slot 2   */
+    HYPERX_REG_SLOT2_LED4_RED           = 0x7D,     /* R color register for LED 4, Slot 2   */
+    HYPERX_REG_SLOT2_LED4_GREEN         = 0x7E,     /* G color register for LED 4, Slot 2   */
+    HYPERX_REG_SLOT2_LED4_BLUE          = 0x7F,     /* B color register for LED 4, Slot 2   */
+    HYPERX_REG_SLOT2_LED0_BRIGHTNESS    = 0x81,     /* Brightness for LED 0, Slot 2 (0-100) */
+    HYPERX_REG_SLOT2_LED1_BRIGHTNESS    = 0x84,     /* Brightness for LED 1, Slot 2 (0-100) */
+    HYPERX_REG_SLOT2_LED2_BRIGHTNESS    = 0x87,     /* Brightness for LED 2, Slot 2 (0-100) */
+    HYPERX_REG_SLOT2_LED3_BRIGHTNESS    = 0x8A,     /* Brightness for LED 3, Slot 2 (0-100) */
+    HYPERX_REG_SLOT2_LED4_BRIGHTNESS    = 0x8D,     /* Brightness for LED 4, Slot 2 (0-100) */
+
+    HYPERX_REG_SLOT3_LED0_RED           = 0xA1,     /* R color register for LED 0, Slot 3   */
+    HYPERX_REG_SLOT3_LED0_GREEN         = 0xA2,     /* G color register for LED 0, Slot 3   */
+    HYPERX_REG_SLOT3_LED0_BLUE          = 0xA3,     /* B color register for LED 0, Slot 3   */
+    HYPERX_REG_SLOT3_LED1_RED           = 0xA4,     /* R color register for LED 1, Slot 3   */
+    HYPERX_REG_SLOT3_LED1_GREEN         = 0xA5,     /* G color register for LED 1, Slot 3   */
+    HYPERX_REG_SLOT3_LED1_BLUE          = 0xA6,     /* B color register for LED 1, Slot 3   */
+    HYPERX_REG_SLOT3_LED2_RED           = 0xA7,     /* R color register for LED 2, Slot 3   */
+    HYPERX_REG_SLOT3_LED2_GREEN         = 0xA8,     /* G color register for LED 2, Slot 3   */
+    HYPERX_REG_SLOT3_LED2_BLUE          = 0xA9,     /* B color register for LED 2, Slot 3   */
+    HYPERX_REG_SLOT3_LED3_RED           = 0xAA,     /* R color register for LED 3, Slot 3   */
+    HYPERX_REG_SLOT3_LED3_GREEN         = 0xAB,     /* G color register for LED 3, Slot 3   */
+    HYPERX_REG_SLOT3_LED3_BLUE          = 0xAC,     /* B color register for LED 3, Slot 3   */
+    HYPERX_REG_SLOT3_LED4_RED           = 0xAD,     /* R color register for LED 4, Slot 3   */
+    HYPERX_REG_SLOT3_LED4_GREEN         = 0xAE,     /* G color register for LED 4, Slot 3   */
+    HYPERX_REG_SLOT3_LED4_BLUE          = 0xAF,     /* B color register for LED 4, Slot 3   */
+    HYPERX_REG_SLOT3_LED0_BRIGHTNESS    = 0xB1,     /* Brightness for LED 0, Slot 3 (0-100) */
+    HYPERX_REG_SLOT3_LED1_BRIGHTNESS    = 0xB4,     /* Brightness for LED 1, Slot 3 (0-100) */
+    HYPERX_REG_SLOT3_LED2_BRIGHTNESS    = 0xB7,     /* Brightness for LED 2, Slot 3 (0-100) */
+    HYPERX_REG_SLOT3_LED3_BRIGHTNESS    = 0xBA,     /* Brightness for LED 3, Slot 3 (0-100) */
+    HYPERX_REG_SLOT3_LED4_BRIGHTNESS    = 0xBD,     /* Brightness for LED 4, Slot 3 (0-100) */
+
+    HYPERX_REG_TIMER_MSB                = 0xD1,     /* Timer MSB                            */
+    HYPERX_REG_TIMER_LSB                = 0xD2,     /* Timer LSB                            */
+    HYPERX_REG_ON_TIME_MSB              = 0xD3,     /* Effect on time MSB                   */
+    HYPERX_REG_ON_TIME_LSB              = 0xD4,     /* Effect on time LSB                   */
+    HYPERX_REG_CHANGE_TIME_MSB          = 0xD5,     /* Change time MSB                      */
+    HYPERX_REG_CHANGE_TIME_LSB          = 0xD6,     /* Change time LSB                      */
+    HYPERX_REG_FADE_IN_TIME_MSB         = 0xD7,     /* Fade in time MSB                     */
+    HYPERX_REG_FADE_IN_TIME_LSB         = 0xD8,     /* Fade in time LSB                     */
+    HYPERX_REG_FADE_OUT_TIME_MSB        = 0xD9,     /* Fade out time MSB                    */
+    HYPERX_REG_FADE_OUT_TIME_LSB        = 0xDA,     /* Fade out time LSB                    */
+    HYPERX_REG_OFF_TIME_MSB             = 0xDB,     /* Effect off time MSB                  */
+    HYPERX_REG_OFF_TIME_LSB             = 0xDC,     /* Effect off time LSB                  */
+    HYPERX_REG_EFFECT_BRIGHTNESS        = 0xDD,     /* Brightness for effects (0-100)       */
     HYPERX_REG_APPLY                    = 0xE1,     /* Apply changes register               */
-    HYPERX_REG_MODE1                    = 0xE3,     /* Mode control register 1              */
-    HYPERX_REG_MODE2                    = 0xE4,     /* Mode control register 2              */
-    HYPERX_REG_RED                      = 0xEC,     /* Red color register                   */
-    HYPERX_REG_GREEN                    = 0xED,     /* Green color register                 */
-    HYPERX_REG_BLUE                     = 0xEE,     /* Blue color register                  */
+    HYPERX_REG_MODE_RANDOM              = 0xE3,     /* Mode control register, random colors */
+    HYPERX_REG_MODE_CUSTOM              = 0xE4,     /* Mode control register, custom colors */
+    HYPERX_REG_MODE_INDEPENDENT         = 0xE5,     /* Mode control register, independent   */
+    HYPERX_REG_DELAY_TIME_MSB           = 0xEA,     /* Delay time MSB                       */
+    HYPERX_REG_DELAY_TIME_LSB           = 0xEB,     /* Delay time LSB                       */
+    HYPERX_REG_EFFECT_RED               = 0xEC,     /* Red color register for effects       */
+    HYPERX_REG_EFFECT_GREEN             = 0xED,     /* Green color register for effects     */
+    HYPERX_REG_EFFECT_BLUE              = 0xEE,     /* Blue color register for effects      */
 };
 
 enum
@@ -43,34 +143,80 @@ enum
 
 enum
 {
-    HYPERX_MODE_STATIC                  = 0,        /* Static color mode                    */
-    HYPERX_MODE_RAINBOW                 = 1,        /* Rainbow wave mode                    */
-    HYPERX_MODE_COMET                   = 2,        /* Comet (chase) mode                   */
-    HYPERX_MODE_HEARTBEAT               = 3,        /* Heartbeat (pulsing) mode             */
-    HYPERX_MODE_CYCLE                   = 4,        /* Spectrum cycle mode                  */
-    HYPERX_MODE_BREATHING               = 5,        /* Breathing mode                       */
-    HYPERX_MODE_BOUNCE                  = 6,        /* Bounce mode                          */
-    HYPERX_MODE_BLINK                   = 7,        /* Blinking mode                        */
+    HYPERX_MODE3_DIRECT                 = 0x21,     /* Mode 3 direct control                */
+};
+
+enum
+{
+    HYPERX_MODE_DIRECT                  = 0,        /* Direct control mode                  */
+    HYPERX_MODE_STATIC                  = 1,        /* Static color mode                    */
+    HYPERX_MODE_RAINBOW                 = 2,        /* Rainbow wave mode                    */
+    HYPERX_MODE_COMET                   = 3,        /* Comet (chase) mode                   */
+    HYPERX_MODE_HEARTBEAT               = 4,        /* Heartbeat (pulsing) mode             */
+    HYPERX_MODE_CYCLE                   = 5,        /* Spectrum cycle mode                  */
+    HYPERX_MODE_BREATHING               = 6,        /* Breathing mode                       */
+    HYPERX_MODE_BOUNCE                  = 7,        /* Bounce mode                          */
+    HYPERX_MODE_BLINK                   = 8,        /* Blinking mode                        */
     HYPERX_NUMBER_MODES                             /* Number of HyperX modes               */
 };
 
+enum
+{
+    HYPERX_SPEED_BOUNCE_SLOW            = 0x07D0,   /* Slowest speed for bounce mode        */
+    HYPERX_SPEED_BOUNCE_NORMAL          = 0x07D0,   /* Normal speed for bounce mode         */
+    HYPERX_SPEED_BOUNCE_FAST            = 0x0064,   /* Fastest speed for bounce mode        */
+    HYPERX_SPEED_BREATHING_SLOW         = 0x07D0,   /* Slowest speed for breathing mode     */
+    HYPERX_SPEED_BREATHING_NORMAL       = 0x07D0,   /* Normal speed for breathing mode      */
+    HYPERX_SPEED_BREATHING_FAST         = 0x0064,   /* Fastest speed for breathing mode     */
+    HYPERX_SPEED_CYCLE_SLOW             = 0x05DC,   /* Slowest speed for cycle mode         */
+    HYPERX_SPEED_CYCLE_NORMAL           = 0x05DC,   /* Normal speed for cycle mode          */
+    HYPERX_SPEED_CYCLE_FAST             = 0x00FA,   /* Fastest speed for cycle mode         */
+    HYPERX_SPEED_RAINBOW_SLOW           = 0x07D0,   /* Slowest speed for rainbow mode       */
+    HYPERX_SPEED_RAINBOW_NORMAL         = 0x07D0,   /* Normal speed for rainbow mode        */
+    HYPERX_SPEED_RAINBOW_FAST           = 0x0064,   /* Fastest speed for rainbow mode       */
+    HYPERX_SPEED_BLINK_SLOW             = 0x07D0,   /* Slowest speed for blink mode         */
+    HYPERX_SPEED_BLINK_NORMAL           = 0x07D0,   /* Normal speed for blink mode          */
+    HYPERX_SPEED_BLINK_FAST             = 0x01F4,   /* Fastest speed for blink mode         */
+    HYPERX_SPEED_HEARTBEAT_SLOW         = 0x07D0,   /* Slowest speed for heartbeat mode     */
+    HYPERX_SPEED_HEARTBEAT_NORMAL       = 0x07D0,   /* Normal speed for heartbeat mode      */
+    HYPERX_SPEED_HEARTBEAT_FAST         = 0x01F4,   /* Fastest speed for heartbeat mode     */
+    HYPERX_SPEED_COMET_SLOW             = 0x07D0,   /* Slowest speed for comet mode         */
+    HYPERX_SPEED_COMET_NORMAL           = 0x07D0,   /* Normal speed for comet mode          */
+    HYPERX_SPEED_COMET_FAST             = 0x0064,   /* Fastest speed for comet mode         */
+};
+
+static const unsigned char slot_base[4] =
+{
+    HYPERX_REG_SLOT0_LED0_RED,                      /* SPD 0x50 maps to slot 0              */
+    HYPERX_REG_SLOT1_LED0_RED,                      /* SPD 0x51 maps to slot 1              */
+    HYPERX_REG_SLOT2_LED0_RED,                      /* SPD 0x52 maps to slot 2              */
+    HYPERX_REG_SLOT3_LED0_RED                       /* SPD 0x53 maps to slot 3              */
+};
 
 class HyperXController
 {
 public:
-    HyperXController(i2c_smbus_interface* bus, hyperx_dev_id dev);
+    HyperXController(i2c_smbus_interface* bus, hyperx_dev_id dev, unsigned char slots);
     ~HyperXController();
 
-    char* GetDeviceName();
+    std::string     GetDeviceName();
+    std::string     GetDeviceLocation();
     unsigned int    GetLEDCount();
-    void            SetMode(unsigned char mode);
+    unsigned int    GetSlotCount();
+    unsigned int    GetMode();
+    void            SetMode(unsigned char new_mode, bool random, unsigned short new_speed);
 
     void            SetAllColors(unsigned char red, unsigned char green, unsigned char blue);
+    void            SetEffectColor(unsigned char red, unsigned char green, unsigned char blue);
     void            SetLEDColor(unsigned int led, unsigned char red, unsigned char green, unsigned char blue);
+    void            SetLEDColor(unsigned int slot, unsigned int led, unsigned char red, unsigned char green, unsigned char blue);
 
 private:
     char                    device_name[32];
     unsigned int            led_count;
+    unsigned char           slots_valid;
     i2c_smbus_interface*    bus;
     hyperx_dev_id           dev;
-};
+    unsigned int            mode;
+    unsigned short          speed;
+};

Controllers/HyperXController/HyperXControllerDetect.cpp

@@ -6,6 +6,17 @@
 #include <stdio.h>
 #include <stdlib.h>
 
+#ifdef WIN32
+#include <Windows.h>
+#else
+#include <unistd.h>
+
+static void Sleep(unsigned int milliseconds)
+{
+    usleep(1000 * milliseconds);
+}
+#endif
+
 /******************************************************************************************\
 *                                                                                          *
 *   TestForHyperXController                                                               *
@@ -58,13 +69,36 @@ void DetectHyperXControllers(std::vector<i2c_smbus_interface*> &busses, std::vec
 
     for (unsigned int bus = 0; bus < busses.size(); bus++)
     {
+        unsigned char slots_valid = 0x00;
+
         // Check for HyperX controller at 0x27
         if (TestForHyperXController(busses[bus], 0x27))
         {
-            new_hyperx = new HyperXController(busses[bus], 0x27);
-            new_controller = new RGBController_HyperX(new_hyperx);
-            rgb_controllers.push_back(new_controller);
+            busses[bus]->i2c_smbus_write_byte_data(0x37, 0x00, 0xFF);
+
+            Sleep(1);
+            
+            for(int slot_addr = 0x50; slot_addr <= 0x57; slot_addr++)
+            {
+                // Test for HyperX SPD at slot_addr
+                // This test was copied from NGENUITY software
+                // Tests SPD addresses in order: 0x40, 0x41
+                if((busses[bus]->i2c_smbus_read_byte_data(slot_addr, 0x40) == 0x01)
+                 &&(busses[bus]->i2c_smbus_read_byte_data(slot_addr, 0x41) == 0x98))
+                {
+                    slots_valid |= (1 << (slot_addr - 0x50));
+                }
+
+                Sleep(1);
+            }
+
+            if(slots_valid != 0)
+            {
+                new_hyperx = new HyperXController(busses[bus], 0x27, slots_valid);
+                new_controller = new RGBController_HyperX(new_hyperx);
+                rgb_controllers.push_back(new_controller);
+            }
         }
     }
 
-}   /* DetectHyperXControllers() */
+}   /* DetectHyperXControllers() */

Controllers/MSI3ZoneController/MSI3ZoneController.cpp

@@ -0,0 +1,78 @@
+/*-----------------------------------------*\
+|  MSI3ZoneController.cpp                   |
+|                                           |
+|  Driver for MSI/Steelseries 3-Zone        |
+|  Keyboard lighting controller             |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 12/25/2019  |
+\*-----------------------------------------*/
+
+#include "MSI3ZoneController.h"
+
+MSI3ZoneController::MSI3ZoneController(hid_device* dev_handle)
+{
+    dev = dev_handle;
+
+    //strcpy(device_name, "MSI 3-Zone Keyboard");
+}
+
+MSI3ZoneController::~MSI3ZoneController()
+{
+
+}
+
+char* MSI3ZoneController::GetDeviceName()
+{
+    return device_name;
+}
+
+void MSI3ZoneController::SetLEDs(std::vector<RGBColor> colors)
+{
+    //Shout out to bparker06 for reverse engineering the MSI keyboard USB protocol!
+    // https://github.com/bparker06/msi-keyboard/blob/master/keyboard.cpp for original implementation
+    unsigned char buf[8] = { 0 };
+
+    buf[0] = 1;
+    buf[1] = 2;
+    buf[2] = 64;
+    buf[3] = 1;
+    buf[4] = RGBGetRValue(colors[0]);
+    buf[5] = RGBGetGValue(colors[0]);
+    buf[6] = RGBGetBValue(colors[0]);
+    buf[7] = 236;
+
+    hid_send_feature_report(dev, buf, 8);
+
+    buf[3] = 2;
+    buf[4] = RGBGetRValue(colors[1]);
+    buf[5] = RGBGetGValue(colors[1]);
+    buf[6] = RGBGetBValue(colors[1]);
+
+    hid_send_feature_report(dev, buf, 8);
+
+    buf[3] = 3;
+    buf[4] = RGBGetRValue(colors[2]);
+    buf[5] = RGBGetGValue(colors[2]);
+    buf[6] = RGBGetBValue(colors[2]);
+
+    hid_send_feature_report(dev, buf, 8);
+
+    buf[3] = 4;
+    buf[4] = RGBGetRValue(colors[3]);
+    buf[5] = RGBGetGValue(colors[3]);
+    buf[6] = RGBGetBValue(colors[3]);
+
+    hid_send_feature_report(dev, buf, 8);
+
+    buf[3] = 5;
+
+    hid_send_feature_report(dev, buf, 8);
+
+    buf[3] = 6;
+
+    hid_send_feature_report(dev, buf, 8);
+
+    buf[3] = 7;
+
+    hid_send_feature_report(dev, buf, 8);
+}

Controllers/MSI3ZoneController/MSI3ZoneController.h

@@ -0,0 +1,30 @@
+/*-----------------------------------------*\
+|  MSI3ZoneController.h                     |
+|                                           |
+|  Definitions and types for MSI/Steelseries|
+|  3-Zone Keyboard lighting controller      |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 12/25/2019  |
+\*-----------------------------------------*/
+
+#include "RGBController.h"
+
+#include <string>
+#include <hidapi/hidapi.h>
+
+#pragma once
+
+class MSI3ZoneController
+{
+public:
+    MSI3ZoneController(hid_device* dev_handle);
+    ~MSI3ZoneController();
+
+    char* GetDeviceName();
+
+    void SetLEDs(std::vector<RGBColor> colors);
+    
+private:
+    char                    device_name[32];
+    hid_device*             dev;
+};

Controllers/MSI3ZoneController/MSI3ZoneControllerDetect.cpp

@@ -0,0 +1,36 @@
+#include "MSI3ZoneController.h"
+#include "RGBController.h"
+#include "RGBController_MSI3Zone.h"
+#include <vector>
+#include <hidapi/hidapi.h>
+
+#define MSI_3_ZONE_KEYBOARD_VID 0x1770
+#define MSI_3_ZONE_KEYBOARD_PID 0xFF00
+
+/******************************************************************************************\
+*                                                                                          *
+*   DetectMSI3ZoneControllers                                                              *
+*                                                                                          *
+*       Tests the USB address to see if an MSI/SteelSeries 3-zone Keyboard controller      *
+*       exists there.                                                                      *
+*                                                                                          *
+\******************************************************************************************/
+
+void DetectMSI3ZoneControllers(std::vector<RGBController*>& rgb_controllers)
+{
+    hid_device* dev;
+
+    //Look for MSI/Steelseries 3-zone Keyboard
+    hid_init();
+
+    dev = hid_open(MSI_3_ZONE_KEYBOARD_VID, MSI_3_ZONE_KEYBOARD_PID, 0);
+
+    if( dev )
+    {
+        MSI3ZoneController* controller = new MSI3ZoneController(dev);
+
+        RGBController_MSI3Zone* rgb_controller = new RGBController_MSI3Zone(controller);
+
+        rgb_controllers.push_back(rgb_controller);
+    }
+}

Controllers/PatriotViperController/PatriotViperController.cpp

@@ -0,0 +1,176 @@
+/*-----------------------------------------*\
+|  PatriotViperController.cpp               |
+|                                           |
+|  Definitions and types for Patriot Viper  |
+|  RGB RAM lighting controller              |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 1/1/2020    |
+\*-----------------------------------------*/
+
+#include "PatriotViperController.h"
+#include <cstring>
+
+PatriotViperController::PatriotViperController(i2c_smbus_interface* bus, viper_dev_id dev, unsigned char slots)
+{
+    this->bus   = bus;
+    this->dev   = dev;
+    slots_valid = slots;
+
+    strcpy(device_name, "Patriot Viper RGB");
+
+    led_count = 0;
+
+    for(int i = 0; i < 8; i++)
+    {
+        if((slots_valid & (1 << i)) != 0)
+        {
+            led_count += 5;
+        }
+    }
+}
+
+PatriotViperController::~PatriotViperController()
+{
+
+}
+
+std::string PatriotViperController::GetDeviceName()
+{
+    return(device_name);
+}
+
+std::string PatriotViperController::GetDeviceLocation()
+{
+    std::string return_string(bus->device_name);
+    char addr[5];
+    snprintf(addr, 5, "0x%02X", dev);
+    return_string.append(", address ");
+    return_string.append(addr);
+    return(return_string);
+}
+
+unsigned int PatriotViperController::GetLEDCount()
+{
+    return(led_count);
+}
+
+unsigned int PatriotViperController::GetSlotCount()
+{
+    unsigned int slot_count = 0;
+
+    for(int slot = 0; slot < 4; slot++)
+    {
+        if((slots_valid & (1 << slot)) != 0)
+        {
+            slot_count++;
+        }
+    }
+
+    return(slot_count);
+}
+
+unsigned int PatriotViperController::GetMode()
+{
+    return(mode);
+}
+
+void PatriotViperController::SetEffectColor(unsigned char red, unsigned char green, unsigned char blue)
+{
+    ViperRegisterWrite(VIPER_REG_START, 0xFF, 0xFF, 0xFF);
+    ViperRegisterWrite(VIPER_REG_STATIC, 0x04, 0x00, 0x00);
+
+    ViperRegisterWrite(VIPER_REG_LED0_EFFECT_COLOR, red, blue, green);
+    ViperRegisterWrite(VIPER_REG_LED1_EFFECT_COLOR, red, blue, green);
+    ViperRegisterWrite(VIPER_REG_LED2_EFFECT_COLOR, red, blue, green);
+    ViperRegisterWrite(VIPER_REG_LED3_EFFECT_COLOR, red, blue, green);
+    ViperRegisterWrite(VIPER_REG_LED4_EFFECT_COLOR, red, blue, green);
+
+    ViperRegisterWrite(VIPER_REG_MODE, mode, 0x00, speed);
+    ViperRegisterWrite(VIPER_REG_MODE, 0xAA, 0x00, 0x00);
+    ViperRegisterWrite(VIPER_REG_MODE, 0xFA, 0x00, 0x00);
+}
+
+void PatriotViperController::SetAllColors(unsigned char red, unsigned char green, unsigned char blue)
+{
+    ViperRegisterWrite(VIPER_REG_START, 0xFF, 0xFF, 0xFF);
+    ViperRegisterWrite(VIPER_REG_STATIC, 0x04, 0x00, 0x00);
+
+    ViperRegisterWrite(VIPER_REG_LED0_DIRECT_COLOR, red, blue, green);
+    ViperRegisterWrite(VIPER_REG_LED1_DIRECT_COLOR, red, blue, green);
+    ViperRegisterWrite(VIPER_REG_LED2_DIRECT_COLOR, red, blue, green);
+    ViperRegisterWrite(VIPER_REG_LED3_DIRECT_COLOR, red, blue, green);
+    ViperRegisterWrite(VIPER_REG_LED4_DIRECT_COLOR, red, blue, green);
+
+    ViperRegisterWrite(VIPER_REG_APPLY, 0x01, 0x00, 0x00);
+}
+
+void PatriotViperController::SetLEDColor(unsigned int led, unsigned char red, unsigned char green, unsigned char blue)
+{
+    ViperRegisterWrite(VIPER_REG_START, 0xFF, 0xFF, 0xFF);
+    ViperRegisterWrite(VIPER_REG_STATIC, 0x04, 0x00, 0x00);
+
+    ViperRegisterWrite(VIPER_REG_LED0_DIRECT_COLOR + led, red, blue, green);
+
+    ViperRegisterWrite(VIPER_REG_APPLY, 0x01, 0x00, 0x00);
+}
+
+void PatriotViperController::SetLEDEffectColor(unsigned int led, unsigned char red, unsigned char green, unsigned char blue)
+{
+    ViperRegisterWrite(VIPER_REG_START, 0xFF, 0xFF, 0xFF);
+    ViperRegisterWrite(VIPER_REG_STATIC, 0x04, 0x00, 0x00);
+
+    ViperRegisterWrite(VIPER_REG_LED0_EFFECT_COLOR + led, red, blue, green);
+
+    ViperRegisterWrite(VIPER_REG_MODE, mode, 0x00, speed);
+    ViperRegisterWrite(VIPER_REG_MODE, 0xAA, 0x00, 0x00);
+    ViperRegisterWrite(VIPER_REG_MODE, 0xFA, 0x00, 0x00);
+}
+
+void PatriotViperController::SetLEDColor(unsigned int slot, unsigned int led, unsigned char red, unsigned char green, unsigned char blue)
+{
+    ViperRegisterWrite(VIPER_REG_START, 0xFF, 0xFF, 0xFF);
+    ViperRegisterWrite(VIPER_REG_STATIC, 0x04, 0x00, 0x00);
+
+    ViperRegisterWrite(VIPER_REG_LED0_DIRECT_COLOR + led, red, blue, green);
+
+    ViperRegisterWrite(VIPER_REG_APPLY, 0x01, 0x00, 0x00);
+}
+
+void PatriotViperController::SetLEDEffectColor(unsigned int slot, unsigned int led, unsigned char red, unsigned char green, unsigned char blue)
+{
+    ViperRegisterWrite(VIPER_REG_START, 0xFF, 0xFF, 0xFF);
+    ViperRegisterWrite(VIPER_REG_STATIC, 0x04, 0x00, 0x00);
+
+    ViperRegisterWrite(VIPER_REG_LED0_EFFECT_COLOR + led, red, blue, green);
+
+    ViperRegisterWrite(VIPER_REG_MODE, mode, 0x00, speed);
+    ViperRegisterWrite(VIPER_REG_MODE, 0xAA, 0x00, 0x00);
+    ViperRegisterWrite(VIPER_REG_MODE, 0xFA, 0x00, 0x00);
+}
+
+void PatriotViperController::SetMode(unsigned char new_mode, unsigned char new_speed)
+{
+    direct = false;
+    mode   = new_mode;
+    speed  = new_speed;
+
+    ViperRegisterWrite(VIPER_REG_START, 0xFF, 0xFF, 0xFF);
+    ViperRegisterWrite(VIPER_REG_STATIC, 0x04, 0x00, 0x00);
+    ViperRegisterWrite(VIPER_REG_MODE, mode, 0x00, speed);
+    ViperRegisterWrite(VIPER_REG_MODE, 0xAA, 0x00, 0x00);
+    ViperRegisterWrite(VIPER_REG_MODE, 0xFA, 0x00, 0x00);
+}
+
+void PatriotViperController::SetDirect()
+{
+    direct = true;
+    ViperRegisterWrite(VIPER_REG_START, 0xFF, 0xFF, 0xFF);
+    ViperRegisterWrite(VIPER_REG_STATIC, 0x04, 0x00, 0x00);
+    ViperRegisterWrite(VIPER_REG_APPLY, 0x01, 0x00, 0x00);
+}
+
+void PatriotViperController::ViperRegisterWrite(viper_register reg, unsigned char val0, unsigned char val1, unsigned char val2)
+{
+    bus->i2c_smbus_write_byte_data(dev, reg, val0);
+    bus->i2c_smbus_write_byte_data(dev, val2, val1);
+}

Controllers/PatriotViperController/PatriotViperController.h

@@ -0,0 +1,90 @@
+/*-----------------------------------------*\
+|  PatriotViperController.h                 |
+|                                           |
+|  Definitions and types for Patriot Viper  |
+|  RGB RAM lighting controller              |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 1/1/2020    |
+\*-----------------------------------------*/
+
+#include <string>
+#include "i2c_smbus.h"
+
+#pragma once
+
+typedef unsigned char	viper_dev_id;
+typedef unsigned short	viper_register;
+
+enum
+{
+    VIPER_REG_STATIC                    = 0x01,     /* Set static mode                      */
+    VIPER_REG_MODE                      = 0x03,     /* Mode register                        */
+    VIPER_REG_LED0_DIRECT_COLOR         = 0x30,     /* LED 0 Color (R, B, G)                */
+    VIPER_REG_LED1_DIRECT_COLOR         = 0x31,     /* LED 1 Color (R, B, G)                */
+    VIPER_REG_LED2_DIRECT_COLOR         = 0x32,     /* LED 2 Color (R, B, G)                */
+    VIPER_REG_LED3_DIRECT_COLOR         = 0x33,     /* LED 3 Color (R, B, G)                */
+    VIPER_REG_LED4_DIRECT_COLOR         = 0x34,     /* LED 4 Color (R, B, G)                */
+    VIPER_REG_APPLY                     = 0x35,     /* Apply Changes (0x01, 0x00, 0x00)     */
+    VIPER_REG_LED0_EFFECT_COLOR         = 0x3B,     /* LED 0 Color (R, B, G)                */
+    VIPER_REG_LED1_EFFECT_COLOR         = 0x3C,     /* LED 1 Color (R, B, G)                */
+    VIPER_REG_LED2_EFFECT_COLOR         = 0x3D,     /* LED 2 Color (R, B, G)                */
+    VIPER_REG_LED3_EFFECT_COLOR         = 0x3E,     /* LED 3 Color (R, B, G)                */
+    VIPER_REG_LED4_EFFECT_COLOR         = 0x3F,     /* LED 4 Color (R, B, G)                */
+    VIPER_REG_START                     = 0xFF,     /* Start Frame (0xFF, 0xFF, 0xFF)       */
+};
+
+enum
+{
+    VIPER_MODE_DARK                     = 0x00,     /* Dark mode                            */
+    VIPER_MODE_BREATHING                = 0x01,     /* Breathing mode                       */
+    VIPER_MODE_VIPER                    = 0x02,     /* Viper mode                           */
+    VIPER_MODE_HEARTBEAT                = 0x03,     /* Heartbeat mode                       */
+    VIPER_MODE_MARQUEE                  = 0x04,     /* Marquee mode                         */
+    VIPER_MODE_RAINDROP                 = 0x05,     /* Raindrop mode                        */
+    VIPER_MODE_AURORA                   = 0x06,     /* Aurora mode                          */
+    VIPER_MODE_NEON                     = 0x08,     /* Neon mode                            */
+};
+
+enum
+{
+    VIPER_SPEED_MIN                     = 0xC8,     /* Slowest speed for non-breathing mode */
+    VIPER_SPEED_DEFAULT                 = 0x64,     /* Default speed for non-breathing mode */
+    VIPER_SPEED_MAX                     = 0x14,     /* Fastest speed for non-breathing mode */
+    VIPER_SPEED_BREATHING_MIN           = 0xFF,     /* Slowest speed for breathing mode     */
+    VIPER_SPEED_BREATHING_DEFAULT       = 0x0C,     /* Default speed for breathing mode     */
+    VIPER_SPEED_BREATHING_MAX           = 0x00,     /* Fastest speed for breathing mode     */
+};
+
+class PatriotViperController
+{
+public:
+    PatriotViperController(i2c_smbus_interface* bus, viper_dev_id dev, unsigned char slots);
+    ~PatriotViperController();
+
+    std::string     GetDeviceName();
+    std::string     GetDeviceLocation();
+    unsigned int    GetLEDCount();
+    unsigned int    GetSlotCount();
+    unsigned int    GetMode();
+    void            SetMode(unsigned char new_mode, unsigned char new_speed);
+    void            SetDirect();
+
+    void            SetAllColors(unsigned char red, unsigned char green, unsigned char blue);
+    void            SetEffectColor(unsigned char red, unsigned char green, unsigned char blue);
+    void            SetLEDColor(unsigned int led, unsigned char red, unsigned char green, unsigned char blue);
+    void            SetLEDColor(unsigned int slot, unsigned int led, unsigned char red, unsigned char green, unsigned char blue);
+    void            SetLEDEffectColor(unsigned int led, unsigned char red, unsigned char green, unsigned char blue);
+    void            SetLEDEffectColor(unsigned int slot, unsigned int led, unsigned char red, unsigned char green, unsigned char blue);
+
+    void            ViperRegisterWrite(viper_register reg, unsigned char val0, unsigned char val1, unsigned char val2);
+    bool            direct;
+
+private:
+    char                    device_name[32];
+    unsigned int            led_count;
+    unsigned char           slots_valid;
+    i2c_smbus_interface*    bus;
+    viper_dev_id            dev;
+    unsigned char           mode;
+    unsigned char           speed;
+};

Controllers/PatriotViperController/PatriotViperControllerDetect.cpp

@@ -0,0 +1,81 @@
+#include "PatriotViperController.h"
+#include "RGBController.h"
+#include "RGBController_PatriotViper.h"
+#include "i2c_smbus.h"
+#include <vector>
+#include <stdio.h>
+#include <stdlib.h>
+
+#ifdef WIN32
+#include <Windows.h>
+#else
+#include <unistd.h>
+
+static void Sleep(unsigned int milliseconds)
+{
+    usleep(1000 * milliseconds);
+}
+#endif
+
+/******************************************************************************************\
+*                                                                                          *
+*   DetectPatriotViperControllers                                                          *
+*                                                                                          *
+*       Detect Patriot Viper RGB controllers on the enumerated I2C busses.                 *
+*                                                                                          *
+*           bus - pointer to i2c_smbus_interface where Aura device is connected            *
+*           dev - I2C address of Aura device                                               *
+*                                                                                          *
+\******************************************************************************************/
+
+void DetectPatriotViperControllers(std::vector<i2c_smbus_interface*> &busses, std::vector<RGBController*> &rgb_controllers)
+{
+    PatriotViperController* new_viper;
+    RGBController_PatriotViper* new_controller;
+
+    for (unsigned int bus = 0; bus < busses.size(); bus++)
+    {
+        unsigned char slots_valid = 0x00;
+
+        for(int slot_addr = 0x50; slot_addr <= 0x57; slot_addr++)
+        {
+            // Test for Patriot Viper RGB SPD at slot_addr
+            // This test was copied from Viper RGB software
+            // Tests SPD addresses in order: 0x00, 0x40, 0x41, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68
+            busses[bus]->i2c_smbus_write_byte_data(0x36, 0x00, 0xFF);
+
+            Sleep(1);
+
+            if(busses[bus]->i2c_smbus_read_byte_data(slot_addr, 0x00) == 0x23)
+            {
+                busses[bus]->i2c_smbus_write_byte_data(0x37, 0x00, 0xFF);
+
+                Sleep(1);
+
+                if((busses[bus]->i2c_smbus_read_byte_data(slot_addr, 0x40) == 0x85)
+                 &&(busses[bus]->i2c_smbus_read_byte_data(slot_addr, 0x41) == 0x02)
+                 &&(busses[bus]->i2c_smbus_read_byte_data(slot_addr, 0x61) == 0x4D)
+                 &&(busses[bus]->i2c_smbus_read_byte_data(slot_addr, 0x62) == 0x49)
+                 &&(busses[bus]->i2c_smbus_read_byte_data(slot_addr, 0x63) == 0x43)
+                 &&(busses[bus]->i2c_smbus_read_byte_data(slot_addr, 0x64) == 0x53)
+                 &&(busses[bus]->i2c_smbus_read_byte_data(slot_addr, 0x65) == 0x59)
+                 &&(busses[bus]->i2c_smbus_read_byte_data(slot_addr, 0x66) == 0x53)
+                 &&(busses[bus]->i2c_smbus_read_byte_data(slot_addr, 0x67) == 0x5f)
+                 &&(busses[bus]->i2c_smbus_read_byte_data(slot_addr, 0x68) == 0x44))
+                {
+                    slots_valid |= (1 << (slot_addr - 0x50));
+                }
+            }
+
+            Sleep(1);
+        }
+
+        if(slots_valid != 0)
+        {
+            new_viper = new PatriotViperController(busses[bus], 0x77, slots_valid);
+            new_controller = new RGBController_PatriotViper(new_viper);
+            rgb_controllers.push_back(new_controller);
+        }
+    }
+
+}   /* DetectPatriotViperControllers() */

Controllers/PolychromeController/PolychromeController.cpp

@@ -0,0 +1,120 @@
+/*-----------------------------------------*\
+|  PolychromeController.cpp                 |
+|                                           |
+|  Driver for for ASRock ASR LED and        |
+|  Polychrome RGB lighting controller       |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 12/14/2019  |
+\*-----------------------------------------*/
+
+#include "PolychromeController.h"
+#include <cstring>
+
+PolychromeController::PolychromeController(i2c_smbus_interface* bus, polychrome_dev_id dev)
+{
+    this->bus = bus;
+    this->dev = dev;
+    
+    switch (GetFirmwareVersion())
+    {
+    case FIRMWARE_VER_1_PT_10:
+        led_count = 1;
+        asr_led = true;
+        strcpy(device_name, "ASRock ASR LED FW 1.10");
+        break;
+
+    case FIRMWARE_VER_2_PT_00:
+        led_count = 1;
+        asr_led = false;
+        strcpy(device_name, "ASRock Polychrome FW 2.00");
+        break;
+
+    case FIRMWARE_VER_3_PT_00:
+        led_count = 1;
+        asr_led = false;
+        strcpy(device_name, "ASRock Polychrome FW 3.00");
+        break;
+
+    default:
+        led_count = 0;
+        strcpy(device_name, "");
+        break;
+    }
+}
+
+PolychromeController::~PolychromeController()
+{
+
+}
+
+char* PolychromeController::GetDeviceName()
+{
+    return(device_name);
+}
+
+unsigned short PolychromeController::GetFirmwareVersion()
+{
+    // The firmware register holds two bytes, so the first read should return 2
+    // If not, report invalid firmware revision FFFF
+    if (bus->i2c_smbus_read_byte_data(dev, POLYCHROME_REG_FIRMWARE_VER) == 0x02)
+    {
+        unsigned char major = bus->i2c_smbus_read_byte(dev);
+        unsigned char minor = bus->i2c_smbus_read_byte(dev);
+
+        return((major << 8) | minor);
+    }
+    else
+    {
+        return(0xFFFF);
+    }
+}
+
+unsigned int PolychromeController::GetLEDCount()
+{
+    return(led_count);
+}
+
+unsigned int PolychromeController::GetMode()
+{
+    return(0);
+}
+
+void PolychromeController::SetAllColors(unsigned char red, unsigned char green, unsigned char blue)
+{
+    if (asr_led)
+    {
+
+    }
+    else
+    {
+        unsigned char colors[3] = { red, green, blue };
+
+        bus->i2c_smbus_write_block_data(dev, POLYCHROME_REG_COLOR, 3, colors);
+    }
+}
+
+void PolychromeController::SetLEDColor(unsigned int /*led*/, unsigned char red, unsigned char green, unsigned char blue)
+{
+    if (asr_led)
+    {
+
+    }
+    else
+    {
+        unsigned char colors[3] = { red, green, blue };
+
+        bus->i2c_smbus_write_block_data(dev, POLYCHROME_REG_COLOR, 3, colors);
+    }
+}
+
+void PolychromeController::SetMode(unsigned char mode)
+{
+    if (asr_led)
+    {
+
+    }
+    else
+    {
+        bus->i2c_smbus_write_byte_data(dev, POLYCHROME_REG_MODE, mode);
+    }    
+}

Controllers/PolychromeController/PolychromeController.h

@@ -0,0 +1,92 @@
+/*-----------------------------------------*\
+|  PolychromeController.h                   |
+|                                           |
+|  Definitions and types for ASRock         |
+|  ASR LED and Polychrome RGB lighting      |
+|  controller                               |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 12/13/2019  |
+\*-----------------------------------------*/
+
+#include "i2c_smbus.h"
+
+#pragma once
+
+typedef unsigned char	polychrome_dev_id;
+
+enum
+{
+    FIRMWARE_VER_1_PT_10            = 0x010A,   /* Firmware nu51_1.10                   */
+    FIRMWARE_VER_2_PT_00            = 0x0200,   /* Firmware nu51_2.00                   */
+    FIRMWARE_VER_3_PT_00            = 0x0300,   /* Firmware nu51_3.00                   */
+};
+
+enum
+{
+    ASRLED_REG_FIRMWARE_VER         = 0x00,     /* Firmware version Major.Minor         */
+    ASRLED_REG_MODE                 = 0x30,     /* Mode selection register              */
+};
+
+#define ASRLED_NUM_MODES             8          /* Number of ASR LED modes              */
+
+enum
+{
+    ASRLED_MODE_OFF                 = 0x10,     /* OFF mode                             */
+    ASRLED_MODE_STATIC              = 0x11,     /* Static color mode                    */
+    ASRLED_MODE_BREATHING           = 0x12,     /* Breathing effect mode                */
+    ASRLED_MODE_FLASHING            = 0x13,     /* Flashing effect mode                 */
+    ASRLED_MODE_SPECTRUM_CYCLE      = 0x14,     /* Spectrum Cycle effect mode           */
+    ASRLED_MODE_RANDOM              = 0x15,     /* Random effect mode                   */
+    ASRLED_MODE_MUSIC               = 0x17,     /* Music effect mode                    */
+    ASRLED_MODE_WAVE                = 0x18,     /* Wave effect mode                     */
+};
+
+enum
+{
+    POLYCHROME_REG_FIRMWARE_VER     = 0x00,     /* Firmware version Major.Minor         */
+    POLYCHROME_REG_MODE             = 0x30,     /* Mode selection register              */
+    POLYCHROME_REG_COLOR            = 0x34,     /* Color register: Red, Green, Blue     */
+};
+
+#define POLYCHROME_NUM_MODES          14        /* Number of Polychrome modes           */
+
+enum
+{
+    POLYCHROME_MODE_OFF             = 0x10,     /* OFF mode                             */
+    POLYCHROME_MODE_STATIC          = 0x11,     /* Static color mode                    */
+    POLYCHROME_MODE_BREATHING       = 0x12,     /* Breating effect mode                 */
+    POLYCHROME_MODE_FLASHING        = 0x13,     /* Flashing effect mode                 */
+    POLYCHROME_MODE_SPECTRUM_CYCLE  = 0x14,     /* Spectrum Cycle effect mode           */
+    POLYCHROME_MODE_RANDOM          = 0x15,     /* Random effect mode                   */
+    POLYCHROME_MODE_WAVE            = 0x17,     /* Wave effect mode                     */
+    POLYCHROME_MODE_SPRING          = 0x18,     /* Spring effect mode                   */
+    POLYCHROME_MODE_STACK           = 0x19,     /* Stack effect mode                    */
+    POLYCHROME_MODE_CRAM            = 0x1A,     /* Cram effect mode                     */
+    POLYCHROME_MODE_SCAN            = 0x1B,     /* Scan effect mode                     */
+    POLYCHROME_MODE_NEON            = 0x1C,     /* Neon effect mode                     */
+    POLYCHROME_MODE_WATER           = 0x1D,     /* Water effect mode                    */
+    POLYCHROME_MODE_RAINBOW         = 0x1E,     /* Rainbow effect mode                  */
+};
+
+class PolychromeController
+{
+public:
+    PolychromeController(i2c_smbus_interface* bus, polychrome_dev_id dev);
+    ~PolychromeController();
+
+    char*           GetDeviceName();
+    unsigned int    GetLEDCount();
+    unsigned int    GetMode();
+    void            SetAllColors(unsigned char red, unsigned char green, unsigned char blue);
+    void            SetLEDColor(unsigned int led, unsigned char red, unsigned char green, unsigned char blue);
+    void            SetMode(unsigned char mode);
+    unsigned short  GetFirmwareVersion();
+
+private:
+    bool                    asr_led;
+    char                    device_name[32];
+    unsigned int            led_count;
+    i2c_smbus_interface*    bus;
+    polychrome_dev_id       dev;
+
+};

Controllers/PolychromeController/PolychromeControllerDetect.cpp

@@ -0,0 +1,69 @@
+#include "PolychromeController.h"
+#include "RGBController.h"
+#include "RGBController_Polychrome.h"
+#include "i2c_smbus.h"
+#include <vector>
+#include <stdio.h>
+#include <stdlib.h>
+
+/******************************************************************************************\
+*                                                                                          *
+*   TestForPolychromeController                                                            *
+*                                                                                          *
+*       Tests the given address to see if an ASRock Polychrome RGB controller exists there.*
+*       First does a quick write to test for a response                                    *
+*                                                                                          *
+\******************************************************************************************/
+
+bool TestForPolychromeController(i2c_smbus_interface* bus, unsigned char address)
+{
+    bool pass = false;
+
+    int res = bus->i2c_smbus_write_quick(address, I2C_SMBUS_WRITE);
+
+    if (res >= 0)
+    {
+        pass = true;
+    }
+
+    return(pass);
+
+}   /* TestForPolychromeController() */
+
+/******************************************************************************************\
+*                                                                                          *
+*   DetectPolychromeControllers                                                            *
+*                                                                                          *
+*       Detect ASRock Polychrome RGB controllers on the enumerated I2C busses at address   *
+*       0x6A.                                                                              *
+*                                                                                          *
+*           bus - pointer to i2c_smbus_interface where Polychrome device is connected      *
+*           dev - I2C address of Polychrome device                                         *
+*                                                                                          *
+\******************************************************************************************/
+
+void DetectPolychromeControllers(std::vector<i2c_smbus_interface*>& busses, std::vector<RGBController*>& rgb_controllers)
+{
+    PolychromeController* new_polychrome;
+    RGBController_Polychrome* new_controller;
+
+    for (unsigned int bus = 0; bus < busses.size(); bus++)
+    {
+        // Check for Polychrome controller at 0x6A
+        if (TestForPolychromeController(busses[bus], 0x6A))
+        {
+            new_polychrome = new PolychromeController(busses[bus], 0x6A);
+
+            if(new_polychrome->GetLEDCount() != 0)
+            {
+                new_controller = new RGBController_Polychrome(new_polychrome);
+                rgb_controllers.push_back(new_controller);
+            }
+            else
+            {
+                delete new_polychrome;
+            }   
+        }
+    }
+
+}   /* DetectPolychromeControllers() */

Controllers/PoseidonZRGBController/PoseidonZRGBController.cpp

@@ -0,0 +1,201 @@
+/*-----------------------------------------*\
+|  PoseidonZRGBController.cpp               |
+|                                           |
+|  Driver for Thermaltake Poseidon Z RGB    |
+|  Keyboard lighting controller             |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 12/25/2019  |
+\*-----------------------------------------*/
+
+#include "PoseidonZRGBController.h"
+
+#include <cstring>
+
+#ifdef WIN32
+#include <Windows.h>
+#else
+#include <unistd.h>
+
+static void Sleep(unsigned int milliseconds)
+{
+    usleep(1000 * milliseconds);
+}
+#endif
+
+static unsigned int keys[] = {8,  9,  10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 21,
+                              22, 23, 24, 25, 26, 27, 29, 30, 31, 32, 33, 34, 35,
+                              36, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49,
+                              50, 51, 52, 54, 55, 56, 57, 58, 59, 60, 62, 63, 64,
+                              65, 66, 67, 68, 70, 71, 72, 73, 74, 75, 76, 78, 79,
+                              80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92,
+                              93, 94, 95, 96, 97, 98, 99, 100, 102, 103, 104, 105,
+                              106, 108, 109, 111, 112, 114, 115, 117, 118, 119, 120,
+                              124, 128, 129 };
+
+PoseidonZRGBController::PoseidonZRGBController(hid_device* dev_handle)
+{
+    dev = dev_handle;
+}
+
+PoseidonZRGBController::~PoseidonZRGBController()
+{
+
+}
+
+char* PoseidonZRGBController::GetDeviceName()
+{
+    return device_name;
+}
+
+void PoseidonZRGBController::SetLEDsDirect(std::vector<RGBColor> colors)
+{
+    unsigned char red_grn_buf[265];
+    unsigned char blu_buf[265];
+
+    for(int i = 0; i < 265; i++)
+    {
+        red_grn_buf[i] = 0x00;
+        blu_buf[i]     = 0x00;
+    }
+
+    red_grn_buf[0] = POSEIDONZ_START;
+    red_grn_buf[1] = POSEIDONZ_LED_CMD;
+    red_grn_buf[2] = POSEIDONZ_PROFILE;
+    red_grn_buf[3] = POSEIDONZ_RED_GRN_CH;
+    red_grn_buf[4] = 0x00;
+    red_grn_buf[5] = 0x00;
+    red_grn_buf[6] = 0x00;
+    red_grn_buf[7] = 0x00;
+
+    blu_buf[0] = POSEIDONZ_START;
+    blu_buf[1] = POSEIDONZ_LED_CMD;
+    blu_buf[2] = POSEIDONZ_PROFILE;
+    blu_buf[3] = POSEIDONZ_BLU_CH;
+    blu_buf[4] = 0x00;
+    blu_buf[5] = 0x00;
+    blu_buf[6] = 0x00;
+    blu_buf[7] = 0x00;
+
+    for(int i = 0; i < 104; i++)
+    {
+        red_grn_buf[keys[i]      ] = RGBGetRValue(colors[i]);
+        red_grn_buf[keys[i] + 128] = RGBGetGValue(colors[i]);
+        blu_buf[    keys[i]      ] = RGBGetBValue(colors[i]);
+    }
+
+    hid_send_feature_report(dev, red_grn_buf, 264);
+    
+    Sleep(1);
+
+    hid_send_feature_report(dev, blu_buf, 264);
+
+}
+
+void PoseidonZRGBController::SetLEDs(std::vector<RGBColor> colors)
+{
+    unsigned char red_color_data[104];
+    unsigned char grn_color_data[104];
+    unsigned char blu_color_data[104];
+
+    for(int i = 0; i < 104; i++)
+    {
+        red_color_data[keys[i] - 8] = RGBGetRValue(colors[i]);
+        grn_color_data[keys[i] - 8] = RGBGetGValue(colors[i]);
+        blu_color_data[keys[i] - 8] = RGBGetBValue(colors[i]);
+    }
+
+    SendColor
+        (
+        POSEIDONZ_PROFILE_P1,
+        POSEIDONZ_COLOR_RED,
+        red_color_data
+        );
+
+    Sleep(10);
+
+    SendColor
+        (
+        POSEIDONZ_PROFILE_P1,
+        POSEIDONZ_COLOR_GREEN,
+        grn_color_data
+        );
+
+    Sleep(10);
+
+    SendColor
+        (
+        POSEIDONZ_PROFILE_P1,
+        POSEIDONZ_COLOR_BLUE,
+        blu_color_data
+        );
+
+    Sleep(10);
+
+    SendControl
+        (
+        POSEIDONZ_PROFILE_P1,
+        POSEIDONZ_PROFILE_P1,
+        0,
+        POSEIDONZ_MODE_STATIC,
+        POSEIDONZ_BRIGHTNESS_MAX
+        );
+}
+
+void PoseidonZRGBController::SendColor
+    (
+    unsigned char   profile_to_edit,
+    unsigned char   color_channel,
+    unsigned char*  color_data
+    )
+{
+    unsigned char usb_buf[265];
+
+    switch(color_channel)
+    {
+        case POSEIDONZ_COLOR_RED:
+            memset(usb_buf, 0xFF, sizeof(usb_buf));
+            break;
+        case POSEIDONZ_COLOR_GREEN:
+            memset(usb_buf, 0x00, sizeof(usb_buf));
+            break;
+        case POSEIDONZ_COLOR_BLUE:
+            memset(usb_buf, 0x11, sizeof(usb_buf));
+            break;
+    }
+    
+
+    usb_buf[0x00]   = 0x07;
+    usb_buf[0x01]   = 0x07;
+    usb_buf[0x02]   = 0x09;
+    usb_buf[0x03]   = profile_to_edit;
+
+    memcpy(&usb_buf[0x08], color_data, 104);
+
+    hid_send_feature_report(dev, &usb_buf[1], 264);
+}
+
+void PoseidonZRGBController::SendControl
+    (
+    unsigned char   profile_to_activate,
+    unsigned char   profile_to_edit,
+    unsigned char   direction,
+    unsigned char   mode,
+    unsigned char   brightness
+    )
+{
+    unsigned char usb_buf[265];
+
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    usb_buf[0x00]   = 0x07;
+    usb_buf[0x01]   = 0x07;
+    usb_buf[0x02]   = 0x02;
+    usb_buf[0x03]   = profile_to_activate;
+    usb_buf[0x09]   = profile_to_edit;
+    usb_buf[0x0B]   = direction;
+    usb_buf[0x0D]   = mode;
+    usb_buf[0x0E]   = brightness;
+    usb_buf[0x11]   = 0x08;
+
+    hid_send_feature_report(dev, &usb_buf[1], 264);
+}

Controllers/PoseidonZRGBController/PoseidonZRGBController.h

@@ -0,0 +1,85 @@
+/*-----------------------------------------*\
+|  PoseidonZRGBController.h                 |
+|                                           |
+|  Definitions and types for Thermaltake    |
+|  Poseidon Z RGB Keyboard lighting         |
+|  controller                               |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 12/25/2019  |
+\*-----------------------------------------*/
+
+#include "RGBController.h"
+
+#include <string>
+#include <hidapi/hidapi.h>
+
+#pragma once
+
+#define POSEIDONZ_START       0x07
+#define POSEIDONZ_PROFILE     0x01
+#define POSEIDONZ_LED_CMD     0x0E
+#define POSEIDONZ_RED_GRN_CH  0x01
+#define POSEIDONZ_BLU_CH      0x02
+
+enum
+{
+    POSEIDONZ_MODE_STATIC       = 0x00,
+    POSEIDONZ_MODE_REACTIVE     = 0x01,
+    POSEIDONZ_MODE_ARROW_FLOW   = 0x02,
+    POSEIDONZ_MODE_WAVE         = 0x03,
+    POSEIDONZ_MODE_RIPPLE       = 0x04
+};
+
+enum
+{
+    POSEIDONZ_PROFILE_P1        = 0x01,
+    POSEIDONZ_PROFILE_P2        = 0x02,
+    POSEIDONZ_PROFILE_P3        = 0x03,
+    POSEIDONZ_PROFILE_P4        = 0x04,
+    POSEIDONZ_PROFILE_P5        = 0x05
+};
+
+enum
+{
+    POSEIDONZ_BRIGHTNESS_MIN    = 0x00,
+    POSEIDONZ_BRIGHTNESS_MAX    = 0x04
+};
+
+enum
+{
+    POSEIDONZ_COLOR_RED         = 0x01,
+    POSEIDONZ_COLOR_GREEN       = 0x02,
+    POSEIDONZ_COLOR_BLUE        = 0x03
+};
+
+class PoseidonZRGBController
+{
+public:
+    PoseidonZRGBController(hid_device* dev_handle);
+    ~PoseidonZRGBController();
+
+    char* GetDeviceName();
+
+    void SetLEDsDirect(std::vector<RGBColor> colors);
+    void SetLEDs(std::vector<RGBColor> colors);
+    
+private:
+    char                    device_name[32];
+    hid_device*             dev;
+
+    void SendControl
+        (
+        unsigned char   profile_to_activate,
+        unsigned char   profile_to_edit,
+        unsigned char   direction,
+        unsigned char   mode,
+        unsigned char   brightness
+        );
+    
+    void SendColor
+        (
+        unsigned char   profile_to_edit,
+        unsigned char   color_channel,
+        unsigned char*  color_data
+        );
+};

Controllers/PoseidonZRGBController/PoseidonZRGBControllerDetect.cpp

@@ -0,0 +1,52 @@
+#include "PoseidonZRGBController.h"
+#include "RGBController.h"
+#include "RGBController_PoseidonZRGB.h"
+#include <vector>
+#include <hidapi/hidapi.h>
+
+#define TT_POSEIDON_Z_RGB_VID 0x264A
+#define TT_POSEIDON_Z_RGB_PID 0x3006
+
+/******************************************************************************************\
+*                                                                                          *
+*   DetectPoseidonZRGBControllers                                                          *
+*                                                                                          *
+*       Tests the USB address to see if a Thermaltake Poseidon Z RGB Keyboard controller   *
+*       exists there.                                                                      *
+*                                                                                          *
+\******************************************************************************************/
+
+void DetectPoseidonZRGBControllers(std::vector<RGBController*>& rgb_controllers)
+{
+    hid_device_info* info;
+    hid_device* dev;
+
+    hid_init();
+
+    info = hid_enumerate(TT_POSEIDON_Z_RGB_VID, TT_POSEIDON_Z_RGB_PID);
+
+    //Look for Thermaltake Poseidon Z RGB Keyboard
+    while(info)
+    {
+        if((info->vendor_id == TT_POSEIDON_Z_RGB_VID)
+         &&(info->product_id == TT_POSEIDON_Z_RGB_PID)
+         &&(info->interface_number == 0))
+        {
+            dev = hid_open_path(info->path);
+            break;
+        }
+        else
+        {
+            info = info->next;
+        }
+    }
+
+    if( dev )
+    {
+        PoseidonZRGBController* controller = new PoseidonZRGBController(dev);
+
+        RGBController_PoseidonZRGB* rgb_controller = new RGBController_PoseidonZRGB(controller);
+
+        rgb_controllers.push_back(rgb_controller);
+    }
+}

Controllers/RGBFusionController/RGBFusionController.cpp

@@ -0,0 +1,194 @@
+/*-----------------------------------------*\
+|  RGBFusionController.cpp                  |
+|                                           |
+|  Driver for Gigabyte Aorus RGB Fusion     |
+|  lighting controller                      |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 12/10/2019  |
+\*-----------------------------------------*/
+
+#include "RGBFusionController.h"
+#include <cstring>
+#include <stdio.h>
+#include <stdlib.h>
+
+RGBFusionController::RGBFusionController(i2c_smbus_interface* bus, rgb_fusion_dev_id dev)
+{
+    this->bus = bus;
+    this->dev = dev;
+
+    // Set Device name
+    strcpy(device_name, "Gigabyte Motherboard");
+
+    // Set LED count
+    led_count = 2;
+
+    // Enable control
+    switch_bank(0);
+    bus->i2c_smbus_write_byte_data(dev, 0x02, 0x09);
+}
+
+RGBFusionController::~RGBFusionController()
+{
+
+}
+
+std::string RGBFusionController::GetDeviceName()
+{
+    return(device_name);
+}
+
+std::string RGBFusionController::GetDeviceLocation()
+{
+    std::string return_string(bus->device_name);
+    char addr[5];
+    snprintf(addr, 5, "0x%02X", dev);
+    return_string.append(", address ");
+    return_string.append(addr);
+    return(return_string);
+}
+
+unsigned int RGBFusionController::GetLEDCount()
+{
+    return(led_count);
+}
+
+unsigned char RGBFusionController::GetMode()
+{
+    switch_bank(0);
+    return(get_mode_ch_0());
+}
+
+void RGBFusionController::SetAllColors(unsigned char red, unsigned char green, unsigned char blue)
+{
+    unsigned char mode_ch_0;
+    unsigned char mode_ch_1;
+    
+    switch_bank(1);
+    set_color_ch_0(red, green, blue);
+    set_color_ch_1(red, green, blue);
+
+    switch_bank(0);
+    mode_ch_0 = get_mode_ch_0();
+    mode_ch_1 = get_mode_ch_1();
+    set_mode_ch_0(mode_ch_0);
+    set_mode_ch_1(mode_ch_1);
+
+}
+
+void RGBFusionController::SetLEDColor(unsigned int led, unsigned char red, unsigned char green, unsigned char blue)
+{
+    unsigned char mode;
+
+    switch (led)
+    {
+    case 0:
+        switch_bank(1);
+        set_color_ch_0(red, green, blue);
+
+        switch_bank(0);
+        mode = get_mode_ch_0();
+        set_mode_ch_0(mode);
+        break;
+
+    case 1:
+        switch_bank(1);
+        set_color_ch_1(red, green, blue);
+
+        switch_bank(0);
+        mode = get_mode_ch_1();
+        set_mode_ch_1(mode);
+        break;
+    }
+}
+
+void RGBFusionController::SetMode(unsigned char mode, unsigned char speed)
+{
+    switch_bank(0);
+    set_mode_ch_0(mode);
+    set_timers_ch_0(speed_table[0][speed], speed_table[1][speed]);
+    set_mode_ch_1(mode);
+    set_timers_ch_1(speed_table[0][speed], speed_table[1][speed]);
+}
+
+void RGBFusionController::dump()
+{
+    int i, j;
+
+    int start = 0x00;
+
+    FILE* file = freopen("rgb_fusion_dump.txt", "a", stdout);
+
+    printf("       0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f\r\n");
+
+    for (i = 0; i < 0xFF; i += 16)
+    {
+        printf("%04x: ", i + start);
+
+        for (j = 0; j < 16; j++)
+        {
+            printf("%02x ", bus->i2c_smbus_read_byte_data(dev, (start + i + j)));
+        }
+
+        printf("\r\n");
+    }
+
+    fclose(file);
+}
+
+unsigned char RGBFusionController::get_mode_ch_0()
+{
+    return(bus->i2c_smbus_read_byte_data(dev, RGB_FUSION_BANK_0_REG_CH_0_MODE));
+}
+
+unsigned char RGBFusionController::get_mode_ch_1()
+{
+    return(bus->i2c_smbus_read_byte_data(dev, RGB_FUSION_BANK_0_REG_CH_1_MODE));
+}
+
+void RGBFusionController::set_color_ch_0(unsigned char red, unsigned char green, unsigned char blue)
+{
+    bus->i2c_smbus_write_byte_data(dev, RGB_FUSION_BANK_1_REG_CH_0_R, red);
+    bus->i2c_smbus_write_byte_data(dev, RGB_FUSION_BANK_1_REG_CH_0_G, green);
+    bus->i2c_smbus_write_byte_data(dev, RGB_FUSION_BANK_1_REG_CH_0_B, blue);
+    bus->i2c_smbus_write_byte_data(dev, 0x03, 0x01);
+}
+
+void RGBFusionController::set_color_ch_1(unsigned char red, unsigned char green, unsigned char blue)
+{
+    bus->i2c_smbus_write_byte_data(dev, RGB_FUSION_BANK_1_REG_CH_1_R, red);
+    bus->i2c_smbus_write_byte_data(dev, RGB_FUSION_BANK_1_REG_CH_1_G, green);
+    bus->i2c_smbus_write_byte_data(dev, RGB_FUSION_BANK_1_REG_CH_1_B, blue);
+    bus->i2c_smbus_write_byte_data(dev, 0x0B, 0x01);
+}
+
+void RGBFusionController::set_mode_ch_0(unsigned char mode)
+{
+    bus->i2c_smbus_write_byte_data(dev, RGB_FUSION_BANK_0_REG_CH_0_MODE, mode + RGB_FUSION_WRITE_MODE_OFST);
+}
+
+void RGBFusionController::set_mode_ch_1(unsigned char mode)
+{
+    bus->i2c_smbus_write_byte_data(dev, RGB_FUSION_BANK_0_REG_CH_1_MODE, mode + RGB_FUSION_WRITE_MODE_OFST);
+}
+
+void RGBFusionController::set_timers_ch_0(unsigned short timer0, unsigned short timer1)
+{
+    bus->i2c_smbus_write_byte_data(dev, RGB_FUSION_BANK_0_REG_CH_0_TIMER_0_MSB, timer0 >> 8);
+    bus->i2c_smbus_write_byte_data(dev, RGB_FUSION_BANK_0_REG_CH_0_TIMER_0_LSB, timer0 & 0xFF);
+    bus->i2c_smbus_write_byte_data(dev, RGB_FUSION_BANK_0_REG_CH_0_TIMER_1_MSB, timer1 >> 8);
+    bus->i2c_smbus_write_byte_data(dev, RGB_FUSION_BANK_0_REG_CH_0_TIMER_1_LSB, timer1 & 0xFF);
+}
+
+void RGBFusionController::set_timers_ch_1(unsigned short timer0, unsigned short timer1)
+{
+    bus->i2c_smbus_write_byte_data(dev, RGB_FUSION_BANK_0_REG_CH_1_TIMER_0_MSB, timer0 >> 8);
+    bus->i2c_smbus_write_byte_data(dev, RGB_FUSION_BANK_0_REG_CH_1_TIMER_0_LSB, timer0 & 0xFF);
+    bus->i2c_smbus_write_byte_data(dev, RGB_FUSION_BANK_0_REG_CH_1_TIMER_1_MSB, timer1 >> 8);
+    bus->i2c_smbus_write_byte_data(dev, RGB_FUSION_BANK_0_REG_CH_1_TIMER_1_LSB, timer1 & 0xFF);
+}
+
+void RGBFusionController::switch_bank(unsigned char bank)
+{
+    bus->i2c_smbus_write_byte_data(dev, RGB_FUSION_BANK_SWITCH_REG, bank);
+}

Controllers/RGBFusionController/RGBFusionController.h

@@ -0,0 +1,102 @@
+/*-----------------------------------------*\
+|  RGBFusionController.h                    |
+|                                           |
+|  Definitions and types for Gigabyte Aorus |
+|  RGB Fusion lighting controller           |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 12/10/2019  |
+\*-----------------------------------------*/
+
+#include <string>
+#include "i2c_smbus.h"
+
+#pragma once
+
+typedef unsigned char	rgb_fusion_dev_id;
+
+enum
+{
+    RGB_FUSION_BANK_0_REG_CH_0_MODE = 0x03, /* Channel 0 Mode Selection             */
+    RGB_FUSION_BANK_0_REG_CH_0_TIMER_0_MSB
+                                    = 0x06, /* Channel 0 Timer 0 MSB                */
+    RGB_FUSION_BANK_0_REG_CH_0_TIMER_0_LSB
+                                    = 0x07, /* Channel 0 Timer 0 LSB                */
+    RGB_FUSION_BANK_0_REG_CH_0_TIMER_1_MSB
+                                    = 0x08, /* Channel 0 Timer 1 MSB                */
+    RGB_FUSION_BANK_0_REG_CH_0_TIMER_1_LSB
+                                    = 0x09, /* Channel 0 Timer 1 LSB                */
+    RGB_FUSION_BANK_0_REG_CH_1_MODE = 0x13, /* Channel 1 Mode Selection             */
+    RGB_FUSION_BANK_0_REG_CH_1_TIMER_0_MSB
+                                    = 0x16, /* Channel 1 Timer 0 MSB                */
+    RGB_FUSION_BANK_0_REG_CH_1_TIMER_0_LSB
+                                    = 0x17, /* Channel 1 Timer 0 LSB                */
+    RGB_FUSION_BANK_0_REG_CH_1_TIMER_1_MSB
+                                    = 0x18, /* Channel 1 Timer 1 MSB                */
+    RGB_FUSION_BANK_0_REG_CH_1_TIMER_1_LSB
+                                    = 0x19, /* Channel 1 Timer 1 LSB                */
+    RGB_FUSION_BANK_1_REG_CH_0_R    = 0x00, /* Channel 0 Red Value                  */
+    RGB_FUSION_BANK_1_REG_CH_0_G    = 0x01, /* Channel 0 Green Value                */
+    RGB_FUSION_BANK_1_REG_CH_0_B    = 0x02, /* Channel 0 Blue Value                 */
+    RGB_FUSION_BANK_1_REG_CH_1_R    = 0x08, /* Channel 1 Red Value                  */
+    RGB_FUSION_BANK_1_REG_CH_1_G    = 0x09, /* Channel 1 Green Value                */
+    RGB_FUSION_BANK_1_REG_CH_1_B    = 0x0A, /* Channel 1 Blue Value                 */
+    RGB_FUSION_BANK_SWITCH_REG      = 0xF0, /* Bank Switch Register                 */
+};
+
+enum
+{
+    RGB_FUSION_SPEED_SLOW           = 0x00, /* Slowest speed                        */
+    RGB_FUSION_SPEED_NORMAL         = 0x01, /* Normal speed                         */
+    RGB_FUSION_SPEED_FAST           = 0x02, /* Fastest speed                        */
+};
+
+static const short speed_table[2][3] =
+{
+    { 0x01E0, 0x00F0, 0x0078 },
+    { 0x4000, 0x2000, 0x1000 }
+};
+
+#define RGB_FUSION_NUMBER_MODES       3     /* Number of RGB Fusion modes           */
+#define RGB_FUSION_WRITE_MODE_OFST    0x10  /* offset to add when writing mode      */
+
+enum
+{
+    RGB_FUSION_MODE_STATIC          = 0x00, /* Static color mode                    */
+    RGB_FUSION_MODE_BREATHING       = 0x01, /* Breathing effect mode                */
+    RGB_FUSION_MODE_FLASHING        = 0x02, /* Flashing effect mode                 */
+};
+
+class RGBFusionController
+{
+public:
+    RGBFusionController(i2c_smbus_interface* bus, rgb_fusion_dev_id dev);
+    ~RGBFusionController();
+
+    std::string     GetDeviceName();
+    std::string     GetDeviceLocation();
+    unsigned int    GetLEDCount();
+    unsigned char   GetMode();
+    void            SetAllColors(unsigned char red, unsigned char green, unsigned char blue);
+    void            SetLEDColor(unsigned int led, unsigned char red, unsigned char green, unsigned char blue);
+    void            SetMode(unsigned char mode, unsigned char speed);
+
+private:
+    void            dump();
+
+    unsigned char   get_mode_ch_0();
+    unsigned char   get_mode_ch_1();
+
+    void            set_color_ch_0(unsigned char red, unsigned char green, unsigned char blue);
+    void            set_color_ch_1(unsigned char red, unsigned char green, unsigned char blue);
+    void            set_mode_ch_0(unsigned char mode);
+    void            set_mode_ch_1(unsigned char mode);
+    void            set_timers_ch_0(unsigned short timer0, unsigned short timer1);
+    void            set_timers_ch_1(unsigned short timer0, unsigned short timer1);
+    void            switch_bank(unsigned char bank);
+
+    char                    device_name[32];
+    unsigned int            led_count;
+    i2c_smbus_interface*    bus;
+    rgb_fusion_dev_id       dev;
+
+};

Controllers/RGBFusionController/RGBFusionControllerDetect.cpp

@@ -0,0 +1,67 @@
+#include "RGBFusionController.h"
+#include "RGBController.h"
+#include "RGBController_RGBFusion.h"
+#include "i2c_smbus.h"
+#include <vector>
+#include <stdio.h>
+#include <stdlib.h>
+
+/******************************************************************************************\
+*                                                                                          *
+*   TestForRGBFusionController                                                             *
+*                                                                                          *
+*       Tests the given address to see if an RGB Fusion controller exists there.  First    *
+*       does a quick write to test for a response                                          *
+*                                                                                          *
+\******************************************************************************************/
+
+bool TestForRGBFusionController(i2c_smbus_interface* bus, unsigned char address)
+{
+    bool pass = false;
+
+    int res = bus->i2c_smbus_write_quick(address, I2C_SMBUS_WRITE);
+
+    if (res >= 0)
+    {
+        pass = true;
+
+        res = bus->i2c_smbus_read_byte_data(address, 0xF2);
+
+        if (res != 0xC4)
+        {
+            pass = false;
+        }
+    }
+
+    return(pass);
+
+}   /* TestForRGBFusionController() */
+
+/******************************************************************************************\
+*                                                                                          *
+*   DetectRGBFusionControllers                                                             *
+*                                                                                          *
+*       Detect RGB Fusion controllers on the enumerated I2C busses at address 0x28.        *
+*                                                                                          *
+*           bus - pointer to i2c_smbus_interface where RGB Fusion device is connected      *
+*           dev - I2C address of RGB Fusion device                                         *
+*                                                                                          *
+\******************************************************************************************/
+
+void DetectRGBFusionControllers(std::vector<i2c_smbus_interface*>& busses, std::vector<RGBController*>& rgb_controllers)
+{
+    RGBFusionController* new_rgb_fusion;
+    RGBController_RGBFusion* new_controller;
+
+    for (unsigned int bus = 0; bus < busses.size(); bus++)
+    {
+        // Check for RGB Fusion controller at 0x28
+        if (TestForRGBFusionController(busses[bus], 0x28))
+        {
+            new_rgb_fusion = new RGBFusionController(busses[bus], 0x28);
+            new_controller = new RGBController_RGBFusion(new_rgb_fusion);
+            rgb_controllers.push_back(new_controller);
+        }
+    }
+
+}   /* DetectRGBFusionControllers() */

OpenAuraSDK.h

@@ -1,12 +0,0 @@
-#include <string>
-#include "AuraController.h"
-#include "i2c_smbus.h"
-
-#define MODE_AUTO   0
-#define MODE_QUICK  1
-#define MODE_READ   2
-#define MODE_FUNC   3
-
-std::string DetectI2C(i2c_smbus_interface * bus, int mode);
-void DumpAuraRegisters(AuraController * controller);
-void DetectRGBControllers();

OpenAuraSDK.pro

@@ -1,79 +0,0 @@
-QT       += core gui
-
-greaterThan(QT_MAJOR_VERSION, 4): QT += widgets
-
-TARGET = OpenAuraSDK.bin
-TEMPLATE = app
-
-INCLUDEPATH +=                                                          \
-    dependencies/libe131/src/                                           \
-    i2c_smbus/                                                          \
-    net_port/                                                           \
-    serial_port/                                                        \
-    Controllers/AuraController/                                         \
-    Controllers/CorsairController/                                      \
-    Controllers/CorsairProController/                                   \
-    Controllers/HuePlusController/                                      \
-    Controllers/HyperXController/                                       \
-    Controllers/LEDStripController/                                     \
-    RGBController/                                                      \
-    qt/
-
-SOURCES +=                                                              \
-    dependencies/libe131/src/e131.c                                     \
-    main.cpp                                                            \
-    OpenAuraSDK.cpp                                                     \
-    qt/OpenAuraSDKQtDialog.cpp                                          \
-    i2c_smbus/i2c_smbus.cpp                                             \
-    i2c_smbus/i2c_smbus_linux.cpp                                       \
-    net_port/net_port.cpp                                               \
-    serial_port/serial_port.cpp                                         \
-    Controllers/AuraController/AuraController.cpp                       \
-    Controllers/AuraController/AuraControllerDetect.cpp                 \
-    Controllers/CorsairController/CorsairController.cpp                 \
-    Controllers/CorsairController/CorsairControllerDetect.cpp           \
-    Controllers/CorsairProController/CorsairProController.cpp           \
-    Controllers/CorsairProController/CorsairProControllerDetect.cpp     \
-    Controllers/HuePlusController/HuePlusController.cpp                 \
-    Controllers/HuePlusController/HuePlusControllerDetect.cpp           \
-    Controllers/HyperXController/HyperXController.cpp                   \
-    Controllers/HyperXController/HyperXControllerDetect.cpp             \
-    Controllers/LEDStripController/LEDStripController.cpp               \
-    Controllers/LEDStripController/LEDStripControllerDetect.cpp         \
-    RGBController/OpenRazerDetect.cpp                                   \
-    RGBController/E131ControllerDetect.cpp                              \
-    RGBController/RGBController_Aura.cpp                                \
-    RGBController/RGBController_Corsair.cpp                             \
-    RGBController/RGBController_CorsairPro.cpp                          \
-    RGBController/RGBController_E131.cpp                                \
-    RGBController/RGBController_HuePlus.cpp                             \
-    RGBController/RGBController_HyperX.cpp                              \
-    RGBController/RGBController_LEDStrip.cpp                            \
-    RGBController/RGBController_OpenRazer.cpp
-
-HEADERS += \
-    qt/OpenAuraSDKQtDialog.h                                            \
-    i2c_smbus/i2c_smbus.h                                               \
-    i2c_smbus/i2c_smbus_linux.h                                         \
-    net_port/net_port.h                                                 \
-    serial_port/serial_port.h                                           \
-    Controllers/AuraController/AuraController.h                         \
-    Controllers/CorsairController/CorsairController.h                   \
-    Controllers/CorsairProController/CorsairProController.h             \
-    Controllers/HuePlusController/HuePlusController.h                   \
-    Controllers/HyperXController/HyperXController.h                     \
-    Controllers/LEDStripController/LEDStripController.h                 \
-    RGBController/RGBController.h                                       \
-    RGBController/RGBController_Aura.h                                  \
-    RGBController/RGBController_Corsair.h                               \
-    RGBController/RGBController_CorsairPro.h                            \
-    RGBController/RGBController_E131.h                                  \
-    RGBController/RGBController_HuePlus.h                               \
-    RGBController/RGBController_HyperX.h                                \
-    RGBController/RGBController_OpenRazer.h
-
-RESOURCES += \
-    qt/resources.qrc
-
-FORMS += \
-    qt/openaurasdk.ui

OpenAuraSDK.sln

@@ -1,31 +0,0 @@
-
-Microsoft Visual Studio Solution File, Format Version 12.00
-# Visual Studio Version 16
-VisualStudioVersion = 16.0.28803.452
-MinimumVisualStudioVersion = 10.0.40219.1
-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "OpenAuraSDK", "OpenAuraSDK.vcxproj", "{6D22BFF3-C1DF-407A-8816-05D63919A991}"
-EndProject
-Global
-	GlobalSection(SolutionConfigurationPlatforms) = preSolution
-		Debug|x64 = Debug|x64
-		Debug|x86 = Debug|x86
-		Release|x64 = Release|x64
-		Release|x86 = Release|x86
-	EndGlobalSection
-	GlobalSection(ProjectConfigurationPlatforms) = postSolution
-		{6D22BFF3-C1DF-407A-8816-05D63919A991}.Debug|x64.ActiveCfg = Debug|x64
-		{6D22BFF3-C1DF-407A-8816-05D63919A991}.Debug|x64.Build.0 = Debug|x64
-		{6D22BFF3-C1DF-407A-8816-05D63919A991}.Debug|x86.ActiveCfg = Debug|Win32
-		{6D22BFF3-C1DF-407A-8816-05D63919A991}.Debug|x86.Build.0 = Debug|Win32
-		{6D22BFF3-C1DF-407A-8816-05D63919A991}.Release|x64.ActiveCfg = Release|x64
-		{6D22BFF3-C1DF-407A-8816-05D63919A991}.Release|x64.Build.0 = Release|x64
-		{6D22BFF3-C1DF-407A-8816-05D63919A991}.Release|x86.ActiveCfg = Release|Win32
-		{6D22BFF3-C1DF-407A-8816-05D63919A991}.Release|x86.Build.0 = Release|Win32
-	EndGlobalSection
-	GlobalSection(SolutionProperties) = preSolution
-		HideSolutionNode = FALSE
-	EndGlobalSection
-	GlobalSection(ExtensibilityGlobals) = postSolution
-		SolutionGuid = {A2BB3E13-D506-413D-900E-F2B1323B3BB3}
-	EndGlobalSection
-EndGlobal

OpenAuraSDK.vcxproj

@@ -1,249 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <ItemGroup Label="ProjectConfigurations">
-    <ProjectConfiguration Include="Debug|Win32">
-      <Configuration>Debug</Configuration>
-      <Platform>Win32</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="Release|Win32">
-      <Configuration>Release</Configuration>
-      <Platform>Win32</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="Debug|x64">
-      <Configuration>Debug</Configuration>
-      <Platform>x64</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="Release|x64">
-      <Configuration>Release</Configuration>
-      <Platform>x64</Platform>
-    </ProjectConfiguration>
-  </ItemGroup>
-  <PropertyGroup Label="Globals">
-    <VCProjectVersion>15.0</VCProjectVersion>
-    <ProjectGuid>{6D22BFF3-C1DF-407A-8816-05D63919A991}</ProjectGuid>
-    <Keyword>Win32Proj</Keyword>
-    <RootNamespace>OpenAuraSDK</RootNamespace>
-    <WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
-  </PropertyGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
-    <ConfigurationType>Application</ConfigurationType>
-    <UseDebugLibraries>true</UseDebugLibraries>
-    <PlatformToolset>v142</PlatformToolset>
-    <CharacterSet>Unicode</CharacterSet>
-    <UseOfMfc>Dynamic</UseOfMfc>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
-    <ConfigurationType>Application</ConfigurationType>
-    <UseDebugLibraries>false</UseDebugLibraries>
-    <PlatformToolset>v142</PlatformToolset>
-    <WholeProgramOptimization>true</WholeProgramOptimization>
-    <CharacterSet>Unicode</CharacterSet>
-    <UseOfMfc>Dynamic</UseOfMfc>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
-    <ConfigurationType>Application</ConfigurationType>
-    <UseDebugLibraries>true</UseDebugLibraries>
-    <PlatformToolset>v142</PlatformToolset>
-    <CharacterSet>Unicode</CharacterSet>
-    <UseOfMfc>Dynamic</UseOfMfc>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
-    <ConfigurationType>Application</ConfigurationType>
-    <UseDebugLibraries>false</UseDebugLibraries>
-    <PlatformToolset>v142</PlatformToolset>
-    <WholeProgramOptimization>true</WholeProgramOptimization>
-    <CharacterSet>Unicode</CharacterSet>
-    <UseOfMfc>Dynamic</UseOfMfc>
-  </PropertyGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
-  <ImportGroup Label="ExtensionSettings">
-  </ImportGroup>
-  <ImportGroup Label="Shared">
-  </ImportGroup>
-  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-  </ImportGroup>
-  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-  </ImportGroup>
-  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-  </ImportGroup>
-  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-  </ImportGroup>
-  <PropertyGroup Label="UserMacros" />
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
-    <LinkIncremental>true</LinkIncremental>
-    <TargetExt>.exe</TargetExt>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
-    <LinkIncremental>true</LinkIncremental>
-    <TargetExt>.exe</TargetExt>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
-    <LinkIncremental>false</LinkIncremental>
-    <TargetExt>.exe</TargetExt>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
-    <LinkIncremental>false</LinkIncremental>
-    <TargetExt>.exe</TargetExt>
-  </PropertyGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
-    <ClCompile>
-      <PrecompiledHeader>NotUsing</PrecompiledHeader>
-      <WarningLevel>Level3</WarningLevel>
-      <Optimization>Disabled</Optimization>
-      <SDLCheck>true</SDLCheck>
-      <PreprocessorDefinitions>WIN32;_CRT_SECURE_NO_WARNINGS;_AFXDLL;_WINSOCK_DEPRECATED_NO_WARNINGS;WIN32_LEAN_AND_MEAN</PreprocessorDefinitions>
-      <ConformanceMode>true</ConformanceMode>
-      <AdditionalIncludeDirectories>.\dependencies\inpout32_1501\Win32;.\dependencies\razer-chroma-2.9.0\inc;.\Controllers\AuraController;.\Controllers\CorsairController;.\Controllers\CorsairProController;.\Controllers\HuePlusController;.\Controllers\HyperXController;.\Controllers\LEDStripController;.\RGBController;.\i2c_smbus;.\net_port;.\serial_port;.\vc;.\wmi;.\;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-      <MultiProcessorCompilation>true</MultiProcessorCompilation>
-      <PrecompiledHeaderFile />
-      <PrecompiledHeaderOutputFile />
-      <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
-    </ClCompile>
-    <Link>
-      <SubSystem>Windows</SubSystem>
-      <GenerateDebugInformation>true</GenerateDebugInformation>
-      <AdditionalLibraryDirectories>.\dependencies\inpout32_1501\Win32;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
-    </Link>
-  </ItemDefinitionGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
-    <ClCompile>
-      <PrecompiledHeader>NotUsing</PrecompiledHeader>
-      <WarningLevel>Level3</WarningLevel>
-      <Optimization>Disabled</Optimization>
-      <SDLCheck>true</SDLCheck>
-      <PreprocessorDefinitions>WIN32;_CRT_SECURE_NO_WARNINGS;_AFXDLL;_WINSOCK_DEPRECATED_NO_WARNINGS;WIN32_LEAN_AND_MEAN</PreprocessorDefinitions>
-      <ConformanceMode>true</ConformanceMode>
-      <PrecompiledHeaderFile />
-      <PrecompiledHeaderOutputFile />
-      <AdditionalIncludeDirectories>.\dependencies\inpout32_1501\Win32;.\dependencies\razer-chroma-2.9.0\inc;.\Controllers\AuraController;.\Controllers\CorsairController;.\Controllers\CorsairProController;.\Controllers\HuePlusController;.\Controllers\HyperXController;.\Controllers\LEDStripController;.\RGBController;.\i2c_smbus;.\net_port;.\serial_port;.\vc;.\wmi;.\;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-      <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
-      <MultiProcessorCompilation>true</MultiProcessorCompilation>
-    </ClCompile>
-    <Link>
-      <SubSystem>Windows</SubSystem>
-      <GenerateDebugInformation>true</GenerateDebugInformation>
-      <AdditionalLibraryDirectories>.\dependencies\inpout32_1501\Win32;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
-    </Link>
-  </ItemDefinitionGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
-    <ClCompile>
-      <PrecompiledHeader>NotUsing</PrecompiledHeader>
-      <WarningLevel>Level3</WarningLevel>
-      <Optimization>MaxSpeed</Optimization>
-      <FunctionLevelLinking>true</FunctionLevelLinking>
-      <IntrinsicFunctions>true</IntrinsicFunctions>
-      <SDLCheck>true</SDLCheck>
-      <PreprocessorDefinitions>WIN32;_CRT_SECURE_NO_WARNINGS;_AFXDLL;_WINSOCK_DEPRECATED_NO_WARNINGS;WIN32_LEAN_AND_MEAN</PreprocessorDefinitions>
-      <ConformanceMode>true</ConformanceMode>
-      <AdditionalIncludeDirectories>.\dependencies\inpout32_1501\Win32;.\dependencies\razer-chroma-2.9.0\inc;.\Controllers\AuraController;.\Controllers\CorsairController;.\Controllers\CorsairProController;.\Controllers\HuePlusController;.\Controllers\HyperXController;.\Controllers\LEDStripController;.\RGBController;.\i2c_smbus;.\net_port;.\serial_port;.\vc;.\wmi;.\;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-      <MultiProcessorCompilation>true</MultiProcessorCompilation>
-      <PrecompiledHeaderFile />
-      <PrecompiledHeaderOutputFile />
-      <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
-    </ClCompile>
-    <Link>
-      <SubSystem>Windows</SubSystem>
-      <EnableCOMDATFolding>true</EnableCOMDATFolding>
-      <OptimizeReferences>true</OptimizeReferences>
-      <GenerateDebugInformation>true</GenerateDebugInformation>
-      <AdditionalLibraryDirectories>.\dependencies\inpout32_1501\Win32;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
-    </Link>
-  </ItemDefinitionGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
-    <ClCompile>
-      <PrecompiledHeader>NotUsing</PrecompiledHeader>
-      <WarningLevel>Level3</WarningLevel>
-      <Optimization>MaxSpeed</Optimization>
-      <FunctionLevelLinking>true</FunctionLevelLinking>
-      <IntrinsicFunctions>true</IntrinsicFunctions>
-      <SDLCheck>true</SDLCheck>
-      <PreprocessorDefinitions>WIN32;_CRT_SECURE_NO_WARNINGS;_AFXDLL;_WINSOCK_DEPRECATED_NO_WARNINGS;WIN32_LEAN_AND_MEAN</PreprocessorDefinitions>
-      <ConformanceMode>true</ConformanceMode>
-      <PrecompiledHeaderFile />
-      <PrecompiledHeaderOutputFile />
-      <AdditionalIncludeDirectories>.\dependencies\inpout32_1501\Win32;.\dependencies\razer-chroma-2.9.0\inc;.\Controllers\AuraController;.\Controllers\CorsairController;.\Controllers\CorsairProController;.\Controllers\HuePlusController;.\Controllers\HyperXController;.\Controllers\LEDStripController;.\RGBController;.\i2c_smbus;.\net_port;.\serial_port;.\vc;.\wmi;.\;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-      <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
-      <MultiProcessorCompilation>true</MultiProcessorCompilation>
-    </ClCompile>
-    <Link>
-      <SubSystem>Windows</SubSystem>
-      <EnableCOMDATFolding>true</EnableCOMDATFolding>
-      <OptimizeReferences>true</OptimizeReferences>
-      <GenerateDebugInformation>true</GenerateDebugInformation>
-      <AdditionalLibraryDirectories>.\dependencies\inpout32_1501\Win32;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
-    </Link>
-  </ItemDefinitionGroup>
-  <ItemGroup>
-    <ClCompile Include="Controllers\AuraController\AuraController.cpp" />
-    <ClCompile Include="Controllers\AuraController\AuraControllerDetect.cpp" />
-    <ClCompile Include="Controllers\CorsairController\CorsairController.cpp" />
-    <ClCompile Include="Controllers\CorsairController\CorsairControllerDetect.cpp" />
-    <ClCompile Include="Controllers\CorsairProController\CorsairProController.cpp" />
-    <ClCompile Include="Controllers\CorsairProController\CorsairProControllerDetect.cpp" />
-    <ClCompile Include="Controllers\HuePlusController\HuePlusController.cpp" />
-    <ClCompile Include="Controllers\HuePlusController\HuePlusControllerDetect.cpp" />
-    <ClCompile Include="Controllers\HyperXController\HyperXController.cpp" />
-    <ClCompile Include="Controllers\HyperXController\HyperXControllerDetect.cpp" />
-    <ClCompile Include="Controllers\LEDStripController\LEDStripController.cpp" />
-    <ClCompile Include="Controllers\LEDStripController\LEDStripControllerDetect.cpp" />
-    <ClCompile Include="i2c_smbus\i2c_smbus.cpp" />
-    <ClCompile Include="i2c_smbus\i2c_smbus_i801.cpp" />
-    <ClCompile Include="i2c_smbus\i2c_smbus_nct6775.cpp" />
-    <ClCompile Include="i2c_smbus\i2c_smbus_piix4.cpp" />
-    <ClCompile Include="main.cpp" />
-    <ClCompile Include="net_port\net_port.cpp" />
-    <ClCompile Include="OpenAuraSDK.cpp" />
-    <ClCompile Include="RGBController\RazerChromaSDKDetect.cpp" />
-    <ClCompile Include="RGBController\RGBController_AorusGPU.cpp" />
-    <ClCompile Include="RGBController\RGBController_Aura.cpp" />
-    <ClCompile Include="RGBController\RGBController_Corsair.cpp" />
-    <ClCompile Include="RGBController\RGBController_CorsairPro.cpp" />
-    <ClCompile Include="RGBController\RGBController_HuePlus.cpp" />
-    <ClCompile Include="RGBController\RGBController_HyperX.cpp" />
-    <ClCompile Include="RGBController\RGBController_LEDStrip.cpp" />
-    <ClCompile Include="RGBController\RGBController_RazerChromaSDK.cpp" />
-    <ClCompile Include="serial_port\serial_port.cpp" />
-    <ClCompile Include="vc\I2CDetectDialog.cpp" />
-    <ClCompile Include="vc\OpenAuraSDKDialog.cpp" />
-    <ClCompile Include="wmi\wmi.cpp" />
-  </ItemGroup>
-  <ItemGroup>
-    <ResourceCompile Include="vc\Resource.rc" />
-  </ItemGroup>
-  <ItemGroup>
-    <ClInclude Include="Controllers\AuraController\AuraController.h" />
-    <ClInclude Include="Controllers\CorsairController\CorsairController.h" />
-    <ClInclude Include="Controllers\CorsairProController\CorsairProController.h" />
-    <ClInclude Include="Controllers\HuePlusController\HuePlusController.h" />
-    <ClInclude Include="Controllers\HyperXController\HyperXController.h" />
-    <ClInclude Include="Controllers\LEDStripController\LEDStripController.h" />
-    <ClInclude Include="i2c_smbus\i2c_smbus.h" />
-    <ClInclude Include="i2c_smbus\i2c_smbus_i801.h" />
-    <ClInclude Include="i2c_smbus\i2c_smbus_nct6775.h" />
-    <ClInclude Include="i2c_smbus\i2c_smbus_piix4.h" />
-    <ClInclude Include="net_port\net_port.h" />
-    <ClInclude Include="OpenAuraSDK.h" />
-    <ClInclude Include="RGBController\RGBController.h" />
-    <ClInclude Include="RGBController\RGBController_AorusGPU.h" />
-    <ClInclude Include="RGBController\RGBController_Aura.h" />
-    <ClInclude Include="RGBController\RGBController_Corsair.h" />
-    <ClInclude Include="RGBController\RGBController_CorsairPro.h" />
-    <ClInclude Include="RGBController\RGBController_HuePlus.h" />
-    <ClInclude Include="RGBController\RGBController_HyperX.h" />
-    <ClInclude Include="RGBController\RGBController_LEDStrip.h" />
-    <ClInclude Include="RGBController\RGBController_RazerChromaSDK.h" />
-    <ClInclude Include="serial_port\serial_port.h" />
-    <ClInclude Include="vc\I2CDetectDialog.h" />
-    <ClInclude Include="vc\OpenAuraSDKDialog.h" />
-    <ClInclude Include="vc\resource.h" />
-    <ClInclude Include="wmi\wmi.h" />
-  </ItemGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
-  <ImportGroup Label="ExtensionTargets">
-  </ImportGroup>
-</Project>

OpenAuraSDK.vcxproj.filters

@@ -1,221 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <ItemGroup>
-    <Filter Include="Source Files">
-      <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
-      <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
-    </Filter>
-    <Filter Include="Header Files">
-      <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
-      <Extensions>h;hh;hpp;hxx;hm;inl;inc;ipp;xsd</Extensions>
-    </Filter>
-    <Filter Include="Resource Files">
-      <UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
-      <Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
-    </Filter>
-    <Filter Include="Source Files\Controllers">
-      <UniqueIdentifier>{192d5e34-581a-40c4-bc69-f4b61632fd81}</UniqueIdentifier>
-    </Filter>
-    <Filter Include="Source Files\Application">
-      <UniqueIdentifier>{d64d74dd-f822-4617-a88c-00dca03f70d9}</UniqueIdentifier>
-    </Filter>
-    <Filter Include="Source Files\RGBController">
-      <UniqueIdentifier>{ee7c811d-9bd1-43a8-9d42-62801332ab30}</UniqueIdentifier>
-    </Filter>
-    <Filter Include="Source Files\i2c_smbus">
-      <UniqueIdentifier>{fa28cfae-d8a7-4194-8f25-e35827dd0145}</UniqueIdentifier>
-    </Filter>
-    <Filter Include="Header Files\Controllers">
-      <UniqueIdentifier>{a50a158e-81a1-45c3-a300-67e869afcc2f}</UniqueIdentifier>
-    </Filter>
-    <Filter Include="Header Files\i2c_smbus">
-      <UniqueIdentifier>{8eae9b90-7558-4b0b-9f03-d3a651cb6624}</UniqueIdentifier>
-    </Filter>
-    <Filter Include="Header Files\RGBController">
-      <UniqueIdentifier>{02dd848e-6106-4f74-a58c-4a7547498ac3}</UniqueIdentifier>
-    </Filter>
-  </ItemGroup>
-  <ItemGroup>
-    <ClCompile Include="OpenAuraSDK.cpp">
-      <Filter>Source Files\Application</Filter>
-    </ClCompile>
-    <ClCompile Include="main.cpp">
-      <Filter>Source Files\Application</Filter>
-    </ClCompile>
-    <ClCompile Include="wmi\wmi.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="serial_port\serial_port.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="Controllers\AuraController\AuraController.cpp">
-      <Filter>Source Files\Controllers</Filter>
-    </ClCompile>
-    <ClCompile Include="Controllers\AuraController\AuraControllerDetect.cpp">
-      <Filter>Source Files\Controllers</Filter>
-    </ClCompile>
-    <ClCompile Include="Controllers\CorsairController\CorsairController.cpp">
-      <Filter>Source Files\Controllers</Filter>
-    </ClCompile>
-    <ClCompile Include="Controllers\CorsairController\CorsairControllerDetect.cpp">
-      <Filter>Source Files\Controllers</Filter>
-    </ClCompile>
-    <ClCompile Include="Controllers\CorsairProController\CorsairProController.cpp">
-      <Filter>Source Files\Controllers</Filter>
-    </ClCompile>
-    <ClCompile Include="Controllers\CorsairProController\CorsairProControllerDetect.cpp">
-      <Filter>Source Files\Controllers</Filter>
-    </ClCompile>
-    <ClCompile Include="Controllers\HyperXController\HyperXController.cpp">
-      <Filter>Source Files\Controllers</Filter>
-    </ClCompile>
-    <ClCompile Include="Controllers\HyperXController\HyperXControllerDetect.cpp">
-      <Filter>Source Files\Controllers</Filter>
-    </ClCompile>
-    <ClCompile Include="i2c_smbus\i2c_smbus.cpp">
-      <Filter>Source Files\i2c_smbus</Filter>
-    </ClCompile>
-    <ClCompile Include="i2c_smbus\i2c_smbus_i801.cpp">
-      <Filter>Source Files\i2c_smbus</Filter>
-    </ClCompile>
-    <ClCompile Include="i2c_smbus\i2c_smbus_nct6775.cpp">
-      <Filter>Source Files\i2c_smbus</Filter>
-    </ClCompile>
-    <ClCompile Include="i2c_smbus\i2c_smbus_piix4.cpp">
-      <Filter>Source Files\i2c_smbus</Filter>
-    </ClCompile>
-    <ClCompile Include="RGBController\RGBController_AorusGPU.cpp">
-      <Filter>Source Files\RGBController</Filter>
-    </ClCompile>
-    <ClCompile Include="RGBController\RGBController_Aura.cpp">
-      <Filter>Source Files\RGBController</Filter>
-    </ClCompile>
-    <ClCompile Include="RGBController\RGBController_Corsair.cpp">
-      <Filter>Source Files\RGBController</Filter>
-    </ClCompile>
-    <ClCompile Include="RGBController\RGBController_CorsairPro.cpp">
-      <Filter>Source Files\RGBController</Filter>
-    </ClCompile>
-    <ClCompile Include="RGBController\RGBController_HyperX.cpp">
-      <Filter>Source Files\RGBController</Filter>
-    </ClCompile>
-    <ClCompile Include="RGBController\RGBController_LEDStrip.cpp">
-      <Filter>Source Files\RGBController</Filter>
-    </ClCompile>
-    <ClCompile Include="vc\I2CDetectDialog.cpp">
-      <Filter>Source Files\Application</Filter>
-    </ClCompile>
-    <ClCompile Include="Controllers\LEDStripController\LEDStripController.cpp">
-      <Filter>Source Files\Controllers</Filter>
-    </ClCompile>
-    <ClCompile Include="Controllers\LEDStripController\LEDStripControllerDetect.cpp">
-      <Filter>Source Files\Controllers</Filter>
-    </ClCompile>
-    <ClCompile Include="vc\OpenAuraSDKDialog.cpp">
-      <Filter>Source Files\Application</Filter>
-    </ClCompile>
-    <ClCompile Include="Controllers\HuePlusController\HuePlusController.cpp">
-      <Filter>Source Files\Controllers</Filter>
-    </ClCompile>
-    <ClCompile Include="Controllers\HuePlusController\HuePlusControllerDetect.cpp">
-      <Filter>Source Files\Controllers</Filter>
-    </ClCompile>
-    <ClCompile Include="net_port\net_port.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="RGBController\RGBController_HuePlus.cpp">
-      <Filter>Source Files\RGBController</Filter>
-    </ClCompile>
-    <ClCompile Include="RGBController\RGBController_RazerChromaSDK.cpp">
-      <Filter>Source Files\RGBController</Filter>
-    </ClCompile>
-    <ClCompile Include="RGBController\RazerChromaSDKDetect.cpp">
-      <Filter>Source Files\RGBController</Filter>
-    </ClCompile>
-  </ItemGroup>
-  <ItemGroup>
-    <ResourceCompile Include="vc\Resource.rc">
-      <Filter>Resource Files</Filter>
-    </ResourceCompile>
-  </ItemGroup>
-  <ItemGroup>
-    <ClInclude Include="wmi\wmi.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="serial_port\serial_port.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="Controllers\AuraController\AuraController.h">
-      <Filter>Header Files\Controllers</Filter>
-    </ClInclude>
-    <ClInclude Include="Controllers\CorsairController\CorsairController.h">
-      <Filter>Header Files\Controllers</Filter>
-    </ClInclude>
-    <ClInclude Include="Controllers\CorsairProController\CorsairProController.h">
-      <Filter>Header Files\Controllers</Filter>
-    </ClInclude>
-    <ClInclude Include="Controllers\HyperXController\HyperXController.h">
-      <Filter>Header Files\Controllers</Filter>
-    </ClInclude>
-    <ClInclude Include="Controllers\LEDStripController\LEDStripController.h">
-      <Filter>Header Files\Controllers</Filter>
-    </ClInclude>
-    <ClInclude Include="RGBController\RGBController.h">
-      <Filter>Header Files\RGBController</Filter>
-    </ClInclude>
-    <ClInclude Include="RGBController\RGBController_AorusGPU.h">
-      <Filter>Header Files\RGBController</Filter>
-    </ClInclude>
-    <ClInclude Include="RGBController\RGBController_Aura.h">
-      <Filter>Header Files\RGBController</Filter>
-    </ClInclude>
-    <ClInclude Include="RGBController\RGBController_Corsair.h">
-      <Filter>Header Files\RGBController</Filter>
-    </ClInclude>
-    <ClInclude Include="RGBController\RGBController_CorsairPro.h">
-      <Filter>Header Files\RGBController</Filter>
-    </ClInclude>
-    <ClInclude Include="RGBController\RGBController_HyperX.h">
-      <Filter>Header Files\RGBController</Filter>
-    </ClInclude>
-    <ClInclude Include="RGBController\RGBController_LEDStrip.h">
-      <Filter>Header Files\RGBController</Filter>
-    </ClInclude>
-    <ClInclude Include="i2c_smbus\i2c_smbus.h">
-      <Filter>Header Files\i2c_smbus</Filter>
-    </ClInclude>
-    <ClInclude Include="i2c_smbus\i2c_smbus_i801.h">
-      <Filter>Header Files\i2c_smbus</Filter>
-    </ClInclude>
-    <ClInclude Include="i2c_smbus\i2c_smbus_nct6775.h">
-      <Filter>Header Files\i2c_smbus</Filter>
-    </ClInclude>
-    <ClInclude Include="i2c_smbus\i2c_smbus_piix4.h">
-      <Filter>Header Files\i2c_smbus</Filter>
-    </ClInclude>
-    <ClInclude Include="vc\I2CDetectDialog.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="OpenAuraSDK.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="vc\OpenAuraSDKDialog.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="vc\resource.h">
-      <Filter>Resource Files</Filter>
-    </ClInclude>
-    <ClInclude Include="Controllers\HuePlusController\HuePlusController.h">
-      <Filter>Header Files\Controllers</Filter>
-    </ClInclude>
-    <ClInclude Include="net_port\net_port.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="RGBController\RGBController_HuePlus.h">
-      <Filter>Header Files\RGBController</Filter>
-    </ClInclude>
-    <ClInclude Include="RGBController\RGBController_RazerChromaSDK.h">
-      <Filter>Header Files\RGBController</Filter>
-    </ClInclude>
-  </ItemGroup>
-</Project>

OpenRGB.cpp

@@ -1,14 +1,12 @@
 /******************************************************************************************\
 *                                                                                          *
-*   OpenAuraSDK.cpp                                                                        *
+*   OpenRGB.cpp                                                                            *
 *                                                                                          *
-*       Functions for communicating with Asus Aura devices on Windows and Linux            *
+*       Functions for communicating with RGBController API devices on Windows and Linux    *
 *                                                                                          *
 \******************************************************************************************/
 
-#include "AuraController.h"
 #include "RGBController.h"
-#include "RGBController_AorusGPU.h"
 #include "i2c_smbus.h"
 #include <vector>
 #include <stdio.h>
@@ -16,7 +14,6 @@
 
 #ifdef WIN32
 
-#include <tchar.h>
 #include <regex>
 #include "i2c_smbus_piix4.h"
 #include "i2c_smbus_i801.h"
@@ -320,126 +317,26 @@ void DetectI2CBusses()
 
 #endif  /* WIN32 */
 
-
-/******************************************************************************************\
-*                                                                                          *
-*   DetectI2C                                                                              *
-*                                                                                          *
-*       Prints a list of all detected I2C addresses on the given bus                       *
-*                                                                                          *
-*           bus - pointer to i2c_smbus_interface to scan                                   *
-*           mode - one of AUTO, QUICK, READ, FUNC - method of access                       *
-*                                                                                          *
-*       Code adapted from i2cdetect.c from i2c-tools Linux package                         *
-*                                                                                          *
-\******************************************************************************************/
-
-#define MODE_AUTO   0
-#define MODE_QUICK  1
-#define MODE_READ   2
-#define MODE_FUNC   3
-
-std::string DetectI2C(i2c_smbus_interface * bus, int mode)
-{
-    int i, j;
-    int res;
-    int slave_addr;
-    char line[128];
-    std::string text;
-
-    sprintf(line, "     0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f\r\n");
-    text.append(line);
-
-    for (i = 0; i < 128; i += 16)
-    {
-        sprintf(line, "%02x: ", i);
-        text.append(line);
-
-        for (j = 0; j < 16; j++)
-        {
-            /* Set slave address */
-            slave_addr = i + j;
-
-            /* Probe this address */
-            switch (mode)
-            {
-            case MODE_QUICK:
-                res = bus->i2c_smbus_write_quick(slave_addr, I2C_SMBUS_WRITE);
-                break;
-            case MODE_READ:
-                res = bus->i2c_smbus_read_byte(slave_addr);
-                break;
-            default:
-                if ((i + j >= 0x30 && i + j <= 0x37)
-                 || (i + j >= 0x50 && i + j <= 0x5F))
-                    res = bus->i2c_smbus_read_byte(slave_addr);
-                else
-                    res = bus->i2c_smbus_write_quick(slave_addr, I2C_SMBUS_WRITE);
-                break;
-            }
-
-            if (res < 0)
-            {
-                sprintf(line, "-- ");
-                text.append(line);
-            }
-            else
-            {
-                sprintf(line, "%02x ", i + j);
-                text.append(line);
-            }
-        }
-        sprintf(line, "\r\n");
-        text.append(line);
-    }
-
-    return text;
-
-}   /* DetectI2C() */
-
-
-/******************************************************************************************\
-*                                                                                          *
-*   DumpAuraRegisters                                                                      *
-*                                                                                          *
-*       Dumps register values from an Aura device                                          *
-*                                                                                          *
-\******************************************************************************************/
-
-void DumpAuraRegisters(AuraController * controller)
-{
-    int i, j;
-
-    int start = 0x0000;
-
-    FILE* file = freopen("auradump.txt", "a", stdout);
-
-    printf("       0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f\r\n");
-
-    for (i = 0; i < 0xFFFF; i += 16)
-    {
-        printf("%04x: ", i + start);
-
-        for (j = 0; j < 16; j++)
-        {
-            printf("%02x ", controller->AuraRegisterRead(start + i + j));
-        }
-
-        printf("\r\n");
-    }
-
-    fclose(file);
-
-}   /* DumpAuraRegisters() */
-
 void DetectAuraControllers(std::vector<i2c_smbus_interface*> &busses, std::vector<RGBController*> &rgb_controllers);
 void DetectCorsairControllers(std::vector<i2c_smbus_interface*> &busses, std::vector<RGBController*> &rgb_controllers);
 void DetectCorsairProControllers(std::vector<i2c_smbus_interface*> &busses, std::vector<RGBController*> &rgb_controllers);
 void DetectHyperXControllers(std::vector<i2c_smbus_interface*> &busses, std::vector<RGBController*> &rgb_controllers);
+void DetectPatriotViperControllers(std::vector<i2c_smbus_interface*> &busses, std::vector<RGBController*> &rgb_controllers);
+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);
 void DetectE131Controllers(std::vector<RGBController*> &rgb_controllers);
+void DetectAMDWraithPrismControllers(std::vector<RGBController*>& rgb_controllers);
+void DetectAorusGPUControllers(std::vector<RGBController*> &rgb_controllers);
+void DetectMSI3ZoneControllers(std::vector<RGBController*>& rgb_controllers);
+void DetectPoseidonZRGBControllers(std::vector<RGBController*>& rgb_controllers);
+void DetectCorsairCmdrProControllers(std::vector<RGBController*> &rgb_controllers);
+void DetectCorsairNodeProControllers(std::vector<RGBController*> &rgb_controllers);
+void DetectFaustusControllers(std::vector<RGBController*> &rgb_controllers);
 
 /******************************************************************************************\
 *                                                                                          *
@@ -457,21 +354,35 @@ void DetectRGBControllers(void)
     DetectCorsairControllers(busses, rgb_controllers);
     DetectCorsairProControllers(busses, rgb_controllers);
     DetectHyperXControllers(busses, rgb_controllers);
+    DetectPatriotViperControllers(busses, rgb_controllers);
+    DetectPolychromeControllers(busses, rgb_controllers);
+    DetectRGBFusionControllers(busses, rgb_controllers);
 
     DetectLEDStripControllers(rgb_controllers);
+    DetectHue2Controllers(rgb_controllers);
+    DetectHuePlusControllers(rgb_controllers);
+
+    DetectAMDWraithPrismControllers(rgb_controllers);
+    DetectMSI3ZoneControllers(rgb_controllers);
+    DetectPoseidonZRGBControllers(rgb_controllers);
+    DetectCorsairCmdrProControllers(rgb_controllers);
+    DetectCorsairNodeProControllers(rgb_controllers);
     
+    DetectE131Controllers(rgb_controllers);
+
+    /*-------------------------------------*\
+    | Windows-only devices                  |
+    \*-------------------------------------*/
 #ifdef WIN32
     DetectRazerChromaSDKControllers(rgb_controllers);
+    //DetectAorusGPUControllers(rgb_controllers);
+
+    /*-------------------------------------*\
+    | Linux-only devices                    |
+    \*-------------------------------------*/
 #else
-    DetectE131Controllers(rgb_controllers);
     DetectOpenRazerControllers(rgb_controllers);
+    DetectFaustusControllers(rgb_controllers);
 #endif
 
-    //This is for testing Aorus GPU
-#if 0
-    RGBController_AorusGPU * aorus_rgb = new RGBController_AorusGPU();
-
-    rgb_controllers.push_back(aorus_rgb);
-#endif
-
-}
+}   /* DetectRGBControllers() */

OpenRGB.h

@@ -0,0 +1 @@
+void DetectRGBControllers();

OpenRGB.pro

@@ -0,0 +1,223 @@
+QT       += core gui
+
+greaterThan(QT_MAJOR_VERSION, 4): QT += widgets
+
+TARGET = OpenRGB
+TEMPLATE = app
+
+INCLUDEPATH +=                                                          \
+    dependencies/libe131/src/                                           \
+    i2c_smbus/                                                          \
+    i2c_tools/                                                          \
+    net_port/                                                           \
+    serial_port/                                                        \
+    Controllers/AMDWraithPrismController/                               \
+    Controllers/AuraController/                                         \
+    Controllers/CorsairController/                                      \
+    Controllers/CorsairCmdrProController/                               \
+    Controllers/CorsairNodeProController/                               \
+    Controllers/CorsairProController/                                   \
+    Controllers/Hue2Controller/                                         \
+    Controllers/HuePlusController/                                      \
+    Controllers/HyperXController/                                       \
+    Controllers/LEDStripController/                                     \
+    Controllers/MSI3ZoneController/                                     \
+    Controllers/PatriotViperController/                                 \
+    Controllers/PolychromeController/                                   \
+    Controllers/PoseidonZRGBController/                                 \
+    Controllers/RGBFusionController/                                    \
+    RGBController/                                                      \
+    qt/
+
+SOURCES +=                                                              \
+    dependencies/libe131/src/e131.c                                     \
+    main.cpp                                                            \
+    OpenRGB.cpp                                                         \
+    qt/OpenRGBDeviceInfoPage.cpp                                        \
+    qt/OpenRGBDevicePage.cpp                                            \
+    qt/OpenRGBDialog.cpp                                                \
+    i2c_smbus/i2c_smbus.cpp                                             \
+    i2c_tools/i2c_tools.cpp                                             \
+    net_port/net_port.cpp                                               \
+    qt/OpenRGBDialog2.cpp                                               \
+    qt/OpenRGBSystemInfoPage.cpp                                        \
+    qt/hsv.cpp                                                          \
+    serial_port/serial_port.cpp                                         \
+    Controllers/AMDWraithPrismController/AMDWraithPrismController.cpp   \
+    Controllers/AMDWraithPrismController/AMDWraithPrismControllerDetect.cpp \
+    Controllers/AuraController/AuraController.cpp                       \
+    Controllers/AuraController/AuraControllerDetect.cpp                 \
+    Controllers/CorsairController/CorsairController.cpp                 \
+    Controllers/CorsairController/CorsairControllerDetect.cpp           \
+    Controllers/CorsairCmdrProController/CorsairCmdrProController.cpp   \
+    Controllers/CorsairCmdrProController/CorsairCmdrProControllerDetect.cpp \
+    Controllers/CorsairNodeProController/CorsairNodeProController.cpp   \
+    Controllers/CorsairNodeProController/CorsairNodeProControllerDetect.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                   \
+    Controllers/HyperXController/HyperXControllerDetect.cpp             \
+    Controllers/LEDStripController/LEDStripController.cpp               \
+    Controllers/LEDStripController/LEDStripControllerDetect.cpp         \
+    Controllers/MSI3ZoneController/MSI3ZoneController.cpp               \
+    Controllers/MSI3ZoneController/MSI3ZoneControllerDetect.cpp         \
+    Controllers/PatriotViperController/PatriotViperController.cpp       \
+    Controllers/PatriotViperController/PatriotViperControllerDetect.cpp \
+    Controllers/PolychromeController/PolychromeController.cpp           \
+    Controllers/PolychromeController/PolychromeControllerDetect.cpp     \
+    Controllers/PoseidonZRGBController/PoseidonZRGBController.cpp       \
+    Controllers/PoseidonZRGBController/PoseidonZRGBControllerDetect.cpp \
+    Controllers/RGBFusionController/RGBFusionController.cpp             \
+    Controllers/RGBFusionController/RGBFusionControllerDetect.cpp       \
+    RGBController/RGBController.cpp                                     \
+    RGBController/E131ControllerDetect.cpp                              \
+    RGBController/RGBController_AMDWraithPrism.cpp                      \
+    RGBController/RGBController_Aura.cpp                                \
+    RGBController/RGBController_Corsair.cpp                             \
+    RGBController/RGBController_CorsairCmdrPro.cpp                      \
+    RGBController/RGBController_CorsairNodePro.cpp                      \
+    RGBController/RGBController_CorsairPro.cpp                          \
+    RGBController/RGBController_Hue2.cpp                                \
+    RGBController/RGBController_HuePlus.cpp                             \
+    RGBController/RGBController_HyperX.cpp                              \
+    RGBController/RGBController_E131.cpp                                \
+    RGBController/RGBController_LEDStrip.cpp                            \
+    RGBController/RGBController_MSI3Zone.cpp                            \
+    RGBController/RGBController_PatriotViper.cpp                        \
+    RGBController/RGBController_Polychrome.cpp                          \
+    RGBController/RGBController_PoseidonZRGB.cpp                        \
+    RGBController/RGBController_RGBFusion.cpp
+
+HEADERS +=                                                              \
+    qt/OpenRGBDeviceInfoPage.h                                          \
+    qt/OpenRGBDevicePage.h                                              \
+    qt/OpenRGBDialog.h                                                  \
+    i2c_smbus/i2c_smbus.h                                               \
+    i2c_tools/i2c_tools.h                                               \
+    net_port/net_port.h                                                 \
+    qt/OpenRGBDialog2.h                                                 \
+    qt/OpenRGBSystemInfoPage.h                                          \
+    serial_port/find_usb_serial_port.h                                  \
+    serial_port/serial_port.h                                           \
+    Controllers/AMDWraithPrismController/AMDWraithPrismController.h     \
+    Controllers/AuraController/AuraController.h                         \
+    Controllers/CorsairController/CorsairController.h                   \
+    Controllers/CorsairCmdrProController/CorsairCmdrProController.h     \
+    Controllers/CorsairNodeProController/CorsairNodeProController.h     \
+    Controllers/CorsairProController/CorsairProController.h             \
+    Controllers/Hue2Controller/Hue2Controller.h                         \
+    Controllers/HuePlusController/HuePlusController.h                   \
+    Controllers/HyperXController/HyperXController.h                     \
+    Controllers/LEDStripController/LEDStripController.h                 \
+    Controllers/MSI3ZoneController/MSI3ZoneController.h                 \
+    Controllers/PatriotViperController/PatriotViperController.h         \
+    Controllers/PolychromeController/PolychromeController.h             \
+    Controllers/PoseidonZRGBController/PoseidonZRGBController.h         \
+    Controllers/RGBFusionController/RGBFusionController.h               \
+    RGBController/RGBController.h                                       \
+    RGBController/RGBController_AMDWraithPrism.h                        \
+    RGBController/RGBController_Aura.h                                  \
+    RGBController/RGBController_Corsair.h                               \
+    RGBController/RGBController_CorsairCmdrPro.h                        \
+    RGBController/RGBController_CorsairNodePro.h                        \
+    RGBController/RGBController_CorsairPro.h                            \
+    RGBController/RGBController_E131.h                                  \
+    RGBController/RGBController_Hue2.h                                  \
+    RGBController/RGBController_HuePlus.h                               \
+    RGBController/RGBController_HyperX.h                                \
+    RGBController/RGBController_LEDStrip.h                              \
+    RGBController/RGBController_MSI3Zone.h                              \
+    RGBController/RGBController_PatriotViper.h                          \
+    RGBController/RGBController_Polychrome.h                            \
+    RGBController/RGBController_PoseidonZRGB.h                          \
+    RGBController/RGBController_RGBFusion.h
+
+RESOURCES += \
+    qt/resources.qrc
+
+FORMS += \
+    qt/OpenRGBDeviceInfoPage.ui \
+    qt/OpenRGBDevicePage.ui \
+    qt/OpenRGBDialog.ui \
+    qt/OpenRGBDialog2.ui \
+    qt/OpenRGBSystemInfoPage.ui
+
+#-----------------------------------------------
+# Windows specific project configuration
+#-----------------------------------------------
+win32:INCLUDEPATH +=                                                    \
+    dependencies/inpout32_1501/Win32/                                   \
+    dependencies/razer-chroma-2.9.0/inc                                 \
+    dependencies/libusb-1.0.22/include                                  \
+    dependencies/hidapi                                                 \
+    wmi/                                                                \
+
+win32:SOURCES +=                                                        \
+    i2c_smbus/i2c_smbus_i801.cpp                                        \
+    i2c_smbus/i2c_smbus_nct6775.cpp                                     \
+    i2c_smbus/i2c_smbus_piix4.cpp                                       \
+    serial_port/find_usb_serial_port_win.cpp                            \
+    wmi/wmi.cpp                                                         \
+    RGBController/AorusGPUDetect.cpp                                    \
+    RGBController/RGBController_AorusGPU.cpp                            \
+    RGBController/RazerChromaSDKDetect.cpp                              \
+    RGBController/RGBController_RazerChromaSDK.cpp                      \
+
+win32:HEADERS +=                                                        \
+    dependencies/inpout32_1501/Win32/inpout32.h                         \
+    i2c_smbus/i2c_smbus_i801.h                                          \
+    i2c_smbus/i2c_smbus_nct6775.h                                       \
+    i2c_smbus/i2c_smbus_piix4.h                                         \
+    wmi/wmi.h                                                           \
+    RGBController/RGBController_AorusGPU.h                              \
+    RGBController/RGBController_RazerChromaSDK.h                        \
+
+win32:LIBS +=                                                           \
+    -lws2_32                                                            \
+    -L"$$PWD/dependencies/inpout32_1501/Win32/" -linpout32              \
+    -L"$$PWD/dependencies/libusb-1.0.22/MS32/dll" -llibusb-1.0          \
+    -L"$$PWD/dependencies/hidapi-win/x86/" -lhidapi
+
+win32:DEFINES -=                                                        \
+    UNICODE
+
+win32:DEFINES +=                                                        \
+    _MBCS                                                               \
+    WIN32                                                               \
+    _CRT_SECURE_NO_WARNINGS                                             \
+    _WINSOCK_DEPRECATED_NO_WARNINGS                                     \
+    WIN32_LEAN_AND_MEAN
+
+#-----------------------------------------------
+# Linux specific project configuration
+#-----------------------------------------------
+unix:INCLUDEPATH +=                                                     \
+
+unix:HEADERS +=                                                         \
+    i2c_smbus/i2c_smbus_linux.h                                         \
+    RGBController/RGBController_Faustus.h                               \
+
+unix:LIBS +=                                                            \
+    -lusb-1.0                                                           \
+
+packagesExist(hidapi-libusb){
+    unix:LIBS += -lhidapi-libusb
+} else {
+    packagesExist(hidapi) {
+        unix:LIBS += -lhidapi
+    } else {
+        unix:LIBS += -lhidapi-libusb
+    }
+}
+
+
+unix:SOURCES +=                                                         \
+    i2c_smbus/i2c_smbus_linux.cpp                                       \
+    serial_port/find_usb_serial_port_linux.cpp                          \
+    RGBController/OpenRazerDetect.cpp                                   \
+    RGBController/RGBController_Faustus.cpp                             \
+    RGBController/RGBController_OpenRazer.cpp                           \

README.md

@@ -1,41 +1,41 @@
-# OpenAuraSDK
-##### This project is an open-source implementation of the Asus Aura RGB controller software.  It currently only supports a limited number of motherboard and RAM module lighting controllers.
+# OpenRGB (formerly OpenAuraSDK)
 
-## Supported Devices 
+The goal of this project is to create an easy-to-use open source software program and library for accessing and controlling RGB lights on various PC hardware including motherboards, RAM modules, graphics cards, cooling devices, and peripherals.
 
-Confirmed supported motherboards:
-  - ASUS PRIME X370 Pro
-  - ASUS PRIME X470 Pro
-  - ASUS PRIME Z270-A
-  - ASUS PRIME Z370-A
-  - ASUS ROG Strix Z370-E
-    
-Confirmed supported RGB RAM (except on X299):
-  - G.Skill Trident Z RGB
-  - Geil Super Luce
-  - TeamGroup Delta RGB
+This project originally focused only on ASUS Aura.  It was spun off of Keyboard Visualizer's AsusAuraWindows branch to learn more about the details behind the Aura protocol and to develop a more flexible, compatible, and reliable driver for Aura.  Our Aura implementation is now quite solid and supports multiple generations of Aura controller across both Intel and AMD platforms.  It also supports Aura-compatible controllers used across multiple manufacturers of RGB memory modules including G.Skill Trident Z RGB and others.  It is still lacking a few capabilities, namely saving settings to persist across reboots, but the core functionality of setting colors and modes is there.
 
-Experimental support in generic RGB testing branch:
-  - Corsair Vengeance RGB
-  - Corsair Vengeance Pro RGB
-  - HyperX Predator RGB
+After getting a solid Aura implementation, the project branched out into other manufacturers and categories of RGB devices.  A major focus was to develop a software API that could reliably represent as many RGB devices as possible, exposing their various modes and describing their LED layouts via zones, that was generic enough to write a user application without specifically targeting any one manufacturer.  To this extent, the generic_rgb_interface_test branch was created which became the foundation of OpenRGB.  The goal of OpenRGB is to both develop new drivers for unsupported devices and integrate existing open source drivers for devices that do have some sort of open support.  The goal is to be the one-stop solution to open source RGB lighting control!
+
+## Supported Devices
+
+See the [Project Wiki](https://gitlab.com/CalcProgrammer1/OpenRGB/-/wikis/home) for the current list of supported devices.
 
 ## Installation
 #### Windows
-  1. Download the latest Visual Studio Community Edition and open the `.sln`.
-  2. Build the project for `x86` Architecture. The InpOut32 library I use does not support x64.
-  3. Copy InpOut32.dll from dependencies to the same path as OpenAuraSDK.exe.
-
-**You may have to retarget the project to the latest version of the Windows SDK and build tools and stuff.**
+  1. Download the latest Visual Studio Community Edition and Qt Creator.
+  2. Update the submodules: git submodule update --init --recursive
+  3. Open the OpenRGB_Win.pro project.
+  4. Build the project for `x86` Architecture. The InpOut32 library I use does not support x64.
+  5. Copy InpOut32.dll from dependencies to the same path as OpenAuraSDK.exe along with the Qt libraries.
 
 **You must run the application as Administrator the first time to allow InpOut32 to set up.  It can be run as a normal user afterwards**
 
 #### Linux:
-  1. Either open the project using QT Creator or build it using qmake.
+  1. Either open the project using QT Creator or build it using qmake.  You will need the libusb-1.0-0 (or equivalent) and libhidapi development packages from your distribution's package manager installed.
     
-         cd OpenAuraSDK
-         qmake OpenAuraSDK.pro
-         make
+    * sudo apt install qt5-default libusb-1.0-0-dev libhidapi-dev
+
+    * git clone https://gitlab.com/CalcProgrammer1/OpenRGB
+
+    * cd OpenRGB
+
+    * git submodule update --init --recursive
+
+    * qmake OpenRGB.pro
+
+    * make -j8
+    
+    * ./OpenRGB
      
 
   2. Allow access to SMBus:<br>

RGBController/AorusGPUDetect.cpp

@@ -0,0 +1,21 @@
+#include "RGBController.h"
+#include "RGBController_AorusGPU.h"
+#include <vector>
+#include <stdio.h>
+#include <stdlib.h>
+
+
+/******************************************************************************************\
+*                                                                                          *
+*   DetectAorusGPUControllers                                                              *
+*                                                                                          *
+*       Detect devices supported by the Aorus GPU driver                                   *
+*                                                                                          *                                                                                          *
+\******************************************************************************************/
+
+void DetectAorusGPUControllers(std::vector<RGBController*> &rgb_controllers)
+{
+    RGBController_AorusGPU * aorus_rgb = new RGBController_AorusGPU();
+
+    rgb_controllers.push_back(aorus_rgb);
+}   /* DetectLEDStripControllers() */

RGBController/E131ControllerDetect.cpp

@@ -13,6 +13,8 @@
 #ifndef WIN32
 #include <unistd.h>
 #include <dirent.h>
+#else
+#include <windows.h>
 #endif
 
 #ifndef WIN32
@@ -167,4 +169,4 @@ void DetectE131Controllers(std::vector<RGBController*> &rgb_controllers)
             }
     }
 
-}   /* DetectLEDStripControllers() */
+}   /* DetectE131Controllers() */

RGBController/OpenRazerDetect.cpp

@@ -22,7 +22,6 @@ void DetectOpenRazerControllers(std::vector<RGBController*> &rgb_controllers)
     char driver_path[512];
     DIR *dir;
     struct dirent *ent;
-    int test_fd;
     bool done = false;
     int driver_to_read = 0;
 
@@ -97,7 +96,6 @@ void DetectOpenRazerControllers(std::vector<RGBController*> &rgb_controllers)
                 }
                 else
                 {
-                    int device_type;
                     char device_string[1024];
                     strcpy(device_string, driver_path);
                     strcat(device_string, ent->d_name);
@@ -124,4 +122,4 @@ void DetectOpenRazerControllers(std::vector<RGBController*> &rgb_controllers)
         driver_to_read++;
     }
 
-}   /* DetectOpenRazerControllers() */
+}   /* DetectOpenRazerControllers() */

RGBController/RGBController.cpp

@@ -0,0 +1,58 @@
+#include "RGBController.h"
+
+RGBColor RGBController::GetLED(int led)
+{
+    if(led < colors.size())
+    {
+        return(colors[led]);
+    }
+    else
+    {
+        return(0x00000000);
+    }
+}
+
+void RGBController::SetLED(int led, RGBColor color)
+{
+    if(led < colors.size())
+    {
+        colors[led] = color;
+
+        UpdateSingleLED(led);
+    }
+}
+
+void RGBController::SetAllLEDs(RGBColor color)
+{
+    for(int led = 0; led < colors.size(); led++)
+    {
+        colors[led] = color;
+    }
+
+    UpdateLEDs();
+}
+
+void RGBController::SetAllZoneLEDs(int zone, RGBColor color)
+{
+    for (std::size_t x = 0; x < zones[zone].map.size(); x++)
+    {
+        for (std::size_t y = 0; y < zones[zone].map[x].size(); y++)
+        {
+            colors[zones[zone].map[x][y]] = color;
+        }
+    }
+
+    UpdateZoneLEDs(zone);
+}
+
+int RGBController::GetMode()
+{
+    return(active_mode);
+}
+
+void RGBController::SetMode(int mode)
+{
+    active_mode = mode;
+
+    UpdateMode();
+}

RGBController/RGBController.h

@@ -20,16 +20,61 @@ typedef unsigned int RGBColor;
 
 #define ToRGBColor(r, g, b) ((b << 16) | (g << 8) | (r))
 
+/*------------------------------------------------------------------*\
+| Mode Flags                                                         |
+\*------------------------------------------------------------------*/
+enum
+{
+    MODE_FLAG_HAS_SPEED         = (1 << 0), /* Mode has speed parameter         */
+    MODE_FLAG_HAS_DIRECTION_LR  = (1 << 1), /* Mode has left/right parameter    */
+    MODE_FLAG_HAS_DIRECTION_UD  = (1 << 2), /* Mode has up/down parameter       */
+    MODE_FLAG_HAS_DIRECTION_HV  = (1 << 3), /* Mode has horiz/vert parameter    */
+    MODE_FLAG_HAS_BRIGHTNESS    = (1 << 4), /* Mode has brightness parameter    */
+    MODE_FLAG_HAS_COLOR         = (1 << 5), /* Mode has custom color parameter  */
+    MODE_FLAG_RANDOM_COLOR      = (1 << 6), /* Mode has random color option     */
+    MODE_FLAG_PER_LED_COLOR     = (1 << 7), /* Mode uses device LED colors      */
+};
+
+/*------------------------------------------------------------------*\
+| Mode Directions                                                    |
+\*------------------------------------------------------------------*/
+enum
+{
+    MODE_DIRECTION_LEFT         = 0,        /* Mode direction left              */
+    MODE_DIRECTION_RIGHT        = 1,        /* Mode direction right             */
+    MODE_DIRECTION_UP           = 2,        /* Mode direction up                */
+    MODE_DIRECTION_DOWN         = 3,        /* Mode direction down              */
+    MODE_DIRECTION_HORIZONTAL   = 4,        /* Mode direction horizontal        */
+    MODE_DIRECTION_VERTICAL     = 5,        /* Mode direction vertical          */
+};
+
+/*------------------------------------------------------------------*\
+| Mode Type                                                          |
+\*------------------------------------------------------------------*/
+typedef struct
+{
+    /*--------------------------------------------------------------*\
+    | Mode Information                                               |
+    \*--------------------------------------------------------------*/
+    std::string         name;   /* Mode name                        */
+    int                 value;  /* Device-specific mode value       */
+    unsigned int        flags;  /* Mode flags bitfield              */
+    unsigned int        speed_min;  /* speed minimum value          */
+    unsigned int        speed_max;  /* speed maximum value          */
+    
+    /*--------------------------------------------------------------*\
+    | Mode Settings                                                  |
+    \*--------------------------------------------------------------*/
+    unsigned int        speed;  /* Mode speed parameter value       */
+    unsigned int        direction;  /* Mode direction value         */
+    bool                random; /* Random color mode enabled        */
+} mode;
+
 typedef struct
 {
     std::string         name;   /* LED name         */
 } led;
 
-typedef struct
-{
-    std::string         name;   /* Mode name        */
-} mode;
-
 typedef int zone_type;
 
 enum
@@ -39,6 +84,22 @@ enum
     ZONE_TYPE_MATRIX
 };
 
+typedef int device_type;
+
+enum
+{
+    DEVICE_TYPE_MOTHERBOARD,
+    DEVICE_TYPE_DRAM,
+    DEVICE_TYPE_GPU,
+    DEVICE_TYPE_COOLER,
+    DEVICE_TYPE_LEDSTRIP,
+    DEVICE_TYPE_KEYBOARD,
+    DEVICE_TYPE_MOUSE,
+    DEVICE_TYPE_MOUSEMAT,
+    DEVICE_TYPE_HEADSET,
+    DEVICE_TYPE_UNKNOWN
+};
+
 typedef struct
 {
     std::string         name;   /* Zone name        */
@@ -50,17 +111,38 @@ typedef struct
 class RGBController
 {
 public:
-    std::string             name;   /* controller name  */
-    std::vector<led>        leds;   /* LEDs             */
-    std::vector<zone>       zones;  /* Zones            */
-    std::vector<mode>       modes;  /* Modes            */
-    std::vector<RGBColor>   colors; /* Color buffer     */
+    std::string             name;           /* controller name          */
+    std::string             description;    /* controller description   */
+    std::string             version;        /* controller version       */
+    std::string             serial;         /* controller serial number */
+    std::string             location;       /* controller location      */
+    std::vector<led>        leds;           /* LEDs                     */
+    std::vector<zone>       zones;          /* Zones                    */
+    std::vector<mode>       modes;          /* Modes                    */
+    std::vector<RGBColor>   colors;         /* Color buffer             */
+    device_type             type;           /* device type              */
+    int                     active_mode = 0;/* active mode              */
 
-    virtual int  GetMode()         = 0;
-    virtual void SetMode(int mode) = 0;
-    virtual void SetCustomMode()   = 0;
-    virtual void SetAllLEDs(RGBColor color) = 0;
-	virtual void SetAllZoneLEDs(int zone, RGBColor color) = 0;
-	virtual void SetLED(int led, RGBColor color) = 0;
-    virtual void UpdateLEDs() = 0;
-};
+    virtual ~RGBController() = default;
+
+    /*---------------------------------------------------------*\
+    | Generic functions implemented in RGBController.cpp        |
+    \*---------------------------------------------------------*/
+    RGBColor                GetLED(int led);
+    void                    SetLED(int led, RGBColor color);
+    void                    SetAllLEDs(RGBColor color);
+    void                    SetAllZoneLEDs(int zone, RGBColor color);
+
+    int                     GetMode();
+    void                    SetMode(int mode);
+
+    /*---------------------------------------------------------*\
+    | Functions to be implemented in device implementation      |
+    \*---------------------------------------------------------*/
+    virtual void            UpdateLEDs()                                = 0;
+    virtual void            UpdateZoneLEDs(int zone)                    = 0;
+    virtual void            UpdateSingleLED(int led)                    = 0;
+
+    virtual void            SetCustomMode()                             = 0;
+    virtual void            UpdateMode()                                = 0;
+};

RGBController/RGBController_AMDWraithPrism.cpp

@@ -0,0 +1,214 @@
+/*-----------------------------------------*\
+|  RGBController_AMDWraithPrism.cpp         |
+|                                           |
+|  Generic RGB Interface for AMD Wraith     |
+|  Prism                                    |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 12/25/2019  |
+\*-----------------------------------------*/
+
+#include "RGBController_AMDWraithPrism.h"
+
+RGBController_AMDWraithPrism::RGBController_AMDWraithPrism(AMDWraithPrismController* wraith_ptr)
+{
+    wraith = wraith_ptr;
+
+    name = "AMD Wraith Prism";
+    type = DEVICE_TYPE_COOLER;
+    version = wraith->GetFirmwareVersionString();
+
+    mode Static;
+    Static.name   = "Static";
+    Static.value  = AMD_WRAITH_PRISM_EFFECT_CHANNEL_STATIC;
+    Static.flags  = MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR;
+    Static.random = false;
+    modes.push_back(Static);
+
+    mode Breathing;
+    Breathing.name      = "Breathing";
+    Breathing.value     = AMD_WRAITH_PRISM_EFFECT_CHANNEL_BREATHING;
+    Breathing.flags     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR | MODE_FLAG_RANDOM_COLOR;
+    Breathing.speed_min = AMD_WRAITH_PRISM_SPEED_SLOWEST;
+    Breathing.speed_max = AMD_WRAITH_PRISM_SPEED_FASTEST;
+    Breathing.random    = false;
+    Breathing.speed     = AMD_WRAITH_PRISM_SPEED_NORMAL;
+    modes.push_back(Breathing);
+
+    mode ColorCycle;
+    ColorCycle.name      = "Color Cycle";
+    ColorCycle.value     = AMD_WRAITH_PRISM_EFFECT_CHANNEL_COLOR_CYCLE;
+    ColorCycle.flags     = MODE_FLAG_HAS_SPEED;
+    ColorCycle.speed_min = AMD_WRAITH_PRISM_SPEED_SLOWEST;
+    ColorCycle.speed_max = AMD_WRAITH_PRISM_SPEED_FASTEST;
+    ColorCycle.random    = false;
+    ColorCycle.speed     = AMD_WRAITH_PRISM_SPEED_NORMAL;
+    modes.push_back(ColorCycle);
+
+    mode Rainbow;
+    Rainbow.name      = "Rainbow";
+    Rainbow.value     = AMD_WRAITH_PRISM_EFFECT_CHANNEL_RAINBOW;
+    Rainbow.flags     = MODE_FLAG_HAS_SPEED;
+    Rainbow.speed_min = AMD_WRAITH_PRISM_SPEED_SLOWEST;
+    Rainbow.speed_max = AMD_WRAITH_PRISM_SPEED_FASTEST;
+    Rainbow.random    = false;
+    Rainbow.speed     = AMD_WRAITH_PRISM_SPEED_NORMAL;
+    modes.push_back(Rainbow);
+
+    mode Bounce;
+    Bounce.name      = "Bounce";
+    Bounce.value     = AMD_WRAITH_PRISM_EFFECT_CHANNEL_BOUNCE;
+    Bounce.flags     = MODE_FLAG_HAS_SPEED;
+    Bounce.speed_min = AMD_WRAITH_PRISM_SPEED_SLOWEST;
+    Bounce.speed_max = AMD_WRAITH_PRISM_SPEED_FASTEST;
+    Bounce.random    = true;
+    Bounce.speed     = AMD_WRAITH_PRISM_SPEED_NORMAL;
+    modes.push_back(Bounce);
+
+    mode Chase;
+    Chase.name      = "Chase";
+    Chase.value     = AMD_WRAITH_PRISM_EFFECT_CHANNEL_CHASE;
+    Chase.flags     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR | MODE_FLAG_RANDOM_COLOR;
+    Chase.speed_min = AMD_WRAITH_PRISM_SPEED_SLOWEST;
+    Chase.speed_max = AMD_WRAITH_PRISM_SPEED_FASTEST;
+    Chase.random    = false;
+    Chase.speed     = AMD_WRAITH_PRISM_SPEED_NORMAL;
+    modes.push_back(Chase);
+
+    mode Swirl;
+    Swirl.name      = "Swirl";
+    Swirl.value     = AMD_WRAITH_PRISM_EFFECT_CHANNEL_SWIRL;
+    Swirl.flags     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR | MODE_FLAG_RANDOM_COLOR;
+    Swirl.speed_min = AMD_WRAITH_PRISM_SPEED_SLOWEST;
+    Swirl.speed_max = AMD_WRAITH_PRISM_SPEED_FASTEST;
+    Swirl.random    = false;
+    Swirl.speed     = AMD_WRAITH_PRISM_SPEED_NORMAL;
+    modes.push_back(Swirl);
+
+    led logo_led;
+    logo_led.name = "Logo";
+    leds.push_back(logo_led);
+    colors.push_back(0x00000000);
+
+    zone logo_zone;
+    logo_zone.name = "Logo";
+    logo_zone.type = ZONE_TYPE_SINGLE;
+    std::vector<int> logo_zone_map;
+    logo_zone_map.push_back(0);
+    logo_zone.map.push_back(logo_zone_map);
+    zones.push_back(logo_zone);
+
+    led fan_led;
+    fan_led.name = "Fan";
+    leds.push_back(fan_led);
+    colors.push_back(0x00000000);
+
+    zone fan_zone;
+    fan_zone.name = "Fan";
+    fan_zone.type = ZONE_TYPE_SINGLE;
+    std::vector<int> fan_zone_map;
+    fan_zone_map.push_back(1);
+    fan_zone.map.push_back(fan_zone_map);
+    zones.push_back(fan_zone);
+
+    led ring_led;
+    ring_led.name = "Ring";
+    leds.push_back(ring_led);
+    colors.push_back(0x00000000);
+
+    zone ring_zone;
+    ring_zone.name = "Ring";
+    ring_zone.type = ZONE_TYPE_SINGLE;
+    std::vector<int> ring_zone_map;
+    ring_zone_map.push_back(2);
+    ring_zone.map.push_back(ring_zone_map);
+    zones.push_back(ring_zone);   
+}
+
+RGBController_AMDWraithPrism::~RGBController_AMDWraithPrism()
+{
+
+}
+
+void RGBController_AMDWraithPrism::UpdateLEDs()
+{
+    unsigned char red = RGBGetRValue(colors[0]);
+    unsigned char grn = RGBGetGValue(colors[0]);
+    unsigned char blu = RGBGetBValue(colors[0]);
+    wraith->SetLogoColor(red, grn, blu);
+
+    red = RGBGetRValue(colors[1]);
+    grn = RGBGetGValue(colors[1]);
+    blu = RGBGetBValue(colors[1]);
+    wraith->SetFanColor(red, grn, blu);
+
+    red = RGBGetRValue(colors[2]);
+    grn = RGBGetGValue(colors[2]);
+    blu = RGBGetBValue(colors[2]);
+    wraith->SetRingColor(red, grn, blu);
+}
+
+void RGBController_AMDWraithPrism::UpdateZoneLEDs(int zone)
+{
+    RGBColor      color = colors[zone];
+    unsigned char red   = RGBGetRValue(color);
+    unsigned char grn   = RGBGetGValue(color);
+    unsigned char blu   = RGBGetBValue(color);
+
+    if(zone == 0)
+    {
+        wraith->SetLogoColor(red, grn, blu);
+    }
+    else if(zone == 1)
+    {
+        wraith->SetFanColor(red, grn, blu);
+    }
+    else if(zone == 2)
+    {
+        wraith->SetRingColor(red, grn, blu);
+    }
+}
+
+void RGBController_AMDWraithPrism::UpdateSingleLED(int led)
+{
+    UpdateZoneLEDs(led);
+}
+
+void RGBController_AMDWraithPrism::SetCustomMode()
+{
+    SetMode(0);
+}
+
+void RGBController_AMDWraithPrism::UpdateMode()
+{
+    wraith->SetRingMode(modes[active_mode].value, modes[active_mode].speed, modes[active_mode].direction, modes[active_mode].random);
+
+    switch(modes[active_mode].value)
+    {
+        case AMD_WRAITH_PRISM_EFFECT_CHANNEL_COLOR_CYCLE:
+        case AMD_WRAITH_PRISM_EFFECT_CHANNEL_RAINBOW:
+        case AMD_WRAITH_PRISM_EFFECT_CHANNEL_BOUNCE:
+            wraith->SetFanMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_COLOR_CYCLE, modes[active_mode].speed, modes[active_mode].random);
+            wraith->SetLogoMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_COLOR_CYCLE, modes[active_mode].speed, modes[active_mode].random);
+            break;
+        
+        case AMD_WRAITH_PRISM_EFFECT_CHANNEL_BREATHING:
+            wraith->SetFanMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_BREATHING, modes[active_mode].speed, modes[active_mode].random);
+            wraith->SetLogoMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_BREATHING, modes[active_mode].speed, modes[active_mode].random);
+            break;
+
+        default:
+            if(modes[active_mode].random)
+            {
+                wraith->SetFanMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_COLOR_CYCLE, modes[active_mode].speed, modes[active_mode].random);
+                wraith->SetLogoMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_COLOR_CYCLE, modes[active_mode].speed, modes[active_mode].random);
+            }
+            else
+            {
+                wraith->SetFanMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_STATIC, modes[active_mode].speed, modes[active_mode].random);
+                wraith->SetLogoMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_STATIC, modes[active_mode].speed, modes[active_mode].random);
+            }
+            break;
+    }
+
+    UpdateLEDs();
+}

RGBController/RGBController_AMDWraithPrism.h

@@ -0,0 +1,28 @@
+/*-----------------------------------------*\
+|  RGBController_AMDWraithPrism.h           |
+|                                           |
+|  Generic RGB Interface for AMD Wraith     |
+|  Prism                                    |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 12/25/2019  |
+\*-----------------------------------------*/
+
+#pragma once
+#include "RGBController.h"
+#include "AMDWraithPrismController.h"
+
+class RGBController_AMDWraithPrism : public RGBController
+{
+public:
+    RGBController_AMDWraithPrism(AMDWraithPrismController* wraith_ptr);
+    ~RGBController_AMDWraithPrism();
+    void        UpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        SetCustomMode();
+    void        UpdateMode();
+
+private:
+    AMDWraithPrismController*   wraith;
+};

RGBController/RGBController_AorusGPU.cpp

@@ -20,23 +20,9 @@ static unsigned char data[] = { 0x8E, 0x00, 0x00, 0x00,
                                 0x64, 0x00, 0x00, 0x00,
                                 0x01, 0x00, 0x00, 0x00 };
 
-int RGBController_AorusGPU::GetMode()
-{
-    return(0);
-}
-
-void RGBController_AorusGPU::SetMode(int mode)
-{
-
-}
-
-void RGBController_AorusGPU::SetCustomMode()
-{
-
-}
-
-void RGBController_AorusGPU::SetAllLEDs(RGBColor color)
+void RGBController_AorusGPU::UpdateLEDs()
 {
+    RGBColor color = colors[0];
     data[9] = RGBGetRValue(color);
     data[10] = RGBGetGValue(color);
     data[11] = RGBGetBValue(color);
@@ -44,27 +30,20 @@ void RGBController_AorusGPU::SetAllLEDs(RGBColor color)
     GvWriteI2C(0x00000000, data, 0x00000000);
 }
 
-void RGBController_AorusGPU::SetAllZoneLEDs(int zone, RGBColor color)
+void RGBController_AorusGPU::UpdateZoneLEDs(int zone)
 {
-    data[9] = RGBGetRValue(color);
-    data[10] = RGBGetGValue(color);
-    data[11] = RGBGetBValue(color);
-
-    GvWriteI2C(0x00000000, data, 0x00000000);
+    UpdateLEDs();
 }
 
-void RGBController_AorusGPU::SetLED(int led, RGBColor color)
+void RGBController_AorusGPU::UpdateSingleLED(int led)
 {
-    data[9] = RGBGetRValue(color);
-    data[10] = RGBGetGValue(color);
-    data[11] = RGBGetBValue(color);
-
-    GvWriteI2C(0x00000000, data, 0x00000000);
+    UpdateLEDs();
 }
 
 RGBController_AorusGPU::RGBController_AorusGPU()
 {
     name = "Aorus GPU";
+    type = DEVICE_TYPE_GPU;
 
     handle = LoadLibrary("GvDisplay.dll");
 
@@ -75,6 +54,8 @@ RGBController_AorusGPU::RGBController_AorusGPU()
     GvFreeDispLib();
     GvInitDispLib();
 
+    colors.push_back(0x00000000);
+
     mode aorus_mode;
     aorus_mode.name = "Static";
     modes.push_back(aorus_mode);
@@ -89,4 +70,14 @@ RGBController_AorusGPU::RGBController_AorusGPU()
     aorus_zone_map.push_back(0);
     aorus_zone.map.push_back(aorus_zone_map);
     zones.push_back(aorus_zone);
+}
+
+void RGBController_AorusGPU::SetCustomMode()
+{
+
+}
+
+void RGBController_AorusGPU::UpdateMode()
+{
+
 }

RGBController/RGBController_AorusGPU.h

@@ -19,15 +19,15 @@ class RGBController_AorusGPU : public RGBController
 {
 public:
     RGBController_AorusGPU();
-    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();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        SetCustomMode();
+    void        UpdateMode();
 
 private:
     _GvWriteI2C GvWriteI2C;
     _GvFreeDispLib GvFreeDispLib;
     _GvInitDispLib GvInitDispLib;
-};
+};

RGBController/RGBController_Aura.cpp

@@ -9,93 +9,49 @@
 
 #include "RGBController_Aura.h"
 
-int RGBController_Aura::GetMode()
+int RGBController_Aura::GetDeviceMode()
 {
+    int  dev_mode = aura->AuraRegisterRead(AURA_REG_MODE);
+    bool random   = false;
+
+    switch(dev_mode)
+    {
+    case AURA_MODE_SPECTRUM_CYCLE_CHASE:
+        dev_mode = AURA_MODE_CHASE;
+        random   = true;
+        break;
+
+    case AURA_MODE_SPECTRUM_CYCLE_BREATHING:
+        dev_mode = AURA_MODE_BREATHING;
+        random   = true;
+        break;
+
+    case AURA_MODE_SPECTRUM_CYCLE_CHASE_FADE:
+        dev_mode = AURA_MODE_CHASE_FADE;
+        random   = true;
+        break;
+    }
+
     if (aura->AuraRegisterRead(AURA_REG_DIRECT))
     {
-        return(0);
+        dev_mode = 0xFFFF;
     }
-    else
-    {
-        return(aura->AuraRegisterRead(AURA_REG_MODE) + 1);
-    }
-}
 
-void RGBController_Aura::SetMode(int mode)
-{
-    if (mode == 0)
+    for(int mode = 0; mode < modes.size(); mode++)
     {
-        aura->SetDirect(true);
-    }
-    else
-    {
-        aura->SetMode(mode - 1);
-        aura->SetDirect(false);
-    }
-}
-
-void RGBController_Aura::SetCustomMode()
-{
-    aura->SetDirect(true);
-}
-
-void RGBController_Aura::SetAllLEDs(RGBColor color)
-{
-    unsigned char red = RGBGetRValue(color);
-    unsigned char grn = RGBGetGValue(color);
-    unsigned char blu = RGBGetBValue(color);
-
-    if (GetMode() == 0)
-    {
-        aura->SetAllColorsDirect(red, grn, blu);
-    }
-    else
-    {
-        aura->SetAllColorsEffect(red, grn, blu);
-    }
-}
-
-void RGBController_Aura::SetAllZoneLEDs(int zone, RGBColor color)
-{
-    unsigned char red = RGBGetRValue(color);
-    unsigned char grn = RGBGetGValue(color);
-    unsigned char blu = RGBGetBValue(color);
-
-    for (int x = 0; x < zones[zone].map.size(); x++)
-    {
-        for (int y = 0; y < zones[zone].map[x].size(); y++)
+        if(modes[mode].value == dev_mode)
         {
-            if (GetMode() == 0)
-            {
-                aura->SetLEDColorDirect(zones[zone].map[x][y], red, grn, blu);
-            }
-            else
-            {
-                aura->SetLEDColorEffect(zones[zone].map[x][y], red, grn, blu);
-            }
+            active_mode        = mode;
+            modes[mode].random = random;
         }
     }
-}
 
-void RGBController_Aura::SetLED(int led, RGBColor color)
-{
-    unsigned char red = RGBGetRValue(color);
-    unsigned char grn = RGBGetGValue(color);
-    unsigned char blu = RGBGetBValue(color);
-
-    if (GetMode() == 0)
-    {
-        aura->SetLEDColorDirect(led, red, grn, blu);
-    }
-    else
-    {
-        aura->SetLEDColorEffect(led, red, grn, blu);
-    }
+    return(active_mode);
 }
 
 void RGBController_Aura::UpdateLEDs()
 {
-    for(int led = 0; led < colors.size(); led++)
+    for(std::size_t led = 0; led < colors.size(); led++)
     {
         unsigned char red = RGBGetRValue(colors[led]);
         unsigned char grn = RGBGetGValue(colors[led]);
@@ -112,38 +68,129 @@ void RGBController_Aura::UpdateLEDs()
     }
 }
 
+void RGBController_Aura::UpdateZoneLEDs(int zone)
+{
+    for (std::size_t x = 0; x < zones[zone].map.size(); x++)
+    {
+        for (std::size_t y = 0; y < zones[zone].map[x].size(); y++)
+        {
+            int           led   = zones[zone].map[x][y];
+            RGBColor      color = colors[led];
+            unsigned char red   = RGBGetRValue(color);
+            unsigned char grn   = RGBGetGValue(color);
+            unsigned char blu   = RGBGetBValue(color);
+
+            if (GetMode() == 0)
+            {
+                aura->SetLEDColorDirect(led, red, grn, blu);
+            }
+            else
+            {
+                aura->SetLEDColorEffect(led, red, grn, blu);
+            }
+        }
+    }
+}
+
+void RGBController_Aura::UpdateSingleLED(int led)
+{
+    RGBColor color    = colors[led];
+    unsigned char red = RGBGetRValue(color);
+    unsigned char grn = RGBGetGValue(color);
+    unsigned char blu = RGBGetBValue(color);
+
+    if (GetMode() == 0)
+    {
+        aura->SetLEDColorDirect(led, red, grn, blu);
+    }
+    else
+    {
+        aura->SetLEDColorEffect(led, red, grn, blu);
+    }
+}
+
 RGBController_Aura::RGBController_Aura(AuraController * aura_ptr)
 {
     std::vector<unsigned char> aura_channels;
 
     aura = aura_ptr;
 
-    name = aura->GetDeviceName();
-
-    mode aura_modes[AURA_NUMBER_MODES + 1];
-
-    aura_modes[0].name = "Direct";
-    aura_modes[1].name = "Off";
-    aura_modes[2].name = "Static";
-    aura_modes[3].name = "Breathing";
-    aura_modes[4].name = "Flashing";
-    aura_modes[5].name = "Spectrum Cycle";
-    aura_modes[6].name = "Rainbow";
-    aura_modes[7].name = "Spectrum Cycle Breathing";
-    aura_modes[8].name = "Chase Fade";
-    aura_modes[9].name = "Spectrum Cycle Chase Fade";
-    aura_modes[10].name = "Chase";
-    aura_modes[11].name = "Spectrum Cycle Chase";
-    aura_modes[12].name = "Spectrum Cycle Wave";
-    aura_modes[13].name = "Chase Rainbow Pulse";
-    aura_modes[14].name = "Random Flicker";
-
-    for (int i = 0; i < (AURA_NUMBER_MODES + 1); i++)
+    version = aura->GetDeviceName();
+    location = aura->GetDeviceLocation();
+    if((version.find("DIMM_LED") != std::string::npos) || (version.find("AUDA") != std::string::npos) )
     {
-        modes.push_back(aura_modes[i]);
+        type = DEVICE_TYPE_DRAM;
+        name = "ASUS Aura DRAM";
+    }
+    else
+    {
+        type = DEVICE_TYPE_MOTHERBOARD;
+        name = "ASUS Aura Motherboard";
     }
 
-    for (int i = 0; i < aura->GetLEDCount(); i++)
+    mode Direct;
+    Direct.name  = "Direct";
+    Direct.value = 0xFFFF;
+    Direct.flags = MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR;
+    modes.push_back(Direct);
+
+    mode Off;
+    Off.name  = "Off";
+    Off.value = AURA_MODE_OFF;
+    Off.flags = 0;
+    modes.push_back(Off);
+
+    mode Static;
+    Static.name  = "Static";
+    Static.value = AURA_MODE_STATIC;
+    Static.flags = MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR;
+    modes.push_back(Static);
+    
+    mode Breathing;
+    Breathing.name  = "Breathing";
+    Breathing.value = AURA_MODE_BREATHING;
+    Breathing.flags = MODE_FLAG_HAS_COLOR | MODE_FLAG_RANDOM_COLOR | MODE_FLAG_PER_LED_COLOR;
+    modes.push_back(Breathing);
+
+    mode Flashing;
+    Flashing.name  = "Flashing";
+    Flashing.value = AURA_MODE_FLASHING;
+    Flashing.flags = MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR;
+    modes.push_back(Flashing);
+
+    mode SpectrumCycle;
+    SpectrumCycle.name  = "Spectrum Cycle";
+    SpectrumCycle.value = AURA_MODE_SPECTRUM_CYCLE;
+    SpectrumCycle.flags = 0;
+    modes.push_back(SpectrumCycle);
+
+    mode Rainbow;
+    Rainbow.name  = "Rainbow";
+    Rainbow.value = AURA_MODE_RAINBOW;
+    Rainbow.flags = 0;
+    modes.push_back(Rainbow);
+
+    mode ChaseFade;
+    ChaseFade.name  = "Chase Fade";
+    ChaseFade.value = AURA_MODE_CHASE_FADE;
+    ChaseFade.flags = MODE_FLAG_HAS_COLOR | MODE_FLAG_RANDOM_COLOR | MODE_FLAG_PER_LED_COLOR;
+    modes.push_back(ChaseFade);
+
+    mode Chase;
+    Chase.name  = "Chase";
+    Chase.value = AURA_MODE_CHASE;
+    Chase.flags = MODE_FLAG_HAS_COLOR | MODE_FLAG_RANDOM_COLOR | MODE_FLAG_PER_LED_COLOR;
+    modes.push_back(Chase);
+
+    mode RandomFlicker;
+    RandomFlicker.name  = "Random Flicker";
+    RandomFlicker.value = AURA_MODE_RANDOM_FLICKER;
+    RandomFlicker.flags = 0;
+    modes.push_back(RandomFlicker);
+
+    colors.resize(aura->GetLEDCount());
+
+    for (std::size_t i = 0; i < aura->GetLEDCount(); i++)
     {
         aura_channels.push_back(aura->GetChannel(i));
 
@@ -152,18 +199,23 @@ RGBController_Aura::RGBController_Aura(AuraController * aura_ptr)
         new_led->name = aura->GetChannelName(i);
 
         leds.push_back(*new_led);
-        colors.push_back(0x00000000);
+
+        unsigned char red = aura->GetLEDRed(i);
+        unsigned char grn = aura->GetLEDGreen(i);
+        unsigned char blu = aura->GetLEDBlue(i);
+
+        colors[i] = ToRGBColor(red, grn, blu);
     }
 
     std::vector<unsigned char> aura_zones;
 
     // Search through all LEDs and create zones for each channel type
-    for (int i = 0; i < aura_channels.size(); i++)
+    for (std::size_t i = 0; i < aura_channels.size(); i++)
     {
         bool matched = false;
 
         // Search through existing zones to make sure we don't create a duplicate zone
-        for (int j = 0; j < aura_zones.size(); j++)
+        for (std::size_t j = 0; j < aura_zones.size(); j++)
         {
             if (aura_channels[i] == aura_zones[j])
             {
@@ -181,7 +233,7 @@ RGBController_Aura::RGBController_Aura(AuraController * aura_ptr)
             new_zone->name = aura->GetChannelName(i);
 
             // Find all LEDs with this channel type and add them to zone
-            for (int j = 0; j < aura->GetLEDCount(); j++)
+            for (std::size_t j = 0; j < aura->GetLEDCount(); j++)
             {
                 if (aura->GetChannel(j) == aura_channels[i])
                 {
@@ -200,4 +252,43 @@ RGBController_Aura::RGBController_Aura(AuraController * aura_ptr)
             zones.push_back(*new_zone);
         }
     }
+
+    // Initialize active mode
+    active_mode = GetDeviceMode();
+}
+
+void RGBController_Aura::SetCustomMode()
+{
+    SetMode(0);
+}
+
+void RGBController_Aura::UpdateMode()
+{
+    if (modes[active_mode].value == 0xFFFF)
+    {
+        aura->SetDirect(true);
+    }
+    else
+    {
+        int new_mode = modes[active_mode].value;
+
+        if(modes[active_mode].random == true)
+        {
+            switch(new_mode)
+            {
+            case AURA_MODE_CHASE:
+                new_mode = AURA_MODE_SPECTRUM_CYCLE_CHASE;
+                break;
+            case AURA_MODE_BREATHING:
+                new_mode = AURA_MODE_SPECTRUM_CYCLE_BREATHING;
+                break;
+            case AURA_MODE_CHASE_FADE:
+                new_mode = AURA_MODE_SPECTRUM_CYCLE_CHASE_FADE;
+                break;
+            }
+        }
+
+        aura->SetMode(new_mode);
+        aura->SetDirect(false);
+    }
 }

RGBController/RGBController_Aura.h

@@ -16,14 +16,15 @@ class RGBController_Aura : public RGBController
 {
 public:
     RGBController_Aura(AuraController* aura_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();
+    void        UpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        SetCustomMode();
+    void        UpdateMode();
 
 private:
     AuraController* aura;
-};
+
+    int         GetDeviceMode();
+};

RGBController/RGBController_Corsair.cpp

@@ -9,57 +9,24 @@
 
 #include "RGBController_Corsair.h"
 
-int RGBController_Corsair::GetMode()
-{
-    return(CORSAIR_VENGEANCE_RGB_MODE_SINGLE);
-}
-
-void RGBController_Corsair::SetMode(int mode)
-{
-    corsair->SetMode(mode);
-}
-
-void RGBController_Corsair::SetCustomMode()
-{
-
-}
-
-void RGBController_Corsair::SetAllLEDs(RGBColor color)
-{
-    unsigned char red = RGBGetRValue(color);
-    unsigned char grn = RGBGetGValue(color);
-    unsigned char blu = RGBGetBValue(color);
-
-    corsair->SetAllColors(red, grn, blu);
-}
-
-void RGBController_Corsair::SetAllZoneLEDs(int zone, RGBColor color)
-{
-    unsigned char red = RGBGetRValue(color);
-    unsigned char grn = RGBGetGValue(color);
-    unsigned char blu = RGBGetBValue(color);
-
-    for (int x = 0; x < zones[zone].map.size(); x++)
-    {
-        for (int y = 0; y < zones[zone].map[x].size(); y++)
-        {
-            corsair->SetLEDColor(zones[zone].map[x][y], red, grn, blu);
-        }
-    }
-}
-
-void RGBController_Corsair::SetLED(int led, RGBColor color)
-{
-    unsigned char red = RGBGetRValue(color);
-    unsigned char grn = RGBGetGValue(color);
-    unsigned char blu = RGBGetBValue(color);
-
-    corsair->SetLEDColor(led, red, grn, blu);
-}
-
 void RGBController_Corsair::UpdateLEDs()
 {
+    RGBColor      color = colors[0];
+    unsigned char red   = RGBGetRValue(color);
+    unsigned char grn   = RGBGetGValue(color);
+    unsigned char blu   = RGBGetBValue(color);
 
+    corsair->SetLEDColor(red, grn, blu);
+}
+
+void RGBController_Corsair::UpdateZoneLEDs(int zone)
+{
+    UpdateLEDs();
+}
+
+void RGBController_Corsair::UpdateSingleLED(int led)
+{
+    UpdateLEDs();
 }
 
 RGBController_Corsair::RGBController_Corsair(CorsairController* corsair_ptr)
@@ -67,19 +34,29 @@ RGBController_Corsair::RGBController_Corsair(CorsairController* corsair_ptr)
     corsair = corsair_ptr;
 
     name = corsair->GetDeviceName();
+    location = corsair->GetDeviceLocation();
 
-    mode corsair_modes[CORSAIR_NUMBER_MODES];
+    type = DEVICE_TYPE_DRAM;
 
-    corsair_modes[0].name = "Static";
-    corsair_modes[1].name = "Fade";
-    corsair_modes[2].name = "Pulse";
+    mode Static;
+    Static.name  = "Static";
+    Static.value = CORSAIR_VENGEANCE_RGB_MODE_SINGLE;
+    Static.flags = MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR;
+    modes.push_back(Static);
 
-    for (int i = 0; i < CORSAIR_NUMBER_MODES; i++)
-    {
-        modes.push_back(corsair_modes[i]);
-    }
+    mode Fade;
+    Fade.name  = "Fade";
+    Fade.value = CORSAIR_VENGEANCE_RGB_MODE_FADE;
+    Fade.flags = MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR;
+    modes.push_back(Fade);
 
-    for (int i = 0; i < corsair->GetLEDCount(); i++)
+    mode Pulse;
+    Pulse.name  = "Pulse";
+    Pulse.value = CORSAIR_VENGEANCE_RGB_MODE_PULSE;
+    Pulse.flags = MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR;
+    modes.push_back(Pulse);
+
+    for (unsigned int i = 0; i < corsair->GetLEDCount(); i++)
     {
         led* new_led = new led();
 
@@ -96,7 +73,7 @@ RGBController_Corsair::RGBController_Corsair(CorsairController* corsair_ptr)
 
     std::vector<int> zone_row;
 
-    for (int i = 0; i < corsair->GetLEDCount(); i++)
+    for (unsigned int i = 0; i < corsair->GetLEDCount(); i++)
     {
         zone_row.push_back(i);
     }
@@ -104,4 +81,14 @@ RGBController_Corsair::RGBController_Corsair(CorsairController* corsair_ptr)
     new_zone.map.push_back(zone_row);
 
     zones.push_back(new_zone);
+}
+
+void RGBController_Corsair::SetCustomMode()
+{
+    SetMode(0);
+}
+
+void RGBController_Corsair::UpdateMode()
+{
+    corsair->SetMode(modes[active_mode].value);
 }

RGBController/RGBController_Corsair.h

@@ -16,14 +16,13 @@ class RGBController_Corsair : public RGBController
 {
 public:
     RGBController_Corsair(CorsairController* corsair_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();
+    void        UpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        SetCustomMode();
+    void        UpdateMode();
 
 private:
     CorsairController* corsair;
-};
+};

RGBController/RGBController_CorsairCmdrPro.cpp

@@ -0,0 +1,276 @@
+/*-----------------------------------------*\
+|  RGBController_CorsairCmdrPro.cpp         |
+|                                           |
+|  Generic RGB Interface for Corsair        |
+|  Commander Pro                            |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 1/16/2020   |
+\*-----------------------------------------*/
+
+#include "RGBController_CorsairCmdrPro.h"
+
+
+RGBController_CorsairCmdrPro::RGBController_CorsairCmdrPro(CorsairCmdrProController* corsair_ptr)
+{
+    corsair = corsair_ptr;
+
+    name = "Corsair Commander Pro";
+
+    type = DEVICE_TYPE_LEDSTRIP;
+    
+    mode Direct;
+    Direct.name  = "Direct";
+    Direct.value = 0xFFFF;
+    Direct.flags = MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR;
+    modes.push_back(Direct);
+
+    mode RainbowWave;
+    RainbowWave.name      = "Rainbow Wave";
+    RainbowWave.value     = CORSAIR_CMDR_PRO_MODE_RAINBOW_WAVE;
+    RainbowWave.flags     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
+    RainbowWave.speed_min = CORSAIR_CMDR_PRO_SPEED_SLOW;
+    RainbowWave.speed_max = CORSAIR_CMDR_PRO_SPEED_FAST;
+    RainbowWave.speed     = CORSAIR_CMDR_PRO_SPEED_MEDIUM;
+    RainbowWave.direction = MODE_DIRECTION_RIGHT;
+    modes.push_back(RainbowWave);
+
+    mode ColorShift;
+    ColorShift.name       = "Color Shift";
+    ColorShift.value      = CORSAIR_CMDR_PRO_MODE_COLOR_SHIFT;
+    ColorShift.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_COLOR | MODE_FLAG_RANDOM_COLOR;
+    ColorShift.speed_min  = CORSAIR_CMDR_PRO_SPEED_SLOW;
+    ColorShift.speed_max  = CORSAIR_CMDR_PRO_SPEED_FAST;
+    ColorShift.speed      = CORSAIR_CMDR_PRO_SPEED_MEDIUM;
+    modes.push_back(ColorShift);
+
+    mode ColorPulse;
+    ColorPulse.name      = "Color Pulse";
+    ColorPulse.value     = CORSAIR_CMDR_PRO_MODE_COLOR_PULSE;
+    ColorPulse.flags     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_COLOR | MODE_FLAG_RANDOM_COLOR;
+    ColorPulse.speed_min = CORSAIR_CMDR_PRO_SPEED_SLOW;
+    ColorPulse.speed_max = CORSAIR_CMDR_PRO_SPEED_FAST;
+    ColorPulse.speed     = CORSAIR_CMDR_PRO_SPEED_MEDIUM;
+    modes.push_back(ColorPulse);
+
+    mode ColorWave;
+    ColorWave.name      = "Color Wave";
+    ColorWave.value     = CORSAIR_CMDR_PRO_MODE_COLOR_WAVE;
+    ColorWave.flags     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_COLOR | MODE_FLAG_RANDOM_COLOR;
+    ColorWave.speed_min = CORSAIR_CMDR_PRO_SPEED_SLOW;
+    ColorWave.speed_max = CORSAIR_CMDR_PRO_SPEED_FAST;
+    ColorWave.speed     = CORSAIR_CMDR_PRO_SPEED_MEDIUM;
+    ColorWave.direction = MODE_DIRECTION_RIGHT;
+    modes.push_back(ColorWave);
+
+    mode Static;
+    Static.name  = "Static";
+    Static.value = CORSAIR_CMDR_PRO_MODE_STATIC;
+    Static.flags = MODE_FLAG_HAS_COLOR;
+    modes.push_back(Static);
+
+    mode Temperature;
+    Temperature.name  = "Temperature";
+    Temperature.value = CORSAIR_CMDR_PRO_MODE_TEMPERATURE;
+    Temperature.flags = MODE_FLAG_HAS_COLOR;
+    modes.push_back(Temperature);
+
+    mode Visor;
+    Visor.name      = "Visor";
+    Visor.value     = CORSAIR_CMDR_PRO_MODE_VISOR;
+    Visor.flags     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_COLOR | MODE_FLAG_RANDOM_COLOR;
+    Visor.speed_min = CORSAIR_CMDR_PRO_SPEED_SLOW;
+    Visor.speed_max = CORSAIR_CMDR_PRO_SPEED_FAST;
+    Visor.speed     = CORSAIR_CMDR_PRO_SPEED_MEDIUM;
+    modes.push_back(Visor);
+
+    mode Marquee;
+    Marquee.name      = "Marquee";
+    Marquee.value     = CORSAIR_CMDR_PRO_MODE_MARQUEE;
+    Marquee.flags     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_COLOR | MODE_FLAG_RANDOM_COLOR;
+    Marquee.speed_min = CORSAIR_CMDR_PRO_SPEED_SLOW;
+    Marquee.speed_max = CORSAIR_CMDR_PRO_SPEED_FAST;
+    Marquee.speed     = CORSAIR_CMDR_PRO_SPEED_MEDIUM;
+    Marquee.direction = MODE_DIRECTION_RIGHT;
+    modes.push_back(Marquee);
+
+    mode Blink;
+    Blink.name      = "Blink";
+    Blink.value     = CORSAIR_CMDR_PRO_MODE_BLINK;
+    Blink.flags     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_COLOR | MODE_FLAG_RANDOM_COLOR;
+    Blink.speed_min = CORSAIR_CMDR_PRO_SPEED_SLOW;
+    Blink.speed_max = CORSAIR_CMDR_PRO_SPEED_FAST;
+    Blink.speed     = CORSAIR_CMDR_PRO_SPEED_MEDIUM;
+    modes.push_back(Blink);
+
+    mode Sequential;
+    Sequential.name      = "Sequential";
+    Sequential.value     = CORSAIR_CMDR_PRO_MODE_SEQUENTIAL;
+    Sequential.flags     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_COLOR | MODE_FLAG_RANDOM_COLOR;
+    Sequential.speed_min = CORSAIR_CMDR_PRO_SPEED_SLOW;
+    Sequential.speed_max = CORSAIR_CMDR_PRO_SPEED_FAST;
+    Sequential.speed     = CORSAIR_CMDR_PRO_SPEED_MEDIUM;
+    Sequential.direction = MODE_DIRECTION_RIGHT;
+    modes.push_back(Sequential);
+
+    mode Rainbow;
+    Rainbow.name      = "Rainbow";
+    Rainbow.value     = CORSAIR_CMDR_PRO_MODE_RAINBOW;
+    Rainbow.flags     = MODE_FLAG_HAS_SPEED;
+    Rainbow.speed_min = CORSAIR_CMDR_PRO_SPEED_SLOW;
+    Rainbow.speed_max = CORSAIR_CMDR_PRO_SPEED_FAST;
+    Rainbow.speed     = CORSAIR_CMDR_PRO_SPEED_MEDIUM;
+    modes.push_back(Rainbow);
+
+    /*-------------------------------------------------*\
+    | Set size of colors array                          |
+    \*-------------------------------------------------*/
+    unsigned int led_count = 0;
+    for (unsigned int channel_idx = 0; channel_idx < CORSAIR_CMDR_PRO_NUM_CHANNELS; channel_idx++)
+    {
+        led_count += corsair->channel_leds[channel_idx];
+    }
+    colors.resize(led_count);
+
+    /*-------------------------------------------------*\
+    | Set zones and leds                                |
+    \*-------------------------------------------------*/
+    unsigned int led_idx = 0;
+    for (unsigned int channel_idx = 0; channel_idx < CORSAIR_CMDR_PRO_NUM_CHANNELS; channel_idx++)
+    {
+        if(corsair->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 = "Corsair 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 (unsigned int led_ch_idx = 0; led_ch_idx < corsair->channel_leds[channel_idx]; led_ch_idx++)
+            {
+                char led_idx_string[3];
+                sprintf(led_idx_string, "%d", led_ch_idx + 1);
+
+                led new_led;
+                new_led.name = "Corsair 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);
+
+                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);
+        }
+    }
+}
+
+void RGBController_CorsairCmdrPro::UpdateLEDs()
+{
+    for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
+    {
+        unsigned int channel = zones_channel[zone_idx];
+
+        std::vector<RGBColor> channel_colors;
+
+        for(std::size_t color = 0; color < colors.size(); color++)
+        {
+            if(leds_channel[color] == channel)
+            {
+                channel_colors.push_back(colors[color]);
+            }
+        }
+
+        if(channel_colors.size() > 0)
+        {
+            corsair->SetChannelLEDs(channel, channel_colors);
+        }
+    }
+}
+
+void RGBController_CorsairCmdrPro::UpdateZoneLEDs(int zone)
+{
+    unsigned int channel = zones_channel[zone];
+
+    std::vector<RGBColor> channel_colors;
+
+    for(std::size_t color = 0; color < colors.size(); color++)
+    {
+        if(leds_channel[color] == channel)
+        {
+            channel_colors.push_back(colors[color]);
+        }
+    }
+
+    if(channel_colors.size() > 0)
+    {
+        corsair->SetChannelLEDs(channel, channel_colors);
+    }
+}
+
+void RGBController_CorsairCmdrPro::UpdateSingleLED(int led)
+{
+    unsigned int channel = leds_channel[led];
+
+    std::vector<RGBColor> channel_colors;
+
+    for(std::size_t color = 0; color < colors.size(); color++)
+    {
+        if(leds_channel[color] == channel)
+        {
+            channel_colors.push_back(colors[color]);
+        }
+    }
+
+    if(channel_colors.size() > 0)
+    {
+        corsair->SetChannelLEDs(channel, channel_colors);
+    }
+}
+
+void RGBController_CorsairCmdrPro::SetCustomMode()
+{
+    SetMode(9);
+}
+
+void RGBController_CorsairCmdrPro::UpdateMode()
+{
+    if(modes[active_mode].value == 0xFFFF)
+    {
+        UpdateLEDs();
+    }
+    else
+    {
+        for(int channel = 0; channel < CORSAIR_CMDR_PRO_NUM_CHANNELS; channel++)
+        {
+            unsigned int direction = 0;
+
+            if(modes[active_mode].direction == MODE_DIRECTION_RIGHT)
+            {
+                direction = 1;
+            }
+
+            corsair->SetChannelEffect(channel,
+                                      modes[active_mode].value,
+                                      modes[active_mode].speed,
+                                      direction,
+                                      modes[active_mode].random,
+                                      RGBGetRValue(colors[0]),
+                                      RGBGetGValue(colors[0]),
+                                      RGBGetBValue(colors[0]),
+                                      RGBGetRValue(colors[1]),
+                                      RGBGetGValue(colors[1]),
+                                      RGBGetBValue(colors[1]));
+        }
+    }
+}

RGBController/RGBController_CorsairCmdrPro.h

@@ -0,0 +1,30 @@
+/*-----------------------------------------*\
+|  RGBController_CorsairCmdrPro.h           |
+|                                           |
+|  Generic RGB Interface for Corsair        |
+|  Commander Pro                            |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 1/16/2020   |
+\*-----------------------------------------*/
+
+#pragma once
+#include "RGBController.h"
+#include "serial_port.h"
+#include "CorsairCmdrProController.h"
+
+class RGBController_CorsairCmdrPro : public RGBController
+{
+public:
+    RGBController_CorsairCmdrPro(CorsairCmdrProController* corsair_ptr);
+    void        UpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        SetCustomMode();
+    void        UpdateMode();
+
+private:
+    CorsairCmdrProController*   corsair;
+    std::vector<unsigned int>   leds_channel;
+    std::vector<unsigned int>   zones_channel;
+};

RGBController/RGBController_CorsairNodePro.cpp

@@ -0,0 +1,276 @@
+/*-----------------------------------------*\
+|  RGBController_CorsairNodePro.cpp         |
+|                                           |
+|  Generic RGB Interface for Corsair        |
+|  Lighting Node Pro                        |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 1/12/2020   |
+\*-----------------------------------------*/
+
+#include "RGBController_CorsairNodePro.h"
+
+
+RGBController_CorsairNodePro::RGBController_CorsairNodePro(CorsairNodeProController* corsair_ptr)
+{
+    corsair = corsair_ptr;
+
+    name = "Corsair Lighting Node Pro";
+
+    type = DEVICE_TYPE_LEDSTRIP;
+
+    mode Direct;
+    Direct.name  = "Direct";
+    Direct.value = 0xFFFF;
+    Direct.flags = MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR;
+    modes.push_back(Direct);
+
+    mode RainbowWave;
+    RainbowWave.name      = "Rainbow Wave";
+    RainbowWave.value     = CORSAIR_CMDR_PRO_MODE_RAINBOW_WAVE;
+    RainbowWave.flags     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
+    RainbowWave.speed_min = CORSAIR_CMDR_PRO_SPEED_SLOW;
+    RainbowWave.speed_max = CORSAIR_CMDR_PRO_SPEED_FAST;
+    RainbowWave.speed     = CORSAIR_CMDR_PRO_SPEED_MEDIUM;
+    RainbowWave.direction = MODE_DIRECTION_RIGHT;
+    modes.push_back(RainbowWave);
+
+    mode ColorShift;
+    ColorShift.name       = "Color Shift";
+    ColorShift.value      = CORSAIR_CMDR_PRO_MODE_COLOR_SHIFT;
+    ColorShift.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_COLOR | MODE_FLAG_RANDOM_COLOR;
+    ColorShift.speed_min  = CORSAIR_CMDR_PRO_SPEED_SLOW;
+    ColorShift.speed_max  = CORSAIR_CMDR_PRO_SPEED_FAST;
+    ColorShift.speed      = CORSAIR_CMDR_PRO_SPEED_MEDIUM;
+    modes.push_back(ColorShift);
+
+    mode ColorPulse;
+    ColorPulse.name      = "Color Pulse";
+    ColorPulse.value     = CORSAIR_CMDR_PRO_MODE_COLOR_PULSE;
+    ColorPulse.flags     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_COLOR | MODE_FLAG_RANDOM_COLOR;
+    ColorPulse.speed_min = CORSAIR_CMDR_PRO_SPEED_SLOW;
+    ColorPulse.speed_max = CORSAIR_CMDR_PRO_SPEED_FAST;
+    ColorPulse.speed     = CORSAIR_CMDR_PRO_SPEED_MEDIUM;
+    modes.push_back(ColorPulse);
+
+    mode ColorWave;
+    ColorWave.name      = "Color Wave";
+    ColorWave.value     = CORSAIR_CMDR_PRO_MODE_COLOR_WAVE;
+    ColorWave.flags     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_COLOR | MODE_FLAG_RANDOM_COLOR;
+    ColorWave.speed_min = CORSAIR_CMDR_PRO_SPEED_SLOW;
+    ColorWave.speed_max = CORSAIR_CMDR_PRO_SPEED_FAST;
+    ColorWave.speed     = CORSAIR_CMDR_PRO_SPEED_MEDIUM;
+    ColorWave.direction = MODE_DIRECTION_RIGHT;
+    modes.push_back(ColorWave);
+
+    mode Static;
+    Static.name  = "Static";
+    Static.value = CORSAIR_CMDR_PRO_MODE_STATIC;
+    Static.flags = MODE_FLAG_HAS_COLOR;
+    modes.push_back(Static);
+
+    mode Temperature;
+    Temperature.name  = "Temperature";
+    Temperature.value = CORSAIR_CMDR_PRO_MODE_TEMPERATURE;
+    Temperature.flags = MODE_FLAG_HAS_COLOR;
+    modes.push_back(Temperature);
+
+    mode Visor;
+    Visor.name      = "Visor";
+    Visor.value     = CORSAIR_CMDR_PRO_MODE_VISOR;
+    Visor.flags     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_COLOR | MODE_FLAG_RANDOM_COLOR;
+    Visor.speed_min = CORSAIR_CMDR_PRO_SPEED_SLOW;
+    Visor.speed_max = CORSAIR_CMDR_PRO_SPEED_FAST;
+    Visor.speed     = CORSAIR_CMDR_PRO_SPEED_MEDIUM;
+    modes.push_back(Visor);
+
+    mode Marquee;
+    Marquee.name      = "Marquee";
+    Marquee.value     = CORSAIR_CMDR_PRO_MODE_MARQUEE;
+    Marquee.flags     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_COLOR | MODE_FLAG_RANDOM_COLOR;
+    Marquee.speed_min = CORSAIR_CMDR_PRO_SPEED_SLOW;
+    Marquee.speed_max = CORSAIR_CMDR_PRO_SPEED_FAST;
+    Marquee.speed     = CORSAIR_CMDR_PRO_SPEED_MEDIUM;
+    Marquee.direction = MODE_DIRECTION_RIGHT;
+    modes.push_back(Marquee);
+
+    mode Blink;
+    Blink.name      = "Blink";
+    Blink.value     = CORSAIR_CMDR_PRO_MODE_BLINK;
+    Blink.flags     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_COLOR | MODE_FLAG_RANDOM_COLOR;
+    Blink.speed_min = CORSAIR_CMDR_PRO_SPEED_SLOW;
+    Blink.speed_max = CORSAIR_CMDR_PRO_SPEED_FAST;
+    Blink.speed     = CORSAIR_CMDR_PRO_SPEED_MEDIUM;
+    modes.push_back(Blink);
+
+    mode Sequential;
+    Sequential.name      = "Sequential";
+    Sequential.value     = CORSAIR_CMDR_PRO_MODE_SEQUENTIAL;
+    Sequential.flags     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_COLOR | MODE_FLAG_RANDOM_COLOR;
+    Sequential.speed_min = CORSAIR_CMDR_PRO_SPEED_SLOW;
+    Sequential.speed_max = CORSAIR_CMDR_PRO_SPEED_FAST;
+    Sequential.speed     = CORSAIR_CMDR_PRO_SPEED_MEDIUM;
+    Sequential.direction = MODE_DIRECTION_RIGHT;
+    modes.push_back(Sequential);
+
+    mode Rainbow;
+    Rainbow.name      = "Rainbow";
+    Rainbow.value     = CORSAIR_CMDR_PRO_MODE_RAINBOW;
+    Rainbow.flags     = MODE_FLAG_HAS_SPEED;
+    Rainbow.speed_min = CORSAIR_CMDR_PRO_SPEED_SLOW;
+    Rainbow.speed_max = CORSAIR_CMDR_PRO_SPEED_FAST;
+    Rainbow.speed     = CORSAIR_CMDR_PRO_SPEED_MEDIUM;
+    modes.push_back(Rainbow);
+    
+    /*-------------------------------------------------*\
+    | Set size of colors array                          |
+    \*-------------------------------------------------*/
+    unsigned int led_count = 0;
+    for (unsigned int channel_idx = 0; channel_idx < CORSAIR_NODE_PRO_NUM_CHANNELS; channel_idx++)
+    {
+        led_count += corsair->channel_leds[channel_idx];
+    }
+    colors.resize(led_count);
+
+    /*-------------------------------------------------*\
+    | Set zones and leds                                |
+    \*-------------------------------------------------*/
+    unsigned int led_idx = 0;
+    for (unsigned int channel_idx = 0; channel_idx < CORSAIR_NODE_PRO_NUM_CHANNELS; channel_idx++)
+    {
+        if(corsair->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 = "Corsair 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 (unsigned int led_ch_idx = 0; led_ch_idx < corsair->channel_leds[channel_idx]; led_ch_idx++)
+            {
+                char led_idx_string[3];
+                sprintf(led_idx_string, "%d", led_ch_idx + 1);
+
+                led new_led;
+                new_led.name = "Corsair 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);
+
+                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);
+        }
+    }
+}
+
+void RGBController_CorsairNodePro::UpdateLEDs()
+{
+    for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
+    {
+        unsigned int channel = zones_channel[zone_idx];
+
+        std::vector<RGBColor> channel_colors;
+
+        for(std::size_t color = 0; color < colors.size(); color++)
+        {
+            if(leds_channel[color] == channel)
+            {
+                channel_colors.push_back(colors[color]);
+            }
+        }
+
+        if(channel_colors.size() > 0)
+        {
+            corsair->SetChannelLEDs(channel, channel_colors);
+        }
+    }
+}
+
+void RGBController_CorsairNodePro::UpdateZoneLEDs(int zone)
+{
+    unsigned int channel = zones_channel[zone];
+
+    std::vector<RGBColor> channel_colors;
+
+    for(std::size_t color = 0; color < colors.size(); color++)
+    {
+        if(leds_channel[color] == channel)
+        {
+            channel_colors.push_back(colors[color]);
+        }
+    }
+
+    if(channel_colors.size() > 0)
+    {
+        corsair->SetChannelLEDs(channel, channel_colors);
+    }
+}
+
+void RGBController_CorsairNodePro::UpdateSingleLED(int led)
+{
+    unsigned int channel = leds_channel[led];
+
+    std::vector<RGBColor> channel_colors;
+
+    for(std::size_t color = 0; color < colors.size(); color++)
+    {
+        if(leds_channel[color] == channel)
+        {
+            channel_colors.push_back(colors[color]);
+        }
+    }
+
+    if(channel_colors.size() > 0)
+    {
+        corsair->SetChannelLEDs(channel, channel_colors);
+    }
+}
+
+void RGBController_CorsairNodePro::SetCustomMode()
+{
+    SetMode(9);
+}
+
+void RGBController_CorsairNodePro::UpdateMode()
+{
+    if(modes[active_mode].value == 0xFFFF)
+    {
+        UpdateLEDs();
+    }
+    else
+    {
+        for(int channel = 0; channel < CORSAIR_CMDR_PRO_NUM_CHANNELS; channel++)
+        {
+            unsigned int direction = 0;
+
+            if(modes[active_mode].direction == MODE_DIRECTION_RIGHT)
+            {
+                direction = 1;
+            }
+
+            corsair->SetChannelEffect(channel,
+                                      modes[active_mode].value,
+                                      modes[active_mode].speed,
+                                      direction,
+                                      modes[active_mode].random,
+                                      RGBGetRValue(colors[0]),
+                                      RGBGetGValue(colors[0]),
+                                      RGBGetBValue(colors[0]),
+                                      RGBGetRValue(colors[1]),
+                                      RGBGetGValue(colors[1]),
+                                      RGBGetBValue(colors[1]));
+        }
+    }
+}

RGBController/RGBController_CorsairNodePro.h

@@ -0,0 +1,30 @@
+/*-----------------------------------------*\
+|  RGBController_CorsairNodePro.h           |
+|                                           |
+|  Generic RGB Interface for Corsair        |
+|  Lighting Node Pro                        |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 1/12/2020   |
+\*-----------------------------------------*/
+
+#pragma once
+#include "RGBController.h"
+#include "serial_port.h"
+#include "CorsairNodeProController.h"
+
+class RGBController_CorsairNodePro : public RGBController
+{
+public:
+    RGBController_CorsairNodePro(CorsairNodeProController* corsair_ptr);
+    void        UpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        SetCustomMode();
+    void        UpdateMode();
+
+private:
+    CorsairNodeProController*   corsair;
+    std::vector<unsigned int>   leds_channel;
+    std::vector<unsigned int>   zones_channel;
+};

RGBController/RGBController_CorsairPro.cpp

@@ -9,127 +9,161 @@
 
 #include "RGBController_CorsairPro.h"
 
-int RGBController_CorsairPro::GetMode()
+void RGBController_CorsairPro::UpdateLEDs()
 {
-    return(0);
-}
-
-void RGBController_CorsairPro::SetMode(int mode)
-{
-    switch (mode)
+    for (std::size_t led = 0; led < colors.size(); led++)
     {
-    case 0:
-        corsair->SetEffect(CORSAIR_PRO_MODE_COLOR_SHIFT);
-        break;
-    case 1:
-        corsair->SetEffect(CORSAIR_PRO_MODE_COLOR_PULSE);
-        break;
-    case 2:
-        corsair->SetEffect(CORSAIR_PRO_MODE_RAINBOW_WAVE);
-        break;
-    case 3:
-        corsair->SetEffect(CORSAIR_PRO_MODE_COLOR_WAVE);
-        break;
-    case 4:
-        corsair->SetEffect(CORSAIR_PRO_MODE_VISOR);
-        break;
-    case 5:
-        corsair->SetEffect(CORSAIR_PRO_MODE_RAIN);
-        break;
-    case 6:
-        corsair->SetEffect(CORSAIR_PRO_MODE_MARQUEE);
-        break;
-    case 7:
-        corsair->SetEffect(CORSAIR_PRO_MODE_RAINBOW);
-        break;
-    case 8:
-        corsair->SetEffect(CORSAIR_PRO_MODE_SEQUENTIAL);
-        break;
-    case 9:
-        corsair->SetEffect(CORSAIR_PRO_MODE_STATIC);
-        break;
-    }
-}
-
-void RGBController_CorsairPro::SetCustomMode()
-{
-    corsair->SetCustom();
-}
-
-void RGBController_CorsairPro::SetAllLEDs(RGBColor color)
-{
-    unsigned char red = RGBGetRValue(color);
-    unsigned char grn = RGBGetGValue(color);
-    unsigned char blu = RGBGetBValue(color);
-
-    corsair->SetAllColors(red, grn, blu);
-    corsair->ApplyColors();
-}
-
-void RGBController_CorsairPro::SetAllZoneLEDs(int zone, RGBColor color)
-{
-    unsigned char red = RGBGetRValue(color);
-    unsigned char grn = RGBGetGValue(color);
-    unsigned char blu = RGBGetBValue(color);
-
-    for (int x = 0; x < zones[zone].map.size(); x++)
-    {
-        for (int y = 0; y < zones[zone].map[x].size(); y++)
-        {
-            corsair->SetLEDColor(zones[zone].map[x][y], red, grn, blu);
-        }
+        RGBColor      color = colors[led];
+        unsigned char red   = RGBGetRValue(color);
+        unsigned char grn   = RGBGetGValue(color);
+        unsigned char blu   = RGBGetBValue(color);
+        corsair->SetLEDColor(led, red, grn, blu);
     }
 
     corsair->ApplyColors();
 }
 
-void RGBController_CorsairPro::SetLED(int led, RGBColor color)
+void RGBController_CorsairPro::UpdateZoneLEDs(int zone)
 {
-    unsigned char red = RGBGetRValue(color);
-    unsigned char grn = RGBGetGValue(color);
-    unsigned char blu = RGBGetBValue(color);
+    UpdateLEDs();
+}
+
+void RGBController_CorsairPro::UpdateSingleLED(int led)
+{
+    RGBColor      color = colors[led];
+    unsigned char red   = RGBGetRValue(color);
+    unsigned char grn   = RGBGetGValue(color);
+    unsigned char blu   = RGBGetBValue(color);
 
     corsair->SetLEDColor(led, red, grn, blu);
     corsair->ApplyColors();
 }
 
-void RGBController_CorsairPro::UpdateLEDs()
-{
-
-}
-
 RGBController_CorsairPro::RGBController_CorsairPro(CorsairProController* corsair_ptr)
 {
     corsair = corsair_ptr;
 
     name = corsair->GetDeviceName();
+    location = corsair->GetDeviceLocation();
 
-    mode corsair_modes[CORSAIR_PRO_NUMBER_MODES];
+    type = DEVICE_TYPE_DRAM;
 
-    corsair_modes[0].name = "Color Shift";
-    corsair_modes[1].name = "Color Pulse";
-    corsair_modes[2].name = "Rainbow Wave";
-    corsair_modes[3].name = "Color Wave";
-    corsair_modes[4].name = "Visor";
-    corsair_modes[5].name = "Rain";
-    corsair_modes[6].name = "Marquee";
-    corsair_modes[7].name = "Rainbow";
-    corsair_modes[8].name = "Sequential";
-    corsair_modes[9].name = "Static";
+    mode ColorShift;
+    ColorShift.name      = "Color Shift";
+    ColorShift.value     = CORSAIR_PRO_MODE_COLOR_SHIFT;
+    ColorShift.flags     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_COLOR | MODE_FLAG_RANDOM_COLOR;
+    ColorShift.speed_min = CORSAIR_PRO_SPEED_SLOW;
+    ColorShift.speed_max = CORSAIR_PRO_SPEED_FAST;
+    ColorShift.random    = false;
+    ColorShift.speed     = CORSAIR_PRO_SPEED_SLOW;
+    modes.push_back(ColorShift);
 
-    for (int i = 0; i < CORSAIR_PRO_NUMBER_MODES; i++)
-    {
-        modes.push_back(corsair_modes[i]);
-    }
+    mode ColorPulse;
+    ColorPulse.name      = "Color Pulse";
+    ColorPulse.value     = CORSAIR_PRO_MODE_COLOR_PULSE;
+    ColorPulse.flags     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_COLOR | MODE_FLAG_RANDOM_COLOR;
+    ColorPulse.speed_min = CORSAIR_PRO_SPEED_SLOW;
+    ColorPulse.speed_max = CORSAIR_PRO_SPEED_FAST;
+    ColorPulse.random    = false;
+    ColorPulse.speed     = CORSAIR_PRO_SPEED_SLOW;
+    modes.push_back(ColorPulse);
 
-    for (int i = 0; i < corsair->GetLEDCount(); i++)
+    mode RainbowWave;
+    RainbowWave.name      = "Rainbow Wave";
+    RainbowWave.value     = CORSAIR_PRO_MODE_RAINBOW_WAVE;
+    RainbowWave.flags     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_DIRECTION_UD;
+    RainbowWave.speed_min = CORSAIR_PRO_SPEED_SLOW;
+    RainbowWave.speed_max = CORSAIR_PRO_SPEED_FAST;
+    RainbowWave.random    = false;
+    RainbowWave.speed     = CORSAIR_PRO_SPEED_SLOW;
+    RainbowWave.direction = MODE_DIRECTION_DOWN;
+    modes.push_back(RainbowWave);
+
+    mode ColorWave;
+    ColorWave.name      = "Color Wave";
+    ColorWave.value     = CORSAIR_PRO_MODE_COLOR_WAVE;
+    ColorWave.flags     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_DIRECTION_UD | MODE_FLAG_HAS_COLOR | MODE_FLAG_RANDOM_COLOR;
+    ColorWave.speed_min = CORSAIR_PRO_SPEED_SLOW;
+    ColorWave.speed_max = CORSAIR_PRO_SPEED_FAST;
+    ColorWave.random    = false;
+    ColorWave.speed     = CORSAIR_PRO_SPEED_SLOW;
+    ColorWave.direction = MODE_DIRECTION_DOWN;
+    modes.push_back(ColorWave); 
+    
+    mode Visor;
+    Visor.name      = "Visor";
+    Visor.value     = CORSAIR_PRO_MODE_VISOR;
+    Visor.flags     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_HV | MODE_FLAG_HAS_COLOR | MODE_FLAG_RANDOM_COLOR;
+    Visor.speed_min = CORSAIR_PRO_SPEED_SLOW;
+    Visor.speed_max = CORSAIR_PRO_SPEED_FAST;
+    Visor.random    = false;
+    Visor.speed     = CORSAIR_PRO_SPEED_SLOW;
+    Visor.direction = MODE_DIRECTION_VERTICAL;
+    modes.push_back(Visor);
+
+    mode Rain;
+    Rain.name      = "Rain";
+    Rain.value     = CORSAIR_PRO_MODE_RAIN;
+    Rain.flags     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_UD | MODE_FLAG_HAS_COLOR | MODE_FLAG_RANDOM_COLOR;
+    Rain.speed_min = CORSAIR_PRO_SPEED_SLOW;
+    Rain.speed_max = CORSAIR_PRO_SPEED_FAST;
+    Rain.random    = false;
+    Rain.speed     = CORSAIR_PRO_SPEED_SLOW;
+    Rain.direction = MODE_DIRECTION_DOWN;
+    modes.push_back(Rain);
+
+    mode Marquee;
+    Marquee.name      = "Marquee";
+    Marquee.value     = CORSAIR_PRO_MODE_MARQUEE;
+    Marquee.flags     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_COLOR;
+    Marquee.speed_min = CORSAIR_PRO_SPEED_SLOW;
+    Marquee.speed_max = CORSAIR_PRO_SPEED_FAST;
+    Marquee.random    = false;
+    Marquee.speed     = CORSAIR_PRO_SPEED_SLOW;
+    modes.push_back(Marquee);
+    
+    mode Rainbow;
+    Rainbow.name      = "Rainbow";
+    Rainbow.value     = CORSAIR_PRO_MODE_RAINBOW;
+    Rainbow.flags     = MODE_FLAG_HAS_SPEED;
+    Rainbow.speed_min = CORSAIR_PRO_SPEED_SLOW;
+    Rainbow.speed_max = CORSAIR_PRO_SPEED_FAST;
+    Rainbow.random    = false;
+    Rainbow.speed     = CORSAIR_PRO_SPEED_SLOW;
+    modes.push_back(Rainbow);
+    
+    mode Sequential;
+    Sequential.name      = "Sequential";
+    Sequential.value     = CORSAIR_PRO_MODE_SEQUENTIAL;
+    Sequential.flags     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_UD | MODE_FLAG_HAS_COLOR | MODE_FLAG_RANDOM_COLOR;
+    Sequential.speed_min = CORSAIR_PRO_SPEED_SLOW;
+    Sequential.speed_max = CORSAIR_PRO_SPEED_FAST;
+    Sequential.random    = false;
+    Sequential.speed     = CORSAIR_PRO_SPEED_SLOW;
+    Sequential.direction = MODE_DIRECTION_DOWN;
+    modes.push_back(Sequential);
+
+    mode Static;
+    Static.name      = "Static";
+    Static.value     = CORSAIR_PRO_MODE_STATIC;
+    Static.flags     = MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR;
+    Static.speed_min = 0;
+    Static.speed_max = 0;
+    Static.random    = false;
+    Static.speed     = 0;
+    modes.push_back(Static);
+
+    active_mode = 9;
+
+    colors.resize(corsair->GetLEDCount());
+
+    for (unsigned int i = 0; i < corsair->GetLEDCount(); i++)
     {
         led* new_led = new led();
 
         new_led->name = "Corsair Pro LED";
 
         leds.push_back(*new_led);
-        colors.push_back(0x00000000);
     }
 
     zone new_zone;
@@ -139,7 +173,7 @@ RGBController_CorsairPro::RGBController_CorsairPro(CorsairProController* corsair
 
     std::vector<int> zone_row;
 
-    for (int i = 0; i < corsair->GetLEDCount(); i++)
+    for (unsigned int i = 0; i < corsair->GetLEDCount(); i++)
     {
         zone_row.push_back(i);
     }
@@ -147,4 +181,47 @@ RGBController_CorsairPro::RGBController_CorsairPro(CorsairProController* corsair
     new_zone.map.push_back(zone_row);
 
     zones.push_back(new_zone);
+}
+
+void RGBController_CorsairPro::SetCustomMode()
+{
+    SetMode(9);
+}
+
+void RGBController_CorsairPro::UpdateMode()
+{
+    unsigned int corsair_direction;
+
+    switch(modes[active_mode].direction)
+    {
+        case MODE_DIRECTION_LEFT:
+            corsair_direction = CORSAIR_PRO_DIRECTION_LEFT;
+            break;
+        case MODE_DIRECTION_RIGHT:
+            corsair_direction = CORSAIR_PRO_DIRECTION_RIGHT;
+            break;
+        case MODE_DIRECTION_UP:
+            corsair_direction = CORSAIR_PRO_DIRECTION_UP;
+            break;
+        case MODE_DIRECTION_DOWN:
+            corsair_direction = CORSAIR_PRO_DIRECTION_DOWN;
+            break;
+        case MODE_DIRECTION_HORIZONTAL:
+            corsair_direction = CORSAIR_PRO_DIRECTION_HORIZONTAL;
+            break;
+        case MODE_DIRECTION_VERTICAL:
+            corsair_direction = CORSAIR_PRO_DIRECTION_VERTICAL;
+            break;
+    }
+
+    corsair->SetEffect(modes[active_mode].value,
+                       modes[active_mode].speed,
+                       corsair_direction,
+                       modes[active_mode].random,
+                       RGBGetRValue(colors[0]),
+                       RGBGetGValue(colors[0]),
+                       RGBGetBValue(colors[0]),
+                       RGBGetRValue(colors[1]),
+                       RGBGetGValue(colors[1]),
+                       RGBGetBValue(colors[1]));
 }

RGBController/RGBController_CorsairPro.h

@@ -16,14 +16,13 @@ class RGBController_CorsairPro : public RGBController
 {
 public:
     RGBController_CorsairPro(CorsairProController* corsair_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();
+    void        UpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        SetCustomMode();
+    void        UpdateMode();
 
 private:
     CorsairProController* corsair;
-};
+};

RGBController/RGBController_E131.cpp

@@ -24,12 +24,12 @@ RGBController_E131::RGBController_E131(std::vector<E131Device> device_list)
 
     sockfd = e131_socket();
 
-    for (int i = 0; i < devices.size(); i++)
+    for (std::size_t i = 0; i < devices.size(); i++)
     {
 		/*-----------------------------------------*\
 		| Add LEDs                                  |
         \*-----------------------------------------*/
-    	for (int led_idx = 0; led_idx < devices[i].num_leds; led_idx++)
+    	for (unsigned int led_idx = 0; led_idx < devices[i].num_leds; led_idx++)
     	{
        		colors.push_back(0x00000000);
         	led new_led;
@@ -44,7 +44,7 @@ RGBController_E131::RGBController_E131(std::vector<E131Device> device_list)
     	led_zone.name = devices[i].name;
     	led_zone.type = devices[i].type;
     	std::vector<int> led_zone_map;
-    	for (int led_idx = 0; led_idx < devices[i].num_leds; led_idx++)
+        for (unsigned int led_idx = 0; led_idx < devices[i].num_leds; led_idx++)
     	{
       	  	led_zone_map.push_back(led_zone_idx);
             led_zone_idx++;
@@ -57,12 +57,12 @@ RGBController_E131::RGBController_E131(std::vector<E131Device> device_list)
         \*-----------------------------------------*/
         unsigned int total_universes = ceil( ( ( devices[i].num_leds * 3 ) + devices[i].start_channel ) / 512.0f );
 
-        for (int univ_idx = 0; univ_idx < total_universes; univ_idx++)
+        for (unsigned int univ_idx = 0; univ_idx < total_universes; univ_idx++)
         {
             unsigned int universe = devices[i].start_universe + univ_idx;
             bool universe_exists = false;
 
-            for (int pkt_idx = 0; pkt_idx < packets.size(); pkt_idx++)
+            for (std::size_t pkt_idx = 0; pkt_idx < packets.size(); pkt_idx++)
             {
                 if(universes[pkt_idx] == universe)
                 {
@@ -86,56 +86,11 @@ RGBController_E131::RGBController_E131(std::vector<E131Device> device_list)
 	}
 }
 
-int RGBController_E131::GetMode()
-{
-    return 0;
-}
-
-void RGBController_E131::SetMode(int mode)
-{
-
-}
-
-void RGBController_E131::SetCustomMode()
-{
-
-}
-
-void RGBController_E131::SetAllLEDs(RGBColor color)
-{
-    for (int i = 0; i < colors.size(); i++)
-    {
-        colors[i] = color;
-    }
-
-	UpdateLEDs();
-}
-
-void RGBController_E131::SetAllZoneLEDs(int zone, RGBColor color)
-{
-    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;
-        }
-    }
-
-	UpdateLEDs();
-}
-
-void RGBController_E131::SetLED(int led, RGBColor color)
-{
-    colors[led] = color;
-
-	UpdateLEDs();
-}
-
 void RGBController_E131::UpdateLEDs()
 {
     int color_idx = 0;
 
-    for(int device_idx = 0; device_idx < devices.size(); device_idx++)
+    for(std::size_t device_idx = 0; device_idx < devices.size(); device_idx++)
     {
         unsigned int total_universes = ceil( ( ( devices[device_idx].num_leds * 3 ) + devices[device_idx].start_channel ) / 512.0f );
         unsigned int channel_idx = devices[device_idx].start_channel;
@@ -143,11 +98,11 @@ void RGBController_E131::UpdateLEDs()
         unsigned int rgb_idx = 0;
         bool         done = false;
 
-        for (int univ_idx = 0; univ_idx < total_universes; univ_idx++)
+        for (unsigned int univ_idx = 0; univ_idx < total_universes; univ_idx++)
         {
             unsigned int universe = devices[device_idx].start_universe + univ_idx;
 
-            for(int packet_idx = 0; packet_idx < packets.size(); packet_idx++)
+            for(std::size_t packet_idx = 0; packet_idx < packets.size(); packet_idx++)
             {
                 if(!done && (universes[packet_idx] == universe))
                 {
@@ -185,9 +140,29 @@ void RGBController_E131::UpdateLEDs()
         }
     }
 
-    for(int packet_idx = 0; packet_idx < packets.size(); packet_idx++)
+    for(std::size_t packet_idx = 0; packet_idx < packets.size(); packet_idx++)
     {
-	    e131_send(sockfd, &packets[packet_idx], &dest_addrs[packet_idx]);
+        e131_send(sockfd, &packets[packet_idx], &dest_addrs[packet_idx]);
         packets[packet_idx].frame.seq_number++;
     }
+}
+
+void RGBController_E131::UpdateZoneLEDs(int zone)
+{
+	UpdateLEDs();
+}
+
+void RGBController_E131::UpdateSingleLED(int led)
+{
+	UpdateLEDs();
+}
+
+void RGBController_E131::SetCustomMode()
+{
+
+}
+
+void RGBController_E131::UpdateMode()
+{
+
 }

RGBController/RGBController_E131.h

@@ -37,13 +37,12 @@ class RGBController_E131 : public RGBController
 {
 public:
     RGBController_E131(std::vector<E131Device> device_list);
-    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();
+    void        UpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        SetCustomMode();
+    void        UpdateMode();
 
 private:
 	std::vector<E131Device> 	devices;
@@ -51,4 +50,4 @@ private:
 	std::vector<e131_addr_t> 	dest_addrs;
 	std::vector<unsigned int> 	universes;
 	int 						sockfd;
-};
+};

RGBController/RGBController_Faustus.cpp

@@ -0,0 +1,150 @@
+#include "RGBController_Faustus.h"
+
+#include <dirent.h>
+#include <string.h>
+
+RGBController_Faustus::RGBController_Faustus(const std::string& dev_path)
+{
+    name = "Faustus";
+    description = "ASUS TUF Keyboard Backlight";
+    type = DEVICE_TYPE_KEYBOARD;
+
+    modes.resize(4);
+    modes[0].name   = "Static";
+    modes[0].value  = FAUSTUS_MODE_STATIC;
+    modes[0].flags  = MODE_FLAG_HAS_COLOR;
+    modes[0].random = false;
+
+    modes[1].name      = "Breathing";
+    modes[1].value     = FAUSTUS_MODE_BREATHING;
+    modes[1].flags     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_COLOR;
+    modes[1].speed_min = FAUSTUS_SPEED_SLOWEST;
+    modes[1].speed_max = FAUSTUS_SPEED_FASTEST;
+    modes[1].random    = false;
+    modes[1].speed     = FAUSTUS_SPEED_NORMAL;
+
+    modes[2].name      = "Color Cycle";
+    modes[2].value     = FAUSTUS_MODE_COLOR_CYCLE;
+    modes[2].flags     = MODE_FLAG_HAS_SPEED;
+    modes[2].speed_min = FAUSTUS_SPEED_SLOWEST;
+    modes[2].speed_max = FAUSTUS_SPEED_FASTEST;
+    modes[2].random    = false;
+    modes[2].speed     = FAUSTUS_SPEED_NORMAL;
+
+    modes[3].name      = "Strobe";
+    modes[3].value     = FAUSTUS_MODE_STROBE;
+    modes[3].flags     = MODE_FLAG_HAS_SPEED;
+    modes[3].speed_min = FAUSTUS_SPEED_SLOWEST;
+    modes[3].speed_max = FAUSTUS_SPEED_FASTEST;
+    modes[3].random    = false;
+    modes[3].speed     = FAUSTUS_SPEED_NORMAL;
+
+    colors.resize(1);
+    leds.resize(1);
+    leds[0].name = "Keyboard backlight LED";
+    zones.resize(1);
+    zones[0].type = ZONE_TYPE_SINGLE;
+    zones[0].name = "Keyboard backlight zone";
+    zones[0].map.push_back(std::vector<int>(1, 0));
+
+    // Prepare file streams
+    r_path = dev_path;
+    g_path = dev_path;
+    b_path = dev_path;
+    mode_path = dev_path;
+    flags_path = dev_path;
+    set_path = dev_path;
+
+    r_path.append("/kbbl_red");
+    g_path.append("/kbbl_green");
+    b_path.append("/kbbl_blue");
+    mode_path.append("/kbbl_mode");
+    flags_path.append("/kbbl_flags");
+    set_path.append("/kbbl_set");
+}
+
+void RGBController_Faustus::UpdateLEDs()
+{
+    int rv = uint8_t(RGBGetRValue(colors[0]));
+    int gv = uint8_t(RGBGetGValue(colors[0]));
+    int bv = uint8_t(RGBGetBValue(colors[0]));
+
+    std::ofstream str_r;
+    std::ofstream str_g;
+    std::ofstream str_b;
+    std::ofstream str_mode;
+    std::ofstream str_flags;
+    std::ofstream str_set;
+
+    str_r.open(r_path, std::ios::out | std::ios::trunc);
+    str_g.open(g_path, std::ios::out | std::ios::trunc);
+    str_b.open(b_path, std::ios::out | std::ios::trunc);
+    str_mode.open(mode_path, std::ios::out | std::ios::trunc);
+    str_flags.open(flags_path, std::ios::out | std::ios::trunc);
+    str_set.open(set_path, std::ios::out | std::ios::trunc);
+
+    str_r << std::hex;
+    str_g << std::hex;
+    str_b << std::hex;
+    str_mode << std::hex;
+    str_flags << std::hex;
+    str_set << std::hex;
+
+    str_r << rv;
+    str_g << gv;
+    str_b << bv;
+    str_mode << active_mode;
+    str_flags << 0x2a; // All of em
+    str_set << 2;
+
+    // Flush everything
+    str_r.close();
+    str_g.close();
+    str_b.close();
+    str_mode.close();
+    str_flags.close();
+    str_set.close();
+}
+
+void RGBController_Faustus::UpdateZoneLEDs(int zone)
+{
+    UpdateLEDs();
+}
+
+void RGBController_Faustus::UpdateSingleLED(int led)
+{
+    UpdateLEDs();
+}
+
+void RGBController_Faustus::SetCustomMode()
+{
+    SetMode(0);
+}
+
+void RGBController_Faustus::UpdateMode()
+{
+    UpdateLEDs();
+}
+
+void DetectFaustusControllers(std::vector<RGBController*> &rgb_controllers)
+{
+    const char* base_path = "/sys/devices/platform/faustus/kbbl";
+    DIR* dir = opendir(base_path);
+    if(!dir) return;
+    // Directory is present - we pretty much have a driver confirmation already, but double check for all files required just in case
+    struct dirent* dent = readdir(dir);
+    if(!dent) return;
+    int found = 0;
+    while(dent)
+    {
+        const char* fname = dent->d_name;
+        if(!strcmp(fname, "kbbl_red") || !strcmp(fname, "kbbl_green") || !strcmp(fname, "kbbl_blue") || !strcmp(fname, "kbbl_mode") || !strcmp(fname, "kbbl_flags") || !strcmp(fname, "kbbl_set"))
+        {
+            ++found;
+        }
+        dent = readdir(dir);
+    }
+    closedir(dir);
+    if(found != 6) return;
+    rgb_controllers.push_back(new RGBController_Faustus(base_path));
+}

RGBController/RGBController_Faustus.h

@@ -0,0 +1,41 @@
+#ifndef RGBCONTROLLER_FAUSTUS_H
+#define RGBCONTROLLER_FAUSTUS_H
+
+#include "RGBController.h"
+#include <fstream>
+
+enum
+{
+    FAUSTUS_MODE_STATIC      = 0,
+    FAUSTUS_MODE_BREATHING   = 1,
+    FAUSTUS_MODE_COLOR_CYCLE = 2,
+    FAUSTUS_MODE_STROBE      = 3
+};
+enum
+{
+    FAUSTUS_SPEED_SLOWEST = 0,
+    FAUSTUS_SPEED_NORMAL  = 1,
+    FAUSTUS_SPEED_FASTEST = 2,
+};
+
+class RGBController_Faustus : public RGBController
+{
+    private:
+        std::string r_path;
+        std::string g_path;
+        std::string b_path;
+        std::string mode_path;
+        std::string flags_path;
+        std::string set_path;
+
+    public:
+        RGBController_Faustus(const std::string& dev_path);
+        void        UpdateLEDs();
+        void        UpdateZoneLEDs(int zone);
+        void        UpdateSingleLED(int led);
+
+        void        SetCustomMode();
+        void        UpdateMode();
+};
+
+#endif // RGBCONTROLLER_FAUSTUS_H

RGBController/RGBController_Hue2.cpp

@@ -0,0 +1,244 @@
+/*-----------------------------------------*\
+|  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 Direct;
+    Direct.name  = "Direct";
+    Direct.value = HUE_2_MODE_FIXED;
+    Direct.flags = MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR;
+    modes.push_back(Direct);
+
+    mode Fading;
+    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     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
+    SpectrumCycle.speed_min = HUE_2_SPEED_SLOWEST;
+    SpectrumCycle.speed_max = HUE_2_SPEED_FASTEST;
+    SpectrumCycle.speed     = HUE_2_SPEED_NORMAL;
+    SpectrumCycle.direction = MODE_DIRECTION_RIGHT;
+    modes.push_back(SpectrumCycle);
+
+    mode Marquee;
+    Marquee.name      = "Marquee";
+    Marquee.value     = HUE_2_MODE_MARQUEE;
+    Marquee.flags     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | 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;
+    Marquee.direction = MODE_DIRECTION_RIGHT;
+    modes.push_back(Marquee);
+
+    mode CoverMarquee;
+    CoverMarquee.name      = "Cover Marquee";
+    CoverMarquee.value     = HUE_2_MODE_COVER_MARQUEE;
+    CoverMarquee.flags     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | 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;
+    CoverMarquee.direction = MODE_DIRECTION_RIGHT;
+    modes.push_back(CoverMarquee);
+
+    mode Alternating;
+    Alternating.name      = "Alternating";
+    Alternating.value     = HUE_2_MODE_ALTERNATING;
+    Alternating.flags     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | 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;
+    Alternating.direction = MODE_DIRECTION_RIGHT;
+    modes.push_back(Alternating);
+
+    mode Pulsing;
+    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_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);
+
+    /*-------------------------------------------------*\
+    | Set size of colors array                          |
+    \*-------------------------------------------------*/
+    unsigned int led_count = 0;
+    for (unsigned int channel_idx = 0; channel_idx < HUE_2_NUM_CHANNELS; channel_idx++)
+    {
+        led_count += hue2->channel_leds[channel_idx];
+    }
+    colors.resize(led_count);
+
+    /*-------------------------------------------------*\
+    | Set zones and leds                                |
+    \*-------------------------------------------------*/
+    unsigned int led_idx = 0;
+    for (unsigned 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 (unsigned int led_ch_idx = 0; led_ch_idx < hue2->channel_leds[channel_idx]; led_ch_idx++)
+            {
+                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);
+
+                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);
+        }
+    }
+}
+
+void RGBController_Hue2::UpdateLEDs()
+{
+    for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
+    {
+        unsigned int channel = zones_channel[zone_idx];
+
+        std::vector<RGBColor> channel_colors;
+
+        for(std::size_t 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);
+        }
+    }
+}
+
+void RGBController_Hue2::UpdateZoneLEDs(int zone)
+{
+    unsigned int channel = zones_channel[zone];
+
+    std::vector<RGBColor> channel_colors;
+
+    for(std::size_t 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);
+    }
+}
+
+void RGBController_Hue2::UpdateSingleLED(int led)
+{
+    unsigned int channel = leds_channel[led];
+
+    std::vector<RGBColor> channel_colors;
+
+    for(std::size_t 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);
+    }
+}
+
+void RGBController_Hue2::SetCustomMode()
+{
+    SetMode(0);
+}
+
+void RGBController_Hue2::UpdateMode()
+{
+    for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
+    {
+        unsigned int channel = zones_channel[zone_idx];
+
+        std::vector<RGBColor> channel_colors;
+
+        for(std::size_t color = 0; color < colors.size(); color++)
+        {
+            if(leds_channel[color] == channel)
+            {
+                channel_colors.push_back(colors[color]);
+            }
+        }
+
+        if(channel_colors.size() > 0)
+        {
+            bool direction = false;
+
+            if(modes[active_mode].direction == MODE_DIRECTION_LEFT)
+            {
+                direction = true;
+            }
+
+            hue2->SetMode(modes[active_mode].value, modes[active_mode].speed, direction);
+            hue2->SetChannelLEDs(channel, channel_colors);
+        }
+    }
+}

RGBController/RGBController_Hue2.h

@@ -0,0 +1,29 @@
+/*-----------------------------------------*\
+|  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);
+    void        UpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        SetCustomMode();
+    void        UpdateMode();
+
+private:
+    Hue2Controller*             hue2;
+    std::vector<unsigned int>   leds_channel;
+    std::vector<unsigned int>   zones_channel;
+};

RGBController/RGBController_HuePlus.cpp

@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  RGBController_HuePlus.cpp               |
+|  RGBController_HuePlus.cpp                |
 |                                           |
 |  Generic RGB Interface for NZXT Hue+      |
 |                                           |
@@ -11,76 +11,268 @@
 
 RGBController_HuePlus::RGBController_HuePlus(HuePlusController* hueplus_ptr)
 {
-    strip = hueplus_ptr;
+    hueplus = hueplus_ptr;
 
-    name = "LED Strip";
+    name = "NZXT Hue+";
 
-    mode led_mode;
-    led_mode.name = "Custom";
-    modes.push_back(led_mode);
+    type = DEVICE_TYPE_LEDSTRIP;
 
-    for (int i = 0; i < strip->num_leds; i++)
+    location = hueplus->GetLocation();
+    
+    mode Direct;
+    Direct.name  = "Direct";
+    Direct.value = HUE_PLUS_MODE_FIXED;
+    Direct.flags = MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR;
+    modes.push_back(Direct);
+
+// Fading mode is currently disabled because it doesn't appear to work
+//    mode Fading;
+//    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_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 | MODE_FLAG_HAS_DIRECTION_LR;
+    SpectrumCycle.speed_min = HUE_PLUS_SPEED_SLOWEST;
+    SpectrumCycle.speed_max = HUE_PLUS_SPEED_FASTEST;
+    SpectrumCycle.speed     = HUE_PLUS_SPEED_NORMAL;
+    SpectrumCycle.direction = MODE_DIRECTION_RIGHT;
+    modes.push_back(SpectrumCycle);
+
+    mode Marquee;
+    Marquee.name      = "Marquee";
+    Marquee.value     = HUE_PLUS_MODE_MARQUEE;
+    Marquee.flags     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR;
+    Marquee.speed_min = HUE_PLUS_SPEED_SLOWEST;
+    Marquee.speed_max = HUE_PLUS_SPEED_FASTEST;
+    Marquee.speed     = HUE_PLUS_SPEED_NORMAL;
+    Marquee.direction = MODE_DIRECTION_RIGHT;
+    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_DIRECTION_LR | MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR;
+    CoverMarquee.speed_min = HUE_PLUS_SPEED_SLOWEST;
+    CoverMarquee.speed_max = HUE_PLUS_SPEED_FASTEST;
+    CoverMarquee.speed     = HUE_PLUS_SPEED_NORMAL;
+    CoverMarquee.direction = MODE_DIRECTION_RIGHT;
+    modes.push_back(CoverMarquee);
+
+    mode Alternating;
+    Alternating.name      = "Alternating";
+    Alternating.value     = HUE_PLUS_MODE_ALTERNATING;
+    Alternating.flags     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR;
+    Alternating.speed_min = HUE_PLUS_SPEED_SLOWEST;
+    Alternating.speed_max = HUE_PLUS_SPEED_FASTEST;
+    Alternating.speed     = HUE_PLUS_SPEED_NORMAL;
+    Alternating.direction = MODE_DIRECTION_RIGHT;
+    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_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_SLOWEST;
+    Breathing.speed_max = HUE_PLUS_SPEED_FASTEST;
+    Breathing.speed     = HUE_PLUS_SPEED_NORMAL;
+    modes.push_back(Breathing);
+
+    mode Alert;
+    Alert.name  = "Alert";
+    Alert.value = HUE_PLUS_MODE_ALERT;
+    Alert.flags = 0;
+    modes.push_back(Alert);
+
+    mode Candlelight;
+    Candlelight.name  = "Candlelight";
+    Candlelight.value = HUE_PLUS_MODE_CANDLELIGHT;
+    Candlelight.flags = MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR;
+    modes.push_back(Candlelight);
+
+    mode Wings;
+    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_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
+//    mode Wave;
+//    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_SLOWEST;
+//    Wave.speed_max = HUE_PLUS_SPEED_FASTEST;
+//    Wave.speed     = HUE_PLUS_SPEED_NORMAL;
+//    modes.push_back(Wave);
+
+    /*-------------------------------------------------*\
+    | Set size of colors array                          |
+    \*-------------------------------------------------*/
+    unsigned int led_count = 0;
+    for (unsigned int channel_idx = 0; channel_idx < HUE_PLUS_NUM_CHANNELS; channel_idx++)
     {
-        colors.push_back(0x00000000);
-        led new_led;
-        new_led.name = "LED Strip";
-        leds.push_back(new_led);
+        led_count += hueplus->channel_leds[channel_idx];
     }
+    colors.resize(led_count);
 
-    zone led_zone;
-    led_zone.name = "LED Strip";
-    std::vector<int> led_zone_map;
-    for (int i = 0; i < strip->num_leds; i++)
+    /*-------------------------------------------------*\
+    | Set zones and leds                                |
+    \*-------------------------------------------------*/
+    unsigned int led_idx = 0;
+    for (int channel_idx = 0; channel_idx < HUE_PLUS_NUM_CHANNELS; channel_idx++)
     {
-        led_zone_map.push_back(i);
+        if(hueplus->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+ 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 (unsigned led_ch_idx = 0; led_ch_idx < hueplus->channel_leds[channel_idx]; led_ch_idx++)
+            {
+                char led_idx_string[3];
+                sprintf(led_idx_string, "%d", led_ch_idx + 1);
+
+                led new_led;
+                new_led.name = "Hue+ 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);
+        }
     }
-    led_zone.map.push_back(led_zone_map);
-    zones.push_back(led_zone);
-}
-
-int RGBController_HuePlus::GetMode()
-{
-    return 0;
-}
-
-void RGBController_HuePlus::SetMode(int mode)
-{
-
-}
-
-void RGBController_HuePlus::SetCustomMode()
-{
-
-}
-
-void RGBController_HuePlus::SetAllLEDs(RGBColor color)
-{
-    for (int i = 0; i < colors.size(); i++)
-    {
-        colors[i] = color;
-    }
-
-    strip->SetLEDs(colors);
-}
-
-void RGBController_HuePlus::SetAllZoneLEDs(int zone, RGBColor color)
-{
-    for (int i = 0; i < colors.size(); i++)
-    {
-        colors[i] = color;
-    }
-
-    strip->SetLEDs(colors);
-}
-
-void RGBController_HuePlus::SetLED(int led, RGBColor color)
-{
-    colors[led] = color;
-
-    strip->SetLEDs(colors);
 }
 
 void RGBController_HuePlus::UpdateLEDs()
 {
-    strip->SetLEDs(colors);
+    for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
+    {
+        unsigned int channel = zones_channel[zone_idx];
+
+        std::vector<RGBColor> channel_colors;
+
+        for(std::size_t color = 0; color < colors.size(); color++)
+        {
+            if(leds_channel[color] == channel)
+            {
+                channel_colors.push_back(colors[color]);
+            }
+        }
+
+        if(channel_colors.size() > 0)
+        {
+            hueplus->SetChannelLEDs(channel, channel_colors);
+        }
+    }
+}
+
+void RGBController_HuePlus::UpdateZoneLEDs(int zone)
+{
+    unsigned int channel = zones_channel[zone];
+
+    std::vector<RGBColor> channel_colors;
+
+    for(std::size_t color = 0; color < colors.size(); color++)
+    {
+        if(leds_channel[color] == channel)
+        {
+            channel_colors.push_back(colors[color]);
+        }
+    }
+
+    if(channel_colors.size() > 0)
+    {
+        hueplus->SetChannelLEDs(channel, channel_colors);
+    }
+}
+
+void RGBController_HuePlus::UpdateSingleLED(int led)
+{
+    unsigned int channel = leds_channel[led];
+
+    std::vector<RGBColor> channel_colors;
+
+    for(std::size_t color = 0; color < colors.size(); color++)
+    {
+        if(leds_channel[color] == channel)
+        {
+            channel_colors.push_back(colors[color]);
+        }
+    }
+
+    if(channel_colors.size() > 0)
+    {
+        hueplus->SetChannelLEDs(channel, channel_colors);
+    }
+}
+
+void RGBController_HuePlus::SetCustomMode()
+{
+    SetMode(0);
+}
+
+void RGBController_HuePlus::UpdateMode()
+{
+    for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
+    {
+        unsigned int channel = zones_channel[zone_idx];
+
+        std::vector<RGBColor> channel_colors;
+
+        for(std::size_t color = 0; color < colors.size(); color++)
+        {
+            if(leds_channel[color] == channel)
+            {
+                channel_colors.push_back(colors[color]);
+            }
+        }
+
+        if(channel_colors.size() > 0)
+        {
+            bool direction = false;
+
+            if(modes[active_mode].direction == MODE_DIRECTION_LEFT)
+            {
+                direction = true;
+            }
+
+            hueplus->SetMode(modes[active_mode].value, modes[active_mode].speed, direction);
+            hueplus->SetChannelLEDs(channel, channel_colors);
+        }
+    }
 }

RGBController/RGBController_HuePlus.h

@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  RGBController_HuePlus.h                 |
+|  RGBController_HuePlus.h                  |
 |                                           |
 |  Generic RGB Interface for NZXT Hue+      |
 |                                           |
@@ -15,14 +15,15 @@ class RGBController_HuePlus : public RGBController
 {
 public:
     RGBController_HuePlus(HuePlusController* hueplus_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();
+    void        UpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        SetCustomMode();
+    void        UpdateMode();
 
 private:
-    HuePlusController* strip;
-};
+    HuePlusController*          hueplus;
+    std::vector<unsigned int>   leds_channel;
+    std::vector<unsigned int>   zones_channel;
+};

RGBController/RGBController_HyperX.cpp

@@ -9,57 +9,77 @@
 
 #include "RGBController_HyperX.h"
 
-int RGBController_HyperX::GetMode()
-{
-    return(0);
-}
-
-void RGBController_HyperX::SetMode(int mode)
-{
-    hyperx->SetMode(mode);
-}
-
-void RGBController_HyperX::SetCustomMode()
-{
-    hyperx->SetMode(HYPERX_MODE_STATIC);
-}
-
-void RGBController_HyperX::SetAllLEDs(RGBColor color)
-{
-    unsigned char red = RGBGetRValue(color);
-    unsigned char grn = RGBGetGValue(color);
-    unsigned char blu = RGBGetBValue(color);
-
-    hyperx->SetAllColors(red, grn, blu);
-}
-
-void RGBController_HyperX::SetAllZoneLEDs(int zone, RGBColor color)
-{
-    unsigned char red = RGBGetRValue(color);
-    unsigned char grn = RGBGetGValue(color);
-    unsigned char blu = RGBGetBValue(color);
-
-    for (int x = 0; x < zones[zone].map.size(); x++)
-    {
-        for (int y = 0; y < zones[zone].map[x].size(); y++)
-        {
-            hyperx->SetLEDColor(zones[zone].map[x][y], red, grn, blu);
-        }
-    }
-}
-
-void RGBController_HyperX::SetLED(int led, RGBColor color)
-{
-    unsigned char red = RGBGetRValue(color);
-    unsigned char grn = RGBGetGValue(color);
-    unsigned char blu = RGBGetBValue(color);
-
-    hyperx->SetLEDColor(led, red, grn, blu);
-}
 
 void RGBController_HyperX::UpdateLEDs()
 {
-    
+    if(hyperx->GetMode() == HYPERX_MODE_DIRECT)
+    {
+        for (std::size_t zone = 0; zone < zones.size(); zone++ )
+        {
+            for (std::size_t x = 0; x < zones[zone].map.size(); x++)
+            {
+                for (std::size_t y = 0; y < zones[zone].map[x].size(); y++)
+                {
+                    int           led   = zones[zone].map[x][y];
+                    RGBColor      color = colors[led];
+                    unsigned char red = RGBGetRValue(color);
+                    unsigned char grn = RGBGetGValue(color);
+                    unsigned char blu = RGBGetBValue(color);
+                    hyperx->SetLEDColor(led, red, grn, blu);
+                }
+            }
+        }
+    }
+    else
+    {
+        unsigned char red = RGBGetRValue(colors[0]);
+        unsigned char grn = RGBGetGValue(colors[0]);
+        unsigned char blu = RGBGetBValue(colors[0]);
+        hyperx->SetEffectColor(red, grn, blu);
+    }
+}
+
+void RGBController_HyperX::UpdateZoneLEDs(int zone)
+{
+    if(hyperx->GetMode() == HYPERX_MODE_DIRECT)
+    {
+        for (std::size_t x = 0; x < zones[zone].map.size(); x++)
+        {
+            for (std::size_t y = 0; y < zones[zone].map[x].size(); y++)
+            {
+                int           led   = zones[zone].map[x][y];
+                RGBColor      color = colors[led];
+                unsigned char red = RGBGetRValue(color);
+                unsigned char grn = RGBGetGValue(color);
+                unsigned char blu = RGBGetBValue(color);
+                hyperx->SetLEDColor(led, red, grn, blu);
+            }
+        }
+    }
+    else
+    {
+        unsigned char red = RGBGetRValue(colors[0]);
+        unsigned char grn = RGBGetGValue(colors[0]);
+        unsigned char blu = RGBGetBValue(colors[0]);
+        hyperx->SetEffectColor(red, grn, blu);
+    }
+}
+
+void RGBController_HyperX::UpdateSingleLED(int led)
+{
+    RGBColor      color = colors[led];
+    unsigned char red   = RGBGetRValue(color);
+    unsigned char grn   = RGBGetGValue(color);
+    unsigned char blu   = RGBGetBValue(color);
+
+    if(hyperx->GetMode() == HYPERX_MODE_DIRECT)
+    {
+        hyperx->SetLEDColor(led, red, grn, blu);
+    }
+    else
+    {
+        hyperx->SetEffectColor(red, grn, blu);
+    }
 }
 
 RGBController_HyperX::RGBController_HyperX(HyperXController* hyperx_ptr)
@@ -67,46 +87,136 @@ RGBController_HyperX::RGBController_HyperX(HyperXController* hyperx_ptr)
     hyperx = hyperx_ptr;
 
     name = hyperx->GetDeviceName();
-
-    mode hyperx_modes[HYPERX_NUMBER_MODES];
-
-    hyperx_modes[0].name = "Static";
-    hyperx_modes[1].name = "Rainbow";
-    hyperx_modes[2].name = "Comet";
-    hyperx_modes[3].name = "Heartbeat";
-    hyperx_modes[4].name = "Spectrum Cycle";
-    hyperx_modes[5].name = "Breathing";
-    hyperx_modes[6].name = "Bounce";
-    hyperx_modes[7].name = "Blink";
+    location = hyperx->GetDeviceLocation();
     
-    for (int i = 0; i < HYPERX_NUMBER_MODES; i++)
+    type = DEVICE_TYPE_DRAM;
+
+    mode Direct;
+    Direct.name  = "Direct";
+    Direct.value = HYPERX_MODE_DIRECT;
+    Direct.flags = MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR;
+    modes.push_back(Direct);
+
+    mode Static;
+    Static.name  = "Static";
+    Static.value = HYPERX_MODE_STATIC;
+    Static.flags = MODE_FLAG_HAS_COLOR;
+    modes.push_back(Static);
+
+    mode Rainbow;
+    Rainbow.name      = "Rainbow";
+    Rainbow.value     = HYPERX_MODE_RAINBOW;
+    Rainbow.flags     = MODE_FLAG_HAS_SPEED;
+    Rainbow.speed_min = HYPERX_SPEED_RAINBOW_SLOW;
+    Rainbow.speed_max = HYPERX_SPEED_RAINBOW_FAST;
+    Rainbow.speed     = HYPERX_SPEED_RAINBOW_NORMAL;
+    modes.push_back(Rainbow);
+
+    mode Comet;
+    Comet.name      = "Comet";
+    Comet.value     = HYPERX_MODE_COMET;
+    Comet.flags     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_COLOR | MODE_FLAG_RANDOM_COLOR;
+    Comet.speed_min = HYPERX_SPEED_COMET_SLOW;
+    Comet.speed_max = HYPERX_SPEED_COMET_FAST;
+    Comet.random    = false;
+    Comet.speed     = HYPERX_SPEED_COMET_NORMAL;
+    modes.push_back(Comet);
+
+    mode Heartbeat;
+    Heartbeat.name      = "Heartbeat";
+    Heartbeat.value     = HYPERX_MODE_HEARTBEAT;
+    Heartbeat.flags     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_COLOR | MODE_FLAG_RANDOM_COLOR;
+    Heartbeat.speed_min = HYPERX_SPEED_COMET_SLOW;
+    Heartbeat.speed_max = HYPERX_SPEED_COMET_FAST;
+    Heartbeat.random    = false;
+    Heartbeat.speed     = HYPERX_SPEED_COMET_NORMAL;
+    modes.push_back(Heartbeat);
+
+    mode SpectrumCycle;
+    SpectrumCycle.name      = "Spectrum Cycle";
+    SpectrumCycle.value     = HYPERX_MODE_CYCLE;
+    SpectrumCycle.flags     = MODE_FLAG_HAS_SPEED;
+    SpectrumCycle.speed_min = HYPERX_SPEED_CYCLE_SLOW;
+    SpectrumCycle.speed_max = HYPERX_SPEED_CYCLE_FAST;
+    SpectrumCycle.speed     = HYPERX_SPEED_CYCLE_NORMAL;
+    modes.push_back(SpectrumCycle);
+    
+    mode Breathing;
+    Breathing.name      = "Breathing";
+    Breathing.value     = HYPERX_MODE_BREATHING;
+    Breathing.flags     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_COLOR | MODE_FLAG_RANDOM_COLOR;
+    Breathing.speed_min = HYPERX_SPEED_BREATHING_SLOW;
+    Breathing.speed_max = HYPERX_SPEED_BREATHING_FAST;
+    Breathing.random    = false;
+    Breathing.speed     = HYPERX_SPEED_BREATHING_NORMAL;
+    modes.push_back(Breathing);
+
+    mode Bounce;
+    Bounce.name      = "Bounce";
+    Bounce.value     = HYPERX_MODE_BOUNCE;
+    Bounce.flags     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_COLOR | MODE_FLAG_RANDOM_COLOR;
+    Bounce.speed_min = HYPERX_SPEED_BOUNCE_SLOW;
+    Bounce.speed_max = HYPERX_SPEED_BOUNCE_FAST;
+    Bounce.random    = false;
+    Bounce.speed     = HYPERX_SPEED_BOUNCE_NORMAL;
+    modes.push_back(Bounce);
+
+    mode Blink;
+    Blink.name      = "Blink";
+    Blink.value     = HYPERX_MODE_BLINK;
+    Blink.flags     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_COLOR | MODE_FLAG_RANDOM_COLOR;
+    Blink.speed_min = HYPERX_SPEED_BLINK_SLOW;
+    Blink.speed_max = HYPERX_SPEED_BLINK_FAST;
+    Blink.random    = false;
+    Blink.speed     = HYPERX_SPEED_BLINK_NORMAL;
+    modes.push_back(Blink);
+
+    colors.resize(hyperx->GetLEDCount());
+
+    unsigned int led_idx = 0;
+
+    for(unsigned int slot = 0; slot < hyperx->GetSlotCount(); slot++)
     {
-        modes.push_back(hyperx_modes[i]);
+        zone* new_zone = new zone;
+
+        char slot_idx_str[3];
+        sprintf(slot_idx_str, "%d", slot);
+        new_zone->name = "HyperX Slot ";
+        new_zone->name.append(slot_idx_str);
+
+        new_zone->type = ZONE_TYPE_LINEAR;
+
+        std::vector<int> *new_zone_map = new std::vector<int>();
+
+        for(int led_slot_idx = 0; led_slot_idx < 5; led_slot_idx++)
+        {
+            led* new_led = new led();
+
+            char led_idx_str[3];
+            sprintf(led_idx_str, "%d", led_slot_idx);
+            new_led->name = "HyperX Slot ";
+            new_led->name.append(slot_idx_str);
+            new_led->name.append(", LED ");
+            new_led->name.append(led_idx_str);
+
+            leds.push_back(*new_led);
+
+            new_zone_map->push_back(led_idx);
+            led_idx++;
+        }
+
+        new_zone->map.push_back(*new_zone_map);
+        zones.push_back(*new_zone);
     }
+}
 
-    for (int i = 0; i < hyperx->GetLEDCount(); i++)
-    {
-        led* new_led = new led();
+void RGBController_HyperX::SetCustomMode()
+{
+    SetMode(0);
+}
 
-        new_led->name = "HyperX LED";
+void RGBController_HyperX::UpdateMode()
+{
+    hyperx->SetMode(modes[active_mode].value, modes[active_mode].random, modes[active_mode].speed);
+}
 
-        leds.push_back(*new_led);
-        colors.push_back(0x00000000);
-    }
-
-    zone new_zone;
-
-    new_zone.name = "HyperX Zone";
-    new_zone.type = ZONE_TYPE_SINGLE;
-
-    std::vector<int> zone_row;
-
-    for (int i = 0; i < hyperx->GetLEDCount(); i++)
-    {
-        zone_row.push_back(i);
-    }
-
-    new_zone.map.push_back(zone_row);
-
-    zones.push_back(new_zone);
-}

RGBController/RGBController_HyperX.h

@@ -16,14 +16,13 @@ class RGBController_HyperX : public RGBController
 {
 public:
     RGBController_HyperX(HyperXController* hyperx_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();
+    void        UpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        SetCustomMode();
+    void        UpdateMode();
 
 private:
     HyperXController* hyperx;
-};
+};

RGBController/RGBController_LEDStrip.cpp

@@ -16,13 +16,16 @@ RGBController_LEDStrip::RGBController_LEDStrip(LEDStripController* ledstrip_ptr)
 
     name = "LED Strip";
 
+    type = DEVICE_TYPE_LEDSTRIP;
+
     mode led_mode;
     led_mode.name = "Custom";
     modes.push_back(led_mode);
 
+    colors.resize(strip->num_leds);
+    
     for (int i = 0; i < strip->num_leds; i++)
     {
-        colors.push_back(0x00000000);
         led new_led;
         new_led.name = "LED Strip";
         leds.push_back(new_led);
@@ -39,14 +42,19 @@ RGBController_LEDStrip::RGBController_LEDStrip(LEDStripController* ledstrip_ptr)
     zones.push_back(led_zone);
 }
 
-int RGBController_LEDStrip::GetMode()
+void RGBController_LEDStrip::UpdateLEDs()
 {
-    return 0;
+    strip->SetLEDs(colors);
 }
 
-void RGBController_LEDStrip::SetMode(int mode)
+void RGBController_LEDStrip::UpdateZoneLEDs(int zone)
 {
+    strip->SetLEDs(colors);
+}
 
+void RGBController_LEDStrip::UpdateSingleLED(int led)
+{
+    strip->SetLEDs(colors);
 }
 
 void RGBController_LEDStrip::SetCustomMode()
@@ -54,34 +62,7 @@ void RGBController_LEDStrip::SetCustomMode()
 
 }
 
-void RGBController_LEDStrip::SetAllLEDs(RGBColor color)
+void RGBController_LEDStrip::UpdateMode()
 {
-    for (int i = 0; i < colors.size(); i++)
-    {
-        colors[i] = color;
-    }
 
-    strip->SetLEDs(colors);
-}
-
-void RGBController_LEDStrip::SetAllZoneLEDs(int zone, RGBColor color)
-{
-    for (int i = 0; i < colors.size(); i++)
-    {
-        colors[i] = color;
-    }
-
-    strip->SetLEDs(colors);
-}
-
-void RGBController_LEDStrip::SetLED(int led, RGBColor color)
-{
-    colors[led] = color;
-
-    strip->SetLEDs(colors);
-}
-
-void RGBController_LEDStrip::UpdateLEDs()
-{
-    strip->SetLEDs(colors);
 }

RGBController/RGBController_LEDStrip.h

@@ -16,14 +16,13 @@ class RGBController_LEDStrip : public RGBController
 {
 public:
     RGBController_LEDStrip(LEDStripController* ledstrip_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();
+    void        UpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        SetCustomMode();
+    void        UpdateMode();
 
 private:
     LEDStripController* strip;
-};
+};

RGBController/RGBController_MSI3Zone.cpp

@@ -0,0 +1,90 @@
+/*-----------------------------------------*\
+|  RGBController_MSI3Zone.cpp               |
+|                                           |
+|  Generic RGB Interface for MSI/Steelseries|
+|  3-Zone Keyboard                          |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 12/25/2019  |
+\*-----------------------------------------*/
+
+#include "RGBController_MSI3Zone.h"
+
+RGBController_MSI3Zone::RGBController_MSI3Zone(MSI3ZoneController* msi_ptr)
+{
+    msi = msi_ptr;
+
+    name = "MSI 3-Zone Keyboard";
+    type = DEVICE_TYPE_KEYBOARD;
+
+    mode led_mode;
+    led_mode.name = "Custom";
+    modes.push_back(led_mode);
+
+    led left_led;
+    left_led.name = "Keyboard Left";
+    leds.push_back(left_led);
+    colors.push_back(0x00000000);
+
+    led mid_led;
+    mid_led.name = "Keyboard Middle";
+    leds.push_back(mid_led);
+    colors.push_back(0x00000000);
+
+    led right_led;
+    right_led.name = "Keyboard Right";
+    leds.push_back(right_led);
+    colors.push_back(0x00000000);
+
+    zone keyboard_zone;
+    keyboard_zone.name = "Keyboard";
+    keyboard_zone.type = ZONE_TYPE_LINEAR;
+    std::vector<int> keyboard_zone_map;
+    keyboard_zone_map.push_back(0);
+    keyboard_zone_map.push_back(1);
+    keyboard_zone_map.push_back(2);
+    keyboard_zone.map.push_back(keyboard_zone_map);
+    zones.push_back(keyboard_zone);
+
+    led aux_led;
+    aux_led.name = "Aux";
+    leds.push_back(aux_led);
+    colors.push_back(0x00000000);
+
+    zone aux_zone;
+    aux_zone.name = "Aux";
+    aux_zone.type = ZONE_TYPE_SINGLE;
+    std::vector<int> aux_zone_map;
+    aux_zone_map.push_back(3);
+    aux_zone.map.push_back(aux_zone_map);
+    zones.push_back(aux_zone);
+}
+
+RGBController_MSI3Zone::~RGBController_MSI3Zone()
+{
+
+}
+
+void RGBController_MSI3Zone::UpdateLEDs()
+{
+    msi->SetLEDs(colors);
+}
+
+void RGBController_MSI3Zone::UpdateZoneLEDs(int zone)
+{
+    msi->SetLEDs(colors);
+}
+
+void RGBController_MSI3Zone::UpdateSingleLED(int led)
+{
+    msi->SetLEDs(colors);
+}
+
+void RGBController_MSI3Zone::SetCustomMode()
+{
+
+}
+
+void RGBController_MSI3Zone::UpdateMode()
+{
+
+}

RGBController/RGBController_MSI3Zone.h

@@ -0,0 +1,28 @@
+/*-----------------------------------------*\
+|  RGBController_MSI3Zone.h                 |
+|                                           |
+|  Generic RGB Interface for MSI/Steelseries|
+|  3-Zone Keyboard                          |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 12/25/2019  |
+\*-----------------------------------------*/
+
+#pragma once
+#include "RGBController.h"
+#include "MSI3ZoneController.h"
+
+class RGBController_MSI3Zone : public RGBController
+{
+public:
+    RGBController_MSI3Zone(MSI3ZoneController* msi_ptr);
+    ~RGBController_MSI3Zone();
+    void        UpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        SetCustomMode();
+    void        UpdateMode();
+
+private:
+    MSI3ZoneController*   msi;
+};

RGBController/RGBController_OpenRazer.cpp

@@ -11,88 +11,11 @@
 
 #include <fstream>
 #include <unistd.h>
-int RGBController_OpenRazer::GetMode()
-{
-    return(0);
-}
 
-void RGBController_OpenRazer::SetMode(int mode)
-{
-    char update_value = 1;
-
-    switch(type)
-    {
-        case RAZER_TYPE_MATRIX_FRAME:
-        case RAZER_TYPE_MATRIX_NOFRAME:
-            {
-                switch(mode)
-                {
-                    case RAZER_MODE_CUSTOM:
-                        matrix_effect_custom.write(&update_value, 1);
-                        matrix_effect_custom.flush();
-                        break;
-                    
-                    case RAZER_MODE_OFF:
-                        matrix_effect_none.write(&update_value, 1);
-                        matrix_effect_none.flush();
-                        break;
-
-                    case RAZER_MODE_STATIC:
-                        break;
-
-                    case RAZER_MODE_BREATHING:
-                        break;
-
-                    case RAZER_MODE_SPECTRUM_CYCLE:
-                        matrix_effect_spectrum.write(&update_value, 1);
-                        matrix_effect_spectrum.flush();
-                        break;
-                    
-                    case RAZER_MODE_WAVE:
-                        matrix_effect_wave.write(&update_value, 1);
-                        matrix_effect_wave.flush();
-                        break;
-
-                    case RAZER_MODE_REACTIVE:
-                        matrix_effect_reactive.write(&update_value, 1);
-                        matrix_effect_reactive.flush();
-                        break;
-                }
-            }
-            break;
-
-        case RAZER_TYPE_NOMATRIX:
-            {
-                switch(mode)
-                {
-                    case RAZER_MODE_CUSTOM:
-                        update_value = 0;
-                        logo_led_effect.write(&update_value, 1);
-                        scroll_led_effect.write(&update_value, 1);
-                        logo_led_effect.flush();
-                        scroll_led_effect.flush();
-                        break;
-
-                    case RAZER_MODE_SPECTRUM_CYCLE:
-                        update_value = '4';
-                        logo_led_effect.write(&update_value, 1);
-                        scroll_led_effect.write(&update_value, 1);
-                        logo_led_effect.flush();
-                        scroll_led_effect.flush();
-                        break;
-                }
-            }
-    }
-}
-
-void RGBController_OpenRazer::SetCustomMode()
-{
-    SetMode(RAZER_MODE_CUSTOM);
-}
 
 void RGBController_OpenRazer::UpdateLEDs()
 {
-    switch(type)
+    switch(matrix_type)
     {
         case RAZER_TYPE_MATRIX_FRAME:
         case RAZER_TYPE_MATRIX_NOFRAME:
@@ -100,13 +23,13 @@ void RGBController_OpenRazer::UpdateLEDs()
             {
                 char update_value = 1;
                 
-                for (int row = 0; row < matrix_rows; row++)
+                for (unsigned int row = 0; row < matrix_rows; row++)
                 {
                     unsigned int output_array_size;
                     unsigned int output_offset;
                     unsigned int row_offset = (row * matrix_cols);
 
-                    if(type == RAZER_TYPE_MATRIX_FRAME)
+                    if(matrix_type == RAZER_TYPE_MATRIX_FRAME)
                     {
                         output_array_size = 3 + (matrix_cols* 3);
                         output_offset = 3;
@@ -119,14 +42,14 @@ void RGBController_OpenRazer::UpdateLEDs()
                     
                     char output_array[output_array_size];
 
-                    if(type == RAZER_TYPE_MATRIX_FRAME)
+                    if(matrix_type == RAZER_TYPE_MATRIX_FRAME)
                     {
                         output_array[0] = row;
                         output_array[1] = 0;
                         output_array[2] = matrix_cols - 1;
                     }
 
-                    for(int col = 0; col < matrix_cols; col++)
+                    for(unsigned int col = 0; col < matrix_cols; col++)
                     {
                         unsigned int color_idx = col + row_offset;
                         output_array[(col * 3) + 0 + output_offset] = (char)RGBGetRValue(colors[color_idx]);
@@ -134,12 +57,12 @@ void RGBController_OpenRazer::UpdateLEDs()
                         output_array[(col * 3) + 2 + output_offset] = (char)RGBGetBValue(colors[color_idx]);
                     }
                     
-                    if(type == RAZER_TYPE_MATRIX_FRAME)
+                    if(matrix_type == RAZER_TYPE_MATRIX_FRAME)
                     {
                         matrix_custom_frame.write(output_array, output_array_size);
                         matrix_custom_frame.flush();
                     }
-                    else if(type == RAZER_TYPE_MATRIX_NOFRAME)
+                    else if(matrix_type == RAZER_TYPE_MATRIX_NOFRAME)
                     {
                         matrix_effect_custom.write(output_array, output_array_size);
                         matrix_effect_custom.flush();
@@ -151,7 +74,7 @@ void RGBController_OpenRazer::UpdateLEDs()
                     }
                 }
                 
-                if(type == RAZER_TYPE_MATRIX_FRAME)
+                if(matrix_type == RAZER_TYPE_MATRIX_FRAME)
                 {
                     matrix_effect_custom.write(&update_value, 1);
                     matrix_effect_custom.flush();
@@ -187,33 +110,13 @@ void RGBController_OpenRazer::UpdateLEDs()
     }
 }
 
-void RGBController_OpenRazer::SetAllLEDs(RGBColor color)
+void RGBController_OpenRazer::UpdateZoneLEDs(int zone)
 {
-    for(int i = 0; i < colors.size(); i++)
-    {
-        colors[i] = color;
-    }
-
     UpdateLEDs();
 }
 
-void RGBController_OpenRazer::SetAllZoneLEDs(int zone, RGBColor color)
+void RGBController_OpenRazer::UpdateSingleLED(int led)
 {
-    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;
-        }
-    }
-
-    UpdateLEDs();
-}
-
-void RGBController_OpenRazer::SetLED(int led, RGBColor color)
-{
-    colors[led] = color;
-
     UpdateLEDs();
 }
 
@@ -231,6 +134,34 @@ static std::string GetDeviceTypeString(std::string dev_path)
     return(ret_str);
 }
 
+static std::string GetFirmwareVersionString(std::string dev_path)
+{
+    // Read firmware_version for firmware version string
+    std::string firm_ver_path = dev_path + "/firmware_version";
+    std::ifstream firm_ver_file;
+    std::string ret_str;
+
+    firm_ver_file.open(firm_ver_path);
+    std::getline(firm_ver_file, ret_str);
+    firm_ver_file.close();
+
+    return(ret_str);   
+}
+
+static std::string GetSerialNumberString(std::string dev_path)
+{
+    // Read device_serial for serial number string
+    std::string ser_num_path = dev_path + "/device_serial";
+    std::ifstream ser_num_file;
+    std::string ret_str;
+
+    ser_num_file.open(ser_num_path);
+    std::getline(ser_num_file, ret_str);
+    ser_num_file.close();
+
+    return(ret_str);    
+}
+
 void RGBController_OpenRazer::SetupMatrixDevice(std::string dev_path, unsigned int rows, unsigned int cols)
 {
     matrix_custom_frame.open(dev_path + "/matrix_custom_frame");
@@ -246,11 +177,11 @@ void RGBController_OpenRazer::SetupMatrixDevice(std::string dev_path, unsigned i
     {
         if(!matrix_effect_custom)
         {
-            type = RAZER_TYPE_MATRIX_STATIC;
+            matrix_type = RAZER_TYPE_MATRIX_STATIC;
         }
         else
         {
-            type = RAZER_TYPE_MATRIX_NOFRAME;
+            matrix_type = RAZER_TYPE_MATRIX_NOFRAME;
         }
 
         matrix_rows = 1;
@@ -258,7 +189,7 @@ void RGBController_OpenRazer::SetupMatrixDevice(std::string dev_path, unsigned i
     }
     else
     {
-        type = RAZER_TYPE_MATRIX_FRAME;
+        matrix_type = RAZER_TYPE_MATRIX_FRAME;
 
         matrix_rows = rows;
         matrix_cols = cols;
@@ -272,7 +203,7 @@ void RGBController_OpenRazer::SetupNonMatrixDevice(std::string dev_path)
     scroll_led_effect.open(dev_path + "/scroll_led_effect");
     scroll_led_rgb.open(dev_path + "/scroll_led_rgb");
 
-    type = RAZER_TYPE_NOMATRIX;
+    matrix_type = RAZER_TYPE_NOMATRIX;
 }
 
 RGBController_OpenRazer::RGBController_OpenRazer(std::string dev_path)
@@ -289,10 +220,30 @@ RGBController_OpenRazer::RGBController_OpenRazer(std::string dev_path)
     \*-----------------------------------------------------------------*/
     name = GetDeviceTypeString(dev_path);
 
+    /*-----------------------------------------------------------------*\
+    | Set the description to indicate this is an OpenRazer device       |
+    \*-----------------------------------------------------------------*/
+    description = "OpenRazer Device";
+    
+    /*-----------------------------------------------------------------*\
+    | Set the device path as the location                               |
+    \*-----------------------------------------------------------------*/
+    location = dev_path;
+
+    /*-----------------------------------------------------------------*\
+    | Get the serial number from the dev path                           |
+    \*-----------------------------------------------------------------*/
+    serial = GetSerialNumberString(dev_path);
+
+    /*-----------------------------------------------------------------*\
+    | Get the firmware version from the dev path                        |
+    \*-----------------------------------------------------------------*/
+    version = GetFirmwareVersionString(dev_path);
+
     /*-----------------------------------------------------------------*\
     | Loop through all known devices to look for a name match           |
     \*-----------------------------------------------------------------*/
-    for (int i = 0; i < RAZER_NUM_DEVICES; i++)
+    for (std::size_t i = 0; i < RAZER_NUM_DEVICES; i++)
     {
         if (device_list[i]->name == name)
         {
@@ -301,6 +252,11 @@ RGBController_OpenRazer::RGBController_OpenRazer(std::string dev_path)
             \*---------------------------------------------------------*/
             device = i;
 
+            /*---------------------------------------------------------*\
+            | Set device type                                           |
+            \*---------------------------------------------------------*/
+            type = device_list[i]->type;
+
             /*---------------------------------------------------------*\
             | Initialize modes                                          |
             \*---------------------------------------------------------*/
@@ -342,11 +298,11 @@ RGBController_OpenRazer::RGBController_OpenRazer(std::string dev_path)
                     new_zone.name = device_list[i]->zones[zone_id]->name;
                     new_zone.type = device_list[i]->zones[zone_id]->type;
 
-                    for (int row_id = 0; row_id < device_list[i]->zones[zone_id]->rows; row_id++)
+                    for (unsigned int row_id = 0; row_id < device_list[i]->zones[zone_id]->rows; row_id++)
                     {
                         std::vector<int> new_zone_map;
 
-                        for (int col_id = 0; col_id < device_list[i]->zones[zone_id]->cols; col_id++)
+                        for (unsigned int col_id = 0; col_id < device_list[i]->zones[zone_id]->cols; col_id++)
                         {
                             RGBColor new_color = 0x00000000;
                             colors.push_back(new_color);
@@ -367,4 +323,78 @@ RGBController_OpenRazer::RGBController_OpenRazer(std::string dev_path)
             }
         }
     }
+}
+
+void RGBController_OpenRazer::SetCustomMode()
+{
+    SetMode(RAZER_MODE_CUSTOM);
+}
+
+void RGBController_OpenRazer::UpdateMode()
+{
+    char update_value = 1;
+
+    switch(matrix_type)
+    {
+        case RAZER_TYPE_MATRIX_FRAME:
+        case RAZER_TYPE_MATRIX_NOFRAME:
+            {
+                switch(active_mode)
+                {
+                    case RAZER_MODE_CUSTOM:
+                        matrix_effect_custom.write(&update_value, 1);
+                        matrix_effect_custom.flush();
+                        break;
+                    
+                    case RAZER_MODE_OFF:
+                        matrix_effect_none.write(&update_value, 1);
+                        matrix_effect_none.flush();
+                        break;
+
+                    case RAZER_MODE_STATIC:
+                        break;
+
+                    case RAZER_MODE_BREATHING:
+                        break;
+
+                    case RAZER_MODE_SPECTRUM_CYCLE:
+                        matrix_effect_spectrum.write(&update_value, 1);
+                        matrix_effect_spectrum.flush();
+                        break;
+                    
+                    case RAZER_MODE_WAVE:
+                        matrix_effect_wave.write(&update_value, 1);
+                        matrix_effect_wave.flush();
+                        break;
+
+                    case RAZER_MODE_REACTIVE:
+                        matrix_effect_reactive.write(&update_value, 1);
+                        matrix_effect_reactive.flush();
+                        break;
+                }
+            }
+            break;
+
+        case RAZER_TYPE_NOMATRIX:
+            {
+                switch(active_mode)
+                {
+                    case RAZER_MODE_CUSTOM:
+                        update_value = 0;
+                        logo_led_effect.write(&update_value, 1);
+                        scroll_led_effect.write(&update_value, 1);
+                        logo_led_effect.flush();
+                        scroll_led_effect.flush();
+                        break;
+
+                    case RAZER_MODE_SPECTRUM_CYCLE:
+                        update_value = '4';
+                        logo_led_effect.write(&update_value, 1);
+                        scroll_led_effect.write(&update_value, 1);
+                        logo_led_effect.flush();
+                        scroll_led_effect.flush();
+                        break;
+                }
+            }
+    }
 }

RGBController/RGBController_OpenRazer.h

@@ -25,6 +25,7 @@ typedef struct
 typedef struct
 {
     std::string name;
+    device_type type;
     bool matrix_type;
     unsigned int rows;
     unsigned int cols;
@@ -53,6 +54,7 @@ static const razer_zone blackwidow_chroma_zone =
 static const razer_device blackwidow_chroma_device =
 {
     "Razer BlackWidow Chroma",
+    DEVICE_TYPE_KEYBOARD,
     true,
     6,
     22,
@@ -84,6 +86,7 @@ static const razer_zone blackwidow_chroma_te_zone =
 static const razer_device blackwidow_chroma_te_device =
 {
     "Razer BlackWidow Chroma Tournament Edition",
+    DEVICE_TYPE_KEYBOARD,
     true,
     6,
     22,
@@ -115,6 +118,7 @@ static const razer_zone ornata_chroma_zone =
 static const razer_device ornata_chroma_device =
 {
     "Razer Ornata Chroma",
+    DEVICE_TYPE_KEYBOARD,
     true,
     6,
     22,
@@ -146,6 +150,7 @@ static const razer_zone deathstalker_chroma_zone =
 static const razer_device deathstalker_chroma_device =
 {
     "Razer DeathStalker Chroma",
+    DEVICE_TYPE_KEYBOARD,
     true,
     1,
     12,
@@ -181,6 +186,7 @@ static const razer_zone blade_stealth_zone =
 static const razer_device blade_stealth_device =
 {
     "Razer Blade Stealth",
+    DEVICE_TYPE_KEYBOARD,
     true,
     6,
     16,
@@ -212,6 +218,7 @@ static const razer_zone blade_pro_late_2016_zone =
 static const razer_device blade_pro_late_2016_device =
 {
     "Razer Blade Pro (Late 2016)",
+    DEVICE_TYPE_KEYBOARD,
     true,
     6,
     25,
@@ -243,6 +250,7 @@ static const razer_zone blade_pro_2017_zone =
 static const razer_device blade_pro_2017_device =
 {
     "Razer Blade Pro (2017)",
+    DEVICE_TYPE_KEYBOARD,
     true,
     6,
     25,
@@ -314,6 +322,7 @@ static const razer_zone mamba_te_scroll_wheel_zone =
 static const razer_device mamba_te_device =
 {
     "Razer Mamba Tournament Edition",
+    DEVICE_TYPE_MOUSE,
     true,
     1,
     16,
@@ -393,6 +402,7 @@ static const razer_zone diamondback_chroma_scroll_wheel_zone =
 static const razer_device diamondback_chroma_device =
 {
     "Razer Diamondback Chroma",
+    DEVICE_TYPE_MOUSE,
     true,
     1,
     21,
@@ -436,6 +446,7 @@ static const razer_zone deathadder_chroma_scroll_wheel_zone =
 static const razer_device deathadder_chroma_device =
 {
     "Razer DeathAdder Chroma",
+    DEVICE_TYPE_MOUSE,
     false,
     1,
     2,
@@ -491,6 +502,7 @@ static const razer_zone naga_chroma_numpad_zone =
 static const razer_device naga_chroma_device =
 {
     "Razer Naga Chroma",
+    DEVICE_TYPE_MOUSE,
     false,
     1,
     3,
@@ -526,6 +538,7 @@ static const razer_zone orbweaver_chroma_zone =
 static const razer_device orbweaver_chroma_device =
 {
     "Razer Orbweaver Chroma",
+    DEVICE_TYPE_KEYBOARD,
     true,
     6,
     25,
@@ -557,6 +570,7 @@ static const razer_zone tartarus_chroma_zone =
 static const razer_device tartarus_chroma_device =
 {
     "Razer Tartarus Chroma",
+    DEVICE_TYPE_KEYBOARD,
     true,
     1,
     1,
@@ -592,6 +606,7 @@ static const razer_zone firefly_zone =
 static const razer_device firefly_device =
 {
     "Razer Firefly",
+    DEVICE_TYPE_MOUSEMAT,
     true,
     1,
     15,
@@ -623,6 +638,7 @@ static const razer_zone goliathus_extended_zone =
 static const razer_device goliathus_extended_device =
 {
     "Razer Goliathus Extended",
+    DEVICE_TYPE_MOUSEMAT,
     true,
     1,
     1,
@@ -658,6 +674,7 @@ static const razer_zone kraken_chroma_zone =
 static const razer_device kraken_chroma_device =
 {
     "Razer Kraken 7.1 Chroma",
+    DEVICE_TYPE_HEADSET,
     true,
     1,
     1,
@@ -689,6 +706,7 @@ static const razer_zone kraken_v2_zone =
 static const razer_device kraken_v2_device =
 {
     "Razer Kraken 7.1 V2",
+    DEVICE_TYPE_HEADSET,
     true,
     1,
     1,
@@ -736,6 +754,7 @@ static const razer_zone core_led_strip_zone =
 static const razer_device core_device =
 {
     "Razer Core",
+    DEVICE_TYPE_UNKNOWN,
     true,
     1,
     9,
@@ -767,6 +786,7 @@ static const razer_zone mug_holder_zone =
 static const razer_device mug_holder_device =
 {
     "Razer Chroma Mug Holder",
+    DEVICE_TYPE_UNKNOWN,
     true,
     1,
     15,
@@ -810,6 +830,7 @@ static const razer_zone chromahdk_zone =
 static const razer_device chromahdk_device =
 {
     "Razer Chroma HDK",
+    DEVICE_TYPE_LEDSTRIP,
     true,
     4,
     16,
@@ -899,13 +920,12 @@ public:
 
 public:
     RGBController_OpenRazer(std::string dev_path);
-    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();
+    void        UpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        SetCustomMode();
+    void        UpdateMode();
 
     int device;
 
@@ -913,7 +933,7 @@ private:
     void SetupMatrixDevice(std::string dev_path, unsigned int rows, unsigned int cols);
     void SetupNonMatrixDevice(std::string dev_path);
 
-    unsigned int type;
+    unsigned int matrix_type;
     unsigned int matrix_rows;
     unsigned int matrix_cols;
 
@@ -932,4 +952,4 @@ private:
     std::ofstream logo_led_rgb;
     std::ofstream scroll_led_effect;
     std::ofstream scroll_led_rgb;
-};
+};

RGBController/RGBController_PatriotViper.cpp

@@ -0,0 +1,202 @@
+/*-----------------------------------------*\
+|  RGBController_PatriotViper.cpp           |
+|                                           |
+|  Generic RGB Interface for OpenRGB        |
+|  Patriot Viper RGB interface              |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 1/1/2020    |
+\*-----------------------------------------*/
+
+#include "RGBController_PatriotViper.h"
+
+void RGBController_PatriotViper::UpdateLEDs()
+{
+    if(viper->direct == true)
+    {
+        for(int led = 0; led < 5; led++)
+        {
+            RGBColor      color = colors[led];
+            unsigned char red   = RGBGetRValue(color);
+            unsigned char grn   = RGBGetGValue(color);
+            unsigned char blu   = RGBGetBValue(color);
+            viper->SetLEDColor(led, red, grn, blu);
+        }
+    }
+    else
+    {
+        for(int led = 0; led < 5; led++)
+        {
+            RGBColor      color = colors[led];
+            unsigned char red   = RGBGetRValue(color);
+            unsigned char grn   = RGBGetGValue(color);
+            unsigned char blu   = RGBGetBValue(color);
+            viper->SetLEDEffectColor(led, red, grn, blu);
+        }
+    }
+}
+
+void RGBController_PatriotViper::UpdateZoneLEDs(int zone)
+{
+    UpdateLEDs();
+}
+
+void RGBController_PatriotViper::UpdateSingleLED(int led)
+{
+    RGBColor      color = colors[led];
+    unsigned char red   = RGBGetRValue(color);
+    unsigned char grn   = RGBGetGValue(color);
+    unsigned char blu   = RGBGetBValue(color);
+
+    if(viper->direct == true)
+    {
+        viper->SetLEDColor(led, red, grn, blu);
+    }
+    else
+    {
+        viper->SetLEDEffectColor(led, red, grn, blu);
+    }
+}
+
+RGBController_PatriotViper::RGBController_PatriotViper(PatriotViperController* viper_ptr)
+{
+    viper = viper_ptr;
+
+    name = viper->GetDeviceName();
+    location = viper->GetDeviceLocation();
+    
+    type = DEVICE_TYPE_DRAM;
+
+    mode Direct;
+    Direct.name      = "Direct";
+    Direct.value     = 0xFFFF;
+    Direct.flags     = MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR;
+    Direct.speed_min = 0;
+    Direct.speed_max = 0;
+    Direct.random    = false;
+    Direct.speed     = 0;
+    modes.push_back(Direct);
+
+    mode Dark;
+    Dark.name      = "Dark";
+    Dark.value     = VIPER_MODE_DARK;
+    Dark.flags     = 0;
+    Dark.speed_min = 0;
+    Dark.speed_max = 0;
+    Dark.random    = false;
+    Dark.speed     = 0;
+    modes.push_back(Dark);
+
+    mode Breathing;
+    Breathing.name      = "Breathing";
+    Breathing.value     = VIPER_MODE_BREATHING;
+    Breathing.flags     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR;
+    Breathing.speed_min = VIPER_SPEED_BREATHING_MIN;
+    Breathing.speed_max = VIPER_SPEED_BREATHING_MAX;
+    Breathing.random    = false;
+    Breathing.speed     = VIPER_SPEED_BREATHING_DEFAULT;
+    modes.push_back(Breathing);
+
+    mode Viper;
+    Viper.name      = "Viper";
+    Viper.value     = VIPER_MODE_VIPER;
+    Viper.flags     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR;
+    Viper.speed_min = VIPER_SPEED_MIN;
+    Viper.speed_max = VIPER_SPEED_MAX;
+    Viper.random    = false;
+    Viper.speed     = VIPER_SPEED_DEFAULT;
+    modes.push_back(Viper);
+
+    mode Heartbeat;
+    Heartbeat.name      = "Heartbeat";
+    Heartbeat.value     = VIPER_MODE_HEARTBEAT;
+    Heartbeat.flags     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR;
+    Heartbeat.speed_min = VIPER_SPEED_MIN;
+    Heartbeat.speed_max = VIPER_SPEED_MAX;
+    Heartbeat.random    = false;
+    Heartbeat.speed     = VIPER_SPEED_DEFAULT;
+    modes.push_back(Heartbeat);
+
+    mode Marquee;
+    Marquee.name      = "Marquee";
+    Marquee.value     = VIPER_MODE_MARQUEE;
+    Marquee.flags     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR;
+    Marquee.speed_min = VIPER_SPEED_MIN;
+    Marquee.speed_max = VIPER_SPEED_MAX;
+    Marquee.random    = false;
+    Marquee.speed     = VIPER_SPEED_DEFAULT;
+    modes.push_back(Marquee);
+
+    mode Raindrop;
+    Raindrop.name      = "Raindrop";
+    Raindrop.value     = VIPER_MODE_RAINDROP;
+    Raindrop.flags     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR;
+    Raindrop.speed_min = VIPER_SPEED_MIN;
+    Raindrop.speed_max = VIPER_SPEED_MAX;
+    Raindrop.random    = false;
+    Raindrop.speed     = VIPER_SPEED_DEFAULT;
+    modes.push_back(Raindrop);
+
+    mode Aurora;
+    Aurora.name      = "Aurora";
+    Aurora.value     = VIPER_MODE_AURORA;
+    Aurora.flags     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR;
+    Aurora.speed_min = VIPER_SPEED_MIN;
+    Aurora.speed_max = VIPER_SPEED_MAX;
+    Aurora.random    = false;
+    Aurora.speed     = VIPER_SPEED_DEFAULT;
+    modes.push_back(Aurora);
+
+    colors.resize(viper->GetLEDCount());
+
+    unsigned int led_idx = 0;
+    for(unsigned int slot = 0; slot < viper->GetSlotCount(); slot++)
+    {
+        zone* new_zone = new zone;
+
+        char slot_idx_str[3];
+        sprintf(slot_idx_str, "%d", slot);
+        new_zone->name = "Patriot Viper RGB Slot ";
+        new_zone->name.append(slot_idx_str);
+
+        new_zone->type = ZONE_TYPE_LINEAR;
+
+        std::vector<int> *new_zone_map = new std::vector<int>();
+
+        for(int led_slot_idx = 0; led_slot_idx < 5; led_slot_idx++)
+        {
+            led* new_led = new led();
+
+            char led_idx_str[3];
+            sprintf(led_idx_str, "%d", led_slot_idx);
+            new_led->name = "Patriot Viper RGB Slot ";
+            new_led->name.append(slot_idx_str);
+            new_led->name.append(", LED ");
+            new_led->name.append(led_idx_str);
+
+            leds.push_back(*new_led);
+
+            new_zone_map->push_back(led_idx);
+            led_idx++;
+        }
+
+        new_zone->map.push_back(*new_zone_map);
+        zones.push_back(*new_zone);
+    }
+}
+
+void RGBController_PatriotViper::SetCustomMode()
+{
+    SetMode(0);
+}
+
+void RGBController_PatriotViper::UpdateMode()
+{
+    if(modes[active_mode].value == 0xFFFF)
+    {
+        viper->SetDirect();
+    }
+    else
+    {
+        viper->SetMode(modes[active_mode].value, modes[active_mode].speed);
+    }
+}

RGBController/RGBController_PatriotViper.h

@@ -0,0 +1,28 @@
+/*-----------------------------------------*\
+|  RGBController_PatriotViper.h             |
+|                                           |
+|  Generic RGB Interface for OpenRGB        |
+|  Patriot Viper RGB interface              |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 1/1/2020    |
+\*-----------------------------------------*/
+
+#pragma once
+
+#include "RGBController.h"
+#include "PatriotViperController.h"
+
+class RGBController_PatriotViper : public RGBController
+{
+public:
+    RGBController_PatriotViper(PatriotViperController* viper_ptr);
+    void        UpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        SetCustomMode();
+    void        UpdateMode();
+
+private:
+    PatriotViperController* viper;
+};

RGBController/RGBController_Polychrome.cpp

@@ -0,0 +1,93 @@
+/*-----------------------------------------*\
+|  RGBController_Polychrome.cpp             |
+|                                           |
+|  Generic RGB Interface for OpenRGB        |
+|  ASRock ASR LED and Polychrome RGB Driver |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 12/15/2019  |
+\*-----------------------------------------*/
+
+#include "RGBController_Polychrome.h"
+
+
+void RGBController_Polychrome::UpdateLEDs()
+{
+    for (std::size_t led = 0; led < colors.size(); led++)
+    {
+        unsigned char red = RGBGetRValue(colors[led]);
+        unsigned char grn = RGBGetGValue(colors[led]);
+        unsigned char blu = RGBGetBValue(colors[led]);
+
+        polychrome->SetLEDColor(led, red, grn, blu);
+    }
+}
+
+void RGBController_Polychrome::UpdateZoneLEDs(int zone)
+{
+    UpdateLEDs();
+}
+
+void RGBController_Polychrome::UpdateSingleLED(int led)
+{
+    UpdateLEDs();
+}
+
+static const char* polychrome_zone_names[] =
+{
+    "Motherboard"
+};
+
+RGBController_Polychrome::RGBController_Polychrome(PolychromeController* polychrome_ptr)
+{
+    polychrome = polychrome_ptr;
+
+    name = polychrome->GetDeviceName();
+
+    mode polychrome_modes[POLYCHROME_NUM_MODES];
+
+    polychrome_modes[0].name = "Static";
+    polychrome_modes[1].name = "Breathing";
+    polychrome_modes[2].name = "Flashing";
+
+    for (int i = 0; i < POLYCHROME_NUM_MODES; i++)
+    {
+        modes.push_back(polychrome_modes[i]);
+    }
+
+    colors.resize(polychrome->GetLEDCount());
+
+    // Search through all LEDs and create zones for each channel type
+    for (unsigned int i = 0; i < polychrome->GetLEDCount(); i++)
+    {
+        zone* new_zone = new zone();
+        led* new_led = new led();
+
+        std::vector<int>* zone_row = new std::vector<int>();
+
+        // Set zone name to channel name
+        new_zone->name = polychrome_zone_names[i];
+        new_led->name = polychrome_zone_names[i];
+
+        zone_row->push_back(i);
+
+        // Aura devices can be either single or linear, never matrix
+        // That means only one row is needed
+        new_zone->map.push_back(*zone_row);
+
+        // Push new LED to LEDs vector
+        leds.push_back(*new_led);
+
+        // Push new zone to zones vector
+        zones.push_back(*new_zone);
+    }
+}
+
+void RGBController_Polychrome::SetCustomMode()
+{
+    SetMode(0);
+}
+
+void RGBController_Polychrome::UpdateMode()
+{
+    polychrome->SetMode(active_mode);
+}

RGBController/RGBController_Polychrome.h

@@ -0,0 +1,28 @@
+/*-----------------------------------------*\
+|  RGBController_Polychrome.h               |
+|                                           |
+|  Generic RGB Interface for OpenRGB        |
+|  ASRock ASR LED and Polychrome RGB Driver |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 12/15/2019  |
+\*-----------------------------------------*/
+
+#pragma once
+
+#include "RGBController.h"
+#include "PolychromeController.h"
+
+class RGBController_Polychrome : public RGBController
+{
+public:
+    RGBController_Polychrome(PolychromeController* polychrome_ptr);
+    void        UpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        SetCustomMode();
+    void        UpdateMode();
+
+private:
+    PolychromeController* polychrome;
+};

RGBController/RGBController_PoseidonZRGB.cpp

@@ -0,0 +1,53 @@
+/*-----------------------------------------*\
+|  RGBController_PoseidonZRGB.cpp           |
+|                                           |
+|  Generic RGB Interface for Thermaltake    |
+|  Poseidon Z RGB Keyboard                  |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 12/25/2019  |
+\*-----------------------------------------*/
+
+#include "RGBController_PoseidonZRGB.h"
+
+RGBController_PoseidonZRGB::RGBController_PoseidonZRGB(PoseidonZRGBController* poseidon_ptr)
+{
+    poseidon = poseidon_ptr;
+
+    name = "Thermaltake Poseidon Z RGB";
+    type = DEVICE_TYPE_KEYBOARD;
+
+    for(int i = 0; i < 104; i++)
+    {
+        colors.push_back(0x00000000);
+    }
+}
+
+RGBController_PoseidonZRGB::~RGBController_PoseidonZRGB()
+{
+
+}
+
+void RGBController_PoseidonZRGB::UpdateLEDs()
+{
+    poseidon->SetLEDsDirect(colors);
+}
+
+void RGBController_PoseidonZRGB::UpdateZoneLEDs(int zone)
+{
+    poseidon->SetLEDs(colors);
+}
+
+void RGBController_PoseidonZRGB::UpdateSingleLED(int led)
+{
+    poseidon->SetLEDs(colors);
+}
+
+void RGBController_PoseidonZRGB::SetCustomMode()
+{
+
+}
+
+void RGBController_PoseidonZRGB::UpdateMode()
+{
+
+}

RGBController/RGBController_PoseidonZRGB.h

@@ -0,0 +1,28 @@
+/*-----------------------------------------*\
+|  RGBController_PoseidonZRGB.h             |
+|                                           |
+|  Generic RGB Interface for Thermaltake    |
+|  Poseidon Z RGB Keyboard                  |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 12/25/2019  |
+\*-----------------------------------------*/
+
+#pragma once
+#include "RGBController.h"
+#include "PoseidonZRGBController.h"
+
+class RGBController_PoseidonZRGB : public RGBController
+{
+public:
+    RGBController_PoseidonZRGB(PoseidonZRGBController* poseidon_ptr);
+    ~RGBController_PoseidonZRGB();
+    void        UpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        SetCustomMode();
+    void        UpdateMode();
+
+private:
+    PoseidonZRGBController*   poseidon;
+};

RGBController/RGBController_RGBFusion.cpp

@@ -0,0 +1,135 @@
+/*-----------------------------------------*\
+|  RGBController_RGBFusion.cpp              |
+|                                           |
+|  Generic RGB Interface for OpenRGB        |
+|  Gigabyte RGB Fusion Driver               |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 12/11/2019  |
+\*-----------------------------------------*/
+
+#include "RGBController_RGBFusion.h"
+
+
+void RGBController_RGBFusion::UpdateLEDs()
+{
+    for (std::size_t led = 0; led < colors.size(); led++)
+    {
+        RGBColor      color = colors[led];
+        unsigned char red   = RGBGetRValue(color);
+        unsigned char grn   = RGBGetGValue(color);
+        unsigned char blu   = RGBGetBValue(color);
+
+        rgb_fusion->SetLEDColor(led, red, grn, blu);
+    }
+}
+
+void RGBController_RGBFusion::UpdateZoneLEDs(int zone)
+{
+    RGBColor      color = colors[zone];
+    unsigned char red   = RGBGetRValue(color);
+    unsigned char grn   = RGBGetGValue(color);
+    unsigned char blu   = RGBGetBValue(color);
+
+    rgb_fusion->SetLEDColor(zone, red, grn, blu);
+}
+
+void RGBController_RGBFusion::UpdateSingleLED(int led)
+{
+    UpdateZoneLEDs(led);
+}
+
+static const char* rgb_fusion_zone_names[] =
+{
+    "Motherboard",
+    "RGB Header"
+};
+
+RGBController_RGBFusion::RGBController_RGBFusion(RGBFusionController* rgb_fusion_ptr)
+{
+    rgb_fusion = rgb_fusion_ptr;
+
+    name = rgb_fusion->GetDeviceName();
+    description = "RGB Fusion 1.0";
+    location = rgb_fusion->GetDeviceLocation();
+
+    type = DEVICE_TYPE_MOTHERBOARD;
+
+    mode Static;
+    Static.name  = "Static";
+    Static.value = RGB_FUSION_MODE_STATIC;
+    Static.flags = MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR;
+    modes.push_back(Static);
+
+    mode Breathing;
+    Breathing.name      = "Breathing";
+    Breathing.value     = RGB_FUSION_MODE_BREATHING;
+    Breathing.flags     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR;
+    Breathing.speed_min = RGB_FUSION_SPEED_SLOW;
+    Breathing.speed_max = RGB_FUSION_SPEED_FAST;
+    Breathing.speed     = RGB_FUSION_SPEED_NORMAL;
+    modes.push_back(Breathing);
+
+    mode Flashing;
+    Flashing.name      = "Flashing";
+    Flashing.value     = RGB_FUSION_MODE_FLASHING;
+    Flashing.flags     = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_COLOR | MODE_FLAG_PER_LED_COLOR;
+    Flashing.speed_min = RGB_FUSION_SPEED_SLOW;
+    Flashing.speed_max = RGB_FUSION_SPEED_FAST;
+    Flashing.speed     = RGB_FUSION_SPEED_NORMAL;
+    modes.push_back(Flashing);
+
+    colors.resize(rgb_fusion->GetLEDCount());
+
+    // Search through all LEDs and create zones for each channel type
+    for (unsigned int i = 0; i < rgb_fusion->GetLEDCount(); i++)
+    {
+        zone* new_zone = new zone();
+        led*  new_led  = new led();
+
+        std::vector<int>* zone_row = new std::vector<int>();
+
+        // Set zone name to channel name
+        new_zone->name = rgb_fusion_zone_names[i];
+        new_led->name  = rgb_fusion_zone_names[i];
+
+        zone_row->push_back(i);
+
+        // Aura devices can be either single or linear, never matrix
+        // That means only one row is needed
+        new_zone->map.push_back(*zone_row);
+
+        // Push new LED to LEDs vector
+        leds.push_back(*new_led);
+
+        // Push new zone to zones vector
+        zones.push_back(*new_zone);
+    }
+
+    // Initialize active mode
+    active_mode = GetDeviceMode();
+}
+
+int RGBController_RGBFusion::GetDeviceMode()
+{
+    int dev_mode = rgb_fusion->GetMode();
+
+    for(int mode = 0; mode < modes.size(); mode++)
+    {
+        if(modes[mode].value == dev_mode)
+        {
+            return(mode);
+        }
+    }
+
+    return(0);
+}
+
+void RGBController_RGBFusion::SetCustomMode()
+{
+    rgb_fusion->SetMode(RGB_FUSION_MODE_STATIC, 0);
+}
+
+void RGBController_RGBFusion::UpdateMode()
+{
+    rgb_fusion->SetMode(modes[active_mode].value, modes[active_mode].speed);
+}

RGBController/RGBController_RGBFusion.h

@@ -0,0 +1,30 @@
+/*-----------------------------------------*\
+|  RGBController_RGBFusion.h                |
+|                                           |
+|  Generic RGB Interface for OpenRGB        |
+|  Gigabyte RGB Fusion Driver               |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 12/11/2019  |
+\*-----------------------------------------*/
+
+#pragma once
+
+#include "RGBController.h"
+#include "RGBFusionController.h"
+
+class RGBController_RGBFusion : public RGBController
+{
+public:
+    RGBController_RGBFusion(RGBFusionController* rgb_fusion_ptr);
+    void        UpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        SetCustomMode();
+    void        UpdateMode();
+
+private:
+    RGBFusionController* rgb_fusion;
+
+    int         GetDeviceMode();
+};

RGBController/RGBController_RazerChromaSDK.cpp

@@ -22,9 +22,11 @@ RGBController_RazerChromaSDK::RGBController_RazerChromaSDK(unsigned int device_t
 
     for (int i = 0; i < RAZER_NUM_DEVICES; i++)
     {
-        if (device_list[i]->type == device_type)
+        if (device_list[i]->razer_type == device_type)
         {
             name = device_list[i]->name;
+            type = device_list[i]->type;
+            location = "Razer Chroma SDK";
 
             for (int zone_id = 0; zone_id < RAZER_MAX_ZONES; zone_id++)
             {
@@ -68,54 +70,9 @@ RGBController_RazerChromaSDK::RGBController_RazerChromaSDK(unsigned int device_t
     if(CreateChromaLinkEffect == NULL) CreateChromaLinkEffect = (CREATECHROMALINKEFFECT)GetProcAddress(*hModule, "CreateChromaLinkEffect");
 }
 
-int RGBController_RazerChromaSDK::GetMode()
-{
-    return 0;
-}
-
-void RGBController_RazerChromaSDK::SetMode(int mode)
-{
-
-}
-
-void RGBController_RazerChromaSDK::SetCustomMode()
-{
-
-}
-
-void RGBController_RazerChromaSDK::SetAllLEDs(RGBColor color)
-{
-    for (int i = 0; i < colors.size(); i++)
-    {
-        colors[i] = color;
-    }
-
-    UpdateLEDs();
-}
-
-void RGBController_RazerChromaSDK::SetAllZoneLEDs(int zone, RGBColor color)
-{
-    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;
-        }
-    }
-
-    UpdateLEDs();
-}
-
-void RGBController_RazerChromaSDK::SetLED(int led, RGBColor color)
-{
-    colors[led] = color;
-
-    UpdateLEDs();
-}
-
 void RGBController_RazerChromaSDK::UpdateLEDs()
 {
-    switch (device->type)
+    switch (device->razer_type)
     {
     case RAZER_GENERIC_MOUSE:
         {
@@ -186,4 +143,24 @@ void RGBController_RazerChromaSDK::UpdateLEDs()
         }
         break;
     }
+}
+
+void RGBController_RazerChromaSDK::UpdateZoneLEDs(int zone)
+{
+    UpdateLEDs();
+}
+
+void RGBController_RazerChromaSDK::UpdateSingleLED(int led)
+{
+    UpdateLEDs();
+}
+
+void RGBController_RazerChromaSDK::SetCustomMode()
+{
+
+}
+
+void RGBController_RazerChromaSDK::UpdateMode()
+{
+
 }

RGBController/RGBController_RazerChromaSDK.h

@@ -59,6 +59,7 @@ typedef struct
 typedef struct
 {
     std::string name;
+    unsigned int razer_type;
     unsigned int type;
     const razer_zone* zones[RAZER_MAX_ZONES];
 } razer_device;
@@ -136,6 +137,7 @@ static const razer_device mouse_device =
 {
     "Razer Generic Mouse",
     RAZER_GENERIC_MOUSE,
+    DEVICE_TYPE_MOUSE,
     {
         &mouse_left_zone,
         &mouse_right_zone,
@@ -164,6 +166,7 @@ static const razer_device mousepad_device =
 {
     "Razer Generic Mousepad",
     RAZER_GENERIC_MOUSEPAD,
+    DEVICE_TYPE_MOUSE,
     {
         &mousepad_zone,
         NULL,
@@ -204,6 +207,7 @@ static const razer_device chromahdk_device =
 {
     "Razer Chroma HDK",
     RAZER_CHROMA_HDK,
+    DEVICE_TYPE_LEDSTRIP,
     {
         &chromahdk_zone,
         &chromahdk_zone,
@@ -225,13 +229,12 @@ class RGBController_RazerChromaSDK : public RGBController
 {
 public:
     RGBController_RazerChromaSDK(unsigned int device_type, HMODULE* hModule);
-    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();
+    void        UpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        SetCustomMode();
+    void        UpdateMode();
 
 private:
     const razer_device* device;
@@ -242,4 +245,4 @@ private:
     static CREATEMOUSEPADEFFECT CreateMousepadEffect;
     static CREATEHEADSETEFFECT CreateHeadsetEffect;
     static CREATECHROMALINKEFFECT CreateChromaLinkEffect;
-};
+};