OpenRGB version 0.2

Corrected syntax errors
Corrected logical errors
Readability improvements
Build no longer segfaults changing zone

.gitignore

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

.gitmodules

@@ -0,0 +1,3 @@
+[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/AuraControllerDetect.cpp

@@ -1,125 +0,0 @@
-#include "AuraController.h"
-#include "RGBController.h"
-#include "RGBController_Aura.h"
-#include "i2c_smbus.h"
-#include <vector>
-#include <stdio.h>
-#include <stdlib.h>
-
-/******************************************************************************************\
-*                                                                                          *
-*   TestForAuraController                                                                  *
-*                                                                                          *
-*       Tests the given address to see if an Aura 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 TestForAuraController(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);
-
-}   /* TestForAuraController() */
-
-/******************************************************************************************\
-*                                                                                          *
-*   DetectAuraControllers                                                                  *
-*                                                                                          *
-*       Detect Aura controllers on the enumerated I2C busses.  Searches for Aura-enabled   *
-*       RAM at 0x77 and tries to initialize their slot addresses, then searches for them   *
-*       at their correct initialized addresses.  Also looks for motherboard controller at  *
-*       address 0x4E.                                                                      *
-*                                                                                          *
-*           bus - pointer to i2c_smbus_interface where Aura device is connected            *
-*           dev - I2C address of Aura device                                               *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectAuraControllers(std::vector<i2c_smbus_interface*> &busses, std::vector<RGBController*> &rgb_controllers)
-{
-    AuraController* new_aura;
-    RGBController_Aura* new_controller;
-
-    for (unsigned int bus = 0; bus < busses.size(); bus++)
-    {
-        // Remap Aura-enabled RAM modules on 0x77
-        for (unsigned int slot = 0; slot < 8; slot++)
-        {
-            int res = busses[bus]->i2c_smbus_write_quick(0x77, I2C_SMBUS_WRITE);
-
-            if (res < 0)
-            {
-                break;
-            }
-
-            AuraController temp_controller(busses[bus], 0x77);
-
-            temp_controller.AuraRegisterWrite(AURA_REG_SLOT_INDEX, slot);
-            temp_controller.AuraRegisterWrite(AURA_REG_I2C_ADDRESS, 0xE0 + (slot << 1));
-        }
-
-        // Add Aura-enabled controllers at their remapped addresses
-        for (unsigned int slot = 0; slot < 8; slot++)
-        {
-            if (TestForAuraController(busses[bus], 0x70 + slot))
-            {
-                new_aura = new AuraController(busses[bus], 0x70 + slot);
-                new_controller = new RGBController_Aura(new_aura);
-                rgb_controllers.push_back(new_controller);
-            }
-        }
-
-        // Check for Aura controller at 0x40
-        if (TestForAuraController(busses[bus], 0x40))
-        {
-            new_aura = new AuraController(busses[bus], 0x40);
-            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);
-        }
-    }
-
-}   /* DetectAuraControllers() */

Controllers/AuraCoreController/AuraCoreController.cpp

@@ -0,0 +1,125 @@
+/*-----------------------------------------*\
+|  AuraCoreController.cpp                   | 
+|                                           |
+|  Driver for ASUS ROG Aura Core RGB        |
+|  lighting controller                      |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 4/13/2020   |
+\*-----------------------------------------*/
+
+#include "AuraCoreController.h"
+#include <cstring>
+
+AuraCoreController::AuraCoreController(hid_device* dev_handle)
+{
+    dev = dev_handle;
+}
+
+AuraCoreController::~AuraCoreController()
+{
+
+}
+
+void AuraCoreController::SendBrightness
+    (
+    unsigned char   brightness
+    )
+{
+    unsigned char usb_buf[17];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up message packet                                 |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]   = 0x5A;
+    usb_buf[0x01]   = AURA_CORE_COMMAND_BRIGHTNESS;
+    usb_buf[0x02]   = 0xC5;
+    usb_buf[0x03]   = 0xC4;
+    usb_buf[0x04]   = brightness;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_send_feature_report(dev, usb_buf, 17);
+}
+
+void AuraCoreController::SendUpdate
+    (
+    unsigned char   zone,
+    unsigned char   mode,
+    unsigned char   speed,
+    unsigned char   red,
+    unsigned char   green,
+    unsigned char   blue
+    )
+{
+    unsigned char usb_buf[17];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up message packet                                 |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]   = 0x5D;
+    usb_buf[0x01]   = AURA_CORE_COMMAND_UPDATE;
+    usb_buf[0x02]   = zone;
+    usb_buf[0x03]   = mode;
+    usb_buf[0x04]   = red;
+    usb_buf[0x05]   = green;
+    usb_buf[0x06]   = blue;
+    usb_buf[0x07]   = speed;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_send_feature_report(dev, usb_buf, 17);
+}
+
+void AuraCoreController::SendSet()
+{
+    unsigned char usb_buf[17];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up message packet                                 |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]   = 0x5D;
+    usb_buf[0x01]   = AURA_CORE_COMMAND_SET;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_send_feature_report(dev, usb_buf, 17);
+}
+
+void AuraCoreController::SendApply()
+{
+    unsigned char usb_buf[17];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up message packet                                 |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]   = 0x5D;
+    usb_buf[0x01]   = AURA_CORE_COMMAND_APPLY;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_send_feature_report(dev, usb_buf, 17);
+}

Controllers/AuraCoreController/AuraCoreController.h

@@ -0,0 +1,76 @@
+/*-----------------------------------------*\
+|  AuraCoreController.h                     |
+|                                           |
+|  Definitions and types for ASUS ROG Aura  |
+|  Core RGB lighting controller             |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 4/13/2020   |
+\*-----------------------------------------*/
+
+#include "RGBController.h"
+
+#include <string>
+#include <hidapi/hidapi.h>
+
+#pragma once
+
+enum
+{
+    AURA_CORE_MODE_STATIC               = 0,        /* Static color mode                    */
+    AURA_CORE_MODE_BREATHING            = 1,        /* Breathing effect mode                */
+    AURA_CORE_MODE_SPECTRUM_CYCLE       = 2,        /* Spectrum Cycle mode                  */
+};
+
+enum
+{
+    AURA_CORE_COMMAND_UPDATE            = 0xB3,     /* Update mode and color                */
+    AURA_CORE_COMMAND_SET               = 0xB5,     /* Set command                          */
+    AURA_CORE_COMMAND_APPLY             = 0xB4,     /* Apply command                        */
+    AURA_CORE_COMMAND_BRIGHTNESS        = 0xBA,     /* Brightness command                   */
+};
+
+enum
+{
+    AURA_CORE_ZONE_IDX_ALL              = 0x00,     /* Update all zones                     */
+    AURA_CORE_ZONE_IDX_1                = 0x01,     /* Update zone 1                        */
+    AURA_CORE_ZONE_IDX_2                = 0x02,     /* Update zone 2                        */
+    AURA_CORE_ZONE_IDX_3                = 0x03,     /* Update zone 3                        */
+    AURA_CORE_ZONE_IDX_4                = 0x04,     /* Update zone 4                        */
+};
+
+enum
+{
+    AURA_CORE_SPEED_SLOW                = 0xE1,     /* Slowest speed                        */
+    AURA_CORE_SPEED_NORMAL              = 0xEB,     /* Normal speed                         */
+    AURA_CORE_SPEED_FAST                = 0xF5,     /* Fastest speed                        */
+};
+
+class AuraCoreController
+{
+public:
+    AuraCoreController(hid_device* dev_handle);
+    ~AuraCoreController();
+
+    void    SendBrightness
+                (
+                unsigned char   brightness
+                );
+
+    void    SendUpdate
+                (
+                unsigned char   zone,
+                unsigned char   mode,
+                unsigned char   speed,
+                unsigned char   red,
+                unsigned char   green,
+                unsigned char   blue
+                );
+
+    void    SendSet();
+
+    void    SendApply();
+
+private:
+    hid_device*             dev;
+
+};

Controllers/AuraCoreController/AuraCoreControllerDetect.cpp

@@ -0,0 +1,45 @@
+#include "AuraCoreController.h"
+#include "RGBController.h"
+#include "RGBController_AuraCore.h"
+#include <vector>
+#include <hidapi/hidapi.h>
+
+#define AURA_CORE_VID 0x0B05
+
+#define NUM_PIDS 3
+static const unsigned short pid_table[] =
+    {
+    0x1854,
+    0x1869,
+    0x1866
+    };
+
+/******************************************************************************************\
+*                                                                                          *
+*   DetectAuraCoreControllers                                                              *
+*                                                                                          *
+*       Tests the USB address to see if an Asus ROG Aura Core controller exists there      *
+*                                                                                          *
+\******************************************************************************************/
+
+void DetectAuraCoreControllers(std::vector<RGBController*>& rgb_controllers)
+{
+    hid_device* dev;
+
+    //Look for Asus ROG Aura Core RGB controller
+    hid_init();
+
+    for(int pid_idx = 0; pid_idx < NUM_PIDS; pid_idx++)
+    {
+        dev = hid_open(AURA_CORE_VID, pid_table[pid_idx], 0);
+
+        if( dev )
+        {
+            AuraCoreController* controller = new AuraCoreController(dev);
+
+            RGBController_AuraCore* rgb_controller = new RGBController_AuraCore(controller);
+
+            rgb_controllers.push_back(rgb_controller);
+        }
+    }
+}

Controllers/AuraGPUController/AuraGPUController.cpp

@@ -0,0 +1,84 @@
+/*-----------------------------------------*\
+|  AuraGPUController.cpp                    |
+|                                           |
+|  Driver for ASUS Aura RGB on GPUs         |
+|                                           |
+|  Jan Rettig (Klapstuhl) 14.02.2020        |
+\*-----------------------------------------*/
+
+#include "AuraGPUController.h"
+#include <cstring>
+
+AuraGPUController::AuraGPUController(i2c_smbus_interface* bus, aura_gpu_dev_id dev)
+{
+    this->bus = bus;
+    this->dev = dev;
+
+    strcpy(device_name, "ASUS Aura GPU");                                               // Would be nice to get the actual GPU name. Using this as a placeholder.
+}
+
+AuraGPUController::~AuraGPUController()
+{
+
+}
+
+std::string AuraGPUController::GetDeviceName()
+{
+    return(device_name);
+}
+
+std::string AuraGPUController::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 AuraGPUController::GetLEDRed()
+{
+    return(AuraGPURegisterRead(AURA_GPU_REG_RED));
+}
+
+unsigned char AuraGPUController::GetLEDGreen()
+{
+    return(AuraGPURegisterRead(AURA_GPU_REG_GREEN));
+}
+
+unsigned char AuraGPUController::GetLEDBlue()
+{
+    return(AuraGPURegisterRead(AURA_GPU_REG_BLUE));
+}
+
+void AuraGPUController::SetLEDColorsDirect(unsigned char red, unsigned char green, unsigned char blue)                  // Direct Mode is just Static Mode without applying color changes
+{
+    AuraGPURegisterWrite(AURA_GPU_REG_RED, red);
+    AuraGPURegisterWrite(AURA_GPU_REG_GREEN, green);
+    AuraGPURegisterWrite(AURA_GPU_REG_BLUE, blue);
+}
+
+void AuraGPUController::SetLEDColorsEffect(unsigned char red, unsigned char green, unsigned char blue)
+{
+    AuraGPURegisterWrite(AURA_GPU_REG_RED, red);
+    AuraGPURegisterWrite(AURA_GPU_REG_GREEN, green);
+    AuraGPURegisterWrite(AURA_GPU_REG_BLUE, blue);
+    AuraGPURegisterWrite(AURA_GPU_REG_APPLY, AURA_GPU_APPLY_VAL);
+}
+
+void AuraGPUController::SetMode(unsigned char mode)
+{
+    AuraGPURegisterWrite(AURA_GPU_REG_MODE, mode);
+    AuraGPURegisterWrite(AURA_GPU_REG_APPLY, AURA_GPU_APPLY_VAL);
+}
+
+unsigned char AuraGPUController::AuraGPURegisterRead(unsigned char reg)
+{
+    return(bus->i2c_smbus_read_byte_data(dev, reg));
+}
+
+void AuraGPUController::AuraGPURegisterWrite(unsigned char reg, unsigned char val)
+{
+    bus->i2c_smbus_write_byte_data(dev, reg, val);
+}

Controllers/AuraGPUController/AuraGPUController.h

@@ -0,0 +1,64 @@
+/*-----------------------------------------*\
+|  AuraGPUController.h                      |
+|                                           |
+|  Definitions for ASUS Aura RGB on GPUs    |
+|                                           |
+|  Jan Rettig (Klapstuhl) 14.02.2020        |
+\*-----------------------------------------*/
+
+#include <string>
+#include "i2c_smbus.h"
+
+#pragma once
+
+typedef unsigned char aura_gpu_dev_id;
+
+#define AURA_GPU_MAGIC_VAL 0x1589                   /* This magic value is present in all Aura GPU controllers */
+#define AURA_GPU_APPLY_VAL 0x01                     /* Value for Apply Changes Register     */
+
+enum
+{
+    AURA_GPU_REG_RED                        = 0x04,    /* AURA GPU RED Register            */
+    AURA_GPU_REG_GREEN                      = 0x05,    /* AURA GPU GREEN Register          */
+    AURA_GPU_REG_BLUE                       = 0x06,    /* AURA GPU BLUE Register           */
+    AURA_GPU_REG_MODE                       = 0x07,    /* AURA GPU Mode Selection Register */
+    AURA_GPU_REG_SYNC                       = 0x0C,    /* AURA GPU "Sync" Register         */
+    AURA_GPU_REG_APPLY                      = 0x0E,    /* AURA GPU Apply Chnages Register  */
+};
+
+enum
+{
+    AURA_GPU_MODE_OFF                       = 0,        /* OFF mode (not a real Mode! Doesn't do anything!)    */
+    AURA_GPU_MODE_STATIC                    = 1,        /* Static color mode                                   */
+    AURA_GPU_MODE_BREATHING                 = 2,        /* Breathing effect mode                               */
+    AURA_GPU_MODE_FLASHING                  = 3,        /* Flashing effect mode                                */
+    AURA_GPU_MODE_SPECTRUM_CYCLE            = 4,        /* Spectrum Cycle mode                                 */
+    AURA_GPU_MODE_DIRECT                    = 5,        /* Direct mode (not a real Mode! Doesn't do anything!) */
+    AURA_GPU_NUMBER_MODES
+};
+
+class AuraGPUController
+{
+public:
+    AuraGPUController(i2c_smbus_interface* bus, aura_gpu_dev_id);
+    ~AuraGPUController();
+
+    std::string   GetDeviceName();
+    std::string   GetDeviceLocation();
+    unsigned char GetLEDRed();
+    unsigned char GetLEDGreen();
+    unsigned char GetLEDBlue();
+    void          SetLEDColorsDirect(unsigned char red, unsigned char green, unsigned char blue);
+    void          SetLEDColorsEffect(unsigned char red, unsigned char green, unsigned char blue);
+    void          SetMode(unsigned char mode);
+
+    unsigned char AuraGPURegisterRead(unsigned char reg);
+    void          AuraGPURegisterWrite(unsigned char reg, unsigned char val);
+
+    bool          direct = false;                                                // Temporary solution to check if we are in "Direct" mode
+
+private:
+    char                    device_name[16];
+    i2c_smbus_interface *   bus;
+    aura_gpu_dev_id         dev;
+};

Controllers/AuraGPUController/AuraGPUControllerDetect.cpp

@@ -0,0 +1,94 @@
+/*-----------------------------------------*\
+|  AuraGPUControllerDetect.cpp              |
+|                                           |
+|  Driver for ASUS Aura RGB on GPUs         |
+|                                           |
+|  Jan Rettig (Klapstuhl) 14.02.2020        |
+\*-----------------------------------------*/
+
+#include "AuraGPUController.h"
+#include "RGBController.h"
+#include "RGBController_AuraGPU.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
+
+/*-------------------------------------------------------------*\
+| This list contains the available I2C addresses for Aura GPUs  |
+\*-------------------------------------------------------------*/
+#define AURA_GPU_ADDRESS_COUNT 3
+
+static const unsigned char aura_gpu_addresses[] =
+{
+    0x29,
+    0x2A,
+    0x60
+};
+
+
+/******************************************************************************************\
+*                                                                                          *
+*   TestForAuraGPUController                                                               *
+*                                                                                          *
+*       Tests the given address to see if an Aura GPU controller exists there.             *
+*                                                                                          *
+\******************************************************************************************/
+
+bool TestForAuraGPUController(i2c_smbus_interface* bus, unsigned char address)
+{
+    bool pass = false;
+
+    unsigned char aura_gpu_magic_high = bus->i2c_smbus_read_byte_data(address, 0x20);                        // High Byte of magic (0x15)                        
+    unsigned char aura_gpu_magic_low = bus->i2c_smbus_read_byte_data(address, 0x21);                         // Low Byte of magic (0x89)
+
+    if((aura_gpu_magic_high << 8) + aura_gpu_magic_low == AURA_GPU_MAGIC_VAL)
+    {
+        pass = true;
+    }
+
+    return(pass);
+
+}   /* TestForAuraGPUController() */
+
+
+/******************************************************************************************\
+*                                                                                          *
+*   DetectAuraGPUControllers                                                               *
+*                                                                                          *
+*       Detect Aura GPU controllers on the enumerated I2C busses.                          *
+*                                                                                          *
+\******************************************************************************************/
+
+void DetectAuraGPUControllers(std::vector<i2c_smbus_interface*> &busses, std::vector<RGBController*> &rgb_controllers)
+{
+    AuraGPUController* new_aura_gpu;
+    RGBController_AuraGPU* new_controller;
+
+    for (unsigned int bus = 0; bus < busses.size(); bus++)
+    {
+        // Add Aura-enabled GPU controllers
+        for (unsigned int address_list_idx = 0; address_list_idx < AURA_GPU_ADDRESS_COUNT; address_list_idx++)
+        {
+            if (TestForAuraGPUController(busses[bus], aura_gpu_addresses[address_list_idx]))
+            {
+                new_aura_gpu = new AuraGPUController(busses[bus], aura_gpu_addresses[address_list_idx]);
+                new_controller = new RGBController_AuraGPU(new_aura_gpu);
+                rgb_controllers.push_back(new_controller);
+            }
+
+            Sleep(1);
+        }
+    }
+} /* DetectAuraGPUControllers() */

Controllers/AuraSMBusController/AuraSMBusController.cpp

@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  AuraController.h                         |
+|  AuraSMBusController.cpp                  |
 |                                           |
 |  Driver for ASUS Aura RGB lighting        |
 |  controller                               |
@@ -7,10 +7,10 @@
 |  Adam Honse (CalcProgrammer1) 8/19/2018   |
 \*-----------------------------------------*/
 
-#include "AuraController.h"
+#include "AuraSMBusController.h"
 #include <cstring>
 
-AuraController::AuraController(i2c_smbus_interface* bus, aura_dev_id dev)
+AuraSMBusController::AuraSMBusController(i2c_smbus_interface* bus, aura_dev_id dev)
 {
     this->bus = bus;
     this->dev = dev;
@@ -77,22 +77,32 @@ AuraController::AuraController(i2c_smbus_interface* bus, aura_dev_id dev)
     }
 }
 
-AuraController::~AuraController()
+AuraSMBusController::~AuraSMBusController()
 {
 
 }
 
-char * AuraController::GetDeviceName()
+std::string AuraSMBusController::GetDeviceName()
 {
     return(device_name);
 }
 
-unsigned char AuraController::GetChannel(unsigned int led)
+std::string AuraSMBusController::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 AuraSMBusController::GetChannel(unsigned int led)
 {
     return(config_table[channel_cfg + led]);
 }
 
-const char * AuraController::GetChannelName(unsigned int led)
+const char * AuraSMBusController::GetChannelName(unsigned int led)
 {
     switch (config_table[channel_cfg + led])
     {
@@ -142,16 +152,31 @@ const char * AuraController::GetChannelName(unsigned int led)
     }
 }
 
-unsigned int AuraController::GetLEDCount()
+unsigned int AuraSMBusController::GetLEDCount()
 {
     return(led_count);
 }
 
-void AuraController::SetAllColorsDirect(unsigned char red, unsigned char green, unsigned char blue)
+unsigned char AuraSMBusController::GetLEDRed(unsigned int led)
+{
+    return(AuraRegisterRead(direct_reg + ( 3 * led )));
+}
+
+unsigned char AuraSMBusController::GetLEDGreen(unsigned int led)
+{
+    return(AuraRegisterRead(direct_reg + ( 3 * led ) + 2));
+}
+
+unsigned char AuraSMBusController::GetLEDBlue(unsigned int led)
+{
+    return(AuraRegisterRead(direct_reg + ( 3 * led ) + 1));
+}
+
+void AuraSMBusController::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;
@@ -163,11 +188,11 @@ void AuraController::SetAllColorsDirect(unsigned char red, unsigned char green,
     delete colors;
 }
 
-void AuraController::SetAllColorsEffect(unsigned char red, unsigned char green, unsigned char blue)
+void AuraSMBusController::SetAllColorsEffect(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;
@@ -178,23 +203,23 @@ 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)
+void AuraSMBusController::SetDirect(unsigned char direct)
 {
     AuraRegisterWrite(AURA_REG_DIRECT, direct);
     AuraRegisterWrite(AURA_REG_APPLY, AURA_APPLY_VAL);
 }
 
-void AuraController::SetLEDColorDirect(unsigned int led, unsigned char red, unsigned char green, unsigned char blue)
+void AuraSMBusController::SetLEDColorDirect(unsigned int led, unsigned char red, unsigned char green, unsigned char blue)
 {
     unsigned char colors[3] = { red, blue, green };
 
     AuraRegisterWriteBlock(direct_reg + ( 3 * led ), colors, 3);
 }
 
-void AuraController::SetLEDColorEffect(unsigned int led, unsigned char red, unsigned char green, unsigned char blue)
+void AuraSMBusController::SetLEDColorEffect(unsigned int led, unsigned char red, unsigned char green, unsigned char blue)
 {
     unsigned char colors[3] = { red, blue, green };
 
@@ -203,13 +228,13 @@ void AuraController::SetLEDColorEffect(unsigned int led, unsigned char red, unsi
     AuraRegisterWrite(AURA_REG_APPLY, AURA_APPLY_VAL);
 }
 
-void AuraController::SetMode(unsigned char mode)
+void AuraSMBusController::SetMode(unsigned char mode)
 {
     AuraRegisterWrite(AURA_REG_MODE, mode);
     AuraRegisterWrite(AURA_REG_APPLY, AURA_APPLY_VAL);
 }
 
-void AuraController::AuraUpdateDeviceName()
+void AuraSMBusController::AuraUpdateDeviceName()
 {
     for (int i = 0; i < 16; i++)
     {
@@ -217,7 +242,7 @@ void AuraController::AuraUpdateDeviceName()
     }
 }
 
-unsigned char AuraController::AuraRegisterRead(aura_register reg)
+unsigned char AuraSMBusController::AuraRegisterRead(aura_register reg)
 {
     //Write Aura register
     bus->i2c_smbus_write_word_data(dev, 0x00, ((reg << 8) & 0xFF00) | ((reg >> 8) & 0x00FF));
@@ -227,7 +252,7 @@ unsigned char AuraController::AuraRegisterRead(aura_register reg)
 
 }
 
-void AuraController::AuraRegisterWrite(aura_register reg, unsigned char val)
+void AuraSMBusController::AuraRegisterWrite(aura_register reg, unsigned char val)
 {
     //Write Aura register
     bus->i2c_smbus_write_word_data(dev, 0x00, ((reg << 8) & 0xFF00) | ((reg >> 8) & 0x00FF));
@@ -237,7 +262,7 @@ void AuraController::AuraRegisterWrite(aura_register reg, unsigned char val)
 
 }
 
-void AuraController::AuraRegisterWriteBlock(aura_register reg, unsigned char * data, unsigned char sz)
+void AuraSMBusController::AuraRegisterWriteBlock(aura_register reg, unsigned char * data, unsigned char sz)
 {
     //Write Aura register
     bus->i2c_smbus_write_word_data(dev, 0x00, ((reg << 8) & 0xFF00) | ((reg >> 8) & 0x00FF));
@@ -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/AuraSMBusController/AuraSMBusController.h

@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  AuraController.h                         |
+|  AuraSMBusController.h                    |
 |                                           |
 |  Definitions and types for ASUS Aura RGB  |
 |  lighting controller                      |
@@ -7,6 +7,7 @@
 |  Adam Honse (CalcProgrammer1) 8/19/2018   |
 \*-----------------------------------------*/
 
+#include <string>
 #include "i2c_smbus.h"
 
 #pragma once
@@ -87,16 +88,20 @@ enum
     AURA_CONFIG_CHANNEL_V2              = 0x1B,     /* LED Channel V2 configuration offset  */
 };
 
-class AuraController
+class AuraSMBusController
 {
 public:
-    AuraController(i2c_smbus_interface* bus, aura_dev_id dev);
-    ~AuraController();
+    AuraSMBusController(i2c_smbus_interface* bus, aura_dev_id dev);
+    ~AuraSMBusController();
 
-    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/AuraSMBusController/AuraSMBusControllerDetect.cpp

@@ -0,0 +1,198 @@
+#include "AuraSMBusController.h"
+#include "RGBController.h"
+#include "RGBController_AuraSMBus.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
+
+/*----------------------------------------------------------------------*\
+| This list contains the available SMBus addresses for mapping Aura RAM  |
+\*----------------------------------------------------------------------*/
+#define AURA_RAM_ADDRESS_COUNT  22
+
+static const unsigned char aura_ram_addresses[] =
+{
+    0x70,
+    0x71,
+    0x72,
+    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 3
+
+static const unsigned char aura_mobo_addresses[] =
+{
+    0x40,
+    0x4E,
+    0x4F
+};
+
+/******************************************************************************************\
+*                                                                                          *
+*   AuraRegisterWrite                                                                      *
+*                                                                                          *
+*       A standalone version of the AuraSMBusController::AuraRegisterWrite function for    *
+*       access to Aura devices without instancing the AuraSMBusController 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);
+}
+
+/******************************************************************************************\
+*                                                                                          *
+*   TestForAuraSMBusController                                                                  *
+*                                                                                          *
+*       Tests the given address to see if an Aura 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 TestForAuraSMBusController(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);
+
+}   /* TestForAuraSMBusController() */
+
+/******************************************************************************************\
+*                                                                                          *
+*   DetectAuraSMBusControllers                                                                  *
+*                                                                                          *
+*       Detect Aura controllers on the enumerated I2C busses.  Searches for Aura-enabled   *
+*       RAM at 0x77 and tries to initialize their slot addresses, then searches for them   *
+*       at their correct initialized addresses.  Also looks for motherboard controller at  *
+*       address 0x4E.                                                                      *
+*                                                                                          *
+*           bus - pointer to i2c_smbus_interface where Aura device is connected            *
+*           dev - I2C address of Aura device                                               *
+*                                                                                          *
+\******************************************************************************************/
+
+void DetectAuraSMBusControllers(std::vector<i2c_smbus_interface*> &busses, std::vector<RGBController*> &rgb_controllers)
+{
+    AuraSMBusController* new_aura;
+    RGBController_AuraSMBus* new_controller;
+
+    for (unsigned int bus = 0; bus < busses.size(); bus++)
+    {
+        int address_list_idx = -1;
+
+        // Remap Aura-enabled RAM modules on 0x77
+        for (unsigned int slot = 0; slot < 8; slot++)
+        {
+            int res = busses[bus]->i2c_smbus_write_quick(0x77, I2C_SMBUS_WRITE);
+
+            if (res < 0)
+            {
+                break;
+            }
+
+            do
+            {
+                address_list_idx++;
+
+                if(address_list_idx < AURA_RAM_ADDRESS_COUNT)
+                {
+                    res = busses[bus]->i2c_smbus_write_quick(aura_ram_addresses[address_list_idx], I2C_SMBUS_WRITE);
+                }
+                else
+                {
+                    break;
+                }
+            } while (res >= 0);
+
+            if(address_list_idx < AURA_RAM_ADDRESS_COUNT)
+            {
+                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 address_list_idx = 0; address_list_idx < AURA_RAM_ADDRESS_COUNT; address_list_idx++)
+        {
+            if (TestForAuraSMBusController(busses[bus], aura_ram_addresses[address_list_idx]))
+            {
+                new_aura = new AuraSMBusController(busses[bus], aura_ram_addresses[address_list_idx]);
+                new_controller = new RGBController_AuraSMBus(new_aura);
+                rgb_controllers.push_back(new_controller);
+            }
+
+            Sleep(1);
+        }
+
+        // Add Aura-enabled motherboard controllers
+        for (unsigned int address_list_idx = 0; address_list_idx < AURA_MOBO_ADDRESS_COUNT; address_list_idx++)
+        {
+            if (TestForAuraSMBusController(busses[bus], aura_mobo_addresses[address_list_idx]))
+            {
+                new_aura = new AuraSMBusController(busses[bus], aura_mobo_addresses[address_list_idx]);
+                new_controller = new RGBController_AuraSMBus(new_aura);
+                rgb_controllers.push_back(new_controller);
+            }
+
+            Sleep(1);
+        }
+    }
+
+}   /* DetectAuraSMBusControllers() */

Controllers/AuraUSBController/AuraAddressableController.cpp

@@ -0,0 +1,173 @@
+/*-----------------------------------------*\
+|  AuraAddressableController.cpp            |
+|                                           |
+|  Driver for ASUS Aura RGB Addressable     |
+|  lighting controller                      |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 1/18/2020   |
+\*-----------------------------------------*/
+
+#include "AuraAddressableController.h"
+#include <cstring>
+
+AuraAddressableController::AuraAddressableController(hid_device* dev_handle) : AuraUSBController(dev_handle)
+{
+    channel_count = config_table[2];
+}
+
+AuraAddressableController::~AuraAddressableController()
+{
+
+}
+
+void AuraAddressableController::SetChannelLEDs(unsigned char channel, RGBColor * colors, unsigned int num_colors)
+{
+    unsigned char   led_data[60];
+    unsigned int    leds_sent = 0;
+
+    while(leds_sent < num_colors)
+    {
+        unsigned int leds_to_send = 20;
+
+        if((num_colors - leds_sent) < leds_to_send)
+        {
+            leds_to_send = num_colors - leds_sent;
+        }
+
+        for(int led_idx = 0; led_idx < leds_to_send; led_idx++)
+        {
+            led_data[(led_idx * 3) + 0] = RGBGetRValue(colors[led_idx + leds_sent]);
+            led_data[(led_idx * 3) + 1] = RGBGetGValue(colors[led_idx + leds_sent]);
+            led_data[(led_idx * 3) + 2] = RGBGetBValue(colors[led_idx + leds_sent]);
+        }
+
+        SendDirect
+        (
+            channel,
+            leds_sent,
+            leds_to_send,
+            led_data
+        );
+
+        leds_sent += leds_to_send;
+    }
+
+    SendDirectApply(channel);
+}
+
+void AuraAddressableController::SetMode
+    (
+    unsigned char   channel,
+    unsigned char   mode,
+    unsigned char   red,
+    unsigned char   grn,
+    unsigned char   blu
+    )
+{
+    SendEffect
+    (
+        channel,
+        mode,
+        red,
+        grn,
+        blu
+    );
+}
+
+void AuraAddressableController::SendEffect
+    (
+    unsigned char   channel,
+    unsigned char   mode,
+    unsigned char   red,
+    unsigned char   grn,
+    unsigned char   blu
+    )
+{
+    unsigned char usb_buf[65];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up message packet                                 |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]   = 0xEC;
+    usb_buf[0x01]   = AURA_ADDRESSABLE_CONTROL_MODE_EFFECT;
+    usb_buf[0x02]   = channel;
+    usb_buf[0x03]   = 0x00;
+    usb_buf[0x04]   = mode;
+
+    /*-----------------------------------------------------*\
+    | Copy in color data bytes                              |
+    \*-----------------------------------------------------*/
+    usb_buf[0x05]   = red;
+    usb_buf[0x06]   = grn;
+    usb_buf[0x07]   = blu;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_write(dev, usb_buf, 65);
+}
+
+void AuraAddressableController::SendDirect
+    (
+    unsigned char   device,
+    unsigned char   start_led,
+    unsigned char   led_count,
+    unsigned char*  led_data
+    )
+{
+    unsigned char usb_buf[65];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up message packet                                 |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]   = 0xEC;
+    usb_buf[0x01]   = AURA_ADDRESSABLE_CONTROL_MODE_DIRECT;
+    usb_buf[0x02]   = device;
+    usb_buf[0x03]   = start_led;
+    usb_buf[0x04]   = led_count;
+
+    /*-----------------------------------------------------*\
+    | Copy in color data bytes                              |
+    \*-----------------------------------------------------*/
+    memcpy(&usb_buf[0x05], led_data, led_count * 3);
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_write(dev, usb_buf, 65);
+}
+
+void AuraAddressableController::SendDirectApply
+    (
+    unsigned char   channel
+    )
+{
+    unsigned char usb_buf[65];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up message packet                                 |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]   = 0xEC;
+    usb_buf[0x01]   = AURA_ADDRESSABLE_CONTROL_MODE_DIRECT;
+    usb_buf[0x02]   = 0x80 | channel;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_write(dev, usb_buf, 65);
+}

Controllers/AuraUSBController/AuraAddressableController.h

@@ -0,0 +1,69 @@
+/*-----------------------------------------*\
+|  AuraAddressableController.h              |
+|                                           |
+|  Definitions and types for ASUS Aura      |
+|  Addressable RGB lighting controller      |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 1/18/2020   |
+\*-----------------------------------------*/
+
+#include "RGBController.h"
+#include "AuraUSBController.h"
+
+#include <string>
+#include <hidapi/hidapi.h>
+
+#pragma once
+
+enum
+{
+    AURA_ADDRESSABLE_CONTROL_MODE_EFFECT            = 0x3B,     /* Effect control mode                  */
+    AURA_ADDRESSABLE_CONTROL_MODE_DIRECT            = 0x40,     /* Direct control mode                  */
+};
+
+class AuraAddressableController : public AuraUSBController
+{
+public:
+    AuraAddressableController(hid_device* dev_handle);
+    ~AuraAddressableController();
+
+    void SetChannelLEDs
+        (
+        unsigned char   channel,
+        RGBColor *      colors,
+        unsigned int    num_colors
+        );
+
+    void SetMode
+        (
+        unsigned char   channel,
+        unsigned char   mode,
+        unsigned char   red,
+        unsigned char   grn,
+        unsigned char   blu
+        );
+
+private:
+
+    void SendEffect
+        (
+        unsigned char   channel,
+        unsigned char   mode,
+        unsigned char   red,
+        unsigned char   grn,
+        unsigned char   blu
+        );
+
+    void SendDirect
+        (
+        unsigned char   device,
+        unsigned char   start_led,
+        unsigned char   led_count,
+        unsigned char*  led_data
+        );
+
+    void    SendDirectApply
+        (
+        unsigned char   channel
+        );
+};

Controllers/AuraUSBController/AuraMainboardController.cpp

@@ -0,0 +1,176 @@
+/*-----------------------------------------*\
+|  AuraMainboardController.cpp              |
+|                                           |
+|  Driver for ASUS Aura RGB USB mainboard   |
+|  lighting controller                      |
+|                                           |
+|  Martin Hartl (inlart) 4/25/2020          |
+\*-----------------------------------------*/
+
+#include "AuraMainboardController.h"
+#include <cstring>
+
+AuraMainboardController::AuraMainboardController(hid_device* dev_handle) : AuraUSBController(dev_handle), mode(AURA_MODE_DIRECT)
+{
+    channel_count = 5;
+}
+
+AuraMainboardController::~AuraMainboardController()
+{
+}
+
+void AuraMainboardController::SetChannelLEDs(unsigned char channel, RGBColor * colors, unsigned int num_colors)
+{
+    unsigned char   led_data[60];
+    unsigned int    leds_sent = 0;
+
+    SendEffect(channel, mode);
+
+    while(leds_sent < num_colors)
+    {
+        unsigned int leds_to_send = 20;
+
+        if((num_colors - leds_sent) < leds_to_send)
+        {
+            leds_to_send = num_colors - leds_sent;
+        }
+
+        for(int led_idx = 0; led_idx < leds_to_send; led_idx++)
+        {
+            led_data[(led_idx * 3) + 0] = RGBGetRValue(colors[led_idx + leds_sent]);
+            led_data[(led_idx * 3) + 1] = RGBGetGValue(colors[led_idx + leds_sent]);
+            led_data[(led_idx * 3) + 2] = RGBGetBValue(colors[led_idx + leds_sent]);
+        }
+
+        SendDirect
+        (
+            channel,
+            leds_sent,
+            leds_to_send,
+            led_data
+        );
+
+        leds_sent += leds_to_send;
+    }
+
+    SendCommit();
+}
+
+void AuraMainboardController::SetMode
+    (
+    unsigned char   channel,
+    unsigned char   mode,
+    unsigned char   red,
+    unsigned char   grn,
+    unsigned char   blu
+    )
+{
+    this->mode = mode;
+    unsigned char led_data[3];
+    led_data[0] = red;
+    led_data[1] = grn;
+    led_data[2] = blu;
+
+    SendEffect
+    (
+        channel,
+        mode
+    );
+    SendDirect
+    (
+        channel,
+        0,
+        1,
+        led_data
+    );
+    SendCommit();
+}
+
+void AuraMainboardController::SendEffect
+    (
+    unsigned char   channel,
+    unsigned char   mode
+    )
+{
+    unsigned char usb_buf[65];
+
+    if(mode == AURA_MODE_DIRECT) {
+        mode = AURA_MODE_STATIC;
+    }
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up message packet                                 |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]   = 0xEC;
+    usb_buf[0x01]   = AURA_MAINBOARD_CONTROL_MODE_EFFECT;
+    usb_buf[0x02]   = 0x00;
+    usb_buf[0x03]   = 0x00;
+    usb_buf[0x04]   = channel;
+    usb_buf[0x05]   = mode;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_write(dev, usb_buf, 65);
+}
+
+void AuraMainboardController::SendDirect
+    (
+    unsigned char   device,
+    unsigned char   start_led,
+    unsigned char   led_count,
+    unsigned char*  led_data
+    )
+{
+    unsigned char usb_buf[65];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up message packet                                 |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]   = 0xEC;
+    usb_buf[0x01]   = AURA_MAINBOARD_CONTROL_MODE_DIRECT;
+    usb_buf[0x02]   = start_led;
+    usb_buf[0x03]   = 0xff;
+    usb_buf[0x04]   = 0x00;
+
+    /*-----------------------------------------------------*\
+    | Copy in color data bytes                              |
+    \*-----------------------------------------------------*/
+    memcpy(&usb_buf[0x05], led_data, led_count * 3);
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_write(dev, usb_buf, 65);
+}
+
+void AuraMainboardController::SendCommit()
+{
+    unsigned char usb_buf[65];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up message packet                                 |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]   = 0xEC;
+    usb_buf[0x01]   = AURA_MAINBOARD_CONTROL_MODE_COMMIT;
+    usb_buf[0x02]   = 0x55;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_write(dev, usb_buf, 65);
+}

Controllers/AuraUSBController/AuraMainboardController.h

@@ -0,0 +1,65 @@
+/*-----------------------------------------*\
+|  AuraMainboardController.h                |
+|                                           |
+|  Definitions and types for ASUS Aura      |
+|  USB Mainboard RGB lighting controller    |
+|                                           |
+|  Martin Hartl (inlart) 4/25/2020          |
+\*-----------------------------------------*/
+
+#include "RGBController.h"
+#include "AuraUSBController.h"
+
+#include <string>
+#include <hidapi/hidapi.h>
+
+#pragma once
+
+enum
+{
+    AURA_MAINBOARD_CONTROL_MODE_EFFECT            = 0x35,     /* Effect control mode                  */
+    AURA_MAINBOARD_CONTROL_MODE_DIRECT            = 0x36,     /* Direct control mode                  */
+    AURA_MAINBOARD_CONTROL_MODE_COMMIT            = 0x3F,     /* Direct control mode                  */
+};
+
+class AuraMainboardController : public AuraUSBController
+{
+public:
+    AuraMainboardController(hid_device* dev_handle);
+    ~AuraMainboardController();
+
+    void SetChannelLEDs
+        (
+        unsigned char   channel,
+        RGBColor *      colors,
+        unsigned int    num_colors
+        );
+
+    void SetMode
+        (
+        unsigned char   channel,
+        unsigned char   mode,
+        unsigned char   red,
+        unsigned char   grn,
+        unsigned char   blu
+        );
+
+private:
+    unsigned int mode;
+
+    void SendEffect
+        (
+        unsigned char   channel,
+        unsigned char   mode
+        );
+
+    void SendDirect
+        (
+        unsigned char   device,
+        unsigned char   start_led,
+        unsigned char   led_count,
+        unsigned char*  led_data
+        );
+
+    void SendCommit();
+};

Controllers/AuraUSBController/AuraUSBController.cpp

@@ -0,0 +1,104 @@
+/*-----------------------------------------*\
+|  AuraUSBController.cpp                    |
+|                                           |
+|  Driver for ASUS Aura RGB USB             |
+|  lighting controller                      |
+|                                           |
+|  Martin Hartl (inlart) 4/25/2020          |
+\*-----------------------------------------*/
+
+#include "AuraUSBController.h"
+#include <cstring>
+
+AuraUSBController::AuraUSBController(hid_device* dev_handle)
+{
+    dev = dev_handle;
+
+    GetFirmwareVersion();
+    GetConfigTable();
+}
+
+AuraUSBController::~AuraUSBController()
+{
+
+}
+
+unsigned int AuraUSBController::GetChannelCount()
+{
+    return( channel_count );
+}
+
+std::string AuraUSBController::GetDeviceName()
+{
+    return(device_name);
+}
+
+void AuraUSBController::GetConfigTable()
+{
+    unsigned char usb_buf[65];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up config table request packet                    |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]   = 0xEC;
+    usb_buf[0x01]   = AURA_REQUEST_CONFIG_TABLE;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_write(dev, usb_buf, 65);
+    hid_read(dev, usb_buf, 65);
+
+    /*-----------------------------------------------------*\
+    | Copy the firmware string if the reply ID is correct   |
+    \*-----------------------------------------------------*/
+    if(usb_buf[1] == 0x30)
+    {
+        memcpy(config_table, &usb_buf[4], 60);
+
+        for(int i = 0; i < 60; i+=6)
+        {
+            printf("%02X %02X %02X %02X %02X %02X\r\n", config_table[i + 0],
+                                                        config_table[i + 1],
+                                                        config_table[i + 2],
+                                                        config_table[i + 3],
+                                                        config_table[i + 4],
+                                                        config_table[i + 5]);
+        }
+    }
+}
+
+void AuraUSBController::GetFirmwareVersion()
+{
+    unsigned char usb_buf[65];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up firmware version request packet                |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]   = 0xEC;
+    usb_buf[0x01]   = AURA_REQUEST_FIRMWARE_VERSION;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_write(dev, usb_buf, 65);
+    hid_read(dev, usb_buf, 65);
+
+    /*-----------------------------------------------------*\
+    | Copy the firmware string if the reply ID is correct   |
+    \*-----------------------------------------------------*/
+    if(usb_buf[1] == 0x02)
+    {
+        memcpy(device_name, &usb_buf[2], 16);
+    }
+}

Controllers/AuraUSBController/AuraUSBController.h

@@ -0,0 +1,81 @@
+/*-----------------------------------------*\
+|  AuraUSBController.h                      |
+|                                           |
+|  Definitions and types for ASUS Aura      |
+|  USB RGB lighting controller              |
+|                                           |
+|  Martin Hartl (inlart) 4/25/2020          |
+\*-----------------------------------------*/
+
+#include "RGBController.h"
+
+#include <string>
+#include <hidapi/hidapi.h>
+
+#pragma once
+
+enum
+{
+    AURA_MODE_OFF                       = 0,        /* OFF mode                             */
+    AURA_MODE_STATIC                    = 1,        /* Static color mode                    */
+    AURA_MODE_BREATHING                 = 2,        /* Breathing effect mode                */
+    AURA_MODE_FLASHING                  = 3,        /* Flashing effect mode                 */
+    AURA_MODE_SPECTRUM_CYCLE            = 4,        /* Spectrum Cycle mode                  */
+    AURA_MODE_RAINBOW                   = 5,        /* Rainbow effect mode                  */
+    AURA_MODE_SPECTRUM_CYCLE_BREATHING  = 6,        /* Rainbow Breathing effect mode        */
+    AURA_MODE_CHASE_FADE                = 7,        /* Chase with Fade effect mode          */
+    AURA_MODE_SPECTRUM_CYCLE_CHASE_FADE = 8,        /* Chase with Fade, Rainbow effect mode */
+    AURA_MODE_CHASE                     = 9,        /* Chase effect mode                    */
+    AURA_MODE_SPECTRUM_CYCLE_CHASE      = 10,       /* Chase with Rainbow effect mode       */
+    AURA_MODE_SPECTRUM_CYCLE_WAVE       = 11,       /* Wave effect mode                     */
+    AURA_MODE_CHASE_RAINBOW_PULSE       = 12,       /* Chase with  Rainbow Pulse effect mode*/
+    AURA_MODE_RANDOM_FLICKER            = 13,       /* Random flicker effect mode           */
+    AURA_MODE_MUSIC                     = 14,       /* Music effect mode                    */
+    AURA_MODE_DIRECT                    = 0xFF,     /* Direct control mode                  */
+};
+
+enum
+{
+    AURA_REQUEST_FIRMWARE_VERSION       = 0x82,     /* Request firmware string              */
+    AURA_REQUEST_CONFIG_TABLE           = 0xB0,     /* Request configuration table          */
+};
+
+class AuraUSBController
+{
+public:
+    AuraUSBController(hid_device* dev_handle);
+    virtual ~AuraUSBController();
+
+    unsigned int GetChannelCount();
+
+    std::string GetDeviceName();
+
+    virtual void SetChannelLEDs
+        (
+        unsigned char   channel,
+        RGBColor *      colors,
+        unsigned int    num_colors
+        ) = 0;
+
+    virtual void SetMode
+        (
+        unsigned char   channel,
+        unsigned char   mode,
+        unsigned char   red,
+        unsigned char   grn,
+        unsigned char   blu
+        ) = 0;
+
+protected:
+    hid_device*             dev;
+    unsigned int            channel_count;
+    unsigned char           config_table[60];
+
+private:
+    char                    device_name[16];
+    unsigned int            led_count;
+
+    void GetConfigTable();
+
+    void GetFirmwareVersion();
+};

Controllers/AuraUSBController/AuraUSBControllerDetect.cpp

@@ -0,0 +1,68 @@
+#include "AuraAddressableController.h"
+#include "AuraMainboardController.h"
+#include "RGBController.h"
+#include "RGBController_AuraUSB.h"
+#include <vector>
+#include <hidapi/hidapi.h>
+
+#define AURA_USB_VID 0x0B05
+
+#define NUM_ADDRESSABLE_PIDS 4
+static const unsigned short addressable_pid_table[] =
+    {
+    0x1867,
+    0x1872,
+    0x1889,
+    0x18A3
+    };
+
+#define NUM_MAINBOARD_PIDS 1
+static const unsigned short mainboard_pid_table[] =
+    {
+    0x18f3
+    };
+
+/******************************************************************************************\
+*                                                                                          *
+*   DetectAuraUSBControllers                                                               *
+*                                                                                          *
+*       Tests the USB address to see if an Asus Aura USB RGB header controller             *
+*       exists there.                                                                      *
+*                                                                                          *
+\******************************************************************************************/
+
+void DetectAuraUSBControllers(std::vector<RGBController*>& rgb_controllers)
+{
+    hid_device* dev;
+
+    //Look for Asus Aura addressable RGB header controller
+    hid_init();
+
+    for(int pid_idx = 0; pid_idx < NUM_ADDRESSABLE_PIDS; pid_idx++)
+    {
+        dev = hid_open(AURA_USB_VID, addressable_pid_table[pid_idx], 0);
+
+        if( dev )
+        {
+            AuraAddressableController* controller = new AuraAddressableController(dev);
+
+            RGBController_AuraUSB* rgb_controller = new RGBController_AuraUSB(controller);
+
+            rgb_controllers.push_back(rgb_controller);
+        }
+    }
+
+    for(int pid_idx = 0; pid_idx < NUM_MAINBOARD_PIDS; pid_idx++)
+    {
+        dev = hid_open(AURA_USB_VID, mainboard_pid_table[pid_idx], 0);
+
+        if( dev )
+        {
+            AuraMainboardController* controller = new AuraMainboardController(dev);
+
+            RGBController_AuraUSB* rgb_controller = new RGBController_AuraUSB(controller);
+
+            rgb_controllers.push_back(rgb_controller);
+        }
+    }
+}

Controllers/CoolerMasterController/CMMP750Controller.cpp

@@ -0,0 +1,100 @@
+/*-------------------------------------------------------------------*\
+|  CMMP750Controller.cpp                                              |
+|                                                                     |
+|  Driver for Coolermaster MP750 mousepad                             |
+|                                                                     |
+|  Chris M (Dr_No)          16th Apr 2020                             |
+|                                                                     |
+\*-------------------------------------------------------------------*/
+
+#include "CMMP750Controller.h"
+#include <cstring>
+#include <stdio.h>
+#include <stdlib.h>
+
+CMMP750Controller::CMMP750Controller(libusb_device_handle* dev_handle, unsigned int _inAddr, unsigned int _outAddr, int _interface)
+{
+    dev = dev_handle;
+    inAddr = _inAddr;
+    outAddr = _outAddr;
+    interface = _interface;
+
+    libusb_device* device = libusb_get_device(dev);
+    int bus = libusb_get_bus_number(device);
+    int bus_addr = libusb_get_device_address(device);
+    int port = libusb_get_port_number(device);
+    location = "Bus: " + std::to_string(bus) + "  Addr: " + std::to_string(bus_addr) + "  Port: " + std::to_string(port);
+
+    strcpy(device_name, "Cooler Master MP750");
+
+    current_mode = MP750_MODE_STATIC;
+    current_speed = MP750_SPEED_NORMAL;
+}
+
+CMMP750Controller::~CMMP750Controller()
+{
+    libusb_release_interface(dev, interface);
+    libusb_attach_kernel_driver(dev, interface);
+}
+
+char* CMMP750Controller::GetDeviceName()
+{
+    return device_name;
+}
+
+char* CMMP750Controller::GetSerial()
+{
+    return serial;
+}
+
+std::string CMMP750Controller::GetLocation()
+{
+    return location;
+}
+
+void CMMP750Controller::SetMode(unsigned char mode, unsigned char speed)
+{
+    current_mode  = mode;
+    current_speed = speed;
+
+    SendUpdate();
+}
+
+void CMMP750Controller::SetColor(unsigned char red, unsigned char green, unsigned char blue)
+{
+    current_red   = red;
+    current_green = green;
+    current_blue  = blue;
+
+    SendUpdate();
+}
+
+void CMMP750Controller::SendUpdate()
+{
+    int actual = 0;
+    unsigned char buffer[0x40] = { 0x00 };
+    int buffer_size = (sizeof(buffer) / sizeof(buffer[0]));
+
+    for(int i = 0; i < CM_COLOUR_MODE_DATA_SIZE; i++)
+    {
+        buffer[i] = colour_mode_data[current_mode][i];
+    }
+
+   if(current_mode > MP750_MODE_BREATHING)
+    { 
+        //If the mode is random colours set SPEED at BYTE2
+        buffer[CM_RED_BYTE] = speed_mode_data[current_mode][current_speed];
+    }
+    else
+    { 
+        //Otherwise SPEED is BYTE5
+        buffer[CM_RED_BYTE] = current_red;
+        buffer[CM_GREEN_BYTE] = current_green;
+        buffer[CM_BLUE_BYTE] = current_blue;
+        buffer[CM_SPEED_BYTE] = speed_mode_data[current_mode][current_speed];
+    }
+
+    //Nothing will be done with the "actual" transfer length
+    libusb_interrupt_transfer(dev, outAddr, buffer, buffer_size, nullptr, CM_INTERRUPT_TIMEOUT);
+}
+

Controllers/CoolerMasterController/CMMP750Controller.h

@@ -0,0 +1,105 @@
+/*-------------------------------------------------------------------*\
+|  CMMP750Controller.h                                                |
+|                                                                     |
+|  Driver for Coolermaster MP750 mousepad                             |
+|                                                                     |
+|  Chris M (Dr_No)          16th Apr 2020                             |
+|                                                                     |
+|  Simple RGB device with 5 modes                                     |
+|  BYTE0 = Mode (0x01 thru 0x05                                       |
+|  BYTE1 = ?? Must be set to 0x04 for colour modes otherwise ignored  |
+|  BYTE2 = Colour Modes: RED    else Cycle SPEED                      |
+|  BYTE3 = Colour Modes: GREEN  else ignored                          |
+|  BYTE4 = Colour Modes: BLUE   else ignored                          |
+|  BYTE5 = Colour Modes: SPEED  else ignored                          |
+\*-------------------------------------------------------------------*/
+
+#include <string>
+#include <array>
+#include <libusb-1.0/libusb.h>
+
+#pragma once
+
+#define CM_COLOUR_MODE_DATA_SIZE (sizeof(colour_mode_data) / sizeof(colour_mode_data[0]))
+#define CM_INTERRUPT_TIMEOUT 250
+
+enum
+{
+    CM_MODE_BYTE   = 0,
+    CM_RED_BYTE    = 2,
+    CM_GREEN_BYTE  = 3,
+    CM_BLUE_BYTE   = 4,
+    CM_SPEED_BYTE  = 5
+};
+
+enum
+{
+    MP750_MODE_STATIC       = 0x00, //Static Mode
+    MP750_MODE_BLINK        = 0x01, //Blinking Mode
+    MP750_MODE_BREATHING    = 0x02, //Breathing Mode
+    MP750_MODE_COLOR_CYCLE  = 0x03, //Color Cycle Mode
+    MP750_MODE_BREATH_CYCLE = 0x04  //Breathing Cycle Mode
+};
+
+static unsigned char colour_mode_data[][6] =
+{
+    { 0x01, 0x04, 0xFF, 0x00, 0xFF, 0x00 },                  /* Static                       */
+    { 0x02, 0x04, 0xFF, 0x00, 0xFF, 0x80 },                  /* Blinking                     */
+    { 0x03, 0x04, 0xFF, 0x00, 0xFF, 0x80 },                  /* Breathing                    */
+    { 0x04, 0x04, 0x80, 0x00, 0x00, 0x00 },                  /* Colour Cycle                 */
+    { 0x05, 0x04, 0x80, 0x00, 0x00, 0x00 }                   /* Colour Breath                */
+};
+
+static unsigned char speed_mode_data[][9] =
+{
+    { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },/* Static                       */
+    { 0x00, 0x20, 0x40, 0x60, 0x80, 0xA0, 0xC0, 0xE0, 0xFF },/* Blinking                     */
+    { 0x00, 0x20, 0x40, 0x60, 0x80, 0xA0, 0xC0, 0xE0, 0xFF },/* Breathing                    */
+    { 0x00, 0x20, 0x40, 0x60, 0x80, 0xA0, 0xC0, 0xE0, 0xFF },/* Colour Cycle                 */
+    { 0x00, 0x20, 0x40, 0x60, 0x80, 0xA0, 0xC0, 0xE0, 0xFF } /* Colour Breath                */
+};
+
+enum
+{
+    MP750_SPEED_SLOWEST              = 0x00, /* Slowest speed                */
+    MP750_SPEED_SLOWER               = 0x01, /* Slower speed                 */
+    MP750_SPEED_SLOW                 = 0x02, /* Slow speed                   */
+    MP750_SPEED_SLOWISH              = 0x03, /* Slowish speed                */
+    MP750_SPEED_NORMAL               = 0x04, /* Normal speed                 */
+    MP750_SPEED_FASTISH              = 0x05, /* Fastish speed                */
+    MP750_SPEED_FAST                 = 0x06, /* Fast speed                   */
+    MP750_SPEED_FASTER               = 0x07, /* Faster speed                 */
+    MP750_SPEED_FASTEST              = 0x08, /* Fastest speed                */
+};
+
+class CMMP750Controller
+{
+public:
+    CMMP750Controller(libusb_device_handle *dev_handle, unsigned int _inAddr, unsigned int _outAddr, int _interface);
+    ~CMMP750Controller();
+
+    char* GetDeviceName();
+    char* GetSerial();
+    std::string GetLocation();
+
+    void SetMode(unsigned char mode, unsigned char speed);
+    void SetColor(unsigned char red, unsigned char green, unsigned char blue);
+
+private:
+    char                    device_name[32];
+    char                    serial[32];
+    std::string             location;
+    libusb_device_handle*   dev;
+    unsigned char           inAddr;
+    unsigned char           outAddr;
+    int                     interface;
+
+    unsigned char           current_mode;
+    unsigned char           current_speed;
+
+    unsigned char           current_red;
+    unsigned char           current_green;
+    unsigned char           current_blue;
+
+    void SendUpdate();
+};

Controllers/CoolerMasterController/CoolerMasterControllerDetect.cpp

@@ -0,0 +1,57 @@
+#include "CMMP750Controller.h"
+#include "RGBController.h"
+#include "RGBController_CMMP750Controller.h"
+#include <vector>
+#include <libusb-1.0/libusb.h>
+
+#define COOLERMASTER_VID 0x2516
+
+#define COOLERMASTER_NUM_DEVICES (sizeof(cm_pids) / sizeof(cm_pids[ 0 ]))
+
+enum
+{
+    CM_PID = 0,
+    CM_INADDR = 1,
+    CM_OUTADDR = 2,
+    CM_INTERFACE = 3
+};
+
+static const unsigned int cm_pids[][4] =
+{ //PID, inAddr, outAddr, interface
+    { 0x0109, 0x82, 0x03, 0x00 }        //Coolermaster MP750
+};
+
+/******************************************************************************************\
+*                                                                                          *
+*   DetectCoolerMasterControllers                                                          *
+*                                                                                          *
+*       Tests the USB address to see if any CoolerMaster controllers exists there.         *
+*                                                                                          *
+\******************************************************************************************/
+
+void DetectCoolerMasterControllers(std::vector<RGBController*>& rgb_controllers)
+{
+    libusb_context * context;
+    libusb_init(&context);
+
+    for(int cm_pid_idx = 0; cm_pid_idx < COOLERMASTER_NUM_DEVICES; cm_pid_idx++)
+    {
+        //Look for the passed in cm_pids
+        libusb_device_handle * dev = libusb_open_device_with_vid_pid(context, COOLERMASTER_VID, cm_pids[cm_pid_idx][CM_PID]);
+
+        if(dev)
+        {
+            int status = libusb_detach_kernel_driver(dev, cm_pids[cm_pid_idx][CM_INTERFACE]);
+            status = libusb_claim_interface(dev, cm_pids[cm_pid_idx][CM_INTERFACE]);
+
+            if(status == 0)
+            {
+                // Success: Device has been claimed
+                CMMP750Controller* controller = new CMMP750Controller(dev, cm_pids[cm_pid_idx][CM_INADDR], cm_pids[cm_pid_idx][CM_OUTADDR], cm_pids[cm_pid_idx][CM_INTERFACE]);
+                RGBController_CMMP750Controller* rgb_controller = new RGBController_CMMP750Controller(controller);
+                rgb_controllers.push_back(rgb_controller);
+            }
+        }
+    }
+
+}

Controllers/CorsairLightingNodeController/CorsairLightingNodeController.cpp

@@ -0,0 +1,463 @@
+/*---------------------------------------------------------*\
+|  Processing Code for Corsair Lighting Node Pro            |
+|                                                           |
+|  Adam Honse ([email protected]), 1/12/2020        |
+\*---------------------------------------------------------*/
+
+#include "CorsairLightingNodeController.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)
+{
+    CorsairLightingNodeController* corsair = static_cast<CorsairLightingNodeController*>(param);
+    corsair->KeepaliveThread();
+    THREADRETURN
+}
+
+CorsairLightingNodeController::CorsairLightingNodeController(libusb_device_handle* dev_handle, unsigned int dev_endpoint)
+{
+    dev = dev_handle;
+    endpoint = dev_endpoint;
+
+    SendFirmwareRequest();
+
+    /*-----------------------------------------------------*\
+    | 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
+}
+
+CorsairLightingNodeController::~CorsairLightingNodeController()
+{
+}
+
+void CorsairLightingNodeController::KeepaliveThread()
+{
+    while(1)
+    {
+        SendCommit();
+        Sleep(5000);
+    }
+}
+
+std::string CorsairLightingNodeController::GetFirmwareString()
+{
+    return(firmware_version);
+}
+
+void CorsairLightingNodeController::SetChannelEffect(unsigned char channel,
+                                                unsigned char num_leds,
+                                                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_LIGHTING_NODE_PORT_STATE_HARDWARE);
+
+    /*-----------------------------------------------------*\
+    | Set Effect Configuration packet                       |
+    \*-----------------------------------------------------*/
+    SendEffectConfig
+    (
+        channel,
+        0,
+        num_leds,
+        mode,
+        speed,
+        direction,
+        random,
+        red1,
+        grn1,
+        blu1,
+        red2,
+        grn2,
+        blu2,
+        red3,
+        grn3,
+        blu3,
+        0,
+        0,
+        0
+    );
+
+    /*-----------------------------------------------------*\
+    | Send Commit packet                                    |
+    \*-----------------------------------------------------*/
+    SendCommit();
+}
+
+void CorsairLightingNodeController::SetChannelLEDs(unsigned char channel, RGBColor * colors, unsigned int num_colors)
+{
+    unsigned char   red_color_data[50];
+    unsigned char   grn_color_data[50];
+    unsigned char   blu_color_data[50];
+    unsigned char   pkt_offset          = 0;
+    unsigned char   pkt_size            = 0;
+    unsigned int    colors_remaining    = num_colors;
+
+    /*-----------------------------------------------------*\
+    | Send Port State packet                                |
+    \*-----------------------------------------------------*/
+    SendPortState(channel, CORSAIR_LIGHTING_NODE_PORT_STATE_SOFTWARE);
+
+    /*-----------------------------------------------------*\
+    | Loop through colors and send 50 at a time             |
+    \*-----------------------------------------------------*/
+    while(colors_remaining > 0)
+    {
+        if(colors_remaining < 50)
+        {
+            pkt_size = colors_remaining;
+        }
+        else
+        {
+            pkt_size = 50;
+        }
+        
+        for(int color_idx = 0; color_idx < pkt_size; color_idx++)
+        {
+            red_color_data[color_idx] = RGBGetRValue(colors[pkt_offset + color_idx]);
+            grn_color_data[color_idx] = RGBGetGValue(colors[pkt_offset + color_idx]);
+            blu_color_data[color_idx] = RGBGetBValue(colors[pkt_offset + color_idx]);
+        }
+
+        SendDirect(channel, pkt_offset, pkt_size, CORSAIR_LIGHTING_NODE_DIRECT_CHANNEL_RED,   red_color_data);
+        SendDirect(channel, pkt_offset, pkt_size, CORSAIR_LIGHTING_NODE_DIRECT_CHANNEL_GREEN, grn_color_data);
+        SendDirect(channel, pkt_offset, pkt_size, CORSAIR_LIGHTING_NODE_DIRECT_CHANNEL_BLUE,  blu_color_data);
+
+        colors_remaining -= pkt_size;
+        pkt_offset       += pkt_size;
+    }
+
+    /*-----------------------------------------------------*\
+    | Send Commit packet                                    |
+    \*-----------------------------------------------------*/
+    SendCommit();
+}
+
+/*-------------------------------------------------------------------------------------------------*\
+| Private packet sending functions.                                                                 |
+\*-------------------------------------------------------------------------------------------------*/
+
+void CorsairLightingNodeController::SendFirmwareRequest()
+{
+    int             actual;
+    unsigned char   usb_buf[64];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up Firmware Version Request packet                |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]   = CORSAIR_LIGHTING_NODE_PACKET_ID_FIRMWARE;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    libusb_interrupt_transfer(dev, endpoint, usb_buf, 64, &actual, 0);
+    libusb_interrupt_transfer(dev, 0x80 + endpoint, usb_buf, 64, &actual, 0);
+
+    if(actual > 0)
+    {
+        firmware_version = std::to_string(usb_buf[0x01]) + "." + std::to_string(usb_buf[0x02]) + "." + std::to_string(usb_buf[0x03]);
+    }
+}
+
+void CorsairLightingNodeController::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_LIGHTING_NODE_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, endpoint, usb_buf, 64, &actual, 0);
+}
+
+void CorsairLightingNodeController::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_LIGHTING_NODE_PACKET_ID_COMMIT;
+    usb_buf[0x01]   = 0xFF;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    libusb_interrupt_transfer(dev, endpoint, usb_buf, 64, &actual, 0);
+}
+
+void CorsairLightingNodeController::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_LIGHTING_NODE_PACKET_ID_BEGIN;
+    usb_buf[0x01]   = channel;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    libusb_interrupt_transfer(dev, endpoint, usb_buf, 64, &actual, 0);
+}
+
+void CorsairLightingNodeController::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_LIGHTING_NODE_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, endpoint, usb_buf, 64, &actual, 0);
+}
+
+void CorsairLightingNodeController::SendTemperature()
+{
+
+}
+
+void CorsairLightingNodeController::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_LIGHTING_NODE_PACKET_ID_RESET;
+    usb_buf[0x01]   = channel;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    libusb_interrupt_transfer(dev, endpoint, usb_buf, 64, &actual, 0);
+}
+
+void CorsairLightingNodeController::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_LIGHTING_NODE_PACKET_ID_PORT_STATE;
+    usb_buf[0x01]   = channel;
+    usb_buf[0x02]   = state;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    libusb_interrupt_transfer(dev, endpoint, usb_buf, 64, &actual, 0);
+}
+
+void CorsairLightingNodeController::SendBrightness()
+{
+
+}
+
+void CorsairLightingNodeController::SendLEDCount()
+{
+
+}
+
+void CorsairLightingNodeController::SendProtocol()
+{
+
+}

Controllers/CorsairLightingNodeController/CorsairLightingNodeController.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_LIGHTING_NODE_PACKET_ID_FIRMWARE         = 0x02,     /* Get firmware version                 */
+    CORSAIR_LIGHTING_NODE_PACKET_ID_DIRECT           = 0x32,     /* Direct mode LED update packet        */
+    CORSAIR_LIGHTING_NODE_PACKET_ID_COMMIT           = 0x33,     /* Commit changes packet                */
+    CORSAIR_LIGHTING_NODE_PACKET_ID_BEGIN            = 0x34,     /* Begin effect packet                  */
+    CORSAIR_LIGHTING_NODE_PACKET_ID_EFFECT_CONFIG    = 0x35,     /* Effect mode configuration packet     */
+    CORSAIR_LIGHTING_NODE_PACKET_ID_TEMPERATURE      = 0x36,     /* Update temperature value packet      */
+    CORSAIR_LIGHTING_NODE_PACKET_ID_RESET            = 0x37,     /* Reset channel packet                 */
+    CORSAIR_LIGHTING_NODE_PACKET_ID_PORT_STATE       = 0x38,     /* Set port state packet                */
+    CORSAIR_LIGHTING_NODE_PACKET_ID_BRIGHTNESS       = 0x39,     /* Set brightness packet                */
+    CORSAIR_LIGHTING_NODE_PACKET_ID_LED_COUNT        = 0x3A,     /* Set LED count packet                 */
+    CORSAIR_LIGHTING_NODE_PACKET_ID_PROTOCOL         = 0x3B,     /* Set protocol packet                  */
+};
+
+enum
+{
+    CORSAIR_LIGHTING_NODE_DIRECT_CHANNEL_RED         = 0x00,     /* Red channel for direct update        */
+    CORSAIR_LIGHTING_NODE_DIRECT_CHANNEL_GREEN       = 0x01,     /* Green channel for direct update      */
+    CORSAIR_LIGHTING_NODE_DIRECT_CHANNEL_BLUE        = 0x02,     /* Blue channel for direct update       */
+};
+
+enum
+{
+    CORSAIR_LIGHTING_NODE_PORT_STATE_HARDWARE        = 0x01,     /* Effect hardware control of channel   */
+    CORSAIR_LIGHTING_NODE_PORT_STATE_SOFTWARE        = 0x02,     /* Direct software control of channel   */
+};
+
+enum
+{
+    CORSAIR_LIGHTING_NODE_LED_TYPE_LED_STRIP         = 0x0A,     /* Corsair LED Strip Type               */
+    CORSAIR_LIGHTING_NODE_LED_TYPE_HD_FAN            = 0x0C,     /* Corsair HD-series Fan Type           */
+    CORSAIR_LIGHTING_NODE_LED_TYPE_SP_FAN            = 0x01,     /* Corsair SP-series Fan Type           */
+    CORSAIR_LIGHTING_NODE_LED_TYPE_ML_FAN            = 0x02,     /* Corsair ML-series Fan Type           */
+};
+
+enum
+{
+    CORSAIR_LIGHTING_NODE_CHANNEL_1                  = 0x00,     /* Channel 1                            */
+    CORSAIR_LIGHTING_NODE_CHANNEL_2                  = 0x01,     /* Channel 2                            */
+    CORSAIR_LIGHTING_NODE_NUM_CHANNELS               = 0x02,     /* Number of channels                   */
+};
+
+enum
+{
+    CORSAIR_LIGHTING_NODE_SPEED_FAST                 = 0x00,     /* Fast speed                           */
+    CORSAIR_LIGHTING_NODE_SPEED_MEDIUM               = 0x01,     /* Medium speed                         */
+    CORSAIR_LIGHTING_NODE_SPEED_SLOW                 = 0x02,     /* Slow speed                           */
+};
+
+enum
+{
+    CORSAIR_LIGHTING_NODE_MODE_RAINBOW_WAVE          = 0x00,     /* Rainbow Wave mode                    */
+    CORSAIR_LIGHTING_NODE_MODE_COLOR_SHIFT           = 0x01,     /* Color Shift mode                     */
+    CORSAIR_LIGHTING_NODE_MODE_COLOR_PULSE           = 0x02,     /* Color Pulse mode                     */
+    CORSAIR_LIGHTING_NODE_MODE_COLOR_WAVE            = 0x03,     /* Color Wave mode                      */
+    CORSAIR_LIGHTING_NODE_MODE_STATIC                = 0x04,     /* Static mode                          */
+    CORSAIR_LIGHTING_NODE_MODE_TEMPERATURE           = 0x05,     /* Temperature mode                     */
+    CORSAIR_LIGHTING_NODE_MODE_VISOR                 = 0x06,     /* Visor mode                           */
+    CORSAIR_LIGHTING_NODE_MODE_MARQUEE               = 0x07,     /* Marquee mode                         */
+    CORSAIR_LIGHTING_NODE_MODE_BLINK                 = 0x08,     /* Blink mode                           */
+    CORSAIR_LIGHTING_NODE_MODE_SEQUENTIAL            = 0x09,     /* Sequential mode                      */
+    CORSAIR_LIGHTING_NODE_MODE_RAINBOW               = 0x0A,     /* Rainbow mode                         */
+};
+
+class CorsairLightingNodeController
+{
+public:
+    CorsairLightingNodeController(libusb_device_handle* dev_handle, unsigned int dev_endpoint);
+    ~CorsairLightingNodeController();
+
+    std::string     GetFirmwareString();
+
+    unsigned int    GetStripsOnChannel(unsigned int channel);
+
+    void            SetChannelEffect(unsigned char channel,
+                                     unsigned char num_leds,
+                                     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, RGBColor * colors, unsigned int num_colors);
+
+    void            KeepaliveThread();
+
+private:
+    libusb_device_handle*   dev;
+    unsigned int            endpoint;
+    std::string             firmware_version;
+
+    void            SendFirmwareRequest();
+
+    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/CorsairLightingNodeController/CorsairLightingNodeControllerDetect.cpp

@@ -0,0 +1,67 @@
+#include "CorsairLightingNodeController.h"
+#include "RGBController.h"
+#include "RGBController_CorsairLightingNode.h"
+#include <vector>
+#include <libusb-1.0/libusb.h>
+
+#define CORSAIR_VID                     0x1B1C
+#define CORSAIR_LIGHTING_NODE_CORE_PID  0x0C1A
+#define CORSAIR_LIGHTING_NODE_PRO_PID   0x0C0B
+#define CORSAIR_COMMANDER_PRO_PID       0x0C10
+#define CORSAIR_LS100_PID               0x0C1E
+#define CORSAIR_1000D_OBSIDIAN_PID      0x1D00
+#define CORSAIR_SPEC_OMEGA_RGB_PID      0x1D04
+
+typedef struct
+{
+    unsigned short  usb_vid;
+    unsigned short  usb_pid;
+    unsigned char   usb_endpoint;
+    unsigned char   channel_count;
+    const char *    name;
+} corsair_node_device;
+
+static const corsair_node_device device_list[6] =
+{
+    { CORSAIR_VID,          CORSAIR_LIGHTING_NODE_CORE_PID,     1,      1,      "Corsair Lighting Node Core"    },
+    { CORSAIR_VID,          CORSAIR_LIGHTING_NODE_PRO_PID,      1,      2,      "Corsair Lighting Node Pro"     },
+    { CORSAIR_VID,          CORSAIR_COMMANDER_PRO_PID,          2,      2,      "Corsair Commander Pro"         },
+    { CORSAIR_VID,          CORSAIR_LS100_PID,                  1,      1,      "Corsair LS100 Lighting Kit"    },
+    { CORSAIR_VID,          CORSAIR_1000D_OBSIDIAN_PID,         2,      2,      "Corsair 1000D Obsidian"        },
+    { CORSAIR_VID,          CORSAIR_SPEC_OMEGA_RGB_PID,         1,      2,      "Corsair SPEC OMEGA RGB"        }
+
+};
+
+/******************************************************************************************\
+*                                                                                          *
+*   DetectCorsairLightingNodeControllers                                                   *
+*                                                                                          *
+*       Detect devices supported by the Corsair Lighting Node Pro driver                   *
+*                                                                                          *                                                                                          *
+\******************************************************************************************/
+
+void DetectCorsairLightingNodeControllers(std::vector<RGBController*> &rgb_controllers)
+{
+    libusb_context * ctx;
+    libusb_init(&ctx);
+
+    for(int device_idx = 0; device_idx < 6; device_idx++)
+    {
+        //Look for Corsair Lighting Node Device
+        libusb_device_handle * dev = libusb_open_device_with_vid_pid(ctx, device_list[device_idx].usb_vid, device_list[device_idx].usb_pid);
+
+        if( dev )
+        {
+            libusb_detach_kernel_driver(dev, 0);
+            libusb_claim_interface(dev, 0);
+
+            CorsairLightingNodeController* controller = new CorsairLightingNodeController(dev, device_list[device_idx].usb_endpoint);
+
+            RGBController_CorsairLightingNode* rgb_controller = new RGBController_CorsairLightingNode(controller);
+
+            rgb_controller->name = device_list[device_idx].name;
+
+            rgb_controllers.push_back(rgb_controller);
+        }
+    }
+}   /* DetectCorsairLightingNodeControllers() */

Controllers/CorsairPeripheralController/CorsairPeripheralController.cpp

@@ -0,0 +1,500 @@
+/*-----------------------------------------*\
+|  CorsairPeripheralController.cpp          |
+|                                           |
+|  Driver for Corsair RGB keyboard, mouse,  |
+|  and mousemat lighting controller         |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 1/9/2020    |
+\*-----------------------------------------*/
+
+#include "CorsairPeripheralController.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[] = {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++;
+
+    Sleep(2);
+}
+
+CorsairPeripheralController::CorsairPeripheralController(hid_device* dev_handle)
+{
+    dev = dev_handle;
+
+    ReadFirmwareInfo();
+
+    SpecialFunctionControl();
+    LightingControl();
+}
+
+CorsairPeripheralController::~CorsairPeripheralController()
+{
+
+}
+
+device_type CorsairPeripheralController::GetDeviceType()
+{
+    return type;
+}
+
+std::string CorsairPeripheralController::GetFirmwareString()
+{
+    return firmware_version;
+}
+
+void CorsairPeripheralController::SetLEDs(std::vector<RGBColor>colors)
+{
+    switch(type)
+    {
+        case DEVICE_TYPE_KEYBOARD:
+            SetLEDsKeyboardFull(colors);
+            break;
+
+        case DEVICE_TYPE_MOUSE:
+            SetLEDsMouse(colors);
+            break;
+
+        case DEVICE_TYPE_MOUSEMAT:
+            SetLEDsMousemat(colors);
+            break;
+    }
+}
+
+void CorsairPeripheralController::SetLEDsKeyboardFull(std::vector<RGBColor> colors)
+{
+    unsigned char red_val[144];
+    unsigned char grn_val[144];
+    unsigned char blu_val[144];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffers                                      |
+    \*-----------------------------------------------------*/
+    memset(red_val, 0x00, sizeof( red_val ));
+    memset(grn_val, 0x00, sizeof( grn_val ));
+    memset(blu_val, 0x00, sizeof( blu_val ));
+
+    /*-----------------------------------------------------*\
+    | Copy red, green, and blue components into buffers     |
+    \*-----------------------------------------------------*/
+    for(std::size_t color_idx = 0; color_idx < colors.size(); color_idx++)
+    {
+        RGBColor           color = colors[color_idx];
+        red_val[keys[color_idx]] = RGBGetRValue(color);
+        grn_val[keys[color_idx]] = RGBGetGValue(color);
+        blu_val[keys[color_idx]] = RGBGetBValue(color);
+    }
+
+    /*-----------------------------------------------------*\
+    | Send red bytes                                        |
+    \*-----------------------------------------------------*/
+    StreamPacket(1, 60, &red_val[0]);
+    StreamPacket(2, 60, &red_val[60]);
+    StreamPacket(3, 24, &red_val[120]);
+    SubmitKeyboardFullColors(1, 3, 1);
+
+    /*-----------------------------------------------------*\
+    | Send green bytes                                      |
+    \*-----------------------------------------------------*/
+    StreamPacket(1, 60, &grn_val[0]);
+    StreamPacket(2, 60, &grn_val[60]);
+    StreamPacket(3, 24, &grn_val[120]);
+    SubmitKeyboardFullColors(2, 3, 1);
+
+    /*-----------------------------------------------------*\
+    | Send blue bytes                                       |
+    \*-----------------------------------------------------*/
+    StreamPacket(1, 60, &blu_val[0]);
+    StreamPacket(2, 60, &blu_val[60]);
+    StreamPacket(3, 24, &blu_val[120]);
+    SubmitKeyboardFullColors(3, 3, 2);
+}
+
+void CorsairPeripheralController::SetLEDsMouse(std::vector<RGBColor> colors)
+{
+    SubmitMouseColors(colors.size(), &colors[0]);
+}
+
+void CorsairPeripheralController::SetLEDsMousemat(std::vector<RGBColor> colors)
+{
+    SubmitMousematColors(colors.size(), &colors[0]);
+}
+
+void CorsairPeripheralController::SetLEDsKeyboardLimited(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(std::size_t 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]);
+    
+    SubmitKeyboardLimitedColors(216);
+}
+
+/*-------------------------------------------------------------------------------------------------*\
+| Private packet sending functions.                                                                 |
+\*-------------------------------------------------------------------------------------------------*/
+
+void CorsairPeripheralController::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;
+
+    /*-----------------------------------------------------*\
+    | Lighting control byte needs to be 3 for keyboards, 1  |
+    | for mice and mousepads                                |
+    \*-----------------------------------------------------*/
+    switch(type)
+    {
+        default:
+        case DEVICE_TYPE_KEYBOARD:
+            usb_buf[0x04]   = 0x03;
+            break;
+
+        case DEVICE_TYPE_MOUSE:
+            usb_buf[0x04]   = 0x01;
+            break;
+
+        case DEVICE_TYPE_MOUSEMAT:
+            usb_buf[0x04]   = 0x04;
+            break;
+    }
+    
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    send_usb_msg(dev, usb_buf);
+}
+
+void CorsairPeripheralController::SpecialFunctionControl()
+{
+    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_SPECIAL_FUNCTION;
+    usb_buf[0x02]           = CORSAIR_LIGHTING_CONTROL_SOFTWARE;
+    
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    send_usb_msg(dev, usb_buf);
+}
+
+void CorsairPeripheralController::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);
+    hid_get_feature_report(dev, (unsigned char*)usb_buf, 64);
+
+    /*-----------------------------------------------------*\
+    | Get device type                                       |
+    |   0xC0    Device is a keyboard                        |
+    |   0xC1    Device is a mouse                           |
+    |   0xC2    Device is a mousepad                        |
+    \*-----------------------------------------------------*/
+    switch((unsigned char)usb_buf[0x14])
+    {
+        case 0xC0:
+            type = DEVICE_TYPE_KEYBOARD;
+            break;
+
+        case 0xC1:
+            type = DEVICE_TYPE_MOUSE;
+            break;
+
+        case 0xC2:
+            type = DEVICE_TYPE_MOUSEMAT;
+            break;
+
+        default:
+            type = DEVICE_TYPE_UNKNOWN;
+            break;
+    }
+
+    /*-----------------------------------------------------*\
+    | Format firmware version string if device type is valid|
+    \*-----------------------------------------------------*/
+    if(type != DEVICE_TYPE_UNKNOWN)
+    {
+        firmware_version = std::to_string(usb_buf[0x09]) + "." + std::to_string(usb_buf[0x08]);
+    }
+}
+
+void CorsairPeripheralController::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 CorsairPeripheralController::SubmitKeyboardFullColors
+    (
+    unsigned char   color_channel,
+    unsigned char   packet_count,
+    unsigned char   finish_val
+    )
+{
+    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;
+    usb_buf[0x02]   = color_channel;
+    usb_buf[0x03]   = packet_count;
+    usb_buf[0x04]   = finish_val;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    send_usb_msg(dev, usb_buf);
+}
+
+void CorsairPeripheralController::SubmitKeyboardLimitedColors
+    (
+    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);
+}
+
+void CorsairPeripheralController::SubmitMouseColors
+    (
+    unsigned char   num_zones,
+    RGBColor *      color_data
+    )
+{
+    char usb_buf[64];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up Submit Mouse Colors packet                     |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]   = CORSAIR_COMMAND_WRITE;
+    usb_buf[0x01]   = CORSAIR_PROPERTY_SUBMIT_MOUSE_COLOR;
+    usb_buf[0x02]   = num_zones;
+    usb_buf[0x03]   = 0x00;
+
+    /*-----------------------------------------------------*\
+    | Copy in colors in <ZONE> <RED> <GREEN> <BLUE> order   |
+    \*-----------------------------------------------------*/
+    for(unsigned int zone_idx = 0; zone_idx < num_zones; zone_idx++)
+    {
+        usb_buf[(zone_idx * 4) + 4] = zone_idx;
+        usb_buf[(zone_idx * 4) + 5] = RGBGetRValue(color_data[zone_idx]);
+        usb_buf[(zone_idx * 4) + 6] = RGBGetGValue(color_data[zone_idx]);
+        usb_buf[(zone_idx * 4) + 7] = RGBGetBValue(color_data[zone_idx]);
+    }
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    send_usb_msg(dev, usb_buf);
+}
+
+void CorsairPeripheralController::SubmitMousematColors
+    (
+    unsigned char   num_zones,
+    RGBColor *      color_data
+    )
+{
+    char usb_buf[64];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up Submit Mouse Colors packet                     |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]   = CORSAIR_COMMAND_WRITE;
+    usb_buf[0x01]   = CORSAIR_PROPERTY_SUBMIT_MOUSE_COLOR;
+    usb_buf[0x02]   = num_zones;
+    usb_buf[0x03]   = 0x00;
+
+    /*-----------------------------------------------------*\
+    | Copy in colors in <ZONE> <RED> <GREEN> <BLUE> order   |
+    \*-----------------------------------------------------*/
+    for(unsigned int zone_idx = 0; zone_idx < num_zones; zone_idx++)
+    {
+        //usb_buf[(zone_idx * 4) + 4] = zone_idx;
+        usb_buf[(zone_idx * 3) + 4] = RGBGetRValue(color_data[zone_idx]);
+        usb_buf[(zone_idx * 3) + 5] = RGBGetGValue(color_data[zone_idx]);
+        usb_buf[(zone_idx * 3) + 6] = RGBGetBValue(color_data[zone_idx]);
+    }
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    send_usb_msg(dev, usb_buf);
+}

Controllers/CorsairPeripheralController/CorsairPeripheralController.h

@@ -0,0 +1,106 @@
+/*-----------------------------------------*\
+|  CorsairPeripheralController.h            |
+|                                           |
+|  Definitions and types for Corsair RGB    |
+|  keyboard, mouse, and mousemat 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 CorsairPeripheralController
+{
+public:
+    CorsairPeripheralController(hid_device* dev_handle);
+    ~CorsairPeripheralController();
+
+    device_type     GetDeviceType();
+    std::string     GetFirmwareString();
+
+    void            SetLEDs(std::vector<RGBColor> colors);
+    void            SetLEDsKeyboardFull(std::vector<RGBColor> colors);
+    void            SetLEDsKeyboardLimited(std::vector<RGBColor> colors);
+    void            SetLEDsMouse(std::vector<RGBColor> colors);
+    void            SetLEDsMousemat(std::vector<RGBColor> colors);
+
+private:
+    hid_device*             dev;
+
+    std::string             firmware_version;
+    device_type             type;
+
+    void    LightingControl();
+    void    SpecialFunctionControl();
+
+    void    ReadFirmwareInfo();
+    
+    void    StreamPacket
+                (
+                unsigned char   packet_id,
+                unsigned char   data_sz,
+                unsigned char*  data_ptr
+                );
+
+    void    SubmitKeyboardFullColors
+                (
+                unsigned char   color_channel,
+                unsigned char   packet_count,
+                unsigned char   finish_val
+                );
+
+    void    SubmitKeyboardLimitedColors
+                (
+                unsigned char   byte_count
+                );
+
+    void    SubmitMouseColors
+                (
+                unsigned char   num_zones,
+                RGBColor *      color_data
+                );
+
+    void    SubmitMousematColors
+            (
+            unsigned char   num_zones,
+            RGBColor *      color_data
+            );
+};

Controllers/CorsairPeripheralController/CorsairPeripheralControllerDetect.cpp

@@ -0,0 +1,137 @@
+#include "CorsairPeripheralController.h"
+#include "RGBController.h"
+#include "RGBController_CorsairPeripheral.h"
+#include <vector>
+#include <hidapi/hidapi.h>
+
+/*-----------------------------------------------------*\
+| Corsair vendor ID                                     |
+\*-----------------------------------------------------*/
+#define CORSAIR_VID                     0x1B1C
+
+/*-----------------------------------------------------*\
+| Keyboard product IDs                                  |
+|   List taken from ckb-next                            |
+|   Non-RGB keyboards were omitted from this list       |
+\*-----------------------------------------------------*/
+#define CORSAIR_K55_RGB_PID             0x1B3D
+
+#define CORSAIR_K65_RGB_PID             0x1B17
+#define CORSAIR_K65_LUX_RGB_PID         0x1B37
+#define CORSAIR_K65_RGB_RAPIDFIRE_PID   0x1B39
+
+#define CORSAIR_K68_RGB                 0x1B4F
+
+#define CORSAIR_K70_RGB_PID             0x1B13
+#define CORSAIR_K70_LUX_RGB_PID         0x1B33
+#define CORSAIR_K70_RGB_RAPIDFIRE_PID   0x1B38
+#define CORSAIR_K70_RGB_MK2_PID         0x1B38
+#define CORSAIR_K70_RGB_MK2_SE_PID      0x1B6B
+#define CORSAIR_K70_RGB_MK2_LP_PID      0x1B55
+
+#define CORSAIR_K95_RGB_PID             0x1B11
+#define CORSAIR_K95_PLATINUM_PID        0x1B2D
+
+#define CORSAIR_STRAFE_PID              0x1B20
+#define CORSAIR_STRAFE_MK2_PID          0x1B48
+
+/*-----------------------------------------------------*\
+| Mouse product IDs                                     |
+|   List taken from ckb-next                            |
+\*-----------------------------------------------------*/
+#define CORSAIR_M65_PRO_PID             0x1B2E
+#define CORSAIR_M65_RGB_ELITE_PID       0x1B5A
+
+/*-----------------------------------------------------*\
+| Mousepad product IDs                                  |
+|   List taken from ckb-next                            |
+\*-----------------------------------------------------*/
+#define CORSAIR_MM800_RGB_POLARIS_PID   0x1B3B
+
+typedef struct
+{
+    unsigned short  usb_vid;
+    unsigned short  usb_pid;
+    unsigned char   usb_interface;
+    const char *    name;
+} corsair_node_device;
+
+#define CORSAIR_NUM_DEVICES (sizeof(device_list) / sizeof(device_list[ 0 ]))
+
+static const corsair_node_device device_list[] =
+{
+    /*-----------------------------------------------------------------------------------------------------*\
+    | Keyboards                                                                                             |
+    \*-----------------------------------------------------------------------------------------------------*/
+    { CORSAIR_VID,          CORSAIR_K68_RGB,                    1,      "Corsair K68 RGB"                   },
+    { CORSAIR_VID,          CORSAIR_K70_RGB_PID,                1,      "Corsair K70 RGB"                   },
+    { CORSAIR_VID,          CORSAIR_K70_LUX_RGB_PID,            1,      "Corsair K70 LUX RGB"               },
+    { CORSAIR_VID,          CORSAIR_K70_RGB_RAPIDFIRE_PID,      1,      "Corsair K70 RGB RAPIDFIRE"         },
+    { CORSAIR_VID,          CORSAIR_K70_RGB_MK2_PID,            1,      "Corsair K70 RGB MK.2"              },
+    { CORSAIR_VID,          CORSAIR_K70_RGB_MK2_SE_PID,         1,      "Corsair K70 RGB MK.2 SE"           },
+    { CORSAIR_VID,          CORSAIR_K70_RGB_MK2_LP_PID,         1,      "Corsair K70 RGB MK.2 Low Profile"  },
+    { CORSAIR_VID,          CORSAIR_K95_RGB_PID,                1,      "Corsair K95 RGB"                   },
+    { CORSAIR_VID,          CORSAIR_K95_PLATINUM_PID,           1,      "Corsair K95 RGB PLATINUM"          },
+    /*-----------------------------------------------------------------------------------------------------*\
+    | Mice                                                                                                  |
+    \*-----------------------------------------------------------------------------------------------------*/
+    { CORSAIR_VID,          CORSAIR_M65_PRO_PID,                1,      "Corsair M65 PRO"                   },
+    { CORSAIR_VID,          CORSAIR_M65_RGB_ELITE_PID,          1,      "Corsair M65 RGB Elite"             },
+    /*-----------------------------------------------------------------------------------------------------*\
+    | Mousemats                                                                                             |
+    \*-----------------------------------------------------------------------------------------------------*/
+    { CORSAIR_VID,          CORSAIR_MM800_RGB_POLARIS_PID,      0,      "Corsair MM800 RGB Polaris"         }
+};
+
+/******************************************************************************************\
+*                                                                                          *
+*   DetectCorsairPeripheralControllers                                                     *
+*                                                                                          *
+*       Tests the USB address to see if a Corsair RGB Keyboard controller exists there.    *
+*                                                                                          *
+\******************************************************************************************/
+
+void DetectCorsairPeripheralControllers(std::vector<RGBController*>& rgb_controllers)
+{
+    hid_device_info* info;
+    hid_device* dev;
+
+    hid_init();
+
+    for(std::size_t device_idx = 0; device_idx < CORSAIR_NUM_DEVICES; device_idx++)
+    {
+        dev = NULL;
+
+        info = hid_enumerate(device_list[device_idx].usb_vid, device_list[device_idx].usb_pid);
+
+        //Look for Corsair RGB Peripheral
+        while(info)
+        {
+            if((info->vendor_id == device_list[device_idx].usb_vid)
+            &&(info->product_id == device_list[device_idx].usb_pid)
+            &&(info->interface_number == device_list[device_idx].usb_interface))
+            {
+                dev = hid_open_path(info->path);
+                break;
+            }
+            else
+            {
+                info = info->next;
+            }
+        }
+
+        if( dev )
+        {
+            CorsairPeripheralController* controller = new CorsairPeripheralController(dev);
+
+            if(controller->GetDeviceType() != DEVICE_TYPE_UNKNOWN)
+            {
+                RGBController_CorsairPeripheral* rgb_controller = new RGBController_CorsairPeripheral(controller);
+
+                rgb_controller->name = device_list[device_idx].name;
+                
+                rgb_controllers.push_back(rgb_controller);
+            }
+        }
+    }
+}

Controllers/CorsairProController/CorsairProControllerDetect.cpp

@@ -1,127 +0,0 @@
-#include "CorsairProController.h"
-#include "RGBController.h"
-#include "RGBController_CorsairPro.h"
-#include "i2c_smbus.h"
-#include <vector>
-#include <stdio.h>
-#include <stdlib.h>
-
-/******************************************************************************************\
-*                                                                                          *
-*   TestForCorsairProController                                                            *
-*                                                                                          *
-*       Tests the given address to see if a Corsair Pro controller exists there.           *
-*                                                                                          *
-\******************************************************************************************/
-
-bool TestForCorsairProController(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, 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)
-        {
-            pass = false;
-        }
-
-        res = bus->i2c_smbus_read_byte_data(address, 0x44);
-
-        if (res != 0x03)
-        {
-            pass = false;
-        }
-    }
-
-    return(pass);
-
-}   /* TestForCorsairProController() */
-
-/******************************************************************************************\
-*                                                                                          *
-*   DetectCorsairProControllers                                                            *
-*                                                                                          *
-*       Detect Corsair Pro controllers on the enumerated I2C busses.                       *
-*                                                                                          *
-*           bus - pointer to i2c_smbus_interface where Aura device is connected            *
-*           dev - I2C address of Aura device                                               *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectCorsairProControllers(std::vector<i2c_smbus_interface*> &busses, std::vector<RGBController*> &rgb_controllers)
-{
-    CorsairProController* new_corsair_pro;
-    RGBController_CorsairPro* new_controller;
-
-    for (unsigned int bus = 0; bus < busses.size(); bus++)
-    {
-        // Check for Corsair controller at 0x58
-        if (TestForCorsairProController(busses[bus], 0x58))
-        {
-            new_corsair_pro = new CorsairProController(busses[bus], 0x58);
-            new_controller = new RGBController_CorsairPro(new_corsair_pro);
-            rgb_controllers.push_back(new_controller);
-        }
-
-        // Check for Corsair controller at 0x59
-        if (TestForCorsairProController(busses[bus], 0x59))
-        {
-            new_corsair_pro = new CorsairProController(busses[bus], 0x59);
-            new_controller = new RGBController_CorsairPro(new_corsair_pro);
-            rgb_controllers.push_back(new_controller);
-        }
-
-        // Check for Corsair controller at 0x5A
-        if (TestForCorsairProController(busses[bus], 0x5A))
-        {
-            new_corsair_pro = new CorsairProController(busses[bus], 0x5A);
-            new_controller = new RGBController_CorsairPro(new_corsair_pro);
-            rgb_controllers.push_back(new_controller);
-        }
-
-        // Check for Corsair controller at 0x5B
-        if (TestForCorsairProController(busses[bus], 0x5B))
-        {
-            new_corsair_pro = new CorsairProController(busses[bus], 0x5B);
-            new_controller = new RGBController_CorsairPro(new_corsair_pro);
-            rgb_controllers.push_back(new_controller);
-        }
-
-        // Check for Corsair controller at 0x5C
-        if (TestForCorsairProController(busses[bus], 0x5C))
-        {
-            new_corsair_pro = new CorsairProController(busses[bus], 0x5C);
-            new_controller = new RGBController_CorsairPro(new_corsair_pro);
-            rgb_controllers.push_back(new_controller);
-        }
-
-        // Check for Corsair controller at 0x5D
-        if (TestForCorsairProController(busses[bus], 0x5D))
-        {
-            new_corsair_pro = new CorsairProController(busses[bus], 0x5D);
-            new_controller = new RGBController_CorsairPro(new_corsair_pro);
-            rgb_controllers.push_back(new_controller);
-        }
-    }
-
-}   /* DetectCorsairProControllers() */

Controllers/CorsairVengeanceController/CorsairVengeanceController.cpp

@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  CorsairController.h                      |
+|  CorsairVengeanceController.h             |
 |                                           |
 |  Driver for Corsair Vengeance RGB RAM     |
 |  lighting controller                      |
@@ -7,10 +7,10 @@
 |  Adam Honse (CalcProgrammer1) 3/8/2019    |
 \*-----------------------------------------*/
 
-#include "CorsairController.h"
+#include "CorsairVengeanceController.h"
 #include <cstring>
 
-CorsairController::CorsairController(i2c_smbus_interface* bus, corsair_dev_id dev)
+CorsairVengeanceController::CorsairVengeanceController(i2c_smbus_interface* bus, corsair_dev_id dev)
 {
     this->bus = bus;
     this->dev = dev;
@@ -19,22 +19,32 @@ CorsairController::CorsairController(i2c_smbus_interface* bus, corsair_dev_id de
     led_count = 1;
 }
 
-CorsairController::~CorsairController()
+CorsairVengeanceController::~CorsairVengeanceController()
 {
 
 }
 
-char * CorsairController::GetDeviceName()
+std::string CorsairVengeanceController::GetDeviceName()
 {
     return(device_name);
 }
 
-unsigned int CorsairController::GetLEDCount()
+std::string CorsairVengeanceController::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 CorsairVengeanceController::GetLEDCount()
 {
     return(led_count);
 }
 
-void CorsairController::SetAllColors(unsigned char red, unsigned char green, unsigned char blue)
+void CorsairVengeanceController::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 CorsairVengeanceController::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/CorsairVengeanceController/CorsairVengeanceController.h

@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  CorsairController.h                      |
+|  CorsairVengeanceController.h             |
 |                                           |
 |  Definitions and types for Corsair        |
 |  Vengeance RGB RAM lighting controller    |
@@ -7,6 +7,7 @@
 |  Adam Honse (CalcProgrammer1) 3/8/2019    |
 \*-----------------------------------------*/
 
+#include <string>
 #include "i2c_smbus.h"
 
 #pragma once
@@ -32,22 +33,22 @@ enum
     CORSAIR_NUMBER_MODES                            /* Number of Corsair modes              */
 };
 
-class CorsairController
+class CorsairVengeanceController
 {
 public:
-    CorsairController(i2c_smbus_interface* bus, corsair_dev_id dev);
-    ~CorsairController();
+    CorsairVengeanceController(i2c_smbus_interface* bus, corsair_dev_id dev);
+    ~CorsairVengeanceController();
 
-    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/CorsairVengeanceController/CorsairVengeanceControllerDetect.cpp

@@ -1,6 +1,6 @@
-#include "CorsairController.h"
+#include "CorsairVengeanceController.h"
 #include "RGBController.h"
-#include "RGBController_Corsair.h"
+#include "RGBController_CorsairVengeance.h"
 #include "i2c_smbus.h"
 #include <vector>
 #include <stdio.h>
@@ -8,13 +8,13 @@
 
 /******************************************************************************************\
 *                                                                                          *
-*   TestForCorsairController                                                               *
+*   TestForCorsairVengeanceController                                                      *
 *                                                                                          *
 *       Tests the given address to see if a Corsair controller exists there.               *
 *                                                                                          *
 \******************************************************************************************/
 
-bool TestForCorsairController(i2c_smbus_interface* bus, unsigned char address)
+bool TestForCorsairVengeanceController(i2c_smbus_interface* bus, unsigned char address)
 {
     bool pass = false;
 
@@ -37,11 +37,11 @@ bool TestForCorsairController(i2c_smbus_interface* bus, unsigned char address)
 
     return(pass);
 
-}   /* TestForCorsairController() */
+}   /* TestForCorsairVengeanceController() */
 
 /******************************************************************************************\
 *                                                                                          *
-*   DetectCorsairControllers                                                               *
+*   DetectCorsairVengeanceControllers                                                      *
 *                                                                                          *
 *       Detect Corsair controllers on the enumerated I2C busses.                           *
 *                                                                                          *
@@ -50,60 +50,76 @@ bool TestForCorsairController(i2c_smbus_interface* bus, unsigned char address)
 *                                                                                          *
 \******************************************************************************************/
 
-void DetectCorsairControllers(std::vector<i2c_smbus_interface*> &busses, std::vector<RGBController*> &rgb_controllers)
+void DetectCorsairVengeanceControllers(std::vector<i2c_smbus_interface*> &busses, std::vector<RGBController*> &rgb_controllers)
 {
-    CorsairController* new_corsair;
-    RGBController_Corsair* new_controller;
+    CorsairVengeanceController* new_corsair;
+    RGBController_CorsairVengeance* new_controller;
 
     for (unsigned int bus = 0; bus < busses.size(); bus++)
     {
         // Check for Corsair controller at 0x58
-        if (TestForCorsairController(busses[bus], 0x58))
+        if (TestForCorsairVengeanceController(busses[bus], 0x58))
         {
-            new_corsair = new CorsairController(busses[bus], 0x58);
-            new_controller = new RGBController_Corsair(new_corsair);
+            new_corsair = new CorsairVengeanceController(busses[bus], 0x58);
+            new_controller = new RGBController_CorsairVengeance(new_corsair);
             rgb_controllers.push_back(new_controller);
         }
 
         // Check for Corsair controller at 0x59
-        if (TestForCorsairController(busses[bus], 0x59))
+        if (TestForCorsairVengeanceController(busses[bus], 0x59))
         {
-            new_corsair = new CorsairController(busses[bus], 0x59);
-            new_controller = new RGBController_Corsair(new_corsair);
+            new_corsair = new CorsairVengeanceController(busses[bus], 0x59);
+            new_controller = new RGBController_CorsairVengeance(new_corsair);
             rgb_controllers.push_back(new_controller);
         }
 
         // Check for Corsair controller at 0x5A
-        if (TestForCorsairController(busses[bus], 0x5A))
+        if (TestForCorsairVengeanceController(busses[bus], 0x5A))
         {
-            new_corsair = new CorsairController(busses[bus], 0x5A);
-            new_controller = new RGBController_Corsair(new_corsair);
+            new_corsair = new CorsairVengeanceController(busses[bus], 0x5A);
+            new_controller = new RGBController_CorsairVengeance(new_corsair);
             rgb_controllers.push_back(new_controller);
         }
 
         // Check for Corsair controller at 0x5B
-        if (TestForCorsairController(busses[bus], 0x5B))
+        if (TestForCorsairVengeanceController(busses[bus], 0x5B))
         {
-            new_corsair = new CorsairController(busses[bus], 0x5B);
-            new_controller = new RGBController_Corsair(new_corsair);
+            new_corsair = new CorsairVengeanceController(busses[bus], 0x5B);
+            new_controller = new RGBController_CorsairVengeance(new_corsair);
             rgb_controllers.push_back(new_controller);
         }
 
         // Check for Corsair controller at 0x5C
-        if (TestForCorsairController(busses[bus], 0x5C))
+        if (TestForCorsairVengeanceController(busses[bus], 0x5C))
         {
-            new_corsair = new CorsairController(busses[bus], 0x5C);
-            new_controller = new RGBController_Corsair(new_corsair);
+            new_corsair = new CorsairVengeanceController(busses[bus], 0x5C);
+            new_controller = new RGBController_CorsairVengeance(new_corsair);
             rgb_controllers.push_back(new_controller);
         }
 
         // Check for Corsair controller at 0x5D
-        if (TestForCorsairController(busses[bus], 0x5D))
+        if (TestForCorsairVengeanceController(busses[bus], 0x5D))
         {
-            new_corsair = new CorsairController(busses[bus], 0x5D);
-            new_controller = new RGBController_Corsair(new_corsair);
+            new_corsair = new CorsairVengeanceController(busses[bus], 0x5D);
+            new_controller = new RGBController_CorsairVengeance(new_corsair);
+            rgb_controllers.push_back(new_controller);
+        }
+
+        // Check for Corsair controller at 0x5E
+        if (TestForCorsairVengeanceController(busses[bus], 0x5E))
+        {
+            new_corsair = new CorsairVengeanceController(busses[bus], 0x5E);
+            new_controller = new RGBController_CorsairVengeance(new_corsair);
+            rgb_controllers.push_back(new_controller);
+        }
+
+        // Check for Corsair controller at 0x5F
+        if (TestForCorsairVengeanceController(busses[bus], 0x5F))
+        {
+            new_corsair = new CorsairVengeanceController(busses[bus], 0x5F);
+            new_controller = new RGBController_CorsairVengeance(new_corsair);
             rgb_controllers.push_back(new_controller);
         }
     }
 
-}   /* DetectCorsairControllers() */
+}   /* DetectCorsairVengeanceControllers() */

Controllers/CorsairVengeanceProController/CorsairVengeanceProController.cpp

@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  CorsairProController.cpp                 |
+|  CorsairVengeanceProController.cpp        |
 |                                           |
 |  Definitions and types for Corsair        |
 |  Vengeance Pro RGB RAM lighting controller|
@@ -7,7 +7,7 @@
 |  Adam Honse (CalcProgrammer1) 6/30/2019   |
 \*-----------------------------------------*/
 
-#include "CorsairProController.h"
+#include "CorsairVengeanceProController.h"
 #include <cstring>
 
 #ifdef WIN32
@@ -15,13 +15,13 @@
 #else
 #include <unistd.h>
 
-void Sleep(unsigned int milliseconds)
+static void Sleep(unsigned int milliseconds)
 {
     usleep(1000 * milliseconds);
 }
 #endif
 
-CorsairProController::CorsairProController(i2c_smbus_interface* bus, corsair_dev_id dev)
+CorsairVengeanceProController::CorsairVengeanceProController(i2c_smbus_interface* bus, corsair_dev_id dev)
 {
     this->bus = bus;
     this->dev = dev;
@@ -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;
@@ -37,24 +39,39 @@ CorsairProController::CorsairProController(i2c_smbus_interface* bus, corsair_dev
     }
 }
 
-CorsairProController::~CorsairProController()
+CorsairVengeanceProController::~CorsairVengeanceProController()
 {
 
 }
 
-char* CorsairProController::GetDeviceName()
+std::string CorsairVengeanceProController::GetDeviceName()
 {
     return(device_name);
 }
 
-unsigned int CorsairProController::GetLEDCount()
+std::string CorsairVengeanceProController::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 CorsairVengeanceProController::GetLEDCount()
 {
     return(led_count);
 }
 
-void CorsairProController::SetAllColors(unsigned char red, unsigned char green, unsigned char blue)
+unsigned char CorsairVengeanceProController::GetEffect()
 {
-    for (int i = 0; i < led_count; i++)
+    return(effect_mode);
+}
+
+void CorsairVengeanceProController::SetAllColors(unsigned char red, unsigned char green, unsigned char blue)
+{
+    for (unsigned int i = 0; i < led_count; i++)
     {
         led_red[i]      = red;
         led_green[i]    = green;
@@ -62,14 +79,14 @@ void CorsairProController::SetAllColors(unsigned char red, unsigned char green,
     }
 }
 
-void CorsairProController::SetLEDColor(unsigned int led, unsigned char red, unsigned char green, unsigned char blue)
+void CorsairVengeanceProController::SetLEDColor(unsigned int led, unsigned char red, unsigned char green, unsigned char blue)
 {
     led_red[led]    = red;
     led_green[led]  = green;
     led_blue[led]   = blue;
 }
 
-void CorsairProController::ApplyColors()
+void CorsairVengeanceProController::ApplyColors()
 {
     bus->i2c_smbus_write_byte_data(dev, 0x26, 0x02);
     Sleep(1);
@@ -87,24 +104,47 @@ void CorsairProController::ApplyColors()
     bus->i2c_smbus_write_byte_data(dev, 0x82, 0x02);
 }
 
-void CorsairProController::SetEffect(unsigned char mode)
+void CorsairVengeanceProController::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,12 +159,7 @@ void CorsairProController::SetEffect(unsigned char mode)
     WaitReady();
 }
 
-void CorsairProController::SetCustom()
-{
-    SetEffect(CORSAIR_PRO_MODE_STATIC);
-}
-
-bool CorsairProController::WaitReady()
+bool CorsairVengeanceProController::WaitReady()
 {
     int i = 0;
     while (bus->i2c_smbus_read_byte_data(dev, 0x41) != 0x00)
@@ -134,4 +169,4 @@ bool CorsairProController::WaitReady()
     }
 
     return false;
-}
+}

Controllers/CorsairVengeanceProController/CorsairVengeanceProController.h

@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  CorsairProController.h                   |
+|  CorsairVengeanceProController.h          |
 |                                           |
 |  Definitions and types for Corsair        |
 |  Vengeance Pro RGB RAM lighting controller|
@@ -7,6 +7,7 @@
 |  Adam Honse (CalcProgrammer1) 6/30/2019   |
 \*-----------------------------------------*/
 
+#include <string>
 #include "i2c_smbus.h"
 
 #pragma once
@@ -59,16 +60,27 @@ enum
     CORSAIR_PRO_DIRECTION_HORIZONTAL    = 0x03,     /* Horizontal direction                 */
 };
 
-class CorsairProController
+class CorsairVengeanceProController
 {
 public:
-    CorsairProController(i2c_smbus_interface* bus, corsair_dev_id dev);
-    ~CorsairProController();
+    CorsairVengeanceProController(i2c_smbus_interface* bus, corsair_dev_id dev);
+    ~CorsairVengeanceProController();
 
-    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/CorsairVengeanceProController/CorsairVengeanceProControllerDetect.cpp

@@ -0,0 +1,142 @@
+#include "CorsairVengeanceProController.h"
+#include "RGBController.h"
+#include "RGBController_CorsairVengeancePro.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
+
+/******************************************************************************************\
+*                                                                                          *
+*   TestForCorsairVengeanceProController                                                   *
+*                                                                                          *
+*       Tests the given address to see if a Corsair Pro controller exists there.           *
+*                                                                                          *
+\******************************************************************************************/
+
+bool TestForCorsairVengeanceProController(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, 0x43);
+
+        if (res != 0x1C)
+        {
+            pass = false;
+        }
+
+        res = bus->i2c_smbus_read_byte_data(address, 0x44);
+
+        if (!((res == 0x03) || (res == 0x04)))
+        {
+            pass = false;
+        }
+    }
+
+    Sleep(10);
+    
+    return(pass);
+
+}   /* TestForCorsairVengeanceProController() */
+
+/******************************************************************************************\
+*                                                                                          *
+*   DetectCorsairVengeanceProControllers                                                   *
+*                                                                                          *
+*       Detect Corsair Vengeance Pro controllers on the enumerated I2C busses.             *
+*                                                                                          *
+*           bus - pointer to i2c_smbus_interface where Aura device is connected            *
+*           dev - I2C address of Aura device                                               *
+*                                                                                          *
+\******************************************************************************************/
+
+void DetectCorsairVengeanceProControllers(std::vector<i2c_smbus_interface*> &busses, std::vector<RGBController*> &rgb_controllers)
+{
+    CorsairVengeanceProController* new_corsair_pro;
+    RGBController_CorsairVengeancePro* new_controller;
+
+    for (unsigned int bus = 0; bus < busses.size(); bus++)
+    {
+        // Check for Corsair controller at 0x58
+        if (TestForCorsairVengeanceProController(busses[bus], 0x58))
+        {
+            new_corsair_pro = new CorsairVengeanceProController(busses[bus], 0x58);
+            new_controller = new RGBController_CorsairVengeancePro(new_corsair_pro);
+            rgb_controllers.push_back(new_controller);
+        }
+
+        // Check for Corsair controller at 0x59
+        if (TestForCorsairVengeanceProController(busses[bus], 0x59))
+        {
+            new_corsair_pro = new CorsairVengeanceProController(busses[bus], 0x59);
+            new_controller = new RGBController_CorsairVengeancePro(new_corsair_pro);
+            rgb_controllers.push_back(new_controller);
+        }
+
+        // Check for Corsair controller at 0x5A
+        if (TestForCorsairVengeanceProController(busses[bus], 0x5A))
+        {
+            new_corsair_pro = new CorsairVengeanceProController(busses[bus], 0x5A);
+            new_controller = new RGBController_CorsairVengeancePro(new_corsair_pro);
+            rgb_controllers.push_back(new_controller);
+        }
+
+        // Check for Corsair controller at 0x5B
+        if (TestForCorsairVengeanceProController(busses[bus], 0x5B))
+        {
+            new_corsair_pro = new CorsairVengeanceProController(busses[bus], 0x5B);
+            new_controller = new RGBController_CorsairVengeancePro(new_corsair_pro);
+            rgb_controllers.push_back(new_controller);
+        }
+
+        // Check for Corsair controller at 0x5C
+        if (TestForCorsairVengeanceProController(busses[bus], 0x5C))
+        {
+            new_corsair_pro = new CorsairVengeanceProController(busses[bus], 0x5C);
+            new_controller = new RGBController_CorsairVengeancePro(new_corsair_pro);
+            rgb_controllers.push_back(new_controller);
+        }
+
+        // Check for Corsair controller at 0x5D
+        if (TestForCorsairVengeanceProController(busses[bus], 0x5D))
+        {
+            new_corsair_pro = new CorsairVengeanceProController(busses[bus], 0x5D);
+            new_controller = new RGBController_CorsairVengeancePro(new_corsair_pro);
+            rgb_controllers.push_back(new_controller);
+        }
+
+        // Check for Corsair controller at 0x5E
+        if (TestForCorsairVengeanceProController(busses[bus], 0x5E))
+        {
+            new_corsair_pro = new CorsairVengeanceProController(busses[bus], 0x5E);
+            new_controller = new RGBController_CorsairVengeancePro(new_corsair_pro);
+            rgb_controllers.push_back(new_controller);
+        }
+
+        // Check for Corsair controller at 0x5F
+        if (TestForCorsairVengeanceProController(busses[bus], 0x5F))
+        {
+            new_corsair_pro = new CorsairVengeanceProController(busses[bus], 0x5F);
+            new_controller = new RGBController_CorsairVengeancePro(new_corsair_pro);
+            rgb_controllers.push_back(new_controller);
+        }
+    }
+
+}   /* DetectCorsairVengeanceProControllers() */

Controllers/CrucialController/CrucialController.cpp

@@ -0,0 +1,150 @@
+/*-----------------------------------------*\
+|  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::SetAllColorsEffect(RGBColor* colors)
+{
+    for(int led_idx = 0; led_idx < 8; led_idx++)
+    {
+        unsigned char red = RGBGetRValue(colors[led_idx]);
+        unsigned char grn = RGBGetGValue(colors[led_idx]);
+        unsigned char blu = RGBGetBValue(colors[led_idx]);
+        SendEffectColor(led_idx, red, grn, blu);
+    }
+}
+
+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);
+
+}
+
+void CrucialController::SendEffectColor
+    (
+    unsigned int    led_idx,
+    unsigned int    red,
+    unsigned int    green,
+    unsigned int    blue
+    )
+{
+    CrucialRegisterWrite(0x82E9, (1 << led_idx));
+    CrucialRegisterWrite(0x82EA, 0x00);
+    CrucialRegisterWrite(0x82EB, 0x00);
+    CrucialRegisterWrite(0x82EC, 0x00);
+    CrucialRegisterWrite(0x82ED, red);
+    CrucialRegisterWrite(0x82EE, green);
+    CrucialRegisterWrite(0x82EF, blue);
+    CrucialRegisterWrite(0x82F0, 0x01);
+}

Controllers/CrucialController/CrucialController.h

@@ -0,0 +1,70 @@
+/*-----------------------------------------*\
+|  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          SetAllColorsEffect(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            SendEffectColor
+                        (
+                        unsigned int    led_idx,
+                        unsigned int    red,
+                        unsigned int    green,
+                        unsigned int    blue
+                        );
+    
+    void            SendDirectColors(RGBColor* color_buf);
+    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,286 @@
+/*---------------------------------------------------------*\
+|  Processing Code for NZXT Hue 2                           |
+|                                                           |
+|  Adam Honse ([email protected]), 12/29/2016       |
+\*---------------------------------------------------------*/
+
+#include "Hue2Controller.h"
+
+#include <fstream>
+#include <iostream>
+#include <string>
+#include <cstring>
+
+Hue2Controller::Hue2Controller(libusb_device_handle* dev_handle)
+{
+    dev = dev_handle;
+
+    GetStripsOnChannel(HUE_2_CHANNEL_1);
+}
+
+Hue2Controller::~Hue2Controller()
+{
+
+}
+
+unsigned int Hue2Controller::GetStripsOnChannel(unsigned int /*channel*/)
+{
+    unsigned int ret_val = 0;
+
+    unsigned char usb_buf[] =
+    {
+        0x20, 0x03, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00
+    };
+    int             actual = 0;
+
+    libusb_interrupt_transfer(dev, 0x01, usb_buf, 64, &actual, 0);
+    libusb_interrupt_transfer(dev, 0x81, usb_buf, 64, &actual, 0);
+
+    for(int chan = 0; chan < 4; chan++)
+    {
+        unsigned int start = 0x0F + (6 * chan);
+        unsigned int num_leds_on_channel = 0;
+        for(int dev = 0; dev < 6; dev++)
+        {
+            switch(usb_buf[start + dev])
+            {
+            case 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::SetChannelEffect
+    (
+    unsigned char   channel,
+    unsigned char   mode,
+    unsigned char   speed,
+    bool            direction,
+    RGBColor *      colors,
+    unsigned int    num_colors
+    )
+{
+    unsigned char color_data[24];
+
+    /*-----------------------------------------------------*\
+    | Fill in color data (up to 8 colors)                  |
+    \*-----------------------------------------------------*/
+    for (std::size_t idx = 0; idx < num_colors; idx++)
+    {
+        int pixel_idx = idx * 3;
+        RGBColor color = colors[idx];
+        color_data[pixel_idx + 0x00] = RGBGetGValue(color);
+        color_data[pixel_idx + 0x01] = RGBGetRValue(color);
+        color_data[pixel_idx + 0x02] = RGBGetBValue(color);
+    }
+
+    /*-----------------------------------------------------*\
+    | Send effect packet                                    |
+    \*-----------------------------------------------------*/
+    SendEffect(channel, mode, speed, direction, num_colors, &color_data[0]);
+}
+
+void Hue2Controller::SetChannelLEDs
+    (
+    unsigned char   channel,
+    RGBColor *      colors,
+    unsigned int    num_colors
+    )
+{
+    unsigned char color_data[120];
+
+    /*-----------------------------------------------------*\
+    | Fill in color data (up to 40 colors)                  |
+    \*-----------------------------------------------------*/
+    for (std::size_t idx = 0; idx < num_colors; idx++)
+    {
+        int pixel_idx = idx * 3;
+        RGBColor color = colors[idx];
+        color_data[pixel_idx + 0x00] = RGBGetGValue(color);
+        color_data[pixel_idx + 0x01] = RGBGetRValue(color);
+        color_data[pixel_idx + 0x02] = RGBGetBValue(color);
+    }
+
+    /*-----------------------------------------------------*\
+    | Send first group of color data                        |
+    \*-----------------------------------------------------*/
+    SendDirect(channel, 0, 20, &color_data[0]);
+
+    /*-----------------------------------------------------*\
+    | Send second group of color data if necessary          |
+    \*-----------------------------------------------------*/
+    if(num_colors > 20)
+    {
+        SendDirect(channel, 1, 20, &color_data[60]);
+    }
+
+    /*-----------------------------------------------------*\
+    | Send apply packet                                     |
+    \*-----------------------------------------------------*/
+    SendApply(channel);
+}
+
+/*-------------------------------------------------------------------------------------------------*\
+| Private packet sending functions.                                                                 |
+\*-------------------------------------------------------------------------------------------------*/
+
+void Hue2Controller::SendApply
+    (
+    unsigned char   channel
+    )
+{
+    int             actual;
+    unsigned char   usb_buf[64];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up Apply packet                                   |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]   = 0x22;
+    usb_buf[0x01]   = 0xA0;
+    usb_buf[0x02]   = (unsigned char)(1 << channel);
+    usb_buf[0x04]   = 0x01;
+    usb_buf[0x07]   = 0x28;
+    usb_buf[0x0A]   = 0x80;
+    usb_buf[0x0C]   = 0x32;
+    usb_buf[0x0F]   = 0x01;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    libusb_interrupt_transfer(dev, 0x01, usb_buf, 64, &actual, 0);
+    libusb_interrupt_transfer(dev, 0x81, usb_buf, 64, &actual, 0);
+}
+
+void Hue2Controller::SendDirect
+    (
+    unsigned char   channel,
+    unsigned char   group,
+    unsigned char   color_count,
+    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]   = 0x22;
+    usb_buf[0x01]   = 0x10 | group;
+    usb_buf[0x02]   = (unsigned char)(1 << channel);
+    usb_buf[0x03]   = 0x00;
+
+    /*-----------------------------------------------------*\
+    | Copy in color data bytes                              |
+    \*-----------------------------------------------------*/
+    memcpy(&usb_buf[0x04], color_data, color_count * 3);
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    libusb_interrupt_transfer(dev, 0x01, usb_buf, 64, &actual, 0);
+    libusb_interrupt_transfer(dev, 0x81, usb_buf, 64, &actual, 0);
+}
+
+void Hue2Controller::SendEffect
+    (
+    unsigned char   channel,
+    unsigned char   mode,
+    unsigned char   speed,
+    bool            direction,
+    unsigned char   color_count,
+    unsigned char*  color_data
+    )
+{
+    int             actual;
+    unsigned char   usb_buf[64];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up Effect packet                                  |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]   = 0x28;
+    usb_buf[0x01]   = 0x03;
+    usb_buf[0x02]   = (unsigned char)(1 << channel);
+    usb_buf[0x03]   = 0x28;
+
+    /*-----------------------------------------------------*\
+    | Set mode in USB packet                                |
+    \*-----------------------------------------------------*/
+    usb_buf[0x04]   = mode;
+
+    /*-----------------------------------------------------*\
+    | Set speed in USB packet                               |
+    \*-----------------------------------------------------*/
+    usb_buf[0x05]   = speed;
+
+    /*-----------------------------------------------------*\
+    | Set direction in USB packet                           |
+    \*-----------------------------------------------------*/
+    usb_buf[0x06]   = direction ? 0x01 : 0x00;
+
+    /*-----------------------------------------------------*\
+    | Set color count in USB packet                         |
+    \*-----------------------------------------------------*/
+    usb_buf[0x08]   = color_count;
+
+    /*-----------------------------------------------------*\
+    | Copy in color data bytes                              |
+    \*-----------------------------------------------------*/
+    memcpy(&usb_buf[0x0A], color_data, color_count * 3);
+
+    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,108 @@
+/*---------------------------------------------------------*\
+|  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            SetChannelEffect
+                        (
+                        unsigned char   channel,
+                        unsigned char   mode,
+                        unsigned char   speed,
+                        bool            direction,
+                        RGBColor *      colors,
+                        unsigned int    num_colors
+                        );
+
+    void            SetChannelLEDs
+                        (
+                        unsigned char   channel,
+                        RGBColor *      colors,
+                        unsigned int    num_colors
+                        );
+    
+    unsigned int    channel_leds[HUE_2_NUM_CHANNELS];
+
+private:
+    libusb_device_handle*   dev;
+
+    void            SendApply
+                        (
+                        unsigned char   channel
+                        );
+
+    void            SendDirect
+                        (
+                        unsigned char   channel,
+                        unsigned char   group,
+                        unsigned char   color_count,
+                        unsigned char*  color_data
+                        );
+
+    void            SendEffect
+                        (
+                        unsigned char   channel,
+                        unsigned char   mode,
+                        unsigned char   speed,
+                        bool            direction,
+                        unsigned char   color_count,
+                        unsigned char*  color_data
+                        );
+};

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,240 @@
 #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()
 {
 
 }
 
-
 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;
+    channel_leds[HUE_PLUS_CHANNEL_1_IDX] = GetLEDsOnChannel(HUE_PLUS_CHANNEL_1);
+    channel_leds[HUE_PLUS_CHANNEL_2_IDX] = GetLEDsOnChannel(HUE_PLUS_CHANNEL_2);
+}
 
-    source = strtok_s(ledstring, ",", &next);
+char* HuePlusController::GetLocation()
+{
+    return(port_name);
+}
 
-    //Check for selected channel 0=both, 1= Ch.1, 2= Ch.2
-    if (strlen(next))
+unsigned int HuePlusController::GetLEDsOnChannel(unsigned int channel)
+{
+    unsigned char serial_buf[] =
     {
-        channels = strtok_s(next, ",", &next);
+        0x8D, 0x00, 0x00, 0x00, 0x00
+    };
+
+    unsigned int ret_val = 0;
+
+    /*-----------------------------------------------------*\
+    | 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)
+        {
+            ret_val = serial_buf[4] * 8;
+        }
+        else
+        {
+            ret_val += serial_buf[4] * 10;
+        }
     }
 
-    switch (atoi(channels))
+    return(ret_val);
+}
+
+void HuePlusController::SetChannelEffect
+    (
+    unsigned char   channel,
+    unsigned char   mode,
+    unsigned char   speed,
+    bool            direction,
+    RGBColor *      colors,
+    unsigned int    num_colors
+    )
+{
+    unsigned char color_data[120];
+
+    /*-----------------------------------------------------*\
+    | If mode requires no colors, send packet               |
+    \*-----------------------------------------------------*/
+    if(num_colors == 0)
     {
-        case 0:
-            channel = 0x00;
-            break;
-
-        case 1:
-            channel = 0x01;
-            break;
-
-        case 2:
-            channel = 0x02;
-            break;
+        /*-----------------------------------------------------*\
+        | Send mode without color data                          |
+        \*-----------------------------------------------------*/
+        SendPacket(channel, mode, direction, 0, speed, 0, NULL);
     }
-
-    //Check for the number of LEDs, sets the corresponding variable with the counter for the fans
-    if (strlen(next))
+    /*-----------------------------------------------------*\
+    | If mode requires indexed colors, send color index     |
+    | packets for each mode color                           |
+    \*-----------------------------------------------------*/
+    else if(num_colors <= 8)
     {
-        numleds = strtok_s(next, ",", &next);
+        for(std::size_t color_idx = 0; color_idx < num_colors; color_idx++)
+        {
+            /*-----------------------------------------------------*\
+            | Fill in color data (40 entries per color)             |
+            \*-----------------------------------------------------*/
+            for (std::size_t idx = 0; idx < 40; idx++)
+            {
+                int pixel_idx = idx * 3;
+                RGBColor color = colors[color_idx];
+                color_data[pixel_idx + 0x00] = RGBGetGValue(color);
+                color_data[pixel_idx + 0x01] = RGBGetRValue(color);
+                color_data[pixel_idx + 0x02] = RGBGetBValue(color);
+            }
+
+            /*-----------------------------------------------------*\
+            | Send mode and color data                              |
+            \*-----------------------------------------------------*/
+            SendPacket(channel, mode, direction, color_idx, speed, 40, &color_data[0]);
+        }
     }
-
-    switch (atoi(numleds) / 8)
+    /*-----------------------------------------------------*\
+    | If mode requires per-LED colors, fill colors array    |
+    \*-----------------------------------------------------*/
+    else
     {
-        case 1:
-            fans = 0x00;
-            break;
+        /*-----------------------------------------------------*\
+        | Fill in color data (up to 40 colors)                  |
+        \*-----------------------------------------------------*/
+        for (std::size_t idx = 0; idx < num_colors; idx++)
+        {
+            int pixel_idx = idx * 3;
+            RGBColor color = colors[idx];
+            color_data[pixel_idx + 0x00] = RGBGetGValue(color);
+            color_data[pixel_idx + 0x01] = RGBGetRValue(color);
+            color_data[pixel_idx + 0x02] = RGBGetBValue(color);
+        }
 
-        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);
+        /*-----------------------------------------------------*\
+        | Send mode and color data                              |
+        \*-----------------------------------------------------*/
+        SendPacket(channel, mode, direction, 0, speed, num_colors, &color_data[0]);
     }
 }
 
-char* HuePlusController::GetLEDString()
+void HuePlusController::SetChannelLEDs
+    (
+    unsigned char   channel,
+    RGBColor *      colors,
+    unsigned int    num_colors
+    )
 {
-    return(led_string);
-}
+    unsigned char color_data[120];
 
-void HuePlusController::SetLEDs(std::vector<RGBColor> colors)
-{
-    if (serialport != NULL)
+    /*-----------------------------------------------------*\
+    | Fill in color data (up to 40 colors)                  |
+    \*-----------------------------------------------------*/
+    for (std::size_t idx = 0; idx < num_colors; idx++)
     {
-        unsigned char *serial_buf;
-
-        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;
-
-        for (int i = 5; i < hueSize; i++)
-        {
-            //clearing the buf otherwise sometimes strange things are written to the COM Port
-            serial_buf[i] = 0x00;
-        }
-
-        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_flush_tx();
-
-        delete[] serial_buf;
+        int pixel_idx = idx * 3;
+        RGBColor color = colors[idx];
+        color_data[pixel_idx + 0x00] = RGBGetGValue(color);
+        color_data[pixel_idx + 0x01] = RGBGetRValue(color);
+        color_data[pixel_idx + 0x02] = RGBGetBValue(color);
     }
 
-}
+    /*-----------------------------------------------------*\
+    | Send color data                                       |
+    \*-----------------------------------------------------*/
+    SendPacket(channel, HUE_PLUS_MODE_FIXED, false, 0, 0, num_colors, &color_data[0]);
+}
+
+/*-------------------------------------------------------------------------------------------------*\
+| Private packet sending functions.                                                                 |
+\*-------------------------------------------------------------------------------------------------*/
+
+void HuePlusController::SendPacket
+    (
+    unsigned char   channel,
+    unsigned char   mode,
+    bool            direction,
+    unsigned char   color_idx,
+    unsigned char   speed,
+    unsigned char   color_count,
+    unsigned char*  color_data
+    )
+{
+    unsigned char serial_buf[125];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(serial_buf, 0x00, sizeof(serial_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up Direct packet                                  |
+    \*-----------------------------------------------------*/
+    serial_buf[0x00]    = 0x4B;
+
+    /*-----------------------------------------------------*\
+    | Set channel in serial packet                          |
+    \*-----------------------------------------------------*/
+    serial_buf[0x01]   = channel + 1;
+
+    /*-----------------------------------------------------*\
+    | Set mode in serial packet                             |
+    \*-----------------------------------------------------*/
+    serial_buf[0x02]   = mode;
+
+    /*-----------------------------------------------------*\
+    | Set options bitfield in serial packet                 |
+    \*-----------------------------------------------------*/
+    serial_buf[0x03]   = 0;
+    serial_buf[0x03]   |= direction ? ( 1 << 4 ) : 0;
+
+    /*-----------------------------------------------------*\
+    | Set color index and speed in serial packet            |
+    \*-----------------------------------------------------*/
+    serial_buf[0x04]   = ( color_idx << 5 ) | speed;
+
+    /*-----------------------------------------------------*\
+    | Copy in color data bytes                              |
+    \*-----------------------------------------------------*/
+    memcpy(&serial_buf[0x05], color_data, color_count * 3);
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    serialport->serial_write((char *)serial_buf, HUE_PLUS_PACKET_SIZE);
+    serialport->serial_flush_tx();
+
+    /*-----------------------------------------------------*\
+    | Delay to allow Hue+ device to ready for next packet   |
+    \*-----------------------------------------------------*/
+    Sleep(20);
+}

Controllers/HuePlusController/HuePlusController.h

@@ -22,27 +22,91 @@
 #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);
 
-    int num_leds;
+    void            SetChannelEffect
+                        (
+                        unsigned char   channel,
+                        unsigned char   mode,
+                        unsigned char   speed,
+                        bool            direction,
+                        RGBColor *      colors,
+                        unsigned int    num_colors
+                        );
+
+    void            SetChannelLEDs
+                        (
+                        unsigned char   channel,
+                        RGBColor *      colors,
+                        unsigned int    num_colors
+                        );
+
+    unsigned int    channel_leds[HUE_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;
+    void            SendPacket
+                        (
+                        unsigned char   channel,
+                        unsigned char   mode,
+                        bool            direction,
+                        unsigned char   color_idx,
+                        unsigned char   speed,
+                        unsigned char   color_count,
+                        unsigned char*  color_data
+                        );
 };
 
 #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

@@ -1,102 +0,0 @@
-/*-----------------------------------------*\
-|  HyperXController.cpp                     |
-|                                           |
-|  Definitions and types for HyperX Predator|
-|  RGB RAM lighting controller              |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 6/29/2019   |
-\*-----------------------------------------*/
-
-#include "HyperXController.h"
-#include <cstring>
-
-HyperXController::HyperXController(i2c_smbus_interface* bus, hyperx_dev_id dev)
-{
-    this->bus = bus;
-    this->dev = dev;
-
-    strcpy(device_name, "HyperX Predator RGB");
-    led_count = 1;
-}
-
-HyperXController::~HyperXController()
-{
-
-}
-
-char* HyperXController::GetDeviceName()
-{
-    return(device_name);
-}
-
-unsigned int HyperXController::GetLEDCount()
-{
-    return(led_count);
-}
-
-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);
-
-    bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_APPLY, 0x02);
-    bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_APPLY, 0x03);
-}
-
-void HyperXController::SetLEDColor(unsigned int led, 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);
-
-    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)
-{
-    bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_APPLY, 0x01);
-
-    switch (mode)
-    {
-    case HYPERX_MODE_STATIC:
-        bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_MODE2, HYPERX_MODE2_STATIC);
-        break;
-
-    case HYPERX_MODE_RAINBOW:
-        bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_MODE1, HYPERX_MODE1_RAINBOW);
-        break;
-
-    case HYPERX_MODE_COMET:
-        bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_MODE2, HYPERX_MODE2_COMET);
-        break;
-
-    case HYPERX_MODE_HEARTBEAT:
-        bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_MODE2, HYPERX_MODE2_HEARTBEAT);
-        break;
-
-    case HYPERX_MODE_CYCLE:
-        bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_MODE1, HYPERX_MODE1_CYCLE);
-        break;
-
-    case HYPERX_MODE_BREATHING:
-        bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_MODE2, HYPERX_MODE2_BREATHING);
-        break;
-
-    case HYPERX_MODE_BOUNCE:
-        bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_MODE2, HYPERX_MODE2_BOUNCE);
-        break;
-
-    case HYPERX_MODE_BLINK:
-        bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_MODE2, HYPERX_MODE2_BLINK);
-        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

@@ -1,76 +0,0 @@
-/*-----------------------------------------*\
-|  HyperXController.h                       |
-|                                           |
-|  Definitions and types for HyperX Predator|
-|  RGB RAM lighting controller              |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 6/29/2019   |
-\*-----------------------------------------*/
-
-#include "i2c_smbus.h"
-
-#pragma once
-
-typedef unsigned char	hyperx_dev_id;
-typedef unsigned short	hyperx_register;
-
-enum
-{
-    HYPERX_REG_BRIGHTNESS               = 0xDD,     /* Brightness control register (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                  */
-};
-
-enum
-{
-    HYPERX_MODE1_RAINBOW                = 0x05,     /* Mode 1 rainbow effect                */
-    HYPERX_MODE1_CYCLE                  = 0x04,     /* Mode 1 cycle effect                  */
-};
-
-enum
-{
-    HYPERX_MODE2_BOUNCE                 = 0x02,     /* Mode 2 bounce effect                 */
-    HYPERX_MODE2_BREATHING              = 0x03,     /* Mode 2 breathing effect              */
-    HYPERX_MODE2_BLINK                  = 0x06,     /* Mode 2 blink effect                  */
-    HYPERX_MODE2_HEARTBEAT              = 0x07,     /* Mode 2 heartbeat effect              */
-    HYPERX_MODE2_COMET                  = 0x08,     /* Mode 2 comet effect                  */
-    HYPERX_MODE2_STATIC                 = 0x09,     /* Mode 2 static effect                 */
-};
-
-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_NUMBER_MODES                             /* Number of HyperX modes               */
-};
-
-
-class HyperXController
-{
-public:
-    HyperXController(i2c_smbus_interface* bus, hyperx_dev_id dev);
-    ~HyperXController();
-
-    char* GetDeviceName();
-    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);
-
-private:
-    char                    device_name[32];
-    unsigned int            led_count;
-    i2c_smbus_interface*    bus;
-    hyperx_dev_id           dev;
-};

Controllers/HyperXDRAMController/HyperXDRAMController.cpp

@@ -0,0 +1,287 @@
+/*-----------------------------------------*\
+|  HyperXDRAMController.cpp                 |
+|                                           |
+|  Definitions and types for HyperX Predator|
+|  and Fury RGB RAM lighting controller     |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 6/29/2019   |
+\*-----------------------------------------*/
+
+#include "HyperXDRAMController.h"
+#include <cstring>
+
+HyperXDRAMController::HyperXDRAMController(i2c_smbus_interface* bus, hyperx_dev_id dev, unsigned char slots)
+{
+    this->bus   = bus;
+    this->dev   = dev;
+    slots_valid = slots;
+
+    strcpy(device_name, "HyperX Predator RGB");
+
+    led_count = 0;
+
+    for(int i = 0; i < 8; i++)
+    {
+        if((slots_valid & (1 << i)) != 0)
+        {
+            led_count += 5;
+        }
+    }
+
+    mode = HYPERX_MODE_DIRECT;
+}
+
+HyperXDRAMController::~HyperXDRAMController()
+{
+
+}
+
+std::string HyperXDRAMController::GetDeviceName()
+{
+    return(device_name);
+}
+
+std::string HyperXDRAMController::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 HyperXDRAMController::GetLEDCount()
+{
+    return(led_count);
+}
+
+unsigned int HyperXDRAMController::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 HyperXDRAMController::GetMode()
+{
+    return(mode);
+}
+
+void HyperXDRAMController::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 HyperXDRAMController::SetAllColors(unsigned char red, unsigned char green, unsigned char blue)
+{
+    bus->i2c_smbus_write_byte_data(dev, HYPERX_REG_APPLY, 0x01);
+
+    /*-----------------------------------------------------*\
+    | 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);
+}
+
+void HyperXDRAMController::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, 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 HyperXDRAMController::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 HyperXDRAMController::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_MODE_CUSTOM, HYPERX_MODE2_STATIC);
+        break;
+
+    case HYPERX_MODE_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, 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, 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_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, 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, 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, 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/HyperXDRAMController/HyperXDRAMController.h

@@ -0,0 +1,222 @@
+/*-----------------------------------------*\
+|  HyperXDRAMController.h                   |
+|                                           |
+|  Definitions and types for HyperX Predator|
+|  and Fury RGB RAM lighting controller     |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 6/29/2019   |
+\*-----------------------------------------*/
+
+#include <string>
+#include "i2c_smbus.h"
+
+#pragma once
+
+typedef unsigned char	hyperx_dev_id;
+typedef unsigned short	hyperx_register;
+
+enum
+{
+    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_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
+{
+    HYPERX_MODE1_RAINBOW                = 0x05,     /* Mode 1 rainbow effect                */
+    HYPERX_MODE1_CYCLE                  = 0x04,     /* Mode 1 cycle effect                  */
+};
+
+enum
+{
+    HYPERX_MODE2_BOUNCE                 = 0x02,     /* Mode 2 bounce effect                 */
+    HYPERX_MODE2_BREATHING              = 0x03,     /* Mode 2 breathing effect              */
+    HYPERX_MODE2_BLINK                  = 0x06,     /* Mode 2 blink effect                  */
+    HYPERX_MODE2_HEARTBEAT              = 0x07,     /* Mode 2 heartbeat effect              */
+    HYPERX_MODE2_COMET                  = 0x08,     /* Mode 2 comet effect                  */
+    HYPERX_MODE2_STATIC                 = 0x09,     /* Mode 2 static effect                 */
+};
+
+enum
+{
+    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 HyperXDRAMController
+{
+public:
+    HyperXDRAMController(i2c_smbus_interface* bus, hyperx_dev_id dev, unsigned char slots);
+    ~HyperXDRAMController();
+
+    std::string     GetDeviceName();
+    std::string     GetDeviceLocation();
+    unsigned int    GetLEDCount();
+    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/HyperXDRAMController/HyperXDRAMControllerDetect.cpp

@@ -0,0 +1,104 @@
+#include "HyperXDRAMController.h"
+#include "RGBController.h"
+#include "RGBController_HyperXDRAM.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
+
+/******************************************************************************************\
+*                                                                                          *
+*   TestForHyperXDRAMController                                                            *
+*                                                                                          *
+*       Tests the given address to see if a HyperX controller exists there.                *
+*                                                                                          *
+\******************************************************************************************/
+
+bool TestForHyperXDRAMController(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)
+            {
+                pass = false;
+            }
+        }
+    }
+
+    return(pass);
+
+}   /* TestForHyperXDRAMController() */
+
+
+/******************************************************************************************\
+*                                                                                          *
+*   DetectHyperXDRAMControllers                                                            *
+*                                                                                          *
+*       Detect HyperX DRAM controllers on the enumerated I2C busses.                       *
+*                                                                                          *
+*           bus - pointer to i2c_smbus_interface where Aura device is connected            *
+*           dev - I2C address of Aura device                                               *
+*                                                                                          *
+\******************************************************************************************/
+
+void DetectHyperXDRAMControllers(std::vector<i2c_smbus_interface*> &busses, std::vector<RGBController*> &rgb_controllers)
+{
+    HyperXDRAMController* new_hyperx;
+    RGBController_HyperXDRAM* new_controller;
+
+    for (unsigned int bus = 0; bus < busses.size(); bus++)
+    {
+        unsigned char slots_valid = 0x00;
+
+        // Check for HyperX controller at 0x27
+        if (TestForHyperXDRAMController(busses[bus], 0x27))
+        {
+            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 HyperXDRAMController(busses[bus], 0x27, slots_valid);
+                new_controller = new RGBController_HyperXDRAM(new_hyperx);
+                rgb_controllers.push_back(new_controller);
+            }
+        }
+    }
+
+}   /* DetectHyperXDRAMControllers() */

Controllers/HyperXKeyboardController/HyperXKeyboardController.cpp

@@ -0,0 +1,489 @@
+/*-----------------------------------------*\
+|  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(5);
+
+    SendDirect
+        (
+        HYPERX_COLOR_CHANNEL_GREEN,
+        grn_color_data
+        );
+
+    Sleep(5);
+
+    SendDirect
+        (
+        HYPERX_COLOR_CHANNEL_BLUE,
+        blu_color_data
+        );
+
+    Sleep(5);
+
+    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
+        );
+
+    Sleep(5);
+
+    SendColor
+        (
+        0x01,
+        HYPERX_COLOR_CHANNEL_GREEN,
+        grn_color_data
+        );
+
+    Sleep(5);
+
+    SendColor
+        (
+        0x01,
+        HYPERX_COLOR_CHANNEL_BLUE,
+        blu_color_data
+        );
+
+    Sleep(5);
+    
+    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/LEDStripController/LEDStripControllerDetect.cpp

@@ -37,12 +37,12 @@ void DetectLEDStripControllers(std::vector<RGBController*> &rgb_controllers)
 #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");
+    strcat(filename, "\\ledstrip.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());
-    strcat(filename, "/settings.txt");
+    strcat(filename, "/ledstrip.txt");
 #endif
 
     //Open settings file

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/MSIMysticLightController/MSIMysticLightController.cpp

@@ -0,0 +1,394 @@
+/*-----------------------------------------*\
+|  MSIMysticLightController.cpp             |
+|                                           |
+|  Driver for MSI Mystic Light USB          |
+|  lighting controller                      |
+|                                           |
+|  T-bond 3/4/2020                          |
+\*-----------------------------------------*/
+
+#include "MSIMysticLightController.h"
+#include <algorithm>
+#include <array>
+#include <bitset>
+
+MSIMysticLightController::MSIMysticLightController(hid_device* handle, const char *path)
+{
+    dev = handle;
+
+    if(dev)
+    {
+        loc = path;
+
+        ReadName();
+        ReadSerial();
+        ReadFwVersion();
+        ReadSettings();
+    }
+}
+
+MSIMysticLightController::~MSIMysticLightController()
+{
+    if(dev)
+    {
+        hid_close(dev);
+    }
+}
+
+unsigned int MSIMysticLightController::GetZoneMinLedCount(ZONE /*zone*/)
+{
+    return 1u;
+}
+
+unsigned int MSIMysticLightController::GetZoneMaxLedCount(ZONE zone)
+{
+    switch (zone)
+    {
+    case J_RAINBOW_1:
+    case J_RAINBOW_2:
+    case J_CORSAIR:
+        return 4u; // TODO: It can be different by zone and by mobo
+    default:
+        return 1u;
+    }
+}
+
+unsigned int MSIMysticLightController::GetZoneLedCount(ZONE zone)
+{
+    RainbowZoneData *requestedZone = GetRainbowZoneData(zone);
+
+    if (!requestedZone)
+    {
+        return GetZoneMaxLedCount(zone);
+    }
+
+    return requestedZone->cycle_or_led_num;
+}
+
+void MSIMysticLightController::SetZoneLedCount(ZONE zone, unsigned int led_count)
+{
+    RainbowZoneData *requestedZone = GetRainbowZoneData(zone);
+
+    if (!requestedZone)
+    {
+        return;
+    }
+
+    led_count = std::min(GetZoneMaxLedCount(zone), std::max(GetZoneMinLedCount(zone), led_count));
+    requestedZone->cycle_or_led_num = led_count;
+}
+
+void MSIMysticLightController::SetMode(ZONE zone, EFFECT mode, SPEED speed, BRIGHTNESS brightness, bool rainbow_color)
+{
+    ZoneData* zoneData = GetZoneData(zone);
+    if(!zoneData)
+    {
+        return;
+    }
+
+    zoneData->effect = mode;
+    zoneData->speedAndBrightnessFlags = (zoneData->speedAndBrightnessFlags & 128u) | brightness << 2u | speed;
+    zoneData->colorFlags = BitSet(zoneData->colorFlags, !rainbow_color, 7u);
+}
+
+std::string MSIMysticLightController::GetDeviceName()
+{
+    return name;
+}
+
+std::string MSIMysticLightController::GetFWVersion()
+{
+    return std::string("AP/LD ").append(version_APROM).append(" / ").append(version_LDROM);
+}
+
+std::string MSIMysticLightController::GetDeviceLocation()
+{
+    return loc;
+}
+
+std::string MSIMysticLightController::GetSerial()
+{
+    return chip_id;
+}
+
+bool MSIMysticLightController::ReadSettings()
+{
+    return hid_get_feature_report(dev, reinterpret_cast<unsigned char *>(&data), sizeof data) == sizeof data;
+}
+
+bool MSIMysticLightController::Update()
+{
+    return hid_send_feature_report(dev, reinterpret_cast<unsigned char *>(&data), sizeof data) == sizeof data;
+}
+
+void MSIMysticLightController::SaveOnUpdate(bool save)
+{
+    data.save_data = save;
+}
+
+void MSIMysticLightController::SetZoneColor(ZONE zone, unsigned char r1, unsigned char g1, unsigned char b1, unsigned char r2, unsigned char g2, unsigned char b2)
+{
+    ZoneData* zoneData = GetZoneData(zone);
+    if(!zoneData)
+    {
+        return;
+    }
+
+    zoneData->color.R = r1;
+    zoneData->color.G = g1;
+    zoneData->color.B = b1;
+
+    zoneData->color2.R = r2;
+    zoneData->color2.G = g2;
+    zoneData->color2.B = b2;
+}
+
+std::pair<Color, Color> MSIMysticLightController::GetZoneColor(ZONE zone)
+{
+    ZoneData *zoneData = GetZoneData(zone);
+    if (!zoneData)
+    {
+        return std::make_pair(Color{}, Color{});
+    }
+
+    return std::make_pair(Color{
+                              zoneData->color.R,
+                              zoneData->color.G,
+                              zoneData->color.B},
+                          Color{zoneData->color2.R, zoneData->color2.G, zoneData->color2.B});
+}
+
+ZoneData *MSIMysticLightController::GetZoneData(ZONE zone)
+{
+    switch (zone)
+    {
+    case J_RGB_1:
+        return &data.j_rgb_1;
+    case J_RGB_2:
+        return &data.j_rgb_2;
+    case J_RAINBOW_1:
+        return &data.j_rainbow_1;
+    case J_RAINBOW_2:
+        return &data.j_rainbow_2;
+    case J_PIPE_1:
+        return &data.j_pipe_1;
+    case J_PIPE_2:
+        return &data.j_pipe_2;
+    case ON_BOARD_LED:
+        return &data.on_board_led;
+    case ON_BOARD_LED_1:
+        return &data.on_board_led_1;
+    case ON_BOARD_LED_2:
+        return &data.on_board_led_2;
+    case ON_BOARD_LED_3:
+        return &data.on_board_led_3;
+    case ON_BOARD_LED_4:
+        return &data.on_board_led_4;
+    case ON_BOARD_LED_5:
+        return &data.on_board_led_5;
+    case ON_BOARD_LED_6:
+        return &data.on_board_led_6;
+    case ON_BOARD_LED_7:
+        return &data.on_board_led_7;
+    case ON_BOARD_LED_8:
+        return &data.on_board_led_8;
+    case ON_BOARD_LED_9:
+        return &data.on_board_led_9;
+    case J_CORSAIR_OUTERLL120:
+        return &data.j_corsair_outerll120;
+    default:
+    case J_CORSAIR:
+        break;
+    }
+
+    return nullptr;
+}
+
+RainbowZoneData *MSIMysticLightController::GetRainbowZoneData(ZONE zone)
+{
+    switch (zone)
+    {
+    case J_RAINBOW_1:
+        return &data.j_rainbow_1;
+    case J_RAINBOW_2:
+        return &data.j_rainbow_2;
+    case J_CORSAIR:
+    default:
+        return nullptr;
+    }
+}
+
+bool MSIMysticLightController::ReadFwVersion()
+{
+    // First read the APROM
+    // Checksum also available at report ID 180, with highCheksum stored at index 8, and low at 9
+    int num = 1;
+    unsigned char request[64] = {1, 176};
+    unsigned char response[64];
+
+    std::fill_n(request + 2, sizeof request - 2, 204);
+    num &= hid_write(dev, request, 64);
+    num &= hid_read(dev, response, 64);
+
+    unsigned char highValue = response[2] >> 4;
+    unsigned char lowValue  = response[2] & 15;
+
+    version_APROM = std::to_string(static_cast<int>(highValue)).append(".").append(std::to_string(static_cast<int>(lowValue)));
+
+    // Now read the LDROM
+    // Checksum also available at report ID 184, with highCheksum stored at index 8, and low at 9
+    request[1] = 182u;
+    num &= hid_write(dev, request, 64);
+    num &= hid_read(dev, response, 64);
+
+    highValue = response[2] >> 4u;
+    lowValue = response[2] & 15u;
+
+    version_LDROM = std::to_string(static_cast<int>(highValue)).append(".").append(std::to_string(static_cast<int>(lowValue)));
+
+    return num == 1;
+}
+
+void MSIMysticLightController::ReadSerial()
+{
+    wchar_t serial[256];
+    hid_get_serial_number_string(dev, serial, 256);
+    std::wstring wserial = std::wstring(serial);
+    chip_id = std::string(wserial.begin(), wserial.end());
+}
+
+void MSIMysticLightController::ReadName()
+{
+    wchar_t tname[256];
+    hid_get_manufacturer_string(dev, tname, 256);
+    std::wstring wname = std::wstring(tname);
+    name = std::string(wname.begin(), wname.end());
+
+    hid_get_product_string(dev, tname, 256);
+    wname = std::wstring(tname);
+    name.append(" ").append(std::string(wname.begin(), wname.end()));
+}
+
+void MSIMysticLightController::SetDeviceSettings(bool is_fan, FAN_TYPE fan_type,
+                                                 unsigned char corsair_device_quantity,
+                                                 bool is_LL120Outer_individual) 
+{
+    // If is_fan false, it is a stripe
+    CorsairZoneData &settingsZone = data.j_corsair;
+    settingsZone.fan_flags = (settingsZone.fan_flags & 128u) | fan_type << 1u | is_fan;
+    settingsZone.corsair_quantity = corsair_device_quantity << 2u;
+    settingsZone.is_individual = BitSet(settingsZone.is_individual, is_LL120Outer_individual, 0u);
+}
+
+bool MSIMysticLightController::SetVolume(unsigned char main, unsigned char left, unsigned char right)
+{
+    unsigned char packet[64];
+    std::fill_n(packet, sizeof packet, 204u);
+
+    if(main > 100u)
+    {
+        main = 100u;
+    }
+
+    if(left > 100u)
+    {
+        left = 100u;
+    }
+
+    if(right > 100u)
+    {
+        right = 100u;
+    }
+
+    packet[0] = 1u;
+    packet[1] = 192u;
+    packet[3] = main;
+    packet[4] = left;
+    packet[5] = right;
+
+    return hid_write(dev, packet, sizeof packet);
+}
+
+void MSIMysticLightController::SetBoardSyncSettings(bool onboard_sync, bool combine_JRGB, bool combine_JPIPE1,
+                                                    bool combine_JPIPE2, bool combine_JRAINBOW1, bool combine_JRAINBOW2,
+                                                    bool combine_crossair)
+{
+    ZoneData &syncZone = data.on_board_led;
+    syncZone.colorFlags = BitSet(syncZone.colorFlags, onboard_sync, 0u);
+    syncZone.colorFlags = BitSet(syncZone.colorFlags, combine_JRAINBOW1, 1u);
+    syncZone.colorFlags = BitSet(syncZone.colorFlags, combine_JRAINBOW2, 2u);
+    syncZone.colorFlags = BitSet(syncZone.colorFlags, combine_crossair, 3u);
+    syncZone.colorFlags = BitSet(syncZone.colorFlags, combine_JPIPE1, 4u);
+    syncZone.colorFlags = BitSet(syncZone.colorFlags, combine_JPIPE2, 5u);
+
+    syncZone.speedAndBrightnessFlags = BitSet(syncZone.speedAndBrightnessFlags, combine_JRGB, 7u);
+}
+
+void MSIMysticLightController::GetMode(ZONE zone, EFFECT &mode, SPEED &speed, BRIGHTNESS &brightness, bool &rainbow_color) 
+{
+    ZoneData *zoneData = GetZoneData(zone);
+    if (!zoneData)
+    {
+        return;
+    }
+
+    mode = static_cast<EFFECT>(zoneData->effect);
+    speed = static_cast<SPEED>(zoneData->speedAndBrightnessFlags & 3u);
+    brightness = static_cast<BRIGHTNESS>((zoneData->speedAndBrightnessFlags >> 2u) & 31u);
+    rainbow_color = (zoneData->colorFlags & 128u) >> 7u;
+}
+
+unsigned char MSIMysticLightController::BitSet(unsigned char value, bool bit, unsigned int position)
+{
+    return static_cast<unsigned char>(std::bitset<8>(value).set(position, bit).to_ulong());
+}
+
+void MSIMysticLightController::SetCycleCount(ZONE zone, unsigned char cycle_num)
+{
+    RainbowZoneData *requestedZone = GetRainbowZoneData(zone);
+
+    if (!requestedZone)
+    {
+        return;
+    }
+
+    requestedZone->cycle_or_led_num = cycle_num;
+}
+
+unsigned char MSIMysticLightController::GetCycleCount(ZONE zone)
+{
+    RainbowZoneData *requestedZone = GetRainbowZoneData(zone);
+
+    if (!requestedZone)
+    {
+        return 0;
+    }
+
+    return requestedZone->cycle_or_led_num;
+}
+
+void MSIMysticLightController::GetBoardSyncSettings(bool &onboard_sync, bool &combine_JRGB, bool &combine_JPIPE1,
+                                                    bool &combine_JPIPE2, bool &combine_JRAINBOW1,
+                                                    bool &combine_JRAINBOW2, bool &combine_crossair)
+{
+    ZoneData &syncZone = data.on_board_led;
+    onboard_sync = syncZone.colorFlags & 1u;
+    combine_JRAINBOW1 = syncZone.colorFlags >> 1u & 1u;
+    combine_JRAINBOW2 = syncZone.colorFlags >> 1u & 1u;
+    combine_crossair = syncZone.colorFlags >> 3u & 1u;
+    combine_JPIPE1 = syncZone.colorFlags >> 4u & 1u;
+    combine_JPIPE2 = syncZone.colorFlags >> 5u & 1u;
+
+    combine_JRGB = (syncZone.speedAndBrightnessFlags & 128u) >> 7u;
+}
+
+void MSIMysticLightController::GetDeviceSettings(bool &stripe_or_fan, FAN_TYPE &fan_type,
+                                                 unsigned char &corsair_device_quantity,
+                                                 bool &is_LL120Outer_individual)
+{
+    CorsairZoneData &settingsZone = data.j_corsair;
+    stripe_or_fan = settingsZone.fan_flags & 1u;
+    fan_type = static_cast<FAN_TYPE >((settingsZone.fan_flags & 14u) >> 1u);
+    corsair_device_quantity = (settingsZone.corsair_quantity & 252u) >> 2u;
+    is_LL120Outer_individual = settingsZone.is_individual & 1u;
+}

Controllers/MSIMysticLightController/MSIMysticLightController.h

@@ -0,0 +1,228 @@
+/*-----------------------------------------*\
+|  MSIMysticLightController.h               |
+|                                           |
+|  Definitions and types for MSI Mystic     |
+|   Light USB lighting controllers          |
+|                                           |
+|  T-bond 3/4/2020                          |
+\*-----------------------------------------*/
+
+#include "RGBController.h"
+#include <cstring>
+#include <hidapi/hidapi.h>
+#include <limits>
+
+#pragma once
+
+enum ZONE
+{
+    J_RGB_1 = 1,
+    J_RGB_2 = 174,
+    J_PIPE_1 = 11,
+    J_PIPE_2 = 21,
+    J_RAINBOW_1 = 31,
+    J_RAINBOW_2 = 42,
+    J_CORSAIR = 53,
+    J_CORSAIR_OUTERLL120 = 64,
+    ON_BOARD_LED = 74,
+    ON_BOARD_LED_1 = 84,
+    ON_BOARD_LED_2 = 94,
+    ON_BOARD_LED_3 = 104,
+    ON_BOARD_LED_4 = 114,
+    ON_BOARD_LED_5 = 124,
+    ON_BOARD_LED_6 = 134,
+    ON_BOARD_LED_7 = 144,
+    ON_BOARD_LED_8 = 154,
+    ON_BOARD_LED_9 = 164
+};
+
+struct ZoneDescription
+{
+    std::string name;
+    ZONE value;
+};
+
+enum EFFECT
+{
+    DISABLE,
+    STATIC,
+    BREATHING,
+    FLASHING,
+    DOUBLE_FLASHING,
+    LIGHTNING,
+    MSI_MARQUEE,
+    METEOR,
+    WATER_DROP,
+    MSI_RAINBOW,
+    POP,
+    RAP,
+    JAZZ,
+    PLAY,
+    MOVIE,
+    COLOR_RING,
+    PLANETARY,
+    DOUBLE_METEOR,
+    ENERGY,
+    BLINK,
+    CLOCK,
+    COLOR_PULSE,
+    COLOR_SHIFT,
+    COLOR_WAVE,
+    MARQUEE,
+    RAINBOW,
+    RAINBOW_WAVE,
+    VISOR,
+    JRAINBOW,
+    RAINBOW_FLASHING,
+    RAINBOW_DOUBLE_FLASHING,
+    RANDOM,
+    FAN_CONTROL,
+    DISABLE_2,
+    COLOR_RING_FLASHING,
+    COLOR_RING_DOUBLE_FLASHING,
+    STACK,
+    CORSAIR_QUE,
+    FIRE,
+    LAVA
+};
+
+enum SPEED
+{
+    LOW,
+    MEDIUM,
+    HIGH
+};
+
+enum FAN_TYPE
+{
+    SP,
+    HD,
+    LL
+};
+
+enum BRIGHTNESS
+{
+    OFF,
+    LEVEL_10,
+    LEVEL_20,
+    LEVEL_30,
+    LEVEL_40,
+    LEVEL_50,
+    LEVEL_60,
+    LEVEL_70,
+    LEVEL_80,
+    LEVEL_90,
+    LEVEL_100
+};
+
+struct Color
+{
+    unsigned char R;
+    unsigned char G;
+    unsigned char B;
+};
+
+struct CorsairZoneData
+{
+    unsigned char effect = EFFECT::STATIC;
+    Color color { std::numeric_limits<unsigned char>::max(), 0, 0 };
+    unsigned char fan_flags = 40;
+    unsigned char corsair_quantity;
+    unsigned char padding[3];
+
+    unsigned char is_individual = 0;
+};
+
+struct ZoneData
+{
+    unsigned char effect = EFFECT::STATIC;
+    Color color { std::numeric_limits<unsigned char>::max(), 0u, 0u };
+    unsigned char speedAndBrightnessFlags = 40u;
+    Color color2 { 0, std::numeric_limits<unsigned char>::max(), 0u };
+    unsigned char colorFlags = 128u;
+
+    const unsigned char padding = 0u;
+};
+
+struct RainbowZoneData : ZoneData
+{
+    unsigned char cycle_or_led_num = 20u;
+};
+
+struct FeaturePacket
+{
+    const unsigned char report_id = 82u; // Report ID
+    ZoneData j_rgb_1; // 1
+    ZoneData j_pipe_1; // 11
+    ZoneData j_pipe_2; // 21
+    RainbowZoneData j_rainbow_1; // 31
+    RainbowZoneData j_rainbow_2; // 42
+    CorsairZoneData j_corsair; // 53
+    ZoneData j_corsair_outerll120; // 64
+    ZoneData on_board_led; // 74
+    ZoneData on_board_led_1; // 84
+    ZoneData on_board_led_2; // 94
+    ZoneData on_board_led_3; // 104
+    ZoneData on_board_led_4; // 114
+    ZoneData on_board_led_5; // 124
+    ZoneData on_board_led_6; // 134
+    ZoneData on_board_led_7; // 144
+    ZoneData on_board_led_8; // 154
+    ZoneData on_board_led_9; // 164
+    ZoneData j_rgb_2; // 174
+
+    unsigned char save_data = 0u; // 184
+};
+
+
+class MSIMysticLightController
+{
+public:
+    MSIMysticLightController(hid_device* handle, const char *path);
+    ~MSIMysticLightController();
+
+    unsigned int    GetZoneMinLedCount(ZONE zone);
+    unsigned int    GetZoneMaxLedCount(ZONE zone);
+    unsigned int    GetZoneLedCount(ZONE zone);
+    void            SetZoneLedCount(ZONE zone, unsigned int led_count);
+
+    void            SetMode(ZONE zone, EFFECT mode, SPEED speed, BRIGHTNESS brightness, bool rainbow_color);
+    void            GetMode(ZONE zone, EFFECT &mode, SPEED &speed, BRIGHTNESS &brightness, bool &rainbow_color);
+    void            SetZoneColor(ZONE zone, unsigned char r1, unsigned char g1, unsigned char b1, unsigned char r2, unsigned char g2, unsigned char b2);
+    void            SetCycleCount(ZONE zone, unsigned char cycle_num);
+    unsigned char   GetCycleCount(ZONE zone);
+    std::pair<Color, Color>
+                    GetZoneColor(ZONE zone);
+    bool            Update();
+
+    void            SetDeviceSettings(bool stripe_or_fan, FAN_TYPE fan_type, unsigned char corsair_device_quantity, bool is_LL120Outer_individual);
+    void            GetDeviceSettings(bool &stripe_or_fan, FAN_TYPE &fan_type, unsigned char &corsair_device_quantity, bool &is_LL120Outer_individual);
+    bool            SetVolume(unsigned char main, unsigned char left, unsigned char right);
+    void            SetBoardSyncSettings(bool onboard_sync, bool combine_JRGB, bool combine_JPIPE1, bool combine_JPIPE2, bool combine_JRAINBOW1, bool combine_JRAINBOW2, bool combine_crossair);
+    void            GetBoardSyncSettings(bool &onboard_sync, bool &combine_JRGB, bool &combine_JPIPE1, bool &combine_JPIPE2, bool &combine_JRAINBOW1, bool &combine_JRAINBOW2, bool &combine_crossair);
+
+    std::string     GetDeviceName();
+    std::string     GetDeviceLocation();
+    std::string     GetFWVersion();
+    std::string     GetSerial();
+
+private:
+    bool            ReadSettings();
+    void            SaveOnUpdate(bool send);
+    bool            ReadFwVersion();
+    void            ReadSerial();
+    void            ReadName();
+    ZoneData*       GetZoneData(ZONE zone);
+    RainbowZoneData*
+                    GetRainbowZoneData(ZONE zone);
+    static unsigned char   BitSet(unsigned char value, bool bit, unsigned int position);
+
+    hid_device*             dev;
+    std::string             name;
+    std::string             loc;
+    std::string             version_APROM;
+    std::string             version_LDROM;
+    std::string             chip_id;
+
+    FeaturePacket data;
+};

Controllers/MSIMysticLightController/MSIMysticLightControllerDetect.cpp

@@ -0,0 +1,90 @@
+#include "MSIMysticLightController.h"
+#include "RGBController_MSIMysticLight.h"
+#include <algorithm>
+
+#define MSI_VID 0x1462
+
+constexpr unsigned short SupportedPIDs[41] =
+{
+    31847, // MS_7C67
+    31504, // MS_7B10
+    31879, // MS_7C87
+    31635, // MS_7B93
+    31796, // MS_7C34
+    31797, // MS_7C35
+    31798, // MS_7C36
+    31799, // MS_7C37
+    31810, // MS_7C42
+    31876, // MS_7C84
+    31636, // MS_7B94
+    31638, // MS_7B96
+    31833, // MS_7C59
+    31840, // MS_7C60
+    31856, // MS_7C70
+    31857, // MS_7C71
+    31859, // MS_7C73
+    31861, // MS_7C75
+    31862, // MS_7C76
+    31863, // MS_7C77
+    31865, // MS_7C79
+    31872, // MS_7C80
+    31896, // MS_7C98
+    31897, // MS_7C99
+    31873, // MS_7C81
+    31874, // MS_7C82
+    31875, // MS_7C83
+    31877, // MS_7C85
+    31878, // MS_7C86
+    31880, // MS_7C88
+    31881, // MS_7C89
+    17497, // MS_4459
+    16036, // MS_3EA4
+    36957, // MS_905D
+    31888, // MS_7C90
+    31889, // MS_7C91
+    31890, // MS_7C92
+    31892, // MS_7C94
+    31893, // MS_7C95
+    31894, // MS_7C96
+    31830  // MS_7C56
+};
+
+/******************************************************************************************\
+*                                                                                          *
+*   DetectMSIMysticLightControllers                                                        *
+*                                                                                          *
+*       Detect MSI Mystic Light devices that use NCT6775 RGB controllers                   *
+*                                                                                          *
+\******************************************************************************************/
+
+void DetectMSIMysticLightControllers(std::vector<RGBController*> &rgb_controllers)
+{
+    if(hid_init() < 0)
+    {
+        return;
+    }
+
+    hid_device_info * device_list = hid_enumerate(MSI_VID, 0);
+    if(!device_list)
+    {
+        return;
+    }
+
+    hid_device_info * device = device_list;
+    while(device)
+    {
+        if(std::find(std::begin(SupportedPIDs), std::end(SupportedPIDs), device->product_id) != std::end(SupportedPIDs))
+        {
+        hid_device * dev = hid_open_path(device->path);
+            if(dev)
+            {
+                MSIMysticLightController * controller = new MSIMysticLightController(dev, device_list->path);
+                RGBController_MSIMysticLight * rgb_controller = new RGBController_MSIMysticLight(controller);
+                rgb_controllers.push_back(rgb_controller);
+            }
+        }
+        device = device->next;
+    }
+
+    hid_free_enumeration(device_list);
+}

Controllers/MSIRGBController/MSIRGBController.cpp

@@ -0,0 +1,99 @@
+/*-----------------------------------------*\
+|  MSIRGBController.cpp                     |
+|                                           |
+|  Driver for MSI-RGB lighting controller   |
+|                                           |
+|  Logic adapted from:                      |
+|     https://github.com/nagisa/msi-rgb     |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 2/11/2020   |
+\*-----------------------------------------*/
+
+#include "MSIRGBController.h"
+#include "super_io.h"
+
+MSIRGBController::MSIRGBController(int sioaddr)
+{
+    msi_sioaddr = sioaddr;
+
+    /*-----------------------------------------------------*\
+    | This setup step isn't well documented                 |
+    | Without this, pulsing does not work                   |
+    \*-----------------------------------------------------*/
+    superio_outb(msi_sioaddr, SIO_REG_LOGDEV, 0x09);
+
+    int val_at_2c = superio_inb(msi_sioaddr, 0x2C);
+
+    val_at_2c &= 0b11110111;
+    val_at_2c |= 0b00010000;
+
+    superio_outb(msi_sioaddr, 0x2C, val_at_2c);
+    
+
+    /*-----------------------------------------------------*\
+    | Set logical device register to RGB controller         |
+    \*-----------------------------------------------------*/
+    superio_outb(msi_sioaddr, SIO_REG_LOGDEV, MSI_SIO_LOGDEV_RGB);
+
+    /*-----------------------------------------------------*\
+    | Test if RGB is enabled.  If it is not, enable it.     |
+    \*-----------------------------------------------------*/
+    int enable = superio_inb(msi_sioaddr, MSI_SIO_RGB_REG_ENABLE);
+
+    if((enable & MSI_SIO_RGB_ENABLE_MASK) != MSI_SIO_RGB_ENABLE_MASK)
+    {
+        superio_outb(msi_sioaddr, MSI_SIO_RGB_REG_ENABLE, MSI_SIO_RGB_ENABLE_MASK & (enable & !MSI_SIO_RGB_ENABLE_MASK));
+    }
+
+    /*-----------------------------------------------------*\
+    | Lighting enabled, no pulsing or blinking              |
+    \*-----------------------------------------------------*/
+    superio_outb(msi_sioaddr, MSI_SIO_RGB_REG_CFG_1, 0x00);
+
+    /*-----------------------------------------------------*\
+    | Lighting enabled, RGB non-inverted, header on         |
+    \*-----------------------------------------------------*/
+    superio_outb(msi_sioaddr, MSI_SIO_RGB_REG_CFG_3, 0xE2);
+}
+
+MSIRGBController::~MSIRGBController()
+{
+
+}
+
+void MSIRGBController::SetColor(unsigned char red, unsigned char green, unsigned char blue)
+{
+    /*-----------------------------------------------------*\
+    | The MSI RGB controller uses 4 bits per color rather   |
+    | than 8.  Shift the values by 4 so that the 4 most     |
+    | significant bits of each color are the new color value|
+    \*-----------------------------------------------------*/
+    red     = red >> 4;
+    green   = green >> 4;
+    blue    = blue >> 4;
+
+    /*-----------------------------------------------------*\
+    | Set logical device register to RGB controller         |
+    \*-----------------------------------------------------*/
+    superio_outb(msi_sioaddr, SIO_REG_LOGDEV, MSI_SIO_LOGDEV_RGB);
+
+    /*-----------------------------------------------------*\
+    | Write the colors to the color sequence registers      |
+    | Only static mode is supported right now - all colors  |
+    | are the same.                                         |
+    \*-----------------------------------------------------*/
+    superio_outb(msi_sioaddr, MSI_SIO_RGB_REG_RED_1_0, (red | (red << 4)));
+    superio_outb(msi_sioaddr, MSI_SIO_RGB_REG_RED_3_2, (red | (red << 4)));
+    superio_outb(msi_sioaddr, MSI_SIO_RGB_REG_RED_5_4, (red | (red << 4)));
+    superio_outb(msi_sioaddr, MSI_SIO_RGB_REG_RED_7_6, (red | (red << 4)));
+
+    superio_outb(msi_sioaddr, MSI_SIO_RGB_REG_GREEN_1_0, (green | (green << 4)));
+    superio_outb(msi_sioaddr, MSI_SIO_RGB_REG_GREEN_3_2, (green | (green << 4)));
+    superio_outb(msi_sioaddr, MSI_SIO_RGB_REG_GREEN_5_4, (green | (green << 4)));
+    superio_outb(msi_sioaddr, MSI_SIO_RGB_REG_GREEN_7_6, (green | (green << 4)));
+
+    superio_outb(msi_sioaddr, MSI_SIO_RGB_REG_BLUE_1_0, (blue | (blue << 4)));
+    superio_outb(msi_sioaddr, MSI_SIO_RGB_REG_BLUE_3_2, (blue | (blue << 4)));
+    superio_outb(msi_sioaddr, MSI_SIO_RGB_REG_BLUE_5_4, (blue | (blue << 4)));
+    superio_outb(msi_sioaddr, MSI_SIO_RGB_REG_BLUE_7_6, (blue | (blue << 4)));
+}

Controllers/MSIRGBController/MSIRGBController.h

@@ -0,0 +1,56 @@
+/*-----------------------------------------*\
+|  MSIRGBController.h                       |
+|                                           |
+|  Definitions and types for MSI-RGB        |
+|  lighting controller                      |
+|                                           |
+|  Logic adapted from:                      |
+|     https://github.com/nagisa/msi-rgb     |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 2/11/2020   |
+\*-----------------------------------------*/
+
+#include <string>
+
+#pragma once
+
+#define MSI_SIO_LOGDEV_RGB      0x12
+
+enum
+{
+    MSI_SIO_RGB_REG_ENABLE      = 0xE0,
+    MSI_SIO_RGB_REG_CFG_1       = 0xE4,
+    MSI_SIO_RGB_REG_RED_1_0     = 0xF0,
+    MSI_SIO_RGB_REG_RED_3_2     = 0xF1,
+    MSI_SIO_RGB_REG_RED_5_4     = 0xF2,
+    MSI_SIO_RGB_REG_RED_7_6     = 0xF3,
+    MSI_SIO_RGB_REG_GREEN_1_0   = 0xF4,
+    MSI_SIO_RGB_REG_GREEN_3_2   = 0xF5,
+    MSI_SIO_RGB_REG_GREEN_5_4   = 0xF6,
+    MSI_SIO_RGB_REG_GREEN_7_6   = 0xF7,
+    MSI_SIO_RGB_REG_BLUE_1_0    = 0xF8,
+    MSI_SIO_RGB_REG_BLUE_3_2    = 0xF9,
+    MSI_SIO_RGB_REG_BLUE_5_4    = 0xFA,
+    MSI_SIO_RGB_REG_BLUE_7_6    = 0xFB,
+    MSI_SIO_RGB_REG_CFG_2       = 0xFE,
+    MSI_SIO_RGB_REG_CFG_3       = 0xFF,
+};
+
+#define MSI_SIO_RGB_ENABLE_MASK 0xE0
+
+class MSIRGBController
+{
+public:
+    MSIRGBController(int sioaddr);
+    ~MSIRGBController();
+
+    std::string     GetDeviceName();
+    std::string     GetDeviceLocation();
+
+    unsigned int    GetMode();
+    void            SetMode(unsigned char new_mode, unsigned char new_speed);
+
+    void            SetColor(unsigned char red, unsigned char green, unsigned char blue);
+private:
+    int     msi_sioaddr;
+};

Controllers/MSIRGBController/MSIRGBControllerDetect.cpp

@@ -0,0 +1,40 @@
+#include "MSIRGBController.h"
+#include "RGBController.h"
+#include "RGBController_MSIRGB.h"
+#include "super_io.h"
+#include <vector>
+#include <stdio.h>
+#include <stdlib.h>
+
+/******************************************************************************************\
+*                                                                                          *
+*   DetectMSIRGBControllers                                                                *
+*                                                                                          *
+*       Detect MSI-RGB compatible Super-IO chips.                                          *
+*                                                                                          *
+\******************************************************************************************/
+
+void DetectMSIRGBControllers(std::vector<RGBController*> &rgb_controllers)
+{
+    int sio_addrs[2] = {0x2E, 0x4E};
+
+    for(int sioaddr_idx = 0; sioaddr_idx < 2; sioaddr_idx++)
+    {
+        int sioaddr = sio_addrs[sioaddr_idx];
+
+        superio_enter(sioaddr);
+
+        int val = (superio_inb(sioaddr, SIO_REG_DEVID) << 8) | superio_inb(sioaddr, SIO_REG_DEVID + 1);
+
+        switch (val & SIO_ID_MASK)
+        {
+        case SIO_NCT6795_ID:
+        case SIO_NCT6797_ID:
+            MSIRGBController* new_msi = new MSIRGBController(sioaddr);
+            RGBController_MSIRGB* new_rgb = new RGBController_MSIRGB(new_msi);
+
+            rgb_controllers.push_back(new_rgb);
+            break;
+        }
+    }
+}   /* DetectMSIRGBControllers() */

Controllers/NZXTKrakenController/NZXTKrakenController.cpp

@@ -0,0 +1,166 @@
+/*---------------------------------------------------------*\
+|  Driver for NZXT Kraken                                   |
+|                                                           |
+|  Martin Hartl (inlart), 04/04/2020                        |
+\*---------------------------------------------------------*/
+
+#include "NZXTKrakenController.h"
+
+#include <string>
+#include <sstream>
+#include <cstring>
+
+const int NZXT_KRAKEN_READ_ENDPOINT = 0x81;
+const int NZXT_KRAKEN_WRITE_ENDPOINT = 0x01;
+
+static void SetColor(const std::vector<RGBColor>& colors, unsigned char* color_data)
+{
+    for (std::size_t idx = 0; idx < colors.size(); idx++)
+    {
+        int pixel_idx = idx * 3;
+        RGBColor color = colors[idx];
+        color_data[pixel_idx + 0x00] = RGBGetRValue(color);
+        color_data[pixel_idx + 0x01] = RGBGetGValue(color);
+        color_data[pixel_idx + 0x02] = RGBGetBValue(color);
+    }
+}
+
+static RGBColor ToLogoColor(RGBColor rgb)
+{
+    return ToRGBColor(RGBGetGValue(rgb), RGBGetRValue(rgb), RGBGetBValue(rgb));
+}
+
+NZXTKrakenController::NZXTKrakenController(libusb_device_handle* dev_handle)
+{
+    dev = dev_handle;
+
+    /*-----------------------------------------------------*\
+    | Get the firmware version                              |
+    \*-----------------------------------------------------*/
+    UpdateStatus();
+}
+
+NZXTKrakenController::~NZXTKrakenController()
+{
+
+}
+
+std::string NZXTKrakenController::GetFirmwareVersion()
+{
+    return firmware_version;
+}
+
+void NZXTKrakenController::UpdateStatus()
+{
+    int actual;
+    unsigned char usb_buf[64];
+    memset(usb_buf, 0, sizeof(usb_buf));
+
+    libusb_interrupt_transfer(dev, NZXT_KRAKEN_READ_ENDPOINT, usb_buf, sizeof(usb_buf), &actual, 0);
+
+    /*-----------------------------------------------------*\
+    | Extract cooler information                            |
+    \*-----------------------------------------------------*/
+    liquid_temperature = usb_buf[0x1] + (usb_buf[0x2] * 0.1);
+    fan_speed = usb_buf[0x3] << 8 | usb_buf[0x4];
+    pump_speed = usb_buf[0x5] << 8 | usb_buf[0x6];
+
+    /*-----------------------------------------------------*\
+    | Extract firmware version                              |
+    \*-----------------------------------------------------*/
+    int major = usb_buf[0xb];
+    int minor = usb_buf[0xc] << 8 | usb_buf[0xd];
+    int patch = usb_buf[0xe];
+    std::stringstream ss;
+    ss << major << '.' << minor << '.' << patch;
+    firmware_version = ss.str();
+}
+
+void NZXTKrakenController::UpdateEffect
+    (
+    NZXTKrakenChannel_t channel,
+    unsigned char mode,
+    bool direction,
+    unsigned char speed,
+    int seq,
+    std::vector<RGBColor> colors
+    )
+{
+    unsigned char color_data[9 * 3];
+    memset(color_data, 0, sizeof(color_data));
+
+    if(!colors.empty() && channel != NZXT_KRAKEN_CHANNEL_RING)
+    {
+        colors[0] = ToLogoColor(colors[0]);
+    }
+
+    SetColor(colors, color_data);
+    SendEffect(channel, mode, direction, color_data, speed, false, seq);
+}
+
+void NZXTKrakenController::SendEffect
+    (
+    unsigned char   channel,
+    unsigned char   mode,
+    bool            direction,
+    unsigned char*  color_data,
+    unsigned char   speed /* = 0x02 */,
+    bool            movement /* = false */,
+    int             cis /* = 0 */,
+    int             size /* = 0 */
+    )
+{
+    int actual;
+    unsigned char usb_buf[65];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set effect mode                                       |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]   = 0x02;
+    usb_buf[0x01]   = 0x4c;
+
+    /*-----------------------------------------------------*\
+    | Set effect channel, movement and direction            |
+    \*-----------------------------------------------------*/
+    usb_buf[0x02]   = channel;
+    usb_buf[0x02]   |= movement ? ( 1 << 3 ) : 0;
+    usb_buf[0x02]   |= direction ? ( 1 << 4 ) : 0;
+
+    /*-----------------------------------------------------*\
+    | Set mode                                              |
+    \*-----------------------------------------------------*/
+    usb_buf[0x03]   = mode;
+
+    /*-----------------------------------------------------*\
+    | Set effect speed, size and color in set               |
+    \*-----------------------------------------------------*/
+    usb_buf[0x04]   = speed;
+    usb_buf[0x04]   |= size << 3;
+    usb_buf[0x04]   |= cis << 5;
+
+    /*-----------------------------------------------------*\
+    | Copy color data bytes                                 |
+    \*-----------------------------------------------------*/
+    if(color_data)
+    {
+        memcpy(usb_buf + 0x05, color_data, 9 * 3);
+    }
+
+    /*-----------------------------------------------------*\
+    | Send effect                                           |
+    \*-----------------------------------------------------*/
+    libusb_interrupt_transfer
+    (
+        dev,
+        NZXT_KRAKEN_WRITE_ENDPOINT,
+        usb_buf,
+        sizeof(usb_buf),
+        &actual,
+        0
+    );
+}

Controllers/NZXTKrakenController/NZXTKrakenController.h

@@ -0,0 +1,86 @@
+/*---------------------------------------------------------*\
+|  Definitions for NZXT Kraken                              |
+|                                                           |
+|  Martin Hartl (inlart), 04/04/2020                        |
+\*---------------------------------------------------------*/
+
+#pragma once
+
+#include "RGBController.h"
+#include <vector>
+#include <string>
+#include <libusb-1.0/libusb.h>
+
+enum NZXTKrakenChannel_t
+{
+    NZXT_KRAKEN_CHANNEL_SYNC           = 0x00, /* Sync Channel                 */
+    NZXT_KRAKEN_CHANNEL_LOGO           = 0x01, /* Logo Channel                 */
+    NZXT_KRAKEN_CHANNEL_RING           = 0x02, /* Ring Channel                 */
+};
+
+enum
+{
+    NZXT_KRAKEN_MODE_FIXED              = 0x00, /* Fixed colors mode            */
+    NZXT_KRAKEN_MODE_FADING             = 0x01, /* Fading mode                  */
+    NZXT_KRAKEN_MODE_SPECTRUM           = 0x02, /* Spectrum cycle mode          */
+    NZXT_KRAKEN_MODE_MARQUEE            = 0x03, /* Marquee mode                 */
+    NZXT_KRAKEN_MODE_COVER_MARQUEE      = 0x04, /* Cover marquee mode           */
+    NZXT_KRAKEN_MODE_ALTERNATING        = 0x05, /* Alternating mode             */
+    NZXT_KRAKEN_MODE_BREATHING          = 0x06, /* Breathing mode               */
+    NZXT_KRAKEN_MODE_PULSE              = 0x07, /* Pulse mode                   */
+    NZXT_KRAKEN_MODE_TAI_CHI            = 0x08, /* Tai Chi mode                 */
+    NZXT_KRAKEN_MODE_WATER_COOLER       = 0x09, /* Water color mode             */
+    NZXT_KRAKEN_MODE_LOADING            = 0x0a, /* Loading mode                 */
+    NZXT_KRAKEN_MODE_WINGS              = 0x0c, /* Wings mode                   */
+};
+
+enum
+{
+    NZXT_KRAKEN_SPEED_SLOWEST           = 0x00, /* Slowest speed                */
+    NZXT_KRAKEN_SPEED_SLOW              = 0x01, /* Slow speed                   */
+    NZXT_KRAKEN_SPEED_NORMAL            = 0x02, /* Normal speed                 */
+    NZXT_KRAKEN_SPEED_FAST              = 0x03, /* Fast speed                   */
+    NZXT_KRAKEN_SPEED_FASTEST           = 0x04, /* Fastest speed                */
+};
+
+class NZXTKrakenController
+{
+public:
+    NZXTKrakenController(libusb_device_handle* dev_handle);
+    ~NZXTKrakenController();
+
+    std::string GetFirmwareVersion();
+
+    void UpdateEffect
+        (
+        NZXTKrakenChannel_t channel,
+        unsigned char mode,
+        bool direction,
+        unsigned char speed,
+        int seq,
+        std::vector<RGBColor> colors
+        );
+
+private:
+    void UpdateStatus();
+
+    void SendEffect
+        (
+        unsigned char   channel,
+        unsigned char   mode,
+        bool            direction,
+        unsigned char*  color_data,
+        unsigned char   speed = 0x02,
+        bool            movement = false,
+        int             cis = 0 ,
+        int             size = 0
+        );
+
+    libusb_device_handle*   dev;
+
+    // -- status
+    std::string             firmware_version;
+    double                  liquid_temperature;
+    unsigned int            fan_speed;
+    unsigned int            pump_speed;
+};

Controllers/NZXTKrakenController/NZXTKrakenControllerDetect.cpp

@@ -0,0 +1,37 @@
+#include "NZXTKrakenController.h"
+#include "RGBController.h"
+#include "RGBController_NZXTKraken.h"
+#include <vector>
+#include <libusb-1.0/libusb.h>
+
+#define NZXT_KRAKEN_VID 0x1E71
+#define NZXT_KRAKEN_PID 0x170E
+
+/******************************************************************************************\
+*                                                                                          *
+*   DetectNZXTKrakenControllers                                                            *
+*                                                                                          *
+*       Detect devices supported by the NZXTKraken driver                                  *
+*                                                                                          *                                                                                          *
+\******************************************************************************************/
+
+void DetectNZXTKrakenControllers(std::vector<RGBController*> &rgb_controllers)
+{
+    libusb_context * ctx;
+    libusb_init(&ctx);
+
+    libusb_device_handle * dev = libusb_open_device_with_vid_pid(ctx, NZXT_KRAKEN_VID, NZXT_KRAKEN_PID);
+
+    if( dev )
+    {
+        libusb_detach_kernel_driver(dev, 0);
+        libusb_claim_interface(dev, 0);
+
+        NZXTKrakenController* controller = new NZXTKrakenController(dev);
+
+        RGBController_NZXTKraken* rgb_controller = new RGBController_NZXTKraken(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,113 @@
+/*-----------------------------------------*\
+|  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;
+    
+    unsigned short fw_version = GetFirmwareVersion();
+
+    /*-----------------------------------------------------*\
+    | Determine whether the device uses ASR LED or          |
+    | Polychrome protocol by checking firmware version.     |
+    | Versions 1.xx and 2.xx use ASR LED, 3.xx uses         |
+    | Polychrome                                            |
+    \*-----------------------------------------------------*/
+    if(((fw_version >> 8) < 0x03) && ((fw_version >> 8) > 0x00))
+    {
+        snprintf(device_name, 32, "ASRock ASR LED FW %d.%02d", (fw_version >> 8), (fw_version & 0xFF));
+        led_count   = 1;
+        asr_led     = true;
+    }
+    else if(fw_version == 0x03)
+    {
+        snprintf(device_name, 32, "ASRock Polychrome FW %d.%02d", (fw_version >> 8), (fw_version & 0xFF));
+        led_count   = 1;
+        asr_led     = false;
+    }
+    else
+    {
+        led_count   = 0;
+    }
+    
+}
+
+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,86 @@
+/*-----------------------------------------*\
+|  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
+{
+    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,241 @@
+/*-----------------------------------------*\
+|  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
+        );
+
+    Sleep(200);
+}
+
+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);
+
+    Sleep(5);
+     
+    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/RGBFusion2SMBusController/RGBFusion2SMBusController.cpp

@@ -0,0 +1,139 @@
+/*-----------------------------------------*\
+|  RGBFusion2SMBusController.cpp            |
+|                                           |
+|  Driver for Gigabyte Aorus RGB Fusion 2   |
+|  SMBus lighting controller                |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 3/12/2020   |
+|  Matt Harper                  5/5/2020    |
+\*-----------------------------------------*/
+
+#include "RGBFusion2SMBusController.h"
+#include <cstring>
+#include <stdio.h>
+#include <stdlib.h>
+
+#ifdef DEBUG
+#include <iostream>
+#include <iomanip>
+#endif
+
+RGBFusion2SMBusController::RGBFusion2SMBusController(i2c_smbus_interface* bus, rgb_fusion_dev_id dev)
+{
+    this->bus = bus;
+    this->dev = dev;
+
+    memset(led_data, 0, 10*16);
+
+    led_count = 10;	// Protocol supports 10 'slots'
+}
+
+unsigned int RGBFusion2SMBusController::GetLEDCount()
+{
+    return(led_count);
+}
+
+std::string RGBFusion2SMBusController::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);
+}
+
+/* Writes are performed in 32 byte chunks. If we need to write the second 16 bytes,
+* we must necessarily write the first 16 as well. Given that reading the existing state
+* from the device is not yet possible, unfortunately we may overwrite existing device
+* states if the state transition did not occur within in the same OpenRGB instance.
+* That is to say, the current behavior is non-deal but the best we have
+*/
+void RGBFusion2SMBusController::WriteLED(int led)
+{
+    unsigned short register_offset = led / 2;	// Relying on integer division to truncate
+    unsigned short write_register = RGB_FUSION_2_LED_START_ADDR + 2*register_offset;
+
+    // Adjust if we are writing the second 16 bytes
+    if(led % 2)
+    {
+        led -= 1;
+    }
+
+    #ifdef DEBUG
+    std::cout << std::hex << write_register << "\t";
+    for(int i = 0; i < 2; i++)
+    {
+        for(int j = 0; j < 16; j++)
+        {
+            std::cout << std::setw(2) << std::setfill('0') << std::hex << (int)led_data[led+i][j] << " ";
+        }
+        std::cout << " ";
+    }
+    std::cout << std::endl;
+    #endif
+
+    bus->i2c_smbus_write_block_data(RGB_FUSION_2_SMBUS_ADDR, write_register, 32, led_data[led]);
+}
+
+void RGBFusion2SMBusController::Apply()
+{
+    // Protocol expects terminating sequence 0x01ff written to register 0x17
+    bus->i2c_smbus_write_word_data(RGB_FUSION_2_SMBUS_ADDR,
+                   RGB_FUSION_2_APPLY_ADDR,
+                   RGB_FUSION_2_ACTION_APPLY);
+}
+
+void RGBFusion2SMBusController::SetLEDEffect
+    (
+    unsigned int    led,
+    int             mode,
+    unsigned int    speed,
+    unsigned char   red,
+    unsigned char   green,
+    unsigned char   blue
+    )
+{
+    led_data[led][RGB_FUSION_2_IDX_MODE]        = mode;
+    led_data[led][RGB_FUSION_2_IDX_RED]         = red;
+    led_data[led][RGB_FUSION_2_IDX_GREEN]       = green;
+    led_data[led][RGB_FUSION_2_IDX_BLUE]        = blue;
+    led_data[led][RGB_FUSION_2_IDX_BRIGHTNESS]  = 0x64;
+
+    switch (mode)
+    {
+        case RGB_FUSION_2_MODE_PULSE:
+        // Timer 1: On time
+        // Timer 2: Off time
+        led_data[led][RGB_FUSION_2_TIMER_1_LSB] = 0x20 * speed;
+        led_data[led][RGB_FUSION_2_TIMER_1_MSB] = 0x03 * speed;
+        led_data[led][RGB_FUSION_2_TIMER_2_LSB] = 0x20 * speed;
+        led_data[led][RGB_FUSION_2_TIMER_2_MSB] = 0x03 * speed;
+        break;
+
+        case RGB_FUSION_2_MODE_COLOR_CYCLE:
+            // Timer 1: Cycle time
+            led_data[led][RGB_FUSION_2_TIMER_1_LSB] = 0x00;
+            led_data[led][RGB_FUSION_2_TIMER_1_MSB] = 0x03 * speed;
+            led_data[led][RGB_FUSION_2_IDX_OPT_1]   = 0x07;		// Number of colors to cycle through. Valid range [1-7]
+            led_data[led][RGB_FUSION_2_IDX_OPT_2]   = 0x00;		// Color cycle, or color cycle and pulse. [0,1]
+        break;
+
+        case RGB_FUSION_2_MODE_FLASHING:
+            /* Timer 1: On time
+             * Timer 2: Interval
+             * Timer 3: Cycle time */
+        led_data[led][RGB_FUSION_2_TIMER_1_LSB] = 0x64;
+                led_data[led][RGB_FUSION_2_TIMER_1_MSB] = 0;
+                led_data[led][RGB_FUSION_2_TIMER_2_LSB] = 0xc8;
+                led_data[led][RGB_FUSION_2_TIMER_2_MSB] = 0;
+                led_data[led][RGB_FUSION_2_TIMER_3_LSB] = 0xd0;
+                led_data[led][RGB_FUSION_2_TIMER_3_MSB] = 0x07;
+
+            led_data[led][RGB_FUSION_2_IDX_OPT_1] = speed;		// Controls number of flashes
+        break;
+    }
+
+    WriteLED(led);
+}
+

Controllers/RGBFusion2SMBusController/RGBFusion2SMBusController.h

@@ -0,0 +1,103 @@
+/*-----------------------------------------*\
+|  RGBFusion2SMBusController.h              |
+|                                           |
+|  Definitions and types for Gigabyte Aorus |
+|  RGB Fusion 2 SMBus lighting controller   |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 3/12/2020   |
+\*-----------------------------------------*/
+
+#include <string>
+#include "i2c_smbus.h"
+
+#pragma once
+
+typedef unsigned char	rgb_fusion_dev_id;
+
+enum
+{
+    RGB_FUSION_2_IDX_MODE           = 0x01,     /* Mode index                                   */
+    RGB_FUSION_2_IDX_BRIGHTNESS     = 0x02,     /* Brightness index                             */
+    RGB_FUSION_2_IDX_MAX_BRIGHTNESS = 0x02,     /* Max brightness index                         */
+    RGB_FUSION_2_IDX_MIN_BRIGHTNESS = 0x03,     /* Minimum brightness index                     */
+    RGB_FUSION_2_IDX_BLUE           = 0x04,     /* Blue index                                   */
+    RGB_FUSION_2_IDX_GREEN          = 0x05,     /* Green index                                  */
+    RGB_FUSION_2_IDX_RED            = 0x06,     /* Red index                                    */
+    RGB_FUSION_2_IDX_WHITE	        = 0x07,	    /* White index			                        */
+    RGB_FUSION_2_TIMER_1_LSB        = 0x08,     /* Timer 1 LSB. Valid timer values [0-65535] 	*/
+    RGB_FUSION_2_TIMER_1_MSB        = 0x09,     /* Timer 1 MSB. Timer unis are milliseconds   	*/
+    RGB_FUSION_2_TIMER_2_LSB        = 0x0A,     /* Timer 2 LSB                      		    */
+    RGB_FUSION_2_TIMER_2_MSB        = 0x0B,     /* Timer 2 MSB                      		    */
+    RGB_FUSION_2_TIMER_3_LSB        = 0x0C,     /* Timer 3 LSB                      		    */
+    RGB_FUSION_2_TIMER_3_MSB        = 0x0D,     /* Timer 3 MSB                      		    */
+    RGB_FUSION_2_IDX_OPT_1	        = 0x0E,	    /* Option 1. Use case varies by mode		    */
+    RGB_FUSION_2_IDX_OPT_2	        = 0x0F,	    /* Option 2. Use case varies by mode		    */
+};
+
+enum
+{
+    RGB_FUSION_2_APPLY_ADDR	        = 0x17,
+    RGB_FUSION_2_LED_START_ADDR     = 0x20,
+    RGB_FUSION_2_SMBUS_ADDR	        = 0x68,
+};
+
+enum
+{
+    RGB_FUSION_2_ACTION_APPLY	    = 0x01ff,
+};
+
+enum
+{
+    RGB_FUSION_2_MODE_PULSE         = 0x01,     /* Pulse mode                       */
+    RGB_FUSION_2_MODE_MUSIC	        = 0x02,	    /* Music mode			            */
+    RGB_FUSION_2_MODE_COLOR_CYCLE   = 0x03,     /* Color cycle mode                 */
+    RGB_FUSION_2_MODE_STATIC        = 0x04,     /* Static color mode                */
+    RGB_FUSION_2_MODE_FLASHING      = 0x05,     /* Flashing / Double Flashing mode  */
+    RGB_FUSION_2_MODE_TRANSITION    = 0x09,	    /* Gradual transition from current  */
+    RGB_FUSION_2_MODE_DIGITAL_A	    = 0x0A,	    /* Wave mode			            */
+    RGB_FUSION_2_MODE_DIGITAL_B	    = 0x0B,	    /* 				                    */
+    RGB_FUSION_2_MODE_DIGITAL_C	    = 0x0C,	    /* 				                    */
+    RGB_FUSION_2_MODE_DIGITAL_D	    = 0x0D,	    /* 				                    */
+    RGB_FUSION_2_MODE_DIGITAL_E	    = 0x0E,	    /* 				                    */
+    RGB_FUSION_2_MODE_DIGITAL_F	    = 0x0F,	    /* 				                    */
+    RGB_FUSION_2_MODE_DIGITAL_G	    = 0x10,	    /* 				                    */
+    RGB_FUSION_2_MODE_DIGITAL_H	    = 0x11,	    /* 				                    */
+    RGB_FUSION_2_MODE_DIGITAL_I	    = 0x12,	    /* 				                    */
+};
+
+enum
+{
+    RGB_FUSION_2_SPEED_FAST         = 0x01,
+    RGB_FUSION_2_SPEED_NORMAL       = 0x02,
+    RGB_FUSION_2_SPEED_SLOW         = 0x04,
+};
+
+class RGBFusion2SMBusController
+{
+public:
+    RGBFusion2SMBusController(i2c_smbus_interface* bus, rgb_fusion_dev_id dev);
+    ~RGBFusion2SMBusController();
+
+    std::string     GetDeviceLocation();
+    unsigned int    GetLEDCount();
+    void	        Apply();
+    
+    void            SetLEDEffect
+                        (
+                        unsigned int    led,
+                        int             mode,
+                        unsigned int    speed,
+                        unsigned char   red,
+                        unsigned char   green,
+                        unsigned char   blue
+                        );
+
+private:
+    unsigned int            led_count;
+    i2c_smbus_interface*    bus;
+    rgb_fusion_dev_id       dev;
+
+    unsigned char           led_data[10][16];
+
+    void		    WriteLED(int);
+};

Controllers/RGBFusion2SMBusController/RGBFusion2SMBusControllerDetect.cpp

@@ -0,0 +1,73 @@
+#include "RGBFusion2SMBusController.h"
+#include "RGBController.h"
+#include "RGBController_RGBFusion2SMBus.h"
+#include "i2c_smbus.h"
+#include <vector>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string>
+
+/******************************************************************************************\
+*                                                                                          *
+*   TestForRGBFusion2SMBusController                                                       *
+*                                                                                          *
+*       Tests the given address to see if an RGB 2 Fusion controller exists there.  First  *
+*       does a quick write to test for a response                                          *
+*                                                                                          *
+\******************************************************************************************/
+
+bool TestForRGBFusion2SMBusController(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);
+
+}   /* TestForRGBFusion2SMBusController() */
+
+/******************************************************************************************\
+*                                                                                          *
+*   DetectRGBFusion2SMBusControllers                                                       *
+*                                                                                          *
+*       Detect RGB Fusion 2 controllers on the enumerated I2C busses at address 0x68.      *
+*                                                                                          *
+*           bus - pointer to i2c_smbus_interface where RGB Fusion device is connected      *
+*           dev - I2C address of RGB Fusion device                                         *
+*                                                                                          *
+\******************************************************************************************/
+
+void DetectRGBFusion2SMBusControllers(std::vector<i2c_smbus_interface*>& busses, std::vector<RGBController*>& rgb_controllers)
+{
+    RGBFusion2SMBusController* new_rgb_fusion;
+    RGBController_RGBFusion2SMBus* new_controller;
+
+    for (unsigned int bus = 0; bus < busses.size(); bus++)
+    {
+        // TODO - Is this necessary? Or an artifact of my own system?
+        // Skip dmcd devices
+        std::string device_name = std::string(busses[bus]->device_name);
+        if (device_name.find("dmdc") == std::string::npos)
+        {
+            // Check for RGB Fusion 2 controller at 0x68
+            if (TestForRGBFusion2SMBusController(busses[bus], 0x68))
+            {
+                new_rgb_fusion = new RGBFusion2SMBusController(busses[bus], 0x68);
+                new_controller = new RGBController_RGBFusion2SMBus(new_rgb_fusion);
+                rgb_controllers.push_back(new_controller);
+            }
+        }
+    }
+
+}   /* DetectRGBFusion2SMBusControllers() */

Controllers/RGBFusion2USBController/RGBFusion2USBController.cpp

@@ -0,0 +1,290 @@
+/*-----------------------------------------*\
+|  RGBFusion2USBController.cpp              |
+|                                           |
+|  Driver for Gigabyte Aorus RGB Fusion 2.0 |
+|  USB lighting controller                  |
+|                                           |
+|  jackun 1/8/2020                          |
+\*-----------------------------------------*/
+
+#include "RGBFusion2USBController.h"
+#include <algorithm>
+#include <array>
+#include <thread>
+#include <chrono>
+
+static LEDCount LedCountToEnum(unsigned int c)
+{
+    if (c <= 32)
+        return(LEDS_32);
+    if (c <= 64)
+        return(LEDS_64);
+    if (c <= 256)
+        return(LEDS_256);
+    if (c <= 512)
+        return(LEDS_512);
+
+    return(LEDS_1024);
+}
+
+RGBFusion2USBController::RGBFusion2USBController(hid_device* handle, const char *path) : dev(handle)
+{
+    int res = 0;
+    char text[64] {};
+    unsigned char buffer[64] {};
+
+    if( dev ) {
+
+        SetCalibration();
+
+        // hid report read needs 0x60 packet or it gives IO error
+        SendPacket(0x60, 0x00);
+
+        buffer[0] = report_id;
+        res = hid_get_feature_report(dev, buffer, 64);
+        if( res > 0 )
+        {
+            report = *reinterpret_cast<IT8297Report*>(buffer);
+
+            name = std::string(report.str_product, 32);
+            name.erase(std::find(name.begin(), name.end(), '\0'), name.end());
+
+            snprintf(text, 11, "0x%08X", report.fw_ver);
+            version = text;
+
+            snprintf(text, 11, "0x%08X", report.chip_id);
+            chip_id = text;
+        }
+
+        loc = path;
+
+        EnableBeat(false);
+    }
+}
+
+RGBFusion2USBController::~RGBFusion2USBController()
+{
+    if( dev ) {
+        hid_close(dev);
+    }
+}
+
+void RGBFusion2USBController::SetMode(int m)
+{
+    mode = m;
+}
+
+// Sets RGB color mapping to LED pins.
+// "Custom" RGB packets don't seem to get remapped so use report.byteorderN and do it manually.
+// Of course it all depends how we send data to the controller, but bios/rgb fusion 2 itself
+// set it up like this.
+void RGBFusion2USBController::SetCalibration()
+{
+    uint8_t buffer[64] {};
+    buffer[0] = report_id;
+    buffer[1] = 0x33;
+
+     // D_LED1 WS2812 GRB, 0x00RRGGBB to 0x00GGRRBB
+    buffer[2] = 0x02; // B
+    buffer[3] = 0x00; // G
+    buffer[4] = 0x01; // R
+    buffer[5] = 0x00;
+
+     // D_LED2 WS2812 GRB
+    buffer[6] = 0x02;
+    buffer[7] = 0x00;
+    buffer[8] = 0x01;
+    buffer[9] = 0x00;
+
+    // LED C1/C2 12vGRB, seems pins already connect to LEDs correctly
+    buffer[10] = 0x00;
+    buffer[11] = 0x01;
+    buffer[12] = 0x02;
+    buffer[13] = 0x00;
+
+    SendPacket(buffer);
+}
+
+void RGBFusion2USBController::SetLedCount(unsigned int count)
+{
+    LEDCount s0 = LedCountToEnum(count);
+    SendPacket(0x34, s0 | (s0 << 4)); // D_LED1 | D_LED2
+}
+
+bool RGBFusion2USBController::DisableBuiltinEffect(int enable_bit, int mask)
+{
+    if(effect_disabled & enable_bit)
+        return(true);
+
+    effect_disabled &= ~mask;
+    effect_disabled |= enable_bit;
+
+    int res = SendPacket(0x32, effect_disabled);
+    // Sometimes effect doesn't apply at first, delay a little and let MCU to react, if this packet is the cause
+    std::this_thread::sleep_for(std::chrono::milliseconds(50));
+    return res;
+}
+
+bool RGBFusion2USBController::EnableBeat(bool e)
+{
+    return SendPacket(0x31, e ? 1 : 0);
+}
+
+std::string RGBFusion2USBController::GetDeviceName()
+{
+    return(name);
+}
+
+std::string RGBFusion2USBController::GetFWVersion()
+{
+    return(version);
+}
+
+std::string RGBFusion2USBController::GetDeviceLocation()
+{
+    return(loc);
+}
+
+std::string RGBFusion2USBController::GetSerial()
+{
+    return(chip_id);
+}
+
+void RGBFusion2USBController::SetStripColors
+    (
+    unsigned int    hdr,
+    RGBColor *      colors,
+    unsigned int    num_colors,
+    int             single_led
+    )
+{
+    PktRGB pkt;
+    pkt.Init(hdr, report_id);
+
+     // FIXME assuming that LED strips ports are 0x58/0x59 for all boards
+    uint32_t byteorder = hdr == HDR_D_LED1_RGB ? report.byteorder0 : report.byteorder1;
+
+    unsigned char bo_r = byteorder >> 16;
+    unsigned char bo_g = byteorder >> 8;
+    unsigned char bo_b = byteorder & 0xFF;
+
+    int res;
+    int leds_left = num_colors;
+    int sent_data = 0;
+    int k = 0;
+    int leds_in_pkt = sizeof(pkt.s.leds) / sizeof(*pkt.s.leds); /* 19 */
+
+    // other leds stay at whatever the builtin effect was doing at that moment
+    // if breathing/pulse effect faded out then they stay dark
+    if(single_led > -1)
+    {
+        leds_left = 1;
+        k = single_led;
+        sent_data = k * 3;
+        leds_in_pkt = 1;
+    }
+
+    while(leds_left > 0)
+    {
+        leds_in_pkt = (std::min)(leds_in_pkt, leds_left);
+        leds_left -= leds_in_pkt;
+
+        pkt.s.bcount = leds_in_pkt * 3;
+        pkt.s.boffset = sent_data;
+        sent_data += pkt.s.bcount;
+
+        for(int i = 0; i < leds_in_pkt; i++)
+        {
+            RGBColor      color = colors[k];
+            unsigned char red   = RGBGetRValue(color);
+            unsigned char grn   = RGBGetGValue(color);
+            unsigned char blu   = RGBGetBValue(color);
+
+            pkt.buffer[5 + i * 3 + bo_r] = red;
+            pkt.buffer[5 + i * 3 + bo_g] = grn;
+            pkt.buffer[5 + i * 3 + bo_b] = blu;
+            k++;
+        }
+
+        res = SendPacket(pkt.buffer);
+        if(res < 0)
+            return;
+    }
+
+    if (hdr == HDR_D_LED1_RGB)
+        DisableBuiltinEffect(0x01, 0x01);
+    else
+        DisableBuiltinEffect(0x02, 0x02);
+}
+
+static const std::array< std::array<int, 3>, 5> speeds = {
+    {
+        {1600, 1600, 200},
+        {1200, 1200, 200},
+        {800, 800, 200},
+        {400, 400, 200},
+        {200, 200, 200},
+    },
+};
+
+void RGBFusion2USBController::SetLEDEffect(unsigned int led, int mode, unsigned int speed, bool random, unsigned char r, unsigned char g, unsigned char b)
+{
+    PktEffect pkt;
+    pkt.Init(led, report_id);
+    pkt.e.effect_type = mode;
+    pkt.e.color0 = r << 16 | g << 8 | b;
+
+    if (speed < speeds.size()) {
+        const auto& s = speeds[speed];
+        pkt.e.period0 = s[0];
+        pkt.e.period1 = s[1];
+        pkt.e.period2 = s[2];
+    }
+
+    switch(mode)
+    {
+    case 0: break;
+    case 1: break; // static
+    case 2: // breathing
+    case 3: // blink
+        if (random)
+            pkt.e.effect_param0 = 7; // cycle through up to 7 (max?) colors
+        break;
+    case 4: // color cycle
+        pkt.e.effect_param0 = 7; // cycle through up to 7 (max?) colors
+        break;
+
+    // "fake" effects
+    case 10: // flashing, flashing color cycle
+        pkt.e.period0 = 200;
+        pkt.e.period1 = 200;
+        pkt.e.period2 = 5000 - 1000 * speed; // time between flashing, doesn't seem to be affected by period0/period1
+        pkt.e.effect_type = 3;
+        pkt.e.effect_param2 = 2; // flash twice
+        if (random)
+            pkt.e.effect_param0 = 7;
+        break;
+    }
+
+    SendPacket(pkt.buffer);
+}
+
+bool RGBFusion2USBController::ApplyEffect()
+{
+    return SendPacket(0x28, 0xFF);
+}
+
+bool RGBFusion2USBController::SendPacket(uint8_t a, uint8_t b, uint8_t c)
+{
+    unsigned char buffer[64] {};
+    buffer[0] = report_id;
+    buffer[1] = a;
+    buffer[2] = b;
+    buffer[3] = c;
+    return (SendPacket(buffer) == 64);
+}
+
+int RGBFusion2USBController::SendPacket(unsigned char* packet)
+{
+    return hid_send_feature_report(dev, packet, 64);
+}

Controllers/RGBFusion2USBController/RGBFusion2USBController.h

@@ -0,0 +1,196 @@
+/*-----------------------------------------*\
+|  RGBFusion2USBController.h                |
+|                                           |
+|  Definitions and types for Gigabyte Aorus |
+|  RGB Fusion 2.0 USB lighting controller   |
+|                                           |
+|  jackun 1/8/2020                          |
+\*-----------------------------------------*/
+
+#include "RGBController.h"
+#include <cstring>
+#include <hidapi/hidapi.h>
+
+#pragma once
+
+// LED "headers" 0x20..0x27, As seen on Gigabyte X570 Elite board
+const uint8_t HDR_BACK_IO  = 0x20;
+const uint8_t HDR_CPU      = 0x21;
+const uint8_t HDR_LED_2    = 0x22;
+const uint8_t HDR_PCIE     = 0x23;
+const uint8_t HDR_LED_C1C2 = 0x24;
+const uint8_t HDR_D_LED1   = 0x25;
+const uint8_t HDR_D_LED2   = 0x26;
+const uint8_t HDR_LED_7    = 0x27;
+
+const uint8_t HDR_D_LED1_RGB = 0x58; // FIXME assuming that it is 0x58 for all boards
+const uint8_t HDR_D_LED2_RGB = 0x59;
+
+enum EffectType
+{
+    EFFECT_NONE = 0,
+    EFFECT_STATIC = 1,
+    EFFECT_PULSE = 2,
+    EFFECT_BLINKING = 3,
+    EFFECT_COLORCYCLE = 4,
+    // to be continued...
+};
+
+enum LEDCount
+{
+    LEDS_32 = 0,
+    LEDS_64,
+    LEDS_256,
+    LEDS_512,
+    LEDS_1024,
+};
+
+struct LEDs
+{
+    uint8_t r;
+    uint8_t g;
+    uint8_t b;
+};
+
+#pragma pack(push, 1)
+
+union PktRGB
+{
+    unsigned char buffer[64];
+    struct RGBData
+    {
+        uint8_t     report_id;
+        uint8_t     header;
+        uint16_t    boffset; // in bytes, absolute
+        uint8_t     bcount;
+        LEDs        leds[19];
+        uint16_t    padding0;
+    } s;
+
+    PktRGB() : s {}
+    {
+    }
+
+    void Init(uint8_t header, uint8_t report_id)
+    {
+        s.report_id = report_id;
+        s.header    = header;
+        s.boffset   = 0;
+        s.bcount    = 0;
+        memset(s.leds, 0, sizeof(s.leds));
+    }
+};
+
+union PktEffect
+{
+    unsigned char buffer[64];
+    struct Effect
+    {
+        uint8_t report_id;
+        uint8_t header;
+        uint32_t zone0; // rgb fusion seems to set it to pow(2, header - 0x20)
+        uint32_t zone1;
+        uint8_t reserved0;
+        uint8_t effect_type;
+        uint8_t max_brightness;
+        uint8_t min_brightness;
+        uint32_t color0;
+        uint32_t color1;
+        uint16_t period0; // fade in
+        uint16_t period1; // fade out
+        uint16_t period2; // hold
+        uint16_t period3;
+        uint8_t effect_param0;
+        uint8_t effect_param1;
+        uint8_t effect_param2;
+        uint8_t effect_param3;
+        uint8_t padding0[30];
+    } e;
+
+    PktEffect() : e {}
+    {
+    }
+
+    void Init(int header, uint8_t report_id)
+    {
+        memset(buffer, 0, sizeof(buffer));
+        e.report_id = report_id;
+        if (header < 8)
+            e.header = 32 + header; // set as default
+        else
+            e.header = header;
+        e.zone0 = (uint32_t)(1 << (e.header - 32));
+        e.effect_type = EFFECT_STATIC;
+        e.max_brightness = 100;
+        e.min_brightness = 0;
+        e.color0 = 0x00FF2100; //orange
+        e.period0 = 1200;
+        e.period1 = 1200;
+        e.period2 = 200;
+        e.period3 = 200;
+        e.effect_param0 = 0; // ex color count to cycle through (max seems to be 7)
+        e.effect_param1 = 0;
+        e.effect_param2 = 1; // ex flash repeat count
+        e.effect_param3 = 0;
+    }
+};
+
+struct IT8297Report
+{
+    uint8_t report_id;
+    uint8_t product;
+    uint8_t device_num;
+    uint8_t total_leds;
+    uint32_t fw_ver;
+    uint16_t curr_led_count;
+    uint16_t reserved0;
+    char str_product[32]; // might be 28 and an extra byteorder3
+    uint32_t byteorder0; // is little-endian 0x00RRGGBB ?
+    uint32_t byteorder1;
+    uint32_t byteorder2;
+    uint32_t chip_id;
+    uint32_t reserved1;
+};
+
+#pragma pack(pop)
+
+class RGBFusion2USBController
+{
+public:
+    RGBFusion2USBController(hid_device* handle, const char *path);
+    ~RGBFusion2USBController();
+
+    void            SetStripColors
+                        (
+                        unsigned int    hdr,
+                        RGBColor *      colors,
+                        unsigned int    num_colors,
+                        int             single_led      = -1
+                        );
+
+    void            SetLEDEffect(unsigned int led, int mode, unsigned int speed, bool random, unsigned char red, unsigned char green, unsigned char blue);
+    void            SetLedCount(unsigned int count);
+    void            SetMode(int mode);
+    bool            ApplyEffect();
+    bool            DisableBuiltinEffect(int enable_bit, int mask);
+    void            SetCalibration();
+    std::string     GetDeviceName();
+    std::string     GetDeviceLocation();
+    std::string     GetFWVersion();
+    std::string     GetSerial();
+
+private:
+    bool            EnableBeat(bool enable);
+    bool            SendPacket(uint8_t a, uint8_t b, uint8_t c = 0);
+    int             SendPacket(unsigned char* packet);
+
+    hid_device*             dev;
+    int                     mode;
+    IT8297Report            report;
+    std::string             name;
+    std::string             loc;
+    std::string             version;
+    std::string             chip_id;
+    int                     effect_disabled = 0;
+    int                     report_id = 0xCC;
+};

Controllers/RGBFusion2USBController/RGBFusion2USBControllerDetect.cpp

@@ -0,0 +1,37 @@
+#include "RGBFusion2USBController.h"
+#include "RGBController_RGBFusion2USB.h"
+
+#define IT8297_VID 0x048D
+#define IT8297_PID 0x8297
+
+/******************************************************************************************\
+*                                                                                          *
+*   DetectRGBFusion2USBControllers                                                         *
+*                                                                                          *
+*       Detect RGB Fusion 2 devices that use IT8297 RGB controller                         *
+*                                                                                          *
+\******************************************************************************************/
+
+void DetectRGBFusion2USBControllers(std::vector<RGBController*> &rgb_controllers)
+{
+    if (hid_init() < 0)
+        return;
+
+    hid_device_info * device_list = hid_enumerate(IT8297_VID, IT8297_PID);
+    if (!device_list)
+        return;
+
+    hid_device_info * device = device_list;
+    while (device)
+    {
+        hid_device * dev = hid_open_path(device->path);
+        if (dev) {
+            RGBFusion2USBController * controller = new RGBFusion2USBController(dev, device_list->path);
+            RGBController_RGBFusion2USB * rgb_controller = new RGBController_RGBFusion2USB(controller);
+            rgb_controllers.push_back(rgb_controller);
+        }
+        device = device->next;
+    }
+
+    hid_free_enumeration(device_list);
+}

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

@@ -1,6 +1,6 @@
-#include "HyperXController.h"
+#include "RGBFusionController.h"
 #include "RGBController.h"
-#include "RGBController_HyperX.h"
+#include "RGBController_RGBFusion.h"
 #include "i2c_smbus.h"
 #include <vector>
 #include <stdio.h>
@@ -8,13 +8,14 @@
 
 /******************************************************************************************\
 *                                                                                          *
-*   TestForHyperXController                                                               *
+*   TestForRGBFusionController                                                             *
 *                                                                                          *
-*       Tests the given address to see if a HyperX controller exists there.               *
+*       Tests the given address to see if an RGB Fusion controller exists there.  First    *
+*       does a quick write to test for a response                                          *
 *                                                                                          *
 \******************************************************************************************/
 
-bool TestForHyperXController(i2c_smbus_interface* bus, unsigned char address)
+bool TestForRGBFusionController(i2c_smbus_interface* bus, unsigned char address)
 {
     bool pass = false;
 
@@ -24,47 +25,43 @@ bool TestForHyperXController(i2c_smbus_interface* bus, unsigned char address)
     {
         pass = true;
 
-        for (int i = 0xA0; i < 0xB0; i++)
-        {
-            res = bus->i2c_smbus_read_byte_data(address, i);
+        res = bus->i2c_smbus_read_byte_data(address, 0xF2);
 
-            if (res != i)
-            {
-                pass = false;
-            }
+        if (res != 0xC4)
+        {
+            pass = false;
         }
     }
 
     return(pass);
 
-}   /* TestForHyperXController() */
-
+}   /* TestForRGBFusionController() */
 
 /******************************************************************************************\
 *                                                                                          *
-*   DetectHyperXControllers                                                                *
+*   DetectRGBFusionControllers                                                             *
 *                                                                                          *
-*       Detect HyperX controllers on the enumerated I2C busses.                            *
+*       Detect RGB Fusion controllers on the enumerated I2C busses at address 0x28.        *
 *                                                                                          *
-*           bus - pointer to i2c_smbus_interface where Aura device is connected            *
-*           dev - I2C address of Aura device                                               *
+*           bus - pointer to i2c_smbus_interface where RGB Fusion device is connected      *
+*           dev - I2C address of RGB Fusion device                                         *
 *                                                                                          *
 \******************************************************************************************/
 
-void DetectHyperXControllers(std::vector<i2c_smbus_interface*> &busses, std::vector<RGBController*> &rgb_controllers)
+void DetectRGBFusionControllers(std::vector<i2c_smbus_interface*>& busses, std::vector<RGBController*>& rgb_controllers)
 {
-    HyperXController* new_hyperx;
-    RGBController_HyperX* new_controller;
+    RGBFusionController* new_rgb_fusion;
+    RGBController_RGBFusion* new_controller;
 
     for (unsigned int bus = 0; bus < busses.size(); bus++)
     {
-        // Check for HyperX controller at 0x27
-        if (TestForHyperXController(busses[bus], 0x27))
+        // Check for RGB Fusion controller at 0x28
+        if (TestForRGBFusionController(busses[bus], 0x28))
         {
-            new_hyperx = new HyperXController(busses[bus], 0x27);
-            new_controller = new RGBController_HyperX(new_hyperx);
+            new_rgb_fusion = new RGBFusionController(busses[bus], 0x28);
+            new_controller = new RGBController_RGBFusion(new_rgb_fusion);
             rgb_controllers.push_back(new_controller);
         }
     }
 
-}   /* DetectHyperXControllers() */
+}   /* 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/RedragonController/RedragonControllerDetect.cpp

@@ -0,0 +1,117 @@
+#include "RedragonK556Controller.h"
+#include "RedragonM711Controller.h"
+#include "RGBController.h"
+#include "RGBController_RedragonK556.h"
+#include "RGBController_RedragonM711.h"
+#include <vector>
+#include <hidapi/hidapi.h>
+
+/*-----------------------------------------------------*\
+| Keyboard product IDs                                  |
+\*-----------------------------------------------------*/
+#define REDRAGON_KEYBOARD_VID           0x0C45
+#define REDRAGON_K550_PID               0x5204
+#define REDRAGON_K556_PID               0x5004
+
+
+/*-----------------------------------------------------*\
+| Mouse product IDs                                     |
+\*-----------------------------------------------------*/
+#define REDRAGON_MOUSE_VID              0x04D9
+#define REDRAGON_M711_PID               0xFC30
+#define REDRAGON_M715_PID               0xFC39
+
+typedef struct
+{
+    unsigned short  usb_vid;
+    unsigned short  usb_pid;
+    unsigned char   usb_interface;
+    device_type     type;
+    const char *    name;
+} redragon_device;
+
+#define REDRAGON_NUM_DEVICES (sizeof(device_list) / sizeof(device_list[ 0 ]))
+
+static const redragon_device device_list[] =
+{
+    /*-----------------------------------------------------------------------------------------------------*\
+    | Keyboards                                                                                             |
+    \*-----------------------------------------------------------------------------------------------------*/
+    { REDRAGON_KEYBOARD_VID,    REDRAGON_K550_PID,  1,  DEVICE_TYPE_KEYBOARD,   "Redragon K550 Yama"        },
+    { REDRAGON_KEYBOARD_VID,    REDRAGON_K556_PID,  1,  DEVICE_TYPE_KEYBOARD,   "Redragon K556 Devarajas"   },
+    /*-----------------------------------------------------------------------------------------------------*\
+    | Mice                                                                                                  |
+    \*-----------------------------------------------------------------------------------------------------*/
+    { REDRAGON_MOUSE_VID,       REDRAGON_M711_PID,  2,  DEVICE_TYPE_MOUSE,      "Redragon M711 Cobra"       },
+    { REDRAGON_MOUSE_VID,       REDRAGON_M715_PID,  2,  DEVICE_TYPE_MOUSE,      "Redragon M715 Dagger"      },
+    /*-----------------------------------------------------------------------------------------------------*\
+    | Mousemats                                                                                             |
+    \*-----------------------------------------------------------------------------------------------------*/
+};
+
+/******************************************************************************************\
+*                                                                                          *
+*   DetectRedragonControllers                                                              *
+*                                                                                          *
+*       Tests the USB address to see if a Redragon RGB Keyboard controller exists there.   *
+*                                                                                          *
+\******************************************************************************************/
+
+void DetectRedragonControllers(std::vector<RGBController*>& rgb_controllers)
+{
+    hid_device_info* info;
+    hid_device* dev;
+
+    hid_init();
+
+    for(int device_idx = 0; device_idx < REDRAGON_NUM_DEVICES; device_idx++)
+    {
+        dev = NULL;
+
+        info = hid_enumerate(device_list[device_idx].usb_vid, device_list[device_idx].usb_pid);
+
+        //Look for Redragon RGB Peripheral
+        while(info)
+        {
+            if((info->vendor_id == device_list[device_idx].usb_vid)
+            &&(info->product_id == device_list[device_idx].usb_pid)
+            &&(info->interface_number == device_list[device_idx].usb_interface))
+            {
+                dev = hid_open_path(info->path);
+                break;
+            }
+            else
+            {
+                info = info->next;
+            }
+        }
+
+        if( dev )
+        {
+            switch(device_list[device_idx].type)
+            {
+                case DEVICE_TYPE_KEYBOARD:
+                    {
+                    RedragonK556Controller* controller = new RedragonK556Controller(dev);
+
+                    RGBController_RedragonK556* rgb_controller = new RGBController_RedragonK556(controller);
+
+                    rgb_controller->name = device_list[device_idx].name;
+                    rgb_controllers.push_back(rgb_controller);
+                    }
+                    break;
+
+                case DEVICE_TYPE_MOUSE:
+                    {
+                    RedragonM711Controller* controller = new RedragonM711Controller(dev);
+
+                    RGBController_RedragonM711* rgb_controller = new RGBController_RedragonM711(controller);
+
+                    rgb_controller->name = device_list[device_idx].name;
+                    rgb_controllers.push_back(rgb_controller);
+                    }
+                    break;
+            }
+        }
+    }
+}

Controllers/RedragonController/RedragonK556Controller.cpp

@@ -0,0 +1,226 @@
+#include "RedragonK556Controller.h"
+
+#include <cstring>
+
+RedragonK556Controller::RedragonK556Controller(hid_device* dev_handle)
+{
+    dev = dev_handle;
+}
+
+void RedragonK556Controller::SetKeyboardColors
+    (
+    unsigned char *     color_data,
+    unsigned int        size
+    )
+{
+    unsigned int    packet_size = 0;
+    unsigned int    packet_offset = 0;
+
+    while(size > 0)
+    {
+        if(size >= REDRAGON_K556_MAX_PACKET_SIZE)
+        {
+            packet_size     = REDRAGON_K556_MAX_PACKET_SIZE;
+        }
+        else
+        {
+            packet_size     = size;
+        }
+        
+        SendKeyboardData
+            (
+            &color_data[packet_offset],
+            packet_size,
+            packet_offset
+            );
+
+        size           -= packet_size;
+        packet_offset  += packet_size;
+    }
+}
+
+void RedragonK556Controller::SendKeyboardMode
+    (
+    unsigned char       mode
+    )
+{
+    SendKeyboardParameter(REDRAGON_K556_PARAMETER_MODE, 1, &mode);
+}
+
+void RedragonK556Controller::SendKeyboardModeEx
+    (
+    unsigned char       mode,
+    unsigned char       brightness,
+    unsigned char       speed,
+    unsigned char       direction,
+    unsigned char       random_flag,
+    unsigned char       red,
+    unsigned char       green,
+    unsigned char       blue
+    )
+{
+    unsigned char parameter_data[8];
+
+    parameter_data[0]   = mode;
+    parameter_data[1]   = brightness;
+    parameter_data[2]   = speed;
+    parameter_data[3]   = direction;
+    parameter_data[4]   = random_flag;
+    parameter_data[5]   = red;
+    parameter_data[6]   = green;
+    parameter_data[7]   = blue;
+
+    SendKeyboardParameter(0, 8, parameter_data);
+}
+
+/*-------------------------------------------------------------------------------------------------*\
+| Private packet sending functions.                                                                 |
+\*-------------------------------------------------------------------------------------------------*/
+
+void RedragonK556Controller::ComputeChecksum
+    (
+    char                usb_buf[64]
+    )
+{
+    unsigned short checksum = 0;
+
+    for(unsigned int byte_idx = 0x03; byte_idx < 64; byte_idx++)
+    {
+        checksum += usb_buf[byte_idx];
+    }
+
+    usb_buf[0x01] = checksum & 0xFF;
+    usb_buf[0x02] = checksum >> 8;
+}
+
+void RedragonK556Controller::SendKeyboardBegin()
+{
+    char usb_buf[64];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up Keyboard Begin (0x01) packet                   |
+    |   Note: Not computing checksum as packet contents are |
+    |         fixed                                         |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]           = 0x04;
+    usb_buf[0x01]           = REDRAGON_K556_COMMAND_BEGIN;
+    usb_buf[0x02]           = 0x00;
+    usb_buf[0x03]           = REDRAGON_K556_COMMAND_BEGIN;
+    
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_write(dev, (unsigned char *)usb_buf, 64);
+    hid_read(dev, (unsigned char *)usb_buf, 64);
+}
+
+void RedragonK556Controller::SendKeyboardEnd()
+{
+    char usb_buf[64];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up Keyboard End (0x02) packet                     |
+    |   Note: Not computing checksum as packet contents are |
+    |         fixed                                         |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]           = 0x04;
+    usb_buf[0x01]           = REDRAGON_K556_COMMAND_END;
+    usb_buf[0x02]           = 0x00;
+    usb_buf[0x03]           = REDRAGON_K556_COMMAND_END;
+    
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_write(dev, (unsigned char *)usb_buf, 64);
+    hid_read(dev, (unsigned char *)usb_buf, 64);
+}
+
+void RedragonK556Controller::SendKeyboardData
+    (
+    unsigned char *     data,
+    unsigned char       data_size,
+    unsigned short      data_offset
+    )
+{
+    char usb_buf[64];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up Keyboard Color Data (0x11) packet              |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]           = 0x04;
+    usb_buf[0x03]           = 0x11;
+
+    usb_buf[0x04]           = data_size;
+    usb_buf[0x05]           = data_offset & 0x00FF;
+    usb_buf[0x06]           = data_offset >> 8;
+
+    /*-----------------------------------------------------*\
+    | Copy in data bytes                                    |
+    \*-----------------------------------------------------*/
+    memcpy(&usb_buf[0x08], data, data_size);
+    
+    /*-----------------------------------------------------*\
+    | Compute Checksum                                      |
+    \*-----------------------------------------------------*/
+    ComputeChecksum(usb_buf);
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_write(dev, (unsigned char *)usb_buf, 64);
+    hid_read(dev, (unsigned char *)usb_buf, 64);
+}
+
+void RedragonK556Controller::SendKeyboardParameter
+    (
+    unsigned char       parameter,
+    unsigned char       parameter_size,
+    unsigned char*      parameter_data
+    )
+{
+    char usb_buf[64];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up Keyboard Parameter (0x06) packet               |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]           = 0x04;
+    usb_buf[0x03]           = REDRAGON_K556_COMMAND_SET_PARAMETER;
+    usb_buf[0x04]           = parameter_size;
+    usb_buf[0x05]           = parameter;
+
+    /*-----------------------------------------------------*\
+    | Copy in data bytes                                    |
+    \*-----------------------------------------------------*/
+    memcpy(&usb_buf[0x08], parameter_data, parameter_size);
+
+    /*-----------------------------------------------------*\
+    | Compute Checksum                                      |
+    \*-----------------------------------------------------*/
+    ComputeChecksum(usb_buf);
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    hid_write(dev, (unsigned char *)usb_buf, 64);
+    hid_read(dev, (unsigned char *)usb_buf, 64);
+}

Controllers/RedragonController/RedragonK556Controller.h

@@ -0,0 +1,146 @@
+/*-----------------------------------------*\
+|  RedragonK556Controller.h                 |
+|                                           |
+|  Definitions and types for Redragon K556  |
+|  Devarajas keyboard lighting controller   |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 3/15/2020   |
+\*-----------------------------------------*/
+
+#include "RGBController.h"
+
+#include <string>
+#include <hidapi/hidapi.h>
+
+#pragma once
+
+#define REDRAGON_K556_MAX_PACKET_SIZE   ( 0x36 )        /* max packet size for color*/
+                                                        /* update packets           */
+enum
+{
+    REDRAGON_K556_COMMAND_BEGIN                     = 0x01, /* Begin packet command     */
+    REDRAGON_K556_COMMAND_END                       = 0x02, /* End packet command       */
+    REDRAGON_K556_COMMAND_SET_PARAMETER             = 0x06, /* Set parameter command    */
+    REDRAGON_K556_COMMAND_READ_CUSTOM_COLOR_DATA    = 0x10, /* Read custom color data   */
+    REDRAGON_K556_COMMAND_WRITE_CUSTOM_COLOR_DATA   = 0x11, /* Write custom color data  */
+};
+
+enum
+{
+    REDRAGON_K556_PARAMETER_MODE                    = 0x00, /* Mode parameter           */
+    REDRAGON_K556_PARAMETER_BRIGHTNESS              = 0x01, /* Brightness parameter     */
+    REDRAGON_K556_PARAMETER_SPEED                   = 0x02, /* Speed parameter          */
+    REDRAGON_K556_PARAMETER_DIRECTION               = 0x03, /* Direction parameter      */
+    REDRAGON_K556_PARAMETER_RANDOM_COLOR_FLAG       = 0x04, /* Random color parameter   */
+    REDRAGON_K556_PARAMETER_MODE_COLOR              = 0x05, /* Mode color (RGB)         */
+    REDRAGON_K556_PARAMETER_POLLING_RATE            = 0x0F, /* Polling rate             */
+    REDRAGON_K556_PARAMETER_SURMOUNT_MODE_COLOR     = 0x11, /* Surmount mode color      */
+};
+
+enum
+{
+    REDRAGON_K556_MODE_COLOR_WAVE_SHORT             = 0x01, /* "Go with the stream"     */
+    REDRAGON_K556_MODE_COLOR_WAVE_LONG              = 0x02, /* "Clouds fly"             */
+    REDRAGON_K556_MODE_COLOR_WHEEL                  = 0x03, /* "Winding paths"          */
+    REDRAGON_K556_MODE_SPECTRUM_CYCLE               = 0x04, /* "The trial of light"     */
+    REDRAGON_K556_MODE_BREATHING                    = 0x05, /* "Breathing"              */
+    REDRAGON_K556_MODE_STATIC                       = 0x06, /* "Normally on"            */
+    REDRAGON_K556_MODE_REACTIVE                     = 0x07, /* "Pass without trace"     */
+    REDRAGON_K556_MODE_REACTIVE_RIPPLE              = 0x08, /* "Ripple graff"           */
+    REDRAGON_K556_MODE_REACTIVE_LINE                = 0x09, /* "Fast run without trace" */
+    REDRAGON_K556_MODE_STARLIGHT_FAST               = 0x0A, /* "Swift action"           */
+    REDRAGON_K556_MODE_BLOOMING                     = 0x0B, /* "Flowers blooming"       */
+    REDRAGON_K556_MODE_RAINBOW_WAVE_VERTICAL        = 0x0C, /* "Snow winter jasmine"    */
+    REDRAGON_K556_MODE_HURRICANE                    = 0x0D, /* "Hurricane"              */
+    REDRAGON_K556_MODE_ACCUMULATE                   = 0x0E, /* "Accumulate"             */
+    REDRAGON_K556_MODE_STARLIGHT_SLOW               = 0x0F, /* "Digital times"          */
+    REDRAGON_K556_MODE_VISOR                        = 0x10, /* "Both ways"              */
+    REDRAGON_K556_MODE_SURMOUNT                     = 0x11, /* "Surmount"               */
+    REDRAGON_K556_MODE_RAINBOW_WAVE_CIRCLE          = 0x12, /* "Fast and the Furious"   */
+    REDRAGON_K556_MODE_CUSTOM                       = 0x14, /* "Coastal"                */
+};
+
+enum
+{
+    REDRAGON_K556_BRIGHTNESS_LOWEST                 = 0x00, /* Lowest brightness (off)  */
+    REDRAGON_K556_BRIGHTNESS_HIGHEST                = 0x05, /* Highest brightness       */
+};
+
+enum
+{
+    REDRAGON_K556_SPEED_SLOWEST                     = 0x05, /* Slowest speed setting    */
+    REDRAGON_K556_SPEED_NORMAL                      = 0x03, /* Normal speed setting     */
+    REDRAGON_K556_SPEED_FASTEST                     = 0x00, /* Fastest speed setting    */
+};
+
+enum
+{
+    REDRAGON_K556_SURMOUNT_MODE_COLOR_RED           = 0x01, /* Red surmount color       */
+    REDRAGON_K556_SURMOUNT_MODE_COLOR_YELLOW        = 0x02, /* Yellow surmount color    */
+    REDRAGON_K556_SURMOUNT_MODE_COLOR_GREEN         = 0x03, /* Green surmount color     */
+    REDRAGON_K556_SURMOUNT_MODE_COLOR_BLUE          = 0x04, /* Blue surmount color      */
+};
+
+enum
+{
+    REDRAGON_K556_POLLING_RATE_125HZ                = 0x00, /* 125Hz polling rate       */
+    REDRAGON_K556_POLLING_RATE_250HZ                = 0x01, /* 250Hz polling rate       */
+    REDRAGON_K556_POLLING_RATE_500HZ                = 0x02, /* 500Hz polling rate       */
+    REDRAGON_K556_POLLING_RATE_1000HZ               = 0x03, /* 1000Hz polling rate      */
+};
+
+class RedragonK556Controller
+{
+public:
+    RedragonK556Controller(hid_device* dev_handle);
+    ~RedragonK556Controller();
+
+    void        SetKeyboardColors
+                    (
+                    unsigned char *     color_data,
+                    unsigned int        size
+                    );
+
+    void        SendKeyboardBegin();
+
+    void        SendKeyboardMode
+                    (
+                    unsigned char       mode
+                    );
+
+    void        SendKeyboardModeEx
+                    (
+                    unsigned char       mode,
+                    unsigned char       brightness,
+                    unsigned char       speed,
+                    unsigned char       direction,
+                    unsigned char       random_flag,
+                    unsigned char       red,
+                    unsigned char       green,
+                    unsigned char       blue
+                    );
+
+    void        SendKeyboardData
+                    (
+                    unsigned char *     data,
+                    unsigned char       data_size,
+                    unsigned short      data_offset
+                    );
+
+    void        SendKeyboardEnd();
+
+private:
+    hid_device*             dev;
+
+    void        ComputeChecksum
+                    (
+                    char                usb_buf[64]
+                    );
+
+    void        SendKeyboardParameter
+                    (
+                    unsigned char       parameter,
+                    unsigned char       parameter_size,
+                    unsigned char*      parameter_data
+                    );
+};

Controllers/RedragonController/RedragonM711Controller.cpp

@@ -0,0 +1,90 @@
+#include "RedragonM711Controller.h"
+
+#include <cstring>
+
+static void send_usb_msg(hid_device* dev, char * data_pkt, unsigned int size)
+{
+    char* usb_pkt = new char[size + 1];
+    
+    usb_pkt[0] = 0x00;
+    for(int i = 1; i < size + 1; i++)
+    {
+        usb_pkt[i] = data_pkt[i-1];
+    }
+    
+    hid_send_feature_report(dev, (unsigned char *)usb_pkt, size + 1);
+    
+    delete usb_pkt;
+}
+
+RedragonM711Controller::RedragonM711Controller(hid_device* dev_handle)
+{
+    dev = dev_handle;
+}
+
+/*-------------------------------------------------------------------------------------------------*\
+| Private packet sending functions.                                                                 |
+\*-------------------------------------------------------------------------------------------------*/
+
+void RedragonM711Controller::SendMouseApply()
+{
+    char usb_buf[16];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up Apply packet                                   |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]           = 0x02;
+    usb_buf[0x01]           = 0xF1;
+    usb_buf[0x02]           = 0x02;
+    usb_buf[0x03]           = 0x04;
+    
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    send_usb_msg(dev, usb_buf, 16);
+}
+
+void RedragonM711Controller::SendMouseMode
+    (
+    unsigned char       mode,
+    unsigned char       speed,
+    unsigned char       red,
+    unsigned char       green,
+    unsigned char       blue
+    )
+{
+    char usb_buf[16];
+
+    /*-----------------------------------------------------*\
+    | Zero out buffer                                       |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up Lighting Control packet                        |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]           = 0x02;
+    usb_buf[0x01]           = 0xF3;
+    usb_buf[0x02]           = 0x49;
+    usb_buf[0x03]           = 0x04;
+    usb_buf[0x04]           = 0x06;
+
+    usb_buf[0x08]           = red;
+    usb_buf[0x09]           = green;
+    usb_buf[0x0A]           = blue;
+
+    usb_buf[0x0B]           = 0x01; //on
+
+    usb_buf[0x0C]           = speed;
+    usb_buf[0x0D]           = mode;
+
+    /*-----------------------------------------------------*\
+    | Send packet                                           |
+    \*-----------------------------------------------------*/
+    send_usb_msg(dev, usb_buf, 16);
+}

Controllers/RedragonController/RedragonM711Controller.h

@@ -0,0 +1,46 @@
+/*-----------------------------------------*\
+|  RedragonM711Controller.h                 |
+|                                           |
+|  Definitions and types for Redragon M711  |
+|  Cobra mouse lighting controller          |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 3/15/2020   |
+\*-----------------------------------------*/
+
+#include "RGBController.h"
+
+#include <string>
+#include <hidapi/hidapi.h>
+
+#pragma once
+
+enum
+{
+    REDRAGON_M711_MODE_WAVE              = 0x00,
+    REDRAGON_M711_MODE_RANDOM_BREATHING  = 0x01,
+    REDRAGON_M711_MODE_STATIC            = 0x02,
+    REDRAGON_M711_MODE_BREATHING         = 0x04,
+    REDRAGON_M711_MODE_RAINBOW           = 0x08,
+    REDRAGON_M711_MODE_FLASHING          = 0x10,
+};
+
+class RedragonM711Controller
+{
+public:
+    RedragonM711Controller(hid_device* dev_handle);
+    ~RedragonM711Controller();
+
+    void        SendMouseApply();
+
+    void        SendMouseMode
+                   (
+                   unsigned char       mode,
+                   unsigned char       speed,
+                   unsigned char       red,
+                   unsigned char       green,
+                   unsigned char       blue
+                   );
+
+private:
+    hid_device*             dev;
+};

Controllers/ThermaltakeRiingController/ThermaltakeRiingController.cpp

@@ -0,0 +1,111 @@
+/*-----------------------------------------*\
+|  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();
+}
+
+ThermaltakeRiingController::~ThermaltakeRiingController()
+{
+
+}
+
+void ThermaltakeRiingController::SetChannelLEDs(unsigned char channel, RGBColor * colors, unsigned int num_colors)
+{
+    unsigned char* color_data = new unsigned char[3 * num_colors];
+
+    for(std::size_t color = 0; color < num_colors; 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 + 1, current_mode, current_speed, num_colors, 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
+};
+
+#define THERMALTAKE_NUM_CHANNELS    5
+
+class ThermaltakeRiingController
+{
+public:
+    ThermaltakeRiingController(libusb_device_handle* dev_handle);
+    ~ThermaltakeRiingController();
+
+    void            SetChannelLEDs(unsigned char channel, RGBColor * colors, unsigned int num_colors);
+    void            SetMode(unsigned char mode, unsigned char speed);
+
+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);
+        }
+    }
+}

NetworkClient.cpp

@@ -0,0 +1,569 @@
+/*-----------------------------------------*\
+|  NetworkClient.cpp                        |
+|                                           |
+|  Client code for OpenRGB SDK              |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 5/9/2020    |
+\*-----------------------------------------*/
+
+#include "NetworkClient.h"
+#include "RGBController_Network.h"
+#include <cstring>
+
+#ifdef WIN32
+#include <Windows.h>
+#define MSG_NOSIGNAL 0
+#else
+#include <unistd.h>
+
+static void Sleep(unsigned int milliseconds)
+{
+    usleep(1000 * milliseconds);
+}
+#endif
+
+NetworkClient::NetworkClient(std::vector<RGBController *>& control) : controllers(control)
+{
+    strcpy(port_ip, "127.0.0.1");
+    port_num                = 1337;
+    server_connected        = false;
+    server_controller_count = 0;
+}
+
+void NetworkClient::ClientInfoChanged()
+{
+    ClientInfoChangeMutex.lock();
+
+    /*-------------------------------------------------*\
+    | Client info has changed, call the callbacks       |
+    \*-------------------------------------------------*/
+    for(unsigned int callback_idx = 0; callback_idx < ClientInfoChangeCallbacks.size(); callback_idx++)
+    {
+        ClientInfoChangeCallbacks[callback_idx](ClientInfoChangeCallbackArgs[callback_idx]);
+    }
+
+    ClientInfoChangeMutex.unlock();
+}
+
+const char * NetworkClient::GetIP()
+{
+    return(port_ip);
+}
+
+unsigned short NetworkClient::GetPort()
+{
+    return port_num;
+}
+
+bool NetworkClient::GetOnline()
+{
+    return server_connected;
+}
+
+void NetworkClient::RegisterClientInfoChangeCallback(NetClientCallback new_callback, void * new_callback_arg)
+{
+    ClientInfoChangeCallbacks.push_back(new_callback);
+    ClientInfoChangeCallbackArgs.push_back(new_callback_arg);
+}
+
+void NetworkClient::SetIP(const char *new_ip)
+{
+    if(server_connected == false)
+    {
+        strcpy(port_ip, new_ip);
+    }
+}
+
+void NetworkClient::SetName(const char *new_name)
+{
+    client_name = new_name;
+
+    if(server_connected == true)
+    {
+        SendData_ClientString();
+    }
+}
+
+void NetworkClient::SetPort(unsigned short new_port)
+{
+    if(server_connected == false)
+    {
+        port_num = new_port;
+    }
+}
+
+void NetworkClient::StartClient()
+{
+    //Start a TCP server and launch threads
+    char port_str[6];
+    snprintf(port_str, 6, "%d", port_num);
+
+    port.tcp_client(port_ip, port_str);
+
+    //Start the connection thread
+    ConnectionThread = new std::thread(&NetworkClient::ConnectionThreadFunction, this);
+
+    /*-------------------------------------------------*\
+    | Client info has changed, call the callbacks       |
+    \*-------------------------------------------------*/
+    ClientInfoChanged();
+}
+
+void NetworkClient::StopClient()
+{
+
+}
+
+void NetworkClient::ConnectionThreadFunction()
+{
+    unsigned int requested_controllers;
+
+    //This thread manages the connection to the server
+    while(1)
+    {
+        if(server_connected == false)
+        {
+            //Connect to server and reconnect if the connection is lost
+            server_initialized = false;
+
+            //Try to connect to server
+            if(port.tcp_client_connect() == true)
+            {
+                client_sock = port.sock;
+                printf( "Connected to server\n" );
+
+                //Server is now connected
+                server_connected = true;
+
+                //Start the listener thread
+                ListenThread = new std::thread(&NetworkClient::ListenThreadFunction, this);
+
+                //Server is not initialized
+                server_initialized = false;
+
+                /*-------------------------------------------------*\
+                | Client info has changed, call the callbacks       |
+                \*-------------------------------------------------*/
+                ClientInfoChanged();
+            }
+            else
+            {
+                printf( "Connection attempt failed\n" );
+            }
+        }
+
+        if(server_initialized == false && server_connected == true)
+        {
+            requested_controllers   = 0;
+            server_controller_count = 0;
+
+            //Wait for server to connect
+            Sleep(100);
+
+            //Once server is connected, send client string
+            SendData_ClientString();
+
+            //Request number of controllers
+            SendRequest_ControllerCount();
+
+            //Wait for server controller count
+            while(server_controller_count == 0)
+            {
+                Sleep(100);
+            }
+
+            printf("Client: Received controller count from server: %d\r\n", server_controller_count);
+
+            //Once count is received, request controllers
+            while(requested_controllers < server_controller_count)
+            {
+                printf("Client: Requesting controller %d\r\n", requested_controllers);
+
+                SendRequest_ControllerData(requested_controllers);
+
+                //Wait until controller is received
+                while(server_controllers.size() == requested_controllers)
+                {
+                    Sleep(100);
+                }
+
+                requested_controllers++;
+            }
+
+            //All controllers received, add them to master list
+            printf("Client: All controllers received, adding them to master list\r\n");
+            for(std::size_t controller_idx = 0; controller_idx < server_controllers.size(); controller_idx++)
+            {
+                controllers.push_back(server_controllers[controller_idx]);
+            }
+
+            server_initialized = true;
+
+            /*-------------------------------------------------*\
+            | Client info has changed, call the callbacks       |
+            \*-------------------------------------------------*/
+            ClientInfoChanged();
+        }
+
+        Sleep(1000);
+    }
+}
+
+int NetworkClient::recv_select(SOCKET s, char *buf, int len, int flags)
+{
+    fd_set              set;
+    struct timeval      timeout;
+    timeout.tv_sec      = 5;
+    timeout.tv_usec     = 0;
+
+    while(1)
+    {
+        FD_ZERO(&set);      /* clear the set */
+        FD_SET(s, &set);    /* add our file descriptor to the set */
+
+        int rv = select(s + 1, &set, NULL, NULL, &timeout);
+
+        if(rv == SOCKET_ERROR || server_connected == false)
+        {
+            return 0;
+        }
+        else if(rv == 0)
+        {
+            continue;
+        }
+        else
+        {
+            // socket has something to read
+            return(recv(s, buf, len, flags));
+        }
+    }
+}
+
+void NetworkClient::ListenThreadFunction()
+{
+    printf("Network client listener started\n");
+    //This thread handles messages received from the server
+    while(server_connected = true)
+    {
+        NetPacketHeader header;
+        int             bytes_read  = 0;
+        char *          data        = NULL;
+
+        //Read first byte of magic
+        bytes_read = recv_select(client_sock, &header.pkt_magic[0], 1, 0);
+
+        if(bytes_read <= 0)
+        {
+            goto listen_done;
+        }
+
+        //Test first character of magic - 'O'
+        if(header.pkt_magic[0] != 'O')
+        {
+            continue;
+        }
+
+        //Read second byte of magic
+        bytes_read = recv_select(client_sock, &header.pkt_magic[1], 1, 0);
+
+        if(bytes_read <= 0)
+        {
+            goto listen_done;
+        }
+
+        //Test second character of magic - 'R'
+        if(header.pkt_magic[1] != 'R')
+        {
+            continue;
+        }
+
+        //Read third byte of magic
+        bytes_read = recv_select(client_sock, &header.pkt_magic[2], 1, 0);
+
+        if(bytes_read <= 0)
+        {
+            goto listen_done;
+        }
+
+        //Test third character of magic - 'G'
+        if(header.pkt_magic[2] != 'G')
+        {
+            continue;
+        }
+
+        //Read fourth byte of magic
+        bytes_read = recv_select(client_sock, &header.pkt_magic[3], 1, 0);
+
+        if(bytes_read <= 0)
+        {
+            goto listen_done;
+        }
+
+        //Test fourth character of magic - 'B'
+        if(header.pkt_magic[3] != 'B')
+        {
+            continue;
+        }
+
+        //If we get to this point, the magic is correct.  Read the rest of the header
+        bytes_read = 0;
+        do
+        {
+            int tmp_bytes_read = 0;
+
+            tmp_bytes_read = recv_select(client_sock, (char *)&header.pkt_dev_idx + bytes_read, sizeof(header) - sizeof(header.pkt_magic) - bytes_read, 0);
+
+            bytes_read += tmp_bytes_read;
+
+            if(tmp_bytes_read <= 0)
+            {
+                goto listen_done;
+            }
+
+        } while(bytes_read != sizeof(header) - sizeof(header.pkt_magic));
+
+        //printf( "Client: Received header, now receiving data of size %d\r\n", header.pkt_size);
+
+        //Header received, now receive the data
+        if(header.pkt_size > 0)
+        {
+            bytes_read = 0;
+
+            data = new char[header.pkt_size];
+
+            do
+            {
+                int tmp_bytes_read = 0;
+
+                tmp_bytes_read = recv_select(client_sock, &data[bytes_read], header.pkt_size - bytes_read, 0);
+
+                if(tmp_bytes_read <= 0)
+                {
+                    goto listen_done;
+                }
+                bytes_read += tmp_bytes_read;
+
+            } while (bytes_read < header.pkt_size);
+        }
+
+        //printf( "Client: Received header and data\r\n" );
+        //printf( "Client: Packet ID: %d \r\n", header.pkt_id);
+
+        //Entire request received, select functionality based on request ID
+        switch(header.pkt_id)
+        {
+            case NET_PACKET_ID_REQUEST_CONTROLLER_COUNT:
+                printf( "Client: NET_PACKET_ID_REQUEST_CONTROLLER_COUNT\r\n" );
+
+                ProcessReply_ControllerCount(header.pkt_size, data);
+                break;
+
+            case NET_PACKET_ID_REQUEST_CONTROLLER_DATA:
+                printf( "Client: NET_PACKET_ID_REQUEST_CONTROLLER_DATA\r\n");
+
+                ProcessReply_ControllerData(header.pkt_size, data, header.pkt_dev_idx);
+                break;
+        }
+
+        delete[] data;
+    }
+
+listen_done:
+    printf( "Client socket has been closed");
+    server_initialized = false;
+    server_connected = false;
+
+    for(int server_controller_idx = 0; server_controller_idx < server_controllers.size(); server_controller_idx++)
+    {
+        for(int controller_idx = 0; controller_idx < controllers.size(); controller_idx++)
+        {
+            if(controllers[controller_idx] == server_controllers[server_controller_idx])
+            {
+                controllers.erase(controllers.begin() + controller_idx);
+                break;
+            }
+        }
+
+        delete server_controllers[server_controller_idx];
+    }
+
+    server_controllers.clear();
+
+    /*-------------------------------------------------*\
+    | Client info has changed, call the callbacks       |
+    \*-------------------------------------------------*/
+    ClientInfoChanged();
+}
+
+void NetworkClient::ProcessReply_ControllerCount(unsigned int data_size, char * data)
+{
+    if(data_size == sizeof(unsigned int))
+    {
+        memcpy(&server_controller_count, data, sizeof(unsigned int));
+    }
+}
+
+void NetworkClient::ProcessReply_ControllerData(unsigned int data_size, char * data, unsigned int dev_idx)
+{
+    RGBController_Network * new_controller = new RGBController_Network(this, dev_idx);
+
+    new_controller->ReadDeviceDescription((unsigned char *)data);
+
+    printf("Received controller: %s\r\n", new_controller->name.c_str());
+
+    server_controllers.push_back(new_controller);
+}
+
+void NetworkClient::SendData_ClientString()
+{
+    NetPacketHeader reply_hdr;
+
+    reply_hdr.pkt_magic[0] = 'O';
+    reply_hdr.pkt_magic[1] = 'R';
+    reply_hdr.pkt_magic[2] = 'G';
+    reply_hdr.pkt_magic[3] = 'B';
+
+    reply_hdr.pkt_dev_idx  = 0;
+    reply_hdr.pkt_id       = NET_PACKET_ID_SET_CLIENT_NAME;
+    reply_hdr.pkt_size     = strlen(client_name.c_str()) + 1;
+
+    send(client_sock, (char *)&reply_hdr, sizeof(NetPacketHeader), MSG_NOSIGNAL);
+    send(client_sock, (char *)client_name.c_str(), reply_hdr.pkt_size, MSG_NOSIGNAL);
+}
+
+void NetworkClient::SendRequest_ControllerCount()
+{
+    NetPacketHeader reply_hdr;
+
+    reply_hdr.pkt_magic[0] = 'O';
+    reply_hdr.pkt_magic[1] = 'R';
+    reply_hdr.pkt_magic[2] = 'G';
+    reply_hdr.pkt_magic[3] = 'B';
+
+    reply_hdr.pkt_dev_idx  = 0;
+    reply_hdr.pkt_id       = NET_PACKET_ID_REQUEST_CONTROLLER_COUNT;
+    reply_hdr.pkt_size     = 0;
+
+    send(client_sock, (char *)&reply_hdr, sizeof(NetPacketHeader), MSG_NOSIGNAL);
+}
+
+void NetworkClient::SendRequest_ControllerData(unsigned int dev_idx)
+{
+    NetPacketHeader reply_hdr;
+
+    reply_hdr.pkt_magic[0] = 'O';
+    reply_hdr.pkt_magic[1] = 'R';
+    reply_hdr.pkt_magic[2] = 'G';
+    reply_hdr.pkt_magic[3] = 'B';
+
+    reply_hdr.pkt_dev_idx  = dev_idx;
+    reply_hdr.pkt_id       = NET_PACKET_ID_REQUEST_CONTROLLER_DATA;
+    reply_hdr.pkt_size     = 0;
+
+    send(client_sock, (char *)&reply_hdr, sizeof(NetPacketHeader), MSG_NOSIGNAL);
+}
+
+void NetworkClient::SendRequest_RGBController_ResizeZone(unsigned int dev_idx, int zone, int new_size)
+{
+    NetPacketHeader reply_hdr;
+    int             reply_data[2];
+
+    reply_hdr.pkt_magic[0] = 'O';
+    reply_hdr.pkt_magic[1] = 'R';
+    reply_hdr.pkt_magic[2] = 'G';
+    reply_hdr.pkt_magic[3] = 'B';
+
+    reply_hdr.pkt_dev_idx  = dev_idx;
+    reply_hdr.pkt_id       = NET_PACKET_ID_RGBCONTROLLER_RESIZEZONE;
+    reply_hdr.pkt_size     = sizeof(reply_data);
+
+    reply_data[0]          = zone;
+    reply_data[1]          = new_size;
+
+    send(client_sock, (char *)&reply_hdr, sizeof(NetPacketHeader), MSG_NOSIGNAL);
+    send(client_sock, (char *)&reply_data, sizeof(reply_data), MSG_NOSIGNAL);
+}
+
+void NetworkClient::SendRequest_RGBController_UpdateLEDs(unsigned int dev_idx, unsigned char * data, unsigned int size)
+{
+    NetPacketHeader reply_hdr;
+
+    reply_hdr.pkt_magic[0] = 'O';
+    reply_hdr.pkt_magic[1] = 'R';
+    reply_hdr.pkt_magic[2] = 'G';
+    reply_hdr.pkt_magic[3] = 'B';
+
+    reply_hdr.pkt_dev_idx  = dev_idx;
+    reply_hdr.pkt_id       = NET_PACKET_ID_RGBCONTROLLER_UPDATELEDS;
+    reply_hdr.pkt_size     = size;
+
+    send(client_sock, (char *)&reply_hdr, sizeof(NetPacketHeader), MSG_NOSIGNAL);
+    send(client_sock, (char *)data, size, 0);
+}
+
+void NetworkClient::SendRequest_RGBController_UpdateZoneLEDs(unsigned int dev_idx, unsigned char * data, unsigned int size)
+{
+    NetPacketHeader reply_hdr;
+
+    reply_hdr.pkt_magic[0] = 'O';
+    reply_hdr.pkt_magic[1] = 'R';
+    reply_hdr.pkt_magic[2] = 'G';
+    reply_hdr.pkt_magic[3] = 'B';
+
+    reply_hdr.pkt_dev_idx  = dev_idx;
+    reply_hdr.pkt_id       = NET_PACKET_ID_RGBCONTROLLER_UPDATEZONELEDS;
+    reply_hdr.pkt_size     = size;
+
+    send(client_sock, (char *)&reply_hdr, sizeof(NetPacketHeader), MSG_NOSIGNAL);
+    send(client_sock, (char *)data, size, MSG_NOSIGNAL);
+}
+
+void NetworkClient::SendRequest_RGBController_UpdateSingleLED(unsigned int dev_idx, unsigned char * data, unsigned int size)
+{
+    NetPacketHeader reply_hdr;
+
+    reply_hdr.pkt_magic[0] = 'O';
+    reply_hdr.pkt_magic[1] = 'R';
+    reply_hdr.pkt_magic[2] = 'G';
+    reply_hdr.pkt_magic[3] = 'B';
+
+    reply_hdr.pkt_dev_idx  = dev_idx;
+    reply_hdr.pkt_id       = NET_PACKET_ID_RGBCONTROLLER_UPDATESINGLELED;
+    reply_hdr.pkt_size     = size;
+
+    send(client_sock, (char *)&reply_hdr, sizeof(NetPacketHeader), MSG_NOSIGNAL);
+    send(client_sock, (char *)data, size, MSG_NOSIGNAL);
+}
+
+void NetworkClient::SendRequest_RGBController_SetCustomMode(unsigned int dev_idx)
+{
+    NetPacketHeader reply_hdr;
+
+    reply_hdr.pkt_magic[0] = 'O';
+    reply_hdr.pkt_magic[1] = 'R';
+    reply_hdr.pkt_magic[2] = 'G';
+    reply_hdr.pkt_magic[3] = 'B';
+
+    reply_hdr.pkt_dev_idx  = dev_idx;
+    reply_hdr.pkt_id       = NET_PACKET_ID_RGBCONTROLLER_SETCUSTOMMODE;
+    reply_hdr.pkt_size     = 0;
+
+    send(client_sock, (char *)&reply_hdr, sizeof(NetPacketHeader), MSG_NOSIGNAL);
+}
+
+void NetworkClient::SendRequest_RGBController_UpdateMode(unsigned int dev_idx, unsigned char * data, unsigned int size)
+{
+    NetPacketHeader reply_hdr;
+
+    reply_hdr.pkt_magic[0] = 'O';
+    reply_hdr.pkt_magic[1] = 'R';
+    reply_hdr.pkt_magic[2] = 'G';
+    reply_hdr.pkt_magic[3] = 'B';
+
+    reply_hdr.pkt_dev_idx  = dev_idx;
+    reply_hdr.pkt_id       = NET_PACKET_ID_RGBCONTROLLER_UPDATEMODE;
+    reply_hdr.pkt_size     = size;
+
+    send(client_sock, (char *)&reply_hdr, sizeof(NetPacketHeader), MSG_NOSIGNAL);
+    send(client_sock, (char *)data, size, MSG_NOSIGNAL);
+}

NetworkClient.h

@@ -0,0 +1,85 @@
+/*-----------------------------------------*\
+|  NetworkClient.h                          |
+|                                           |
+|  Client header for OpenRGB SDK            |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 5/9/2020    |
+\*-----------------------------------------*/
+
+#include "RGBController.h"
+#include "NetworkProtocol.h"
+#include "net_port.h"
+
+#include <mutex>
+#include <thread>
+
+#pragma once
+
+typedef void (*NetClientCallback)(void *);
+
+class NetworkClient
+{
+public:
+    NetworkClient(std::vector<RGBController *>& control);
+
+    void            ClientInfoChanged();
+
+    const char *    GetIP();
+    unsigned short  GetPort();
+    bool            GetOnline();
+
+    void            RegisterClientInfoChangeCallback(NetClientCallback new_callback, void * new_callback_arg);
+
+    void            SetIP(const char *new_ip);
+    void            SetName(const char *new_name);
+    void            SetPort(unsigned short new_port);
+
+    void            StartClient();
+    void            StopClient();
+
+    void            ConnectionThreadFunction();
+    void            ListenThreadFunction();
+
+    void        ProcessReply_ControllerCount(unsigned int data_size, char * data);
+    void        ProcessReply_ControllerData(unsigned int data_size, char * data, unsigned int dev_idx);
+    
+    void        SendData_ClientString();
+
+    void        SendRequest_ControllerCount();
+    void        SendRequest_ControllerData(unsigned int dev_idx);
+
+    void        SendRequest_RGBController_ResizeZone(unsigned int dev_idx, int zone, int new_size);
+
+    void        SendRequest_RGBController_UpdateLEDs(unsigned int dev_idx, unsigned char * data, unsigned int size);
+    void        SendRequest_RGBController_UpdateZoneLEDs(unsigned int dev_idx, unsigned char * data, unsigned int size);
+    void        SendRequest_RGBController_UpdateSingleLED(unsigned int dev_idx, unsigned char * data, unsigned int size);
+
+    void        SendRequest_RGBController_SetCustomMode(unsigned int dev_idx);
+
+    void        SendRequest_RGBController_UpdateMode(unsigned int dev_idx, unsigned char * data, unsigned int size);
+
+    std::vector<RGBController *>  server_controllers;
+
+protected:
+    std::vector<RGBController *>& controllers;
+
+
+private:
+    SOCKET          client_sock;
+    std::string     client_name;
+    net_port        port;
+    char            port_ip[20];
+    unsigned short  port_num;
+    bool            server_connected;
+    bool            server_initialized;
+    unsigned int    server_controller_count;
+
+    std::thread *   ConnectionThread;
+    std::thread *   ListenThread;
+
+    std::mutex                          ClientInfoChangeMutex;
+    std::vector<NetClientCallback>      ClientInfoChangeCallbacks;
+    std::vector<void *>                 ClientInfoChangeCallbackArgs;
+
+    int recv_select(SOCKET s, char *buf, int len, int flags);
+};

NetworkProtocol.cpp

@@ -0,0 +1,20 @@
+#include "NetworkProtocol.h"
+
+NetPacketHeader * InitNetPacketHeader
+    (
+    unsigned int        pkt_dev_idx,
+    unsigned int        pkt_id,
+    unsigned int        pkt_size
+    )
+{
+    NetPacketHeader * new_header = new NetPacketHeader;
+
+    new_header->pkt_magic[0] = 'O';
+    new_header->pkt_magic[1] = 'R';
+    new_header->pkt_magic[2] = 'G';
+    new_header->pkt_magic[3] = 'B';
+
+    new_header->pkt_dev_idx  = pkt_dev_idx;
+    new_header->pkt_id       = pkt_id;
+    new_header->pkt_size     = pkt_size;
+}