Get corsair working on linux

.gitmodules

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

Controllers/AMDWraithPrismController/AMDWraithPrismController.cpp

@@ -0,0 +1,330 @@
+/*-----------------------------------------*\
+|  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");
+
+    SendEnableCommand();
+    SetRingEffectChannel(0x00);
+    SendApplyCommand();
+}
+
+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::SetFanColor(unsigned char red, unsigned char green, unsigned char blue)
+{
+    unsigned char usb_buf[] =
+    {
+        0x51, 0x2C, 0x01, 0x00,
+        0x06, 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[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::SetLogoColor(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[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::SetRingColor(unsigned char red, unsigned char green, unsigned char blue)
+{
+    unsigned char usb_buf[] =
+    {
+        0x51, 0x2C, 0x01, 0x00,
+        0x00, 0xFF, 0x00, 0xFF,
+        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[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::SetRingEffectChannel(unsigned char 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;
+
+    for(int led = 0x0A; led <= 0x18; led++)
+    {
+        usb_buf[led] = channel;
+    }
+
+    libusb_interrupt_transfer(dev, 0x04, usb_buf, 64, &actual, 0);
+    libusb_interrupt_transfer(dev, 0x83, usb_buf, 64, &actual, 0);
+}
+
+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::SendEffectCommand()
+{
+    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;
+
+    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,39 @@
+/*-----------------------------------------*\
+|  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
+
+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 SetFanColor(unsigned char red, unsigned char green, unsigned char blue);
+    void SetLogoColor(unsigned char red, unsigned char green, unsigned char blue);
+    void SetRingColor(unsigned char red, unsigned char green, unsigned char blue);
+
+    void SendEnableCommand();
+    void SendApplyCommand();
+    void SendEffectCommand();
+
+private:
+    char                    device_name[32];
+    libusb_device_handle*   dev;
+};

Controllers/AMDWraithPrismController/AMDWraithPrismControllerDetect.cpp

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

Controllers/AuraController/AuraController.cpp

@@ -157,11 +157,26 @@ unsigned int AuraController::GetLEDCount()
     return(led_count);
 }
 
+unsigned char AuraController::GetLEDRed(unsigned int led)
+{
+    return(AuraRegisterRead(direct_reg + ( 3 * led )));
+}
+
+unsigned char AuraController::GetLEDGreen(unsigned int led)
+{
+    return(AuraRegisterRead(direct_reg + ( 3 * led ) + 2));
+}
+
+unsigned char AuraController::GetLEDBlue(unsigned int led)
+{
+    return(AuraRegisterRead(direct_reg + ( 3 * led ) + 1));
+}
+
 void AuraController::SetAllColorsDirect(unsigned char red, unsigned char green, unsigned char blue)
 {
     unsigned char* colors = new unsigned char[led_count * 3];
 
-    for (int i = 0; i < (led_count * 3); i += 3)
+    for (unsigned int i = 0; i < (led_count * 3); i += 3)
     {
         colors[i + 0] = red;
         colors[i + 1] = blue;
@@ -177,7 +192,7 @@ void AuraController::SetAllColorsEffect(unsigned char red, unsigned char green,
 {
     unsigned char* colors = new unsigned char[led_count * 3];
 
-    for (int i = 0; i < (led_count * 3); i += 3)
+    for (unsigned int i = 0; i < (led_count * 3); i += 3)
     {
         colors[i + 0] = red;
         colors[i + 1] = blue;
@@ -188,7 +203,7 @@ void AuraController::SetAllColorsEffect(unsigned char red, unsigned char green,
     
     AuraRegisterWrite(AURA_REG_APPLY, AURA_APPLY_VAL);
 
-    delete colors;
+    delete[] colors;
 }
 
 void AuraController::SetDirect(unsigned char direct)

Controllers/AuraController/AuraController.h

@@ -99,6 +99,9 @@ public:
     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);

Controllers/AuraController/AuraControllerDetect.cpp

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

Controllers/CorsairController/CorsairController.cpp

@@ -44,7 +44,7 @@ unsigned int CorsairController::GetLEDCount()
     return(led_count);
 }
 
-void CorsairController::SetAllColors(unsigned char red, unsigned char green, unsigned char blue)
+void CorsairController::SetLEDColor(unsigned char red, unsigned char green, unsigned char blue)
 {
     bus->i2c_smbus_write_byte_data(dev, CORSAIR_VENGEANCE_RGB_CMD_FADE_TIME, 0x00);
     bus->i2c_smbus_write_byte_data(dev, CORSAIR_VENGEANCE_RGB_CMD_RED_VAL, red);
@@ -53,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)
-{
-    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)
+void CorsairController::SetMode(unsigned char /*mode*/)
 {
     bus->i2c_smbus_write_byte_data(dev, CORSAIR_VENGEANCE_RGB_CMD_MODE, CORSAIR_VENGEANCE_RGB_MODE_SINGLE);
 }

Controllers/CorsairController/CorsairController.h

@@ -44,8 +44,7 @@ public:
     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];

Controllers/CorsairKbdV1Controller/CorsairKbdV1Controller.cpp

@@ -0,0 +1,141 @@
+/*-----------------------------------------*\
+|  CorsairKbdV1Controller.cpp               |
+|                                           |
+|  Driver for first-generation Corsair Kxx  |
+|  RGB keyboard lighting controller         |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 1/9/2020    |
+\*-----------------------------------------*/
+
+#include "CorsairKbdV1Controller.h"
+
+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++;
+}
+
+CorsairKbdV1Controller::CorsairKbdV1Controller(hid_device* dev_handle)
+{
+    dev = dev_handle;
+
+    char data_pkt[64] = { 0 };
+
+    data_pkt[0] = 0x07;
+    data_pkt[1] = 0x05;
+    data_pkt[2] = 0x02;
+    data_pkt[3] = 0x00;
+    data_pkt[4] = 0x03;
+
+    send_usb_msg(dev, data_pkt);
+}
+
+CorsairKbdV1Controller::~CorsairKbdV1Controller()
+{
+
+}
+
+char* CorsairKbdV1Controller::GetDeviceName()
+{
+    return device_name;
+}
+
+void CorsairKbdV1Controller::SetLEDs(std::vector<RGBColor> colors)
+{
+    char data_pkt[5][64] = { 0 };
+    char red_val[144];
+    char grn_val[144];
+    char blu_val[144];
+
+    for(int color_idx = 0; color_idx < colors.size(); color_idx++)
+    {
+        RGBColor      color = colors[color_idx];
+        unsigned char red   = RGBGetRValue(color);
+        unsigned char grn   = RGBGetGValue(color);
+        unsigned char blu   = RGBGetBValue(color);
+
+        if( red > 7 ) red = 7;
+        if( grn > 7 ) grn = 7;
+        if( blu > 7 ) blu = 7;
+
+        red = 7 - red;
+        grn = 7 - grn;
+        blu = 7 - blu;
+
+        red_val[color_idx] = red;
+        grn_val[color_idx] = grn;
+        blu_val[color_idx] = blu;
+    }
+
+    // Perform USB control message to keyboard
+    //
+    // Request Type:  0x21
+    // Request:       0x09
+    // Value          0x0300
+    // Index:         0x03
+    // Size:          64
+
+    data_pkt[0][0] = 0x7F;
+    data_pkt[0][1] = 0x01;
+    data_pkt[0][2] = 0x3C;
+
+    data_pkt[1][0] = 0x7F;
+    data_pkt[1][1] = 0x02;
+    data_pkt[1][2] = 0x3C;
+
+    data_pkt[2][0] = 0x7F;
+    data_pkt[2][1] = 0x03;
+    data_pkt[2][2] = 0x3C;
+
+    data_pkt[3][0] = 0x7F;
+    data_pkt[3][1] = 0x04;
+    data_pkt[3][2] = 0x24;
+
+    data_pkt[4][0] = 0x07;
+    data_pkt[4][1] = 0x27;
+    data_pkt[4][2] = 0x00;
+    data_pkt[4][2] = 0x00;
+    data_pkt[4][4] = 0xD8; //Number of payload bytes
+
+    for(int i = 0; i < 60; i++)
+    {
+        data_pkt[0][i+4] = red_val[i*2+1] << 4 | red_val[i*2];
+    }
+
+    for(int i = 0; i < 12; i++)
+    {
+        data_pkt[1][i+4] = red_val[i*2+121] << 4 | red_val[i*2+120];
+    }
+
+    for(int i = 0; i < 48; i++)
+    {
+        data_pkt[1][i+16] = grn_val[i*2+1] << 4 | grn_val[i*2];
+    }
+
+    for(int i = 0; i < 24; i++)
+    {
+        data_pkt[2][i+4] = grn_val[i*2+97] << 4 | grn_val[i*2+96];
+    }
+
+    for(int i = 0; i < 36; i++)
+    {
+        data_pkt[2][i+28] = blu_val[i*2+1] << 4 | blu_val[i*2];
+    }
+
+    for(int i = 0; i < 36; i++)
+    {
+        data_pkt[3][i+4] = blu_val[i*2+73] << 4 | blu_val[i*2+72];
+    }
+
+    send_usb_msg(dev, data_pkt[0]);
+    send_usb_msg(dev, data_pkt[1]);
+    send_usb_msg(dev, data_pkt[2]);
+    send_usb_msg(dev, data_pkt[3]);
+    send_usb_msg(dev, data_pkt[4]);
+}

Controllers/CorsairKbdV1Controller/CorsairKbdV1Controller.h

@@ -0,0 +1,31 @@
+/*-----------------------------------------*\
+|  CorsairKbdV1Controller.h                 |
+|                                           |
+|  Definitions and types for first-gene     |
+|  Corsair Kxx keyboard lighting controller |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 1/9/2020    |
+\*-----------------------------------------*/
+
+#include "RGBController.h"
+
+#include <string>
+#include <hidapi/hidapi.h>
+
+#pragma once
+
+class CorsairKbdV1Controller
+{
+public:
+    CorsairKbdV1Controller(hid_device* dev_handle);
+    ~CorsairKbdV1Controller();
+
+    char* GetDeviceName();
+
+    void SetLEDsDirect(std::vector<RGBColor> colors);
+    void SetLEDs(std::vector<RGBColor> colors);
+
+private:
+    char                    device_name[32];
+    hid_device*             dev;
+};

Controllers/CorsairKbdV1Controller/CorsairKbdV1ControllerDetect.cpp

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

Controllers/CorsairProController/CorsairProController.cpp

@@ -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;
@@ -62,9 +64,14 @@ unsigned int CorsairProController::GetLEDCount()
     return(led_count);
 }
 
+unsigned char CorsairProController::GetEffect()
+{
+    return(effect_mode);
+}
+
 void CorsairProController::SetAllColors(unsigned char red, unsigned char green, unsigned char blue)
 {
-    for (int i = 0; i < led_count; i++)
+    for (unsigned int i = 0; i < led_count; i++)
     {
         led_red[i]      = red;
         led_green[i]    = green;
@@ -99,12 +106,14 @@ void CorsairProController::ApplyColors()
 
 void CorsairProController::SetEffect(unsigned char mode)
 {
+    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, effect_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

Controllers/CorsairProController/CorsairProController.h

@@ -69,6 +69,7 @@ public:
     std::string     GetDeviceName();
     std::string     GetDeviceLocation();
     unsigned int    GetLEDCount();
+    unsigned char   GetEffect();
     void            SetEffect(unsigned char mode);
     void            SetCustom();
 
@@ -80,7 +81,7 @@ 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];

Controllers/Hue2Controller/Hue2Controller.cpp

@@ -0,0 +1,243 @@
+/*---------------------------------------------------------*\
+|  Processing Code for NZXT Hue 2                           |
+|                                                           |
+|  Adam Honse ([email protected]), 12/29/2016       |
+\*---------------------------------------------------------*/
+
+#include "Hue2Controller.h"
+
+#include <fstream>
+#include <iostream>
+#include <string>
+
+Hue2Controller::Hue2Controller(libusb_device_handle* dev_handle)
+{
+    dev = dev_handle;
+
+    GetStripsOnChannel(HUE_2_CHANNEL_1);
+}
+
+Hue2Controller::~Hue2Controller()
+{
+}
+
+unsigned int Hue2Controller::GetStripsOnChannel(unsigned int /*channel*/)
+{
+    unsigned int ret_val = 0;
+
+    unsigned char usb_buf[] =
+    {
+        0x20, 0x03, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00
+    };
+    int             actual = 0;
+
+    libusb_interrupt_transfer(dev, 0x01, usb_buf, 64, &actual, 0);
+    libusb_interrupt_transfer(dev, 0x81, usb_buf, 64, &actual, 0);
+
+    for(int chan = 0; chan < 4; chan++)
+    {
+        unsigned int start = 0x0F + (6 * chan);
+        unsigned int num_leds_on_channel = 0;
+        for(int dev = 0; dev < 6; dev++)
+        {
+            switch(usb_buf[start + dev])
+            {
+            case 0x01: //Hue 1 strip
+                num_leds_on_channel += 10;
+                break;
+
+            case 0x02: //Aer 1 fan
+                num_leds_on_channel += 8;
+                break;
+
+            case 0x04: //Hue 2 strip
+                num_leds_on_channel += 10;
+                break;
+            
+            case 0x0B: //Aer 2 fan
+                num_leds_on_channel += 8;
+                break;
+
+            default:
+                break;
+            }
+        }
+        channel_leds[chan] = num_leds_on_channel;
+    }
+    return(ret_val);
+}
+
+void Hue2Controller::SetChannelEffect(unsigned int channel, unsigned int mode, std::vector<RGBColor> colors)
+{
+    unsigned char usb_buf[] =
+    {
+        0x28, 0x03, 0x00, 0x28,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00
+    };
+    int             actual = 0;
+
+    /*-----------------------------------------------------*\
+    | Set channel in USB packet                             |
+    \*-----------------------------------------------------*/
+    usb_buf[0x02]   = 1 << channel;
+
+    /*-----------------------------------------------------*\
+    | Set mode in USB packet                                |
+    \*-----------------------------------------------------*/
+    usb_buf[0x04]   = mode;
+
+    /*-----------------------------------------------------*\
+    | Set color count in USB packet                         |
+    \*-----------------------------------------------------*/
+    usb_buf[0x08]   = colors.size();
+
+    /*-----------------------------------------------------*\
+    | Fill in color data                                    |
+    \*-----------------------------------------------------*/
+    for (std::size_t idx = 0; idx < colors.size(); idx++)
+    {
+        int pixel_idx = idx * 3;
+        RGBColor color = colors[idx];
+        usb_buf[pixel_idx + 0x0A] = RGBGetGValue(color);
+        usb_buf[pixel_idx + 0x0B] = RGBGetRValue(color);
+        usb_buf[pixel_idx + 0x0C] = RGBGetBValue(color);
+    }
+
+    libusb_interrupt_transfer(dev, 0x01, usb_buf, 64, &actual, 0);
+    libusb_interrupt_transfer(dev, 0x81, usb_buf, 64, &actual, 0);
+}
+
+void Hue2Controller::SetChannelLEDs(unsigned int channel, std::vector<RGBColor> colors)
+{
+    unsigned char usb_buf[] =
+    {
+        0x22, 0x10, 0x01, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00
+    };
+
+    unsigned char usb_apply[] =
+    {
+        0x22, 0xA0, 0x01, 0x00,
+        0x01, 0x00, 0x00, 0x28,
+        0x00, 0x00, 0x80, 0x00,
+        0x32, 0x00, 0x00, 0x01,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00
+    };
+    int             actual;
+
+    std::size_t pkt_max = 20;
+
+    /*-----------------------------------------------------*\
+    | Set channel in USB packets                            |
+    \*-----------------------------------------------------*/
+    usb_buf[0x02]   = 1 << channel;
+    usb_apply[0x02] = 1 << channel;
+
+    /*-----------------------------------------------------*\
+    | Send first packet for first 20 LEDs                   |
+    \*-----------------------------------------------------*/
+    if(pkt_max > colors.size())
+    {
+        pkt_max = colors.size();
+    }
+
+    for (std::size_t idx = 0; idx < pkt_max; idx++)
+    {
+        int pixel_idx = idx * 3;
+        RGBColor color = colors[idx];
+        usb_buf[pixel_idx + 4] = RGBGetGValue(color);
+        usb_buf[pixel_idx + 5] = RGBGetRValue(color);
+        usb_buf[pixel_idx + 6] = RGBGetBValue(color);
+    }
+
+    libusb_interrupt_transfer(dev, 0x01, usb_buf, 64, &actual, 0);
+
+    /*-----------------------------------------------------*\
+    | Send second packet for second 20 LEDs if necessary    |
+    \*-----------------------------------------------------*/
+    for(int idx = 4; idx < 64; idx++)
+    {
+        usb_buf[idx] = 0;
+    }
+    
+    usb_buf[0x01] = 0x11;
+    pkt_max       = 0;
+
+    if (colors.size() > 20)
+    {
+        pkt_max = colors.size() - 20;
+    }
+
+    if(pkt_max > 0)
+    {
+        for (std::size_t idx = 0; idx < pkt_max; idx++)
+        {
+            int pixel_idx = idx * 3;
+            RGBColor color = colors[idx + 20];
+            usb_buf[pixel_idx + 4] = RGBGetGValue(color);
+            usb_buf[pixel_idx + 5] = RGBGetRValue(color);
+            usb_buf[pixel_idx + 6] = RGBGetBValue(color);
+        }
+
+        libusb_interrupt_transfer(dev, 0x01, usb_buf, 64, &actual, 0);
+    }
+
+    /*-----------------------------------------------------*\
+    | Send apply packet                                     |
+    \*-----------------------------------------------------*/
+    libusb_interrupt_transfer(dev, 0x01, usb_apply, 64, &actual, 0);
+}

Controllers/Hue2Controller/Hue2Controller.h

@@ -0,0 +1,59 @@
+/*---------------------------------------------------------*\
+|  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_MODE_FIXED            = 0x00,     /* Fixed colors mode            */
+    HUE_2_MODE_FADING           = 0x01,     /* Fading mode                  */
+    HUE_2_MODE_SPECTRUM         = 0x02,     /* Spectrum cycle mode          */
+    HUE_2_MODE_MARQUEE          = 0x03,     /* Marquee mode                 */
+    HUE_2_MODE_COVER_MARQUEE    = 0x04,     /* Cover marquee mode           */
+    HUE_2_MODE_ALTERNATING      = 0x05,     /* Alternating mode             */
+    HUE_2_MODE_PULSING          = 0x06,     /* Pulsing mode                 */
+    HUE_2_MODE_BREATHING        = 0x07,     /* Breathing mode               */
+    HUE_2_NUM_MODES                         /* Number of Hue 2 modes        */
+};
+
+class Hue2Controller
+{
+public:
+    Hue2Controller(libusb_device_handle* dev_handle);
+    ~Hue2Controller();
+    
+    char*           GetLEDString();
+    unsigned int    GetStripsOnChannel(unsigned int channel);
+    void            SetChannelEffect(unsigned int channel, unsigned int mode, std::vector<RGBColor> colors);
+    void            SetChannelLEDs(unsigned int channel, std::vector<RGBColor> colors);
+    
+    unsigned int    channel_leds[HUE_2_NUM_CHANNELS];
+
+private:
+    libusb_device_handle*   dev;
+};

Controllers/Hue2Controller/Hue2ControllerDetect.cpp

@@ -0,0 +1,37 @@
+#include "Hue2Controller.h"
+#include "RGBController.h"
+#include "RGBController_Hue2.h"
+#include <vector>
+#include <libusb-1.0/libusb.h>
+
+#define NZXT_HUE_2_VID 0x1E71
+#define NZXT_HUE_2_PID 0x2001
+
+/******************************************************************************************\
+*                                                                                          *
+*   DetectHue2Controllers                                                                  *
+*                                                                                          *
+*       Detect devices supported by the Hue2 driver                                        *
+*                                                                                          *                                                                                          *
+\******************************************************************************************/
+
+void DetectHue2Controllers(std::vector<RGBController*> &rgb_controllers)
+{
+    libusb_context * ctx;
+    libusb_init(&ctx);
+
+    //Look for NZXT Hue 2
+    libusb_device_handle * dev = libusb_open_device_with_vid_pid(ctx, NZXT_HUE_2_VID, NZXT_HUE_2_PID);
+
+    if( dev )
+    {
+        libusb_detach_kernel_driver(dev, 0);
+        libusb_claim_interface(dev, 0);
+
+        Hue2Controller* controller = new Hue2Controller(dev);
+
+        RGBController_Hue2* rgb_controller = new RGBController_Hue2(controller);
+
+        rgb_controllers.push_back(rgb_controller);
+    }
+}   /* DetectHuePlusControllers() */

Controllers/HuePlusController/HuePlusController.cpp

@@ -37,8 +37,8 @@ void HuePlusController::Initialize(char* port_name)
     
     serialport = new serial_port(port_name, HUE_PLUS_BAUD);
 
-    channel_leds[HUE_PLUS_CHANNEL_1_IDX] = GetStripsOnChannel(HUE_PLUS_CHANNEL_1) * 10;
-    channel_leds[HUE_PLUS_CHANNEL_2_IDX] = GetStripsOnChannel(HUE_PLUS_CHANNEL_2) * 10;
+    channel_leds[HUE_PLUS_CHANNEL_1_IDX] = GetLEDsOnChannel(HUE_PLUS_CHANNEL_1);
+    channel_leds[HUE_PLUS_CHANNEL_2_IDX] = GetLEDsOnChannel(HUE_PLUS_CHANNEL_2);
 }
 
 char* HuePlusController::GetLEDString()
@@ -46,69 +46,172 @@ char* HuePlusController::GetLEDString()
     return(led_string);
 }
 
-unsigned int HuePlusController::GetStripsOnChannel(unsigned int channel)
+unsigned int HuePlusController::GetLEDsOnChannel(unsigned int channel)
 {
+    unsigned char serial_buf[] =
+    {
+        0x8D, 0x00, 0x00, 0x00, 0x00
+    };
+
     unsigned int ret_val = 0;
 
-    if (serialport != NULL)
+    /*-----------------------------------------------------*\
+    | 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);
+
+    printf("%x %x %x %x %x \r\n", serial_buf[0], serial_buf[1], serial_buf[2], serial_buf[3], serial_buf[4]);
+    if(bytes_read == 5)
     {
-        unsigned char *serial_buf;
-        serial_buf = new unsigned char[5];
-
-        serial_buf[0] = 0x8D;
-        serial_buf[1] = 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];
+            ret_val = serial_buf[4] * 8;
+        }
+        else
+        {
+            ret_val += serial_buf[4] * 10;
         }
-
-        delete[] serial_buf;
     }
 
     return(ret_val);
 }
 
-void HuePlusController::SetChannelLEDs(unsigned int channel, std::vector<RGBColor> colors)
+void HuePlusController::SetChannelEffect(unsigned int channel, unsigned int mode, std::vector<RGBColor> colors)
 {
-    if (serialport != NULL)
+    unsigned char serial_buf[] =
     {
-        unsigned char *serial_buf;
+        0x4B, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00
+    };
 
-        serial_buf = new unsigned char[HUE_PLUS_PACKET_SIZE];
+    /*-----------------------------------------------------*\
+    | Set channel in serial packet                          |
+    \*-----------------------------------------------------*/
+    serial_buf[0x01]   = channel;
 
-        serial_buf[0] = 0x4B;
-        serial_buf[1] = channel;
-        serial_buf[2] = HUE_PLUS_MODE_FIXED;				
-        serial_buf[3] = 0x00; 
-        serial_buf[4] = 0x00;
+    /*-----------------------------------------------------*\
+    | Set mode in serial packet                             |
+    \*-----------------------------------------------------*/
+    serial_buf[0x02]   = mode;
 
-        for (int i = 5; i < HUE_PLUS_PACKET_SIZE; i++)
-        {
-            serial_buf[i] = 0x00;
-        }
-
-        for (int idx = 0; idx < (colors.size() * 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, HUE_PLUS_PACKET_SIZE);
-        serialport->serial_flush_tx();
-
-        delete[] serial_buf;
+    /*-----------------------------------------------------*\
+    | Fill in color data                                    |
+    \*-----------------------------------------------------*/
+    for (std::size_t idx = 0; idx < colors.size(); idx++)
+    {
+        int pixel_idx = idx * 3;
+        RGBColor color = colors[idx];
+        serial_buf[pixel_idx + 0x05] = RGBGetGValue(color);
+        serial_buf[pixel_idx + 0x06] = RGBGetRValue(color);
+        serial_buf[pixel_idx + 0x07] = RGBGetBValue(color);
     }
 
-}
+    serialport->serial_write((char *)serial_buf, HUE_PLUS_PACKET_SIZE);
+    serialport->serial_flush_tx();
+
+    Sleep(10);
+}
+
+void HuePlusController::SetChannelLEDs(unsigned int channel, std::vector<RGBColor> colors)
+{
+    unsigned char serial_buf[] =
+    {
+        0x4B, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00
+    };
+
+    /*-----------------------------------------------------*\
+    | Set channel in serial packet                          |
+    \*-----------------------------------------------------*/
+    serial_buf[0x01]   = channel;
+
+    /*-----------------------------------------------------*\
+    | Set mode in serial packet                             |
+    \*-----------------------------------------------------*/
+    serial_buf[0x02]   = HUE_PLUS_MODE_FIXED;
+
+    /*-----------------------------------------------------*\
+    | Fill in color data                                    |
+    \*-----------------------------------------------------*/
+    for (unsigned int idx = 0; idx < (colors.size() * 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, HUE_PLUS_PACKET_SIZE);
+    serialport->serial_flush_tx();
+
+    Sleep(10);
+}

Controllers/HuePlusController/HuePlusController.h

@@ -55,7 +55,8 @@ public:
 
     void            Initialize(char* port_name);
     char*           GetLEDString();
-    unsigned int    GetStripsOnChannel(unsigned int channel);
+    unsigned int    GetLEDsOnChannel(unsigned int channel);
+    void            SetChannelEffect(unsigned int channel, unsigned int mode, std::vector<RGBColor> colors);
     void            SetChannelLEDs(unsigned int channel, std::vector<RGBColor> colors);
 
     unsigned int    channel_leds[HUE_PLUS_NUM_CHANNELS];

Controllers/HuePlusController/HuePlusControllerDetect.cpp

@@ -1,20 +1,11 @@
 #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
 
 /******************************************************************************************\
 *                                                                                          *
@@ -29,60 +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());
-#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() */

Controllers/HyperXController/HyperXControllerDetect.cpp

@@ -82,11 +82,9 @@ void DetectHyperXControllers(std::vector<i2c_smbus_interface*> &busses, std::vec
             {
                 // Test for HyperX SPD at slot_addr
                 // This test was copied from NGENUITY software
-                // Tests SPD addresses in order: 0x40, 0x41, 0x68, and 0x67
+                // 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)
-                 &&(busses[bus]->i2c_smbus_read_byte_data(slot_addr, 0x68) == 0x10)
-                 &&(busses[bus]->i2c_smbus_read_byte_data(slot_addr, 0x67) == 0x00))
+                 &&(busses[bus]->i2c_smbus_read_byte_data(slot_addr, 0x41) == 0x98))
                 {
                     slots_valid |= (1 << (slot_addr - 0x50));
                 }

Controllers/MSI3ZoneController/MSI3ZoneController.cpp

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

Controllers/MSI3ZoneController/MSI3ZoneController.h

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

Controllers/MSI3ZoneController/MSI3ZoneControllerDetect.cpp

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

Controllers/PatriotViperController/PatriotViperController.cpp

@@ -0,0 +1,175 @@
+/*-----------------------------------------*\
+|  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, 0x0C);
+    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, 0x0C);
+    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, 0x0C);
+    ViperRegisterWrite(VIPER_REG_MODE, 0xAA, 0x00, 0x00);
+    ViperRegisterWrite(VIPER_REG_MODE, 0xFA, 0x00, 0x00);
+}
+
+void PatriotViperController::SetMode(unsigned char new_mode)
+{
+    direct = false;
+    mode = new_mode;
+
+    ViperRegisterWrite(VIPER_REG_START, 0xFF, 0xFF, 0xFF);
+    ViperRegisterWrite(VIPER_REG_STATIC, 0x04, 0x00, 0x00);
+    ViperRegisterWrite(VIPER_REG_MODE, new_mode, 0x00, 0x0C);
+    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,79 @@
+/*-----------------------------------------*\
+|  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                            */
+};
+
+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);
+    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 int            mode;
+};

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

@@ -34,6 +34,11 @@ PolychromeController::PolychromeController(i2c_smbus_interface* bus, polychrome_
         asr_led = false;
         strcpy(device_name, "ASRock Polychrome FW 3.00");
         break;
+
+    default:
+        led_count = 0;
+        strcpy(device_name, "");
+        break;
     }
 }
 
@@ -69,6 +74,11 @@ unsigned int PolychromeController::GetLEDCount()
     return(led_count);
 }
 
+unsigned int PolychromeController::GetMode()
+{
+    return(0);
+}
+
 void PolychromeController::SetAllColors(unsigned char red, unsigned char green, unsigned char blue)
 {
     if (asr_led)
@@ -83,7 +93,7 @@ void PolychromeController::SetAllColors(unsigned char red, unsigned char green,
     }
 }
 
-void PolychromeController::SetLEDColor(unsigned int led, unsigned char red, unsigned char green, unsigned char blue)
+void PolychromeController::SetLEDColor(unsigned int /*led*/, unsigned char red, unsigned char green, unsigned char blue)
 {
     if (asr_led)
     {
@@ -107,4 +117,4 @@ void PolychromeController::SetMode(unsigned char mode)
     {
         bus->i2c_smbus_write_byte_data(dev, POLYCHROME_REG_MODE, mode);
     }    
-}
+}

Controllers/PolychromeController/PolychromeController.h

@@ -76,6 +76,7 @@ public:
 
     char*           GetDeviceName();
     unsigned int    GetLEDCount();
+    unsigned int    GetMode();
     void            SetAllColors(unsigned char red, unsigned char green, unsigned char blue);
     void            SetLEDColor(unsigned int led, unsigned char red, unsigned char green, unsigned char blue);
     void            SetMode(unsigned char mode);

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

Controllers/PoseidonZRGBController/PoseidonZRGBController.h

@@ -0,0 +1,38 @@
+/*-----------------------------------------*\
+|  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
+
+class PoseidonZRGBController
+{
+public:
+    PoseidonZRGBController(hid_device* dev_handle);
+    ~PoseidonZRGBController();
+
+    char* GetDeviceName();
+
+    void SetLEDsDirect(std::vector<RGBColor> colors);
+    void SetLEDs(std::vector<RGBColor> colors);
+    
+private:
+    char                    device_name[32];
+    hid_device*             dev;
+};

Controllers/PoseidonZRGBController/PoseidonZRGBControllerDetect.cpp

@@ -0,0 +1,36 @@
+#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* dev;
+
+    //Look for Thermaltake Poseidon Z RGB Keyboard
+    hid_init();
+
+    dev = hid_open(TT_POSEIDON_Z_RGB_VID, TT_POSEIDON_Z_RGB_PID, 0);
+
+    if( dev )
+    {
+        PoseidonZRGBController* controller = new PoseidonZRGBController(dev);
+
+        RGBController_PoseidonZRGB* rgb_controller = new RGBController_PoseidonZRGB(controller);
+
+        rgb_controllers.push_back(rgb_controller);
+    }
+}

Controllers/RGBFusionController/RGBFusionController.cpp

@@ -22,6 +22,10 @@ RGBFusionController::RGBFusionController(i2c_smbus_interface* bus, rgb_fusion_de
 
     // Set LED count
     led_count = 2;
+
+    // Enable control
+    switch_bank(0);
+    bus->i2c_smbus_write_byte_data(dev, 0x02, 0x09);
 }
 
 RGBFusionController::~RGBFusionController()
@@ -132,37 +136,38 @@ void RGBFusionController::dump()
 
 unsigned char RGBFusionController::get_mode_ch_0()
 {
-    s32 temp = bus->i2c_smbus_read_byte_data(dev, RGB_FUSION_BANK_1_REG_CH_0_MODE);
-    return(temp);
+    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_1_REG_CH_1_MODE));
+    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_0_REG_CH_0_R, red);
-    bus->i2c_smbus_write_byte_data(dev, RGB_FUSION_BANK_0_REG_CH_0_G, green);
-    bus->i2c_smbus_write_byte_data(dev, RGB_FUSION_BANK_0_REG_CH_0_B, 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_0_REG_CH_1_R, red);
-    bus->i2c_smbus_write_byte_data(dev, RGB_FUSION_BANK_0_REG_CH_1_G, green);
-    bus->i2c_smbus_write_byte_data(dev, RGB_FUSION_BANK_0_REG_CH_1_B, 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_1_REG_CH_0_MODE, mode + RGB_FUSION_WRITE_MODE_OFST);
+    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_1_REG_CH_1_MODE, mode + RGB_FUSION_WRITE_MODE_OFST);
+    bus->i2c_smbus_write_byte_data(dev, RGB_FUSION_BANK_0_REG_CH_1_MODE, mode + RGB_FUSION_WRITE_MODE_OFST);
 }
 
 void RGBFusionController::switch_bank(unsigned char bank)

Controllers/RGBFusionController/RGBFusionController.h

@@ -16,14 +16,14 @@ typedef unsigned char	rgb_fusion_dev_id;
 
 enum
 {
-    RGB_FUSION_BANK_0_REG_CH_0_R    = 0x00, /* Channel 0 Red Value                  */
-    RGB_FUSION_BANK_0_REG_CH_0_G    = 0x01, /* Channel 0 Green Value                */
-    RGB_FUSION_BANK_0_REG_CH_0_B    = 0x02, /* Channel 0 Blue Value                 */
-    RGB_FUSION_BANK_0_REG_CH_1_R    = 0x08, /* Channel 1 Red Value                  */
-    RGB_FUSION_BANK_0_REG_CH_1_G    = 0x09, /* Channel 1 Green Value                */
-    RGB_FUSION_BANK_0_REG_CH_1_B    = 0x0A, /* Channel 1 Blue Value                 */
-    RGB_FUSION_BANK_1_REG_CH_0_MODE = 0x03, /* Channel 0 Mode Selection             */
-    RGB_FUSION_BANK_1_REG_CH_1_MODE = 0x13, /* Channel 1 Mode Selection             */
+    RGB_FUSION_BANK_0_REG_CH_0_MODE = 0x03, /* Channel 0 Mode Selection             */
+    RGB_FUSION_BANK_0_REG_CH_1_MODE = 0x13, /* Channel 1 Mode Selection             */
+    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                 */
 };
 

Controllers/RGBFusionController/RGBFusionControllerDetect.cpp

@@ -24,6 +24,13 @@ bool TestForRGBFusionController(i2c_smbus_interface* bus, unsigned char address)
     if (res >= 0)
     {
         pass = true;
+
+        res = bus->i2c_smbus_read_byte_data(address, 0xF2);
+
+        if (res != 0xC4)
+        {
+            pass = false;
+        }
     }
 
     return(pass);

OpenAuraSDK.h

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

OpenRGB.cpp

@@ -1,14 +1,12 @@
 /******************************************************************************************\
 *                                                                                          *
-*   OpenAuraSDK.cpp                                                                        *
+*   OpenRGB.cpp                                                                            *
 *                                                                                          *
-*       Functions for communicating with Asus Aura devices on Windows and Linux            *
+*       Functions for communicating with RGBController API devices on Windows and Linux    *
 *                                                                                          *
 \******************************************************************************************/
 
-#include "AuraController.h"
 #include "RGBController.h"
-#include "RGBController_AorusGPU.h"
 #include "i2c_smbus.h"
 #include <vector>
 #include <stdio.h>
@@ -319,50 +317,24 @@ void DetectI2CBusses()
 
 #endif  /* WIN32 */
 
-/******************************************************************************************\
-*                                                                                          *
-*   DumpAuraRegisters                                                                      *
-*                                                                                          *
-*       Dumps register values from an Aura device                                          *
-*                                                                                          *
-\******************************************************************************************/
-
-void DumpAuraRegisters(AuraController * controller)
-{
-    int i, j;
-
-    int start = 0x0000;
-
-    FILE* file = freopen("auradump.txt", "a", stdout);
-
-    printf("       0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f\r\n");
-
-    for (i = 0; i < 0xFFFF; i += 16)
-    {
-        printf("%04x: ", i + start);
-
-        for (j = 0; j < 16; j++)
-        {
-            printf("%02x ", controller->AuraRegisterRead(start + i + j));
-        }
-
-        printf("\r\n");
-    }
-
-    fclose(file);
-
-}   /* DumpAuraRegisters() */
-
 void DetectAuraControllers(std::vector<i2c_smbus_interface*> &busses, std::vector<RGBController*> &rgb_controllers);
 void DetectCorsairControllers(std::vector<i2c_smbus_interface*> &busses, std::vector<RGBController*> &rgb_controllers);
 void DetectCorsairProControllers(std::vector<i2c_smbus_interface*> &busses, std::vector<RGBController*> &rgb_controllers);
 void DetectHyperXControllers(std::vector<i2c_smbus_interface*> &busses, std::vector<RGBController*> &rgb_controllers);
+void DetectPatriotViperControllers(std::vector<i2c_smbus_interface*> &busses, std::vector<RGBController*> &rgb_controllers);
+void DetectPolychromeControllers(std::vector<i2c_smbus_interface*>& busses, std::vector<RGBController*>& rgb_controllers);
 void DetectRGBFusionControllers(std::vector<i2c_smbus_interface*>& busses, std::vector<RGBController*>& rgb_controllers);
 void DetectLEDStripControllers(std::vector<RGBController*> &rgb_controllers);
+void DetectHue2Controllers(std::vector<RGBController*> &rgb_controllers);
 void DetectHuePlusControllers(std::vector<RGBController*> &rgb_controllers);
 void DetectOpenRazerControllers(std::vector<RGBController*> &rgb_controllers);
 void DetectRazerChromaSDKControllers(std::vector<RGBController*>& rgb_controllers);
 void DetectE131Controllers(std::vector<RGBController*> &rgb_controllers);
+void DetectAMDWraithPrismControllers(std::vector<RGBController*>& rgb_controllers);
+void DetectAorusGPUControllers(std::vector<RGBController*> &rgb_controllers);
+void DetectMSI3ZoneControllers(std::vector<RGBController*>& rgb_controllers);
+void DetectPoseidonZRGBControllers(std::vector<RGBController*>& rgb_controllers);
+void DetectCorsairKbdV1Controllers(std::vector<RGBController*>& rgb_controllers);
 
 /******************************************************************************************\
 *                                                                                          *
@@ -380,22 +352,33 @@ void DetectRGBControllers(void)
     DetectCorsairControllers(busses, rgb_controllers);
     DetectCorsairProControllers(busses, rgb_controllers);
     DetectHyperXControllers(busses, rgb_controllers);
+    DetectPatriotViperControllers(busses, rgb_controllers);
+    DetectPolychromeControllers(busses, rgb_controllers);
     DetectRGBFusionControllers(busses, rgb_controllers);
 
     DetectLEDStripControllers(rgb_controllers);
+    DetectHue2Controllers(rgb_controllers);
     DetectHuePlusControllers(rgb_controllers);
+
+    DetectAMDWraithPrismControllers(rgb_controllers);
+    DetectMSI3ZoneControllers(rgb_controllers);
+    DetectPoseidonZRGBControllers(rgb_controllers);
+    DetectCorsairKbdV1Controllers(rgb_controllers);
+    
+    DetectE131Controllers(rgb_controllers);
+
+    /*-------------------------------------*\
+    | Windows-only devices                  |
+    \*-------------------------------------*/
 #ifdef WIN32
     DetectRazerChromaSDKControllers(rgb_controllers);
+    //DetectAorusGPUControllers(rgb_controllers);
+
+    /*-------------------------------------*\
+    | Linux-only devices                    |
+    \*-------------------------------------*/
 #else
-    DetectE131Controllers(rgb_controllers);
     DetectOpenRazerControllers(rgb_controllers);
 #endif
 
-    //This is for testing Aorus GPU
-#if 0
-    RGBController_AorusGPU * aorus_rgb = new RGBController_AorusGPU();
-
-    rgb_controllers.push_back(aorus_rgb);
-#endif
-
-}
+}   /* DetectRGBControllers() */

OpenRGB.h

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

OpenRGB.pro

@@ -6,23 +6,32 @@ TARGET = OpenRGB
 TEMPLATE = app
 
 INCLUDEPATH +=                                                          \
+    dependencies/libe131/src/                                           \
     i2c_smbus/                                                          \
     i2c_tools/                                                          \
     net_port/                                                           \
     serial_port/                                                        \
+    Controllers/AMDWraithPrismController/                               \
     Controllers/AuraController/                                         \
     Controllers/CorsairController/                                      \
+    Controllers/CorsairKbdV1Controller/                                 \
     Controllers/CorsairProController/                                   \
+    Controllers/Hue2Controller/                                         \
     Controllers/HuePlusController/                                      \
     Controllers/HyperXController/                                       \
     Controllers/LEDStripController/                                     \
+    Controllers/MSI3ZoneController/                                     \
+    Controllers/PatriotViperController/                                 \
+    Controllers/PolychromeController/                                   \
+    Controllers/PoseidonZRGBController/                                 \
     Controllers/RGBFusionController/                                    \
     RGBController/                                                      \
     qt/
 
 SOURCES +=                                                              \
+    dependencies/libe131/src/e131.c                                     \
     main.cpp                                                            \
-    OpenAuraSDK.cpp                                                     \
+    OpenRGB.cpp                                                         \
     qt/OpenRGBDeviceInfoPage.cpp                                        \
     qt/OpenRGBDevicePage.cpp                                            \
     qt/OpenRGBDialog.cpp                                                \
@@ -33,30 +42,53 @@ SOURCES +=                                                              \
     qt/OpenRGBSystemInfoPage.cpp                                        \
     qt/hsv.cpp                                                          \
     serial_port/serial_port.cpp                                         \
+    Controllers/AMDWraithPrismController/AMDWraithPrismController.cpp   \
+    Controllers/AMDWraithPrismController/AMDWraithPrismControllerDetect.cpp \
     Controllers/AuraController/AuraController.cpp                       \
     Controllers/AuraController/AuraControllerDetect.cpp                 \
     Controllers/CorsairController/CorsairController.cpp                 \
+    Controllers/CorsairKbdV1Controller/CorsairKbdV1Controller.cpp       \
+    Controllers/CorsairKbdV1Controller/CorsairKbdV1ControllerDetect.cpp \
     Controllers/CorsairController/CorsairControllerDetect.cpp           \
     Controllers/CorsairProController/CorsairProController.cpp           \
     Controllers/CorsairProController/CorsairProControllerDetect.cpp     \
+    Controllers/Hue2Controller/Hue2Controller.cpp                       \
+    Controllers/Hue2Controller/Hue2ControllerDetect.cpp                 \
     Controllers/HuePlusController/HuePlusController.cpp                 \
     Controllers/HuePlusController/HuePlusControllerDetect.cpp           \
     Controllers/HyperXController/HyperXController.cpp                   \
     Controllers/HyperXController/HyperXControllerDetect.cpp             \
     Controllers/LEDStripController/LEDStripController.cpp               \
     Controllers/LEDStripController/LEDStripControllerDetect.cpp         \
+    Controllers/MSI3ZoneController/MSI3ZoneController.cpp               \
+    Controllers/MSI3ZoneController/MSI3ZoneControllerDetect.cpp         \
+    Controllers/PatriotViperController/PatriotViperController.cpp       \
+    Controllers/PatriotViperController/PatriotViperControllerDetect.cpp \
+    Controllers/PolychromeController/PolychromeController.cpp           \
+    Controllers/PolychromeController/PolychromeControllerDetect.cpp     \
+    Controllers/PoseidonZRGBController/PoseidonZRGBController.cpp       \
+    Controllers/PoseidonZRGBController/PoseidonZRGBControllerDetect.cpp \
     Controllers/RGBFusionController/RGBFusionController.cpp             \
     Controllers/RGBFusionController/RGBFusionControllerDetect.cpp       \
+    RGBController/RGBController.cpp                                     \
+    RGBController/E131ControllerDetect.cpp                              \
+    RGBController/RGBController_AMDWraithPrism.cpp                      \
     RGBController/RGBController_Aura.cpp                                \
     RGBController/RGBController_Corsair.cpp                             \
+    RGBController/RGBController_CorsairKbdV1.cpp                        \
     RGBController/RGBController_CorsairPro.cpp                          \
+    RGBController/RGBController_Hue2.cpp                                \
     RGBController/RGBController_HuePlus.cpp                             \
     RGBController/RGBController_HyperX.cpp                              \
+    RGBController/RGBController_E131.cpp                                \
     RGBController/RGBController_LEDStrip.cpp                            \
+    RGBController/RGBController_MSI3Zone.cpp                            \
+    RGBController/RGBController_PatriotViper.cpp                        \
+    RGBController/RGBController_Polychrome.cpp                          \
+    RGBController/RGBController_PoseidonZRGB.cpp                        \
     RGBController/RGBController_RGBFusion.cpp
 
 HEADERS +=                                                              \
-    Controllers/RGBFusionController/RGBFusionController.h               \
     qt/OpenRGBDeviceInfoPage.h                                          \
     qt/OpenRGBDevicePage.h                                              \
     qt/OpenRGBDialog.h                                                  \
@@ -65,19 +97,36 @@ HEADERS +=                                                              \
     net_port/net_port.h                                                 \
     qt/OpenRGBDialog2.h                                                 \
     qt/OpenRGBSystemInfoPage.h                                          \
+    serial_port/find_usb_serial_port.h                                  \
     serial_port/serial_port.h                                           \
+    Controllers/AMDWraithPrismController/AMDWraithPrismController.h     \
     Controllers/AuraController/AuraController.h                         \
     Controllers/CorsairController/CorsairController.h                   \
     Controllers/CorsairProController/CorsairProController.h             \
+    Controllers/Hue2Controller/Hue2Controller.h                         \
     Controllers/HuePlusController/HuePlusController.h                   \
     Controllers/HyperXController/HyperXController.h                     \
     Controllers/LEDStripController/LEDStripController.h                 \
+    Controllers/MSI3ZoneController/MSI3ZoneController.h                 \
+    Controllers/PatriotViperController/PatriotViperController.h         \
+    Controllers/PolychromeController/PolychromeController.h             \
+    Controllers/PoseidonZRGBController/PoseidonZRGBController.h         \
+    Controllers/RGBFusionController/RGBFusionController.h               \
     RGBController/RGBController.h                                       \
+    RGBController/RGBController_AMDWraithPrism.h                        \
     RGBController/RGBController_Aura.h                                  \
     RGBController/RGBController_Corsair.h                               \
+    RGBController/RGBController_CorsairKbdV1.h                          \
     RGBController/RGBController_CorsairPro.h                            \
+    RGBController/RGBController_E131.h                                  \
+    RGBController/RGBController_Hue2.h                                  \
     RGBController/RGBController_HuePlus.h                               \
     RGBController/RGBController_HyperX.h                                \
+    RGBController/RGBController_LEDStrip.h                              \
+    RGBController/RGBController_MSI3Zone.h                              \
+    RGBController/RGBController_PatriotViper.h                          \
+    RGBController/RGBController_Polychrome.h                            \
+    RGBController/RGBController_PoseidonZRGB.h                          \
     RGBController/RGBController_RGBFusion.h
 
 RESOURCES += \
@@ -96,13 +145,18 @@ FORMS += \
 win32:INCLUDEPATH +=                                                    \
     dependencies/inpout32_1501/Win32/                                   \
     dependencies/razer-chroma-2.9.0/inc                                 \
+    dependencies/libusb-1.0.22/include                                  \
+    dependencies/hidapi                                                 \
     wmi/                                                                \
 
 win32:SOURCES +=                                                        \
     i2c_smbus/i2c_smbus_i801.cpp                                        \
     i2c_smbus/i2c_smbus_nct6775.cpp                                     \
     i2c_smbus/i2c_smbus_piix4.cpp                                       \
+    serial_port/find_usb_serial_port_win.cpp                            \
     wmi/wmi.cpp                                                         \
+    RGBController/AorusGPUDetect.cpp                                    \
+    RGBController/RGBController_AorusGPU.cpp                            \
     RGBController/RazerChromaSDKDetect.cpp                              \
     RGBController/RGBController_RazerChromaSDK.cpp                      \
 
@@ -112,11 +166,14 @@ win32:HEADERS +=                                                        \
     i2c_smbus/i2c_smbus_nct6775.h                                       \
     i2c_smbus/i2c_smbus_piix4.h                                         \
     wmi/wmi.h                                                           \
+    RGBController/RGBController_AorusGPU.h                              \
     RGBController/RGBController_RazerChromaSDK.h                        \
 
 win32:LIBS +=                                                           \
     -lws2_32                                                            \
-    -L"$$PWD/dependencies/inpout32_1501/Win32/" -linpout32
+    -L"$$PWD/dependencies/inpout32_1501/Win32/" -linpout32              \
+    -L"$$PWD/dependencies/libusb-1.0.22/MS32/dll" -llibusb-1.0          \
+    -L"$$PWD/dependencies/hidapi-win/x86/" -lhidapi
 
 win32:DEFINES -=                                                        \
     UNICODE
@@ -132,16 +189,26 @@ win32:DEFINES +=                                                        \
 # Linux specific project configuration
 #-----------------------------------------------
 unix:INCLUDEPATH +=                                                     \
-    dependencies/libe131/src/                                           \
 
 unix:HEADERS +=                                                         \
     i2c_smbus/i2c_smbus_linux.h                                         \
-    RGBController/RGBController_E131.h                                  \
+
+unix:LIBS +=                                                            \
+    -lusb-1.0                                                           \
+
+packagesExist(hidapi-libusb){
+    unix:LIBS += -lhidapi-libusb
+} else {
+    packagesExist(hidapi) {
+        unix:LIBS += -lhidapi
+    } else {
+        unix:LIBS += -lhidapi-libusb
+    }
+}
+
 
 unix:SOURCES +=                                                         \
-    dependencies/libe131/src/e131.c                                     \
     i2c_smbus/i2c_smbus_linux.cpp                                       \
+    serial_port/find_usb_serial_port_linux.cpp                          \
     RGBController/OpenRazerDetect.cpp                                   \
-    RGBController/E131ControllerDetect.cpp                              \
-    RGBController/RGBController_E131.cpp                                \
     RGBController/RGBController_OpenRazer.cpp                           \

README.md

@@ -31,17 +31,20 @@ After getting a solid Aura implementation, the project branched out into other m
 ## Installation
 #### Windows
   1. Download the latest Visual Studio Community Edition and Qt Creator.
-  2. Open the OpenRGB_Win.pro project.
-  3. Build the project for `x86` Architecture. The InpOut32 library I use does not support x64.
-  4. Copy InpOut32.dll from dependencies to the same path as OpenAuraSDK.exe along with the Qt libraries.
+  2. Update the submodules: git submodule update --init --recursive
+  3. Open the OpenRGB_Win.pro project.
+  4. Build the project for `x86` Architecture. The InpOut32 library I use does not support x64.
+  5. Copy InpOut32.dll from dependencies to the same path as OpenAuraSDK.exe along with the Qt libraries.
 
 **You must run the application as Administrator the first time to allow InpOut32 to set up.  It can be run as a normal user afterwards**
 
 #### Linux:
-  1. Either open the project using QT Creator or build it using qmake.
+  1. Either open the project using QT Creator or build it using qmake.  You will need the libusb-1.0-0 (or equivalent) development package from your distribution's package manager installed.
     
-         cd OpenAuraSDK
-         qmake OpenAuraSDK.pro
+         git clone https://gitlab.com/CalcProgrammer1/OpenRGB
+         cd OpenRGB
+         git submodule update --init --recursive
+         qmake OpenRGB.pro
          make
      
 

RGBController/AorusGPUDetect.cpp

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

RGBController/E131ControllerDetect.cpp

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

RGBController/OpenRazerDetect.cpp

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

RGBController/RGBController.cpp

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

RGBController/RGBController.h

@@ -77,11 +77,23 @@ public:
     std::vector<RGBColor>   colors;         /* Color buffer             */
     device_type             type;           /* device type              */
 
-    virtual int  GetMode()         = 0;
-    virtual void SetMode(int mode) = 0;
-    virtual void SetCustomMode()   = 0;
-    virtual void SetAllLEDs(RGBColor color) = 0;
-	virtual void SetAllZoneLEDs(int zone, RGBColor color) = 0;
-	virtual void SetLED(int led, RGBColor color) = 0;
-    virtual void UpdateLEDs() = 0;
+    virtual ~RGBController() = default;
+
+    /*---------------------------------------------------------*\
+    | Generic functions implemented in RGBController.cpp        |
+    \*---------------------------------------------------------*/
+    RGBColor                GetLED(int led);
+    void                    SetLED(int led, RGBColor color);
+    void                    SetAllLEDs(RGBColor color);
+    void                    SetAllZoneLEDs(int zone, RGBColor color);
+
+    /*---------------------------------------------------------*\
+    | Functions to be implemented in device implementation      |
+    \*---------------------------------------------------------*/
+    virtual int             GetMode()                                   = 0;
+    virtual void            SetMode(int mode)                           = 0;
+    virtual void            SetCustomMode()                             = 0;
+    virtual void            UpdateLEDs()                                = 0;
+    virtual void            UpdateZoneLEDs(int zone)                    = 0;
+    virtual void            UpdateSingleLED(int led)                    = 0;
 };

RGBController/RGBController_AMDWraithPrism.cpp

@@ -0,0 +1,126 @@
+/*-----------------------------------------*\
+|  RGBController_AMDWraithPrism.cpp         |
+|                                           |
+|  Generic RGB Interface for AMD Wraith     |
+|  Prism                                    |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 12/25/2019  |
+\*-----------------------------------------*/
+
+#include "RGBController_AMDWraithPrism.h"
+
+RGBController_AMDWraithPrism::RGBController_AMDWraithPrism(AMDWraithPrismController* wraith_ptr)
+{
+    wraith = wraith_ptr;
+
+    name = "AMD Wraith Prism";
+    type = DEVICE_TYPE_COOLER;
+    version = wraith->GetFirmwareVersionString();
+
+    mode led_mode;
+    led_mode.name = "Custom";
+    modes.push_back(led_mode);
+
+    led logo_led;
+    logo_led.name = "Logo";
+    leds.push_back(logo_led);
+    colors.push_back(0x00000000);
+
+    zone logo_zone;
+    logo_zone.name = "Logo";
+    logo_zone.type = ZONE_TYPE_SINGLE;
+    std::vector<int> logo_zone_map;
+    logo_zone_map.push_back(0);
+    logo_zone.map.push_back(logo_zone_map);
+    zones.push_back(logo_zone);
+
+    led fan_led;
+    fan_led.name = "Fan";
+    leds.push_back(fan_led);
+    colors.push_back(0x00000000);
+
+    zone fan_zone;
+    fan_zone.name = "Fan";
+    fan_zone.type = ZONE_TYPE_SINGLE;
+    std::vector<int> fan_zone_map;
+    fan_zone_map.push_back(1);
+    fan_zone.map.push_back(fan_zone_map);
+    zones.push_back(fan_zone);
+
+    led ring_led;
+    ring_led.name = "Ring";
+    leds.push_back(ring_led);
+    colors.push_back(0x00000000);
+
+    zone ring_zone;
+    ring_zone.name = "Ring";
+    ring_zone.type = ZONE_TYPE_SINGLE;
+    std::vector<int> ring_zone_map;
+    ring_zone_map.push_back(2);
+    ring_zone.map.push_back(ring_zone_map);
+    zones.push_back(ring_zone);   
+}
+
+RGBController_AMDWraithPrism::~RGBController_AMDWraithPrism()
+{
+
+}
+
+int RGBController_AMDWraithPrism::GetMode()
+{
+    return 0;
+}
+
+void RGBController_AMDWraithPrism::SetMode(int /*mode*/)
+{
+
+}
+
+void RGBController_AMDWraithPrism::SetCustomMode()
+{
+
+}
+
+void RGBController_AMDWraithPrism::UpdateLEDs()
+{
+    unsigned char red = RGBGetRValue(colors[0]);
+    unsigned char grn = RGBGetGValue(colors[0]);
+    unsigned char blu = RGBGetBValue(colors[0]);
+    wraith->SetLogoColor(red, grn, blu);
+
+    red = RGBGetRValue(colors[1]);
+    grn = RGBGetGValue(colors[1]);
+    blu = RGBGetBValue(colors[1]);
+    wraith->SetFanColor(red, grn, blu);
+
+    red = RGBGetRValue(colors[2]);
+    grn = RGBGetGValue(colors[2]);
+    blu = RGBGetBValue(colors[2]);
+    wraith->SetRingColor(red, grn, blu);
+}
+
+void RGBController_AMDWraithPrism::UpdateZoneLEDs(int zone)
+{
+    RGBColor      color = colors[zone];
+    unsigned char red   = RGBGetRValue(color);
+    unsigned char grn   = RGBGetGValue(color);
+    unsigned char blu   = RGBGetBValue(color);
+
+    if(zone == 0)
+    {
+        wraith->SetLogoColor(red, grn, blu);
+    }
+    else if(zone == 1)
+    {
+        wraith->SetFanColor(red, grn, blu);
+    }
+    else if(zone == 2)
+    {
+        wraith->SetRingColor(red, grn, blu);
+    }
+}
+
+void RGBController_AMDWraithPrism::UpdateSingleLED(int led)
+{
+    UpdateZoneLEDs(led);
+}

RGBController/RGBController_AMDWraithPrism.h

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

RGBController/RGBController_AorusGPU.cpp

@@ -35,8 +35,9 @@ void RGBController_AorusGPU::SetCustomMode()
 
 }
 
-void RGBController_AorusGPU::SetAllLEDs(RGBColor color)
+void RGBController_AorusGPU::UpdateLEDs()
 {
+    RGBColor color = colors[0];
     data[9] = RGBGetRValue(color);
     data[10] = RGBGetGValue(color);
     data[11] = RGBGetBValue(color);
@@ -44,27 +45,20 @@ void RGBController_AorusGPU::SetAllLEDs(RGBColor color)
     GvWriteI2C(0x00000000, data, 0x00000000);
 }
 
-void RGBController_AorusGPU::SetAllZoneLEDs(int zone, RGBColor color)
+void RGBController_AorusGPU::UpdateZoneLEDs(int zone)
 {
-    data[9] = RGBGetRValue(color);
-    data[10] = RGBGetGValue(color);
-    data[11] = RGBGetBValue(color);
-
-    GvWriteI2C(0x00000000, data, 0x00000000);
+    UpdateLEDs();
 }
 
-void RGBController_AorusGPU::SetLED(int led, RGBColor color)
+void RGBController_AorusGPU::UpdateSingleLED(int led)
 {
-    data[9] = RGBGetRValue(color);
-    data[10] = RGBGetGValue(color);
-    data[11] = RGBGetBValue(color);
-
-    GvWriteI2C(0x00000000, data, 0x00000000);
+    UpdateLEDs();
 }
 
 RGBController_AorusGPU::RGBController_AorusGPU()
 {
     name = "Aorus GPU";
+    type = DEVICE_TYPE_GPU;
 
     handle = LoadLibrary("GvDisplay.dll");
 
@@ -75,6 +69,8 @@ RGBController_AorusGPU::RGBController_AorusGPU()
     GvFreeDispLib();
     GvInitDispLib();
 
+    colors.push_back(0x00000000);
+
     mode aorus_mode;
     aorus_mode.name = "Static";
     modes.push_back(aorus_mode);
@@ -89,4 +85,4 @@ RGBController_AorusGPU::RGBController_AorusGPU()
     aorus_zone_map.push_back(0);
     aorus_zone.map.push_back(aorus_zone_map);
     zones.push_back(aorus_zone);
-}
+}

RGBController/RGBController_AorusGPU.h

@@ -19,15 +19,15 @@ class RGBController_AorusGPU : public RGBController
 {
 public:
     RGBController_AorusGPU();
-    int GetMode();
-    void SetMode(int mode);
-    void SetCustomMode();
-    void SetAllLEDs(RGBColor color);
-    void SetAllZoneLEDs(int zone, RGBColor color);
-    void SetLED(int led, RGBColor color);
+    int         GetMode();
+    void        SetMode(int mode);
+    void        SetCustomMode();
+    void        UpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
 
 private:
     _GvWriteI2C GvWriteI2C;
     _GvFreeDispLib GvFreeDispLib;
     _GvInitDispLib GvInitDispLib;
-};
+};

RGBController/RGBController_Aura.cpp

@@ -39,63 +39,9 @@ void RGBController_Aura::SetCustomMode()
     aura->SetDirect(true);
 }
 
-void RGBController_Aura::SetAllLEDs(RGBColor color)
-{
-    unsigned char red = RGBGetRValue(color);
-    unsigned char grn = RGBGetGValue(color);
-    unsigned char blu = RGBGetBValue(color);
-
-    if (GetMode() == 0)
-    {
-        aura->SetAllColorsDirect(red, grn, blu);
-    }
-    else
-    {
-        aura->SetAllColorsEffect(red, grn, blu);
-    }
-}
-
-void RGBController_Aura::SetAllZoneLEDs(int zone, RGBColor color)
-{
-    unsigned char red = RGBGetRValue(color);
-    unsigned char grn = RGBGetGValue(color);
-    unsigned char blu = RGBGetBValue(color);
-
-    for (int x = 0; x < zones[zone].map.size(); x++)
-    {
-        for (int y = 0; y < zones[zone].map[x].size(); y++)
-        {
-            if (GetMode() == 0)
-            {
-                aura->SetLEDColorDirect(zones[zone].map[x][y], red, grn, blu);
-            }
-            else
-            {
-                aura->SetLEDColorEffect(zones[zone].map[x][y], red, grn, blu);
-            }
-        }
-    }
-}
-
-void RGBController_Aura::SetLED(int led, RGBColor color)
-{
-    unsigned char red = RGBGetRValue(color);
-    unsigned char grn = RGBGetGValue(color);
-    unsigned char blu = RGBGetBValue(color);
-
-    if (GetMode() == 0)
-    {
-        aura->SetLEDColorDirect(led, red, grn, blu);
-    }
-    else
-    {
-        aura->SetLEDColorEffect(led, red, grn, blu);
-    }
-}
-
 void RGBController_Aura::UpdateLEDs()
 {
-    for(int led = 0; led < colors.size(); led++)
+    for(std::size_t led = 0; led < colors.size(); led++)
     {
         unsigned char red = RGBGetRValue(colors[led]);
         unsigned char grn = RGBGetGValue(colors[led]);
@@ -112,6 +58,47 @@ void RGBController_Aura::UpdateLEDs()
     }
 }
 
+void RGBController_Aura::UpdateZoneLEDs(int zone)
+{
+    for (std::size_t x = 0; x < zones[zone].map.size(); x++)
+    {
+        for (std::size_t y = 0; y < zones[zone].map[x].size(); y++)
+        {
+            int           led   = zones[zone].map[x][y];
+            RGBColor      color = colors[led];
+            unsigned char red   = RGBGetRValue(color);
+            unsigned char grn   = RGBGetGValue(color);
+            unsigned char blu   = RGBGetBValue(color);
+
+            if (GetMode() == 0)
+            {
+                aura->SetLEDColorDirect(led, red, grn, blu);
+            }
+            else
+            {
+                aura->SetLEDColorEffect(led, red, grn, blu);
+            }
+        }
+    }
+}
+
+void RGBController_Aura::UpdateSingleLED(int led)
+{
+    RGBColor color    = colors[led];
+    unsigned char red = RGBGetRValue(color);
+    unsigned char grn = RGBGetGValue(color);
+    unsigned char blu = RGBGetBValue(color);
+
+    if (GetMode() == 0)
+    {
+        aura->SetLEDColorDirect(led, red, grn, blu);
+    }
+    else
+    {
+        aura->SetLEDColorEffect(led, red, grn, blu);
+    }
+}
+
 RGBController_Aura::RGBController_Aura(AuraController * aura_ptr)
 {
     std::vector<unsigned char> aura_channels;
@@ -149,12 +136,14 @@ RGBController_Aura::RGBController_Aura(AuraController * aura_ptr)
     aura_modes[13].name = "Chase Rainbow Pulse";
     aura_modes[14].name = "Random Flicker";
 
-    for (int i = 0; i < (AURA_NUMBER_MODES + 1); i++)
+    for (std::size_t i = 0; i < (AURA_NUMBER_MODES + 1); i++)
     {
         modes.push_back(aura_modes[i]);
     }
 
-    for (int i = 0; i < aura->GetLEDCount(); i++)
+    colors.resize(aura->GetLEDCount());
+
+    for (std::size_t i = 0; i < aura->GetLEDCount(); i++)
     {
         aura_channels.push_back(aura->GetChannel(i));
 
@@ -163,18 +152,23 @@ RGBController_Aura::RGBController_Aura(AuraController * aura_ptr)
         new_led->name = aura->GetChannelName(i);
 
         leds.push_back(*new_led);
-        colors.push_back(0x00000000);
+
+        unsigned char red = aura->GetLEDRed(i);
+        unsigned char grn = aura->GetLEDGreen(i);
+        unsigned char blu = aura->GetLEDBlue(i);
+
+        colors[i] = ToRGBColor(red, grn, blu);
     }
 
     std::vector<unsigned char> aura_zones;
 
     // Search through all LEDs and create zones for each channel type
-    for (int i = 0; i < aura_channels.size(); i++)
+    for (std::size_t i = 0; i < aura_channels.size(); i++)
     {
         bool matched = false;
 
         // Search through existing zones to make sure we don't create a duplicate zone
-        for (int j = 0; j < aura_zones.size(); j++)
+        for (std::size_t j = 0; j < aura_zones.size(); j++)
         {
             if (aura_channels[i] == aura_zones[j])
             {
@@ -192,7 +186,7 @@ RGBController_Aura::RGBController_Aura(AuraController * aura_ptr)
             new_zone->name = aura->GetChannelName(i);
 
             // Find all LEDs with this channel type and add them to zone
-            for (int j = 0; j < aura->GetLEDCount(); j++)
+            for (std::size_t j = 0; j < aura->GetLEDCount(); j++)
             {
                 if (aura->GetChannel(j) == aura_channels[i])
                 {

RGBController/RGBController_Aura.h

@@ -16,14 +16,13 @@ class RGBController_Aura : public RGBController
 {
 public:
     RGBController_Aura(AuraController* aura_ptr);
-    int GetMode();
-    void SetMode(int mode);
-    void SetCustomMode();
-    void SetAllLEDs(RGBColor color);
-    void SetAllZoneLEDs(int zone, RGBColor color);
-    void SetLED(int led, RGBColor color);
-    void UpdateLEDs();
+    int         GetMode();
+    void        SetMode(int mode);
+    void        SetCustomMode();
+    void        UpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
 
 private:
     AuraController* aura;
-};
+};

RGBController/RGBController_Corsair.cpp

@@ -24,42 +24,24 @@ void RGBController_Corsair::SetCustomMode()
 
 }
 
-void RGBController_Corsair::SetAllLEDs(RGBColor color)
-{
-    unsigned char red = RGBGetRValue(color);
-    unsigned char grn = RGBGetGValue(color);
-    unsigned char blu = RGBGetBValue(color);
-
-    corsair->SetAllColors(red, grn, blu);
-}
-
-void RGBController_Corsair::SetAllZoneLEDs(int zone, RGBColor color)
-{
-    unsigned char red = RGBGetRValue(color);
-    unsigned char grn = RGBGetGValue(color);
-    unsigned char blu = RGBGetBValue(color);
-
-    for (int x = 0; x < zones[zone].map.size(); x++)
-    {
-        for (int y = 0; y < zones[zone].map[x].size(); y++)
-        {
-            corsair->SetLEDColor(zones[zone].map[x][y], red, grn, blu);
-        }
-    }
-}
-
-void RGBController_Corsair::SetLED(int led, RGBColor color)
-{
-    unsigned char red = RGBGetRValue(color);
-    unsigned char grn = RGBGetGValue(color);
-    unsigned char blu = RGBGetBValue(color);
-
-    corsair->SetLEDColor(led, red, grn, blu);
-}
-
 void RGBController_Corsair::UpdateLEDs()
 {
+    RGBColor      color = colors[0];
+    unsigned char red   = RGBGetRValue(color);
+    unsigned char grn   = RGBGetGValue(color);
+    unsigned char blu   = RGBGetBValue(color);
 
+    corsair->SetLEDColor(red, grn, blu);
+}
+
+void RGBController_Corsair::UpdateZoneLEDs(int zone)
+{
+    UpdateLEDs();
+}
+
+void RGBController_Corsair::UpdateSingleLED(int led)
+{
+    UpdateLEDs();
 }
 
 RGBController_Corsair::RGBController_Corsair(CorsairController* corsair_ptr)
@@ -82,7 +64,7 @@ RGBController_Corsair::RGBController_Corsair(CorsairController* corsair_ptr)
         modes.push_back(corsair_modes[i]);
     }
 
-    for (int i = 0; i < corsair->GetLEDCount(); i++)
+    for (unsigned int i = 0; i < corsair->GetLEDCount(); i++)
     {
         led* new_led = new led();
 
@@ -99,7 +81,7 @@ RGBController_Corsair::RGBController_Corsair(CorsairController* corsair_ptr)
 
     std::vector<int> zone_row;
 
-    for (int i = 0; i < corsair->GetLEDCount(); i++)
+    for (unsigned int i = 0; i < corsair->GetLEDCount(); i++)
     {
         zone_row.push_back(i);
     }

RGBController/RGBController_Corsair.h

@@ -16,13 +16,12 @@ class RGBController_Corsair : public RGBController
 {
 public:
     RGBController_Corsair(CorsairController* corsair_ptr);
-    int GetMode();
-    void SetMode(int mode);
-    void SetCustomMode();
-    void SetAllLEDs(RGBColor color);
-    void SetAllZoneLEDs(int zone, RGBColor color);
-    void SetLED(int led, RGBColor color);
-    void UpdateLEDs();
+    int         GetMode();
+    void        SetMode(int mode);
+    void        SetCustomMode();
+    void        UpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
 
 private:
     CorsairController* corsair;

RGBController/RGBController_CorsairKbdV1.cpp

@@ -0,0 +1,58 @@
+/*-----------------------------------------*\
+|  RGBController_CorsairKbdV1.cpp           |
+|                                           |
+|  Generic RGB Interface for first-gen      |
+|  Corsair RGB keyboard                     |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 1/9/2020    |
+\*-----------------------------------------*/
+
+#include "RGBController_CorsairKbdV1.h"
+
+RGBController_CorsairKbdV1::RGBController_CorsairKbdV1(CorsairKbdV1Controller* corsair_ptr)
+{
+    corsair = corsair_ptr;
+
+    name = "Corsair RGB Keyboard";
+    type = DEVICE_TYPE_KEYBOARD;
+
+    for(int i = 0; i < 144; i++)
+    {
+        colors.push_back(0x00000000);
+    }
+}
+
+RGBController_CorsairKbdV1::~RGBController_CorsairKbdV1()
+{
+
+}
+
+int RGBController_CorsairKbdV1::GetMode()
+{
+    return 0;
+}
+
+void RGBController_CorsairKbdV1::SetMode(int mode)
+{
+
+}
+
+void RGBController_CorsairKbdV1::SetCustomMode()
+{
+
+}
+
+void RGBController_CorsairKbdV1::UpdateLEDs()
+{
+    corsair->SetLEDs(colors);
+}
+
+void RGBController_CorsairKbdV1::UpdateZoneLEDs(int zone)
+{
+    corsair->SetLEDs(colors);
+}
+
+void RGBController_CorsairKbdV1::UpdateSingleLED(int led)
+{
+    corsair->SetLEDs(colors);
+}

RGBController/RGBController_CorsairKbdV1.h

@@ -0,0 +1,28 @@
+/*-----------------------------------------*\
+|  RGBController_CorsairKbdV1.h             |
+|                                           |
+|  Generic RGB Interface for first-gen      |
+|  Corsair RGB keyboard                     |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 1/9/2020    |
+\*-----------------------------------------*/
+
+#pragma once
+#include "RGBController.h"
+#include "CorsairKbdV1Controller.h"
+
+class RGBController_CorsairKbdV1 : public RGBController
+{
+public:
+    RGBController_CorsairKbdV1(CorsairKbdV1Controller* corsair_ptr);
+    ~RGBController_CorsairKbdV1();
+    int         GetMode();
+    void        SetMode(int mode);
+    void        SetCustomMode();
+    void        UpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+private:
+    CorsairKbdV1Controller*   corsair;
+};

RGBController/RGBController_CorsairPro.cpp

@@ -11,6 +11,40 @@
 
 int RGBController_CorsairPro::GetMode()
 {
+    switch (corsair->GetEffect())
+    {
+    case CORSAIR_PRO_MODE_COLOR_SHIFT:
+        return(0);
+        break;
+    case CORSAIR_PRO_MODE_COLOR_PULSE:
+        return(1);
+        break;
+    case CORSAIR_PRO_MODE_RAINBOW_WAVE:
+        return(2);
+        break;
+    case CORSAIR_PRO_MODE_COLOR_WAVE:
+        return(3);
+        break;
+    case CORSAIR_PRO_MODE_VISOR:
+        return(4);
+        break;
+    case CORSAIR_PRO_MODE_RAIN:
+        return(5);
+        break;
+    case CORSAIR_PRO_MODE_MARQUEE:
+        return(6);
+        break;
+    case CORSAIR_PRO_MODE_RAINBOW:
+        return(7);
+        break;
+    case CORSAIR_PRO_MODE_SEQUENTIAL:
+        return(8);
+        break;
+    case CORSAIR_PRO_MODE_STATIC:
+        return(9);
+        break;
+    }
+
     return(0);
 }
 
@@ -56,48 +90,36 @@ void RGBController_CorsairPro::SetCustomMode()
     corsair->SetCustom();
 }
 
-void RGBController_CorsairPro::SetAllLEDs(RGBColor color)
+void RGBController_CorsairPro::UpdateLEDs()
 {
-    unsigned char red = RGBGetRValue(color);
-    unsigned char grn = RGBGetGValue(color);
-    unsigned char blu = RGBGetBValue(color);
-
-    corsair->SetAllColors(red, grn, blu);
-    corsair->ApplyColors();
-}
-
-void RGBController_CorsairPro::SetAllZoneLEDs(int zone, RGBColor color)
-{
-    unsigned char red = RGBGetRValue(color);
-    unsigned char grn = RGBGetGValue(color);
-    unsigned char blu = RGBGetBValue(color);
-
-    for (int x = 0; x < zones[zone].map.size(); x++)
+    for (std::size_t led = 0; led < colors.size(); led++)
     {
-        for (int y = 0; y < zones[zone].map[x].size(); y++)
-        {
-            corsair->SetLEDColor(zones[zone].map[x][y], red, grn, blu);
-        }
+        RGBColor      color = colors[led];
+        unsigned char red   = RGBGetRValue(color);
+        unsigned char grn   = RGBGetGValue(color);
+        unsigned char blu   = RGBGetBValue(color);
+        corsair->SetLEDColor(led, red, grn, blu);
     }
 
     corsair->ApplyColors();
 }
 
-void RGBController_CorsairPro::SetLED(int led, RGBColor color)
+void RGBController_CorsairPro::UpdateZoneLEDs(int zone)
 {
-    unsigned char red = RGBGetRValue(color);
-    unsigned char grn = RGBGetGValue(color);
-    unsigned char blu = RGBGetBValue(color);
+    UpdateLEDs();
+}
+
+void RGBController_CorsairPro::UpdateSingleLED(int led)
+{
+    RGBColor      color = colors[led];
+    unsigned char red   = RGBGetRValue(color);
+    unsigned char grn   = RGBGetGValue(color);
+    unsigned char blu   = RGBGetBValue(color);
 
     corsair->SetLEDColor(led, red, grn, blu);
     corsair->ApplyColors();
 }
 
-void RGBController_CorsairPro::UpdateLEDs()
-{
-
-}
-
 RGBController_CorsairPro::RGBController_CorsairPro(CorsairProController* corsair_ptr)
 {
     corsair = corsair_ptr;
@@ -125,14 +147,15 @@ RGBController_CorsairPro::RGBController_CorsairPro(CorsairProController* corsair
         modes.push_back(corsair_modes[i]);
     }
 
-    for (int i = 0; i < corsair->GetLEDCount(); i++)
+    colors.resize(corsair->GetLEDCount());
+
+    for (unsigned int i = 0; i < corsair->GetLEDCount(); i++)
     {
         led* new_led = new led();
 
         new_led->name = "Corsair Pro LED";
 
         leds.push_back(*new_led);
-        colors.push_back(0x00000000);
     }
 
     zone new_zone;
@@ -142,7 +165,7 @@ RGBController_CorsairPro::RGBController_CorsairPro(CorsairProController* corsair
 
     std::vector<int> zone_row;
 
-    for (int i = 0; i < corsair->GetLEDCount(); i++)
+    for (unsigned int i = 0; i < corsair->GetLEDCount(); i++)
     {
         zone_row.push_back(i);
     }

RGBController/RGBController_CorsairPro.h

@@ -16,14 +16,13 @@ class RGBController_CorsairPro : public RGBController
 {
 public:
     RGBController_CorsairPro(CorsairProController* corsair_ptr);
-    int GetMode();
-    void SetMode(int mode);
-    void SetCustomMode();
-    void SetAllLEDs(RGBColor color);
-    void SetAllZoneLEDs(int zone, RGBColor color);
-    void SetLED(int led, RGBColor color);
-    void UpdateLEDs();
+    int         GetMode();
+    void        SetMode(int mode);
+    void        SetCustomMode();
+    void        UpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
 
 private:
     CorsairProController* corsair;
-};
+};

RGBController/RGBController_E131.cpp

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

RGBController/RGBController_E131.h

@@ -37,13 +37,12 @@ class RGBController_E131 : public RGBController
 {
 public:
     RGBController_E131(std::vector<E131Device> device_list);
-    int GetMode();
-    void SetMode(int mode);
-    void SetCustomMode();
-    void SetAllLEDs(RGBColor color);
-    void SetAllZoneLEDs(int zone, RGBColor color);
-    void SetLED(int led, RGBColor color);
-    void UpdateLEDs();
+    int         GetMode();
+    void        SetMode(int mode);
+    void        SetCustomMode();
+    void        UpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
 
 private:
 	std::vector<E131Device> 	devices;
@@ -51,4 +50,4 @@ private:
 	std::vector<e131_addr_t> 	dest_addrs;
 	std::vector<unsigned int> 	universes;
 	int 						sockfd;
-};
+};

RGBController/RGBController_Hue2.cpp

@@ -0,0 +1,154 @@
+/*-----------------------------------------*\
+|  RGBController_Hue2.cpp                   |
+|                                           |
+|  Generic RGB Interface for NZXT Hue 2     |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 12/29/2019  |
+\*-----------------------------------------*/
+
+#include "RGBController_Hue2.h"
+
+
+RGBController_Hue2::RGBController_Hue2(Hue2Controller* hue2_ptr)
+{
+    hue2 = hue2_ptr;
+
+    name = "NZXT Hue 2";
+
+    type = DEVICE_TYPE_LEDSTRIP;
+    
+    mode led_mode;
+    led_mode.name = "Custom";
+    modes.push_back(led_mode);
+
+    /*-------------------------------------------------*\
+    | Set size of colors array                          |
+    \*-------------------------------------------------*/
+    unsigned int led_count = 0;
+    for (unsigned int channel_idx = 0; channel_idx < HUE_2_NUM_CHANNELS; channel_idx++)
+    {
+        led_count += hue2->channel_leds[channel_idx];
+    }
+    colors.resize(led_count);
+
+    /*-------------------------------------------------*\
+    | Set zones and leds                                |
+    \*-------------------------------------------------*/
+    unsigned int led_idx = 0;
+    for (unsigned int channel_idx = 0; channel_idx < HUE_2_NUM_CHANNELS; channel_idx++)
+    {
+        if(hue2->channel_leds[channel_idx] > 0)
+        {
+            zone* new_zone = new zone;
+
+            char ch_idx_string[2];
+            sprintf(ch_idx_string, "%d", channel_idx + 1);
+
+            new_zone->name = "Hue 2 Channel ";
+            new_zone->name.append(ch_idx_string);
+            new_zone->type = ZONE_TYPE_LINEAR;
+
+            std::vector<int> *new_zone_map = new std::vector<int>();
+
+            for (unsigned int led_ch_idx = 0; led_ch_idx < hue2->channel_leds[channel_idx]; led_ch_idx++)
+            {
+                char led_idx_string[3];
+                sprintf(led_idx_string, "%d", led_ch_idx + 1);
+
+                led new_led;
+                new_led.name = "Hue 2 Channel ";
+                new_led.name.append(ch_idx_string);
+                new_led.name.append(", LED ");
+                new_led.name.append(led_idx_string);
+
+                leds.push_back(new_led);
+                leds_channel.push_back(channel_idx);
+
+                new_zone_map->push_back(led_idx);
+                led_idx++;
+            }
+
+            new_zone->map.push_back(*new_zone_map);
+            zones.push_back(*new_zone);
+            zones_channel.push_back(channel_idx);
+        }
+    }
+}
+
+int RGBController_Hue2::GetMode()
+{
+    return 0;
+}
+
+void RGBController_Hue2::SetMode(int /*mode*/)
+{
+
+}
+
+void RGBController_Hue2::SetCustomMode()
+{
+
+}
+
+void RGBController_Hue2::UpdateLEDs()
+{
+    for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
+    {
+        unsigned int channel = zones_channel[zone_idx];
+
+        std::vector<RGBColor> channel_colors;
+
+        for(std::size_t color = 0; color < colors.size(); color++)
+        {
+            if(leds_channel[color] == channel)
+            {
+                channel_colors.push_back(colors[color]);
+            }
+        }
+
+        if(channel_colors.size() > 0)
+        {
+            hue2->SetChannelLEDs(channel, channel_colors);
+        }
+    }
+}
+
+void RGBController_Hue2::UpdateZoneLEDs(int zone)
+{
+    unsigned int channel = zones_channel[zone];
+
+    std::vector<RGBColor> channel_colors;
+
+    for(std::size_t color = 0; color < colors.size(); color++)
+    {
+        if(leds_channel[color] == channel)
+        {
+            channel_colors.push_back(colors[color]);
+        }
+    }
+
+    if(channel_colors.size() > 0)
+    {
+        hue2->SetChannelLEDs(channel, channel_colors);
+    }
+}
+
+void RGBController_Hue2::UpdateSingleLED(int led)
+{
+    unsigned int channel = leds_channel[led];
+
+    std::vector<RGBColor> channel_colors;
+
+    for(std::size_t color = 0; color < colors.size(); color++)
+    {
+        if(leds_channel[color] == channel)
+        {
+            channel_colors.push_back(colors[color]);
+        }
+    }
+
+    if(channel_colors.size() > 0)
+    {
+        hue2->SetChannelLEDs(channel, channel_colors);
+    }
+}

RGBController/RGBController_Hue2.h

@@ -0,0 +1,29 @@
+/*-----------------------------------------*\
+|  RGBController_Hue2.h                     |
+|                                           |
+|  Generic RGB Interface for NZXT Hue 2     |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 12/29/2019  |
+\*-----------------------------------------*/
+
+#pragma once
+#include "RGBController.h"
+#include "serial_port.h"
+#include "Hue2Controller.h"
+
+class RGBController_Hue2 : public RGBController
+{
+public:
+    RGBController_Hue2(Hue2Controller* hue2_ptr);
+    int         GetMode();
+    void        SetMode(int mode);
+    void        SetCustomMode();
+    void        UpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+private:
+    Hue2Controller*             hue2;
+    std::vector<unsigned int>   leds_channel;
+    std::vector<unsigned int>   zones_channel;
+};

RGBController/RGBController_HuePlus.cpp

@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  RGBController_HuePlus.cpp               |
+|  RGBController_HuePlus.cpp                |
 |                                           |
 |  Generic RGB Interface for NZXT Hue+      |
 |                                           |
@@ -23,8 +23,20 @@ RGBController_HuePlus::RGBController_HuePlus(HuePlusController* hueplus_ptr)
     led_mode.name = "Custom";
     modes.push_back(led_mode);
 
-    unsigned int led_idx = 0;
+    /*-------------------------------------------------*\
+    | Set size of colors array                          |
+    \*-------------------------------------------------*/
+    unsigned int led_count = 0;
+    for (unsigned int channel_idx = 0; channel_idx < HUE_PLUS_NUM_CHANNELS; channel_idx++)
+    {
+        led_count += hueplus->channel_leds[channel_idx];
+    }
+    colors.resize(led_count);
 
+    /*-------------------------------------------------*\
+    | Set zones and leds                                |
+    \*-------------------------------------------------*/
+    unsigned int led_idx = 0;
     for (int channel_idx = 0; channel_idx < HUE_PLUS_NUM_CHANNELS; channel_idx++)
     {
         if(hueplus->channel_leds[channel_idx] > 0)
@@ -40,10 +52,8 @@ RGBController_HuePlus::RGBController_HuePlus(HuePlusController* hueplus_ptr)
 
             std::vector<int> *new_zone_map = new std::vector<int>();
 
-            for (int led_ch_idx = 0; led_ch_idx < hueplus->channel_leds[channel_idx]; led_ch_idx++)
+            for (unsigned led_ch_idx = 0; led_ch_idx < hueplus->channel_leds[channel_idx]; led_ch_idx++)
             {
-                colors.push_back(0x00000000);
-
                 char led_idx_string[3];
                 sprintf(led_idx_string, "%d", led_ch_idx + 1);
 
@@ -72,7 +82,7 @@ int RGBController_HuePlus::GetMode()
     return 0;
 }
 
-void RGBController_HuePlus::SetMode(int mode)
+void RGBController_HuePlus::SetMode(int /*mode*/)
 {
 
 }
@@ -82,59 +92,65 @@ void RGBController_HuePlus::SetCustomMode()
 
 }
 
-void RGBController_HuePlus::SetAllLEDs(RGBColor color)
-{
-    for (int i = 0; i < colors.size(); i++)
-    {
-        colors[i] = color;
-    }
-
-    hueplus->SetChannelLEDs(0, colors);
-}
-
-void RGBController_HuePlus::SetAllZoneLEDs(int zone, RGBColor color)
-{
-    int channel = zones_channel[zone];
-
-    for (int x = 0; x < zones[zone].map.size(); x++)
-    {
-        for (int y = 0; y < zones[zone].map[x].size(); y++)
-        {
-            colors[zones[zone].map[x][y]] = color;
-        }
-    }
-
-    std::vector<RGBColor> channel_colors;
-
-    for(int color = 0; color < colors.size(); color++)
-    {
-        if(leds_channel[color] == channel)
-        {
-            channel_colors.push_back(colors[color]);
-        }
-    }
-
-    hueplus->SetChannelLEDs(channel, channel_colors);
-}
-
-void RGBController_HuePlus::SetLED(int led, RGBColor color)
-{
-    int channel = leds_channel[led];
-    colors[led] = color;
-
-    std::vector<RGBColor> channel_colors;
-
-    for(int color = 0; color < colors.size(); color++)
-    {
-        if(leds_channel[color] == channel)
-        {
-            channel_colors.push_back(colors[color]);
-        }
-    }
-    hueplus->SetChannelLEDs(channel, channel_colors);
-}
-
 void RGBController_HuePlus::UpdateLEDs()
 {
-    hueplus->SetChannelLEDs(0, colors);
+    for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
+    {
+        unsigned int channel = zones_channel[zone_idx];
+
+        std::vector<RGBColor> channel_colors;
+
+        for(std::size_t color = 0; color < colors.size(); color++)
+        {
+            if(leds_channel[color] == channel)
+            {
+                channel_colors.push_back(colors[color]);
+            }
+        }
+
+        if(channel_colors.size() > 0)
+        {
+            hueplus->SetChannelLEDs(channel, channel_colors);
+        }
+    }
+}
+
+void RGBController_HuePlus::UpdateZoneLEDs(int zone)
+{
+    unsigned int channel = zones_channel[zone];
+
+    std::vector<RGBColor> channel_colors;
+
+    for(std::size_t color = 0; color < colors.size(); color++)
+    {
+        if(leds_channel[color] == channel)
+        {
+            channel_colors.push_back(colors[color]);
+        }
+    }
+
+    if(channel_colors.size() > 0)
+    {
+        hueplus->SetChannelLEDs(channel, channel_colors);
+    }
+}
+
+void RGBController_HuePlus::UpdateSingleLED(int led)
+{
+    unsigned int channel = leds_channel[led];
+
+    std::vector<RGBColor> channel_colors;
+
+    for(std::size_t color = 0; color < colors.size(); color++)
+    {
+        if(leds_channel[color] == channel)
+        {
+            channel_colors.push_back(colors[color]);
+        }
+    }
+
+    if(channel_colors.size() > 0)
+    {
+        hueplus->SetChannelLEDs(channel, channel_colors);
+    }
 }

RGBController/RGBController_HuePlus.h

@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  RGBController_HuePlus.h                 |
+|  RGBController_HuePlus.h                  |
 |                                           |
 |  Generic RGB Interface for NZXT Hue+      |
 |                                           |
@@ -15,16 +15,15 @@ class RGBController_HuePlus : public RGBController
 {
 public:
     RGBController_HuePlus(HuePlusController* hueplus_ptr);
-    int GetMode();
-    void SetMode(int mode);
-    void SetCustomMode();
-    void SetAllLEDs(RGBColor color);
-    void SetAllZoneLEDs(int zone, RGBColor color);
-    void SetLED(int led, RGBColor color);
-    void UpdateLEDs();
+    int         GetMode();
+    void        SetMode(int mode);
+    void        SetCustomMode();
+    void        UpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
 
 private:
     HuePlusController*          hueplus;
     std::vector<unsigned int>   leds_channel;
     std::vector<unsigned int>   zones_channel;
-};
+};

RGBController/RGBController_HyperX.cpp

@@ -24,50 +24,67 @@ void RGBController_HyperX::SetCustomMode()
     hyperx->SetMode(HYPERX_MODE_DIRECT);
 }
 
-void RGBController_HyperX::SetAllLEDs(RGBColor color)
+void RGBController_HyperX::UpdateLEDs()
 {
-    unsigned char red = RGBGetRValue(color);
-    unsigned char grn = RGBGetGValue(color);
-    unsigned char blu = RGBGetBValue(color);
-
     if(hyperx->GetMode() == HYPERX_MODE_DIRECT)
     {
-        hyperx->SetAllColors(red, grn, blu);
-    }
-    else
-    {
-        hyperx->SetEffectColor(red, grn, blu);
-    }
-    
-}
-
-void RGBController_HyperX::SetAllZoneLEDs(int zone, RGBColor color)
-{
-    unsigned char red = RGBGetRValue(color);
-    unsigned char grn = RGBGetGValue(color);
-    unsigned char blu = RGBGetBValue(color);
-
-    if(hyperx->GetMode() == HYPERX_MODE_DIRECT)
-    {
-        for (int x = 0; x < zones[zone].map.size(); x++)
+        for (std::size_t zone = 0; zone < zones.size(); zone++ )
         {
-            for (int y = 0; y < zones[zone].map[x].size(); y++)
+            for (std::size_t x = 0; x < zones[zone].map.size(); x++)
             {
-                hyperx->SetLEDColor(zones[zone].map[x][y], red, grn, blu);
+                for (std::size_t y = 0; y < zones[zone].map[x].size(); y++)
+                {
+                    int           led   = zones[zone].map[x][y];
+                    RGBColor      color = colors[led];
+                    unsigned char red = RGBGetRValue(color);
+                    unsigned char grn = RGBGetGValue(color);
+                    unsigned char blu = RGBGetBValue(color);
+                    hyperx->SetLEDColor(led, red, grn, blu);
+                }
             }
         }
     }
     else
     {
+        unsigned char red = RGBGetRValue(colors[0]);
+        unsigned char grn = RGBGetGValue(colors[0]);
+        unsigned char blu = RGBGetBValue(colors[0]);
         hyperx->SetEffectColor(red, grn, blu);
     }
 }
 
-void RGBController_HyperX::SetLED(int led, RGBColor color)
+void RGBController_HyperX::UpdateZoneLEDs(int zone)
 {
-    unsigned char red = RGBGetRValue(color);
-    unsigned char grn = RGBGetGValue(color);
-    unsigned char blu = RGBGetBValue(color);
+    if(hyperx->GetMode() == HYPERX_MODE_DIRECT)
+    {
+        for (std::size_t x = 0; x < zones[zone].map.size(); x++)
+        {
+            for (std::size_t y = 0; y < zones[zone].map[x].size(); y++)
+            {
+                int           led   = zones[zone].map[x][y];
+                RGBColor      color = colors[led];
+                unsigned char red = RGBGetRValue(color);
+                unsigned char grn = RGBGetGValue(color);
+                unsigned char blu = RGBGetBValue(color);
+                hyperx->SetLEDColor(led, red, grn, blu);
+            }
+        }
+    }
+    else
+    {
+        unsigned char red = RGBGetRValue(colors[0]);
+        unsigned char grn = RGBGetGValue(colors[0]);
+        unsigned char blu = RGBGetBValue(colors[0]);
+        hyperx->SetEffectColor(red, grn, blu);
+    }
+}
+
+void RGBController_HyperX::UpdateSingleLED(int led)
+{
+    RGBColor      color = colors[led];
+    unsigned char red   = RGBGetRValue(color);
+    unsigned char grn   = RGBGetGValue(color);
+    unsigned char blu   = RGBGetBValue(color);
 
     if(hyperx->GetMode() == HYPERX_MODE_DIRECT)
     {
@@ -79,11 +96,6 @@ void RGBController_HyperX::SetLED(int led, RGBColor color)
     }
 }
 
-void RGBController_HyperX::UpdateLEDs()
-{
-    
-}
-
 RGBController_HyperX::RGBController_HyperX(HyperXController* hyperx_ptr)
 {
     hyperx = hyperx_ptr;
@@ -110,9 +122,11 @@ RGBController_HyperX::RGBController_HyperX(HyperXController* hyperx_ptr)
         modes.push_back(hyperx_modes[i]);
     }
 
+    colors.resize(hyperx->GetLEDCount());
+
     unsigned int led_idx = 0;
 
-    for(int slot = 0; slot < hyperx->GetSlotCount(); slot++)
+    for(unsigned int slot = 0; slot < hyperx->GetSlotCount(); slot++)
     {
         zone* new_zone = new zone;
 
@@ -127,8 +141,6 @@ RGBController_HyperX::RGBController_HyperX(HyperXController* hyperx_ptr)
 
         for(int led_slot_idx = 0; led_slot_idx < 5; led_slot_idx++)
         {
-            colors.push_back(0x00000000);
-
             led* new_led = new led();
 
             char led_idx_str[3];

RGBController/RGBController_HyperX.h

@@ -16,14 +16,13 @@ class RGBController_HyperX : public RGBController
 {
 public:
     RGBController_HyperX(HyperXController* hyperx_ptr);
-    int GetMode();
-    void SetMode(int mode);
-    void SetCustomMode();
-    void SetAllLEDs(RGBColor color);
-    void SetAllZoneLEDs(int zone, RGBColor color);
-    void SetLED(int led, RGBColor color);
-    void UpdateLEDs();
+    int         GetMode();
+    void        SetMode(int mode);
+    void        SetCustomMode();
+    void        UpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
 
 private:
     HyperXController* hyperx;
-};
+};

RGBController/RGBController_LEDStrip.cpp

@@ -22,9 +22,10 @@ RGBController_LEDStrip::RGBController_LEDStrip(LEDStripController* ledstrip_ptr)
     led_mode.name = "Custom";
     modes.push_back(led_mode);
 
+    colors.resize(strip->num_leds);
+    
     for (int i = 0; i < strip->num_leds; i++)
     {
-        colors.push_back(0x00000000);
         led new_led;
         new_led.name = "LED Strip";
         leds.push_back(new_led);
@@ -46,7 +47,7 @@ int RGBController_LEDStrip::GetMode()
     return 0;
 }
 
-void RGBController_LEDStrip::SetMode(int mode)
+void RGBController_LEDStrip::SetMode(int /*mode*/)
 {
 
 }
@@ -56,34 +57,17 @@ void RGBController_LEDStrip::SetCustomMode()
 
 }
 
-void RGBController_LEDStrip::SetAllLEDs(RGBColor color)
-{
-    for (int i = 0; i < colors.size(); i++)
-    {
-        colors[i] = color;
-    }
-
-    strip->SetLEDs(colors);
-}
-
-void RGBController_LEDStrip::SetAllZoneLEDs(int zone, RGBColor color)
-{
-    for (int i = 0; i < colors.size(); i++)
-    {
-        colors[i] = color;
-    }
-
-    strip->SetLEDs(colors);
-}
-
-void RGBController_LEDStrip::SetLED(int led, RGBColor color)
-{
-    colors[led] = color;
-
-    strip->SetLEDs(colors);
-}
-
 void RGBController_LEDStrip::UpdateLEDs()
 {
     strip->SetLEDs(colors);
 }
+
+void RGBController_LEDStrip::UpdateZoneLEDs(int zone)
+{
+    strip->SetLEDs(colors);
+}
+
+void RGBController_LEDStrip::UpdateSingleLED(int led)
+{
+    strip->SetLEDs(colors);
+}

RGBController/RGBController_LEDStrip.h

@@ -16,14 +16,14 @@ class RGBController_LEDStrip : public RGBController
 {
 public:
     RGBController_LEDStrip(LEDStripController* ledstrip_ptr);
-    int GetMode();
-    void SetMode(int mode);
-    void SetCustomMode();
-    void SetAllLEDs(RGBColor color);
-    void SetAllZoneLEDs(int zone, RGBColor color);
-    void SetLED(int led, RGBColor color);
-    void UpdateLEDs();
+    int         GetMode();
+    void        SetMode(int mode);
+    void        SetCustomMode();
+    void        UpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
 
 private:
     LEDStripController* strip;
-};
+};

RGBController/RGBController_MSI3Zone.cpp

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

RGBController/RGBController_MSI3Zone.h

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

RGBController/RGBController_OpenRazer.cpp

@@ -100,7 +100,7 @@ void RGBController_OpenRazer::UpdateLEDs()
             {
                 char update_value = 1;
                 
-                for (int row = 0; row < matrix_rows; row++)
+                for (unsigned int row = 0; row < matrix_rows; row++)
                 {
                     unsigned int output_array_size;
                     unsigned int output_offset;
@@ -126,7 +126,7 @@ void RGBController_OpenRazer::UpdateLEDs()
                         output_array[2] = matrix_cols - 1;
                     }
 
-                    for(int col = 0; col < matrix_cols; col++)
+                    for(unsigned int col = 0; col < matrix_cols; col++)
                     {
                         unsigned int color_idx = col + row_offset;
                         output_array[(col * 3) + 0 + output_offset] = (char)RGBGetRValue(colors[color_idx]);
@@ -187,33 +187,13 @@ void RGBController_OpenRazer::UpdateLEDs()
     }
 }
 
-void RGBController_OpenRazer::SetAllLEDs(RGBColor color)
+void RGBController_OpenRazer::UpdateZoneLEDs(int zone)
 {
-    for(int i = 0; i < colors.size(); i++)
-    {
-        colors[i] = color;
-    }
-
     UpdateLEDs();
 }
 
-void RGBController_OpenRazer::SetAllZoneLEDs(int zone, RGBColor color)
+void RGBController_OpenRazer::UpdateSingleLED(int led)
 {
-    for (int x = 0; x < zones[zone].map.size(); x++)
-    {
-        for (int y = 0; y < zones[zone].map[x].size(); y++)
-        {
-            colors[zones[zone].map[x][y]] = color;
-        }
-    }
-
-    UpdateLEDs();
-}
-
-void RGBController_OpenRazer::SetLED(int led, RGBColor color)
-{
-    colors[led] = color;
-
     UpdateLEDs();
 }
 
@@ -340,7 +320,7 @@ RGBController_OpenRazer::RGBController_OpenRazer(std::string dev_path)
     /*-----------------------------------------------------------------*\
     | Loop through all known devices to look for a name match           |
     \*-----------------------------------------------------------------*/
-    for (int i = 0; i < RAZER_NUM_DEVICES; i++)
+    for (std::size_t i = 0; i < RAZER_NUM_DEVICES; i++)
     {
         if (device_list[i]->name == name)
         {
@@ -395,11 +375,11 @@ RGBController_OpenRazer::RGBController_OpenRazer(std::string dev_path)
                     new_zone.name = device_list[i]->zones[zone_id]->name;
                     new_zone.type = device_list[i]->zones[zone_id]->type;
 
-                    for (int row_id = 0; row_id < device_list[i]->zones[zone_id]->rows; row_id++)
+                    for (unsigned int row_id = 0; row_id < device_list[i]->zones[zone_id]->rows; row_id++)
                     {
                         std::vector<int> new_zone_map;
 
-                        for (int col_id = 0; col_id < device_list[i]->zones[zone_id]->cols; col_id++)
+                        for (unsigned int col_id = 0; col_id < device_list[i]->zones[zone_id]->cols; col_id++)
                         {
                             RGBColor new_color = 0x00000000;
                             colors.push_back(new_color);
@@ -420,4 +400,4 @@ RGBController_OpenRazer::RGBController_OpenRazer(std::string dev_path)
             }
         }
     }
-}
+}

RGBController/RGBController_OpenRazer.h

@@ -920,13 +920,12 @@ public:
 
 public:
     RGBController_OpenRazer(std::string dev_path);
-    int GetMode();
-    void SetMode(int mode);
-    void SetCustomMode();
-    void SetAllLEDs(RGBColor color);
-    void SetAllZoneLEDs(int zone, RGBColor color);
-    void SetLED(int led, RGBColor color);
-    void UpdateLEDs();
+    int         GetMode();
+    void        SetMode(int mode);
+    void        SetCustomMode();
+    void        UpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
 
     int device;
 
@@ -953,4 +952,4 @@ private:
     std::ofstream logo_led_rgb;
     std::ofstream scroll_led_effect;
     std::ofstream scroll_led_rgb;
-};
+};

RGBController/RGBController_PatriotViper.cpp

@@ -0,0 +1,145 @@
+/*-----------------------------------------*\
+|  RGBController_PatriotViper.cpp           |
+|                                           |
+|  Generic RGB Interface for OpenRGB        |
+|  Patriot Viper RGB interface              |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 1/1/2020    |
+\*-----------------------------------------*/
+
+#include "RGBController_PatriotViper.h"
+
+int RGBController_PatriotViper::GetMode()
+{
+    return(0);
+}
+
+void RGBController_PatriotViper::SetMode(int mode)
+{
+    if(mode == 0)
+    {
+        viper->SetDirect();
+    }
+    else
+    {
+        viper->SetMode(mode - 1);
+    }
+}
+
+void RGBController_PatriotViper::SetCustomMode()
+{
+    viper->SetDirect();
+}
+
+void RGBController_PatriotViper::UpdateLEDs()
+{
+    if(viper->direct == true)
+    {
+        for(int led = 0; led < 5; led++)
+        {
+            RGBColor      color = colors[led];
+            unsigned char red   = RGBGetRValue(color);
+            unsigned char grn   = RGBGetGValue(color);
+            unsigned char blu   = RGBGetBValue(color);
+            viper->SetLEDColor(led, red, grn, blu);
+        }
+    }
+    else
+    {
+        for(int led = 0; led < 5; led++)
+        {
+            RGBColor      color = colors[led];
+            unsigned char red   = RGBGetRValue(color);
+            unsigned char grn   = RGBGetGValue(color);
+            unsigned char blu   = RGBGetBValue(color);
+            viper->SetLEDEffectColor(led, red, grn, blu);
+        }
+    }
+}
+
+void RGBController_PatriotViper::UpdateZoneLEDs(int zone)
+{
+    UpdateLEDs();
+}
+
+void RGBController_PatriotViper::UpdateSingleLED(int led)
+{
+    RGBColor      color = colors[led];
+    unsigned char red   = RGBGetRValue(color);
+    unsigned char grn   = RGBGetGValue(color);
+    unsigned char blu   = RGBGetBValue(color);
+
+    if(viper->direct == true)
+    {
+        viper->SetLEDColor(led, red, grn, blu);
+    }
+    else
+    {
+        viper->SetLEDEffectColor(led, red, grn, blu);
+    }
+}
+
+RGBController_PatriotViper::RGBController_PatriotViper(PatriotViperController* viper_ptr)
+{
+    viper = viper_ptr;
+
+    name = viper->GetDeviceName();
+    location = viper->GetDeviceLocation();
+    
+    type = DEVICE_TYPE_DRAM;
+
+    mode viper_modes[10];
+
+    viper_modes[0].name = "Direct";
+    viper_modes[1].name = "Dark";
+    viper_modes[2].name = "Breathing";
+    viper_modes[3].name = "Viper";
+    viper_modes[4].name = "Heartbeat";
+    viper_modes[5].name = "Marquee";
+    viper_modes[6].name = "Raindrop";
+    viper_modes[7].name = "Aurora";
+    viper_modes[8].name = "Unknown";
+    viper_modes[9].name = "Neon";
+
+    for (int i = 0; i < 9; i++)
+    {
+        modes.push_back(viper_modes[i]);
+    }
+
+    colors.resize(viper->GetLEDCount());
+
+    unsigned int led_idx = 0;
+    for(unsigned int slot = 0; slot < viper->GetSlotCount(); slot++)
+    {
+        zone* new_zone = new zone;
+
+        char slot_idx_str[3];
+        sprintf(slot_idx_str, "%d", slot);
+        new_zone->name = "Patriot Viper RGB Slot ";
+        new_zone->name.append(slot_idx_str);
+
+        new_zone->type = ZONE_TYPE_LINEAR;
+
+        std::vector<int> *new_zone_map = new std::vector<int>();
+
+        for(int led_slot_idx = 0; led_slot_idx < 5; led_slot_idx++)
+        {
+            led* new_led = new led();
+
+            char led_idx_str[3];
+            sprintf(led_idx_str, "%d", led_slot_idx);
+            new_led->name = "Patriot Viper RGB Slot ";
+            new_led->name.append(slot_idx_str);
+            new_led->name.append(", LED ");
+            new_led->name.append(led_idx_str);
+
+            leds.push_back(*new_led);
+
+            new_zone_map->push_back(led_idx);
+            led_idx++;
+        }
+
+        new_zone->map.push_back(*new_zone_map);
+        zones.push_back(*new_zone);
+    }
+}

RGBController/RGBController_PatriotViper.h

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

RGBController/RGBController_Polychrome.cpp

@@ -24,36 +24,9 @@ void RGBController_Polychrome::SetCustomMode()
     polychrome->SetMode(POLYCHROME_MODE_STATIC);
 }
 
-void RGBController_Polychrome::SetAllLEDs(RGBColor color)
-{
-    unsigned char red = RGBGetRValue(color);
-    unsigned char grn = RGBGetGValue(color);
-    unsigned char blu = RGBGetBValue(color);
-
-    polychrome->SetAllColors(red, grn, blu);
-}
-
-void RGBController_Polychrome::SetAllZoneLEDs(int zone, RGBColor color)
-{
-    unsigned char red = RGBGetRValue(color);
-    unsigned char grn = RGBGetGValue(color);
-    unsigned char blu = RGBGetBValue(color);
-
-    polychrome->SetLEDColor(zone, red, grn, blu);
-}
-
-void RGBController_Polychrome::SetLED(int led, RGBColor color)
-{
-    unsigned char red = RGBGetRValue(color);
-    unsigned char grn = RGBGetGValue(color);
-    unsigned char blu = RGBGetBValue(color);
-
-    polychrome->SetLEDColor(led, red, grn, blu);
-}
-
 void RGBController_Polychrome::UpdateLEDs()
 {
-    for (int led = 0; led < colors.size(); led++)
+    for (std::size_t led = 0; led < colors.size(); led++)
     {
         unsigned char red = RGBGetRValue(colors[led]);
         unsigned char grn = RGBGetGValue(colors[led]);
@@ -63,6 +36,16 @@ void RGBController_Polychrome::UpdateLEDs()
     }
 }
 
+void RGBController_Polychrome::UpdateZoneLEDs(int zone)
+{
+    UpdateLEDs();
+}
+
+void RGBController_Polychrome::UpdateSingleLED(int led)
+{
+    UpdateLEDs();
+}
+
 static const char* polychrome_zone_names[] =
 {
     "Motherboard"
@@ -85,8 +68,10 @@ RGBController_Polychrome::RGBController_Polychrome(PolychromeController* polychr
         modes.push_back(polychrome_modes[i]);
     }
 
+    colors.resize(polychrome->GetLEDCount());
+
     // Search through all LEDs and create zones for each channel type
-    for (int i = 0; i < polychrome->GetLEDCount(); i++)
+    for (unsigned int i = 0; i < polychrome->GetLEDCount(); i++)
     {
         zone* new_zone = new zone();
         led* new_led = new led();
@@ -109,4 +94,4 @@ RGBController_Polychrome::RGBController_Polychrome(PolychromeController* polychr
         // Push new zone to zones vector
         zones.push_back(*new_zone);
     }
-}
+}

RGBController/RGBController_Polychrome.h

@@ -16,14 +16,13 @@ class RGBController_Polychrome : public RGBController
 {
 public:
     RGBController_Polychrome(PolychromeController* polychrome_ptr);
-    int GetMode();
-    void SetMode(int mode);
-    void SetCustomMode();
-    void SetAllLEDs(RGBColor color);
-    void SetAllZoneLEDs(int zone, RGBColor color);
-    void SetLED(int led, RGBColor color);
-    void UpdateLEDs();
+    int         GetMode();
+    void        SetMode(int mode);
+    void        SetCustomMode();
+    void        UpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
 
 private:
     PolychromeController* polychrome;
-};
+};

RGBController/RGBController_PoseidonZRGB.cpp

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

RGBController/RGBController_PoseidonZRGB.h

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

RGBController/RGBController_RGBFusion.cpp

@@ -24,43 +24,32 @@ void RGBController_RGBFusion::SetCustomMode()
     rgb_fusion->SetMode(RGB_FUSION_MODE_STATIC);
 }
 
-void RGBController_RGBFusion::SetAllLEDs(RGBColor color)
+void RGBController_RGBFusion::UpdateLEDs()
 {
-    unsigned char red = RGBGetRValue(color);
-    unsigned char grn = RGBGetGValue(color);
-    unsigned char blu = RGBGetBValue(color);
-    
-    rgb_fusion->SetAllColors(red, grn, blu);
+    for (std::size_t led = 0; led < colors.size(); led++)
+    {
+        RGBColor      color = colors[led];
+        unsigned char red   = RGBGetRValue(color);
+        unsigned char grn   = RGBGetGValue(color);
+        unsigned char blu   = RGBGetBValue(color);
+
+        rgb_fusion->SetLEDColor(led, red, grn, blu);
+    }
 }
 
-void RGBController_RGBFusion::SetAllZoneLEDs(int zone, RGBColor color)
+void RGBController_RGBFusion::UpdateZoneLEDs(int zone)
 {
-    unsigned char red = RGBGetRValue(color);
-    unsigned char grn = RGBGetGValue(color);
-    unsigned char blu = RGBGetBValue(color);
+    RGBColor      color = colors[zone];
+    unsigned char red   = RGBGetRValue(color);
+    unsigned char grn   = RGBGetGValue(color);
+    unsigned char blu   = RGBGetBValue(color);
 
     rgb_fusion->SetLEDColor(zone, red, grn, blu);
 }
 
-void RGBController_RGBFusion::SetLED(int led, RGBColor color)
+void RGBController_RGBFusion::UpdateSingleLED(int led)
 {
-    unsigned char red = RGBGetRValue(color);
-    unsigned char grn = RGBGetGValue(color);
-    unsigned char blu = RGBGetBValue(color);
-    
-    rgb_fusion->SetLEDColor(led, red, grn, blu);
-}
-
-void RGBController_RGBFusion::UpdateLEDs()
-{
-    for (int led = 0; led < colors.size(); led++)
-    {
-        unsigned char red = RGBGetRValue(colors[led]);
-        unsigned char grn = RGBGetGValue(colors[led]);
-        unsigned char blu = RGBGetBValue(colors[led]);
-
-        rgb_fusion->SetLEDColor(led, red, grn, blu);
-    }
+    UpdateZoneLEDs(led);
 }
 
 static const char* rgb_fusion_zone_names[] =
@@ -90,8 +79,10 @@ RGBController_RGBFusion::RGBController_RGBFusion(RGBFusionController* rgb_fusion
         modes.push_back(rgb_fusion_modes[i]);
     }
 
+    colors.resize(rgb_fusion->GetLEDCount());
+
     // Search through all LEDs and create zones for each channel type
-    for (int i = 0; i < rgb_fusion->GetLEDCount(); i++)
+    for (unsigned int i = 0; i < rgb_fusion->GetLEDCount(); i++)
     {
         zone* new_zone = new zone();
         led*  new_led  = new led();

RGBController/RGBController_RGBFusion.h

@@ -16,14 +16,13 @@ class RGBController_RGBFusion : public RGBController
 {
 public:
     RGBController_RGBFusion(RGBFusionController* rgb_fusion_ptr);
-    int GetMode();
-    void SetMode(int mode);
-    void SetCustomMode();
-    void SetAllLEDs(RGBColor color);
-    void SetAllZoneLEDs(int zone, RGBColor color);
-    void SetLED(int led, RGBColor color);
-    void UpdateLEDs();
+    int         GetMode();
+    void        SetMode(int mode);
+    void        SetCustomMode();
+    void        UpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
 
 private:
     RGBFusionController* rgb_fusion;
-};
+};

RGBController/RGBController_RazerChromaSDK.cpp

@@ -85,36 +85,6 @@ void RGBController_RazerChromaSDK::SetCustomMode()
 
 }
 
-void RGBController_RazerChromaSDK::SetAllLEDs(RGBColor color)
-{
-    for (int i = 0; i < colors.size(); i++)
-    {
-        colors[i] = color;
-    }
-
-    UpdateLEDs();
-}
-
-void RGBController_RazerChromaSDK::SetAllZoneLEDs(int zone, RGBColor color)
-{
-    for (int x = 0; x < zones[zone].map.size(); x++)
-    {
-        for (int y = 0; y < zones[zone].map[x].size(); y++)
-        {
-            colors[zones[zone].map[x][y]] = color;
-        }
-    }
-
-    UpdateLEDs();
-}
-
-void RGBController_RazerChromaSDK::SetLED(int led, RGBColor color)
-{
-    colors[led] = color;
-
-    UpdateLEDs();
-}
-
 void RGBController_RazerChromaSDK::UpdateLEDs()
 {
     switch (device->razer_type)
@@ -189,3 +159,13 @@ void RGBController_RazerChromaSDK::UpdateLEDs()
         break;
     }
 }
+
+void RGBController_RazerChromaSDK::UpdateZoneLEDs(int zone)
+{
+    UpdateLEDs();
+}
+
+void RGBController_RazerChromaSDK::UpdateSingleLED(int led)
+{
+    UpdateLEDs();
+}

RGBController/RGBController_RazerChromaSDK.h

@@ -229,13 +229,12 @@ class RGBController_RazerChromaSDK : public RGBController
 {
 public:
     RGBController_RazerChromaSDK(unsigned int device_type, HMODULE* hModule);
-    int GetMode();
-    void SetMode(int mode);
-    void SetCustomMode();
-    void SetAllLEDs(RGBColor color);
-    void SetAllZoneLEDs(int zone, RGBColor color);
-    void SetLED(int led, RGBColor color);
-    void UpdateLEDs();
+    int         GetMode();
+    void        SetMode(int mode);
+    void        SetCustomMode();
+    void        UpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
 
 private:
     const razer_device* device;

dependencies/hidapi/hidapi/hidapi.h

@@ -0,0 +1,395 @@
+/*******************************************************
+ HIDAPI - Multi-Platform library for
+ communication with HID devices.
+
+ Alan Ott
+ Signal 11 Software
+
+ 8/22/2009
+
+ Copyright 2009, All Rights Reserved.
+
+ At the discretion of the user of this library,
+ this software may be licensed under the terms of the
+ GNU General Public License v3, a BSD-Style license, or the
+ original HIDAPI license as outlined in the LICENSE.txt,
+ LICENSE-gpl3.txt, LICENSE-bsd.txt, and LICENSE-orig.txt
+ files located at the root of the source distribution.
+ These files may also be found in the public source
+ code repository located at:
+        http://github.com/signal11/hidapi .
+********************************************************/
+
+/** @file
+ * @defgroup API hidapi API
+ */
+
+#ifndef HIDAPI_H__
+#define HIDAPI_H__
+
+#include <wchar.h>
+
+#ifdef _WIN32
+      #define HID_API_EXPORT __declspec(dllexport)
+      #define HID_API_CALL
+#else
+      #define HID_API_EXPORT /**< API export macro */
+      #define HID_API_CALL /**< API call macro */
+#endif
+
+#define HID_API_EXPORT_CALL HID_API_EXPORT HID_API_CALL /**< API export and call macro*/
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+		struct hid_device_;
+		typedef struct hid_device_ hid_device; /**< opaque hidapi structure */
+
+		/** hidapi info structure */
+		struct hid_device_info {
+			/** Platform-specific device path */
+			char *path;
+			/** Device Vendor ID */
+			unsigned short vendor_id;
+			/** Device Product ID */
+			unsigned short product_id;
+			/** Serial Number */
+			wchar_t *serial_number;
+			/** Device Release Number in binary-coded decimal,
+			    also known as Device Version Number */
+			unsigned short release_number;
+			/** Manufacturer String */
+			wchar_t *manufacturer_string;
+			/** Product string */
+			wchar_t *product_string;
+			/** Usage Page for this Device/Interface
+			    (Windows/Mac only). */
+			unsigned short usage_page;
+			/** Usage for this Device/Interface
+			    (Windows/Mac only).*/
+			unsigned short usage;
+			/** The USB interface which this logical device
+			    represents.
+
+				* Valid on both Linux implementations in all cases.
+				* Valid on the Windows implementation only if the device
+				  contains more than one interface.
+				* Valid on the Mac implementation if and only if the device
+				  is a USB HID device. */
+			int interface_number;
+
+			/** Pointer to the next device */
+			struct hid_device_info *next;
+		};
+
+
+		/** @brief Initialize the HIDAPI library.
+
+			This function initializes the HIDAPI library. Calling it is not
+			strictly necessary, as it will be called automatically by
+			hid_enumerate() and any of the hid_open_*() functions if it is
+			needed.  This function should be called at the beginning of
+			execution however, if there is a chance of HIDAPI handles
+			being opened by different threads simultaneously.
+			
+			@ingroup API
+
+			@returns
+				This function returns 0 on success and -1 on error.
+		*/
+		int HID_API_EXPORT HID_API_CALL hid_init(void);
+
+		/** @brief Finalize the HIDAPI library.
+
+			This function frees all of the static data associated with
+			HIDAPI. It should be called at the end of execution to avoid
+			memory leaks.
+
+			@ingroup API
+
+		    @returns
+				This function returns 0 on success and -1 on error.
+		*/
+		int HID_API_EXPORT HID_API_CALL hid_exit(void);
+
+		/** @brief Enumerate the HID Devices.
+
+			This function returns a linked list of all the HID devices
+			attached to the system which match vendor_id and product_id.
+			If @p vendor_id is set to 0 then any vendor matches.
+			If @p product_id is set to 0 then any product matches.
+			If @p vendor_id and @p product_id are both set to 0, then
+			all HID devices will be returned.
+
+			@ingroup API
+			@param vendor_id The Vendor ID (VID) of the types of device
+				to open.
+			@param product_id The Product ID (PID) of the types of
+				device to open.
+
+		    @returns
+		    	This function returns a pointer to a linked list of type
+		    	struct #hid_device_info, containing information about the HID devices
+		    	attached to the system, or NULL in the case of failure. Free
+		    	this linked list by calling hid_free_enumeration().
+		*/
+		struct hid_device_info HID_API_EXPORT * HID_API_CALL hid_enumerate(unsigned short vendor_id, unsigned short product_id);
+
+		/** @brief Free an enumeration Linked List
+
+		    This function frees a linked list created by hid_enumerate().
+
+			@ingroup API
+		    @param devs Pointer to a list of struct_device returned from
+		    	      hid_enumerate().
+		*/
+		void  HID_API_EXPORT HID_API_CALL hid_free_enumeration(struct hid_device_info *devs);
+
+		/** @brief Open a HID device using a Vendor ID (VID), Product ID
+			(PID) and optionally a serial number.
+
+			If @p serial_number is NULL, the first device with the
+			specified VID and PID is opened.
+
+			@ingroup API
+			@param vendor_id The Vendor ID (VID) of the device to open.
+			@param product_id The Product ID (PID) of the device to open.
+			@param serial_number The Serial Number of the device to open
+				               (Optionally NULL).
+
+			@returns
+				This function returns a pointer to a #hid_device object on
+				success or NULL on failure.
+		*/
+		HID_API_EXPORT hid_device * HID_API_CALL hid_open(unsigned short vendor_id, unsigned short product_id, const wchar_t *serial_number);
+
+		/** @brief Open a HID device by its path name.
+
+			The path name be determined by calling hid_enumerate(), or a
+			platform-specific path name can be used (eg: /dev/hidraw0 on
+			Linux).
+
+			@ingroup API
+		    @param path The path name of the device to open
+
+			@returns
+				This function returns a pointer to a #hid_device object on
+				success or NULL on failure.
+		*/
+		HID_API_EXPORT hid_device * HID_API_CALL hid_open_path(const char *path);
+
+		/** @brief Write an Output report to a HID device.
+
+			The first byte of @p data[] must contain the Report ID. For
+			devices which only support a single report, this must be set
+			to 0x0. The remaining bytes contain the report data. Since
+			the Report ID is mandatory, calls to hid_write() will always
+			contain one more byte than the report contains. For example,
+			if a hid report is 16 bytes long, 17 bytes must be passed to
+			hid_write(), the Report ID (or 0x0, for devices with a
+			single report), followed by the report data (16 bytes). In
+			this example, the length passed in would be 17.
+
+			hid_write() will send the data on the first OUT endpoint, if
+			one exists. If it does not, it will send the data through
+			the Control Endpoint (Endpoint 0).
+
+			@ingroup API
+			@param dev A device handle returned from hid_open().
+			@param data The data to send, including the report number as
+				the first byte.
+			@param length The length in bytes of the data to send.
+
+			@returns
+				This function returns the actual number of bytes written and
+				-1 on error.
+		*/
+		int  HID_API_EXPORT HID_API_CALL hid_write(hid_device *dev, const unsigned char *data, size_t length);
+
+		/** @brief Read an Input report from a HID device with timeout.
+
+			Input reports are returned
+			to the host through the INTERRUPT IN endpoint. The first byte will
+			contain the Report number if the device uses numbered reports.
+
+			@ingroup API
+			@param dev A device handle returned from hid_open().
+			@param data A buffer to put the read data into.
+			@param length The number of bytes to read. For devices with
+				multiple reports, make sure to read an extra byte for
+				the report number.
+			@param milliseconds timeout in milliseconds or -1 for blocking wait.
+
+			@returns
+				This function returns the actual number of bytes read and
+				-1 on error. If no packet was available to be read within
+				the timeout period, this function returns 0.
+		*/
+		int HID_API_EXPORT HID_API_CALL hid_read_timeout(hid_device *dev, unsigned char *data, size_t length, int milliseconds);
+
+		/** @brief Read an Input report from a HID device.
+
+			Input reports are returned
+		    to the host through the INTERRUPT IN endpoint. The first byte will
+			contain the Report number if the device uses numbered reports.
+
+			@ingroup API
+			@param dev A device handle returned from hid_open().
+			@param data A buffer to put the read data into.
+			@param length The number of bytes to read. For devices with
+				multiple reports, make sure to read an extra byte for
+				the report number.
+
+			@returns
+				This function returns the actual number of bytes read and
+				-1 on error. If no packet was available to be read and
+				the handle is in non-blocking mode, this function returns 0.
+		*/
+		int  HID_API_EXPORT HID_API_CALL hid_read(hid_device *dev, unsigned char *data, size_t length);
+
+		/** @brief Set the device handle to be non-blocking.
+
+			In non-blocking mode calls to hid_read() will return
+			immediately with a value of 0 if there is no data to be
+			read. In blocking mode, hid_read() will wait (block) until
+			there is data to read before returning.
+
+			Nonblocking can be turned on and off at any time.
+
+			@ingroup API
+			@param dev A device handle returned from hid_open().
+			@param nonblock enable or not the nonblocking reads
+			 - 1 to enable nonblocking
+			 - 0 to disable nonblocking.
+
+			@returns
+				This function returns 0 on success and -1 on error.
+		*/
+		int  HID_API_EXPORT HID_API_CALL hid_set_nonblocking(hid_device *dev, int nonblock);
+
+		/** @brief Send a Feature report to the device.
+
+			Feature reports are sent over the Control endpoint as a
+			Set_Report transfer.  The first byte of @p data[] must
+			contain the Report ID. For devices which only support a
+			single report, this must be set to 0x0. The remaining bytes
+			contain the report data. Since the Report ID is mandatory,
+			calls to hid_send_feature_report() will always contain one
+			more byte than the report contains. For example, if a hid
+			report is 16 bytes long, 17 bytes must be passed to
+			hid_send_feature_report(): the Report ID (or 0x0, for
+			devices which do not use numbered reports), followed by the
+			report data (16 bytes). In this example, the length passed
+			in would be 17.
+
+			@ingroup API
+			@param dev A device handle returned from hid_open().
+			@param data The data to send, including the report number as
+				the first byte.
+			@param length The length in bytes of the data to send, including
+				the report number.
+
+			@returns
+				This function returns the actual number of bytes written and
+				-1 on error.
+		*/
+		int HID_API_EXPORT HID_API_CALL hid_send_feature_report(hid_device *dev, const unsigned char *data, size_t length);
+
+		/** @brief Get a feature report from a HID device.
+
+			Set the first byte of @p data[] to the Report ID of the
+			report to be read.  Make sure to allow space for this
+			extra byte in @p data[]. Upon return, the first byte will
+			still contain the Report ID, and the report data will
+			start in data[1].
+
+			@ingroup API
+			@param dev A device handle returned from hid_open().
+			@param data A buffer to put the read data into, including
+				the Report ID. Set the first byte of @p data[] to the
+				Report ID of the report to be read, or set it to zero
+				if your device does not use numbered reports.
+			@param length The number of bytes to read, including an
+				extra byte for the report ID. The buffer can be longer
+				than the actual report.
+
+			@returns
+				This function returns the number of bytes read plus
+				one for the report ID (which is still in the first
+				byte), or -1 on error.
+		*/
+		int HID_API_EXPORT HID_API_CALL hid_get_feature_report(hid_device *dev, unsigned char *data, size_t length);
+
+		/** @brief Close a HID device.
+
+			@ingroup API
+			@param dev A device handle returned from hid_open().
+		*/
+		void HID_API_EXPORT HID_API_CALL hid_close(hid_device *dev);
+
+		/** @brief Get The Manufacturer String from a HID device.
+
+			@ingroup API
+			@param dev A device handle returned from hid_open().
+			@param string A wide string buffer to put the data into.
+			@param maxlen The length of the buffer in multiples of wchar_t.
+
+			@returns
+				This function returns 0 on success and -1 on error.
+		*/
+		int HID_API_EXPORT_CALL hid_get_manufacturer_string(hid_device *dev, wchar_t *string, size_t maxlen);
+
+		/** @brief Get The Product String from a HID device.
+
+			@ingroup API
+			@param dev A device handle returned from hid_open().
+			@param string A wide string buffer to put the data into.
+			@param maxlen The length of the buffer in multiples of wchar_t.
+
+			@returns
+				This function returns 0 on success and -1 on error.
+		*/
+		int HID_API_EXPORT_CALL hid_get_product_string(hid_device *dev, wchar_t *string, size_t maxlen);
+
+		/** @brief Get The Serial Number String from a HID device.
+
+			@ingroup API
+			@param dev A device handle returned from hid_open().
+			@param string A wide string buffer to put the data into.
+			@param maxlen The length of the buffer in multiples of wchar_t.
+
+			@returns
+				This function returns 0 on success and -1 on error.
+		*/
+		int HID_API_EXPORT_CALL hid_get_serial_number_string(hid_device *dev, wchar_t *string, size_t maxlen);
+
+		/** @brief Get a string from a HID device, based on its string index.
+
+			@ingroup API
+			@param dev A device handle returned from hid_open().
+			@param string_index The index of the string to get.
+			@param string A wide string buffer to put the data into.
+			@param maxlen The length of the buffer in multiples of wchar_t.
+
+			@returns
+				This function returns 0 on success and -1 on error.
+		*/
+		int HID_API_EXPORT_CALL hid_get_indexed_string(hid_device *dev, int string_index, wchar_t *string, size_t maxlen);
+
+		/** @brief Get a string describing the last error which occurred.
+
+			@ingroup API
+			@param dev A device handle returned from hid_open().
+
+			@returns
+				This function returns a string containing the last error
+				which occurred or NULL if none has occurred.
+		*/
+		HID_API_EXPORT const wchar_t* HID_API_CALL hid_error(hid_device *dev);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+