Fix include path for NvAPI

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,6 @@
 [submodule "dependencies/libe131"]
 	path = dependencies/libe131
-	url = https://github.com/hhromic/libe131
+	url = https://github.com/CalcProgrammer1/libe131
+[submodule "razer-drivers-win32"]
+	path = razer-drivers-win32
+	url = https://github.com/rsandoz/razer-drivers-win32

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,79 @@
 #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  21
+
+static const unsigned char aura_ram_addresses[] =
+{
+    0x70,
+    0x71,
+    0x73,
+    0x74,
+    0x75,
+    0x76,
+    0x78,
+    0x79,
+    0x7A,
+    0x7B,
+    0x7C,
+    0x7D,
+    0x7E,
+    0x7F,
+    0x4F,
+    0x66,
+    0x67,
+    0x39,
+    0x3B,
+    0x3C,
+    0x3D
+};
+
+/*---------------------------------------------------------------------------------*\
+| 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 +135,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 +147,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,507 @@
+/*---------------------------------------------------------*\
+|  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,
+                                                unsigned char red3,
+                                                unsigned char grn3,
+                                                unsigned char blu3
+                                               )
+{
+    /*-----------------------------------------------------*\
+    | 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,
+        red3,
+        grn3,
+        blu3,
+        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,166 @@
+/*---------------------------------------------------------*\
+|  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();
+    
+    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,
+                                     unsigned char red3,
+                                     unsigned char grn3,
+                                     unsigned char blu3
+                                    );
+
+    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/CorsairController/CorsairControllerDetect.cpp

@@ -104,6 +104,22 @@ void DetectCorsairControllers(std::vector<i2c_smbus_interface*> &busses, std::ve
             new_controller = new RGBController_Corsair(new_corsair);
             rgb_controllers.push_back(new_controller);
         }
+
+        // Check for Corsair controller at 0x5E
+        if (TestForCorsairController(busses[bus], 0x5E))
+        {
+            new_corsair = new CorsairController(busses[bus], 0x5E);
+            new_controller = new RGBController_Corsair(new_corsair);
+            rgb_controllers.push_back(new_controller);
+        }
+
+        // Check for Corsair controller at 0x5F
+        if (TestForCorsairController(busses[bus], 0x5F))
+        {
+            new_corsair = new CorsairController(busses[bus], 0x5F);
+            new_controller = new RGBController_Corsair(new_corsair);
+            rgb_controllers.push_back(new_controller);
+        }
     }
 
 }   /* DetectCorsairControllers() */

Controllers/CorsairKeyboardController/CorsairKeyboardController.cpp

@@ -0,0 +1,253 @@
+/*-----------------------------------------*\
+|  CorsairKeyboardController.cpp            |
+|                                           |
+|  Driver for Corsair RGB keyboard lighting |
+|  controller                               |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 1/9/2020    |
+\*-----------------------------------------*/
+
+#include "CorsairKeyboardController.h"
+
+#include <cstring>
+
+static unsigned int keys[] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0C, 0x0D, 0x0E, 0x0F, 0x11, 0x12,
+                              0x14, 0x15, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x20, 0x21, 0x24, 0x25, 0x26,
+                              0x27, 0x28, 0x2A, 0x2B, 0x2C, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
+                              0x3C, 0x3D, 0x3E, 0x3F, 0x40, 0x42, 0x43, 0x44, 0x45, 0x48, 73,   74,   75,   76,   78,
+                              79,   80,   81,   84,   85,   86,   87,   88,   89,   90,   91,   92,   93,   96,   97,
+                              98,   99,   100,  101,  102,  103,  104,  105,  108,  109,  110,  111,  112,  113,  115,
+                              116,  117,  120,  121,  122,  123,  124,  126,  127,  128,  129,  132,  133,  134,  135,
+                              136,  137,  139,  140,  141};
+
+static void send_usb_msg(hid_device* dev, char * data_pkt)
+{
+    char usb_pkt[65];
+    usb_pkt[0] = 0x00;
+    for(int i = 1; i < 65; i++)
+    {
+        usb_pkt[i] = data_pkt[i-1];
+    }
+    int bytes = hid_send_feature_report(dev, (unsigned char *)usb_pkt, 65);
+    bytes++;
+}
+
+static void get_usb_msg(hid_device* dev, char* data_pkt)
+{
+    char usb_pkt[65];
+    usb_pkt[0] = 0x00;
+    for(int i = 1; i < 65; i++)
+    {
+        usb_pkt[i] = data_pkt[i-1];
+    }
+    int bytes = hid_get_feature_report(dev, (unsigned char*)data_pkt, 64);
+    bytes++;
+}
+
+CorsairKeyboardController::CorsairKeyboardController(hid_device* dev_handle)
+{
+    dev = dev_handle;
+
+    char data_pkt[64] = { 0 };
+
+    LightingControl();
+}
+
+CorsairKeyboardController::~CorsairKeyboardController()
+{
+
+}
+
+void CorsairKeyboardController::SetLEDs(std::vector<RGBColor> colors)
+{
+    unsigned char data_pkt[216];
+    unsigned char red_val[144];
+    unsigned char grn_val[144];
+    unsigned char blu_val[144];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffers                                      |
+    \*-----------------------------------------------------*/
+    memset(data_pkt, 0x00, sizeof( data_pkt ));
+    memset(red_val, 0x00, sizeof( red_val ));
+    memset(grn_val, 0x00, sizeof( grn_val ));
+    memset(blu_val, 0x00, sizeof( blu_val ));
+
+    /*-----------------------------------------------------*\
+    | Scale color values to 9-bit                           |
+    \*-----------------------------------------------------*/
+    for(int color_idx = 0; color_idx < colors.size(); color_idx++)
+    {
+        RGBColor      color = colors[color_idx];
+        unsigned char red   = RGBGetRValue(color);
+        unsigned char grn   = RGBGetGValue(color);
+        unsigned char blu   = RGBGetBValue(color);
+
+        if( red > 7 ) red = 7;
+        if( grn > 7 ) grn = 7;
+        if( blu > 7 ) blu = 7;
+
+        red = 7 - red;
+        grn = 7 - grn;
+        blu = 7 - blu;
+
+        red_val[keys[color_idx]] = red;
+        grn_val[keys[color_idx]] = grn;
+        blu_val[keys[color_idx]] = blu;
+    }
+
+    /*-----------------------------------------------------*\
+    | Pack the color values, 2 values per byte              |
+    \*-----------------------------------------------------*/
+    for(int red_idx = 0; red_idx < 72; red_idx++)
+    {
+        data_pkt[red_idx] = red_val[(red_idx * 2) + 1] << 4 | red_val[red_idx * 2];
+    }
+
+    for(int grn_idx = 0; grn_idx < 72; grn_idx++)
+    {
+        data_pkt[grn_idx + 72] = grn_val[(grn_idx * 2) + 1] << 4 | grn_val[grn_idx * 2];
+    }
+
+    for(int blu_idx = 0; blu_idx < 72; blu_idx++)
+    {
+        data_pkt[blu_idx + 144] = blu_val[(blu_idx * 2) + 1] << 4 | blu_val[blu_idx * 2];
+    }
+
+    /*-----------------------------------------------------*\
+    | Send the packets                                      |
+    \*-----------------------------------------------------*/
+    StreamPacket(1, 60, &data_pkt[0]);
+    StreamPacket(2, 60, &data_pkt[60]);
+    StreamPacket(3, 60, &data_pkt[120]);
+    StreamPacket(4, 36, &data_pkt[180]);
+    
+    SubmitLimitedColors(216);
+}
+
+/*-------------------------------------------------------------------------------------------------*\
+| Private packet sending functions.                                                                 |
+\*-------------------------------------------------------------------------------------------------*/
+
+void CorsairKeyboardController::LightingControl()
+{
+    char usb_buf[64];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up Lighting Control packet                        |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]   = CORSAIR_COMMAND_WRITE;
+    usb_buf[0x01]   = CORSAIR_PROPERTY_LIGHTING_CONTROL;
+    usb_buf[0x02]   = CORSAIR_LIGHTING_CONTROL_SOFTWARE;
+    usb_buf[0x04]   = 0x03;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    send_usb_msg(dev, usb_buf);
+}
+
+void CorsairKeyboardController::ReadFirmwareInfo()
+{
+    char usb_buf[64];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up Read Firmware Info packet                      |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]   = CORSAIR_COMMAND_READ;
+    usb_buf[0x01]   = CORSAIR_PROPERTY_FIRMWARE_INFO;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    send_usb_msg(dev, usb_buf);
+    get_usb_msg(dev, usb_buf);
+}
+
+void CorsairKeyboardController::StreamPacket
+    (
+    unsigned char   packet_id,
+    unsigned char   data_sz,
+    unsigned char*  data_ptr
+    )
+{
+    char usb_buf[64];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up Stream packet                                  |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]   = CORSAIR_COMMAND_STREAM;
+    usb_buf[0x01]   = packet_id;
+    usb_buf[0x02]   = data_sz;
+
+    /*-----------------------------------------------------*\
+    | Copy in data bytes                                    |
+    \*-----------------------------------------------------*/
+    memcpy(&usb_buf[0x04], data_ptr, data_sz);
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    send_usb_msg(dev, usb_buf);
+}
+
+void CorsairKeyboardController::SubmitColors()
+{
+    char usb_buf[64];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up Submit Keyboard 24-Bit Colors packet           |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]   = CORSAIR_COMMAND_WRITE;
+    usb_buf[0x01]   = CORSAIR_PROPERTY_SUBMIT_KEYBOARD_COLOR_24;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    send_usb_msg(dev, usb_buf);
+}
+
+void CorsairKeyboardController::SubmitLimitedColors
+    (
+    unsigned char   byte_count
+    )
+{
+    char usb_buf[64];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up Submit Keyboard 9-Bit Colors packet            |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]   = CORSAIR_COMMAND_WRITE;
+    usb_buf[0x01]   = CORSAIR_PROPERTY_SUBMIT_KEYBOARD_COLOR_9;
+    usb_buf[0x04]   = byte_count;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    send_usb_msg(dev, usb_buf);
+}

Controllers/CorsairKeyboardController/CorsairKeyboardController.h

@@ -0,0 +1,78 @@
+/*-----------------------------------------*\
+|  CorsairKeyboardController.h              |
+|                                           |
+|  Definitions and types for Corsair RGB    |
+|  keyboard lighting controller             |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 1/9/2020    |
+\*-----------------------------------------*/
+
+#include "RGBController.h"
+
+#include <string>
+#include <hidapi/hidapi.h>
+
+#pragma once
+
+enum
+{
+    CORSAIR_COMMAND_WRITE       = 0x07,
+    CORSAIR_COMMAND_READ        = 0x0E,
+    CORSAIR_COMMAND_STREAM      = 0x7F
+};
+
+enum
+{
+    CORSAIR_PROPERTY_FIRMWARE_INFO              = 0x01,
+    CORSAIR_PROPERTY_RESET                      = 0x02,
+    CORSAIR_PROPERTY_SPECIAL_FUNCTION           = 0x04,
+    CORSAIR_PROPERTY_LIGHTING_CONTROL           = 0x05,
+    CORSAIR_PROPERTY_HARDWARE_PROFILE           = 0x13,
+    CORSAIR_PROPERTY_SUBMIT_MOUSE_COLOR         = 0x22,
+    CORSAIR_PROPERTY_SUBMIT_KEYBOARD_COLOR_9    = 0x27,
+    CORSAIR_PROPERTY_SUBMIT_KEYBOARD_COLOR_24   = 0x28,
+};
+
+enum
+{
+    CORSAIR_LIGHTING_CONTROL_HARDWARE           = 0x01,
+    CORSAIR_LIGHTING_CONTROL_SOFTWARE           = 0x02
+};
+
+enum
+{
+    CORSAIR_COLOR_CHANNEL_RED       = 0x01,
+    CORSAIR_COLOR_CHANNEL_GREEN     = 0x02,
+    CORSAIR_COLOR_CHANNEL_BLUE      = 0x03
+};
+
+class CorsairKeyboardController
+{
+public:
+    CorsairKeyboardController(hid_device* dev_handle);
+    ~CorsairKeyboardController();
+
+    void SetLEDsDirect(std::vector<RGBColor> colors);
+    void SetLEDs(std::vector<RGBColor> colors);
+
+private:
+    hid_device*             dev;
+
+    void    LightingControl();
+
+    void    ReadFirmwareInfo();
+    
+    void    StreamPacket
+                (
+                unsigned char   packet_id,
+                unsigned char   data_sz,
+                unsigned char*  data_ptr
+                );
+
+    void    SubmitColors();
+
+    void    SubmitLimitedColors
+                (
+                unsigned char   byte_count
+                );
+};

Controllers/CorsairKeyboardController/CorsairKeyboardControllerDetect.cpp

@@ -0,0 +1,52 @@
+#include "CorsairKeyboardController.h"
+#include "RGBController.h"
+#include "RGBController_CorsairKeyboard.h"
+#include <vector>
+#include <hidapi/hidapi.h>
+
+#define CORSAIR_RGB_KEYBOARD_VID        0x1B1C
+#define CORSAIR_RGB_KEYBOARD_K70_PID    0x1B13
+#define CORSAIR_RGB_KEYBOARD_K95_PID    0x1B11
+
+/******************************************************************************************\
+*                                                                                          *
+*   DetectCorsairKeyboardControllers                                                       *
+*                                                                                          *
+*       Tests the USB address to see if a Corsair RGB Keyboard controller exists there.    *
+*                                                                                          *
+\******************************************************************************************/
+
+void DetectCorsairKeyboardControllers(std::vector<RGBController*>& rgb_controllers)
+{
+    hid_device_info* info;
+    hid_device* dev = NULL;
+
+    hid_init();
+
+    info = hid_enumerate(CORSAIR_RGB_KEYBOARD_VID, CORSAIR_RGB_KEYBOARD_K70_PID);
+
+    //Look for Corsair RGB Keyboard, interface 1
+    while(info)
+    {
+        if((info->vendor_id == CORSAIR_RGB_KEYBOARD_VID)
+         &&(info->product_id == CORSAIR_RGB_KEYBOARD_K70_PID)
+         &&(info->interface_number == 1))
+        {
+            dev = hid_open_path(info->path);
+            break;
+        }
+        else
+        {
+            info = info->next;
+        }
+    }
+
+    if( dev )
+    {
+        CorsairKeyboardController* controller = new CorsairKeyboardController(dev);
+
+        RGBController_CorsairKeyboard* rgb_controller = new RGBController_CorsairKeyboard(controller);
+
+        rgb_controllers.push_back(rgb_controller);
+    }
+}

Controllers/CorsairNodeProController/CorsairNodeProController.cpp

@@ -0,0 +1,507 @@
+/*---------------------------------------------------------*\
+|  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,
+                                                unsigned char red3,
+                                                unsigned char grn3,
+                                                unsigned char blu3
+                                               )
+{
+    /*-----------------------------------------------------*\
+    | 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,
+        red3,
+        grn3,
+        blu3,
+        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,173 @@
+/*---------------------------------------------------------*\
+|  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();
+    
+    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,
+                                     unsigned char red3,
+                                     unsigned char grn3,
+                                     unsigned char blu3
+                                    );
+
+    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() */
@@ -122,6 +121,22 @@ void DetectCorsairProControllers(std::vector<i2c_smbus_interface*> &busses, std:
             new_controller = new RGBController_CorsairPro(new_corsair_pro);
             rgb_controllers.push_back(new_controller);
         }
+
+        // Check for Corsair controller at 0x5E
+        if (TestForCorsairProController(busses[bus], 0x5E))
+        {
+            new_corsair_pro = new CorsairProController(busses[bus], 0x5E);
+            new_controller = new RGBController_CorsairPro(new_corsair_pro);
+            rgb_controllers.push_back(new_controller);
+        }
+
+        // Check for Corsair controller at 0x5F
+        if (TestForCorsairProController(busses[bus], 0x5F))
+        {
+            new_corsair_pro = new CorsairProController(busses[bus], 0x5F);
+            new_controller = new RGBController_CorsairPro(new_corsair_pro);
+            rgb_controllers.push_back(new_controller);
+        }
     }
 
 }   /* DetectCorsairProControllers() */

Controllers/CrucialController/CrucialController.cpp

@@ -0,0 +1,133 @@
+/*-----------------------------------------*\
+|  CrucialController.cpp                    |
+|                                           |
+|  Driver for Crucial Ballistix RGB lighting|
+|  controller                               |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 1/19/2020   |
+\*-----------------------------------------*/
+
+#include "RGBController.h"
+#include "CrucialController.h"
+#include <cstring>
+
+CrucialController::CrucialController(i2c_smbus_interface* bus, crucial_dev_id dev)
+{
+    this->bus = bus;
+    this->dev = dev;
+}
+
+CrucialController::~CrucialController()
+{
+
+}
+
+std::string CrucialController::GetDeviceName()
+{
+    return(device_name);
+}
+
+std::string CrucialController::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 CrucialController::GetLEDCount()
+{
+    return(led_count);
+}
+
+void CrucialController::SetMode(unsigned char mode)
+{
+    SendEffectMode(mode, 0x10);
+}
+
+void CrucialController::SetAllColorsDirect(RGBColor* colors)
+{
+    SendDirectColors(colors);
+}
+
+void CrucialController::SendEffectColors(unsigned char red, unsigned char green, unsigned char blue)
+{
+    CrucialRegisterWrite(0x82E9, 0xFF);
+    CrucialRegisterWrite(0x82EA, 0x00);
+    CrucialRegisterWrite(0x82EB, 0x00);
+    CrucialRegisterWrite(0x82EC, 0x00);
+    CrucialRegisterWrite(0x82ED, red);
+    CrucialRegisterWrite(0x82EE, green);
+    CrucialRegisterWrite(0x82EF, blue);
+    CrucialRegisterWrite(0x82F0, 0x01);
+}
+
+void CrucialController::SendBrightness(unsigned char brightness)
+{
+    CrucialRegisterWrite(0x82EE, 0xFF);
+    CrucialRegisterWrite(0x82EF, brightness);
+    CrucialRegisterWrite(0x82F0, 0x83);
+}
+
+void CrucialController::SendEffectMode(unsigned char mode, unsigned char speed)
+{
+    CrucialRegisterWrite(0x820F, mode);
+    CrucialRegisterWrite(0x82EE, 0x00);
+    CrucialRegisterWrite(0x82EF, speed);
+    CrucialRegisterWrite(0x82F0, 0x84);
+}
+
+void CrucialController::SendDirectColors(RGBColor* color_buf)
+{
+    //Red Channels
+    CrucialRegisterWrite(0x8300, RGBGetRValue(color_buf[0]));
+    CrucialRegisterWrite(0x8301, RGBGetRValue(color_buf[1]));
+    CrucialRegisterWrite(0x8302, RGBGetRValue(color_buf[2]));
+    CrucialRegisterWrite(0x8303, RGBGetRValue(color_buf[3]));
+    CrucialRegisterWrite(0x8304, RGBGetRValue(color_buf[4]));
+    CrucialRegisterWrite(0x8305, RGBGetRValue(color_buf[5]));
+    CrucialRegisterWrite(0x8306, RGBGetRValue(color_buf[6]));
+    CrucialRegisterWrite(0x8307, RGBGetRValue(color_buf[7]));
+
+    //Green Channels
+    CrucialRegisterWrite(0x8340, RGBGetGValue(color_buf[0]));
+    CrucialRegisterWrite(0x8341, RGBGetGValue(color_buf[1]));
+    CrucialRegisterWrite(0x8342, RGBGetGValue(color_buf[2]));
+    CrucialRegisterWrite(0x8343, RGBGetGValue(color_buf[3]));
+    CrucialRegisterWrite(0x8344, RGBGetGValue(color_buf[4]));
+    CrucialRegisterWrite(0x8345, RGBGetGValue(color_buf[5]));
+    CrucialRegisterWrite(0x8346, RGBGetGValue(color_buf[6]));
+    CrucialRegisterWrite(0x8347, RGBGetGValue(color_buf[7]));
+
+    //Blue Channels
+    CrucialRegisterWrite(0x8380, RGBGetBValue(color_buf[0]));
+    CrucialRegisterWrite(0x8381, RGBGetBValue(color_buf[1]));
+    CrucialRegisterWrite(0x8382, RGBGetBValue(color_buf[2]));
+    CrucialRegisterWrite(0x8383, RGBGetBValue(color_buf[3]));
+    CrucialRegisterWrite(0x8384, RGBGetBValue(color_buf[4]));
+    CrucialRegisterWrite(0x8385, RGBGetBValue(color_buf[5]));
+    CrucialRegisterWrite(0x8386, RGBGetBValue(color_buf[6]));
+    CrucialRegisterWrite(0x8387, RGBGetBValue(color_buf[7]));
+}
+
+unsigned char CrucialController::CrucialRegisterRead(crucial_register reg)
+{
+    //Write Crucial register
+    bus->i2c_smbus_write_word_data(dev, 0x00, ((reg << 8) & 0xFF00) | ((reg >> 8) & 0x00FF));
+
+    //Read Crucial value
+    return(bus->i2c_smbus_read_byte_data(dev, 0x81));
+
+}
+
+void CrucialController::CrucialRegisterWrite(crucial_register reg, unsigned char val)
+{
+    //Write Crucial register
+    bus->i2c_smbus_write_word_data(dev, 0x00, ((reg << 8) & 0xFF00) | ((reg >> 8) & 0x00FF));
+
+    //Write Crucial value
+    bus->i2c_smbus_write_byte_data(dev, 0x01, val);
+
+}

Controllers/CrucialController/CrucialController.h

@@ -0,0 +1,62 @@
+/*-----------------------------------------*\
+|  CrucialController.h                      |
+|                                           |
+|  Definitions and types for Crucial        |
+|  Ballistix RGB lighting controller        |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 1/19/2020   |
+\*-----------------------------------------*/
+
+#include "RGBController.h"
+#include <string>
+#include "i2c_smbus.h"
+
+#pragma once
+
+typedef unsigned char	crucial_dev_id;
+typedef unsigned short	crucial_register;
+
+enum
+{
+    CRUCIAL_MODE_SHIFT              = 0x1F,     /* Shift effect mode                */
+    CRUCIAL_MODE_GRADIENT_SHIFT     = 0x2F,     /* Gradient shift mode              */
+    CRUCIAL_MODE_FILL               = 0x3F,     /* Fill effect mode                 */
+    CRUCIAL_MODE_STACK              = 0x4F,     /* Stack effect mode                */
+    CRUCIAL_MODE_DOUBLE_STACK       = 0x5F,     /* Double stack effect mode         */
+    CRUCIAL_MODE_BREATHING          = 0x6F,     /* Breathing effect mode            */
+    CRUCIAL_MODE_MOTION_POINT       = 0x7F,     /* Motion point effect mode         */
+    CRUCIAL_MODE_INSIDE_OUT         = 0x8F,     /* Inside out effect mode           */
+    CRUCIAL_MODE_COLOR_STEP         = 0x9F,     /* Color step effect mode           */
+    CRUCIAL_MODE_WATER_WAVE         = 0xAF,     /* Water wave effect mode           */
+    CRUCIAL_MODE_FLASHING           = 0xBF,     /* Flashing effect mode             */
+    CRUCIAL_MODE_STATIC             = 0xCF,     /* Static effect mode               */
+};
+
+class CrucialController
+{
+public:
+    CrucialController(i2c_smbus_interface* bus, crucial_dev_id dev);
+    ~CrucialController();
+
+    std::string   GetDeviceName();
+    std::string   GetDeviceLocation();
+    unsigned int  GetLEDCount();
+    void          SetAllColorsDirect(RGBColor* colors);
+    void          SetMode(unsigned char mode);
+
+    unsigned char CrucialRegisterRead(crucial_register reg);
+    void          CrucialRegisterWrite(crucial_register reg, unsigned char val);
+
+private:
+    char                    device_name[16];
+    unsigned char           config_table[64];
+    unsigned int            led_count;
+    unsigned char           channel_cfg;
+    i2c_smbus_interface *   bus;
+    crucial_dev_id          dev;
+
+    void            SendDirectColors(RGBColor* color_buf);
+    void            SendEffectColors(unsigned char red, unsigned char green, unsigned char blue);
+    void            SendBrightness(unsigned char brightness);
+    void            SendEffectMode(unsigned char mode, unsigned char speed);
+};

Controllers/CrucialController/CrucialControllerDetect.cpp

@@ -0,0 +1,88 @@
+#include "CrucialController.h"
+#include "RGBController.h"
+#include "RGBController_Crucial.h"
+#include "i2c_smbus.h"
+#include <vector>
+#include <stdio.h>
+#include <stdlib.h>
+
+/*----------------------------------------------------------------------*\
+| This list contains the available SMBus addresses for Crucial RAM       |
+\*----------------------------------------------------------------------*/
+#define CRUCIAL_ADDRESS_COUNT  4
+
+static const unsigned char crucial_addresses[] =
+{
+    0x20,
+    0x21,
+    0x22,
+    0x23
+};
+
+
+/******************************************************************************************\
+*                                                                                          *
+*   TestForCrucialController                                                               *
+*                                                                                          *
+*       Tests the given address to see if an Crucial controller exists there.  First does a*
+*       quick write to test for a response, and if so does a simple read at 0xA0 to test   *
+*       for incrementing values 0...F which was observed at this location during data dump *
+*                                                                                          *
+\******************************************************************************************/
+
+bool TestForCrucialController(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;
+
+        for (int i = 0xA0; i < 0xB0; i++)
+        {
+            res = bus->i2c_smbus_read_byte_data(address, i);
+
+            if (res != (i - 0xA0))
+            {
+                pass = false;
+            }
+        }
+    }
+
+    return(pass);
+
+}   /* TestForCrucialController() */
+
+/******************************************************************************************\
+*                                                                                          *
+*   DetectCrucialControllers                                                               *
+*                                                                                          *
+*       Detect Crucial controllers on the enumerated I2C busses.                           *
+*                                                                                          *
+*           bus - pointer to i2c_smbus_interface where Aura device is connected            *
+*           dev - I2C address of Aura device                                               *
+*                                                                                          *
+\******************************************************************************************/
+
+void DetectCrucialControllers(std::vector<i2c_smbus_interface*> &busses, std::vector<RGBController*> &rgb_controllers)
+{
+    CrucialController* new_crucial;
+    RGBController_Crucial* new_controller;
+
+    for (unsigned int bus = 0; bus < busses.size(); bus++)
+    {
+        // Add Crucial controllers
+        for (unsigned int address_list_idx = 0; address_list_idx < CRUCIAL_ADDRESS_COUNT; address_list_idx++)
+        {
+            if (TestForCrucialController(busses[bus], crucial_addresses[address_list_idx]))
+            {
+                new_crucial = new CrucialController(busses[bus], crucial_addresses[address_list_idx]);
+                new_controller = new RGBController_Crucial(new_crucial);
+                rgb_controllers.push_back(new_controller);
+            }
+        }
+    }
+
+}   /* DetectCrucialControllers() */

Controllers/Hue2Controller/Hue2Controller.cpp

@@ -0,0 +1,161 @@
+/*---------------------------------------------------------*\
+|  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 (120mm)
+                num_leds_on_channel += 8;
+                break;
+
+            case 0x0C: //Aer 2 fan (140mm)
+                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,71 @@
+/*---------------------------------------------------------*\
+|  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();
+
+    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,53 @@
+#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
+#define NZXT_SMART_DEVICE_V2_PID 0x2006
+
+/******************************************************************************************\
+*                                                                                          *
+*   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 * hue_2_dev = libusb_open_device_with_vid_pid(ctx, NZXT_HUE_2_VID, NZXT_HUE_2_PID);
+
+    if( hue_2_dev )
+    {
+        libusb_detach_kernel_driver(hue_2_dev, 0);
+        libusb_claim_interface(hue_2_dev, 0);
+
+        Hue2Controller* controller = new Hue2Controller(hue_2_dev);
+
+        RGBController_Hue2* rgb_controller = new RGBController_Hue2(controller);
+
+        rgb_controllers.push_back(rgb_controller);
+    }
+
+    //Look for NZXT Smart Device V2
+    libusb_device_handle * smart_dev_2_dev = libusb_open_device_with_vid_pid(ctx, NZXT_HUE_2_VID, NZXT_SMART_DEVICE_V2_PID);
+
+    if( smart_dev_2_dev )
+    {
+        libusb_detach_kernel_driver(smart_dev_2_dev, 0);
+        libusb_claim_interface(smart_dev_2_dev, 0);
+
+        Hue2Controller* controller = new Hue2Controller(smart_dev_2_dev);
+
+        RGBController_Hue2* rgb_controller = new RGBController_Hue2(controller);
+
+        rgb_controllers.push_back(rgb_controller);
+    }
+}   /* DetectHuePlusControllers() */

Controllers/HuePlusController/HuePlusController.cpp

@@ -9,128 +9,194 @@
 #include <fstream>
 #include <iostream>
 #include <string>
+#include <cstring>
+
+#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;
+        }
+        else
+        {
+            ret_val += serial_buf[4] * 10;
+        }
+    }
+
+    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::SetModeColors(unsigned char channel, std::vector<RGBColor> colors)
+{
+    unsigned char serial_buf[125];
+
+    for(int color_idx = 0; color_idx < colors.size(); color_idx++)
+    {
+        /*-----------------------------------------------------*\
+        | Zero out buffer                                       |
+        \*-----------------------------------------------------*/
+        memset(serial_buf, 0x00, sizeof(serial_buf));
+
+        /*-----------------------------------------------------*\
+        | Set up main packet                                    |
+        \*-----------------------------------------------------*/
+        serial_buf[0x00]    = 0x4B;
+
+        /*-----------------------------------------------------*\
+        | 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 color index and speed in serial packet            |
+        \*-----------------------------------------------------*/
+        serial_buf[0x04]   = ( color_idx << 5 ) | current_speed;
+
+        /*-----------------------------------------------------*\
+        | Fill in color data                                    |
+        \*-----------------------------------------------------*/
+        for (std::size_t idx = 0; idx < 40; idx++)
+        {
+            int pixel_idx = idx * 3;
+            RGBColor color = colors[color_idx];
+            serial_buf[pixel_idx + 0x05] = RGBGetGValue(color);
+            serial_buf[pixel_idx + 0x06] = RGBGetRValue(color);
+            serial_buf[pixel_idx + 0x07] = RGBGetBValue(color);
         }
 
-        for (int idx = 0; idx < (num_leds * 3); idx += 3)
-        {
-            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);
-        }
-
-        serialport->serial_write((char *)serial_buf, hueSize);
+        serialport->serial_write((char *)serial_buf, HUE_PLUS_PACKET_SIZE);
         serialport->serial_flush_tx();
 
-        delete[] serial_buf;
+        Sleep(10);
+    }
+}
+
+void HuePlusController::SetChannelLEDs(unsigned char channel, std::vector<RGBColor> colors)
+{
+    unsigned char serial_buf[125];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(serial_buf, 0x00, sizeof(serial_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up main packet                                    |
+    \*-----------------------------------------------------*/
+    serial_buf[0x00]    = 0x4B;
+
+    /*-----------------------------------------------------*\
+    | 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,70 @@
 #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);
+    void            SetModeColors(unsigned char channel, std::vector<RGBColor> colors);
 
-    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/HyperXKeyboardController/HyperXKeyboardController.cpp

@@ -0,0 +1,483 @@
+/*-----------------------------------------*\
+|  HyperXKeyboardController.cpp             |
+|                                           |
+|  Driver for HyperX RGB Keyboard lighting  |
+|  controller                               |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 1/30/2020   |
+\*-----------------------------------------*/
+
+#include "HyperXKeyboardController.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[] = {0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13, 0x14,
+                              0x15, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1D, 0x1E, 0x20, 0x21, 0x22, 0x23, 0x24,
+                              0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F, 0x30, 0x31, 0x32,
+                              0x33, 0x34, 0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3E, 0x3F, 0x41, 0x44, 0x45,
+                              0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F, 0x51, 0x54, 0x55, 0x58, 0x59,
+                              0x5A, 0x5B, 0x5C, 0x5E, 0x5F, 0x61, 0x64, 0x65, 0x68, 0x69, 0x6A, 0x6B, 0x6C,
+                              0x6E, 0x6F, 0x74, 0x75, 0x78, 0x79, 0x7A, 0x7B, 0x7C, 0x7D, 0x7E, 0x7F, 0x81,
+                              0x84, 0x85, 0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F, 0x91, 0x94, 0x95 };
+
+static unsigned int extended_red[] = {0x08, 0x48, 0x88, 0x09, 0x89, 0x0A, 0x8A, 0x0B, 0x8B, 0x0C, 0x8C, 0x0D, 0x8D, 0x0E, 0x8F, 0x8E, 0x0F, 0x4F, 0x92, 0x13, 0x93, 0x12 };
+static unsigned int extended_grn[] = {0x29, 0x28, 0x78, 0x19, 0x79, 0x1A, 0x7A, 0x1B, 0x7B, 0x1C, 0x7C, 0x1D, 0x7D, 0x1E, 0x6E, 0x7E, 0x1F, 0x6F, 0x82, 0x23, 0x83, 0x22 };
+static unsigned int extended_blu[] = {0x39, 0x38, 0x68, 0x3A, 0x69, 0x2A, 0x6A, 0x2B, 0x6B, 0x2C, 0x6C, 0x2D, 0x6D, 0x2E, 0x5E, 0x5D, 0x2F, 0x5F, 0x72, 0x33, 0x73, 0x32 };
+
+HyperXKeyboardController::HyperXKeyboardController(hid_device* dev_handle)
+{
+    dev = dev_handle;
+}
+
+HyperXKeyboardController::~HyperXKeyboardController()
+{
+
+}
+
+void HyperXKeyboardController::SetMode
+    (
+    unsigned char mode,
+    unsigned char direction,
+    unsigned char speed,
+    std::vector<RGBColor> colors
+    )
+{
+    unsigned char color_mode;
+    unsigned char mode_colors[9];
+
+    active_mode = mode;
+    active_direction = direction;
+    active_speed = speed;
+
+    memset(mode_colors, 0x00, sizeof(mode_colors));
+
+    switch(colors.size())
+    {
+        default:
+        case 0:
+            color_mode = HYPERX_COLOR_MODE_SPECTRUM;
+            break;
+
+        case 1:
+            color_mode = HYPERX_COLOR_MODE_SINGLE;
+            mode_colors[0] = RGBGetRValue(colors[0]);
+            mode_colors[1] = RGBGetGValue(colors[0]);
+            mode_colors[2] = RGBGetBValue(colors[0]);
+            break;
+
+        case 2:
+            color_mode = HYPERX_COLOR_MODE_DUAL;
+            mode_colors[3] = RGBGetRValue(colors[0]);
+            mode_colors[4] = RGBGetGValue(colors[0]);
+            mode_colors[5] = RGBGetBValue(colors[0]);
+            mode_colors[6] = RGBGetRValue(colors[1]);
+            mode_colors[7] = RGBGetGValue(colors[1]);
+            mode_colors[8] = RGBGetBValue(colors[1]);
+            break;
+    }
+
+    SendEffect
+        (
+        0x01,
+        active_mode,
+        active_direction,
+        HYPERX_REACTIVE_MODE_NONE,
+        active_speed,
+        color_mode,
+        mode_colors[0],
+        mode_colors[1],
+        mode_colors[2],
+        mode_colors[3],
+        mode_colors[4],
+        mode_colors[5],
+        mode_colors[6],
+        mode_colors[7],
+        mode_colors[8]
+        );
+
+    Sleep(100);
+}
+
+void HyperXKeyboardController::SetLEDsDirect(std::vector<RGBColor> colors)
+{
+    unsigned char red_color_data[104];
+    unsigned char grn_color_data[104];
+    unsigned char blu_color_data[104];
+    unsigned char ext_color_data[150];
+
+    for(std::size_t i = 0; i < 104; i++)
+    {
+        red_color_data[i] = RGBGetRValue(colors[i]);
+        grn_color_data[i] = RGBGetGValue(colors[i]);
+        blu_color_data[i] = RGBGetBValue(colors[i]);
+    }
+
+    for(std::size_t i = 0; i < 22; i++)
+    {
+        ext_color_data[extended_red[i]] = RGBGetRValue(colors[i + 104]);
+        ext_color_data[extended_grn[i]] = RGBGetGValue(colors[i + 104]);
+        ext_color_data[extended_blu[i]] = RGBGetBValue(colors[i + 104]);
+    }
+
+    SendDirect
+        (
+        HYPERX_COLOR_CHANNEL_RED,
+        red_color_data
+        );
+
+    Sleep(2);
+
+    SendDirect
+        (
+        HYPERX_COLOR_CHANNEL_GREEN,
+        grn_color_data
+        );
+
+    Sleep(2);
+
+    SendDirect
+        (
+        HYPERX_COLOR_CHANNEL_BLUE,
+        blu_color_data
+        );
+
+    Sleep(2);
+
+    SendDirectExtended
+        (
+        ext_color_data
+        );
+}
+
+void HyperXKeyboardController::SetLEDs(std::vector<RGBColor> colors)
+{
+    unsigned char red_color_data[104];
+    unsigned char grn_color_data[104];
+    unsigned char blu_color_data[104];
+    unsigned char ext_color_data[150];
+
+    for(std::size_t i = 0; i < 104; i++)
+    {
+        red_color_data[i] = RGBGetRValue(colors[i]);
+        grn_color_data[i] = RGBGetGValue(colors[i]);
+        blu_color_data[i] = RGBGetBValue(colors[i]);
+    }
+
+    for(std::size_t i = 0; i < 22; i++)
+    {
+        ext_color_data[extended_red[i]] = RGBGetRValue(colors[i + 104]);
+        ext_color_data[extended_grn[i]] = RGBGetGValue(colors[i + 104]);
+        ext_color_data[extended_blu[i]] = RGBGetBValue(colors[i + 104]);
+    }
+
+    SendColor
+        (
+        0x01,
+        HYPERX_COLOR_CHANNEL_RED,
+        red_color_data
+        );
+
+    SendColor
+        (
+        0x01,
+        HYPERX_COLOR_CHANNEL_GREEN,
+        grn_color_data
+        );
+
+    SendColor
+        (
+        0x01,
+        HYPERX_COLOR_CHANNEL_BLUE,
+        blu_color_data
+        );
+
+    SendExtendedColor
+        (
+        0x01,
+        ext_color_data
+        );
+}
+
+/*-------------------------------------------------------------------------------------------------*\
+| Private packet sending functions.                                                                 |
+\*-------------------------------------------------------------------------------------------------*/
+
+void HyperXKeyboardController::SelectProfile
+    (
+    unsigned char   profile
+    )
+{
+    unsigned char buf[264];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(buf, 0x00, sizeof(buf));
+
+    /*-----------------------------------------------------*\
+    | Set up Select Profile packet                          |
+    \*-----------------------------------------------------*/
+    buf[0x00]   = 0x07;
+    buf[0x01]   = 0x01;
+    buf[0x02]   = profile;
+
+    buf[0x06]   = 0x03;
+    buf[0x07]   = 0x01;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_send_feature_report(dev, buf, 264);
+}
+
+void HyperXKeyboardController::SendEffect
+    (
+    unsigned char   profile,
+    unsigned char   mode,
+    unsigned char   direction,
+    unsigned char   reactive_mode,
+    unsigned char   speed,
+    unsigned char   color_mode,
+    unsigned char   red_single,
+    unsigned char   grn_single,
+    unsigned char   blu_single,
+    unsigned char   red_dual_1,
+    unsigned char   grn_dual_1,
+    unsigned char   blu_dual_1,
+    unsigned char   red_dual_2,
+    unsigned char   grn_dual_2,
+    unsigned char   blu_dual_2
+    )
+{
+    unsigned char buf[264];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(buf, 0x00, sizeof(buf));
+
+    /*-----------------------------------------------------*\
+    | Set up Effect packet                                  |
+    \*-----------------------------------------------------*/
+    buf[0x00]   = 0x07;
+    buf[0x01]   = HYPERX_PACKET_ID_SET_EFFECT;
+    buf[0x02]   = profile;
+
+    /*-----------------------------------------------------*\
+    | Set mode                                              |
+    \*-----------------------------------------------------*/
+    buf[0x09]   = 0x01;
+    buf[0x0A]   = mode;
+
+    /*-----------------------------------------------------*\
+    | Set direction                                         |
+    \*-----------------------------------------------------*/
+    buf[0x0D]   = direction;
+    buf[0x0E]   = direction;
+
+    /*-----------------------------------------------------*\
+    | Set reactive mode                                     |
+    \*-----------------------------------------------------*/
+    buf[0x1B]   = reactive_mode;
+    buf[0x1C]   = reactive_mode;
+    buf[0x1D]   = reactive_mode;
+    buf[0x1E]   = reactive_mode;
+    buf[0x1F]   = reactive_mode;
+    buf[0x20]   = reactive_mode;
+    buf[0x21]   = reactive_mode;
+    buf[0x22]   = reactive_mode;
+
+    /*-----------------------------------------------------*\
+    | Set mode-specific colors                              |
+    \*-----------------------------------------------------*/
+    buf[0x29]   = red_single;
+    buf[0x41]   = grn_single;
+    buf[0x59]   = blu_single;
+    buf[0x2A]   = red_dual_1;
+    buf[0x42]   = grn_dual_1;
+    buf[0x5A]   = blu_dual_1;
+    buf[0x2B]   = red_dual_2;
+    buf[0x43]   = grn_dual_2;
+    buf[0x5B]   = blu_dual_2;
+
+    buf[0x6B]   = 0x09;
+    buf[0x6C]   = 0x09;
+    buf[0x6D]   = 0x05;
+    buf[0x6E]   = 0x05;
+    buf[0x6F]   = 0x06;
+    buf[0x70]   = 0x05;
+
+    /*-----------------------------------------------------*\
+    | Set speed                                             |
+    \*-----------------------------------------------------*/
+    buf[0x71]   = speed;
+
+    buf[0x72]   = 0x09;
+
+    /*-----------------------------------------------------*\
+    | Set color mode                                        |
+    \*-----------------------------------------------------*/
+    buf[0x73]   = color_mode;
+    buf[0x74]   = color_mode;
+    buf[0x75]   = color_mode;
+    buf[0x76]   = color_mode;
+    buf[0x77]   = color_mode;
+    buf[0x78]   = color_mode;
+    buf[0x79]   = color_mode;
+    buf[0x7A]   = color_mode;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_send_feature_report(dev, buf, 264);
+}
+
+void HyperXKeyboardController::SendColor
+    (
+    unsigned char   profile,
+    unsigned char   color_channel,
+    unsigned char*  color_data
+    )
+{
+    unsigned char buf[264];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(buf, 0x00, sizeof(buf));
+
+    /*-----------------------------------------------------*\
+    | Set up Color packet                                   |
+    \*-----------------------------------------------------*/
+    buf[0x00]   = 0x07;
+    buf[0x01]   = HYPERX_PACKET_ID_SET_COLOR;
+    buf[0x02]   = profile;
+    buf[0x03]   = color_channel;
+
+    /*-----------------------------------------------------*\
+    | Fill in color data                                    |
+    \*-----------------------------------------------------*/
+    for(int i = 0; i < 104; i++)
+    {
+        buf[keys[i]] = color_data[i];
+    }
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_send_feature_report(dev, buf, 264);
+}
+
+void HyperXKeyboardController::SendExtendedColor
+    (
+    unsigned char   profile,
+    unsigned char*  color_data
+    )
+{
+    unsigned char buf[264];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(buf, 0x00, sizeof(buf));
+
+    /*-----------------------------------------------------*\
+    | Set up Color packet                                   |
+    \*-----------------------------------------------------*/
+    buf[0x00]   = 0x07;
+    buf[0x01]   = HYPERX_PACKET_ID_SET_COLOR;
+    buf[0x02]   = profile;
+    buf[0x03]   = HYPERX_COLOR_CHANNEL_EXTENDED;
+
+    /*-----------------------------------------------------*\
+    | Fill in color data                                    |
+    \*-----------------------------------------------------*/
+    for(int i = 0x08; i <= 0x93; i++)
+    {
+        buf[i] = color_data[i];
+    }
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_send_feature_report(dev, buf, 264);
+}
+
+void HyperXKeyboardController::SendDirect
+    (
+    unsigned char   color_channel,
+    unsigned char*  color_data
+    )
+{
+    unsigned char buf[264];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(buf, 0x00, sizeof(buf));
+
+    /*-----------------------------------------------------*\
+    | Set up Direct packet                                  |
+    \*-----------------------------------------------------*/
+    buf[0x00]   = 0x07;
+    buf[0x01]   = HYPERX_PACKET_ID_DIRECT;
+    buf[0x02]   = color_channel;
+
+    /*-----------------------------------------------------*\
+    | Fill in color data                                    |
+    \*-----------------------------------------------------*/
+    for(int i = 0; i < 104; i++)
+    {
+        buf[keys[i]] = color_data[i];
+    }
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_send_feature_report(dev, buf, 264);
+}
+
+void HyperXKeyboardController::SendDirectExtended
+    (
+    unsigned char*  color_data
+    )
+{
+    unsigned char buf[264];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(buf, 0x00, sizeof(buf));
+
+    /*-----------------------------------------------------*\
+    | Set up Direct packet                                  |
+    \*-----------------------------------------------------*/
+    buf[0x00]   = 0x07;
+    buf[0x01]   = HYPERX_PACKET_ID_DIRECT;
+    buf[0x02]   = HYPERX_COLOR_CHANNEL_EXTENDED;
+
+    /*-----------------------------------------------------*\
+    | Fill in color data                                    |
+    \*-----------------------------------------------------*/
+    for(int i = 0x08; i <= 0x93; i++)
+    {
+        buf[i] = color_data[i];
+    }
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_send_feature_report(dev, buf, 264);
+}

Controllers/HyperXKeyboardController/HyperXKeyboardController.h

@@ -0,0 +1,135 @@
+/*-----------------------------------------*\
+|  HyperXKeyboardController.h               |
+|                                           |
+|  Definitions and types for HyperX RGB     |
+|  Keyboard lighting controller             |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 1/30/2020   |
+\*-----------------------------------------*/
+
+#include "RGBController.h"
+
+#include <string>
+#include <hidapi/hidapi.h>
+
+#pragma once
+
+enum
+{
+    HYPERX_PACKET_ID_SET_EFFECT                 = 0x02,     /* Set profile effect packet            */
+    HYPERX_PACKET_ID_SET_COLOR                  = 0x06,     /* Set profile color packet             */
+    HYPERX_PACKET_ID_DIRECT                     = 0x16,     /* Direct control packet                */
+};
+
+
+enum
+{
+    HYPERX_DIRECTION_RIGHT  = 0x00,
+    HYPERX_DIRECTION_LEFT   = 0x01,
+    HYPERX_DIRECTION_UP     = 0x02,
+    HYPERX_DIRECTION_DOWN   = 0x03,
+    HYPERX_DIRECTION_IN     = 0x04,
+    HYPERX_DIRECTION_OUT    = 0x05
+};
+
+enum
+{
+    HYPERX_MODE_WAVE                    = 0x00,
+    HYPERX_MODE_STATIC                  = 0x01,
+    HYPERX_MODE_BREATHING               = 0x02,
+};
+
+enum
+{
+    HYPERX_REACTIVE_MODE_TRIGGER        = 0x03,
+    HYPERX_REACTIVE_MODE_EXPLOSION      = 0x04,
+    HYPERX_REACTIVE_MODE_HYPERX_FLAME   = 0x05,
+    HYPERX_REACTIVE_MODE_NONE           = 0xFF
+};
+
+enum
+{
+    HYPERX_COLOR_MODE_SINGLE            = 0x00,
+    HYPERX_COLOR_MODE_DUAL              = 0x01,
+    HYPERX_COLOR_MODE_SPECTRUM          = 0x02
+};
+
+enum
+{
+    HYPERX_COLOR_CHANNEL_RED                = 0x01,
+    HYPERX_COLOR_CHANNEL_GREEN              = 0x02,
+    HYPERX_COLOR_CHANNEL_BLUE               = 0x03,
+    HYPERX_COLOR_CHANNEL_EXTENDED           = 0x04
+};
+
+class HyperXKeyboardController
+{
+public:
+    HyperXKeyboardController(hid_device* dev_handle);
+    ~HyperXKeyboardController();
+
+    void SetMode
+        (
+        unsigned char mode,
+        unsigned char direction,
+        unsigned char speed,
+        std::vector<RGBColor> colors
+        );
+
+    void SetLEDsDirect(std::vector<RGBColor> colors);
+    void SetLEDs(std::vector<RGBColor> colors);
+
+private:
+    hid_device*             dev;
+    unsigned char           active_mode;
+    unsigned char           active_direction;
+    unsigned char           active_speed;
+
+    void    SelectProfile
+                (
+                unsigned char   profile
+                );
+
+    void    SendEffect
+                (
+                unsigned char   profile,
+                unsigned char   mode,
+                unsigned char   direction,
+                unsigned char   reactive_mode,
+                unsigned char   speed,
+                unsigned char   color_mode,
+                unsigned char   red_single,
+                unsigned char   grn_single,
+                unsigned char   blu_single,
+                unsigned char   red_dual_1,
+                unsigned char   grn_dual_1,
+                unsigned char   blu_dual_1,
+                unsigned char   red_dual_2,
+                unsigned char   grn_dual_2,
+                unsigned char   blu_dual_2
+                );
+
+    void    SendColor
+                (
+                unsigned char   profile,
+                unsigned char   color_channel,
+                unsigned char*  color_data
+                );
+
+    void    SendExtendedColor
+                (
+                unsigned char   profile,
+                unsigned char*  color_data
+                );
+
+    void    SendDirect
+                (
+                unsigned char   color_channel,
+                unsigned char*  color_data
+                );
+
+    void    SendDirectExtended
+                (
+                unsigned char*  color_data
+                );
+};

Controllers/HyperXKeyboardController/HyperXKeyboardControllerDetect.cpp

@@ -0,0 +1,51 @@
+#include "HyperXKeyboardController.h"
+#include "RGBController.h"
+#include "RGBController_HyperXKeyboard.h"
+#include <vector>
+#include <hidapi/hidapi.h>
+
+#define HYPERX_KEYBOARD_VID         0x0951
+#define HYPERX_ALLOY_ELITE_PID      0x16BE
+
+/******************************************************************************************\
+*                                                                                          *
+*   DetectHyperXKeyboardControllers                                                        *
+*                                                                                          *
+*       Tests the USB address to see if a HyperX Keyboard controller exists there.         *
+*                                                                                          *
+\******************************************************************************************/
+
+void DetectHyperXKeyboardControllers(std::vector<RGBController*>& rgb_controllers)
+{
+    hid_device_info* info;
+    hid_device* dev = NULL;
+
+    hid_init();
+
+    info = hid_enumerate(HYPERX_KEYBOARD_VID, HYPERX_ALLOY_ELITE_PID);
+
+    //Look for HyperX Keyboard, Interface 2
+    while(info)
+    {
+        if((info->vendor_id == HYPERX_KEYBOARD_VID)
+         &&(info->product_id == HYPERX_ALLOY_ELITE_PID)
+         &&(info->interface_number == 2))
+        {
+            dev = hid_open_path(info->path);
+            break;
+        }
+        else
+        {
+            info = info->next;
+        }
+    }
+
+    if( dev )
+    {
+        HyperXKeyboardController* controller = new HyperXKeyboardController(dev);
+
+        RGBController_HyperXKeyboard* rgb_controller = new RGBController_HyperXKeyboard(controller);
+
+        rgb_controllers.push_back(rgb_controller);
+    }
+}

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,125 @@
+/*-----------------------------------------*\
+|  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 = true;
+        strcpy(device_name, "ASRock ASR LED FW 2.00");
+        break;
+
+    case FIRMWARE_VER_2_PT_08:
+        led_count = 1;
+        asr_led = true;
+        strcpy(device_name, "ASRock ASR LED FW 2.08");
+        break;
+
+    case FIRMWARE_VER_2_PT_10:
+        led_count = 1;
+        asr_led = true;
+        strcpy(device_name, "ASRock ASR LED FW 2.10");
+        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(active_mode);
+}
+
+bool PolychromeController::IsAsrLed()
+{
+    return(asr_led);
+}
+
+void PolychromeController::SetColor(unsigned char red, unsigned char green, unsigned char blue)
+{
+    unsigned char colors[3] = { red, green, blue };
+
+    if (asr_led)
+    {
+        bus->i2c_smbus_write_block_data(dev, active_mode, 3, colors);
+    }
+    else
+    {
+        bus->i2c_smbus_write_block_data(dev, POLYCHROME_REG_COLOR, 3, colors);
+    }
+}
+
+void PolychromeController::SetMode(unsigned char mode)
+{
+    active_mode = mode;
+
+    if (asr_led)
+    {
+        bus->i2c_smbus_write_block_data(dev, ASRLED_REG_MODE, 1, &active_mode);
+    }
+    else
+    {
+        bus->i2c_smbus_write_block_data(dev, POLYCHROME_REG_MODE, 1, &active_mode);
+    }    
+}

Controllers/PolychromeController/PolychromeController.h

@@ -0,0 +1,95 @@
+/*-----------------------------------------*\
+|  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_2_PT_08            = 0x0208,   /* Firmware nu51_2.08                   */
+    FIRMWARE_VER_2_PT_10            = 0x020A,   /* Firmware nu51_2.10                   */
+    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();
+    bool            IsAsrLed();
+    void            SetColor(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;
+    unsigned char           active_mode;
+    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,236 @@
+/*-----------------------------------------*\
+|  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[] = {0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13, 0x15,
+                              0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1D, 0x1E, 0x1F, 0x20, 0x21, 0x22, 0x23,
+                              0x24, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F, 0x30, 0x31,
+                              0x32, 0x33, 0x34, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3E, 0x3F, 0x40,
+                              0x41, 0x42, 0x43, 0x44, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4E, 0x4F,
+                              0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x5B, 0x5C,
+                              0x5D, 0x5E, 0x5F, 0x60, 0x61, 0x62, 0x63, 0x64, 0x66, 0x67, 0x68, 0x69, 0x6A,
+                              0x6C, 0x6D, 0x6F, 0x70, 0x72, 0x73, 0x75, 0x76, 0x77, 0x78, 0x7C, 0x80, 0x81 };
+
+PoseidonZRGBController::PoseidonZRGBController(hid_device* dev_handle)
+{
+    dev = dev_handle;
+}
+
+PoseidonZRGBController::~PoseidonZRGBController()
+{
+
+}
+
+void PoseidonZRGBController::SetMode(unsigned char mode, unsigned char direction, unsigned char speed)
+{
+    active_mode = mode;
+    active_direction = direction;
+    active_speed = speed;
+
+    SendControl
+        (
+        POSEIDONZ_PROFILE_P1,
+        POSEIDONZ_PROFILE_P1,
+        active_direction,
+        active_mode,
+        POSEIDONZ_BRIGHTNESS_MAX,
+        active_speed
+        );
+}
+
+void PoseidonZRGBController::SetLEDsDirect(std::vector<RGBColor> colors)
+{
+    unsigned char red_grn_buf[264];
+    unsigned char blu_buf[264];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffers                                      |
+    \*-----------------------------------------------------*/
+    memset(red_grn_buf, 0x00, sizeof(red_grn_buf));
+    memset(blu_buf, 0x00, sizeof(blu_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up Direct packets                                 |
+    \*-----------------------------------------------------*/
+    red_grn_buf[0] = 0x07;
+    red_grn_buf[1] = POSEIDONZ_PACKET_ID_SET_DIRECT;
+    red_grn_buf[2] = POSEIDONZ_PROFILE_P1;
+    red_grn_buf[3] = POSEIDONZ_DIRECT_RED_GREEN;
+    red_grn_buf[4] = 0x00;
+    red_grn_buf[5] = 0x00;
+    red_grn_buf[6] = 0x00;
+    red_grn_buf[7] = 0x00;
+
+    blu_buf[0] = 0x07;
+    blu_buf[1] = POSEIDONZ_PACKET_ID_SET_DIRECT;
+    blu_buf[2] = POSEIDONZ_PROFILE_P1;
+    blu_buf[3] = POSEIDONZ_DIRECT_BLUE;
+    blu_buf[4] = 0x00;
+    blu_buf[5] = 0x00;
+    blu_buf[6] = 0x00;
+    blu_buf[7] = 0x00;
+
+    /*-----------------------------------------------------*\
+    | Fill in color data                                    |
+    \*-----------------------------------------------------*/
+    for(std::size_t 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]);
+    }
+
+    /*-----------------------------------------------------*\
+    | Send packets                                          |
+    \*-----------------------------------------------------*/
+    hid_send_feature_report(dev, red_grn_buf, 264);
+    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(std::size_t i = 0; i < 104; i++)
+    {
+        red_color_data[i] = RGBGetRValue(colors[i]);
+        grn_color_data[i] = RGBGetGValue(colors[i]);
+        blu_color_data[i] = 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,
+        active_direction,
+        active_mode,
+        POSEIDONZ_BRIGHTNESS_MAX,
+        active_speed
+        );
+}
+
+/*-------------------------------------------------------------------------------------------------*\
+| Private packet sending functions.                                                                 |
+\*-------------------------------------------------------------------------------------------------*/
+
+void PoseidonZRGBController::SendColor
+    (
+    unsigned char   profile_to_edit,
+    unsigned char   color_channel,
+    unsigned char*  color_data
+    )
+{
+    unsigned char buf[264];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(buf, 0x00, sizeof(buf));
+
+    /*-----------------------------------------------------*\
+    | Set up Color packet                                   |
+    \*-----------------------------------------------------*/
+    buf[0x00]   = 0x07;
+    buf[0x01]   = POSEIDONZ_PACKET_ID_SET_COLOR;
+    buf[0x02]   = profile_to_edit;
+    buf[0x03]   = color_channel;
+
+    /*-----------------------------------------------------*\
+    | Fill in color data                                    |
+    \*-----------------------------------------------------*/
+    for(int i = 0; i < 104; i++)
+    {
+        buf[keys[i]] = color_data[i];
+    }
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_send_feature_report(dev, buf, 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   speed
+    )
+{
+    unsigned char buf[264];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(buf, 0x00, sizeof(buf));
+
+    /*-----------------------------------------------------*\
+    | Set up Effect packet                                  |
+    \*-----------------------------------------------------*/
+    buf[0x00]   = 0x07;
+    buf[0x01]   = POSEIDONZ_PACKET_ID_SET_EFFECT;
+    buf[0x02]   = profile_to_activate;
+    buf[0x08]   = profile_to_edit;
+    buf[0x0A]   = direction;
+    buf[0x0C]   = mode;
+    buf[0x0D]   = brightness;
+    buf[0x10]   = 0x08;
+    buf[0x12]   = speed;
+    buf[0x13]   = 0x50;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_send_feature_report(dev, buf, 264);
+}

Controllers/PoseidonZRGBController/PoseidonZRGBController.h

@@ -0,0 +1,106 @@
+/*-----------------------------------------*\
+|  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_PACKET_ID_SET_EFFECT      = 0x02,     /* Set profile effect packet            */
+    POSEIDONZ_PACKET_ID_SET_COLOR       = 0x09,     /* Set profile color packet             */
+    POSEIDONZ_PACKET_ID_SET_DIRECT      = 0x0E,     /* Set direct color packet              */
+};
+
+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
+};
+
+enum
+{
+    POSEIDONZ_DIRECT_RED_GREEN  = 0x01,
+    POSEIDONZ_DIRECT_BLUE       = 0x02
+};
+
+enum
+{
+    POSEIDONZ_SPEED_SLOW        = 0x10,
+    POSEIDONZ_SPEED_FAST        = 0x05
+};
+
+class PoseidonZRGBController
+{
+public:
+    PoseidonZRGBController(hid_device* dev_handle);
+    ~PoseidonZRGBController();
+
+    void SetMode(unsigned char mode, unsigned char direction, unsigned char speed);
+    void SetLEDsDirect(std::vector<RGBColor> colors);
+    void SetLEDs(std::vector<RGBColor> colors);
+    
+private:
+    hid_device*             dev;
+    unsigned char           active_mode;
+    unsigned char           active_direction;
+    unsigned char           active_speed;
+
+    void SendControl
+        (
+        unsigned char   profile_to_activate,
+        unsigned char   profile_to_edit,
+        unsigned char   direction,
+        unsigned char   mode,
+        unsigned char   brightness,
+        unsigned char   speed
+        );
+    
+    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 = NULL;
+
+    hid_init();
+
+    info = hid_enumerate(TT_POSEIDON_Z_RGB_VID, TT_POSEIDON_Z_RGB_PID);
+
+    //Look for Thermaltake Poseidon Z RGB, Interface 2
+    while(info)
+    {
+        if((info->vendor_id == TT_POSEIDON_Z_RGB_VID)
+         &&(info->product_id == TT_POSEIDON_Z_RGB_PID)
+         &&(info->interface_number == 2))
+        {
+            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/RGBFusion2Controller/RGBFusion2Controller.cpp

@@ -0,0 +1,121 @@
+/*-----------------------------------------*\
+|  RGBFusion2Controller.cpp                 |
+|                                           |
+|  Driver for Gigabyte Aorus RGB Fusion 2.0 |
+|  lighting controller                      |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 1/15/2020   |
+\*-----------------------------------------*/
+
+#include "RGBFusion2Controller.h"
+#include <cstring>
+#include <stdio.h>
+#include <stdlib.h>
+
+RGBFusion2Controller::RGBFusion2Controller(hid_device* dev_handle)
+{
+    dev = dev_handle;
+
+    // Set Device name
+    strcpy(device_name, "Gigabyte Motherboard");
+
+    // Set LED count
+    led_count = 8;
+}
+
+RGBFusion2Controller::~RGBFusion2Controller()
+{
+
+}
+
+std::string RGBFusion2Controller::GetDeviceName()
+{
+    return(device_name);
+}
+
+std::string RGBFusion2Controller::GetDeviceLocation()
+{
+    return("");
+}
+
+unsigned int RGBFusion2Controller::GetLEDCount()
+{
+    return(led_count);
+}
+
+unsigned char RGBFusion2Controller::GetMode()
+{
+    return(0);
+}
+
+void RGBFusion2Controller::SetAllColors(unsigned char red, unsigned char green, unsigned char blue)
+{
+}
+
+void RGBFusion2Controller::SetLEDColor(unsigned int led, unsigned char red, unsigned char green, unsigned char blue)
+{
+    unsigned char usb_buf[] =
+    {
+        0xCC, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x01,
+        0x5A, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+    };
+
+    usb_buf[0x01] = (0x20 |  led);
+    usb_buf[0x02] = (0x01 << led );
+
+    usb_buf[0x0E] = blue;
+    usb_buf[0x0F] = green;
+    usb_buf[0x10] = red;
+
+    hid_send_feature_report(dev, usb_buf, 64);
+    
+    SendApply();
+}
+
+void RGBFusion2Controller::SendApply()
+{
+    unsigned char usb_buf[] =
+    {
+        0xCC, 0x28, 0xFF, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+    };
+
+    hid_send_feature_report(dev, usb_buf, 64);
+}
+
+void RGBFusion2Controller::SetMode(unsigned char mode)
+{
+}
+
+void RGBFusion2Controller::dump()
+{
+
+}

Controllers/RGBFusion2Controller/RGBFusion2Controller.h

@@ -0,0 +1,39 @@
+/*-----------------------------------------*\
+|  RGBFusion2Controller.h                   |
+|                                           |
+|  Definitions and types for Gigabyte Aorus |
+|  RGB Fusion 2.0 lighting controller       |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 1/15/2020   |
+\*-----------------------------------------*/
+
+#include <string>
+#include <hidapi/hidapi.h>
+
+#pragma once
+
+
+class RGBFusion2Controller
+{
+public:
+    RGBFusion2Controller(hid_device* dev_handle);
+    ~RGBFusion2Controller();
+
+    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);
+
+private:
+    void            dump();
+
+    char                    device_name[32];
+    unsigned int            led_count;
+
+    void            SendApply();
+    
+    hid_device*             dev;
+};

Controllers/RGBFusion2Controller/RGBFusion2ControllerDetect.cpp

@@ -0,0 +1,36 @@
+#include "RGBFusion2Controller.h"
+#include "RGBController.h"
+#include "RGBController_RGBFusion2.h"
+#include <vector>
+#include <hidapi/hidapi.h>
+
+#define RGB_FUSION_2_VID 0x048D
+#define RGB_FUSION_2_PID 0x8297
+
+/******************************************************************************************\
+*                                                                                          *
+*   DetectRGBFusion2Controllers                                                            *
+*                                                                                          *
+*       Detect RGB Fusion 2.0 controllers on the USB interface.                            *
+*                                                                                          *
+\******************************************************************************************/
+
+void DetectRGBFusion2Controllers(std::vector<RGBController*>& rgb_controllers)
+{
+    hid_device* dev;
+
+    //Look for RGB Fusion 2.0 Controller
+    hid_init();
+
+    dev = hid_open(RGB_FUSION_2_VID, RGB_FUSION_2_PID, 0);
+
+    if( dev )
+    {
+        RGBFusion2Controller* controller = new RGBFusion2Controller(dev);
+
+        RGBController_RGBFusion2* rgb_controller = new RGBController_RGBFusion2(controller);
+
+        rgb_controllers.push_back(rgb_controller);
+    }
+
+}   /* DetectRGBFusionControllers() */

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

Controllers/RGBFusionGPUController/RGBFusionGPUController.cpp

@@ -0,0 +1,47 @@
+/*-----------------------------------------*\
+|  RGBFusionGPUController.cpp               |
+|                                           |
+|  Driver for Gigabyte Aorus RGB Fusion GPU |
+|  lighting controller                      |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 2/20/2020   |
+\*-----------------------------------------*/
+
+#include "RGBFusionGPUController.h"
+
+RGBFusionGPUController::RGBFusionGPUController(i2c_smbus_interface* bus, rgb_fusion_dev_id dev)
+{
+    this->bus = bus;
+    this->dev = dev;
+}
+
+RGBFusionGPUController::~RGBFusionGPUController()
+{
+
+}
+
+std::string RGBFusionGPUController::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);
+}
+
+void RGBFusionGPUController::SetColor(unsigned char red, unsigned char green, unsigned char blue)
+{
+    bus->i2c_smbus_write_byte(dev, RGB_FUSION_GPU_REG_COLOR);
+    bus->i2c_smbus_write_byte(dev, red);
+    bus->i2c_smbus_write_byte(dev, green);
+    bus->i2c_smbus_write_byte(dev, blue);
+}
+
+void RGBFusionGPUController::SetMode(unsigned char mode, unsigned char speed)
+{
+    bus->i2c_smbus_write_byte(dev, RGB_FUSION_GPU_REG_MODE);
+    bus->i2c_smbus_write_byte(dev, mode);
+    bus->i2c_smbus_write_byte(dev, speed);
+    bus->i2c_smbus_write_byte(dev, 0x63);
+}

Controllers/RGBFusionGPUController/RGBFusionGPUController.h

@@ -0,0 +1,54 @@
+/*-----------------------------------------*\
+|  RGBFusionGPUController.h                 |
+|                                           |
+|  Definitions and types for Gigabyte Aorus |
+|  RGB Fusion GPU lighting controller       |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 2/20/2020   |
+\*-----------------------------------------*/
+
+#include <string>
+#include "i2c_smbus.h"
+
+#pragma once
+
+typedef unsigned char	rgb_fusion_dev_id;
+
+enum
+{
+    RGB_FUSION_GPU_REG_COLOR            = 0x40,
+    RGB_FUSION_GPU_REG_MODE             = 0x88
+};
+
+enum
+{
+    RGB_FUSION_GPU_MODE_STATIC          = 0x01,
+    RGB_FUSION_GPU_MODE_BREATHING       = 0x02,
+    RGB_FUSION_GPU_MODE_FLASHING        = 0x04,
+    RGB_FUSION_GPU_MODE_DUAL_FLASHING   = 0x08,
+    RGB_FUSION_GPU_MODE_SPECTRUM_CYCLE  = 0x11
+};
+
+enum
+{
+    RGB_FUSION_GPU_SPEED_SLOWEST        = 0x00,
+    RGB_FUSION_GPU_SPEED_NORMAL         = 0x05,
+    RGB_FUSION_GPU_SPEED_FASTEST        = 0x09
+};
+
+class RGBFusionGPUController
+{
+public:
+    RGBFusionGPUController(i2c_smbus_interface* bus, rgb_fusion_dev_id dev);
+    ~RGBFusionGPUController();
+
+    std::string     GetDeviceLocation();
+
+    void            SetColor(unsigned char red, unsigned char green, unsigned char blue);
+    void            SetMode(unsigned char mode, unsigned char speed);
+
+private:
+    i2c_smbus_interface*    bus;
+    rgb_fusion_dev_id       dev;
+
+};

Controllers/RGBFusionGPUController/RGBFusionGPUControllerDetect.cpp

@@ -0,0 +1,83 @@
+#include "RGBFusionGPUController.h"
+#include "RGBController.h"
+#include "RGBController_RGBFusionGPU.h"
+#include "i2c_smbus.h"
+#include <vector>
+#include <stdio.h>
+#include <stdlib.h>
+
+/******************************************************************************************\
+*                                                                                          *
+*   TestForRGBFusionGPUController                                                          *
+*                                                                                          *
+*       Tests the given address to see if an RGB Fusion controller exists there.  First    *
+*       does a quick write to test for a response                                          *
+*                                                                                          *
+\******************************************************************************************/
+
+bool TestForRGBFusionGPUController(i2c_smbus_interface* bus, unsigned char address)
+{
+    bool pass = false;
+    int res;
+
+    //Write out 0xAB 0x00 0x00 0x00 sequence
+    res = bus->i2c_smbus_write_byte(address, 0xAB);
+
+    if (res >= 0)
+    {
+        bus->i2c_smbus_write_byte(address, 0x00);
+        bus->i2c_smbus_write_byte(address, 0x00);
+        bus->i2c_smbus_write_byte(address, 0x00);
+
+        pass = true;
+
+        res = bus->i2c_smbus_read_byte(address);
+
+        if (res != 0xAB)
+        {
+            pass = false;
+        }
+
+        res = bus->i2c_smbus_read_byte(address);
+
+        if(res != 0x14)
+        {
+            pass = false;
+        }
+
+        bus->i2c_smbus_read_byte(address);
+        bus->i2c_smbus_read_byte(address);
+    }
+
+    return(pass);
+
+}   /* TestForRGBFusionGPUController() */
+
+/******************************************************************************************\
+*                                                                                          *
+*   DetectRGBFusionGPUControllers                                                          *
+*                                                                                          *
+*       Detect RGB Fusion controllers on the enumerated I2C busses at address 0x47.        *
+*                                                                                          *
+*           bus - pointer to i2c_smbus_interface where RGB Fusion device is connected      *
+*           dev - I2C address of RGB Fusion device                                         *
+*                                                                                          *
+\******************************************************************************************/
+
+void DetectRGBFusionGPUControllers(std::vector<i2c_smbus_interface*>& busses, std::vector<RGBController*>& rgb_controllers)
+{
+    RGBFusionGPUController* new_rgb_fusion;
+    RGBController_RGBFusionGPU* new_controller;
+
+    for (unsigned int bus = 0; bus < busses.size(); bus++)
+    {
+        // Check for RGB Fusion controller at 0x47
+        if (TestForRGBFusionGPUController(busses[bus], 0x47))
+        {
+            new_rgb_fusion = new RGBFusionGPUController(busses[bus], 0x47);
+            new_controller = new RGBController_RGBFusionGPU(new_rgb_fusion);
+            rgb_controllers.push_back(new_controller);
+        }
+    }
+
+}   /* DetectRGBFusionGPUControllers() */

Controllers/ThermaltakeRiingController/ThermaltakeRiingController.cpp

@@ -0,0 +1,117 @@
+/*-----------------------------------------*\
+|  ThermaltakeRiingController.cpp           |
+|                                           |
+|  Definitions and types for Thermaltake    |
+|  Riing Plus lighting controller           |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 2/7/2020    |
+\*-----------------------------------------*/
+
+#include "ThermaltakeRiingController.h"
+
+#include <cstring>
+
+ThermaltakeRiingController::ThermaltakeRiingController(libusb_device_handle* dev_handle)
+{
+    dev = dev_handle;
+
+    SendInit();
+
+    channel_leds[0] = 9;
+    channel_leds[1] = 9;
+    channel_leds[2] = 9;
+    channel_leds[3] = 0;
+    channel_leds[4] = 0;
+}
+
+ThermaltakeRiingController::~ThermaltakeRiingController()
+{
+
+}
+
+void ThermaltakeRiingController::SetChannelLEDs(unsigned char channel, std::vector<RGBColor> colors)
+{
+    unsigned char* color_data = new unsigned char[3 * colors.size()];
+
+    for(int color = 0; color < colors.size(); color++)
+    {
+        int color_idx = color * 3;
+        color_data[color_idx + 0] = RGBGetGValue(colors[color]);
+        color_data[color_idx + 1] = RGBGetRValue(colors[color]);
+        color_data[color_idx + 2] = RGBGetBValue(colors[color]);
+    }
+
+    SendRGB(channel, current_mode, current_speed, colors.size(), color_data);
+
+    delete[] color_data;
+}
+
+void ThermaltakeRiingController::SetMode(unsigned char mode, unsigned char speed)
+{
+    current_mode        = mode;
+    current_speed       = speed;
+}
+
+/*-------------------------------------------------------------------------------------------------*\
+| Private packet sending functions.                                                                 |
+\*-------------------------------------------------------------------------------------------------*/
+
+void ThermaltakeRiingController::SendInit()
+{
+    unsigned char usb_buf[64];
+    int           actual;
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up Init packet                                    |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]   = 0xFE;
+    usb_buf[0x01]   = 0x33;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    libusb_interrupt_transfer(dev, 0x01, usb_buf, 64, &actual, 0);
+    libusb_interrupt_transfer(dev, 0x81, usb_buf, 64, &actual, 0);
+}
+
+void ThermaltakeRiingController::SendRGB
+    (
+        unsigned char       port,
+        unsigned char       mode,
+        unsigned char       speed,
+        unsigned char       num_colors,
+        unsigned char*      color_data
+    )
+{
+    unsigned char usb_buf[64];
+    int           actual;
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up RGB packet                                     |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]   = 0x32;
+    usb_buf[0x01]   = 0x52;
+    usb_buf[0x02]   = port;
+    usb_buf[0x03]   = mode + ( speed & 0x03 );
+
+    /*-----------------------------------------------------*\
+    | Copy in GRB color data                                |
+    \*-----------------------------------------------------*/
+    memcpy(&usb_buf[0x04], color_data, (num_colors * 3));
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    libusb_interrupt_transfer(dev, 0x01, usb_buf, 64, &actual, 0);
+    libusb_interrupt_transfer(dev, 0x81, usb_buf, 64, &actual, 0);
+}

Controllers/ThermaltakeRiingController/ThermaltakeRiingController.h

@@ -0,0 +1,75 @@
+/*-----------------------------------------*\
+|  ThermaltakeRiingController.h             |
+|                                           |
+|  Definitions and types for Thermaltake    |
+|  Riing Plus lighting controller           |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 2/7/2020    |
+\*-----------------------------------------*/
+
+#include "RGBController.h"
+#include <vector>
+#include <libusb-1.0/libusb.h>
+
+#pragma once
+
+enum
+{
+    THERMALTAKE_PORT_1              = 0x01,
+    THERMALTAKE_PORT_2              = 0x02,
+    THERMALTAKE_PORT_3              = 0x03,
+    THERMALTAKE_PORT_4              = 0x04,
+    THERMALTAKE_PORT_5              = 0x05
+};
+
+enum
+{
+    THERMALTAKE_MODE_FLOW           = 0x00,
+    THERMALTAKE_MODE_SPECTRUM       = 0x04,
+    THERMALTAKE_MODE_RIPPLE         = 0x08,
+    THERMALTAKE_MODE_BLINK          = 0x0C,
+    THERMALTAKE_MODE_PULSE          = 0x10,
+    THERMALTAKE_MODE_WAVE           = 0x14,
+    THERMALTAKE_MODE_PER_LED        = 0x18,
+    THERMALTAKE_MODE_FULL           = 0x19
+};
+
+enum
+{
+    THERMALTAKE_SPEED_SLOW          = 0x03,
+    THERMALTAKE_SPEED_NORMAL        = 0x02,
+    THERMALTAKE_SPEED_FAST          = 0x01,
+    THERMALTAKE_SPEED_EXTREME       = 0x00
+};
+
+class ThermaltakeRiingController
+{
+public:
+    ThermaltakeRiingController(libusb_device_handle* dev_handle);
+    ~ThermaltakeRiingController();
+
+    void            SetChannelLEDs(unsigned char channel, std::vector<RGBColor> colors);
+    void            SetMode(unsigned char mode, unsigned char speed);
+    
+    unsigned int    channel_leds[5];
+
+private:
+    libusb_device_handle*   dev;
+
+    unsigned char   current_mode;
+    unsigned char   current_speed;
+
+    void    SendInit();
+
+    void SendRGB
+        (
+            unsigned char       port,
+            unsigned char       mode,
+            unsigned char       speed,
+            unsigned char       num_colors,
+            unsigned char*      color_data
+        );
+
+    void    SendFan();
+    void    SendSave();
+};

Controllers/ThermaltakeRiingController/ThermaltakeRiingControllerDetect.cpp

@@ -0,0 +1,41 @@
+#include "ThermaltakeRiingController.h"
+#include "RGBController.h"
+#include "RGBController_ThermaltakeRiing.h"
+#include <vector>
+#include <libusb-1.0/libusb.h>
+
+#define THERMALTAKE_RIING_VID       0x264A
+#define THERMALTAKE_RIING_PID_BEGIN 0x1FA5
+#define THERMALTAKE_RIING_PID_END   0x1FB5
+
+/******************************************************************************************\
+*                                                                                          *
+*   DetectThermaltakeRiingControllers                                                      *
+*                                                                                          *
+*       Tests the USB address to see if an AMD Wraith Prism controller exists there.       *
+*                                                                                          *
+\******************************************************************************************/
+
+void DetectThermaltakeRiingControllers(std::vector<RGBController*>& rgb_controllers)
+{
+    libusb_context * ctx;
+    libusb_init(&ctx);
+
+    for(int pid = THERMALTAKE_RIING_PID_BEGIN; pid <= THERMALTAKE_RIING_PID_END; pid++)
+    {
+        //Look for Thermaltake Riing device
+        libusb_device_handle * dev = libusb_open_device_with_vid_pid(ctx, THERMALTAKE_RIING_VID, pid);
+
+        if( dev )
+        {
+            libusb_detach_kernel_driver(dev, 0);
+            libusb_claim_interface(dev, 0);
+
+            ThermaltakeRiingController* controller = new ThermaltakeRiingController(dev);
+
+            RGBController_ThermaltakeRiing* rgb_controller = new RGBController_ThermaltakeRiing(controller);
+
+            rgb_controllers.push_back(rgb_controller);
+        }
+    }
+}

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,30 +1,25 @@
 /******************************************************************************************\
 *                                                                                          *
-*   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>
 #include <stdlib.h>
 
 #ifdef WIN32
-
-#include <tchar.h>
 #include <regex>
 #include "i2c_smbus_piix4.h"
 #include "i2c_smbus_i801.h"
 #include "i2c_smbus_nct6775.h"
+#include "i2c_smbus_nvapi.h"
+#include "super_io.h"
 #include "wmi.h"
-#include "inpout32.h"
-
-#pragma comment(lib, "inpout32.lib")
 #else /* WIN32 */
 
 #include "i2c_smbus_linux.h"
@@ -39,68 +34,6 @@ std::vector<i2c_smbus_interface*> busses;
 std::vector<RGBController*> rgb_controllers;
 
 #ifdef WIN32
-/******************************************************************************************\
-*                                                                                          *
-*   Nuvoton Super IO constants                                                             *
-*                                                                                          *
-\******************************************************************************************/
-
-#define SIO_NCT5577_ID      0xC330  /* Device ID for NCT5577D (C333)        */
-#define SIO_NCT6102_ID      0x1060  /* Device ID for NCT6102D/6106D (1061)  */
-#define SIO_NCT6793_ID      0xd120  /* Device ID for NCT6793D (D121)        */
-#define SIO_NCT6796_ID      0xd420  /* Device ID for NCT6796D (D421)        */
-#define SIO_REG_LOGDEV      0x07    /* Logical Device Register              */
-#define SIO_REG_DEVID       0x20    /* Device ID Register                   */
-#define SIO_REG_SMBA        0x62    /* SMBus Base Address Register          */
-#define SIO_LOGDEV_SMBUS    0x0B    /* Logical Device for SMBus             */
-#define SIO_ID_MASK         0xFFF8  /* Device ID mask                       */
-
-
-/******************************************************************************************\
-*                                                                                          *
-*   superio_enter                                                                          *
-*                                                                                          *
-*   Put the Super IO chip into Extended Function Mode                                      *
-*                                                                                          *
-\******************************************************************************************/
-
-void superio_enter(int ioreg)
-{
-    Out32(ioreg, 0x87);
-    Out32(ioreg, 0x87);
-}
-
-
-/******************************************************************************************\
-*                                                                                          *
-*   superio_outb                                                                           *
-*                                                                                          *
-*   Write a byte to the Super IO configuration register                                    *
-*                                                                                          *
-\******************************************************************************************/
-
-void superio_outb(int ioreg, int reg, int val)
-{
-    Out32(ioreg, reg);
-    Out32(ioreg + 1, val);
-}
-
-
-/******************************************************************************************\
-*                                                                                          *
-*   superio_inb                                                                            *
-*                                                                                          *
-*   Read a byte to the Super IO configuration register                                     *
-*                                                                                          *
-\******************************************************************************************/
-
-int superio_inb(int ioreg, int reg)
-{
-    Out32(ioreg, reg);
-    return Inp32(ioreg + 1);
-}
-
-
 /******************************************************************************************\
 *                                                                                          *
 *   DetectNuvotonI2CBusses (Windows)                                                       *
@@ -155,6 +88,33 @@ void DetectNuvotonI2CBusses()
 
 }   /* DetectNuvotonI2CBusses() */
 
+/******************************************************************************************\
+*                                                                                          *
+*   DetectNvAPII2CBusses (Windows)                                                         *
+*                                                                                          *
+*       Detects available NVidia NvAPI I2C adapters and enumerates                         *
+*       i2c_smbus_interface objects for them.  Only enumerates the first bus for each GPU  *
+*                                                                                          *
+\******************************************************************************************/
+
+void DetectNvAPII2CBusses()
+{
+    static NV_PHYSICAL_GPU_HANDLE   gpu_handles[64];
+    static NV_S32                   gpu_count = 0;
+
+    NV_STATUS initialize = NvAPI_Initialize();
+
+    NvAPI_EnumPhysicalGPUs(gpu_handles, &gpu_count);
+
+    for(NV_S32 gpu_idx = 0; gpu_idx < gpu_count; gpu_idx++)
+    {
+        i2c_smbus_nvapi * nvapi_bus = new i2c_smbus_nvapi(gpu_handles[gpu_idx]);
+
+        sprintf(nvapi_bus->device_name, "NVidia NvAPI I2C on GPU %d", gpu_idx);
+
+        busses.push_back(nvapi_bus);
+    }
+}   /* DetectNvAPII2CBusses() */
 
 /******************************************************************************************\
 *                                                                                          *
@@ -238,6 +198,9 @@ void DetectI2CBusses()
     // Detect Nuvoton Super IO SMBus adapters
     DetectNuvotonI2CBusses();
 
+    // Detect NVidia NvAPI I2C adapters
+    DetectNvAPII2CBusses();
+
 }   /* DetectI2CBusses() */
 
 #else /* WIN32 */
@@ -320,126 +283,29 @@ 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 DetectCrucialControllers(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 DetectRGBFusionGPUControllers(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 DetectMSI3ZoneControllers(std::vector<RGBController*>& rgb_controllers);
+void DetectPoseidonZRGBControllers(std::vector<RGBController*>& rgb_controllers);
+void DetectCorsairCmdrProControllers(std::vector<RGBController*> &rgb_controllers);
+void DetectCorsairKeyboardControllers(std::vector<RGBController*>& rgb_controllers);
+void DetectCorsairNodeProControllers(std::vector<RGBController*> &rgb_controllers);
+void DetectFaustusControllers(std::vector<RGBController*> &rgb_controllers);
+void DetectHyperXKeyboardControllers(std::vector<RGBController*>& rgb_controllers);
+void DetectThermaltakeRiingControllers(std::vector<RGBController*>& rgb_controllers);
 
 /******************************************************************************************\
 *                                                                                          *
@@ -456,22 +322,40 @@ void DetectRGBControllers(void)
     DetectAuraControllers(busses, rgb_controllers);
     DetectCorsairControllers(busses, rgb_controllers);
     DetectCorsairProControllers(busses, rgb_controllers);
+    DetectCrucialControllers(busses, rgb_controllers);
     DetectHyperXControllers(busses, rgb_controllers);
+    DetectPatriotViperControllers(busses, rgb_controllers);
+    DetectPolychromeControllers(busses, rgb_controllers);
+    DetectRGBFusionGPUControllers(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);
+    DetectHyperXKeyboardControllers(rgb_controllers);
+    DetectCorsairCmdrProControllers(rgb_controllers);
+    DetectCorsairKeyboardControllers(rgb_controllers);
+    DetectCorsairNodeProControllers(rgb_controllers);
+    DetectThermaltakeRiingControllers(rgb_controllers);
     
-#ifdef WIN32
-    DetectRazerChromaSDKControllers(rgb_controllers);
-#else
     DetectE131Controllers(rgb_controllers);
+
+    /*-------------------------------------*\
+    | Windows-only devices                  |
+    \*-------------------------------------*/
+#ifdef WIN32
     DetectOpenRazerControllers(rgb_controllers);
+    /*-------------------------------------*\
+    | Linux-only devices                    |
+    \*-------------------------------------*/
+#else
+    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,290 @@
+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/                                                        \
+    super_io/                                                           \
+    Controllers/AMDWraithPrismController/                               \
+    Controllers/AuraController/                                         \
+    Controllers/CorsairController/                                      \
+    Controllers/CorsairCmdrProController/                               \
+    Controllers/CorsairKeyboardController/                              \
+    Controllers/CorsairNodeProController/                               \
+    Controllers/CorsairProController/                                   \
+    Controllers/CrucialController/                                      \
+    Controllers/Hue2Controller/                                         \
+    Controllers/HuePlusController/                                      \
+    Controllers/HyperXController/                                       \
+    Controllers/HyperXKeyboardController/                               \
+    Controllers/LEDStripController/                                     \
+    Controllers/MSI3ZoneController/                                     \
+    Controllers/PatriotViperController/                                 \
+    Controllers/PolychromeController/                                   \
+    Controllers/PoseidonZRGBController/                                 \
+    Controllers/RGBFusionController/                                    \
+    Controllers/RGBFusion2Controller/                                   \
+    Controllers/RGBFusionGPUController/                                 \
+    Controllers/ThermaltakeRiingController/                             \
+    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                                         \
+    super_io/super_io.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/CorsairKeyboardController/CorsairKeyboardController.cpp \
+    Controllers/CorsairKeyboardController/CorsairKeyboardControllerDetect.cpp \
+    Controllers/CorsairNodeProController/CorsairNodeProController.cpp   \
+    Controllers/CorsairNodeProController/CorsairNodeProControllerDetect.cpp \
+    Controllers/CorsairProController/CorsairProController.cpp           \
+    Controllers/CorsairProController/CorsairProControllerDetect.cpp     \
+    Controllers/CrucialController/CrucialController.cpp                 \
+    Controllers/CrucialController/CrucialControllerDetect.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/HyperXKeyboardController/HyperXKeyboardController.cpp   \
+    Controllers/HyperXKeyboardController/HyperXKeyboardControllerDetect.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       \
+    Controllers/RGBFusion2Controller/RGBFusion2Controller.cpp           \
+    Controllers/RGBFusion2Controller/RGBFusion2ControllerDetect.cpp     \
+    Controllers/RGBFusionGPUController/RGBFusionGPUController.cpp       \
+    Controllers/RGBFusionGPUController/RGBFusionGPUControllerDetect.cpp \
+    Controllers/ThermaltakeRiingController/ThermaltakeRiingController.cpp \
+    Controllers/ThermaltakeRiingController/ThermaltakeRiingControllerDetect.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_CorsairKeyboard.cpp                     \
+    RGBController/RGBController_CorsairNodePro.cpp                      \
+    RGBController/RGBController_CorsairPro.cpp                          \
+    RGBController/RGBController_Crucial.cpp                             \
+    RGBController/RGBController_Hue2.cpp                                \
+    RGBController/RGBController_HuePlus.cpp                             \
+    RGBController/RGBController_HyperX.cpp                              \
+    RGBController/RGBController_HyperXKeyboard.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                           \
+    RGBController/RGBController_RGBFusion2.cpp                          \
+    RGBController/RGBController_RGBFusionGPU.cpp                        \
+    RGBController/RGBController_ThermaltakeRiing.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                                           \
+    super_io/super_io.h                                                 \
+    Controllers/AMDWraithPrismController/AMDWraithPrismController.h     \
+    Controllers/AuraController/AuraController.h                         \
+    Controllers/CorsairController/CorsairController.h                   \
+    Controllers/CorsairCmdrProController/CorsairCmdrProController.h     \
+    Controllers/CorsairKeyboardController/CorsairKeyboardController.h   \
+    Controllers/CorsairNodeProController/CorsairNodeProController.h     \
+    Controllers/CorsairProController/CorsairProController.h             \
+    Controllers/CrucialController/CrucialController.h                   \
+    Controllers/Hue2Controller/Hue2Controller.h                         \
+    Controllers/HuePlusController/HuePlusController.h                   \
+    Controllers/HyperXController/HyperXController.h                     \
+    Controllers/HyperXKeyboardController/HyperXKeyboardController.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               \
+    Controllers/RGBFusion2Controller/RGBFusion2Controller.h             \
+    Controllers/RGBFusionGPUController/RGBFusionGPUController.h         \
+    Controllers/ThermaltakeRiingController/ThermaltakeRiingController.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_Crucial.h                               \
+    RGBController/RGBController_E131.h                                  \
+    RGBController/RGBController_Hue2.h                                  \
+    RGBController/RGBController_HuePlus.h                               \
+    RGBController/RGBController_HyperX.h                                \
+    RGBController/RGBController_HyperXKeyboard.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                             \
+    RGBController/RGBController_RGBFusion2.h                            \
+    RGBController/RGBController_RGBFusionGPU.h                          \
+    RGBController/RGBController_ThermaltakeRiing.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/libusb-1.0.22/include                                  \
+    dependencies/hidapi                                                 \
+    dependencies/NVFC                                                   \
+    dependencies/openrazer-win32                                        \
+    wmi/                                                                \
+
+win32:SOURCES +=                                                        \
+    dependencies/NVFC/nvapi.cpp                                         \
+    i2c_smbus/i2c_smbus_i801.cpp                                        \
+    i2c_smbus/i2c_smbus_nct6775.cpp                                     \
+    i2c_smbus/i2c_smbus_nvapi.cpp                                       \
+    i2c_smbus/i2c_smbus_piix4.cpp                                       \
+    serial_port/find_usb_serial_port_win.cpp                            \
+    wmi/wmi.cpp                                                         \
+    RGBController/OpenRazerWindowsDetect.cpp                            \
+    RGBController/RGBController_OpenRazerWindows.cpp                    \
+
+win32:HEADERS +=                                                        \
+    dependencies/inpout32_1501/Win32/inpout32.h                         \
+    dependencies/NVFC/nvapi.h                                           \
+    i2c_smbus/i2c_smbus_i801.h                                          \
+    i2c_smbus/i2c_smbus_nct6775.h                                       \
+    i2c_smbus/i2c_smbus_nvapi.h                                         \
+    i2c_smbus/i2c_smbus_piix4.h                                         \
+    wmi/wmi.h                                                           \
+    RGBController/RGBController_OpenRazerWindows.h                      \
+
+win32:contains(QMAKE_TARGET.arch, x86_64) {
+    LIBS +=                                                             \
+        -lws2_32                                                        \
+        -L"$$PWD/dependencies/inpout32_1501/x64/" -linpoutx64           \
+        -L"$$PWD/dependencies/libusb-1.0.22/MS64/dll" -llibusb-1.0      \
+        -L"$$PWD/dependencies/hidapi-win/x64/" -lhidapi
+}
+
+win32:contains(QMAKE_TARGET.arch, x86) {
+    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
+
+# Copy OpenRazer.dll to output directory
+win32:contains(QMAKE_TARGET.arch, x86_64) {
+    copydata.commands = $(COPY_FILE) \"$$shell_path($$PWD\\dependencies\\openrazer-win32\\OpenRazer64.dll)\" \"$$shell_path($$OUT_PWD)\"
+    first.depends = $(first) copydata
+    export(first.depends)
+    export(copydata.commands)
+    QMAKE_EXTRA_TARGETS += first copydata
+}
+
+win32:contains(QMAKE_TARGET.arch, x86) {
+    copydata.commands = $(COPY_FILE) \"$$shell_path($$PWD\\dependencies\\openrazer-win32\\OpenRazer.dll)\" \"$$shell_path($$OUT_PWD)\"
+    first.depends = $(first) copydata
+    export(first.depends)
+    export(copydata.commands)
+    QMAKE_EXTRA_TARGETS += first copydata
+}
+
+#-----------------------------------------------
+# 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/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;
 
@@ -59,7 +58,7 @@ void DetectOpenRazerControllers(std::vector<RGBController*> &rgb_controllers)
             break;
         
         case 7:
-            strcpy(driver_path, "/sys/bus/hid/drivers/razerchromahdk/");
+            strcpy(driver_path, "/sys/bus/hid/drivers/razeraccessory/");
             break;
         }
 
@@ -97,14 +96,13 @@ 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);
 
                     RGBController_OpenRazer * razer_rgb = new RGBController_OpenRazer(device_string);
 
-                    if(razer_rgb->device != -1)
+                    if(razer_rgb->device_index != -1)
                     {
                         rgb_controllers.push_back(razer_rgb);
                     }
@@ -124,4 +122,4 @@ void DetectOpenRazerControllers(std::vector<RGBController*> &rgb_controllers)
         driver_to_read++;
     }
 
-}   /* DetectOpenRazerControllers() */
+}   /* DetectOpenRazerControllers() */

RGBController/OpenRazerWindowsDetect.cpp

@@ -0,0 +1,387 @@
+#include "RGBController.h"
+#include "RGBController_OpenRazerWindows.h"
+#include <vector>
+#include <stdio.h>
+#include <stdlib.h>
+#include <Windows.h>
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/hid.h>
+
+#ifdef _WIN64
+#define OPENRAZERDLL            "OpenRazer64.dll"
+#elif WIN32
+#define OPENRAZERDLL            "OpenRazer.dll"
+#endif
+
+/******************************************************************************************\
+*                                                                                          *
+*   DetectOpenRazerControllers                                                             *
+*                                                                                          *
+*       Detect devices supported by the OpenRazer kernel drivers                           *
+*                                                                                          *
+\******************************************************************************************/
+
+void DetectOpenRazerControllers(std::vector<RGBController*> &rgb_controllers)
+{
+    static HMODULE module = LoadLibrary(OPENRAZERDLL);
+
+	if(module == nullptr)
+    {
+        return;
+    }
+
+    // map DLL calls
+	typedef unsigned int(*INITRAZERDRIVER)(struct hid_device** hdev);
+	
+	INITRAZERDRIVER init_razer_kbd_driver = reinterpret_cast<INITRAZERDRIVER>(GetProcAddress(module, "init_razer_kbd_driver"));
+    static struct device_attribute devkbd_attr_device_type         				= *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devkbd_attr_device_type"));
+    static struct device_attribute devkbd_attr_device_serial       				= *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devkbd_attr_device_serial"));
+    static struct device_attribute devkbd_attr_firmware_version    				= *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devkbd_attr_firmware_version"));
+	static struct device_attribute devkbd_attr_matrix_effect_custom				= *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devkbd_attr_matrix_effect_custom"));
+	static struct device_attribute devkbd_attr_matrix_custom_frame 				= *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devkbd_attr_matrix_custom_frame"));
+	static struct device_attribute devkbd_attr_matrix_brightness   				= *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devkbd_attr_matrix_brightness"));
+	static struct device_attribute devkbd_attr_matrix_effect_none  				= *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devkbd_attr_matrix_effect_none"));
+	static struct device_attribute devkbd_attr_matrix_effect_static				= *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devkbd_attr_matrix_effect_static"));
+	static struct device_attribute devkbd_attr_matrix_effect_breath			    = *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devkbd_attr_matrix_effect_breath"));
+	static struct device_attribute devkbd_attr_matrix_effect_spectrum			= *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devkbd_attr_matrix_effect_spectrum"));
+	static struct device_attribute devkbd_attr_matrix_effect_reactive			= *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devkbd_attr_matrix_effect_reactive"));
+	static struct device_attribute devkbd_attr_matrix_effect_wave				= *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devkbd_attr_matrix_effect_wave"));
+
+	INITRAZERDRIVER init_razer_mousemat_driver = reinterpret_cast<INITRAZERDRIVER>(GetProcAddress(module, "init_razer_mousemat_driver"));
+    static struct device_attribute devmousemat_attr_device_type                  = *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devmousemat_attr_device_type"));
+    static struct device_attribute devmousemat_attr_device_serial                = *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devmousemat_attr_device_serial"));
+    static struct device_attribute devmousemat_attr_firmware_version             = *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devmousemat_attr_firmware_version"));
+	static struct device_attribute devmousemat_attr_matrix_effect_custom         = *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devmousemat_attr_matrix_effect_custom"));
+	static struct device_attribute devmousemat_attr_matrix_custom_frame          = *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devmousemat_attr_matrix_custom_frame"));
+	static struct device_attribute devmousemat_attr_matrix_brightness            = *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devmousemat_attr_matrix_brightness"));
+	static struct device_attribute devmousemat_attr_matrix_effect_none           = *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devmousemat_attr_matrix_effect_none"));
+	static struct device_attribute devmousemat_attr_matrix_effect_static         = *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devmousemat_attr_matrix_effect_static"));
+	static struct device_attribute devmousemat_attr_matrix_effect_breath	        = *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devmousemat_attr_matrix_effect_breath"));
+	static struct device_attribute devmousemat_attr_matrix_effect_spectrum       = *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devmousemat_attr_matrix_effect_spectrum"));
+	static struct device_attribute devmousemat_attr_matrix_effect_reactive       = *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devmousemat_attr_matrix_effect_reactive"));
+	static struct device_attribute devmousemat_attr_matrix_effect_wave           = *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devmousemat_attr_matrix_effect_wave"));
+	
+	INITRAZERDRIVER init_razer_mouse_driver = reinterpret_cast<INITRAZERDRIVER>(GetProcAddress(module, "init_razer_mouse_driver"));
+    static struct device_attribute devmouse_attr_device_type                   	= *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devmouse_attr_device_type"));
+    static struct device_attribute devmouse_attr_device_serial                 	= *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devmouse_attr_device_serial"));
+    static struct device_attribute devmouse_attr_firmware_version              	= *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devmouse_attr_firmware_version"));
+	static struct device_attribute devmouse_attr_matrix_effect_custom          	= *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devmouse_attr_matrix_effect_custom"));
+	static struct device_attribute devmouse_attr_matrix_custom_frame           	= *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devmouse_attr_matrix_custom_frame"));
+	static struct device_attribute devmouse_attr_matrix_brightness             	= *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devmouse_attr_matrix_brightness"));
+	static struct device_attribute devmouse_attr_logo_led_brightness           	= *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devmouse_attr_logo_led_brightness"));
+	static struct device_attribute devmouse_attr_scroll_led_brightness         	= *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devmouse_attr_scroll_led_brightness"));
+	static struct device_attribute devmouse_attr_matrix_effect_none            	= *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devmouse_attr_matrix_effect_none"));
+	static struct device_attribute devmouse_attr_logo_matrix_effect_none       	= *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devmouse_attr_logo_matrix_effect_none"));
+	static struct device_attribute devmouse_attr_scroll_matrix_effect_none     	= *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devmouse_attr_scroll_matrix_effect_none"));
+	static struct device_attribute devmouse_attr_matrix_effect_static          	= *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devmouse_attr_matrix_effect_static"));
+	static struct device_attribute devmouse_attr_logo_matrix_effect_static     	= *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devmouse_attr_logo_matrix_effect_static"));
+	static struct device_attribute devmouse_attr_scroll_matrix_effect_static   	= *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devmouse_attr_scroll_matrix_effect_static"));
+	static struct device_attribute devmouse_attr_matrix_effect_breath 	        = *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devmouse_attr_matrix_effect_breath"));
+	static struct device_attribute devmouse_attr_matrix_effect_spectrum        	= *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devmouse_attr_matrix_effect_spectrum"));
+	static struct device_attribute devmouse_attr_logo_matrix_effect_spectrum   	= *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devmouse_attr_logo_matrix_effect_spectrum"));
+	static struct device_attribute devmouse_attr_scroll_matrix_effect_spectrum 	= *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devmouse_attr_scroll_matrix_effect_spectrum"));
+	static struct device_attribute devmouse_attr_matrix_effect_reactive        	= *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devmouse_attr_matrix_effect_reactive"));
+	static struct device_attribute devmouse_attr_logo_matrix_effect_reactive   	= *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devmouse_attr_logo_matrix_effect_reactive"));
+	static struct device_attribute devmouse_attr_scroll_matrix_effect_reactive 	= *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devmouse_attr_scroll_matrix_effect_reactive"));
+	static struct device_attribute devmouse_attr_scroll_led_effect             	= *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devmouse_attr_scroll_led_effect"));
+	static struct device_attribute devmouse_attr_scroll_led_rgb                	= *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devmouse_attr_scroll_led_rgb"));
+	static struct device_attribute devmouse_attr_scroll_led_state              	= *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devmouse_attr_scroll_led_state"));
+	static struct device_attribute devmouse_attr_matrix_effect_wave            	= *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devmouse_attr_matrix_effect_wave"));
+
+	INITRAZERDRIVER init_razer_accessory_driver = reinterpret_cast<INITRAZERDRIVER>(GetProcAddress(module, "init_razer_accessory_driver"));
+    static struct device_attribute devaccessory_attr_device_type                      = *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devaccessory_attr_device_type"));
+    static struct device_attribute devaccessory_attr_device_serial                    = *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devaccessory_attr_device_serial"));
+    static struct device_attribute devaccessory_attr_firmware_version                 = *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devaccessory_attr_firmware_version"));
+	static struct device_attribute devaccessory_attr_matrix_effect_custom             = *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devaccessory_attr_matrix_effect_custom"));
+	static struct device_attribute devaccessory_attr_matrix_custom_frame              = *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devaccessory_attr_matrix_custom_frame"));
+	static struct device_attribute devaccessory_attr_matrix_brightness                = *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devaccessory_attr_matrix_brightness"));
+	static struct device_attribute devaccessory_attr_matrix_effect_none               = *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devaccessory_attr_matrix_effect_none"));
+	static struct device_attribute devaccessory_attr_matrix_effect_static             = *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devaccessory_attr_matrix_effect_static"));
+	static struct device_attribute devaccessory_attr_matrix_effect_breath	    	    = *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devaccessory_attr_matrix_effect_breath"));
+	static struct device_attribute devaccessory_attr_matrix_effect_spectrum           = *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devaccessory_attr_matrix_effect_spectrum"));
+	//static struct device_attribute devaccessory_attr_matrix_effect_reactive         = *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devaccessory_attr_matrix_effect_reactive"));
+	static struct device_attribute devaccessory_attr_matrix_effect_wave               = *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devaccessory_attr_matrix_effect_wave"));
+
+	INITRAZERDRIVER init_razer_kraken_driver = reinterpret_cast<INITRAZERDRIVER>(GetProcAddress(module, "init_razer_kraken_driver"));
+    static struct device_attribute devkraken_attr_device_type                   = *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devkraken_attr_device_type"));
+    static struct device_attribute devkraken_attr_device_serial                 = *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devkraken_attr_device_serial"));
+    static struct device_attribute devkraken_attr_firmware_version              = *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devkraken_attr_firmware_version"));
+	static struct device_attribute devkraken_attr_matrix_effect_custom          = *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devkraken_attr_matrix_effect_custom"));
+    //static struct device_attribute devkraken_attr_matrix_custom_frame           = *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devkraken_attr_matrix_custom_frame"));
+	//static struct device_attribute devkraken_attr_matrix_brightness           = *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devkraken_attr_matrix_brightness"));
+	static struct device_attribute devkraken_attr_matrix_effect_none            = *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devkraken_attr_matrix_effect_none"));
+	static struct device_attribute devkraken_attr_matrix_effect_static          = *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devkraken_attr_matrix_effect_static"));
+	static struct device_attribute devkraken_attr_matrix_effect_breath	        = *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devkraken_attr_matrix_effect_breath"));
+	static struct device_attribute devkraken_attr_matrix_effect_spectrum        = *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devkraken_attr_matrix_effect_spectrum"));
+
+	INITRAZERDRIVER init_razer_core_driver = reinterpret_cast<INITRAZERDRIVER>(GetProcAddress(module, "init_razer_core_driver"));
+    static struct device_attribute devcore_attr_device_type                     = *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devcore_attr_device_type"));
+    static struct device_attribute devcore_attr_device_serial                   = *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devcore_attr_device_serial"));
+    static struct device_attribute devcore_attr_firmware_version                = *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devcore_attr_firmware_version"));
+	static struct device_attribute devcore_attr_matrix_effect_custom            = *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devcore_attr_matrix_effect_custom"));
+	static struct device_attribute devcore_attr_matrix_custom_frame             = *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devcore_attr_matrix_custom_frame"));
+	static struct device_attribute devcore_attr_matrix_brightness               = *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devcore_attr_matrix_brightness"));
+	static struct device_attribute devcore_attr_matrix_effect_none              = *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devcore_attr_matrix_effect_none"));
+	static struct device_attribute devcore_attr_matrix_effect_static            = *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devcore_attr_matrix_effect_static"));
+	static struct device_attribute devcore_attr_matrix_effect_breath	        = *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devcore_attr_matrix_effect_breath"));
+	static struct device_attribute devcore_attr_matrix_effect_spectrum          = *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devcore_attr_matrix_effect_spectrum"));
+	static struct device_attribute devcore_attr_matrix_effect_reactive          = *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devcore_attr_matrix_effect_reactive"));
+	static struct device_attribute devcore_attr_matrix_effect_wave              = *(struct device_attribute*)reinterpret_cast<void*>(GetProcAddress(module, "devcore_attr_matrix_effect_wave"));
+
+	struct hid_device* hdev;
+	unsigned int num;
+
+    hdev = NULL;
+	num = init_razer_kbd_driver(&hdev);
+	for (unsigned int i = 0; i < num; i++)
+    {
+        device_fn_type* device_fn = new device_fn_type;
+        device_fn->device_type             	     = &devkbd_attr_device_type;
+        device_fn->device_serial           	     = &devkbd_attr_device_serial;
+		device_fn->firmware_version			     = &devkbd_attr_firmware_version;
+        device_fn->matrix_effect_custom    	     = &devkbd_attr_matrix_effect_custom;
+        device_fn->matrix_custom_frame     	     = &devkbd_attr_matrix_custom_frame;
+        device_fn->matrix_brightness       	     = &devkbd_attr_matrix_brightness;
+        device_fn->matrix_effect_none      	     = &devkbd_attr_matrix_effect_none;
+        device_fn->matrix_effect_static    	     = &devkbd_attr_matrix_effect_static;
+		device_fn->matrix_effect_breath	         = &devkbd_attr_matrix_effect_breath;
+        device_fn->matrix_effect_spectrum  	     = &devkbd_attr_matrix_effect_spectrum;
+        device_fn->matrix_effect_reactive  	     = &devkbd_attr_matrix_effect_reactive;
+		device_fn->matrix_effect_wave		     = &devkbd_attr_matrix_effect_wave;
+        device_fn->logo_led_brightness           = NULL;
+        device_fn->logo_matrix_effect_none       = NULL;
+        device_fn->logo_matrix_effect_static     = NULL;
+        device_fn->logo_matrix_effect_spectrum   = NULL;
+        device_fn->logo_matrix_effect_reactive   = NULL;
+        device_fn->scroll_led_brightness         = NULL;
+        device_fn->scroll_matrix_effect_none     = NULL;
+        device_fn->scroll_matrix_effect_static   = NULL;
+        device_fn->scroll_matrix_effect_spectrum = NULL;
+        device_fn->scroll_matrix_effect_reactive = NULL;
+        device_fn->scroll_led_effect             = NULL;
+        device_fn->scroll_led_rgb                = NULL;
+        RGBController_OpenRazer * razer_rgb = new RGBController_OpenRazer(&hdev[i].dev, device_fn);
+
+        if(razer_rgb->device_index != -1)
+        {
+            rgb_controllers.push_back(razer_rgb);
+        }
+        else
+        {
+            delete razer_rgb;
+        }
+    }
+
+    hdev = NULL;
+	num = init_razer_mouse_driver(&hdev);
+	for (unsigned int i = 0; i < num; i++)
+    {
+        device_fn_type* device_fn = new device_fn_type;
+        device_fn->device_type             	     = &devmouse_attr_device_type;
+        device_fn->device_serial           	     = &devmouse_attr_device_serial;
+		device_fn->firmware_version			     = &devmouse_attr_firmware_version;
+        device_fn->matrix_effect_custom    	     = &devmouse_attr_matrix_effect_custom;
+        device_fn->matrix_custom_frame     	     = &devmouse_attr_matrix_custom_frame;
+        device_fn->matrix_brightness       	     = &devmouse_attr_matrix_brightness;
+        device_fn->matrix_effect_none      	     = &devmouse_attr_matrix_effect_none;
+        device_fn->matrix_effect_static    	     = &devmouse_attr_matrix_effect_static;
+		device_fn->matrix_effect_breath	         = &devmouse_attr_matrix_effect_breath;
+        device_fn->matrix_effect_spectrum  	     = &devmouse_attr_matrix_effect_spectrum;
+        device_fn->matrix_effect_reactive  	     = &devmouse_attr_matrix_effect_reactive;
+		device_fn->matrix_effect_wave		     = &devmouse_attr_matrix_effect_wave;
+        device_fn->logo_led_brightness           = NULL;
+        device_fn->logo_matrix_effect_none       = NULL;
+        device_fn->logo_matrix_effect_static     = NULL;
+        device_fn->logo_matrix_effect_spectrum   = NULL;
+        device_fn->logo_matrix_effect_reactive   = NULL;
+        device_fn->scroll_led_brightness         = NULL;
+        device_fn->scroll_matrix_effect_none     = NULL;
+        device_fn->scroll_matrix_effect_static   = NULL;
+        device_fn->scroll_matrix_effect_spectrum = NULL;
+        device_fn->scroll_matrix_effect_reactive = NULL;
+        device_fn->scroll_led_effect             = NULL;
+        device_fn->scroll_led_rgb                = NULL;
+
+        RGBController_OpenRazer * razer_rgb = new RGBController_OpenRazer(&hdev[i].dev, device_fn);
+
+        if(razer_rgb->device_index != -1)
+        {
+            rgb_controllers.push_back(razer_rgb);
+        }
+        else
+        {
+            delete razer_rgb;
+        }
+    }
+
+    hdev = NULL;
+	num = init_razer_mousemat_driver(&hdev);
+	for (unsigned int i = 0; i < num; i++)
+    {
+        device_fn_type* device_fn = new device_fn_type;
+        device_fn->device_type             	     = &devmousemat_attr_device_type;
+        device_fn->device_serial           	     = &devmousemat_attr_device_serial;
+		device_fn->firmware_version			     = &devmousemat_attr_firmware_version;
+        device_fn->matrix_effect_custom    	     = &devmousemat_attr_matrix_effect_custom;
+        device_fn->matrix_custom_frame     	     = &devmousemat_attr_matrix_custom_frame;
+        device_fn->matrix_brightness       	     = &devmousemat_attr_matrix_brightness;
+        device_fn->matrix_effect_none      	     = &devmousemat_attr_matrix_effect_none;
+        device_fn->matrix_effect_static    	     = &devmousemat_attr_matrix_effect_static;
+		device_fn->matrix_effect_breath	         = &devmousemat_attr_matrix_effect_breath;
+        device_fn->matrix_effect_spectrum  	     = &devmousemat_attr_matrix_effect_spectrum;
+        device_fn->matrix_effect_reactive  	     = &devmousemat_attr_matrix_effect_reactive;
+		device_fn->matrix_effect_wave		     = &devmousemat_attr_matrix_effect_wave;
+        device_fn->logo_led_brightness           = NULL;
+        device_fn->logo_matrix_effect_none       = NULL;
+        device_fn->logo_matrix_effect_static     = NULL;
+        device_fn->logo_matrix_effect_spectrum   = NULL;
+        device_fn->logo_matrix_effect_reactive   = NULL;
+        device_fn->scroll_led_brightness         = NULL;
+        device_fn->scroll_matrix_effect_none     = NULL;
+        device_fn->scroll_matrix_effect_static   = NULL;
+        device_fn->scroll_matrix_effect_spectrum = NULL;
+        device_fn->scroll_matrix_effect_reactive = NULL;
+        device_fn->scroll_led_effect             = NULL;
+        device_fn->scroll_led_rgb                = NULL;
+
+        RGBController_OpenRazer * razer_rgb = new RGBController_OpenRazer(&hdev[i].dev, device_fn);
+
+        if(razer_rgb->device_index != -1)
+        {
+            rgb_controllers.push_back(razer_rgb);
+        }
+        else
+        {
+            delete razer_rgb;
+        }
+    }
+
+    hdev = NULL;
+	num = init_razer_accessory_driver(&hdev);
+	for (unsigned int i = 0; i < num; i++)
+    {
+        device_fn_type* device_fn = new device_fn_type;
+        device_fn->device_type                   = &devaccessory_attr_device_type;
+        device_fn->device_serial                 = &devaccessory_attr_device_serial;
+		device_fn->firmware_version			     = &devaccessory_attr_firmware_version;
+        device_fn->matrix_effect_custom          = &devaccessory_attr_matrix_effect_custom;
+        device_fn->matrix_custom_frame           = &devaccessory_attr_matrix_custom_frame;
+        device_fn->matrix_brightness             = &devaccessory_attr_matrix_brightness;
+        device_fn->matrix_effect_none            = &devaccessory_attr_matrix_effect_none;
+        device_fn->matrix_effect_static          = &devaccessory_attr_matrix_effect_static;
+		device_fn->matrix_effect_breath	         = &devaccessory_attr_matrix_effect_breath;
+        device_fn->matrix_effect_spectrum        = &devaccessory_attr_matrix_effect_spectrum;
+        device_fn->matrix_effect_reactive        = NULL;//&devaccessory_attr_matrix_effect_reactive;
+		device_fn->matrix_effect_wave            = &devaccessory_attr_matrix_effect_wave;
+        device_fn->logo_led_brightness           = NULL;
+        device_fn->logo_matrix_effect_none       = NULL;
+        device_fn->logo_matrix_effect_static     = NULL;
+        device_fn->logo_matrix_effect_spectrum   = NULL;
+        device_fn->logo_matrix_effect_reactive   = NULL;
+        device_fn->scroll_led_brightness         = NULL;
+        device_fn->scroll_matrix_effect_none     = NULL;
+        device_fn->scroll_matrix_effect_static   = NULL;
+        device_fn->scroll_matrix_effect_spectrum = NULL;
+        device_fn->scroll_matrix_effect_reactive = NULL;
+        device_fn->scroll_led_effect             = NULL;
+        device_fn->scroll_led_rgb                = NULL;
+
+        RGBController_OpenRazer * razer_rgb = new RGBController_OpenRazer(&hdev[i].dev, device_fn);
+
+        if(razer_rgb->device_index != -1)
+        {
+            rgb_controllers.push_back(razer_rgb);
+        }
+        else
+        {
+            delete razer_rgb;
+        }
+    }
+
+    hdev = NULL;
+	num = init_razer_kraken_driver(&hdev);
+	for (unsigned int i = 0; i < num; i++)
+    {
+        device_fn_type* device_fn = new device_fn_type;
+        device_fn->device_type                   = &devkraken_attr_device_type;
+        device_fn->device_serial                 = &devkraken_attr_device_serial;
+		device_fn->firmware_version			     = &devkraken_attr_firmware_version;
+        device_fn->matrix_effect_custom          = &devkraken_attr_matrix_effect_custom;
+        device_fn->matrix_custom_frame           = NULL;//&devkraken_attr_matrix_custom_frame;
+        device_fn->matrix_brightness             = NULL;//&devkraken_attr_matrix_brightness;
+        device_fn->matrix_effect_none            = &devkraken_attr_matrix_effect_none;
+        device_fn->matrix_effect_static          = &devkraken_attr_matrix_effect_static;
+		device_fn->matrix_effect_breath	         = &devkraken_attr_matrix_effect_breath;
+        device_fn->matrix_effect_spectrum        = &devkraken_attr_matrix_effect_spectrum;
+        device_fn->matrix_effect_reactive        = NULL;//&devkraken_attr_matrix_effect_reactive;
+		device_fn->matrix_effect_wave            = NULL;//&devkraken_attr_matrix_effect_wave;
+        device_fn->logo_led_brightness           = NULL;
+        device_fn->logo_matrix_effect_none       = NULL;
+        device_fn->logo_matrix_effect_static     = NULL;
+        device_fn->logo_matrix_effect_spectrum   = NULL;
+        device_fn->logo_matrix_effect_reactive   = NULL;
+        device_fn->scroll_led_brightness         = NULL;
+        device_fn->scroll_matrix_effect_none     = NULL;
+        device_fn->scroll_matrix_effect_static   = NULL;
+        device_fn->scroll_matrix_effect_spectrum = NULL;
+        device_fn->scroll_matrix_effect_reactive = NULL;
+        device_fn->scroll_led_effect             = NULL;
+        device_fn->scroll_led_rgb                = NULL;
+
+        RGBController_OpenRazer * razer_rgb = new RGBController_OpenRazer(&hdev[i].dev, device_fn);
+
+        if(razer_rgb->device_index != -1)
+        {
+            rgb_controllers.push_back(razer_rgb);
+        }
+        else
+        {
+            delete razer_rgb;
+        }
+    }
+
+    hdev = NULL;
+	num = init_razer_core_driver(&hdev);
+	for (unsigned int i = 0; i < num; i++)
+    {
+        device_fn_type* device_fn = new device_fn_type;
+        device_fn->device_type                   = &devcore_attr_device_type;
+        device_fn->device_serial                 = &devcore_attr_device_serial;
+		device_fn->firmware_version			     = &devcore_attr_firmware_version;
+        device_fn->matrix_effect_custom          = &devcore_attr_matrix_effect_custom;
+        device_fn->matrix_custom_frame           = &devcore_attr_matrix_custom_frame;
+        device_fn->matrix_brightness             = &devcore_attr_matrix_brightness;
+        device_fn->matrix_effect_none            = &devcore_attr_matrix_effect_none;
+        device_fn->matrix_effect_static          = &devcore_attr_matrix_effect_static;
+		device_fn->matrix_effect_breath	         = &devcore_attr_matrix_effect_breath;
+        device_fn->matrix_effect_spectrum        = &devcore_attr_matrix_effect_spectrum;
+        device_fn->matrix_effect_reactive        = &devcore_attr_matrix_effect_reactive;
+		device_fn->matrix_effect_wave            = &devcore_attr_matrix_effect_wave;
+        device_fn->logo_led_brightness           = NULL;
+        device_fn->logo_matrix_effect_none       = NULL;
+        device_fn->logo_matrix_effect_static     = NULL;
+        device_fn->logo_matrix_effect_spectrum   = NULL;
+        device_fn->logo_matrix_effect_reactive   = NULL;
+        device_fn->scroll_led_brightness         = NULL;
+        device_fn->scroll_matrix_effect_none     = NULL;
+        device_fn->scroll_matrix_effect_static   = NULL;
+        device_fn->scroll_matrix_effect_spectrum = NULL;
+        device_fn->scroll_matrix_effect_reactive = NULL;
+        device_fn->scroll_led_effect             = NULL;
+        device_fn->scroll_led_rgb                = NULL;
+
+        RGBController_OpenRazer * razer_rgb = new RGBController_OpenRazer(&hdev[i].dev, device_fn);
+
+        if(razer_rgb->device_index != -1)
+        {
+            rgb_controllers.push_back(razer_rgb);
+        }
+        else
+        {
+            delete razer_rgb;
+        }
+    }
+
+}   /* 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,73 @@ 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_PER_LED_COLOR         = (1 << 5), /* Mode has per-LED colors          */
+    MODE_FLAG_HAS_MODE_SPECIFIC_COLOR   = (1 << 6), /* Mode has mode specific colors    */
+    MODE_FLAG_HAS_RANDOM_COLOR          = (1 << 7), /* Mode has random color option     */
+};
+
+/*------------------------------------------------------------------*\
+| 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          */
+};
+
+enum
+{
+    MODE_COLORS_NONE            = 0,        /* Mode has no colors               */
+    MODE_COLORS_PER_LED         = 1,        /* Mode has per LED colors selected */
+    MODE_COLORS_MODE_SPECIFIC   = 2,        /* Mode specific colors selected    */
+    MODE_COLORS_RANDOM          = 3,        /* Mode has random colors selected  */
+};
+
+/*------------------------------------------------------------------*\
+| 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          */
+    unsigned int        colors_min; /* minimum number of mode colors*/
+    unsigned int        colors_max; /* maximum numver of mode colors*/
+    
+    /*--------------------------------------------------------------*\
+    | Mode Settings                                                  |
+    \*--------------------------------------------------------------*/
+    unsigned int        speed;  /* Mode speed parameter value       */
+    unsigned int        direction;  /* Mode direction value         */
+    unsigned int        color_mode; /* Mode color selection         */
+    std::vector<RGBColor>
+                        colors; /* mode-specific colors             */
+} mode;
+
 typedef struct
 {
     std::string         name;   /* LED name         */
 } led;
 
-typedef struct
-{
-    std::string         name;   /* Mode name        */
-} mode;
-
 typedef int zone_type;
 
 enum
@@ -39,6 +96,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 +123,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,216 @@
+/*-----------------------------------------*\
+|  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_PER_LED_COLOR;
+    Static.color_mode = MODE_COLORS_PER_LED;
+    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_PER_LED_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
+    Breathing.speed_min  = AMD_WRAITH_PRISM_SPEED_SLOWEST;
+    Breathing.speed_max  = AMD_WRAITH_PRISM_SPEED_FASTEST;
+    Breathing.color_mode = MODE_COLORS_PER_LED;
+    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.color_mode = MODE_COLORS_NONE;
+    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.color_mode = MODE_COLORS_NONE;
+    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.color_mode = MODE_COLORS_NONE;
+    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_PER_LED_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
+    Chase.speed_min  = AMD_WRAITH_PRISM_SPEED_SLOWEST;
+    Chase.speed_max  = AMD_WRAITH_PRISM_SPEED_FASTEST;
+    Chase.color_mode = MODE_COLORS_PER_LED;
+    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_PER_LED_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
+    Swirl.speed_min  = AMD_WRAITH_PRISM_SPEED_SLOWEST;
+    Swirl.speed_max  = AMD_WRAITH_PRISM_SPEED_FASTEST;
+    Swirl.color_mode = MODE_COLORS_PER_LED;
+    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()
+{
+    active_mode = 0;
+}
+
+void RGBController_AMDWraithPrism::UpdateMode()
+{
+    bool random = (modes[active_mode].color_mode == MODE_COLORS_RANDOM);
+
+    wraith->SetRingMode(modes[active_mode].value, modes[active_mode].speed, modes[active_mode].direction, 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, random);
+            wraith->SetLogoMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_COLOR_CYCLE, modes[active_mode].speed, random);
+            break;
+        
+        case AMD_WRAITH_PRISM_EFFECT_CHANNEL_BREATHING:
+            wraith->SetFanMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_BREATHING, modes[active_mode].speed, random);
+            wraith->SetLogoMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_BREATHING, modes[active_mode].speed, random);
+            break;
+
+        default:
+            if(random)
+            {
+                wraith->SetFanMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_COLOR_CYCLE, modes[active_mode].speed, random);
+                wraith->SetLogoMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_COLOR_CYCLE, modes[active_mode].speed, random);
+            }
+            else
+            {
+                wraith->SetFanMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_STATIC, modes[active_mode].speed, random);
+                wraith->SetLogoMode(AMD_WRAITH_PRISM_FAN_LOGO_MODE_STATIC, modes[active_mode].speed, 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

@@ -1,92 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_AorusGPU.cpp               |
-|                                           |
-|  Generic RGB Interface for OpenAuraSDK    |
-|  Aorus GPU                                |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 6/17/2019   |
-\*-----------------------------------------*/
-
-#include "RGBController_AorusGPU.h"
-
-#include <Windows.h>
-
-static HMODULE handle;
-static unsigned char data[] = { 0x8E, 0x00, 0x00, 0x00,
-                                0x00, 0x00, 0x00, 0x00,
-                                0x40, 0x00, 0x00, 0x00,
-                                0x00, 0x00, 0x00, 0x00,
-                                0x04, 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)
-{
-    data[9] = RGBGetRValue(color);
-    data[10] = RGBGetGValue(color);
-    data[11] = RGBGetBValue(color);
-
-    GvWriteI2C(0x00000000, data, 0x00000000);
-}
-
-void RGBController_AorusGPU::SetAllZoneLEDs(int zone, RGBColor color)
-{
-    data[9] = RGBGetRValue(color);
-    data[10] = RGBGetGValue(color);
-    data[11] = RGBGetBValue(color);
-
-    GvWriteI2C(0x00000000, data, 0x00000000);
-}
-
-void RGBController_AorusGPU::SetLED(int led, RGBColor color)
-{
-    data[9] = RGBGetRValue(color);
-    data[10] = RGBGetGValue(color);
-    data[11] = RGBGetBValue(color);
-
-    GvWriteI2C(0x00000000, data, 0x00000000);
-}
-
-RGBController_AorusGPU::RGBController_AorusGPU()
-{
-    name = "Aorus GPU";
-
-    handle = LoadLibrary("GvDisplay.dll");
-
-    GvWriteI2C = (_GvWriteI2C)GetProcAddress(handle, "GvWriteI2C");
-    GvFreeDispLib = (_GvFreeDispLib)GetProcAddress(handle, "GvFreeDispLib");
-    GvInitDispLib = (_GvInitDispLib)GetProcAddress(handle, "GvInitDispLib");
-    
-    GvFreeDispLib();
-    GvInitDispLib();
-
-    mode aorus_mode;
-    aorus_mode.name = "Static";
-    modes.push_back(aorus_mode);
-
-    led aorus_led;
-    aorus_led.name = "GPU LED";
-    leds.push_back(aorus_led);
-
-    zone aorus_zone;
-    aorus_zone.name = "GPU LED";
-    std::vector<int> aorus_zone_map;
-    aorus_zone_map.push_back(0);
-    aorus_zone.map.push_back(aorus_zone_map);
-    zones.push_back(aorus_zone);
-}

RGBController/RGBController_AorusGPU.h

@@ -1,33 +0,0 @@
-/*-----------------------------------------*\
-|  RGBController_AorusGPU.h                 |
-|                                           |
-|  Generic RGB Interface for OpenAuraSDK    |
-|  Aorus GPU                                |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 6/17/2019   |
-\*-----------------------------------------*/
-
-#pragma once
-#include "RGBController.h"
-
-typedef unsigned int uint32;
-typedef uint32(*_GvWriteI2C)(uint32, void*, uint32);
-typedef void (*_GvFreeDispLib)();
-typedef void (*_GvInitDispLib)();
-
-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);
-
-private:
-    _GvWriteI2C GvWriteI2C;
-    _GvFreeDispLib GvFreeDispLib;
-    _GvInitDispLib GvInitDispLib;
-};

RGBController/RGBController_Aura.cpp

@@ -9,93 +9,56 @@
 
 #include "RGBController_Aura.h"
 
-int RGBController_Aura::GetMode()
+int RGBController_Aura::GetDeviceMode()
 {
+    int  dev_mode  = aura->AuraRegisterRead(AURA_REG_MODE);
+    int color_mode = MODE_COLORS_PER_LED;
+
     if (aura->AuraRegisterRead(AURA_REG_DIRECT))
     {
-        return(0);
+        dev_mode = 0xFFFF;
     }
-    else
+
+    switch(dev_mode)
     {
-        return(aura->AuraRegisterRead(AURA_REG_MODE) + 1);
+    case AURA_MODE_OFF:
+    case AURA_MODE_RAINBOW:
+    case AURA_MODE_SPECTRUM_CYCLE:
+    case AURA_MODE_RANDOM_FLICKER:
+        color_mode = MODE_COLORS_NONE;
+        break;
+
+    case AURA_MODE_SPECTRUM_CYCLE_CHASE:
+        dev_mode   = AURA_MODE_CHASE;
+        color_mode = MODE_COLORS_RANDOM;
+        break;
+
+    case AURA_MODE_SPECTRUM_CYCLE_BREATHING:
+        dev_mode   = AURA_MODE_BREATHING;
+        color_mode = MODE_COLORS_RANDOM;
+        break;
+
+    case AURA_MODE_SPECTRUM_CYCLE_CHASE_FADE:
+        dev_mode   = AURA_MODE_CHASE_FADE;
+        color_mode = MODE_COLORS_RANDOM;
+        break;
     }
-}
 
-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].color_mode = color_mode;
         }
     }
-}
 
-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 +75,139 @@ 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_PER_LED_COLOR;
+    Direct.color_mode = MODE_COLORS_PER_LED;
+    modes.push_back(Direct);
+
+    mode Off;
+    Off.name       = "Off";
+    Off.value      = AURA_MODE_OFF;
+    Off.flags      = 0;
+    Off.color_mode = MODE_COLORS_NONE;
+    modes.push_back(Off);
+
+    mode Static;
+    Static.name       = "Static";
+    Static.value      = AURA_MODE_STATIC;
+    Static.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    Static.color_mode = MODE_COLORS_PER_LED;
+    modes.push_back(Static);
+    
+    mode Breathing;
+    Breathing.name       = "Breathing";
+    Breathing.value      = AURA_MODE_BREATHING;
+    Breathing.flags      = MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_PER_LED_COLOR;
+    Breathing.color_mode = MODE_COLORS_PER_LED;
+    modes.push_back(Breathing);
+
+    mode Flashing;
+    Flashing.name       = "Flashing";
+    Flashing.value      = AURA_MODE_FLASHING;
+    Flashing.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    Flashing.color_mode = MODE_COLORS_PER_LED;
+    modes.push_back(Flashing);
+
+    mode SpectrumCycle;
+    SpectrumCycle.name       = "Spectrum Cycle";
+    SpectrumCycle.value      = AURA_MODE_SPECTRUM_CYCLE;
+    SpectrumCycle.flags      = 0;
+    SpectrumCycle.color_mode = MODE_COLORS_NONE;
+    modes.push_back(SpectrumCycle);
+
+    mode Rainbow;
+    Rainbow.name       = "Rainbow";
+    Rainbow.value      = AURA_MODE_RAINBOW;
+    Rainbow.flags      = 0;
+    Rainbow.color_mode = MODE_COLORS_NONE;
+    modes.push_back(Rainbow);
+
+    mode ChaseFade;
+    ChaseFade.name       = "Chase Fade";
+    ChaseFade.value      = AURA_MODE_CHASE_FADE;
+    ChaseFade.flags      = MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_PER_LED_COLOR;
+    ChaseFade.color_mode = MODE_COLORS_PER_LED;
+    modes.push_back(ChaseFade);
+
+    mode Chase;
+    Chase.name       = "Chase";
+    Chase.value      = AURA_MODE_CHASE;
+    Chase.flags      = MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_PER_LED_COLOR;
+    Chase.color_mode = MODE_COLORS_PER_LED;
+    modes.push_back(Chase);
+
+    mode RandomFlicker;
+    RandomFlicker.name       = "Random Flicker";
+    RandomFlicker.value      = AURA_MODE_RANDOM_FLICKER;
+    RandomFlicker.flags      = 0;
+    RandomFlicker.color_mode = MODE_COLORS_NONE;
+    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 +216,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 +250,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 +269,43 @@ RGBController_Aura::RGBController_Aura(AuraController * aura_ptr)
             zones.push_back(*new_zone);
         }
     }
-}
+
+    // Initialize active mode
+    active_mode = GetDeviceMode();
+}
+
+void RGBController_Aura::SetCustomMode()
+{
+    active_mode = 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].color_mode == MODE_COLORS_RANDOM)
+        {
+            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,32 @@ 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_PER_LED_COLOR;
+    Static.color_mode = MODE_COLORS_PER_LED;
+    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_PER_LED_COLOR;
+    Fade.color_mode = MODE_COLORS_PER_LED;
+    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_PER_LED_COLOR;
+    Pulse.color_mode = MODE_COLORS_PER_LED;
+    modes.push_back(Pulse);
+
+    for (unsigned int i = 0; i < corsair->GetLEDCount(); i++)
     {
         led* new_led = new led();
 
@@ -96,7 +76,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 +84,14 @@ RGBController_Corsair::RGBController_Corsair(CorsairController* corsair_ptr)
     new_zone.map.push_back(zone_row);
 
     zones.push_back(new_zone);
-}
+}
+
+void RGBController_Corsair::SetCustomMode()
+{
+    active_mode = 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,331 @@
+/*-----------------------------------------*\
+|  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_PER_LED_COLOR;
+    Direct.color_mode = MODE_COLORS_PER_LED;
+    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;
+    RainbowWave.color_mode = MODE_COLORS_NONE;
+    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_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
+    ColorShift.colors_min = 2;
+    ColorShift.colors_max = 2;
+    ColorShift.speed_min  = CORSAIR_CMDR_PRO_SPEED_SLOW;
+    ColorShift.speed_max  = CORSAIR_CMDR_PRO_SPEED_FAST;
+    ColorShift.speed      = CORSAIR_CMDR_PRO_SPEED_MEDIUM;
+    ColorShift.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    ColorShift.colors.resize(2);
+    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_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
+    ColorPulse.colors_min = 2;
+    ColorPulse.colors_max = 2;
+    ColorPulse.speed_min  = CORSAIR_CMDR_PRO_SPEED_SLOW;
+    ColorPulse.speed_max  = CORSAIR_CMDR_PRO_SPEED_FAST;
+    ColorPulse.speed      = CORSAIR_CMDR_PRO_SPEED_MEDIUM;
+    ColorPulse.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    ColorPulse.colors.resize(2);
+    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_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
+    ColorWave.colors_min = 2;
+    ColorWave.colors_max = 2;
+    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;
+    ColorWave.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    ColorWave.colors.resize(2);
+    modes.push_back(ColorWave);
+
+    mode Static;
+    Static.name       = "Static";
+    Static.value      = CORSAIR_CMDR_PRO_MODE_STATIC;
+    Static.flags      = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    Static.colors_min = 1;
+    Static.colors_max = 1;
+    Static.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Static.colors.resize(1);
+    modes.push_back(Static);
+
+    mode Temperature;
+    Temperature.name       = "Temperature";
+    Temperature.value      = CORSAIR_CMDR_PRO_MODE_TEMPERATURE;
+    Temperature.flags      = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    Temperature.colors_min = 3;
+    Temperature.colors_max = 3;
+    Temperature.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Temperature.colors.resize(3);
+    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_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
+    Visor.colors_min = 2;
+    Visor.colors_max = 2;
+    Visor.speed_min  = CORSAIR_CMDR_PRO_SPEED_SLOW;
+    Visor.speed_max  = CORSAIR_CMDR_PRO_SPEED_FAST;
+    Visor.speed      = CORSAIR_CMDR_PRO_SPEED_MEDIUM;
+    Visor.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Visor.colors.resize(2);
+    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_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
+    Marquee.colors_min = 1;
+    Marquee.colors_max = 1;
+    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;
+    Marquee.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Marquee.colors.resize(1);
+    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_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
+    Blink.colors_min = 2;
+    Blink.colors_max = 2;
+    Blink.speed_min  = CORSAIR_CMDR_PRO_SPEED_SLOW;
+    Blink.speed_max  = CORSAIR_CMDR_PRO_SPEED_FAST;
+    Blink.speed      = CORSAIR_CMDR_PRO_SPEED_MEDIUM;
+    Blink.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Blink.colors.resize(2);
+    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_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
+    Sequential.colors_min = 1;
+    Sequential.colors_max = 1;
+    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;
+    Sequential.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Sequential.colors.resize(1);
+    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;
+    Rainbow.color_mode = MODE_COLORS_NONE;
+    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()
+{
+    active_mode = 0;
+}
+
+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;
+            bool random = (modes[active_mode].color_mode == MODE_COLORS_RANDOM);
+
+            if(modes[active_mode].direction == MODE_DIRECTION_RIGHT)
+            {
+                direction = 1;
+            }
+
+            unsigned char mode_colors[9];
+
+            if(modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC)
+            {
+                for(int i = 0; i < modes[active_mode].colors.size(); i++)
+                {
+                    mode_colors[(3 * i) + 0] = RGBGetRValue(modes[active_mode].colors[i]);
+                    mode_colors[(3 * i) + 1] = RGBGetGValue(modes[active_mode].colors[i]);
+                    mode_colors[(3 * i) + 2] = RGBGetBValue(modes[active_mode].colors[i]);
+                }
+            }
+
+            corsair->SetChannelEffect(channel,
+                                      modes[active_mode].value,
+                                      modes[active_mode].speed,
+                                      direction,
+                                      random,
+                                      mode_colors[0],
+                                      mode_colors[1],
+                                      mode_colors[2],
+                                      mode_colors[3],
+                                      mode_colors[4],
+                                      mode_colors[5],
+                                      mode_colors[6],
+                                      mode_colors[7],
+                                      mode_colors[8]);
+        }
+    }
+}

RGBController/RGBController_CorsairCmdrPro.h

@@ -0,0 +1,29 @@
+/*-----------------------------------------*\
+|  RGBController_CorsairCmdrPro.h           |
+|                                           |
+|  Generic RGB Interface for Corsair        |
+|  Commander Pro                            |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 1/16/2020   |
+\*-----------------------------------------*/
+
+#pragma once
+#include "RGBController.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_CorsairKeyboard.cpp

@@ -0,0 +1,209 @@
+/*-----------------------------------------*\
+|  RGBController_CorsairKeyboard.cpp        |
+|                                           |
+|  Generic RGB Interface for Corsair RGB    |
+|  keyboards                                |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 1/9/2020    |
+\*-----------------------------------------*/
+
+#include "RGBController_CorsairKeyboard.h"
+
+static const char* zone_names[] =
+{
+    "Keyboard",
+    "Media Keys"
+};
+
+static const unsigned int zone_sizes[] =
+{
+    104,
+    7
+};
+
+static const char* led_names[] =
+{
+    "Key: Escape",          //0
+    "Key: `",               //1
+    "Key: Tab",             //2
+    "Key: Caps Lock",       //3
+    "Key: Left Shift",      //4
+    "Key: Left Control",    //5
+    "Key: F12",             //6
+    "Key: =",               //7
+    "Key: Lock",            //8
+    "Key: Number Pad 7",    //9
+    "Key: F1",              //12
+    "Key: 1",               //13
+    "Key: Q",               //14
+    "Key: A",               //15
+    "Key: Left Windows",    //17
+    "Key: Print Screen",    //18
+    "Media Mute",           //20
+    "Key: Number Pad 8",    //21
+    "Key: F2",              //24
+    "Key: 2",               //25
+    "Key: W",               //26
+    "Key: S",               //27
+    "Key: Z",               //28
+    "Key: Left Alt",        //29
+    "Key: Scroll Lock",     //30
+    "Key: Backspace",       //31
+    "Media Stop",           //32
+    "Key: Number Pad 9",    //33
+    "Key: F3",              //36
+    "Key: 3",               //37
+    "Key: E",               //38
+    "Key: D",               //39
+    "Key: X",               //40
+    "Key: Pause/Break",     //42
+    "Key: Delete",          //43
+    "Media Previous",       //44
+    "Key: F4",              //48
+    "Key: 4",               //49
+    "Key: R",               //50
+    "Key: F",               //51
+    "Key: C",               //52
+    "Key: Space",           //53
+    "Key: Insert",          //54
+    "Key: End",             //55
+    "Media Play/Pause",     //56
+    "Key: Number Pad 4",    //57
+    "Key: F5",              //60
+    "Key: 5",               //61
+    "Key: T",               //62
+    "Key: G",               //63
+    "Key: V",               //64
+    "Key: Home",            //66
+    "Key: Page Down",       //67
+    "Media Next",           //68
+    "Key: Number Pad 5",    //69
+    "Key: F6",              //72
+    "Key: 6",               //73
+    "Key: Y",               //74
+    "Key: H",               //75
+    "Key: B",               //76
+    "Key: Page Up",         //78
+    "Key: Right Shift",     //79
+    "Key: Num Lock",        //80
+    "Key: Number Pad 6",    //81
+    "Key: F7",              //84
+    "Key: 7",               //85
+    "Key: U",               //86
+    "Key: J",               //87
+    "Key: N",               //88
+    "Key: Right Alt",       //89
+    "Key: ]",               //90
+    "Key: Right Control",   //91
+    "Key: Number Pad /",    //92
+    "Key: Number Pad 1",    //93
+    "Key: F8",              //96
+    "Key: 8",               //97
+    "Key: I",               //98
+    "Key: K",               //99
+    "Key: M",               //100
+    "Key: Right Windows",   //101
+    "Key: \\",              //102
+    "Key: Up Arrow",        //103
+    "Key: Number Pad *",    //104
+    "Key: Number Pad 2",    //105
+    "Key: F9",              //108
+    "Key: 9",               //109
+    "Key: O",               //110
+    "Key: L",               //111
+    "Key: ,",               //112
+    "Key: Context",         //113
+    "Key: Left Arrow",      //115
+    "Key: Number Pad -",    //116
+    "Key: Number Pad 3",    //117
+    "Key: F10",             //120
+    "Key: 0",               //121
+    "Key: P",               //122
+    "Key: ;",               //123
+    "Key: .",               //124
+    "Key: Enter",           //126
+    "Key: Down Arrow",      //127
+    "Key: Number Pad +",    //128
+    "Key: Number Pad 0",    //129
+    "Key: F11",             //132
+    "Key: -",               //133
+    "Key: [",               //134
+    "Key: '",               //135
+    "Key: /",               //136
+    "Key: Brightness",      //137
+    "Key: Right Arrow",     //139
+    "Key: Number Pad Enter",//140
+    "Key: Number Pad .",    //141
+    "Key: F12"
+};
+
+RGBController_CorsairKeyboard::RGBController_CorsairKeyboard(CorsairKeyboardController* corsair_ptr)
+{
+    corsair = corsair_ptr;
+
+    name = "Corsair RGB Keyboard";
+    type = DEVICE_TYPE_KEYBOARD;
+
+    mode Direct;
+    Direct.name       = "Direct";
+    Direct.value      = 0;
+    Direct.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    Direct.color_mode = MODE_COLORS_PER_LED;
+    modes.push_back(Direct);
+
+    colors.resize(111);
+
+    unsigned int led_idx = 0;
+    for(unsigned int zone_idx = 0; zone_idx < 2; zone_idx++)
+    {
+        zone new_zone;
+        new_zone.name.append(zone_names[zone_idx]);
+
+        std::vector<int> new_zone_map;
+
+        for(unsigned int led_count = 0; led_count < zone_sizes[zone_idx]; led_count++)
+        {
+            led new_led;
+            new_led.name.append(led_names[led_idx]);
+            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);
+    }
+}
+
+RGBController_CorsairKeyboard::~RGBController_CorsairKeyboard()
+{
+
+}
+
+void RGBController_CorsairKeyboard::UpdateLEDs()
+{
+    corsair->SetLEDs(colors);
+}
+
+void RGBController_CorsairKeyboard::UpdateZoneLEDs(int zone)
+{
+    corsair->SetLEDs(colors);
+}
+
+void RGBController_CorsairKeyboard::UpdateSingleLED(int led)
+{
+    corsair->SetLEDs(colors);
+}
+
+void RGBController_CorsairKeyboard::SetCustomMode()
+{
+    active_mode = 0;
+}
+
+void RGBController_CorsairKeyboard::UpdateMode()
+{
+
+}

RGBController/RGBController_CorsairKeyboard.h

@@ -0,0 +1,29 @@
+/*-----------------------------------------*\
+|  RGBController_CorsairKeyboard.h          |
+|                                           |
+|  Generic RGB Interface for Corsair RGB    |
+|  keyboards                                |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 1/9/2020    |
+\*-----------------------------------------*/
+
+#pragma once
+#include "RGBController.h"
+#include "CorsairKeyboardController.h"
+
+class RGBController_CorsairKeyboard : public RGBController
+{
+public:
+    RGBController_CorsairKeyboard(CorsairKeyboardController* corsair_ptr);
+    ~RGBController_CorsairKeyboard();
+
+    void        UpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        SetCustomMode();
+    void        UpdateMode();
+
+private:
+    CorsairKeyboardController*   corsair;
+};

RGBController/RGBController_CorsairNodePro.cpp

@@ -0,0 +1,331 @@
+/*-----------------------------------------*\
+|  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_PER_LED_COLOR;
+    Direct.color_mode = MODE_COLORS_PER_LED;
+    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;
+    RainbowWave.color_mode = MODE_COLORS_NONE;
+    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_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
+    ColorShift.colors_min = 2;
+    ColorShift.colors_max = 2;
+    ColorShift.speed_min  = CORSAIR_CMDR_PRO_SPEED_SLOW;
+    ColorShift.speed_max  = CORSAIR_CMDR_PRO_SPEED_FAST;
+    ColorShift.speed      = CORSAIR_CMDR_PRO_SPEED_MEDIUM;
+    ColorShift.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    ColorShift.colors.resize(2);
+    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_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
+    ColorPulse.colors_min = 2;
+    ColorPulse.colors_max = 2;
+    ColorPulse.speed_min  = CORSAIR_CMDR_PRO_SPEED_SLOW;
+    ColorPulse.speed_max  = CORSAIR_CMDR_PRO_SPEED_FAST;
+    ColorPulse.speed      = CORSAIR_CMDR_PRO_SPEED_MEDIUM;
+    ColorPulse.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    ColorPulse.colors.resize(2);
+    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_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
+    ColorWave.colors_min = 2;
+    ColorWave.colors_max = 2;
+    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;
+    ColorWave.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    ColorWave.colors.resize(2);
+    modes.push_back(ColorWave);
+
+    mode Static;
+    Static.name       = "Static";
+    Static.value      = CORSAIR_CMDR_PRO_MODE_STATIC;
+    Static.flags      = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    Static.colors_min = 1;
+    Static.colors_max = 1;
+    Static.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Static.colors.resize(1);
+    modes.push_back(Static);
+
+    mode Temperature;
+    Temperature.name       = "Temperature";
+    Temperature.value      = CORSAIR_CMDR_PRO_MODE_TEMPERATURE;
+    Temperature.flags      = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    Temperature.colors_min = 3;
+    Temperature.colors_max = 3;
+    Temperature.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Temperature.colors.resize(3);
+    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_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
+    Visor.colors_min = 2;
+    Visor.colors_max = 2;
+    Visor.speed_min  = CORSAIR_CMDR_PRO_SPEED_SLOW;
+    Visor.speed_max  = CORSAIR_CMDR_PRO_SPEED_FAST;
+    Visor.speed      = CORSAIR_CMDR_PRO_SPEED_MEDIUM;
+    Visor.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Visor.colors.resize(2);
+    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_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
+    Marquee.colors_min = 1;
+    Marquee.colors_max = 1;
+    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;
+    Marquee.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Marquee.colors.resize(1);
+    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_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
+    Blink.colors_min = 2;
+    Blink.colors_max = 2;
+    Blink.speed_min  = CORSAIR_CMDR_PRO_SPEED_SLOW;
+    Blink.speed_max  = CORSAIR_CMDR_PRO_SPEED_FAST;
+    Blink.speed      = CORSAIR_CMDR_PRO_SPEED_MEDIUM;
+    Blink.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Blink.colors.resize(2);
+    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_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
+    Sequential.colors_min = 1;
+    Sequential.colors_max = 1;
+    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;
+    Sequential.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Sequential.colors.resize(1);
+    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;
+    Rainbow.color_mode = MODE_COLORS_NONE;
+    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()
+{
+    active_mode = 0;
+}
+
+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;
+            bool random = (modes[active_mode].color_mode == MODE_COLORS_RANDOM);
+
+            if(modes[active_mode].direction == MODE_DIRECTION_RIGHT)
+            {
+                direction = 1;
+            }
+
+            unsigned char mode_colors[9];
+
+            if(modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC)
+            {
+                for(int i = 0; i < modes[active_mode].colors.size(); i++)
+                {
+                    mode_colors[(3 * i) + 0] = RGBGetRValue(modes[active_mode].colors[i]);
+                    mode_colors[(3 * i) + 1] = RGBGetGValue(modes[active_mode].colors[i]);
+                    mode_colors[(3 * i) + 2] = RGBGetBValue(modes[active_mode].colors[i]);
+                }
+            }
+
+            corsair->SetChannelEffect(channel,
+                                      modes[active_mode].value,
+                                      modes[active_mode].speed,
+                                      direction,
+                                      random,
+                                      mode_colors[0],
+                                      mode_colors[1],
+                                      mode_colors[2],
+                                      mode_colors[3],
+                                      mode_colors[4],
+                                      mode_colors[5],
+                                      mode_colors[6],
+                                      mode_colors[7],
+                                      mode_colors[8]);
+        }
+    }
+}

RGBController/RGBController_CorsairNodePro.h

@@ -0,0 +1,29 @@
+/*-----------------------------------------*\
+|  RGBController_CorsairNodePro.h           |
+|                                           |
+|  Generic RGB Interface for Corsair        |
+|  Lighting Node Pro                        |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 1/12/2020   |
+\*-----------------------------------------*/
+
+#pragma once
+#include "RGBController.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,182 @@
 
 #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_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
+    ColorShift.speed_min  = CORSAIR_PRO_SPEED_SLOW;
+    ColorShift.speed_max  = CORSAIR_PRO_SPEED_FAST;
+    ColorShift.colors_min = 2;
+    ColorShift.colors_max = 2;
+    ColorShift.speed      = CORSAIR_PRO_SPEED_SLOW;
+    ColorShift.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    ColorShift.colors.resize(2);
+    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_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
+    ColorPulse.speed_min  = CORSAIR_PRO_SPEED_SLOW;
+    ColorPulse.speed_max  = CORSAIR_PRO_SPEED_FAST;
+    ColorPulse.colors_min = 2;
+    ColorPulse.colors_max = 2;
+    ColorPulse.speed      = CORSAIR_PRO_SPEED_SLOW;
+    ColorPulse.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    ColorPulse.colors.resize(2);
+    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.speed      = CORSAIR_PRO_SPEED_SLOW;
+    RainbowWave.direction  = MODE_DIRECTION_DOWN;
+    RainbowWave.color_mode = MODE_COLORS_NONE;
+    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_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
+    ColorWave.speed_min  = CORSAIR_PRO_SPEED_SLOW;
+    ColorWave.speed_max  = CORSAIR_PRO_SPEED_FAST;
+    ColorWave.colors_min = 2;
+    ColorWave.colors_max = 2;
+    ColorWave.speed      = CORSAIR_PRO_SPEED_SLOW;
+    ColorWave.direction  = MODE_DIRECTION_DOWN;
+    ColorWave.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    ColorWave.colors.resize(2);
+    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_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
+    Visor.speed_min  = CORSAIR_PRO_SPEED_SLOW;
+    Visor.speed_max  = CORSAIR_PRO_SPEED_FAST;
+    Visor.colors_min = 2;
+    Visor.colors_max = 2;
+    Visor.speed      = CORSAIR_PRO_SPEED_SLOW;
+    Visor.direction  = MODE_DIRECTION_VERTICAL;
+    Visor.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Visor.colors.resize(2);
+    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_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
+    Rain.speed_min  = CORSAIR_PRO_SPEED_SLOW;
+    Rain.speed_max  = CORSAIR_PRO_SPEED_FAST;
+    Rain.colors_min = 2;
+    Rain.colors_max = 2;
+    Rain.speed      = CORSAIR_PRO_SPEED_SLOW;
+    Rain.direction  = MODE_DIRECTION_DOWN;
+    Rain.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Rain.colors.resize(2);
+    modes.push_back(Rain);
+
+    mode Marquee;
+    Marquee.name       = "Marquee";
+    Marquee.value      = CORSAIR_PRO_MODE_MARQUEE;
+    Marquee.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    Marquee.speed_min  = CORSAIR_PRO_SPEED_SLOW;
+    Marquee.speed_max  = CORSAIR_PRO_SPEED_FAST;
+    Marquee.colors_min = 1;
+    Marquee.colors_max = 1;
+    Marquee.speed      = CORSAIR_PRO_SPEED_SLOW;
+    Marquee.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Marquee.colors.resize(1);
+    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.speed      = CORSAIR_PRO_SPEED_SLOW;
+    Rainbow.color_mode = MODE_COLORS_NONE;
+    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_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
+    Sequential.speed_min  = CORSAIR_PRO_SPEED_SLOW;
+    Sequential.speed_max  = CORSAIR_PRO_SPEED_FAST;
+    Sequential.colors_min = 1;
+    Sequential.colors_max = 1;
+    Sequential.speed      = CORSAIR_PRO_SPEED_SLOW;
+    Sequential.direction  = MODE_DIRECTION_DOWN;
+    Sequential.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Sequential.colors.resize(1);
+    modes.push_back(Sequential);
+
+    mode Static;
+    Static.name       = "Static";
+    Static.value      = CORSAIR_PRO_MODE_STATIC;
+    Static.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    Static.speed_min  = 0;
+    Static.speed_max  = 0;
+    Static.speed      = 0;
+    Static.color_mode = MODE_COLORS_PER_LED;
+    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 +194,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 +202,63 @@ RGBController_CorsairPro::RGBController_CorsairPro(CorsairProController* corsair
     new_zone.map.push_back(zone_row);
 
     zones.push_back(new_zone);
-}
+}
+
+void RGBController_CorsairPro::SetCustomMode()
+{
+    active_mode = 9;
+}
+
+void RGBController_CorsairPro::UpdateMode()
+{
+    unsigned int corsair_direction;
+    bool random = (modes[active_mode].color_mode == MODE_COLORS_RANDOM);
+    unsigned char mode_colors[6];
+
+    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;
+    }
+
+    if(modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC)
+    {
+        mode_colors[0] = RGBGetRValue(modes[active_mode].colors[0]);
+        mode_colors[1] = RGBGetGValue(modes[active_mode].colors[0]);
+        mode_colors[2] = RGBGetBValue(modes[active_mode].colors[0]);
+
+        if(modes[active_mode].colors.size() == 2)
+        {
+            mode_colors[3] = RGBGetRValue(modes[active_mode].colors[1]);
+            mode_colors[4] = RGBGetGValue(modes[active_mode].colors[1]);
+            mode_colors[5] = RGBGetBValue(modes[active_mode].colors[1]);
+        }
+    }
+
+    corsair->SetEffect(modes[active_mode].value,
+                       modes[active_mode].speed,
+                       corsair_direction,
+                       random,
+                       mode_colors[0],
+                       mode_colors[1],
+                       mode_colors[2],
+                       mode_colors[3],
+                       mode_colors[4],
+                       mode_colors[5]);
+}

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_Crucial.cpp

@@ -0,0 +1,160 @@
+/*-----------------------------------------*\
+|  RGBController_Crucial.cpp                |
+|                                           |
+|  Generic RGB Interface for Crucial        |
+|  Ballistix RGB controller                 |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 1/19/2020   |
+\*-----------------------------------------*/
+
+#include "RGBController_Crucial.h"
+
+void RGBController_Crucial::UpdateLEDs()
+{
+    if(modes[active_mode].value == 0xFFFF)
+    {
+        crucial->SetAllColorsDirect(&colors[0]);
+    }
+    else
+    {
+
+    }
+}
+
+void RGBController_Crucial::UpdateZoneLEDs(int zone)
+{
+    UpdateLEDs();
+}
+
+void RGBController_Crucial::UpdateSingleLED(int led)
+{
+    UpdateLEDs();
+}
+
+RGBController_Crucial::RGBController_Crucial(CrucialController * crucial_ptr)
+{
+    crucial = crucial_ptr;
+
+    location = crucial->GetDeviceLocation();
+    type = DEVICE_TYPE_DRAM;
+    name = "Crucial DRAM";
+
+    mode Direct;
+    Direct.name       = "Direct";
+    Direct.value      = 0xFFFF;
+    Direct.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    Direct.color_mode = MODE_COLORS_PER_LED;
+    modes.push_back(Direct);
+
+#if 0
+    mode Shift;
+    Shift.name       = "Shift";
+    Shift.value      = CRUCIAL_MODE_SHIFT;
+    Shift.flags      = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    Shift.colors_min = 1;
+    Shift.colors_max = 1;
+    Shift.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Shift.colors.resize(1);
+    modes.push_back(Shift);
+    
+    mode GradientShift;
+    GradientShift.name       = "Gradient Shift";
+    GradientShift.value      = CRUCIAL_MODE_GRADIENT_SHIFT;
+    GradientShift.flags      = 0;
+    GradientShift.color_mode = MODE_COLORS_NONE;
+    modes.push_back(GradientShift);
+
+    mode Fill;
+    Fill.name       = "Fill";
+    Fill.value      = CRUCIAL_MODE_FILL;
+    Fill.flags      = 0;
+    Fill.color_mode = MODE_COLORS_NONE;
+    modes.push_back(Fill);
+
+    mode Stack;
+    Stack.name       = "Stack";
+    Stack.value      = CRUCIAL_MODE_STACK;
+    Stack.flags      = 0;
+    Stack.color_mode = MODE_COLORS_NONE;
+    modes.push_back(Stack);
+
+    mode DoubleStack;
+    DoubleStack.name = "Double Stack";
+    DoubleStack.value = CRUCIAL_MODE_DOUBLE_STACK;
+    DoubleStack.flags = 0;
+    modes.push_back(DoubleStack);
+
+    mode Breathing;
+    Breathing.name = "Breathing";
+    Breathing.value = CRUCIAL_MODE_BREATHING;
+    Breathing.flags = 0;
+    modes.push_back(Breathing);
+
+    mode MotionPoint;
+    MotionPoint.name = "Motion Point";
+    MotionPoint.value = CRUCIAL_MODE_MOTION_POINT;
+    MotionPoint.flags = 0;
+    modes.push_back(MotionPoint);
+
+    mode InsideOut;
+    InsideOut.name = "Inside Out";
+    InsideOut.value = CRUCIAL_MODE_INSIDE_OUT;
+    InsideOut.flags = 0;
+    modes.push_back(InsideOut);
+
+    mode ColorStep;
+    ColorStep.name = "Color Step";
+    ColorStep.value = CRUCIAL_MODE_COLOR_STEP;
+    ColorStep.flags = 0;
+    modes.push_back(ColorStep);
+
+    mode WaterWave;
+    WaterWave.name = "Water Wave (Color Blending)";
+    WaterWave.value = CRUCIAL_MODE_WATER_WAVE;
+    WaterWave.flags = 0;
+    modes.push_back(WaterWave);
+
+    mode Flashing;
+    Flashing.name = "Flashing";
+    Flashing.value = CRUCIAL_MODE_FLASHING;
+    Flashing.flags = 0;
+    modes.push_back(Flashing);
+
+    mode Static;
+    Static.name = "Static";
+    Static.value = CRUCIAL_MODE_STATIC;
+    Static.flags = 0;
+    modes.push_back(Static);
+#endif
+
+    zone new_zone;
+    new_zone.name = "DRAM";
+    new_zone.type = ZONE_TYPE_LINEAR;
+    
+    std::vector<int> new_zone_map;
+
+    for(int led_idx = 0; led_idx < 8; led_idx++)
+    {
+        colors.push_back(0x00000000);
+
+        led new_led;
+        new_led.name = "DRAM LED";
+
+        leds.push_back(new_led);
+        new_zone_map.push_back(led_idx);
+    }
+
+    new_zone.map.push_back(new_zone_map);
+
+    zones.push_back(new_zone);
+}
+
+void RGBController_Crucial::SetCustomMode()
+{
+    active_mode = 0;
+}
+
+void RGBController_Crucial::UpdateMode()
+{
+    crucial->SetMode(modes[active_mode].value);
+}

RGBController/RGBController_Crucial.h

@@ -0,0 +1,28 @@
+/*-----------------------------------------*\
+|  RGBController_Crucial.h                  |
+|                                           |
+|  Generic RGB Interface for Crucial        |
+|  Ballistix RGB controller                 |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 1/19/2020   |
+\*-----------------------------------------*/
+
+#pragma once
+
+#include "RGBController.h"
+#include "CrucialController.h"
+
+class RGBController_Crucial : public RGBController
+{
+public:
+    RGBController_Crucial(CrucialController* crucial_ptr);
+    void        UpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        SetCustomMode();
+    void        UpdateMode();
+
+private:
+    CrucialController*  crucial;
+};

RGBController/RGBController_E131.cpp

@@ -18,22 +18,33 @@ RGBController_E131::RGBController_E131(std::vector<E131Device> device_list)
     devices = device_list;
 
     unsigned int led_zone_idx = 0;
-    mode led_mode;
-    led_mode.name = "Custom";
-    modes.push_back(led_mode);
+
+    mode Direct;
+    Direct.name       = "Direct";
+    Direct.value      = 0;
+    Direct.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    Direct.color_mode = MODE_COLORS_PER_LED;
+    modes.push_back(Direct);
 
     sockfd = e131_socket();
 
-    for (int i = 0; i < devices.size(); i++)
+    colors.resize(0);
+    
+    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++)
+        colors.resize(colors.size() + devices[i].num_leds);
+
+    	for (unsigned int led_idx = 0; led_idx < devices[i].num_leds; led_idx++)
     	{
-       		colors.push_back(0x00000000);
+            char id_buf[16];
+            snprintf(id_buf, 16, "%d", led_idx);
+
         	led new_led;
-        	new_led.name = devices[i].name + " LED";
+        	new_led.name = devices[i].name + " LED ";
+            new_led.name.append(id_buf);
         	leds.push_back(new_led);
 		}
 		
@@ -44,7 +55,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 +68,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 +97,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 +109,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 +151,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_PER_LED_COLOR;
+    modes[0].color_mode = MODE_COLORS_PER_LED;
+
+    modes[1].name       = "Breathing";
+    modes[1].value      = FAUSTUS_MODE_BREATHING;
+    modes[1].flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
+    modes[1].speed_min  = FAUSTUS_SPEED_SLOWEST;
+    modes[1].speed_max  = FAUSTUS_SPEED_FASTEST;
+    modes[1].color_mode = MODE_COLORS_PER_LED;
+    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].color_mode = MODE_COLORS_NONE;
+    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].color_mode = MODE_COLORS_NONE;
+    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