Swap red and blue channels in RGB Fusion 2.0 packet after it was found that they were reversed

Controllers/CorsairKbdV1Controller/CorsairKbdV1Controller.cpp

@@ -1,141 +0,0 @@
-/*-----------------------------------------*\
-|  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

@@ -1,31 +0,0 @@
-/*-----------------------------------------*\
-|  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

@@ -1,52 +0,0 @@
-#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/CorsairNodeProController/CorsairNodeProController.cpp

@@ -0,0 +1,345 @@
+/*---------------------------------------------------------*\
+|  Processing Code for Corsair Lighting Node Pro            |
+|                                                           |
+|  Adam Honse ([email protected]), 1/12/2020        |
+\*---------------------------------------------------------*/
+
+#include "CorsairNodeProController.h"
+
+#include <fstream>
+#include <iostream>
+#include <string>
+
+//Include thread libraries for Windows or Linux
+#ifdef WIN32
+#include <process.h>
+#else
+#include "pthread.h"
+#include "unistd.h"
+#endif
+
+//Thread functions have different types in Windows and Linux
+#ifdef WIN32
+#define THREAD static void
+#define THREADRETURN
+#else
+#define THREAD static void*
+#define THREADRETURN return(NULL);
+#endif
+
+#ifdef WIN32
+#include <Windows.h>
+#else
+#include <unistd.h>
+
+static void Sleep(unsigned int milliseconds)
+{
+    usleep(1000 * milliseconds);
+}
+#endif
+
+THREAD keepalive_thread(void *param)
+{
+    CorsairNodeProController* corsair = static_cast<CorsairNodeProController*>(param);
+    corsair->KeepaliveThread();
+    THREADRETURN
+}
+
+CorsairNodeProController::CorsairNodeProController(libusb_device_handle* dev_handle)
+{
+    dev = dev_handle;
+    channel_leds[0] = 60;
+    channel_leds[1] = 60;
+
+    /*-----------------------------------------------------*\
+    | The Corsair Lighting Node Pro requires a packet within|
+    | 20 seconds of sending the lighting change in order    |
+    | to not revert back into rainbow mode.  Start a thread |
+    | to continuously send a keepalive packet every 5s      |
+    \*-----------------------------------------------------*/
+#ifdef WIN32
+    _beginthread(keepalive_thread, 0, this);
+#else
+    pthread_t thread;
+    pthread_create(&thread, NULL, &keepalive_thread, this);
+#endif
+}
+
+CorsairNodeProController::~CorsairNodeProController()
+{
+}
+
+void CorsairNodeProController::SendKeepalive()
+{
+    unsigned char usb_apply[] =
+    {
+        0x33, 0xFF, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 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
+    };
+    int             actual;
+
+    /*-----------------------------------------------------*\
+    | Send apply packet                                     |
+    \*-----------------------------------------------------*/
+    libusb_interrupt_transfer(dev, 0x01, usb_apply, 64, &actual, 0);
+}
+
+void CorsairNodeProController::KeepaliveThread()
+{
+    while(1)
+    {
+        SendKeepalive();
+
+        Sleep(5000);
+    }
+}
+
+void CorsairNodeProController::SetChannelLEDs(unsigned int channel, std::vector<RGBColor> colors)
+{
+    unsigned char usb_start[] =
+    {
+        0x38, 0x00, 0x02, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        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_data[] =
+    {
+        0x32, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        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[] =
+    {
+        0x33, 0xFF, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 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
+    };
+    int             actual;
+
+    /*-----------------------------------------------------*\
+    | Set channel in USB packets                            |
+    \*-----------------------------------------------------*/
+    usb_data[0x01]   = channel;
+    usb_start[0x01]  = channel;
+
+    /*-----------------------------------------------------*\
+    | Send start packet                                     |
+    \*-----------------------------------------------------*/
+    libusb_interrupt_transfer(dev, 0x01, usb_start, 64, &actual, 0);
+
+    /*-----------------------------------------------------*\
+    | Send red channel packet 1                             |
+    \*-----------------------------------------------------*/
+    std::size_t pkt_max = 50;
+
+    if(pkt_max > colors.size())
+    {
+        pkt_max = colors.size();
+    }
+
+    usb_data[0x02]  = 0;
+    usb_data[0x03]  = pkt_max;
+    usb_data[0x04]  = 0x00; //red
+
+    for (std::size_t idx = 0; idx < pkt_max; idx++)
+    {
+        RGBColor color = colors[idx];
+        usb_data[idx + 5] = RGBGetRValue(color);
+    }
+
+    libusb_interrupt_transfer(dev, 0x01, usb_data, 64, &actual, 0);
+
+    /*-----------------------------------------------------*\
+    | Send red channel packet 2 if necessary                |
+    \*-----------------------------------------------------*/
+    for(int idx = 4; idx < 64; idx++)
+    {
+        usb_data[idx] = 0;
+    }
+
+    pkt_max         = 0;
+
+    if (colors.size() > 50)
+    {
+        pkt_max = colors.size() - 50;
+    }
+
+    if(pkt_max > 0)
+    {
+        usb_data[0x02]  = 50;
+        usb_data[0x03]  = pkt_max;
+        usb_data[0x04]  = 0x00; //red
+
+        for (std::size_t idx = 0; idx < pkt_max; idx++)
+        {
+            RGBColor color = colors[idx + 50];
+            usb_data[idx + 5] = RGBGetRValue(color);
+        }
+
+        libusb_interrupt_transfer(dev, 0x01, usb_data, 64, &actual, 0);
+    }
+    
+    /*-----------------------------------------------------*\
+    | Send green channel packet 1                           |
+    \*-----------------------------------------------------*/
+    pkt_max = 50;
+
+    if(pkt_max > colors.size())
+    {
+        pkt_max = colors.size();
+    }
+
+    usb_data[0x02]  = 0;
+    usb_data[0x03]  = pkt_max;
+    usb_data[0x04]  = 0x01; //green
+
+    for (std::size_t idx = 0; idx < pkt_max; idx++)
+    {
+        RGBColor color = colors[idx];
+        usb_data[idx + 5] = RGBGetGValue(color);
+    }
+
+    libusb_interrupt_transfer(dev, 0x01, usb_data, 64, &actual, 0);
+
+    /*-----------------------------------------------------*\
+    | Send green channel packet 2 if necessary              |
+    \*-----------------------------------------------------*/
+    for(int idx = 4; idx < 64; idx++)
+    {
+        usb_data[idx] = 0;
+    }
+
+    pkt_max         = 0;
+
+    if (colors.size() > 50)
+    {
+        pkt_max = colors.size() - 50;
+    }
+
+    if(pkt_max > 0)
+    {
+        usb_data[0x02]  = 50;
+        usb_data[0x03]  = pkt_max;
+        usb_data[0x04]  = 0x01; //green
+
+        for (std::size_t idx = 0; idx < pkt_max; idx++)
+        {
+            RGBColor color = colors[idx + 50];
+            usb_data[idx + 5] = RGBGetGValue(color);
+        }
+
+        libusb_interrupt_transfer(dev, 0x01, usb_data, 64, &actual, 0);
+    }
+
+    /*-----------------------------------------------------*\
+    | Send blue channel packet 1                            |
+    \*-----------------------------------------------------*/
+    pkt_max = 50;
+
+    if(pkt_max > colors.size())
+    {
+        pkt_max = colors.size();
+    }
+
+    usb_data[0x02]  = 0;
+    usb_data[0x03]  = pkt_max;
+    usb_data[0x04]  = 0x02; //blue
+
+    for (std::size_t idx = 0; idx < pkt_max; idx++)
+    {
+        RGBColor color = colors[idx];
+        usb_data[idx + 5] = RGBGetBValue(color);
+    }
+
+    libusb_interrupt_transfer(dev, 0x01, usb_data, 64, &actual, 0);
+
+    /*-----------------------------------------------------*\
+    | Send blue channel packet 2 if necessary               |
+    \*-----------------------------------------------------*/
+    for(int idx = 4; idx < 64; idx++)
+    {
+        usb_data[idx] = 0;
+    }
+
+    pkt_max         = 0;
+
+    if (colors.size() > 50)
+    {
+        pkt_max = colors.size() - 50;
+    }
+
+    if(pkt_max > 0)
+    {
+        usb_data[0x02]  = 50;
+        usb_data[0x03]  = pkt_max;
+        usb_data[0x04]  = 0x02; //blue
+
+        for (std::size_t idx = 0; idx < pkt_max; idx++)
+        {
+            RGBColor color = colors[idx + 50];
+            usb_data[idx + 5] = RGBGetBValue(color);
+        }
+
+        libusb_interrupt_transfer(dev, 0x01, usb_data, 64, &actual, 0);
+    }
+
+    /*-----------------------------------------------------*\
+    | Send apply packet                                     |
+    \*-----------------------------------------------------*/
+    libusb_interrupt_transfer(dev, 0x01, usb_apply, 64, &actual, 0);
+}

Controllers/CorsairNodeProController/CorsairNodeProController.h

@@ -0,0 +1,37 @@
+/*---------------------------------------------------------*\
+|  Definitions for Corsair Lighting Node Pro                |
+|                                                           |
+|  Adam Honse ([email protected]), 1/12/2020        |
+\*---------------------------------------------------------*/
+
+#include "RGBController.h"
+#include <vector>
+#include <libusb-1.0/libusb.h>
+
+#pragma once
+
+enum
+{
+    CORSAIR_NODE_PRO_CHANNEL_1      = 0x00,     /* Channel 1                    */
+    CORSAIR_NODE_PRO_CHANNEL_2      = 0x01,     /* Channel 2                    */
+    CORSAIR_NODE_PRO_NUM_CHANNELS   = 0x02      /* Number of channels           */
+};
+
+class CorsairNodeProController
+{
+public:
+    CorsairNodeProController(libusb_device_handle* dev_handle);
+    ~CorsairNodeProController();
+    
+    char*           GetLEDString();
+    unsigned int    GetStripsOnChannel(unsigned int channel);
+    void            SetChannelEffect(unsigned int channel, unsigned int mode, std::vector<RGBColor> colors);
+    void            SetChannelLEDs(unsigned int channel, std::vector<RGBColor> colors);
+    void            SendKeepalive();
+    unsigned int    channel_leds[CORSAIR_NODE_PRO_NUM_CHANNELS];
+
+    void            KeepaliveThread();
+
+private:
+    libusb_device_handle*   dev;
+};

Controllers/CorsairNodeProController/CorsairNodeProControllerDetect.cpp

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

Controllers/HuePlusController/HuePlusController.cpp

@@ -68,7 +68,6 @@ unsigned int HuePlusController::GetLEDsOnChannel(unsigned int channel)
 
     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)
     {
         if(serial_buf[3] == 0x01)

Controllers/RGBFusion2Controller/RGBFusion2Controller.cpp

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

Controllers/RGBFusion2Controller/RGBFusion2Controller.h

@@ -0,0 +1,39 @@
+/*-----------------------------------------*\
+|  RGBFusion2Controller.h                   |
+|                                           |
+|  Definitions and types for Gigabyte Aorus |
+|  RGB Fusion 2.0 lighting controller       |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 1/15/2020   |
+\*-----------------------------------------*/
+
+#include <string>
+#include <hidapi/hidapi.h>
+
+#pragma once
+
+
+class RGBFusion2Controller
+{
+public:
+    RGBFusion2Controller(hid_device* dev_handle);
+    ~RGBFusion2Controller();
+
+    std::string     GetDeviceName();
+    std::string     GetDeviceLocation();
+    unsigned int    GetLEDCount();
+    unsigned char   GetMode();
+    void            SetAllColors(unsigned char red, unsigned char green, unsigned char blue);
+    void            SetLEDColor(unsigned int led, unsigned char red, unsigned char green, unsigned char blue);
+    void            SetMode(unsigned char mode);
+
+private:
+    void            dump();
+
+    char                    device_name[32];
+    unsigned int            led_count;
+
+    void            SendApply();
+    
+    hid_device*             dev;
+};

Controllers/RGBFusion2Controller/RGBFusion2ControllerDetect.cpp

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

OpenRGB.cpp

@@ -324,6 +324,7 @@ void DetectHyperXControllers(std::vector<i2c_smbus_interface*> &busses, std::vec
 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 DetectRGBFusion2Controllers(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);
@@ -334,7 +335,7 @@ void DetectAMDWraithPrismControllers(std::vector<RGBController*>& rgb_controller
 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);
+void DetectCorsairNodeProControllers(std::vector<RGBController*> &rgb_controllers);
 
 /******************************************************************************************\
 *                                                                                          *
@@ -356,6 +357,7 @@ void DetectRGBControllers(void)
     DetectPolychromeControllers(busses, rgb_controllers);
     DetectRGBFusionControllers(busses, rgb_controllers);
 
+    DetectRGBFusion2Controllers(rgb_controllers);
     DetectLEDStripControllers(rgb_controllers);
     DetectHue2Controllers(rgb_controllers);
     DetectHuePlusControllers(rgb_controllers);
@@ -363,7 +365,7 @@ void DetectRGBControllers(void)
     DetectAMDWraithPrismControllers(rgb_controllers);
     DetectMSI3ZoneControllers(rgb_controllers);
     DetectPoseidonZRGBControllers(rgb_controllers);
-    DetectCorsairKbdV1Controllers(rgb_controllers);
+    DetectCorsairNodeProControllers(rgb_controllers);
     
     DetectE131Controllers(rgb_controllers);
 

OpenRGB.pro

@@ -14,7 +14,7 @@ INCLUDEPATH +=                                                          \
     Controllers/AMDWraithPrismController/                               \
     Controllers/AuraController/                                         \
     Controllers/CorsairController/                                      \
-    Controllers/CorsairKbdV1Controller/                                 \
+    Controllers/CorsairNodeProController/                               \
     Controllers/CorsairProController/                                   \
     Controllers/Hue2Controller/                                         \
     Controllers/HuePlusController/                                      \
@@ -25,6 +25,7 @@ INCLUDEPATH +=                                                          \
     Controllers/PolychromeController/                                   \
     Controllers/PoseidonZRGBController/                                 \
     Controllers/RGBFusionController/                                    \
+    Controllers/RGBFusion2Controller/                                   \
     RGBController/                                                      \
     qt/
 
@@ -47,9 +48,9 @@ SOURCES +=                                                              \
     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/CorsairNodeProController/CorsairNodeProController.cpp   \
+    Controllers/CorsairNodeProController/CorsairNodeProControllerDetect.cpp \
     Controllers/CorsairProController/CorsairProController.cpp           \
     Controllers/CorsairProController/CorsairProControllerDetect.cpp     \
     Controllers/Hue2Controller/Hue2Controller.cpp                       \
@@ -70,12 +71,14 @@ SOURCES +=                                                              \
     Controllers/PoseidonZRGBController/PoseidonZRGBControllerDetect.cpp \
     Controllers/RGBFusionController/RGBFusionController.cpp             \
     Controllers/RGBFusionController/RGBFusionControllerDetect.cpp       \
+    Controllers/RGBFusion2Controller/RGBFusion2Controller.cpp           \
+    Controllers/RGBFusion2Controller/RGBFusion2ControllerDetect.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_CorsairNodePro.cpp                      \
     RGBController/RGBController_CorsairPro.cpp                          \
     RGBController/RGBController_Hue2.cpp                                \
     RGBController/RGBController_HuePlus.cpp                             \
@@ -86,7 +89,8 @@ SOURCES +=                                                              \
     RGBController/RGBController_PatriotViper.cpp                        \
     RGBController/RGBController_Polychrome.cpp                          \
     RGBController/RGBController_PoseidonZRGB.cpp                        \
-    RGBController/RGBController_RGBFusion.cpp
+    RGBController/RGBController_RGBFusion.cpp                           \
+    RGBController/RGBController_RGBFusion2.cpp
 
 HEADERS +=                                                              \
     qt/OpenRGBDeviceInfoPage.h                                          \
@@ -102,6 +106,7 @@ HEADERS +=                                                              \
     Controllers/AMDWraithPrismController/AMDWraithPrismController.h     \
     Controllers/AuraController/AuraController.h                         \
     Controllers/CorsairController/CorsairController.h                   \
+    Controllers/CorsairNodeProController/CorsairNodeProController.h     \
     Controllers/CorsairProController/CorsairProController.h             \
     Controllers/Hue2Controller/Hue2Controller.h                         \
     Controllers/HuePlusController/HuePlusController.h                   \
@@ -112,11 +117,12 @@ HEADERS +=                                                              \
     Controllers/PolychromeController/PolychromeController.h             \
     Controllers/PoseidonZRGBController/PoseidonZRGBController.h         \
     Controllers/RGBFusionController/RGBFusionController.h               \
+    Controllers/RGBFusion2Controller/RGBFusion2Controller.h             \
     RGBController/RGBController.h                                       \
     RGBController/RGBController_AMDWraithPrism.h                        \
     RGBController/RGBController_Aura.h                                  \
     RGBController/RGBController_Corsair.h                               \
-    RGBController/RGBController_CorsairKbdV1.h                          \
+    RGBController/RGBController_CorsairNodePro.h                        \
     RGBController/RGBController_CorsairPro.h                            \
     RGBController/RGBController_E131.h                                  \
     RGBController/RGBController_Hue2.h                                  \
@@ -127,7 +133,8 @@ HEADERS +=                                                              \
     RGBController/RGBController_PatriotViper.h                          \
     RGBController/RGBController_Polychrome.h                            \
     RGBController/RGBController_PoseidonZRGB.h                          \
-    RGBController/RGBController_RGBFusion.h
+    RGBController/RGBController_RGBFusion.h                             \
+    RGBController/RGBController_RGBFusion2.h
 
 RESOURCES += \
     qt/resources.qrc

README.md

@@ -8,25 +8,7 @@ After getting a solid Aura implementation, the project branched out into other m
 
 ## Supported Devices
 
-* Asus Aura (SMBus variants only)
-
-* Gigabyte RGB Fusion 1.0
-
-* Asus Aura RAM
-
-* Corsair Vengeance RGB
-
-* Corsair Vengeance Pro RGB
-
-* HyperX Predator RGB
-
-* NZXT Hue+
-
-* KeyboardVisualizer Arduino LED Strips
-
-* E1.31 (Linux only)
-
-* OpenRazer (Linux only)
+See the [Project Wiki](https://gitlab.com/CalcProgrammer1/OpenRGB/-/wikis/home) for the current list of supported devices.
 
 ## Installation
 #### Windows

RGBController/RGBController_CorsairKbdV1.cpp

@@ -1,58 +0,0 @@
-/*-----------------------------------------*\
-|  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_CorsairNodePro.cpp

@@ -0,0 +1,156 @@
+/*-----------------------------------------*\
+|  RGBController_CorsairNodePro.cpp         |
+|                                           |
+|  Generic RGB Interface for Corsair        |
+|  Lighting Node Pro                        |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 1/12/2020   |
+\*-----------------------------------------*/
+
+#include "RGBController_CorsairNodePro.h"
+
+
+RGBController_CorsairNodePro::RGBController_CorsairNodePro(CorsairNodeProController* corsair_ptr)
+{
+    corsair = corsair_ptr;
+
+    name = "Corsair Lighting Node Pro";
+
+    type = DEVICE_TYPE_LEDSTRIP;
+    
+    mode 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 < CORSAIR_NODE_PRO_NUM_CHANNELS; channel_idx++)
+    {
+        led_count += corsair->channel_leds[channel_idx];
+    }
+    colors.resize(led_count);
+
+    /*-------------------------------------------------*\
+    | Set zones and leds                                |
+    \*-------------------------------------------------*/
+    unsigned int led_idx = 0;
+    for (unsigned int channel_idx = 0; channel_idx < CORSAIR_NODE_PRO_NUM_CHANNELS; channel_idx++)
+    {
+        if(corsair->channel_leds[channel_idx] > 0)
+        {
+            zone* new_zone = new zone;
+
+            char ch_idx_string[2];
+            sprintf(ch_idx_string, "%d", channel_idx + 1);
+
+            new_zone->name = "Corsair Channel ";
+            new_zone->name.append(ch_idx_string);
+            new_zone->type = ZONE_TYPE_LINEAR;
+
+            std::vector<int> *new_zone_map = new std::vector<int>();
+
+            for (unsigned int led_ch_idx = 0; led_ch_idx < corsair->channel_leds[channel_idx]; led_ch_idx++)
+            {
+                char led_idx_string[3];
+                sprintf(led_idx_string, "%d", led_ch_idx + 1);
+
+                led new_led;
+                new_led.name = "Corsair Channel ";
+                new_led.name.append(ch_idx_string);
+                new_led.name.append(", LED ");
+                new_led.name.append(led_idx_string);
+
+                leds.push_back(new_led);
+                leds_channel.push_back(channel_idx);
+
+                new_zone_map->push_back(led_idx);
+                led_idx++;
+            }
+
+            new_zone->map.push_back(*new_zone_map);
+            zones.push_back(*new_zone);
+            zones_channel.push_back(channel_idx);
+        }
+    }
+}
+
+int RGBController_CorsairNodePro::GetMode()
+{
+    return 0;
+}
+
+void RGBController_CorsairNodePro::SetMode(int /*mode*/)
+{
+
+}
+
+void RGBController_CorsairNodePro::SetCustomMode()
+{
+
+}
+
+void RGBController_CorsairNodePro::UpdateLEDs()
+{
+    for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
+    {
+        unsigned int channel = zones_channel[zone_idx];
+
+        std::vector<RGBColor> channel_colors;
+
+        for(std::size_t color = 0; color < colors.size(); color++)
+        {
+            if(leds_channel[color] == channel)
+            {
+                channel_colors.push_back(colors[color]);
+            }
+        }
+
+        if(channel_colors.size() > 0)
+        {
+            corsair->SetChannelLEDs(channel, channel_colors);
+        }
+    }
+}
+
+void RGBController_CorsairNodePro::UpdateZoneLEDs(int zone)
+{
+    unsigned int channel = zones_channel[zone];
+
+    std::vector<RGBColor> channel_colors;
+
+    for(std::size_t color = 0; color < colors.size(); color++)
+    {
+        if(leds_channel[color] == channel)
+        {
+            channel_colors.push_back(colors[color]);
+        }
+    }
+
+    if(channel_colors.size() > 0)
+    {
+        //corsair->SetChannelLEDs(channel, channel_colors);
+    }
+    corsair->SendKeepalive();
+}
+
+void RGBController_CorsairNodePro::UpdateSingleLED(int led)
+{
+    unsigned int channel = leds_channel[led];
+
+    std::vector<RGBColor> channel_colors;
+
+    for(std::size_t color = 0; color < colors.size(); color++)
+    {
+        if(leds_channel[color] == channel)
+        {
+            channel_colors.push_back(colors[color]);
+        }
+    }
+
+    if(channel_colors.size() > 0)
+    {
+        corsair->SetChannelLEDs(channel, channel_colors);
+    }
+}

RGBController/RGBController_CorsairNodePro.h

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

RGBController/RGBController_RGBFusion2.cpp

@@ -0,0 +1,100 @@
+/*-----------------------------------------*\
+|  RGBController_RGBFusion2.cpp             |
+|                                           |
+|  Generic RGB Interface for OpenRGB        |
+|  Gigabyte RGB Fusion 2.0 Driver           |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 1/15/2020   |
+\*-----------------------------------------*/
+
+#include "RGBController_RGBFusion2.h"
+
+int RGBController_RGBFusion2::GetMode()
+{
+    return(rgb_fusion->GetMode());
+}
+
+void RGBController_RGBFusion2::SetMode(int mode)
+{
+    rgb_fusion->SetMode(mode);
+}
+
+void RGBController_RGBFusion2::SetCustomMode()
+{
+    rgb_fusion->SetMode(0);
+}
+
+void RGBController_RGBFusion2::UpdateLEDs()
+{
+    for (std::size_t led = 0; led < colors.size(); led++)
+    {
+        RGBColor      color = colors[led];
+        unsigned char red   = RGBGetRValue(color);
+        unsigned char grn   = RGBGetGValue(color);
+        unsigned char blu   = RGBGetBValue(color);
+
+        rgb_fusion->SetLEDColor(led, red, grn, blu);
+    }
+}
+
+void RGBController_RGBFusion2::UpdateZoneLEDs(int zone)
+{
+    RGBColor      color = colors[zone];
+    unsigned char red   = RGBGetRValue(color);
+    unsigned char grn   = RGBGetGValue(color);
+    unsigned char blu   = RGBGetBValue(color);
+
+    rgb_fusion->SetLEDColor(zone, red, grn, blu);
+}
+
+void RGBController_RGBFusion2::UpdateSingleLED(int led)
+{
+    UpdateZoneLEDs(led);
+}
+
+RGBController_RGBFusion2::RGBController_RGBFusion2(RGBFusion2Controller* rgb_fusion_ptr)
+{
+    rgb_fusion = rgb_fusion_ptr;
+
+    name = rgb_fusion->GetDeviceName();
+    description = "RGB Fusion 2.0";
+    location = rgb_fusion->GetDeviceLocation();
+
+    type = DEVICE_TYPE_MOTHERBOARD;
+
+    mode rgb_fusion_modes[1];
+
+    rgb_fusion_modes[0].name = "Static";
+
+    for (int i = 0; i < 1; i++)
+    {
+        modes.push_back(rgb_fusion_modes[i]);
+    }
+
+    colors.resize(rgb_fusion->GetLEDCount());
+
+    // Search through all LEDs and create zones for each channel type
+    for (unsigned int i = 0; i < rgb_fusion->GetLEDCount(); i++)
+    {
+        zone* new_zone = new zone();
+        led*  new_led  = new led();
+
+        std::vector<int>* zone_row = new std::vector<int>();
+
+        // Set zone name to channel name
+        new_zone->name = "Zone";
+        new_led->name  = "LED";
+
+        zone_row->push_back(i);
+
+        // Aura devices can be either single or linear, never matrix
+        // That means only one row is needed
+        new_zone->map.push_back(*zone_row);
+
+        // Push new LED to LEDs vector
+        leds.push_back(*new_led);
+
+        // Push new zone to zones vector
+        zones.push_back(*new_zone);
+    }
+}

RGBController/RGBController_RGBFusion2.h

@@ -1,21 +1,21 @@
 /*-----------------------------------------*\
-|  RGBController_CorsairKbdV1.h             |
+|  RGBController_RGBFusion2.h               |
 |                                           |
-|  Generic RGB Interface for first-gen      |
-|  Corsair RGB keyboard                     |
+|  Generic RGB Interface for OpenRGB        |
+|  Gigabyte RGB Fusion 2.0 Driver           |
 |                                           |
-|  Adam Honse (CalcProgrammer1) 1/9/2020    |
+|  Adam Honse (CalcProgrammer1) 1/15/2020   |
 \*-----------------------------------------*/
 
 #pragma once
-#include "RGBController.h"
-#include "CorsairKbdV1Controller.h"
 
-class RGBController_CorsairKbdV1 : public RGBController
+#include "RGBController.h"
+#include "RGBFusion2Controller.h"
+
+class RGBController_RGBFusion2 : public RGBController
 {
 public:
-    RGBController_CorsairKbdV1(CorsairKbdV1Controller* corsair_ptr);
-    ~RGBController_CorsairKbdV1();
+    RGBController_RGBFusion2(RGBFusion2Controller* rgb_fusion_ptr);
     int         GetMode();
     void        SetMode(int mode);
     void        SetCustomMode();
@@ -24,5 +24,5 @@ public:
     void        UpdateSingleLED(int led);
 
 private:
-    CorsairKbdV1Controller*   corsair;
-};
+    RGBFusion2Controller* rgb_fusion;
+};