Change search path for i2c devices on linux

Looking for devices by bus instead of class should fix issues where the
class is named differently, e.g. i2c-dev instead of i2c-adapter.

.gitignore

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

.gitmodules

@@ -1,6 +0,0 @@
-[submodule "dependencies/libe131"]
-	path = dependencies/libe131
-	url = https://github.com/CalcProgrammer1/libe131
-[submodule "razer-drivers-win32"]
-	path = razer-drivers-win32
-	url = https://github.com/rsandoz/razer-drivers-win32

Controllers/AMDWraithPrismController/AMDWraithPrismController.cpp

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

Controllers/AMDWraithPrismController/AMDWraithPrismController.h

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

Controllers/AMDWraithPrismController/AMDWraithPrismControllerDetect.cpp

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

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

Controllers/AuraGPUController/AuraGPUController.h

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

Controllers/AuraGPUController/AuraGPUControllerDetect.cpp

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

Controllers/AuraSMBusController/AuraSMBusController.cpp

@@ -1,273 +0,0 @@
-/*-----------------------------------------*\
-|  AuraSMBusController.cpp                  |
-|                                           |
-|  Driver for ASUS Aura RGB lighting        |
-|  controller                               |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 8/19/2018   |
-\*-----------------------------------------*/
-
-#include "AuraSMBusController.h"
-#include <cstring>
-
-AuraSMBusController::AuraSMBusController(i2c_smbus_interface* bus, aura_dev_id dev)
-{
-    this->bus = bus;
-    this->dev = dev;
-
-    AuraUpdateDeviceName();
-
-    // Read the device configuration table
-    for (int i = 0; i < 64; i++)
-    {
-        config_table[i] = AuraRegisterRead(AURA_REG_CONFIG_TABLE + i);
-    }
-
-    // Read LED count from configuration table
-    led_count = config_table[AURA_CONFIG_LED_COUNT];
-
-    // LED-0116 - First generation motherboard controller
-    if (strcmp(device_name, "LED-0116") == 0)
-    {
-        direct_reg  = AURA_REG_COLORS_DIRECT;
-        effect_reg  = AURA_REG_COLORS_EFFECT;
-        channel_cfg = AURA_CONFIG_CHANNEL_V1;
-    }
-    // DIMM_LED-0102 - First generation DRAM controller (Trident Z RGB)
-    else if (strcmp(device_name, "DIMM_LED-0102") == 0)
-    {
-        direct_reg  = AURA_REG_COLORS_DIRECT;
-        effect_reg  = AURA_REG_COLORS_EFFECT;
-        channel_cfg = AURA_CONFIG_CHANNEL_V1;
-    }
-    // AUDA0-E6K5-0101 - Second generation DRAM controller (Geil Super Luce)
-    else if (strcmp(device_name, "AUDA0-E6K5-0101") == 0)
-    {
-        direct_reg  = AURA_REG_COLORS_DIRECT_V2;
-        effect_reg  = AURA_REG_COLORS_EFFECT_V2;
-        channel_cfg = AURA_CONFIG_CHANNEL_V2;
-    }
-    // AUMA0-E6K5-0106 - Second generation motherboard controller
-    else if (strcmp(device_name, "AUMA0-E6K5-0106") == 0)
-    {
-        direct_reg  = AURA_REG_COLORS_DIRECT_V2;
-        effect_reg  = AURA_REG_COLORS_EFFECT_V2;
-        channel_cfg = AURA_CONFIG_CHANNEL_V2;
-    }
-    // AUMA0-E6K5-0105 - Second generation motherboard controller
-    else if (strcmp(device_name, "AUMA0-E6K5-0105") == 0)
-    {
-        direct_reg  = AURA_REG_COLORS_DIRECT_V2;
-        effect_reg  = AURA_REG_COLORS_EFFECT_V2;
-        channel_cfg = AURA_CONFIG_CHANNEL_V2;
-    }
-    // AUMA0-E6K5-0104 - Second generation motherboard controller
-    else if (strcmp(device_name, "AUMA0-E6K5-0104") == 0)
-    {
-        direct_reg = AURA_REG_COLORS_DIRECT_V2;
-        effect_reg = AURA_REG_COLORS_EFFECT_V2;
-        channel_cfg = AURA_CONFIG_CHANNEL_V2;
-    }
-    // Assume first generation controller if string does not match
-    else
-    {
-        direct_reg  = AURA_REG_COLORS_DIRECT;
-        effect_reg  = AURA_REG_COLORS_EFFECT;
-        channel_cfg = AURA_CONFIG_CHANNEL_V1;
-    }
-}
-
-AuraSMBusController::~AuraSMBusController()
-{
-
-}
-
-std::string AuraSMBusController::GetDeviceName()
-{
-    return(device_name);
-}
-
-std::string AuraSMBusController::GetDeviceLocation()
-{
-    std::string return_string(bus->device_name);
-    char addr[5];
-    snprintf(addr, 5, "0x%02X", dev);
-    return_string.append(", address ");
-    return_string.append(addr);
-    return(return_string);
-}
-
-unsigned char AuraSMBusController::GetChannel(unsigned int led)
-{
-    return(config_table[channel_cfg + led]);
-}
-
-const char * AuraSMBusController::GetChannelName(unsigned int led)
-{
-    switch (config_table[channel_cfg + led])
-    {
-    case (unsigned char)AURA_LED_CHANNEL_AUDIO:
-        return(aura_channels[0]);
-        break;
-
-    case (unsigned char)AURA_LED_CHANNEL_BACKPLATE:
-        return(aura_channels[1]);
-        break;
-
-    case (unsigned char)AURA_LED_CHANNEL_BACK_IO:
-        return(aura_channels[2]);
-        break;
-
-    case (unsigned char)AURA_LED_CHANNEL_CENTER:
-        return(aura_channels[3]);
-        break;
-
-    case (unsigned char)AURA_LED_CHANNEL_CENTER_START:
-        return(aura_channels[4]);
-        break;
-
-    case (unsigned char)AURA_LED_CHANNEL_DRAM:
-        return(aura_channels[5]);
-        break;
-    
-    case (unsigned char)AURA_LED_CHANNEL_PCIE:
-        return(aura_channels[6]);
-        break;
-
-    case (unsigned char)AURA_LED_CHANNEL_RGB_HEADER:
-        return(aura_channels[7]);
-        break;
-
-    case (unsigned char)AURA_LED_CHANNEL_RGB_HEADER_2:
-        return(aura_channels[8]);
-        break;
-
-    case (unsigned char)AURA_LED_CHANNEL_RGB_HEADER_3:
-        return(aura_channels[9]);
-        break;
-
-    default:
-        return(aura_channels[10]);
-        break;
-    }
-}
-
-unsigned int AuraSMBusController::GetLEDCount()
-{
-    return(led_count);
-}
-
-unsigned char AuraSMBusController::GetLEDRed(unsigned int led)
-{
-    return(AuraRegisterRead(direct_reg + ( 3 * led )));
-}
-
-unsigned char AuraSMBusController::GetLEDGreen(unsigned int led)
-{
-    return(AuraRegisterRead(direct_reg + ( 3 * led ) + 2));
-}
-
-unsigned char AuraSMBusController::GetLEDBlue(unsigned int led)
-{
-    return(AuraRegisterRead(direct_reg + ( 3 * led ) + 1));
-}
-
-void AuraSMBusController::SetAllColorsDirect(unsigned char red, unsigned char green, unsigned char blue)
-{
-    unsigned char* colors = new unsigned char[led_count * 3];
-
-    for (unsigned int i = 0; i < (led_count * 3); i += 3)
-    {
-        colors[i + 0] = red;
-        colors[i + 1] = blue;
-        colors[i + 2] = green;
-    }
-
-    AuraRegisterWriteBlock(direct_reg, colors, led_count * 3);
-
-    delete colors;
-}
-
-void AuraSMBusController::SetAllColorsEffect(unsigned char red, unsigned char green, unsigned char blue)
-{
-    unsigned char* colors = new unsigned char[led_count * 3];
-
-    for (unsigned int i = 0; i < (led_count * 3); i += 3)
-    {
-        colors[i + 0] = red;
-        colors[i + 1] = blue;
-        colors[i + 2] = green;
-    }
-
-    AuraRegisterWriteBlock(effect_reg, colors, led_count * 3);
-    
-    AuraRegisterWrite(AURA_REG_APPLY, AURA_APPLY_VAL);
-
-    delete[] colors;
-}
-
-void AuraSMBusController::SetDirect(unsigned char direct)
-{
-    AuraRegisterWrite(AURA_REG_DIRECT, direct);
-    AuraRegisterWrite(AURA_REG_APPLY, AURA_APPLY_VAL);
-}
-
-void AuraSMBusController::SetLEDColorDirect(unsigned int led, unsigned char red, unsigned char green, unsigned char blue)
-{
-    unsigned char colors[3] = { red, blue, green };
-
-    AuraRegisterWriteBlock(direct_reg + ( 3 * led ), colors, 3);
-}
-
-void AuraSMBusController::SetLEDColorEffect(unsigned int led, unsigned char red, unsigned char green, unsigned char blue)
-{
-    unsigned char colors[3] = { red, blue, green };
-
-    AuraRegisterWriteBlock(effect_reg + (3 * led), colors, 3);
-
-    AuraRegisterWrite(AURA_REG_APPLY, AURA_APPLY_VAL);
-}
-
-void AuraSMBusController::SetMode(unsigned char mode)
-{
-    AuraRegisterWrite(AURA_REG_MODE, mode);
-    AuraRegisterWrite(AURA_REG_APPLY, AURA_APPLY_VAL);
-}
-
-void AuraSMBusController::AuraUpdateDeviceName()
-{
-    for (int i = 0; i < 16; i++)
-    {
-        device_name[i] = AuraRegisterRead(AURA_REG_DEVICE_NAME + i);
-    }
-}
-
-unsigned char AuraSMBusController::AuraRegisterRead(aura_register reg)
-{
-    //Write Aura register
-    bus->i2c_smbus_write_word_data(dev, 0x00, ((reg << 8) & 0xFF00) | ((reg >> 8) & 0x00FF));
-
-    //Read Aura value
-    return(bus->i2c_smbus_read_byte_data(dev, 0x81));
-
-}
-
-void AuraSMBusController::AuraRegisterWrite(aura_register reg, unsigned char val)
-{
-    //Write Aura register
-    bus->i2c_smbus_write_word_data(dev, 0x00, ((reg << 8) & 0xFF00) | ((reg >> 8) & 0x00FF));
-
-    //Write Aura value
-    bus->i2c_smbus_write_byte_data(dev, 0x01, val);
-
-}
-
-void AuraSMBusController::AuraRegisterWriteBlock(aura_register reg, unsigned char * data, unsigned char sz)
-{
-    //Write Aura register
-    bus->i2c_smbus_write_word_data(dev, 0x00, ((reg << 8) & 0xFF00) | ((reg >> 8) & 0x00FF));
-
-    //Write Aura block data
-    bus->i2c_smbus_write_block_data(dev, 0x03, sz, data);
-
-}

Controllers/AuraSMBusController/AuraSMBusControllerDetect.cpp

@@ -1,199 +0,0 @@
-#include "AuraSMBusController.h"
-#include "RGBController.h"
-#include "RGBController_AuraSMBus.h"
-#include "i2c_smbus.h"
-#include <vector>
-#include <stdio.h>
-#include <stdlib.h>
-
-#ifdef WIN32
-#include <Windows.h>
-#else
-#include <unistd.h>
-
-static void Sleep(unsigned int milliseconds)
-{
-    usleep(1000 * milliseconds);
-}
-#endif
-
-/*----------------------------------------------------------------------*\
-| This list contains the available SMBus addresses for mapping Aura RAM  |
-\*----------------------------------------------------------------------*/
-#define AURA_RAM_ADDRESS_COUNT  22
-
-static const unsigned char aura_ram_addresses[] =
-{
-    0x70,
-    0x71,
-    0x72,
-    0x73,
-    0x74,
-    0x75,
-    0x76,
-    0x78,
-    0x79,
-    0x7A,
-    0x7B,
-    0x7C,
-    0x7D,
-    0x7E,
-    0x7F,
-    0x4F,
-    0x66,
-    0x67,
-    0x39,
-    0x3B,
-    0x3C,
-    0x3D
-};
-
-/*---------------------------------------------------------------------------------*\
-| This list contains the available SMBus addresses for mapping Aura motherboards    |
-\*---------------------------------------------------------------------------------*/
-#define AURA_MOBO_ADDRESS_COUNT 4
-
-static const unsigned char aura_mobo_addresses[] =
-{
-    0x40,
-    0x4E,
-    0x4F,
-    0x66
-};
-
-/******************************************************************************************\
-*                                                                                          *
-*   AuraRegisterWrite                                                                      *
-*                                                                                          *
-*       A standalone version of the AuraSMBusController::AuraRegisterWrite function for    *
-*       access to Aura devices without instancing the AuraSMBusController class or reading *
-*       the config table from the device.                                                  *
-*                                                                                          *
-\******************************************************************************************/
-
-void AuraRegisterWrite(i2c_smbus_interface* bus, aura_dev_id dev, aura_register reg, unsigned char val)
-{
-    //Write Aura register
-    bus->i2c_smbus_write_word_data(dev, 0x00, ((reg << 8) & 0xFF00) | ((reg >> 8) & 0x00FF));
-
-    //Write Aura value
-    bus->i2c_smbus_write_byte_data(dev, 0x01, val);
-}
-
-/******************************************************************************************\
-*                                                                                          *
-*   TestForAuraSMBusController                                                                  *
-*                                                                                          *
-*       Tests the given address to see if an Aura controller exists there.  First does a   *
-*       quick write to test for a response, and if so does a simple read at 0xA0 to test   *
-*       for incrementing values 0...F which was observed at this location during data dump *
-*                                                                                          *
-\******************************************************************************************/
-
-bool TestForAuraSMBusController(i2c_smbus_interface* bus, unsigned char address)
-{
-    bool pass = false;
-
-    int res = bus->i2c_smbus_write_quick(address, I2C_SMBUS_WRITE);
-
-    if (res >= 0)
-    {
-        pass = true;
-
-        for (int i = 0xA0; i < 0xB0; i++)
-        {
-            res = bus->i2c_smbus_read_byte_data(address, i);
-
-            if (res != (i - 0xA0))
-            {
-                pass = false;
-            }
-        }
-    }
-
-    return(pass);
-
-}   /* TestForAuraSMBusController() */
-
-/******************************************************************************************\
-*                                                                                          *
-*   DetectAuraSMBusControllers                                                                  *
-*                                                                                          *
-*       Detect Aura controllers on the enumerated I2C busses.  Searches for Aura-enabled   *
-*       RAM at 0x77 and tries to initialize their slot addresses, then searches for them   *
-*       at their correct initialized addresses.  Also looks for motherboard controller at  *
-*       address 0x4E.                                                                      *
-*                                                                                          *
-*           bus - pointer to i2c_smbus_interface where Aura device is connected            *
-*           dev - I2C address of Aura device                                               *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectAuraSMBusControllers(std::vector<i2c_smbus_interface*> &busses, std::vector<RGBController*> &rgb_controllers)
-{
-    AuraSMBusController* new_aura;
-    RGBController_AuraSMBus* new_controller;
-
-    for (unsigned int bus = 0; bus < busses.size(); bus++)
-    {
-        int address_list_idx = -1;
-
-        // Remap Aura-enabled RAM modules on 0x77
-        for (unsigned int slot = 0; slot < 8; slot++)
-        {
-            int res = busses[bus]->i2c_smbus_write_quick(0x77, I2C_SMBUS_WRITE);
-
-            if (res < 0)
-            {
-                break;
-            }
-
-            do
-            {
-                address_list_idx++;
-
-                if(address_list_idx < AURA_RAM_ADDRESS_COUNT)
-                {
-                    res = busses[bus]->i2c_smbus_write_quick(aura_ram_addresses[address_list_idx], I2C_SMBUS_WRITE);
-                }
-                else
-                {
-                    break;
-                }
-            } while (res >= 0);
-
-            if(address_list_idx < AURA_RAM_ADDRESS_COUNT)
-            {
-                AuraRegisterWrite(busses[bus], 0x77, AURA_REG_SLOT_INDEX, slot);
-                AuraRegisterWrite(busses[bus], 0x77, AURA_REG_I2C_ADDRESS, (aura_ram_addresses[address_list_idx] << 1));
-            }
-        }
-
-        // Add Aura-enabled controllers at their remapped addresses
-        for (unsigned int address_list_idx = 0; address_list_idx < AURA_RAM_ADDRESS_COUNT; address_list_idx++)
-        {
-            if (TestForAuraSMBusController(busses[bus], aura_ram_addresses[address_list_idx]))
-            {
-                new_aura = new AuraSMBusController(busses[bus], aura_ram_addresses[address_list_idx]);
-                new_controller = new RGBController_AuraSMBus(new_aura);
-                rgb_controllers.push_back(new_controller);
-            }
-
-            Sleep(1);
-        }
-
-        // Add Aura-enabled motherboard controllers
-        for (unsigned int address_list_idx = 0; address_list_idx < AURA_MOBO_ADDRESS_COUNT; address_list_idx++)
-        {
-            if (TestForAuraSMBusController(busses[bus], aura_mobo_addresses[address_list_idx]))
-            {
-                new_aura = new AuraSMBusController(busses[bus], aura_mobo_addresses[address_list_idx]);
-                new_controller = new RGBController_AuraSMBus(new_aura);
-                rgb_controllers.push_back(new_controller);
-            }
-
-            Sleep(1);
-        }
-    }
-
-}   /* DetectAuraSMBusControllers() */

Controllers/CorsairLightingNodeController/CorsairLightingNodeController.cpp

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

Controllers/CorsairLightingNodeController/CorsairLightingNodeController.h

@@ -1,173 +0,0 @@
-/*---------------------------------------------------------*\
-|  Definitions for Corsair Lighting Node Pro                |
-|                                                           |
-|  Adam Honse ([email protected]), 1/12/2020        |
-\*---------------------------------------------------------*/
-
-#include "RGBController.h"
-#include <vector>
-#include <libusb-1.0/libusb.h>
-
-#pragma once
-
-enum
-{
-    CORSAIR_LIGHTING_NODE_PACKET_ID_FIRMWARE         = 0x02,     /* Get firmware version                 */
-    CORSAIR_LIGHTING_NODE_PACKET_ID_DIRECT           = 0x32,     /* Direct mode LED update packet        */
-    CORSAIR_LIGHTING_NODE_PACKET_ID_COMMIT           = 0x33,     /* Commit changes packet                */
-    CORSAIR_LIGHTING_NODE_PACKET_ID_BEGIN            = 0x34,     /* Begin effect packet                  */
-    CORSAIR_LIGHTING_NODE_PACKET_ID_EFFECT_CONFIG    = 0x35,     /* Effect mode configuration packet     */
-    CORSAIR_LIGHTING_NODE_PACKET_ID_TEMPERATURE      = 0x36,     /* Update temperature value packet      */
-    CORSAIR_LIGHTING_NODE_PACKET_ID_RESET            = 0x37,     /* Reset channel packet                 */
-    CORSAIR_LIGHTING_NODE_PACKET_ID_PORT_STATE       = 0x38,     /* Set port state packet                */
-    CORSAIR_LIGHTING_NODE_PACKET_ID_BRIGHTNESS       = 0x39,     /* Set brightness packet                */
-    CORSAIR_LIGHTING_NODE_PACKET_ID_LED_COUNT        = 0x3A,     /* Set LED count packet                 */
-    CORSAIR_LIGHTING_NODE_PACKET_ID_PROTOCOL         = 0x3B,     /* Set protocol packet                  */
-};
-
-enum
-{
-    CORSAIR_LIGHTING_NODE_DIRECT_CHANNEL_RED         = 0x00,     /* Red channel for direct update        */
-    CORSAIR_LIGHTING_NODE_DIRECT_CHANNEL_GREEN       = 0x01,     /* Green channel for direct update      */
-    CORSAIR_LIGHTING_NODE_DIRECT_CHANNEL_BLUE        = 0x02,     /* Blue channel for direct update       */
-};
-
-enum
-{
-    CORSAIR_LIGHTING_NODE_PORT_STATE_HARDWARE        = 0x01,     /* Effect hardware control of channel   */
-    CORSAIR_LIGHTING_NODE_PORT_STATE_SOFTWARE        = 0x02,     /* Direct software control of channel   */
-};
-
-enum
-{
-    CORSAIR_LIGHTING_NODE_LED_TYPE_LED_STRIP         = 0x0A,     /* Corsair LED Strip Type               */
-    CORSAIR_LIGHTING_NODE_LED_TYPE_HD_FAN            = 0x0C,     /* Corsair HD-series Fan Type           */
-    CORSAIR_LIGHTING_NODE_LED_TYPE_SP_FAN            = 0x01,     /* Corsair SP-series Fan Type           */
-    CORSAIR_LIGHTING_NODE_LED_TYPE_ML_FAN            = 0x02,     /* Corsair ML-series Fan Type           */
-};
-
-enum
-{
-    CORSAIR_LIGHTING_NODE_CHANNEL_1                  = 0x00,     /* Channel 1                            */
-    CORSAIR_LIGHTING_NODE_CHANNEL_2                  = 0x01,     /* Channel 2                            */
-    CORSAIR_LIGHTING_NODE_NUM_CHANNELS               = 0x02,     /* Number of channels                   */
-};
-
-enum
-{
-    CORSAIR_LIGHTING_NODE_SPEED_FAST                 = 0x00,     /* Fast speed                           */
-    CORSAIR_LIGHTING_NODE_SPEED_MEDIUM               = 0x01,     /* Medium speed                         */
-    CORSAIR_LIGHTING_NODE_SPEED_SLOW                 = 0x02,     /* Slow speed                           */
-};
-
-enum
-{
-    CORSAIR_LIGHTING_NODE_MODE_RAINBOW_WAVE          = 0x00,     /* Rainbow Wave mode                    */
-    CORSAIR_LIGHTING_NODE_MODE_COLOR_SHIFT           = 0x01,     /* Color Shift mode                     */
-    CORSAIR_LIGHTING_NODE_MODE_COLOR_PULSE           = 0x02,     /* Color Pulse mode                     */
-    CORSAIR_LIGHTING_NODE_MODE_COLOR_WAVE            = 0x03,     /* Color Wave mode                      */
-    CORSAIR_LIGHTING_NODE_MODE_STATIC                = 0x04,     /* Static mode                          */
-    CORSAIR_LIGHTING_NODE_MODE_TEMPERATURE           = 0x05,     /* Temperature mode                     */
-    CORSAIR_LIGHTING_NODE_MODE_VISOR                 = 0x06,     /* Visor mode                           */
-    CORSAIR_LIGHTING_NODE_MODE_MARQUEE               = 0x07,     /* Marquee mode                         */
-    CORSAIR_LIGHTING_NODE_MODE_BLINK                 = 0x08,     /* Blink mode                           */
-    CORSAIR_LIGHTING_NODE_MODE_SEQUENTIAL            = 0x09,     /* Sequential mode                      */
-    CORSAIR_LIGHTING_NODE_MODE_RAINBOW               = 0x0A,     /* Rainbow mode                         */
-};
-
-class CorsairLightingNodeController
-{
-public:
-    CorsairLightingNodeController(libusb_device_handle* dev_handle, unsigned int dev_endpoint);
-    ~CorsairLightingNodeController();
-
-    std::string     GetFirmwareString();
-
-    unsigned int    GetStripsOnChannel(unsigned int channel);
-
-    void            SetChannelEffect(unsigned char channel,
-                                     unsigned char num_leds,
-                                     unsigned char mode,
-                                     unsigned char speed,
-                                     unsigned char direction,
-                                     bool          random,
-                                     unsigned char red1,
-                                     unsigned char grn1,
-                                     unsigned char blu1,
-                                     unsigned char red2,
-                                     unsigned char grn2,
-                                     unsigned char blu2,
-                                     unsigned char red3,
-                                     unsigned char grn3,
-                                     unsigned char blu3
-                                    );
-
-    void            SetChannelLEDs(unsigned char channel, RGBColor * colors, unsigned int num_colors);
-
-    void            KeepaliveThread();
-
-private:
-    libusb_device_handle*   dev;
-    unsigned int            endpoint;
-    std::string             firmware_version;
-
-    void            SendFirmwareRequest();
-
-    void            SendDirect
-                        (
-                        unsigned char   channel,
-                        unsigned char   start,
-                        unsigned char   count,
-                        unsigned char   color_channel,
-                        unsigned char*  color_data
-                        );
-
-    void            SendCommit();
-
-    void            SendBegin
-                        (
-                        unsigned char   channel
-                        );
-
-    void            SendEffectConfig
-                        (
-                        unsigned char   channel,
-                        unsigned char   count,
-                        unsigned char   led_type,
-                        unsigned char   mode,
-                        unsigned char   speed,
-                        unsigned char   direction,
-                        unsigned char   change_style,
-                        unsigned char   color_0_red,
-                        unsigned char   color_0_green,
-                        unsigned char   color_0_blue,
-                        unsigned char   color_1_red,
-                        unsigned char   color_1_green,
-                        unsigned char   color_1_blue,
-                        unsigned char   color_2_red,
-                        unsigned char   color_2_green,
-                        unsigned char   color_2_blue,
-                        unsigned short  temperature_0,
-                        unsigned short  temperature_1,
-                        unsigned short  temperature_2
-                        );
-
-    void            SendTemperature();
-
-    void            SendReset
-                        (
-                        unsigned char   channel
-                        );
-
-    void            SendPortState
-                        (
-                        unsigned char   channel,
-                        unsigned char   state
-                        );
-
-    void            SendBrightness();
-
-    void            SendLEDCount();
-
-    void            SendProtocol();
-};

Controllers/CorsairLightingNodeController/CorsairLightingNodeControllerDetect.cpp

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

Controllers/CorsairPeripheralController/CorsairPeripheralController.cpp

@@ -1,487 +0,0 @@
-/*-----------------------------------------*\
-|  CorsairPeripheralController.cpp          |
-|                                           |
-|  Driver for Corsair RGB keyboard, mouse,  |
-|  and mousemat lighting controller         |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 1/9/2020    |
-\*-----------------------------------------*/
-
-#include "CorsairPeripheralController.h"
-
-#include <cstring>
-
-static unsigned int keys[] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0C, 0x0D, 0x0E, 0x0F, 0x11, 0x12,
-                              0x14, 0x15, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x20, 0x21, 0x24, 0x25, 0x26,
-                              0x27, 0x28, 0x2A, 0x2B, 0x2C, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
-                              0x3C, 0x3D, 0x3E, 0x3F, 0x40, 0x42, 0x43, 0x44, 0x45, 0x48, 73,   74,   75,   76,   78,
-                              79,   80,   81,   84,   85,   86,   87,   88,   89,   90,   91,   92,   93,   96,   97,
-                              98,   99,   100,  101,  102,  103,  104,  105,  108,  109,  110,  111,  112,  113,  115,
-                              116,  117,  120,  121,  122,  123,  124,  126,  127,  128,  129,  132,  133,  134,  135,
-                              136,  137,  139,  140,  141};
-
-static void send_usb_msg(hid_device* dev, char * data_pkt)
-{
-    char usb_pkt[65];
-    usb_pkt[0] = 0x00;
-    for(int i = 1; i < 65; i++)
-    {
-        usb_pkt[i] = data_pkt[i-1];
-    }
-    int bytes = hid_send_feature_report(dev, (unsigned char *)usb_pkt, 65);
-    bytes++;
-}
-
-CorsairPeripheralController::CorsairPeripheralController(hid_device* dev_handle)
-{
-    dev = dev_handle;
-
-    ReadFirmwareInfo();
-
-    SpecialFunctionControl();
-    LightingControl();
-}
-
-CorsairPeripheralController::~CorsairPeripheralController()
-{
-
-}
-
-device_type CorsairPeripheralController::GetDeviceType()
-{
-    return type;
-}
-
-std::string CorsairPeripheralController::GetFirmwareString()
-{
-    return firmware_version;
-}
-
-void CorsairPeripheralController::SetLEDs(std::vector<RGBColor>colors)
-{
-    switch(type)
-    {
-        case DEVICE_TYPE_KEYBOARD:
-            SetLEDsKeyboardFull(colors);
-            break;
-
-        case DEVICE_TYPE_MOUSE:
-            SetLEDsMouse(colors);
-            break;
-
-        case DEVICE_TYPE_MOUSEMAT:
-            SetLEDsMousemat(colors);
-            break;
-    }
-}
-
-void CorsairPeripheralController::SetLEDsKeyboardFull(std::vector<RGBColor> colors)
-{
-    unsigned char red_val[144];
-    unsigned char grn_val[144];
-    unsigned char blu_val[144];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffers                                      |
-    \*-----------------------------------------------------*/
-    memset(red_val, 0x00, sizeof( red_val ));
-    memset(grn_val, 0x00, sizeof( grn_val ));
-    memset(blu_val, 0x00, sizeof( blu_val ));
-
-    /*-----------------------------------------------------*\
-    | Copy red, green, and blue components into buffers     |
-    \*-----------------------------------------------------*/
-    for(std::size_t color_idx = 0; color_idx < colors.size(); color_idx++)
-    {
-        RGBColor           color = colors[color_idx];
-        red_val[keys[color_idx]] = RGBGetRValue(color);
-        grn_val[keys[color_idx]] = RGBGetGValue(color);
-        blu_val[keys[color_idx]] = RGBGetBValue(color);
-    }
-
-    /*-----------------------------------------------------*\
-    | Send red bytes                                        |
-    \*-----------------------------------------------------*/
-    StreamPacket(1, 60, &red_val[0]);
-    StreamPacket(2, 60, &red_val[60]);
-    StreamPacket(3, 24, &red_val[120]);
-    SubmitKeyboardFullColors(1, 3, 1);
-
-    /*-----------------------------------------------------*\
-    | Send green bytes                                      |
-    \*-----------------------------------------------------*/
-    StreamPacket(1, 60, &grn_val[0]);
-    StreamPacket(2, 60, &grn_val[60]);
-    StreamPacket(3, 24, &grn_val[120]);
-    SubmitKeyboardFullColors(2, 3, 1);
-
-    /*-----------------------------------------------------*\
-    | Send blue bytes                                       |
-    \*-----------------------------------------------------*/
-    StreamPacket(1, 60, &blu_val[0]);
-    StreamPacket(2, 60, &blu_val[60]);
-    StreamPacket(3, 24, &blu_val[120]);
-    SubmitKeyboardFullColors(3, 3, 2);
-}
-
-void CorsairPeripheralController::SetLEDsMouse(std::vector<RGBColor> colors)
-{
-    SubmitMouseColors(colors.size(), &colors[0]);
-}
-
-void CorsairPeripheralController::SetLEDsMousemat(std::vector<RGBColor> colors)
-{
-    SubmitMousematColors(colors.size(), &colors[0]);
-}
-
-void CorsairPeripheralController::SetLEDsKeyboardLimited(std::vector<RGBColor> colors)
-{
-    unsigned char data_pkt[216];
-    unsigned char red_val[144];
-    unsigned char grn_val[144];
-    unsigned char blu_val[144];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffers                                      |
-    \*-----------------------------------------------------*/
-    memset(data_pkt, 0x00, sizeof( data_pkt ));
-    memset(red_val, 0x00, sizeof( red_val ));
-    memset(grn_val, 0x00, sizeof( grn_val ));
-    memset(blu_val, 0x00, sizeof( blu_val ));
-
-    /*-----------------------------------------------------*\
-    | Scale color values to 9-bit                           |
-    \*-----------------------------------------------------*/
-    for(std::size_t color_idx = 0; color_idx < colors.size(); color_idx++)
-    {
-        RGBColor      color = colors[color_idx];
-        unsigned char red   = RGBGetRValue(color);
-        unsigned char grn   = RGBGetGValue(color);
-        unsigned char blu   = RGBGetBValue(color);
-
-        if( red > 7 ) red = 7;
-        if( grn > 7 ) grn = 7;
-        if( blu > 7 ) blu = 7;
-
-        red = 7 - red;
-        grn = 7 - grn;
-        blu = 7 - blu;
-
-        red_val[keys[color_idx]] = red;
-        grn_val[keys[color_idx]] = grn;
-        blu_val[keys[color_idx]] = blu;
-    }
-
-    /*-----------------------------------------------------*\
-    | Pack the color values, 2 values per byte              |
-    \*-----------------------------------------------------*/
-    for(int red_idx = 0; red_idx < 72; red_idx++)
-    {
-        data_pkt[red_idx] = red_val[(red_idx * 2) + 1] << 4 | red_val[red_idx * 2];
-    }
-
-    for(int grn_idx = 0; grn_idx < 72; grn_idx++)
-    {
-        data_pkt[grn_idx + 72] = grn_val[(grn_idx * 2) + 1] << 4 | grn_val[grn_idx * 2];
-    }
-
-    for(int blu_idx = 0; blu_idx < 72; blu_idx++)
-    {
-        data_pkt[blu_idx + 144] = blu_val[(blu_idx * 2) + 1] << 4 | blu_val[blu_idx * 2];
-    }
-
-    /*-----------------------------------------------------*\
-    | Send the packets                                      |
-    \*-----------------------------------------------------*/
-    StreamPacket(1, 60, &data_pkt[0]);
-    StreamPacket(2, 60, &data_pkt[60]);
-    StreamPacket(3, 60, &data_pkt[120]);
-    StreamPacket(4, 36, &data_pkt[180]);
-    
-    SubmitKeyboardLimitedColors(216);
-}
-
-/*-------------------------------------------------------------------------------------------------*\
-| Private packet sending functions.                                                                 |
-\*-------------------------------------------------------------------------------------------------*/
-
-void CorsairPeripheralController::LightingControl()
-{
-    char usb_buf[64];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up Lighting Control packet                        |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]           = CORSAIR_COMMAND_WRITE;
-    usb_buf[0x01]           = CORSAIR_PROPERTY_LIGHTING_CONTROL;
-    usb_buf[0x02]           = CORSAIR_LIGHTING_CONTROL_SOFTWARE;
-
-    /*-----------------------------------------------------*\
-    | Lighting control byte needs to be 3 for keyboards, 1  |
-    | for mice and mousepads                                |
-    \*-----------------------------------------------------*/
-    switch(type)
-    {
-        default:
-        case DEVICE_TYPE_KEYBOARD:
-            usb_buf[0x04]   = 0x03;
-            break;
-
-        case DEVICE_TYPE_MOUSE:
-            usb_buf[0x04]   = 0x01;
-            break;
-
-        case DEVICE_TYPE_MOUSEMAT:
-            usb_buf[0x04]   = 0x04;
-            break;
-    }
-    
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    send_usb_msg(dev, usb_buf);
-}
-
-void CorsairPeripheralController::SpecialFunctionControl()
-{
-    char usb_buf[64];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up Lighting Control packet                        |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]           = CORSAIR_COMMAND_WRITE;
-    usb_buf[0x01]           = CORSAIR_PROPERTY_SPECIAL_FUNCTION;
-    usb_buf[0x02]           = CORSAIR_LIGHTING_CONTROL_SOFTWARE;
-    
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    send_usb_msg(dev, usb_buf);
-}
-
-void CorsairPeripheralController::ReadFirmwareInfo()
-{
-    char usb_buf[64];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up Read Firmware Info packet                      |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]   = CORSAIR_COMMAND_READ;
-    usb_buf[0x01]   = CORSAIR_PROPERTY_FIRMWARE_INFO;
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    send_usb_msg(dev, usb_buf);
-    hid_get_feature_report(dev, (unsigned char*)usb_buf, 64);
-
-    /*-----------------------------------------------------*\
-    | Get device type                                       |
-    |   0xC0    Device is a keyboard                        |
-    |   0xC1    Device is a mouse                           |
-    |   0xC2    Device is a mousepad                        |
-    \*-----------------------------------------------------*/
-    switch((unsigned char)usb_buf[0x14])
-    {
-        case 0xC0:
-            type = DEVICE_TYPE_KEYBOARD;
-            break;
-
-        case 0xC1:
-            type = DEVICE_TYPE_MOUSE;
-            break;
-
-        case 0xC2:
-            type = DEVICE_TYPE_MOUSEMAT;
-            break;
-
-        default:
-            type = DEVICE_TYPE_UNKNOWN;
-            break;
-    }
-
-    /*-----------------------------------------------------*\
-    | Format firmware version string if device type is valid|
-    \*-----------------------------------------------------*/
-    if(type != DEVICE_TYPE_UNKNOWN)
-    {
-        firmware_version = std::to_string(usb_buf[0x09]) + "." + std::to_string(usb_buf[0x08]);
-    }
-}
-
-void CorsairPeripheralController::StreamPacket
-    (
-    unsigned char   packet_id,
-    unsigned char   data_sz,
-    unsigned char*  data_ptr
-    )
-{
-    char usb_buf[64];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up Stream packet                                  |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]   = CORSAIR_COMMAND_STREAM;
-    usb_buf[0x01]   = packet_id;
-    usb_buf[0x02]   = data_sz;
-
-    /*-----------------------------------------------------*\
-    | Copy in data bytes                                    |
-    \*-----------------------------------------------------*/
-    memcpy(&usb_buf[0x04], data_ptr, data_sz);
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    send_usb_msg(dev, usb_buf);
-}
-
-void CorsairPeripheralController::SubmitKeyboardFullColors
-    (
-    unsigned char   color_channel,
-    unsigned char   packet_count,
-    unsigned char   finish_val
-    )
-{
-    char usb_buf[64];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up Submit Keyboard 24-Bit Colors packet           |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]   = CORSAIR_COMMAND_WRITE;
-    usb_buf[0x01]   = CORSAIR_PROPERTY_SUBMIT_KEYBOARD_COLOR_24;
-    usb_buf[0x02]   = color_channel;
-    usb_buf[0x03]   = packet_count;
-    usb_buf[0x04]   = finish_val;
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    send_usb_msg(dev, usb_buf);
-}
-
-void CorsairPeripheralController::SubmitKeyboardLimitedColors
-    (
-    unsigned char   byte_count
-    )
-{
-    char usb_buf[64];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up Submit Keyboard 9-Bit Colors packet            |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]   = CORSAIR_COMMAND_WRITE;
-    usb_buf[0x01]   = CORSAIR_PROPERTY_SUBMIT_KEYBOARD_COLOR_9;
-    usb_buf[0x04]   = byte_count;
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    send_usb_msg(dev, usb_buf);
-}
-
-void CorsairPeripheralController::SubmitMouseColors
-    (
-    unsigned char   num_zones,
-    RGBColor *      color_data
-    )
-{
-    char usb_buf[64];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up Submit Mouse Colors packet                     |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]   = CORSAIR_COMMAND_WRITE;
-    usb_buf[0x01]   = CORSAIR_PROPERTY_SUBMIT_MOUSE_COLOR;
-    usb_buf[0x02]   = num_zones;
-    usb_buf[0x03]   = 0x00;
-
-    /*-----------------------------------------------------*\
-    | Copy in colors in <ZONE> <RED> <GREEN> <BLUE> order   |
-    \*-----------------------------------------------------*/
-    for(unsigned int zone_idx = 0; zone_idx < num_zones; zone_idx++)
-    {
-        usb_buf[(zone_idx * 4) + 4] = zone_idx;
-        usb_buf[(zone_idx * 4) + 5] = RGBGetRValue(color_data[zone_idx]);
-        usb_buf[(zone_idx * 4) + 6] = RGBGetGValue(color_data[zone_idx]);
-        usb_buf[(zone_idx * 4) + 7] = RGBGetBValue(color_data[zone_idx]);
-    }
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    send_usb_msg(dev, usb_buf);
-}
-
-void CorsairPeripheralController::SubmitMousematColors
-    (
-    unsigned char   num_zones,
-    RGBColor *      color_data
-    )
-{
-    char usb_buf[64];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up Submit Mouse Colors packet                     |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]   = CORSAIR_COMMAND_WRITE;
-    usb_buf[0x01]   = CORSAIR_PROPERTY_SUBMIT_MOUSE_COLOR;
-    usb_buf[0x02]   = num_zones;
-    usb_buf[0x03]   = 0x00;
-
-    /*-----------------------------------------------------*\
-    | Copy in colors in <ZONE> <RED> <GREEN> <BLUE> order   |
-    \*-----------------------------------------------------*/
-    for(unsigned int zone_idx = 0; zone_idx < num_zones; zone_idx++)
-    {
-        //usb_buf[(zone_idx * 4) + 4] = zone_idx;
-        usb_buf[(zone_idx * 3) + 4] = RGBGetRValue(color_data[zone_idx]);
-        usb_buf[(zone_idx * 3) + 5] = RGBGetGValue(color_data[zone_idx]);
-        usb_buf[(zone_idx * 3) + 6] = RGBGetBValue(color_data[zone_idx]);
-    }
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    send_usb_msg(dev, usb_buf);
-}

Controllers/CorsairPeripheralController/CorsairPeripheralController.h

@@ -1,106 +0,0 @@
-/*-----------------------------------------*\
-|  CorsairPeripheralController.h            |
-|                                           |
-|  Definitions and types for Corsair RGB    |
-|  keyboard, mouse, and mousemat lighting   |
-|  controller                               |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 1/9/2020    |
-\*-----------------------------------------*/
-
-#include "RGBController.h"
-
-#include <string>
-#include <hidapi/hidapi.h>
-
-#pragma once
-
-enum
-{
-    CORSAIR_COMMAND_WRITE       = 0x07,
-    CORSAIR_COMMAND_READ        = 0x0E,
-    CORSAIR_COMMAND_STREAM      = 0x7F
-};
-
-enum
-{
-    CORSAIR_PROPERTY_FIRMWARE_INFO              = 0x01,
-    CORSAIR_PROPERTY_RESET                      = 0x02,
-    CORSAIR_PROPERTY_SPECIAL_FUNCTION           = 0x04,
-    CORSAIR_PROPERTY_LIGHTING_CONTROL           = 0x05,
-    CORSAIR_PROPERTY_HARDWARE_PROFILE           = 0x13,
-    CORSAIR_PROPERTY_SUBMIT_MOUSE_COLOR         = 0x22,
-    CORSAIR_PROPERTY_SUBMIT_KEYBOARD_COLOR_9    = 0x27,
-    CORSAIR_PROPERTY_SUBMIT_KEYBOARD_COLOR_24   = 0x28,
-};
-
-enum
-{
-    CORSAIR_LIGHTING_CONTROL_HARDWARE           = 0x01,
-    CORSAIR_LIGHTING_CONTROL_SOFTWARE           = 0x02
-};
-
-enum
-{
-    CORSAIR_COLOR_CHANNEL_RED       = 0x01,
-    CORSAIR_COLOR_CHANNEL_GREEN     = 0x02,
-    CORSAIR_COLOR_CHANNEL_BLUE      = 0x03
-};
-
-class CorsairPeripheralController
-{
-public:
-    CorsairPeripheralController(hid_device* dev_handle);
-    ~CorsairPeripheralController();
-
-    device_type     GetDeviceType();
-    std::string     GetFirmwareString();
-
-    void            SetLEDs(std::vector<RGBColor> colors);
-    void            SetLEDsKeyboardFull(std::vector<RGBColor> colors);
-    void            SetLEDsKeyboardLimited(std::vector<RGBColor> colors);
-    void            SetLEDsMouse(std::vector<RGBColor> colors);
-    void            SetLEDsMousemat(std::vector<RGBColor> colors);
-
-private:
-    hid_device*             dev;
-
-    std::string             firmware_version;
-    device_type             type;
-
-    void    LightingControl();
-    void    SpecialFunctionControl();
-
-    void    ReadFirmwareInfo();
-    
-    void    StreamPacket
-                (
-                unsigned char   packet_id,
-                unsigned char   data_sz,
-                unsigned char*  data_ptr
-                );
-
-    void    SubmitKeyboardFullColors
-                (
-                unsigned char   color_channel,
-                unsigned char   packet_count,
-                unsigned char   finish_val
-                );
-
-    void    SubmitKeyboardLimitedColors
-                (
-                unsigned char   byte_count
-                );
-
-    void    SubmitMouseColors
-                (
-                unsigned char   num_zones,
-                RGBColor *      color_data
-                );
-
-    void    SubmitMousematColors
-            (
-            unsigned char   num_zones,
-            RGBColor *      color_data
-            );
-};

Controllers/CorsairPeripheralController/CorsairPeripheralControllerDetect.cpp

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

Controllers/CorsairVengeanceController/CorsairVengeanceControllerDetect.cpp

@@ -1,125 +0,0 @@
-#include "CorsairVengeanceController.h"
-#include "RGBController.h"
-#include "RGBController_CorsairVengeance.h"
-#include "i2c_smbus.h"
-#include <vector>
-#include <stdio.h>
-#include <stdlib.h>
-
-/******************************************************************************************\
-*                                                                                          *
-*   TestForCorsairVengeanceController                                                      *
-*                                                                                          *
-*       Tests the given address to see if a Corsair controller exists there.               *
-*                                                                                          *
-\******************************************************************************************/
-
-bool TestForCorsairVengeanceController(i2c_smbus_interface* bus, unsigned char address)
-{
-    bool pass = false;
-
-    int res = bus->i2c_smbus_write_quick(address, I2C_SMBUS_WRITE);
-
-    if (res >= 0)
-    {
-        pass = true;
-
-        for (int i = 0xA0; i < 0xB0; i++)
-        {
-            res = bus->i2c_smbus_read_byte_data(address, i);
-
-            if (res != 0xBA)
-            {
-                pass = false;
-            }
-        }
-    }
-
-    return(pass);
-
-}   /* TestForCorsairVengeanceController() */
-
-/******************************************************************************************\
-*                                                                                          *
-*   DetectCorsairVengeanceControllers                                                      *
-*                                                                                          *
-*       Detect Corsair controllers on the enumerated I2C busses.                           *
-*                                                                                          *
-*           bus - pointer to i2c_smbus_interface where Aura device is connected            *
-*           dev - I2C address of Aura device                                               *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectCorsairVengeanceControllers(std::vector<i2c_smbus_interface*> &busses, std::vector<RGBController*> &rgb_controllers)
-{
-    CorsairVengeanceController* new_corsair;
-    RGBController_CorsairVengeance* new_controller;
-
-    for (unsigned int bus = 0; bus < busses.size(); bus++)
-    {
-        // Check for Corsair controller at 0x58
-        if (TestForCorsairVengeanceController(busses[bus], 0x58))
-        {
-            new_corsair = new CorsairVengeanceController(busses[bus], 0x58);
-            new_controller = new RGBController_CorsairVengeance(new_corsair);
-            rgb_controllers.push_back(new_controller);
-        }
-
-        // Check for Corsair controller at 0x59
-        if (TestForCorsairVengeanceController(busses[bus], 0x59))
-        {
-            new_corsair = new CorsairVengeanceController(busses[bus], 0x59);
-            new_controller = new RGBController_CorsairVengeance(new_corsair);
-            rgb_controllers.push_back(new_controller);
-        }
-
-        // Check for Corsair controller at 0x5A
-        if (TestForCorsairVengeanceController(busses[bus], 0x5A))
-        {
-            new_corsair = new CorsairVengeanceController(busses[bus], 0x5A);
-            new_controller = new RGBController_CorsairVengeance(new_corsair);
-            rgb_controllers.push_back(new_controller);
-        }
-
-        // Check for Corsair controller at 0x5B
-        if (TestForCorsairVengeanceController(busses[bus], 0x5B))
-        {
-            new_corsair = new CorsairVengeanceController(busses[bus], 0x5B);
-            new_controller = new RGBController_CorsairVengeance(new_corsair);
-            rgb_controllers.push_back(new_controller);
-        }
-
-        // Check for Corsair controller at 0x5C
-        if (TestForCorsairVengeanceController(busses[bus], 0x5C))
-        {
-            new_corsair = new CorsairVengeanceController(busses[bus], 0x5C);
-            new_controller = new RGBController_CorsairVengeance(new_corsair);
-            rgb_controllers.push_back(new_controller);
-        }
-
-        // Check for Corsair controller at 0x5D
-        if (TestForCorsairVengeanceController(busses[bus], 0x5D))
-        {
-            new_corsair = new CorsairVengeanceController(busses[bus], 0x5D);
-            new_controller = new RGBController_CorsairVengeance(new_corsair);
-            rgb_controllers.push_back(new_controller);
-        }
-
-        // Check for Corsair controller at 0x5E
-        if (TestForCorsairVengeanceController(busses[bus], 0x5E))
-        {
-            new_corsair = new CorsairVengeanceController(busses[bus], 0x5E);
-            new_controller = new RGBController_CorsairVengeance(new_corsair);
-            rgb_controllers.push_back(new_controller);
-        }
-
-        // Check for Corsair controller at 0x5F
-        if (TestForCorsairVengeanceController(busses[bus], 0x5F))
-        {
-            new_corsair = new CorsairVengeanceController(busses[bus], 0x5F);
-            new_controller = new RGBController_CorsairVengeance(new_corsair);
-            rgb_controllers.push_back(new_controller);
-        }
-    }
-
-}   /* DetectCorsairVengeanceControllers() */

Controllers/CorsairVengeanceProController/CorsairVengeanceProController.cpp

@@ -1,172 +0,0 @@
-/*-----------------------------------------*\
-|  CorsairVengeanceProController.cpp        |
-|                                           |
-|  Definitions and types for Corsair        |
-|  Vengeance Pro RGB RAM lighting controller|
-|                                           |
-|  Adam Honse (CalcProgrammer1) 6/30/2019   |
-\*-----------------------------------------*/
-
-#include "CorsairVengeanceProController.h"
-#include <cstring>
-
-#ifdef WIN32
-#include <Windows.h>
-#else
-#include <unistd.h>
-
-static void Sleep(unsigned int milliseconds)
-{
-    usleep(1000 * milliseconds);
-}
-#endif
-
-CorsairVengeanceProController::CorsairVengeanceProController(i2c_smbus_interface* bus, corsair_dev_id dev)
-{
-    this->bus = bus;
-    this->dev = dev;
-
-    strcpy(device_name, "Corsair Vengeance Pro RGB");
-    led_count = CORSAIR_PRO_LED_COUNT;
-
-    effect_mode = CORSAIR_PRO_MODE_STATIC;
-    
-    for (unsigned int i = 0; i < led_count; i++)
-    {
-        led_red[i]      = 0;
-        led_green[i]    = 0;
-        led_blue[i]     = 0;
-    }
-}
-
-CorsairVengeanceProController::~CorsairVengeanceProController()
-{
-
-}
-
-std::string CorsairVengeanceProController::GetDeviceName()
-{
-    return(device_name);
-}
-
-std::string CorsairVengeanceProController::GetDeviceLocation()
-{
-    std::string return_string(bus->device_name);
-    char addr[5];
-    snprintf(addr, 5, "0x%02X", dev);
-    return_string.append(", address ");
-    return_string.append(addr);
-    return(return_string);
-}
-
-unsigned int CorsairVengeanceProController::GetLEDCount()
-{
-    return(led_count);
-}
-
-unsigned char CorsairVengeanceProController::GetEffect()
-{
-    return(effect_mode);
-}
-
-void CorsairVengeanceProController::SetAllColors(unsigned char red, unsigned char green, unsigned char blue)
-{
-    for (unsigned int i = 0; i < led_count; i++)
-    {
-        led_red[i]      = red;
-        led_green[i]    = green;
-        led_blue[i]     = blue;
-    }
-}
-
-void CorsairVengeanceProController::SetLEDColor(unsigned int led, unsigned char red, unsigned char green, unsigned char blue)
-{
-    led_red[led]    = red;
-    led_green[led]  = green;
-    led_blue[led]   = blue;
-}
-
-void CorsairVengeanceProController::ApplyColors()
-{
-    bus->i2c_smbus_write_byte_data(dev, 0x26, 0x02);
-    Sleep(1);
-    bus->i2c_smbus_write_byte_data(dev, 0x21, 0x00);
-    Sleep(1);
-
-    for (int i = 0; i < 10; i++)
-    {
-        bus->i2c_smbus_write_byte_data(dev, CORSAIR_PRO_REG_COMMAND, led_red[i]);
-        bus->i2c_smbus_write_byte_data(dev, CORSAIR_PRO_REG_COMMAND, led_green[i]);
-        bus->i2c_smbus_write_byte_data(dev, CORSAIR_PRO_REG_COMMAND, led_blue[i]);
-        bus->i2c_smbus_write_byte_data(dev, CORSAIR_PRO_REG_COMMAND, 0xFF);
-    }
-
-    bus->i2c_smbus_write_byte_data(dev, 0x82, 0x02);
-}
-
-void CorsairVengeanceProController::SetEffect(unsigned char mode,
-                                     unsigned char speed,
-                                     unsigned char direction,
-                                     bool          random,
-                                     unsigned char red1,
-                                     unsigned char grn1,
-                                     unsigned char blu1,
-                                     unsigned char red2,
-                                     unsigned char grn2,
-                                     unsigned char blu2
-                                    )
-{
-    effect_mode = mode;
-
-    bus->i2c_smbus_write_byte_data(dev, 0x26, 0x01);
-    Sleep(1);
-    bus->i2c_smbus_write_byte_data(dev, 0x21, 0x00);
-    Sleep(1);
-
-    unsigned char random_byte;
-
-    if(random)
-    {
-        random_byte = CORSAIR_PRO_EFFECT_RANDOM_COLORS;
-    }
-    else
-    {
-        random_byte = CORSAIR_PRO_EFFECT_CUSTOM_COLORS;
-    }
-
-    bus->i2c_smbus_write_byte_data(dev, CORSAIR_PRO_REG_COMMAND, effect_mode);  //Mode
-    bus->i2c_smbus_write_byte_data(dev, CORSAIR_PRO_REG_COMMAND, speed);        //Speed
-    bus->i2c_smbus_write_byte_data(dev, CORSAIR_PRO_REG_COMMAND, random_byte);  //Custom color
-    bus->i2c_smbus_write_byte_data(dev, CORSAIR_PRO_REG_COMMAND, direction);    //Direction
-    bus->i2c_smbus_write_byte_data(dev, CORSAIR_PRO_REG_COMMAND, red1);         // Custom color 1 red
-    bus->i2c_smbus_write_byte_data(dev, CORSAIR_PRO_REG_COMMAND, grn1);         // Custom color 1 green
-    bus->i2c_smbus_write_byte_data(dev, CORSAIR_PRO_REG_COMMAND, blu1);         // Custom color 1 blue
-    bus->i2c_smbus_write_byte_data(dev, CORSAIR_PRO_REG_COMMAND, 0xFF);
-    bus->i2c_smbus_write_byte_data(dev, CORSAIR_PRO_REG_COMMAND, red2);         // Custom color 2 red
-    bus->i2c_smbus_write_byte_data(dev, CORSAIR_PRO_REG_COMMAND, grn2);         // Custom color 2 green
-    bus->i2c_smbus_write_byte_data(dev, CORSAIR_PRO_REG_COMMAND, blu2);         // Custom color 2 blue
-    bus->i2c_smbus_write_byte_data(dev, CORSAIR_PRO_REG_COMMAND, 0xFF);
-    bus->i2c_smbus_write_byte_data(dev, CORSAIR_PRO_REG_COMMAND, 0x00);
-    bus->i2c_smbus_write_byte_data(dev, CORSAIR_PRO_REG_COMMAND, 0x00);
-    bus->i2c_smbus_write_byte_data(dev, CORSAIR_PRO_REG_COMMAND, 0x00);
-    bus->i2c_smbus_write_byte_data(dev, CORSAIR_PRO_REG_COMMAND, 0x00);
-    bus->i2c_smbus_write_byte_data(dev, CORSAIR_PRO_REG_COMMAND, 0x00);
-    bus->i2c_smbus_write_byte_data(dev, CORSAIR_PRO_REG_COMMAND, 0x00);
-    bus->i2c_smbus_write_byte_data(dev, CORSAIR_PRO_REG_COMMAND, 0x00);
-    bus->i2c_smbus_write_byte_data(dev, CORSAIR_PRO_REG_COMMAND, 0x00);
-
-    bus->i2c_smbus_write_byte_data(dev, 0x82, 0x01);
-    WaitReady();
-}
-
-bool CorsairVengeanceProController::WaitReady()
-{
-    int i = 0;
-    while (bus->i2c_smbus_read_byte_data(dev, 0x41) != 0x00)
-    {
-        i++;
-        Sleep(1);
-    }
-
-    return false;
-}

Controllers/CorsairVengeanceProController/CorsairVengeanceProController.h

@@ -1,100 +0,0 @@
-/*-----------------------------------------*\
-|  CorsairVengeanceProController.h          |
-|                                           |
-|  Definitions and types for Corsair        |
-|  Vengeance Pro RGB RAM lighting controller|
-|                                           |
-|  Adam Honse (CalcProgrammer1) 6/30/2019   |
-\*-----------------------------------------*/
-
-#include <string>
-#include "i2c_smbus.h"
-
-#pragma once
-
-typedef unsigned char	corsair_dev_id;
-
-#define CORSAIR_PRO_LED_COUNT   ( 10 )
-
-enum
-{
-    CORSAIR_PRO_REG_COMMAND             = 0x20,     /* Command write register               */
-};
-
-enum
-{
-    CORSAIR_PRO_MODE_COLOR_SHIFT        = 0x00,     /* Color Shift mode                     */
-    CORSAIR_PRO_MODE_COLOR_PULSE        = 0x01,     /* Color Pulse mode                     */
-    CORSAIR_PRO_MODE_RAINBOW_WAVE       = 0x03,     /* Rainbow Wave mode                    */
-    CORSAIR_PRO_MODE_COLOR_WAVE         = 0x04,     /* Color Wave mode                      */
-    CORSAIR_PRO_MODE_VISOR              = 0x05,     /* Visor mode                           */
-    CORSAIR_PRO_MODE_RAIN               = 0x06,     /* Rain mode                            */
-    CORSAIR_PRO_MODE_MARQUEE            = 0x07,     /* Marquee mode                         */
-    CORSAIR_PRO_MODE_RAINBOW            = 0x08,     /* Rainbow mode                         */
-    CORSAIR_PRO_MODE_SEQUENTIAL         = 0x09,     /* Sequential mode                      */
-    CORSAIR_PRO_MODE_STATIC             = 0x10,     /* Static mode                          */
-
-    CORSAIR_PRO_NUMBER_MODES            = 10,       /* Number of Corsair Pro modes          */
-};
-
-enum
-{
-    CORSAIR_PRO_SPEED_SLOW              = 0x00,     /* Slow speed                           */
-    CORSAIR_PRO_SPEED_MEDIUM            = 0x01,     /* Medium speed                         */
-    CORSAIR_PRO_SPEED_FAST              = 0x02,     /* Fast speed                           */
-};
-
-enum
-{
-    CORSAIR_PRO_EFFECT_RANDOM_COLORS    = 0x00,     /* Random colors                        */
-    CORSAIR_PRO_EFFECT_CUSTOM_COLORS    = 0x01,     /* Custom colors                        */
-};
-
-enum
-{
-    CORSAIR_PRO_DIRECTION_UP            = 0x00,     /* Up direction                         */
-    CORSAIR_PRO_DIRECTION_DOWN          = 0x01,     /* Down direction                       */
-    CORSAIR_PRO_DIRECTION_LEFT          = 0x02,     /* Left direction                       */
-    CORSAIR_PRO_DIRECTION_RIGHT         = 0x03,     /* Right direction                      */
-    CORSAIR_PRO_DIRECTION_VERTICAL      = 0x01,     /* Vertical direction                   */
-    CORSAIR_PRO_DIRECTION_HORIZONTAL    = 0x03,     /* Horizontal direction                 */
-};
-
-class CorsairVengeanceProController
-{
-public:
-    CorsairVengeanceProController(i2c_smbus_interface* bus, corsair_dev_id dev);
-    ~CorsairVengeanceProController();
-
-    std::string     GetDeviceName();
-    std::string     GetDeviceLocation();
-    unsigned int    GetLEDCount();
-    unsigned char   GetEffect();
-    void            SetEffect(unsigned char mode,
-                              unsigned char speed,
-                              unsigned char direction,
-                              bool          random,
-                              unsigned char red1,
-                              unsigned char grn1,
-                              unsigned char blu1,
-                              unsigned char red2,
-                              unsigned char grn2,
-                              unsigned char blu2
-                             );
-
-    void            SetAllColors(unsigned char red, unsigned char green, unsigned char blue);
-    void            SetLEDColor(unsigned int led, unsigned char red, unsigned char green, unsigned char blue);
-    void            ApplyColors();
-    bool            WaitReady();
-
-private:
-    char                    device_name[32];
-    unsigned int            led_count;
-    unsigned char           effect_mode;
-    unsigned char           led_red[CORSAIR_PRO_LED_COUNT];
-    unsigned char           led_green[CORSAIR_PRO_LED_COUNT];
-    unsigned char           led_blue[CORSAIR_PRO_LED_COUNT];
-
-    i2c_smbus_interface*    bus;
-    corsair_dev_id          dev;
-};

Controllers/CorsairVengeanceProController/CorsairVengeanceProControllerDetect.cpp

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

Controllers/CrucialController/CrucialController.cpp

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

Controllers/CrucialController/CrucialController.h

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

Controllers/CrucialController/CrucialControllerDetect.cpp

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

Controllers/Hue2Controller/Hue2Controller.cpp

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

Controllers/Hue2Controller/Hue2Controller.h

@@ -1,108 +0,0 @@
-/*---------------------------------------------------------*\
-|  Definitions for NZXT Hue 2                               |
-|                                                           |
-|  Adam Honse ([email protected]), 12/29/2016       |
-\*---------------------------------------------------------*/
-
-#include "RGBController.h"
-#include <vector>
-#include <libusb-1.0/libusb.h>
-
-#pragma once
-
-enum
-{
-    HUE_2_CHANNEL_ALL       = 0x00,     /* All channels                 */
-    HUE_2_CHANNEL_1         = 0x01,     /* Channel 1                    */
-    HUE_2_CHANNEL_2         = 0x02,     /* Channel 2                    */
-    HUE_2_CHANNEL_3         = 0x03,     /* Channel 3                    */
-    HUE_2_CHANNEL_4         = 0x04,     /* Channel 4                    */
-    HUE_2_NUM_CHANNELS      = 0x04      /* Number of channels           */
-};
-
-enum
-{
-    HUE_2_CHANNEL_1_IDX     = 0x00,     /* Channel 1 array index        */
-    HUE_2_CHANNEL_2_IDX     = 0x01,     /* Channel 2 array index        */
-    HUE_2_CHANNEL_3_IDX     = 0x01,     /* Channel 3 array index        */
-    HUE_2_CHANNEL_4_IDX     = 0x01,     /* Channel 4 array index        */
-};
-
-enum
-{
-    HUE_2_SPEED_SLOWEST         = 0x00,     /* Slowest speed                */
-    HUE_2_SPEED_SLOW            = 0x01,     /* Slow speed                   */
-    HUE_2_SPEED_NORMAL          = 0x02,     /* Normal speed                 */
-    HUE_2_SPEED_FAST            = 0x03,     /* Fast speed                   */
-    HUE_2_SPEED_FASTEST         = 0x04,     /* Fastest speed                */
-};
-
-enum
-{
-    HUE_2_MODE_FIXED            = 0x00,     /* Fixed colors mode            */
-    HUE_2_MODE_FADING           = 0x01,     /* Fading mode                  */
-    HUE_2_MODE_SPECTRUM         = 0x02,     /* Spectrum cycle mode          */
-    HUE_2_MODE_MARQUEE          = 0x03,     /* Marquee mode                 */
-    HUE_2_MODE_COVER_MARQUEE    = 0x04,     /* Cover marquee mode           */
-    HUE_2_MODE_ALTERNATING      = 0x05,     /* Alternating mode             */
-    HUE_2_MODE_PULSING          = 0x06,     /* Pulsing mode                 */
-    HUE_2_MODE_BREATHING        = 0x07,     /* Breathing mode               */
-    HUE_2_NUM_MODES                         /* Number of Hue 2 modes        */
-};
-
-class Hue2Controller
-{
-public:
-    Hue2Controller(libusb_device_handle* dev_handle);
-    ~Hue2Controller();
-
-    unsigned int    GetStripsOnChannel
-                        (
-                        unsigned int    channel
-                        );
-
-    void            SetChannelEffect
-                        (
-                        unsigned char   channel,
-                        unsigned char   mode,
-                        unsigned char   speed,
-                        bool            direction,
-                        RGBColor *      colors,
-                        unsigned int    num_colors
-                        );
-
-    void            SetChannelLEDs
-                        (
-                        unsigned char   channel,
-                        RGBColor *      colors,
-                        unsigned int    num_colors
-                        );
-    
-    unsigned int    channel_leds[HUE_2_NUM_CHANNELS];
-
-private:
-    libusb_device_handle*   dev;
-
-    void            SendApply
-                        (
-                        unsigned char   channel
-                        );
-
-    void            SendDirect
-                        (
-                        unsigned char   channel,
-                        unsigned char   group,
-                        unsigned char   color_count,
-                        unsigned char*  color_data
-                        );
-
-    void            SendEffect
-                        (
-                        unsigned char   channel,
-                        unsigned char   mode,
-                        unsigned char   speed,
-                        bool            direction,
-                        unsigned char   color_count,
-                        unsigned char*  color_data
-                        );
-};

Controllers/Hue2Controller/Hue2ControllerDetect.cpp

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

Controllers/HuePlusController/HuePlusController.cpp

@@ -1,248 +0,0 @@
-/*---------------------------------------------------------*\
-|  Processing Code for NZXT Hue+                            |
-|                                                           |
-|  Adam Honse ([email protected]), 12/11/2016       |
-\*---------------------------------------------------------*/
-
-#include "HuePlusController.h"
-
-#include <fstream>
-#include <iostream>
-#include <string>
-#include <cstring>
-
-#ifdef WIN32
-#include <Windows.h>
-#else
-#include <unistd.h>
-
-static void Sleep(unsigned int milliseconds)
-{
-    usleep(1000 * milliseconds);
-}
-#endif
-
-HuePlusController::HuePlusController()
-{
-
-}
-
-HuePlusController::~HuePlusController()
-{
-}
-
-void HuePlusController::Initialize(char* port)
-{
-    strcpy(port_name, port);
-    
-    serialport = new serial_port(port_name, HUE_PLUS_BAUD);
-
-    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::GetLocation()
-{
-    return(port_name);
-}
-
-unsigned int HuePlusController::GetLEDsOnChannel(unsigned int channel)
-{
-    unsigned char serial_buf[] =
-    {
-        0x8D, 0x00, 0x00, 0x00, 0x00
-    };
-
-    unsigned int ret_val = 0;
-
-    /*-----------------------------------------------------*\
-    | Set channel in serial packet                          |
-    \*-----------------------------------------------------*/
-    serial_buf[0x01]   = channel;
-
-    serialport->serial_flush_rx();
-    serialport->serial_write((char *)serial_buf, 2);
-    serialport->serial_flush_tx();
-
-    Sleep(50);
-
-    int bytes_read = serialport->serial_read((char *)serial_buf, 5);
-
-    if(bytes_read == 5)
-    {
-        if(serial_buf[3] == 0x01)
-        {
-            ret_val = serial_buf[4] * 8;
-        }
-        else
-        {
-            ret_val += serial_buf[4] * 10;
-        }
-    }
-
-    return(ret_val);
-}
-
-void HuePlusController::SetChannelEffect
-    (
-    unsigned char   channel,
-    unsigned char   mode,
-    unsigned char   speed,
-    bool            direction,
-    RGBColor *      colors,
-    unsigned int    num_colors
-    )
-{
-    unsigned char color_data[120];
-
-    /*-----------------------------------------------------*\
-    | If mode requires no colors, send packet               |
-    \*-----------------------------------------------------*/
-    if(num_colors == 0)
-    {
-        /*-----------------------------------------------------*\
-        | Send mode without color data                          |
-        \*-----------------------------------------------------*/
-        SendPacket(channel, mode, direction, 0, speed, 0, NULL);
-    }
-    /*-----------------------------------------------------*\
-    | If mode requires indexed colors, send color index     |
-    | packets for each mode color                           |
-    \*-----------------------------------------------------*/
-    else if(num_colors <= 8)
-    {
-        for(std::size_t color_idx = 0; color_idx < num_colors; color_idx++)
-        {
-            /*-----------------------------------------------------*\
-            | Fill in color data (40 entries per color)             |
-            \*-----------------------------------------------------*/
-            for (std::size_t idx = 0; idx < 40; idx++)
-            {
-                int pixel_idx = idx * 3;
-                RGBColor color = colors[color_idx];
-                color_data[pixel_idx + 0x00] = RGBGetGValue(color);
-                color_data[pixel_idx + 0x01] = RGBGetRValue(color);
-                color_data[pixel_idx + 0x02] = RGBGetBValue(color);
-            }
-
-            /*-----------------------------------------------------*\
-            | Send mode and color data                              |
-            \*-----------------------------------------------------*/
-            SendPacket(channel, mode, direction, color_idx, speed, 40, &color_data[0]);
-        }
-    }
-    /*-----------------------------------------------------*\
-    | If mode requires per-LED colors, fill colors array    |
-    \*-----------------------------------------------------*/
-    else
-    {
-        /*-----------------------------------------------------*\
-        | Fill in color data (up to 40 colors)                  |
-        \*-----------------------------------------------------*/
-        for (std::size_t idx = 0; idx < num_colors; idx++)
-        {
-            int pixel_idx = idx * 3;
-            RGBColor color = colors[idx];
-            color_data[pixel_idx + 0x00] = RGBGetGValue(color);
-            color_data[pixel_idx + 0x01] = RGBGetRValue(color);
-            color_data[pixel_idx + 0x02] = RGBGetBValue(color);
-        }
-
-        /*-----------------------------------------------------*\
-        | Send mode and color data                              |
-        \*-----------------------------------------------------*/
-        SendPacket(channel, mode, direction, 0, speed, num_colors, &color_data[0]);
-    }
-}
-
-void HuePlusController::SetChannelLEDs
-    (
-    unsigned char   channel,
-    RGBColor *      colors,
-    unsigned int    num_colors
-    )
-{
-    unsigned char color_data[120];
-
-    /*-----------------------------------------------------*\
-    | Fill in color data (up to 40 colors)                  |
-    \*-----------------------------------------------------*/
-    for (std::size_t idx = 0; idx < num_colors; idx++)
-    {
-        int pixel_idx = idx * 3;
-        RGBColor color = colors[idx];
-        color_data[pixel_idx + 0x00] = RGBGetGValue(color);
-        color_data[pixel_idx + 0x01] = RGBGetRValue(color);
-        color_data[pixel_idx + 0x02] = RGBGetBValue(color);
-    }
-
-    /*-----------------------------------------------------*\
-    | Send color data                                       |
-    \*-----------------------------------------------------*/
-    SendPacket(channel, HUE_PLUS_MODE_FIXED, false, 0, 0, num_colors, &color_data[0]);
-}
-
-/*-------------------------------------------------------------------------------------------------*\
-| Private packet sending functions.                                                                 |
-\*-------------------------------------------------------------------------------------------------*/
-
-void HuePlusController::SendPacket
-    (
-    unsigned char   channel,
-    unsigned char   mode,
-    bool            direction,
-    unsigned char   color_idx,
-    unsigned char   speed,
-    unsigned char   color_count,
-    unsigned char*  color_data
-    )
-{
-    unsigned char serial_buf[125];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(serial_buf, 0x00, sizeof(serial_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up Direct packet                                  |
-    \*-----------------------------------------------------*/
-    serial_buf[0x00]    = 0x4B;
-
-    /*-----------------------------------------------------*\
-    | Set channel in serial packet                          |
-    \*-----------------------------------------------------*/
-    serial_buf[0x01]   = channel + 1;
-
-    /*-----------------------------------------------------*\
-    | Set mode in serial packet                             |
-    \*-----------------------------------------------------*/
-    serial_buf[0x02]   = mode;
-
-    /*-----------------------------------------------------*\
-    | Set options bitfield in serial packet                 |
-    \*-----------------------------------------------------*/
-    serial_buf[0x03]   = 0;
-    serial_buf[0x03]   |= direction ? ( 1 << 4 ) : 0;
-
-    /*-----------------------------------------------------*\
-    | Set color index and speed in serial packet            |
-    \*-----------------------------------------------------*/
-    serial_buf[0x04]   = ( color_idx << 5 ) | speed;
-
-    /*-----------------------------------------------------*\
-    | Copy in color data bytes                              |
-    \*-----------------------------------------------------*/
-    memcpy(&serial_buf[0x05], color_data, color_count * 3);
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    serialport->serial_write((char *)serial_buf, HUE_PLUS_PACKET_SIZE);
-    serialport->serial_flush_tx();
-
-    /*-----------------------------------------------------*\
-    | Delay to allow Hue+ device to ready for next packet   |
-    \*-----------------------------------------------------*/
-    Sleep(20);
-}

Controllers/HuePlusController/HuePlusController.h

@@ -1,112 +0,0 @@
-/*---------------------------------------------------------*\
-|  Definitions for NZXT Hue+                                |
-|                                                           |
-|  Adam Honse ([email protected]), 12/11/2016       |
-\*---------------------------------------------------------*/
-
-#ifndef LED_STRIP_H
-#define LED_STRIP_H
-
-#include "RGBController.h"
-#include "serial_port.h"
-#include <vector>
-
-
-#ifndef TRUE
-#define TRUE true
-#define FALSE false
-#endif
-
-#ifndef WIN32
-#define LPSTR           char *
-#define strtok_s        strtok_r
-#endif
-
-#define HUE_PLUS_BAUD           256000
-#define HUE_PLUS_PACKET_SIZE    125
-
-enum
-{
-    HUE_PLUS_CHANNEL_BOTH   = 0x00,     /* Both channels                */
-    HUE_PLUS_CHANNEL_1      = 0x01,     /* Channel 1                    */
-    HUE_PLUS_CHANNEL_2      = 0x02,     /* Channel 2                    */
-    HUE_PLUS_NUM_CHANNELS   = 0x02      /* Number of channels           */
-};
-
-enum
-{
-    HUE_PLUS_CHANNEL_1_IDX  = 0x00,     /* Channel 1 array index        */
-    HUE_PLUS_CHANNEL_2_IDX  = 0x01,     /* Channel 2 array index        */
-};
-
-enum
-{
-    HUE_PLUS_SPEED_SLOWEST      = 0x00, /* Slowest speed                */
-    HUE_PLUS_SPEED_SLOW         = 0x01, /* Slow speed                   */
-    HUE_PLUS_SPEED_NORMAL       = 0x02, /* Normal speed                 */
-    HUE_PLUS_SPEED_FAST         = 0x03, /* Fast speed                   */
-    HUE_PLUS_SPEED_FASTEST      = 0x04, /* Fastest speed                */
-};
-
-enum
-{
-    HUE_PLUS_MODE_FIXED         = 0x00, /* Fixed colors mode            */
-    HUE_PLUS_MODE_FADING        = 0x01, /* Fading mode                  */
-    HUE_PLUS_MODE_SPECTRUM      = 0x02, /* Spectrum cycle mode          */
-    HUE_PLUS_MODE_MARQUEE       = 0x03, /* Marquee mode                 */
-    HUE_PLUS_MODE_COVER_MARQUEE = 0x04, /* Cover marquee mode           */
-    HUE_PLUS_MODE_ALTERNATING   = 0x05, /* Alternating mode             */
-    HUE_PLUS_MODE_PULSING       = 0x06, /* Pulsing mode                 */
-    HUE_PLUS_MODE_BREATHING     = 0x07, /* Breathing mode               */
-    HUE_PLUS_MODE_ALERT         = 0x08, /* Alert mode                   */
-    HUE_PLUS_MODE_CANDLELIGHT   = 0x09, /* Candlelight mode             */
-    HUE_PLUS_MODE_WINGS         = 0x0C, /* Wings mode                   */
-    HUE_PLUS_MODE_WAVE          = 0x0D, /* Wave mode                    */
-};
-
-class HuePlusController
-{
-public:
-    HuePlusController();
-    ~HuePlusController();
-
-    void            Initialize(char* port);
-    char*           GetLocation();
-    unsigned int    GetLEDsOnChannel(unsigned int channel);
-
-    void            SetChannelEffect
-                        (
-                        unsigned char   channel,
-                        unsigned char   mode,
-                        unsigned char   speed,
-                        bool            direction,
-                        RGBColor *      colors,
-                        unsigned int    num_colors
-                        );
-
-    void            SetChannelLEDs
-                        (
-                        unsigned char   channel,
-                        RGBColor *      colors,
-                        unsigned int    num_colors
-                        );
-
-    unsigned int    channel_leds[HUE_PLUS_NUM_CHANNELS];
-
-private:
-    char            port_name[128];
-    serial_port     *serialport;
-
-    void            SendPacket
-                        (
-                        unsigned char   channel,
-                        unsigned char   mode,
-                        bool            direction,
-                        unsigned char   color_idx,
-                        unsigned char   speed,
-                        unsigned char   color_count,
-                        unsigned char*  color_data
-                        );
-};
-
-#endif

Controllers/HuePlusController/HuePlusControllerDetect.cpp

@@ -1,32 +0,0 @@
-#include "HuePlusController.h"
-#include "RGBController.h"
-#include "RGBController_HuePlus.h"
-#include "find_usb_serial_port.h"
-#include <vector>
-
-#define NZXT_HUE_PLUS_VID 0x04D8
-#define NZXT_HUE_PLUS_PID 0x00DF
-
-/******************************************************************************************\
-*                                                                                          *
-*   DetectHuePlusControllers                                                               *
-*                                                                                          *
-*       Detect devices supported by the HuePlus driver                                     *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectHuePlusControllers(std::vector<RGBController*> &rgb_controllers)
-{
-    HuePlusController* new_hueplus;
-    RGBController_HuePlus* new_controller;
-
-    std::string portname = find_usb_serial_port(NZXT_HUE_PLUS_VID, NZXT_HUE_PLUS_PID);
-    if( portname != "" )
-    {
-        new_hueplus = new HuePlusController();
-        new_hueplus->Initialize((char *)portname.c_str());
-
-        new_controller = new RGBController_HuePlus(new_hueplus);
-        rgb_controllers.push_back(new_controller);
-    }
-}   /* DetectHuePlusControllers() */

Controllers/HyperXDRAMController/HyperXDRAMController.cpp

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

Controllers/HyperXDRAMController/HyperXDRAMController.h

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

Controllers/HyperXDRAMController/HyperXDRAMControllerDetect.cpp

@@ -1,104 +0,0 @@
-#include "HyperXDRAMController.h"
-#include "RGBController.h"
-#include "RGBController_HyperXDRAM.h"
-#include "i2c_smbus.h"
-#include <vector>
-#include <stdio.h>
-#include <stdlib.h>
-
-#ifdef WIN32
-#include <Windows.h>
-#else
-#include <unistd.h>
-
-static void Sleep(unsigned int milliseconds)
-{
-    usleep(1000 * milliseconds);
-}
-#endif
-
-/******************************************************************************************\
-*                                                                                          *
-*   TestForHyperXDRAMController                                                            *
-*                                                                                          *
-*       Tests the given address to see if a HyperX controller exists there.                *
-*                                                                                          *
-\******************************************************************************************/
-
-bool TestForHyperXDRAMController(i2c_smbus_interface* bus, unsigned char address)
-{
-    bool pass = false;
-
-    int res = bus->i2c_smbus_write_quick(address, I2C_SMBUS_WRITE);
-
-    if (res >= 0)
-    {
-        pass = true;
-
-        for (int i = 0xA0; i < 0xB0; i++)
-        {
-            res = bus->i2c_smbus_read_byte_data(address, i);
-
-            if (res != i)
-            {
-                pass = false;
-            }
-        }
-    }
-
-    return(pass);
-
-}   /* TestForHyperXDRAMController() */
-
-
-/******************************************************************************************\
-*                                                                                          *
-*   DetectHyperXDRAMControllers                                                            *
-*                                                                                          *
-*       Detect HyperX DRAM controllers on the enumerated I2C busses.                       *
-*                                                                                          *
-*           bus - pointer to i2c_smbus_interface where Aura device is connected            *
-*           dev - I2C address of Aura device                                               *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectHyperXDRAMControllers(std::vector<i2c_smbus_interface*> &busses, std::vector<RGBController*> &rgb_controllers)
-{
-    HyperXDRAMController* new_hyperx;
-    RGBController_HyperXDRAM* new_controller;
-
-    for (unsigned int bus = 0; bus < busses.size(); bus++)
-    {
-        unsigned char slots_valid = 0x00;
-
-        // Check for HyperX controller at 0x27
-        if (TestForHyperXDRAMController(busses[bus], 0x27))
-        {
-            busses[bus]->i2c_smbus_write_byte_data(0x37, 0x00, 0xFF);
-
-            Sleep(1);
-            
-            for(int slot_addr = 0x50; slot_addr <= 0x57; slot_addr++)
-            {
-                // Test for HyperX SPD at slot_addr
-                // This test was copied from NGENUITY software
-                // Tests SPD addresses in order: 0x40, 0x41
-                if((busses[bus]->i2c_smbus_read_byte_data(slot_addr, 0x40) == 0x01)
-                 &&(busses[bus]->i2c_smbus_read_byte_data(slot_addr, 0x41) == 0x98))
-                {
-                    slots_valid |= (1 << (slot_addr - 0x50));
-                }
-
-                Sleep(1);
-            }
-
-            if(slots_valid != 0)
-            {
-                new_hyperx = new HyperXDRAMController(busses[bus], 0x27, slots_valid);
-                new_controller = new RGBController_HyperXDRAM(new_hyperx);
-                rgb_controllers.push_back(new_controller);
-            }
-        }
-    }
-
-}   /* DetectHyperXDRAMControllers() */

Controllers/HyperXKeyboardController/HyperXKeyboardController.cpp

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

Controllers/HyperXKeyboardController/HyperXKeyboardController.h

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

Controllers/HyperXKeyboardController/HyperXKeyboardControllerDetect.cpp

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

Controllers/LEDStripController/LEDStripController.cpp

@@ -1,147 +0,0 @@
-/*---------------------------------------------------------*\
-|  Processing Code for Generic LED Strip Interface          |
-|                                                           |
-|  Adam Honse ([email protected]), 12/11/2016       |
-\*---------------------------------------------------------*/
-
-#include "LEDStripController.h"
-
-#include <fstream>
-#include <iostream>
-#include <string>
-
-LEDStripController::LEDStripController()
-{
-
-}
-
-
-LEDStripController::~LEDStripController()
-{
-}
-
-void LEDStripController::Initialize(char* ledstring)
-{
-    LPSTR   numleds = NULL;
-    LPSTR   source = NULL;
-    LPSTR   udpport_baud = NULL;
-    LPSTR   next = NULL;
-    
-    //Assume serial device unless a different protocol is specified
-    bool    serial = TRUE;
-    
-    source = strtok_s(ledstring, ",", &next);
-
-    //Check if we are setting up a Keyboard Visualizer UDP protocol device
-    if (strncmp(source, "udp:", 4) == 0)
-    {
-        source = source + 4;
-        serial = FALSE;
-    }
-    
-    //Check for either the UDP port or the serial baud rate
-    if (strlen(next))
-    {
-        udpport_baud = strtok_s(next, ",", &next);
-    }
-
-    //Check for the number of LEDs
-    if (strlen(next))
-    {
-        numleds = strtok_s(next, ",", &next);
-    }
-
-    if (serial)
-    {
-        if (udpport_baud == NULL)
-        {
-            //Initialize with default baud rate
-            InitializeSerial(source, 115200);
-        }
-        else
-        {
-            //Initialize with custom baud rate
-            InitializeSerial(source, atoi(udpport_baud));
-        }
-    }
-    else
-    {
-        if (udpport_baud == NULL)
-        {
-            //Do something
-        }
-        else
-        {
-            //Initialize UDP port
-            InitializeUDP(source, udpport_baud);
-        }
-    }
-
-    if (numleds != NULL && strlen(numleds))
-    {
-        num_leds = atoi(numleds);
-    }
-}
-
-void LEDStripController::InitializeSerial(char* portname, int baud)
-{
-    portname = strtok(portname, "\r");
-    strcpy(port_name, portname);
-    baud_rate = baud;
-    serialport = new serial_port(port_name, baud_rate);
-    udpport = NULL;
-}
-
-void LEDStripController::InitializeUDP(char * clientname, char * port)
-{
-    strcpy(client_name, clientname);
-    strcpy(port_name, port);
-
-    udpport = new net_port(client_name, port_name);
-    serialport = NULL;
-}
-
-char* LEDStripController::GetLEDString()
-{
-    return(led_string);
-}
-
-void LEDStripController::SetLEDs(std::vector<RGBColor> colors)
-{
-    unsigned char *serial_buf;
-
-    serial_buf = new unsigned char[(num_leds * 3) + 3];
-
-    serial_buf[0] = 0xAA;
-
-    for (int idx = 0; idx < (num_leds * 3); idx += 3)
-    {
-        int pixel_idx = idx / 3;
-        RGBColor color = colors[pixel_idx];
-        serial_buf[idx + 1] = RGBGetRValue(color);
-        serial_buf[idx + 2] = RGBGetGValue(color);
-        serial_buf[idx + 3] = RGBGetBValue(color);
-    }
-
-    unsigned short sum = 0;
-
-    for (int i = 0; i < (num_leds * 3) + 1; i++)
-    {
-        sum += serial_buf[i];
-    }
-
-    serial_buf[(num_leds * 3) + 1] = sum >> 8;
-    serial_buf[(num_leds * 3) + 2] = sum & 0x00FF;
-
-    if (serialport != NULL)
-    {
-        serialport->serial_write((char *)serial_buf, (num_leds * 3) + 3);
-        serialport->serial_flush_tx();
-    }
-    else if (udpport != NULL)
-    {
-        udpport->udp_write((char *)serial_buf, (num_leds * 3) + 3);
-    }
-
-    delete[] serial_buf;
-}

Controllers/LEDStripController/LEDStripController.h

@@ -1,50 +0,0 @@
-/*---------------------------------------------------------*\
-|  Definitions for Generic LED Strip Interface              |
-|                                                           |
-|  Adam Honse ([email protected]), 12/11/2016       |
-\*---------------------------------------------------------*/
-
-#ifndef LED_STRIP_H
-#define LED_STRIP_H
-
-#include "RGBController.h"
-#include "serial_port.h"
-#include "net_port.h"
-#include <vector>
-
-
-#ifndef TRUE
-#define TRUE true
-#define FALSE false
-#endif
-
-#ifndef WIN32
-#define LPSTR           char *
-#define strtok_s        strtok_r
-#endif
-
-class LEDStripController
-{
-public:
-    LEDStripController();
-    ~LEDStripController();
-
-    void Initialize(char* ledstring);
-    void InitializeSerial(char* portname, int baud);
-    void InitializeUDP(char* clientname, char* port);
-    char* GetLEDString();
-    void SetLEDs(std::vector<RGBColor> colors);
-
-    int num_leds;
-
-private:
-    int baud_rate;
-
-    char led_string[1024];
-    char port_name[128];
-    char client_name[1024];
-    serial_port *serialport;
-    net_port *udpport;
-};
-
-#endif

Controllers/LEDStripController/LEDStripControllerDetect.cpp

@@ -1,88 +0,0 @@
-#include "LEDStripController.h"
-#include "RGBController.h"
-#include "RGBController_LEDStrip.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
-
-/******************************************************************************************\
-*                                                                                          *
-*   DetectLEDStripControllers                                                              *
-*                                                                                          *
-*       Detect devices supported by the LEDStrip driver                                    *
-*                                                                                          *                                                                                          *
-\******************************************************************************************/
-
-void DetectLEDStripControllers(std::vector<RGBController*> &rgb_controllers)
-{
-    LEDStripController* new_ledstrip;
-    RGBController_LEDStrip* new_controller;
-
-    //Get file path in executable directory
-    std::ifstream infile;
-    char filename[2048];
-    char arg1[64];
-
-#ifdef WIN32
-    GetModuleFileName(NULL, filename, 2048);
-    strcpy(filename, std::string(filename).substr(0, std::string(filename).find_last_of("\\/")).c_str());
-    strcat(filename, "\\ledstrip.txt");
-#else
-    snprintf(arg1, 64, "/proc/%d/exe", getpid());
-    readlink(arg1, filename, 1024);
-    strcpy(filename, std::string(filename).substr(0, std::string(filename).find_last_of("\\/")).c_str());
-    strcat(filename, "/ledstrip.txt");
-#endif
-
-    //Open settings file
-    infile.open(filename);
-
-    if (infile.good())
-    {
-        for (std::string line; std::getline(infile, line); )
-        {
-            if (line == "")
-            {
-                continue;
-            }
-            if ((line[0] != ';') && (line[0] != '#') && (line[0] != '/'))
-            {
-                char * argument;
-                char * value;
-
-                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, "ledstrip") == 0)
-                    {
-                        new_ledstrip = new LEDStripController();
-                        new_ledstrip->Initialize(value);
-
-                        new_controller = new RGBController_LEDStrip(new_ledstrip);
-                        rgb_controllers.push_back(new_controller);
-                    }
-                }
-            }
-        }
-    }
-
-
-}   /* DetectLEDStripControllers() */

Controllers/MSI3ZoneController/MSI3ZoneController.cpp

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

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

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

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

Controllers/MSIRGBController/MSIRGBController.h

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

Controllers/MSIRGBController/MSIRGBControllerDetect.cpp

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

Controllers/PatriotViperController/PatriotViperController.cpp

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

Controllers/PatriotViperController/PatriotViperController.h

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

Controllers/PatriotViperController/PatriotViperControllerDetect.cpp

@@ -1,81 +0,0 @@
-#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

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

Controllers/PolychromeController/PolychromeController.h

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

Controllers/PolychromeController/PolychromeControllerDetect.cpp

@@ -1,69 +0,0 @@
-#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

@@ -1,241 +0,0 @@
-/*-----------------------------------------*\
-|  PoseidonZRGBController.cpp               |
-|                                           |
-|  Driver for Thermaltake Poseidon Z RGB    |
-|  Keyboard lighting controller             |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 12/25/2019  |
-\*-----------------------------------------*/
-
-#include "PoseidonZRGBController.h"
-
-#include <cstring>
-
-#ifdef WIN32
-#include <Windows.h>
-#else
-#include <unistd.h>
-
-static void Sleep(unsigned int milliseconds)
-{
-    usleep(1000 * milliseconds);
-}
-#endif
-
-static unsigned int keys[] = {0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13, 0x15,
-                              0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1D, 0x1E, 0x1F, 0x20, 0x21, 0x22, 0x23,
-                              0x24, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F, 0x30, 0x31,
-                              0x32, 0x33, 0x34, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3E, 0x3F, 0x40,
-                              0x41, 0x42, 0x43, 0x44, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4E, 0x4F,
-                              0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x5B, 0x5C,
-                              0x5D, 0x5E, 0x5F, 0x60, 0x61, 0x62, 0x63, 0x64, 0x66, 0x67, 0x68, 0x69, 0x6A,
-                              0x6C, 0x6D, 0x6F, 0x70, 0x72, 0x73, 0x75, 0x76, 0x77, 0x78, 0x7C, 0x80, 0x81 };
-
-PoseidonZRGBController::PoseidonZRGBController(hid_device* dev_handle)
-{
-    dev = dev_handle;
-}
-
-PoseidonZRGBController::~PoseidonZRGBController()
-{
-
-}
-
-void PoseidonZRGBController::SetMode(unsigned char mode, unsigned char direction, unsigned char speed)
-{
-    active_mode = mode;
-    active_direction = direction;
-    active_speed = speed;
-
-    SendControl
-        (
-        POSEIDONZ_PROFILE_P1,
-        POSEIDONZ_PROFILE_P1,
-        active_direction,
-        active_mode,
-        POSEIDONZ_BRIGHTNESS_MAX,
-        active_speed
-        );
-
-    Sleep(200);
-}
-
-void PoseidonZRGBController::SetLEDsDirect(std::vector<RGBColor> colors)
-{
-    unsigned char red_grn_buf[264];
-    unsigned char blu_buf[264];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffers                                      |
-    \*-----------------------------------------------------*/
-    memset(red_grn_buf, 0x00, sizeof(red_grn_buf));
-    memset(blu_buf, 0x00, sizeof(blu_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up Direct packets                                 |
-    \*-----------------------------------------------------*/
-    red_grn_buf[0] = 0x07;
-    red_grn_buf[1] = POSEIDONZ_PACKET_ID_SET_DIRECT;
-    red_grn_buf[2] = POSEIDONZ_PROFILE_P1;
-    red_grn_buf[3] = POSEIDONZ_DIRECT_RED_GREEN;
-    red_grn_buf[4] = 0x00;
-    red_grn_buf[5] = 0x00;
-    red_grn_buf[6] = 0x00;
-    red_grn_buf[7] = 0x00;
-
-    blu_buf[0] = 0x07;
-    blu_buf[1] = POSEIDONZ_PACKET_ID_SET_DIRECT;
-    blu_buf[2] = POSEIDONZ_PROFILE_P1;
-    blu_buf[3] = POSEIDONZ_DIRECT_BLUE;
-    blu_buf[4] = 0x00;
-    blu_buf[5] = 0x00;
-    blu_buf[6] = 0x00;
-    blu_buf[7] = 0x00;
-
-    /*-----------------------------------------------------*\
-    | Fill in color data                                    |
-    \*-----------------------------------------------------*/
-    for(std::size_t i = 0; i < 104; i++)
-    {
-        red_grn_buf[keys[i]      ] = RGBGetRValue(colors[i]);
-        red_grn_buf[keys[i] + 128] = RGBGetGValue(colors[i]);
-        blu_buf[    keys[i]      ] = RGBGetBValue(colors[i]);
-    }
-
-    /*-----------------------------------------------------*\
-    | Send packets                                          |
-    \*-----------------------------------------------------*/
-    hid_send_feature_report(dev, red_grn_buf, 264);
-
-    Sleep(5);
-     
-    hid_send_feature_report(dev, blu_buf, 264);
-}
-
-void PoseidonZRGBController::SetLEDs(std::vector<RGBColor> colors)
-{
-    unsigned char red_color_data[104];
-    unsigned char grn_color_data[104];
-    unsigned char blu_color_data[104];
-
-    for(std::size_t i = 0; i < 104; i++)
-    {
-        red_color_data[i] = RGBGetRValue(colors[i]);
-        grn_color_data[i] = RGBGetGValue(colors[i]);
-        blu_color_data[i] = RGBGetBValue(colors[i]);
-    }
-
-    SendColor
-        (
-        POSEIDONZ_PROFILE_P1,
-        POSEIDONZ_COLOR_RED,
-        red_color_data
-        );
-
-    Sleep(10);
-
-    SendColor
-        (
-        POSEIDONZ_PROFILE_P1,
-        POSEIDONZ_COLOR_GREEN,
-        grn_color_data
-        );
-
-    Sleep(10);
-
-    SendColor
-        (
-        POSEIDONZ_PROFILE_P1,
-        POSEIDONZ_COLOR_BLUE,
-        blu_color_data
-        );
-
-    Sleep(10);
-
-    SendControl
-        (
-        POSEIDONZ_PROFILE_P1,
-        POSEIDONZ_PROFILE_P1,
-        active_direction,
-        active_mode,
-        POSEIDONZ_BRIGHTNESS_MAX,
-        active_speed
-        );
-}
-
-/*-------------------------------------------------------------------------------------------------*\
-| Private packet sending functions.                                                                 |
-\*-------------------------------------------------------------------------------------------------*/
-
-void PoseidonZRGBController::SendColor
-    (
-    unsigned char   profile_to_edit,
-    unsigned char   color_channel,
-    unsigned char*  color_data
-    )
-{
-    unsigned char buf[264];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(buf, 0x00, sizeof(buf));
-
-    /*-----------------------------------------------------*\
-    | Set up Color packet                                   |
-    \*-----------------------------------------------------*/
-    buf[0x00]   = 0x07;
-    buf[0x01]   = POSEIDONZ_PACKET_ID_SET_COLOR;
-    buf[0x02]   = profile_to_edit;
-    buf[0x03]   = color_channel;
-
-    /*-----------------------------------------------------*\
-    | Fill in color data                                    |
-    \*-----------------------------------------------------*/
-    for(int i = 0; i < 104; i++)
-    {
-        buf[keys[i]] = color_data[i];
-    }
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_send_feature_report(dev, buf, 264);
-}
-
-void PoseidonZRGBController::SendControl
-    (
-    unsigned char   profile_to_activate,
-    unsigned char   profile_to_edit,
-    unsigned char   direction,
-    unsigned char   mode,
-    unsigned char   brightness,
-    unsigned char   speed
-    )
-{
-    unsigned char buf[264];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(buf, 0x00, sizeof(buf));
-
-    /*-----------------------------------------------------*\
-    | Set up Effect packet                                  |
-    \*-----------------------------------------------------*/
-    buf[0x00]   = 0x07;
-    buf[0x01]   = POSEIDONZ_PACKET_ID_SET_EFFECT;
-    buf[0x02]   = profile_to_activate;
-    buf[0x08]   = profile_to_edit;
-    buf[0x0A]   = direction;
-    buf[0x0C]   = mode;
-    buf[0x0D]   = brightness;
-    buf[0x10]   = 0x08;
-    buf[0x12]   = speed;
-    buf[0x13]   = 0x50;
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_send_feature_report(dev, buf, 264);
-}

Controllers/PoseidonZRGBController/PoseidonZRGBController.h

@@ -1,106 +0,0 @@
-/*-----------------------------------------*\
-|  PoseidonZRGBController.h                 |
-|                                           |
-|  Definitions and types for Thermaltake    |
-|  Poseidon Z RGB Keyboard lighting         |
-|  controller                               |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 12/25/2019  |
-\*-----------------------------------------*/
-
-#include "RGBController.h"
-
-#include <string>
-#include <hidapi/hidapi.h>
-
-#pragma once
-
-#define POSEIDONZ_START       0x07
-#define POSEIDONZ_PROFILE     0x01
-#define POSEIDONZ_LED_CMD     0x0E
-#define POSEIDONZ_RED_GRN_CH  0x01
-#define POSEIDONZ_BLU_CH      0x02
-
-enum
-{
-    POSEIDONZ_PACKET_ID_SET_EFFECT      = 0x02,     /* Set profile effect packet            */
-    POSEIDONZ_PACKET_ID_SET_COLOR       = 0x09,     /* Set profile color packet             */
-    POSEIDONZ_PACKET_ID_SET_DIRECT      = 0x0E,     /* Set direct color packet              */
-};
-
-enum
-{
-    POSEIDONZ_MODE_STATIC       = 0x00,
-    POSEIDONZ_MODE_REACTIVE     = 0x01,
-    POSEIDONZ_MODE_ARROW_FLOW   = 0x02,
-    POSEIDONZ_MODE_WAVE         = 0x03,
-    POSEIDONZ_MODE_RIPPLE       = 0x04
-};
-
-enum
-{
-    POSEIDONZ_PROFILE_P1        = 0x01,
-    POSEIDONZ_PROFILE_P2        = 0x02,
-    POSEIDONZ_PROFILE_P3        = 0x03,
-    POSEIDONZ_PROFILE_P4        = 0x04,
-    POSEIDONZ_PROFILE_P5        = 0x05
-};
-
-enum
-{
-    POSEIDONZ_BRIGHTNESS_MIN    = 0x00,
-    POSEIDONZ_BRIGHTNESS_MAX    = 0x04
-};
-
-enum
-{
-    POSEIDONZ_COLOR_RED         = 0x01,
-    POSEIDONZ_COLOR_GREEN       = 0x02,
-    POSEIDONZ_COLOR_BLUE        = 0x03
-};
-
-enum
-{
-    POSEIDONZ_DIRECT_RED_GREEN  = 0x01,
-    POSEIDONZ_DIRECT_BLUE       = 0x02
-};
-
-enum
-{
-    POSEIDONZ_SPEED_SLOW        = 0x10,
-    POSEIDONZ_SPEED_FAST        = 0x05
-};
-
-class PoseidonZRGBController
-{
-public:
-    PoseidonZRGBController(hid_device* dev_handle);
-    ~PoseidonZRGBController();
-
-    void SetMode(unsigned char mode, unsigned char direction, unsigned char speed);
-    void SetLEDsDirect(std::vector<RGBColor> colors);
-    void SetLEDs(std::vector<RGBColor> colors);
-    
-private:
-    hid_device*             dev;
-    unsigned char           active_mode;
-    unsigned char           active_direction;
-    unsigned char           active_speed;
-
-    void SendControl
-        (
-        unsigned char   profile_to_activate,
-        unsigned char   profile_to_edit,
-        unsigned char   direction,
-        unsigned char   mode,
-        unsigned char   brightness,
-        unsigned char   speed
-        );
-    
-    void SendColor
-        (
-        unsigned char   profile_to_edit,
-        unsigned char   color_channel,
-        unsigned char*  color_data
-        );
-};

Controllers/PoseidonZRGBController/PoseidonZRGBControllerDetect.cpp

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

Controllers/RGBFusion2USBController/RGBFusion2USBController.cpp

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

Controllers/RGBFusion2USBController/RGBFusion2USBController.h

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

Controllers/RGBFusion2USBController/RGBFusion2USBControllerDetect.cpp

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

Controllers/RGBFusionController/RGBFusionController.cpp

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

Controllers/RGBFusionController/RGBFusionController.h

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

Controllers/RGBFusionController/RGBFusionControllerDetect.cpp

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

Controllers/RGBFusionGPUController/RGBFusionGPUController.cpp

@@ -1,47 +0,0 @@
-/*-----------------------------------------*\
-|  RGBFusionGPUController.cpp               |
-|                                           |
-|  Driver for Gigabyte Aorus RGB Fusion GPU |
-|  lighting controller                      |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 2/20/2020   |
-\*-----------------------------------------*/
-
-#include "RGBFusionGPUController.h"
-
-RGBFusionGPUController::RGBFusionGPUController(i2c_smbus_interface* bus, rgb_fusion_dev_id dev)
-{
-    this->bus = bus;
-    this->dev = dev;
-}
-
-RGBFusionGPUController::~RGBFusionGPUController()
-{
-
-}
-
-std::string RGBFusionGPUController::GetDeviceLocation()
-{
-    std::string return_string(bus->device_name);
-    char addr[5];
-    snprintf(addr, 5, "0x%02X", dev);
-    return_string.append(", address ");
-    return_string.append(addr);
-    return(return_string);
-}
-
-void RGBFusionGPUController::SetColor(unsigned char red, unsigned char green, unsigned char blue)
-{
-    bus->i2c_smbus_write_byte(dev, RGB_FUSION_GPU_REG_COLOR);
-    bus->i2c_smbus_write_byte(dev, red);
-    bus->i2c_smbus_write_byte(dev, green);
-    bus->i2c_smbus_write_byte(dev, blue);
-}
-
-void RGBFusionGPUController::SetMode(unsigned char mode, unsigned char speed)
-{
-    bus->i2c_smbus_write_byte(dev, RGB_FUSION_GPU_REG_MODE);
-    bus->i2c_smbus_write_byte(dev, mode);
-    bus->i2c_smbus_write_byte(dev, speed);
-    bus->i2c_smbus_write_byte(dev, 0x63);
-}

Controllers/RGBFusionGPUController/RGBFusionGPUController.h

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

Controllers/RGBFusionGPUController/RGBFusionGPUControllerDetect.cpp

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

Controllers/RedragonController/RedragonControllerDetect.cpp

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

Controllers/RedragonController/RedragonK556Controller.cpp

@@ -1,159 +0,0 @@
-#include "RedragonK556Controller.h"
-
-#include <cstring>
-
-RedragonK556Controller::RedragonK556Controller(hid_device* dev_handle)
-{
-    dev = dev_handle;
-}
-
-void RedragonK556Controller::SetKeyboardColors
-    (
-    unsigned char *     color_data,
-    unsigned int        size
-    )
-{
-    unsigned int    packet_size = 0;
-    unsigned int    packet_offset = 0;
-
-    while(size > 0)
-    {
-        if(size >= REDRAGON_K556_MAX_PACKET_SIZE)
-        {
-            packet_size     = REDRAGON_K556_MAX_PACKET_SIZE;
-        }
-        else
-        {
-            packet_size     = size;
-        }
-        
-        SendKeyboardData
-            (
-            &color_data[packet_offset],
-            packet_size,
-            packet_offset
-            );
-
-        size           -= packet_size;
-        packet_offset  += packet_size;
-    }
-}
-
-/*-------------------------------------------------------------------------------------------------*\
-| Private packet sending functions.                                                                 |
-\*-------------------------------------------------------------------------------------------------*/
-
-void RedragonK556Controller::SendKeyboardBegin()
-{
-    char usb_buf[64];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up Keyboard Begin packet                          |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]           = 0x04;
-    usb_buf[0x01]           = 0x01;
-    usb_buf[0x02]           = 0x00;
-    usb_buf[0x03]           = 0x01;
-    
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_write(dev, (unsigned char *)usb_buf, 64);
-    hid_read(dev, (unsigned char *)usb_buf, 64);
-}
-
-void RedragonK556Controller::SendKeyboardData
-    (
-    unsigned char *     data,
-    unsigned char       data_size,
-    unsigned short      data_offset
-    )
-{
-    char usb_buf[64];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up Keyboard End packet                            |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]           = 0x04;
-    usb_buf[0x01]           = 0x11 + data_offset;
-    usb_buf[0x02]           = data_size;
-    usb_buf[0x03]           = ( data_size / 3 ) - 1;
-    usb_buf[0x04]           = data_size;
-    usb_buf[0x05]           = data_offset & 0x00FF;
-    usb_buf[0x06]           = data_offset >> 8;
-
-    /*-----------------------------------------------------*\
-    | Copy in data bytes                                    |
-    \*-----------------------------------------------------*/
-    memcpy(&usb_buf[0x08], data, data_size);
-    
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_write(dev, (unsigned char *)usb_buf, 64);
-    hid_read(dev, (unsigned char *)usb_buf, 64);
-}
-
-void RedragonK556Controller::SendKeyboardMode
-    (
-    unsigned char       mode
-    )
-{
-    char usb_buf[64];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up Keyboard End packet                            |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]           = 0x04;
-    usb_buf[0x01]           = 0x00;
-    usb_buf[0x02]           = 0x00;
-    usb_buf[0x03]           = 0x06;
-    usb_buf[0x04]           = 0x01;
-
-    usb_buf[0x08]           = mode;
-    
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_write(dev, (unsigned char *)usb_buf, 64);
-    hid_read(dev, (unsigned char *)usb_buf, 64);
-}
-
-void RedragonK556Controller::SendKeyboardEnd()
-{
-    char usb_buf[64];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up Keyboard End packet                            |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]           = 0x04;
-    usb_buf[0x01]           = 0x02;
-    usb_buf[0x02]           = 0x00;
-    usb_buf[0x03]           = 0x02;
-    
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_write(dev, (unsigned char *)usb_buf, 64);
-    hid_read(dev, (unsigned char *)usb_buf, 64);
-}

Controllers/RedragonController/RedragonK556Controller.h

@@ -1,72 +0,0 @@
-/*-----------------------------------------*\
-|  RedragonK556Controller.h                 |
-|                                           |
-|  Definitions and types for Redragon K556  |
-|  Devarajas keyboard lighting controller   |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 3/15/2020   |
-\*-----------------------------------------*/
-
-#include "RGBController.h"
-
-#include <string>
-#include <hidapi/hidapi.h>
-
-#pragma once
-
-#define REDRAGON_K556_MAX_PACKET_SIZE   ( 0x36 )        /* max packet size for color*/
-                                                        /* update packets           */
-
-enum
-{
-    REDRAGON_K556_MODE_COLOR_WAVE_SHORT         = 0x01, /* "Go with the stream"     */
-    REDRAGON_K556_MODE_COLOR_WAVE_LONG          = 0x02, /* "Clouds fly"             */
-    REDRAGON_K556_MODE_COLOR_WHEEL              = 0x03, /* "Winding paths"          */
-    REDRAGON_K556_MODE_SPECTRUM_CYCLE           = 0x04, /* "The trial of light"     */
-    REDRAGON_K556_MODE_BREATHING                = 0x05, /* "Breathing"              */
-    REDRAGON_K556_MODE_STATIC                   = 0x06, /* "Normally on"            */
-    REDRAGON_K556_MODE_REACTIVE                 = 0x07, /* "Pass without trace"     */
-    REDRAGON_K556_MODE_REACTIVE_RIPPLE          = 0x08, /* "Ripple graff"           */
-    REDRAGON_K556_MODE_REACTIVE_LINE            = 0x09, /* "Fast run without trace" */
-    REDRAGON_K556_MODE_STARLIGHT_FAST           = 0x0A, /* "Swift action"           */
-    REDRAGON_K556_MODE_BLOOMING                 = 0x0B, /* "Flowers blooming"       */
-    REDRAGON_K556_MODE_RAINBOW_WAVE_VERTICAL    = 0x0C, /* "Snow winter jasmine"    */
-    REDRAGON_K556_MODE_HURRICANE                = 0x0D, /* "Hurricane"              */
-    REDRAGON_K556_MODE_ACCUMULATE               = 0x0E, /* "Accumulate"             */
-    REDRAGON_K556_MODE_STARLIGHT_SLOW           = 0x0F, /* "Digital times"          */
-    REDRAGON_K556_MODE_VISOR                    = 0x10, /* "Both ways"              */
-    REDRAGON_K556_MODE_RAINBOW_WAVE_CIRCLE      = 0x12, /* "Fast and the Furious"   */
-    REDRAGON_K556_MODE_CUSTOM                   = 0x14, /* "Coastal"                */
-};
-
-class RedragonK556Controller
-{
-public:
-    RedragonK556Controller(hid_device* dev_handle);
-    ~RedragonK556Controller();
-
-    void        SetKeyboardColors
-                    (
-                    unsigned char *     color_data,
-                    unsigned int        size
-                    );
-
-    void        SendKeyboardBegin();
-
-    void        SendKeyboardMode
-                    (
-                    unsigned char       mode
-                    );
-
-    void        SendKeyboardData
-                    (
-                    unsigned char *     data,
-                    unsigned char       data_size,
-                    unsigned short      data_offset
-                    );
-
-    void        SendKeyboardEnd();
-
-private:
-    hid_device*             dev;
-};

Controllers/RedragonController/RedragonM711Controller.cpp

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

Controllers/RedragonController/RedragonM711Controller.h

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

Controllers/ThermaltakeRiingController/ThermaltakeRiingController.cpp

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

Controllers/ThermaltakeRiingController/ThermaltakeRiingController.h

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

Controllers/ThermaltakeRiingController/ThermaltakeRiingControllerDetect.cpp

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

OpenAuraSDK.pro

@@ -0,0 +1,22 @@
+QT       += core gui
+
+greaterThan(QT_MAJOR_VERSION, 4): QT += widgets
+
+TARGET = OpenAuraSDK.bin
+TEMPLATE = app
+
+SOURCES += \
+    OpenAuraSDK/i2c_smbus.cpp \
+    OpenAuraSDK/AuraController.cpp \
+    OpenAuraSDK/OpenAuraSDK.cpp \
+    OpenAuraSDK/i2c_smbus_linux.cpp \
+    OpenAuraSDK/OpenAuraSDKQtDialog.cpp
+
+HEADERS += \
+    OpenAuraSDK/i2c_smbus.h \
+    OpenAuraSDK/i2c_smbus_linux.h \
+    OpenAuraSDK/AuraController.h \
+    OpenAuraSDK/OpenAuraSDKQtDialog.h
+
+FORMS += \
+    OpenAuraSDK/openaurasdk.ui

OpenAuraSDK.sln

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

OpenAuraSDK/AuraController.cpp

@@ -0,0 +1,185 @@
+/*-----------------------------------------*\
+|  AuraController.h                         |
+|                                           |
+|  Driver for ASUS Aura RGB lighting        |
+|  controller                               |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 8/19/2018   |
+\*-----------------------------------------*/
+
+#include "AuraController.h"
+#include <cstring>
+
+AuraController::AuraController(i2c_smbus_interface* bus, aura_dev_id dev)
+{
+    this->bus = bus;
+    this->dev = dev;
+
+    AuraUpdateDeviceName();
+
+    // LED-0116 - First generation motherboard controller
+    if (strcmp(device_name, "LED-0116") == 0)
+    {
+        direct_reg = AURA_REG_COLORS_DIRECT;
+        effect_reg = AURA_REG_COLORS_EFFECT;
+        led_count  = 5;
+    }
+    // DIMM_LED-0102 - First generation DRAM controller (Trident Z RGB)
+    else if (strcmp(device_name, "DIMM_LED-0102") == 0)
+    {
+        direct_reg = AURA_REG_COLORS_DIRECT;
+        effect_reg = AURA_REG_COLORS_EFFECT;
+        led_count  = 5;
+    }
+    // AUDA0-E6K5-0101 - Second generation DRAM controller (Geil Super Luce)
+    else if (strcmp(device_name, "AUDA0-E6K5-0101") == 0)
+    {
+        direct_reg = AURA_REG_COLORS_DIRECT_V2;
+        effect_reg = AURA_REG_COLORS_EFFECT_V2;
+        led_count  = 5;
+    }
+    // AUMA0-E6K5-0106 - Second generation motherboard controller
+    else if (strcmp(device_name, "AUMA0-E6K5-0106") == 0)
+    {
+        direct_reg = AURA_REG_COLORS_DIRECT_V2;
+        effect_reg = AURA_REG_COLORS_EFFECT_V2;
+        led_count = 5;
+    }
+    // AUMA0-E6K5-0105 - Second generation motherboard controller
+    else if (strcmp(device_name, "AUMA0-E6K5-0105") == 0)
+    {
+        direct_reg = AURA_REG_COLORS_DIRECT_V2;
+        effect_reg = AURA_REG_COLORS_EFFECT_V2;
+        led_count = 5;
+    }
+    // AUMA0-E6K5-0104 - Second generation motherboard controller
+    else if (strcmp(device_name, "AUMA0-E6K5-0104") == 0)
+    {
+        direct_reg = AURA_REG_COLORS_DIRECT_V2;
+        effect_reg = AURA_REG_COLORS_EFFECT_V2;
+        led_count = 5;
+    }
+    // Assume first generation controller if string does not match
+    else
+    {
+        direct_reg = AURA_REG_COLORS_DIRECT;
+        effect_reg = AURA_REG_COLORS_EFFECT;
+        led_count = 5;
+    }
+    
+}
+
+AuraController::~AuraController()
+{
+
+}
+
+char * AuraController::GetDeviceName()
+{
+    return(device_name);
+}
+
+unsigned int AuraController::GetLEDCount()
+{
+    return(led_count);
+}
+
+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)
+    {
+        colors[i + 0] = red;
+        colors[i + 1] = blue;
+        colors[i + 2] = green;
+    }
+
+    AuraRegisterWriteBlock(direct_reg, colors, led_count * 3);
+
+    delete colors;
+}
+
+void AuraController::SetAllColorsEffect(unsigned char red, unsigned char green, unsigned char blue)
+{
+    unsigned char* colors = new unsigned char[led_count * 3];
+
+    for (int i = 0; i < (led_count * 3); i += 3)
+    {
+        colors[i + 0] = red;
+        colors[i + 1] = blue;
+        colors[i + 2] = green;
+    }
+
+    AuraRegisterWriteBlock(effect_reg, colors, led_count * 3);
+    
+    AuraRegisterWrite(AURA_REG_APPLY, AURA_APPLY_VAL);
+
+    delete colors;
+}
+
+void AuraController::SetDirect(unsigned char direct)
+{
+    AuraRegisterWrite(AURA_REG_DIRECT, direct);
+    AuraRegisterWrite(AURA_REG_APPLY, AURA_APPLY_VAL);
+}
+
+void AuraController::SetLEDColorDirect(unsigned int led, unsigned char red, unsigned char green, unsigned char blue)
+{
+    unsigned char colors[3] = { red, blue, green };
+
+    AuraRegisterWriteBlock(direct_reg + ( 3 * led ), colors, 3);
+}
+
+void AuraController::SetLEDColorEffect(unsigned int led, unsigned char red, unsigned char green, unsigned char blue)
+{
+    unsigned char colors[3] = { red, blue, green };
+
+    AuraRegisterWriteBlock(effect_reg + (3 * led), colors, 3);
+
+    AuraRegisterWrite(AURA_REG_APPLY, AURA_APPLY_VAL);
+}
+
+void AuraController::SetMode(unsigned char mode)
+{
+    AuraRegisterWrite(AURA_REG_MODE, mode);
+    AuraRegisterWrite(AURA_REG_APPLY, AURA_APPLY_VAL);
+}
+
+void AuraController::AuraUpdateDeviceName()
+{
+    for (int i = 0; i < 16; i++)
+    {
+        device_name[i] = AuraRegisterRead(AURA_REG_DEVICE_NAME + i);
+    }
+}
+
+unsigned char AuraController::AuraRegisterRead(aura_register reg)
+{
+    //Write Aura register
+    bus->i2c_smbus_write_word_data(dev, 0x00, ((reg << 8) & 0xFF00) | ((reg >> 8) & 0x00FF));
+
+    //Read Aura value
+    return(bus->i2c_smbus_read_byte_data(dev, 0x81));
+
+}
+
+void AuraController::AuraRegisterWrite(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);
+
+}
+
+void AuraController::AuraRegisterWriteBlock(aura_register reg, unsigned char * data, unsigned char sz)
+{
+    //Write Aura register
+    bus->i2c_smbus_write_word_data(dev, 0x00, ((reg << 8) & 0xFF00) | ((reg >> 8) & 0x00FF));
+
+    //Write Aura block data
+    bus->i2c_smbus_write_block_data(dev, 0x03, sz, data);
+
+}

OpenAuraSDK/AuraController.h

@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  AuraSMBusController.h                    |
+|  AuraController.h                         |
 |                                           |
 |  Definitions and types for ASUS Aura RGB  |
 |  lighting controller                      |
@@ -7,7 +7,6 @@
 |  Adam Honse (CalcProgrammer1) 8/19/2018   |
 \*-----------------------------------------*/
 
-#include <string>
 #include "i2c_smbus.h"
 
 #pragma once
@@ -20,7 +19,6 @@ typedef unsigned short	aura_register;
 enum
 {
     AURA_REG_DEVICE_NAME                = 0x1000,   /* Device String 16 bytes               */
-    AURA_REG_CONFIG_TABLE               = 0x1C00,   /* Start of LED configuration bytes     */
     AURA_REG_COLORS_DIRECT              = 0x8000,   /* Colors for Direct Mode 15 bytes      */
     AURA_REG_COLORS_EFFECT              = 0x8010,   /* Colors for Internal Effects 15 bytes */
     AURA_REG_DIRECT                     = 0x8020,   /* "Direct Access" Selection Register   */
@@ -48,60 +46,16 @@ enum
     AURA_MODE_SPECTRUM_CYCLE_WAVE       = 11,       /* Wave effect mode                     */
     AURA_MODE_CHASE_RAINBOW_PULSE       = 12,       /* Chase with  Rainbow Pulse effect mode*/
     AURA_MODE_RANDOM_FLICKER            = 13,       /* Random flicker effect mode           */
-    AURA_NUMBER_MODES                               /* Number of Aura modes                 */
 };
 
-enum
-{
-    AURA_LED_CHANNEL_DRAM_2             = 0x05,     /* DRAM LED channel                     */
-    AURA_LED_CHANNEL_CENTER_START       = 0x82,     /* Center zone first LED channel        */
-    AURA_LED_CHANNEL_CENTER             = 0x83,     /* Center zone LED channel              */
-    AURA_LED_CHANNEL_AUDIO              = 0x84,     /* Audio zone LED channel               */
-    AURA_LED_CHANNEL_BACK_IO            = 0x85,     /* Back I/O zone LED channel            */
-    AURA_LED_CHANNEL_RGB_HEADER         = 0x86,     /* RGB Header LED channel               */
-    AURA_LED_CHANNEL_RGB_HEADER_2       = 0x87,     /* RGB Header 2 LED channel             */
-    AURA_LED_CHANNEL_BACKPLATE          = 0x88,     /* Backplate zone LED channel           */
-    AURA_LED_CHANNEL_DRAM               = 0x8A,     /* DRAM LED channel                     */
-    AURA_LED_CHANNEL_PCIE               = 0x8B,     /* PCIe zone LED channel                */
-    AURA_LED_CHANNEL_RGB_HEADER_3       = 0x91,     /* RGB Header 3 LED channel             */
-};
-
-static const char* aura_channels[] =                /* Aura channel strings                 */
-{
-    "Audio",
-    "Backplate",
-    "Back I/O",
-    "Center",
-    "Center",
-    "DRAM",
-    "PCIe",
-    "RGB Header",
-    "RGB Header 2",
-    "RGB Header",
-    "Unknown",
-};
-
-enum
-{
-    AURA_CONFIG_LED_COUNT               = 0x02,     /* LED Count configuration offset       */
-    AURA_CONFIG_CHANNEL_V1              = 0x13,     /* LED Channel configuration offset     */
-    AURA_CONFIG_CHANNEL_V2              = 0x1B,     /* LED Channel V2 configuration offset  */
-};
-
-class AuraSMBusController
+class AuraController
 {
 public:
-    AuraSMBusController(i2c_smbus_interface* bus, aura_dev_id dev);
-    ~AuraSMBusController();
+    AuraController(i2c_smbus_interface* bus, aura_dev_id dev);
+    ~AuraController();
 
-    std::string   GetDeviceName();
-    std::string   GetDeviceLocation();
-    unsigned char GetChannel(unsigned int led);
-    const char*   GetChannelName(unsigned int led);
+    char*         GetDeviceName();
     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);
@@ -111,18 +65,17 @@ public:
 
     void          AuraUpdateDeviceName();
 
-    unsigned char AuraRegisterRead(aura_register reg);
-    void          AuraRegisterWrite(aura_register reg, unsigned char val);
-    void          AuraRegisterWriteBlock(aura_register reg, unsigned char * data, unsigned char sz);
+	unsigned char AuraRegisterRead(aura_register reg);
+	void          AuraRegisterWrite(aura_register reg, unsigned char val);
+	void          AuraRegisterWriteBlock(aura_register reg, unsigned char * data, unsigned char sz);
 
 private:
     char                    device_name[16];
-    unsigned char           config_table[64];
     unsigned int            led_count;
     aura_register           direct_reg;
     aura_register           effect_reg;
-    unsigned char           channel_cfg;
     i2c_smbus_interface *   bus;
     aura_dev_id             dev;
+	
 
-};
+};

OpenAuraSDK/CorsairController.cpp

@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  CorsairVengeanceController.h             |
+|  CorsairController.h                      |
 |                                           |
 |  Driver for Corsair Vengeance RGB RAM     |
 |  lighting controller                      |
@@ -7,10 +7,10 @@
 |  Adam Honse (CalcProgrammer1) 3/8/2019    |
 \*-----------------------------------------*/
 
-#include "CorsairVengeanceController.h"
+#include "CorsairController.h"
 #include <cstring>
 
-CorsairVengeanceController::CorsairVengeanceController(i2c_smbus_interface* bus, corsair_dev_id dev)
+CorsairController::CorsairController(i2c_smbus_interface* bus, corsair_dev_id dev)
 {
     this->bus = bus;
     this->dev = dev;
@@ -19,41 +19,26 @@ CorsairVengeanceController::CorsairVengeanceController(i2c_smbus_interface* bus,
     led_count = 1;
 }
 
-CorsairVengeanceController::~CorsairVengeanceController()
+CorsairController::~CorsairController()
 {
 
 }
 
-std::string CorsairVengeanceController::GetDeviceName()
+char * CorsairController::GetDeviceName()
 {
     return(device_name);
 }
 
-std::string CorsairVengeanceController::GetDeviceLocation()
-{
-    std::string return_string(bus->device_name);
-    char addr[5];
-    snprintf(addr, 5, "0x%02X", dev);
-    return_string.append(", address ");
-    return_string.append(addr);
-    return(return_string);
-}
-
-unsigned int CorsairVengeanceController::GetLEDCount()
+unsigned int CorsairController::GetLEDCount()
 {
     return(led_count);
 }
 
-void CorsairVengeanceController::SetLEDColor(unsigned char red, unsigned char green, unsigned char blue)
+void CorsairController::SetAllColorsDirect(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 CorsairVengeanceController::SetMode(unsigned char /*mode*/)
-{
-    bus->i2c_smbus_write_byte_data(dev, CORSAIR_VENGEANCE_RGB_CMD_MODE, CORSAIR_VENGEANCE_RGB_MODE_SINGLE);
-}
+}

OpenAuraSDK/CorsairController.h

@@ -1,5 +1,5 @@
 /*-----------------------------------------*\
-|  CorsairVengeanceController.h             |
+|  CorsairController.h                      |
 |                                           |
 |  Definitions and types for Corsair        |
 |  Vengeance RGB RAM lighting controller    |
@@ -7,7 +7,6 @@
 |  Adam Honse (CalcProgrammer1) 3/8/2019    |
 \*-----------------------------------------*/
 
-#include <string>
 #include "i2c_smbus.h"
 
 #pragma once
@@ -30,25 +29,23 @@ enum
     CORSAIR_VENGEANCE_RGB_MODE_SINGLE   = 0x00,     /* Single Color Effect Mode             */
     CORSAIR_VENGEANCE_RGB_MODE_FADE     = 0x01,     /* Fade Through Colors                  */
     CORSAIR_VENGEANCE_RGB_MODE_PULSE    = 0x02,     /* Pulse Through Colors                 */
-    CORSAIR_NUMBER_MODES                            /* Number of Corsair modes              */
 };
 
-class CorsairVengeanceController
+class CorsairController
 {
 public:
-    CorsairVengeanceController(i2c_smbus_interface* bus, corsair_dev_id dev);
-    ~CorsairVengeanceController();
+    CorsairController(i2c_smbus_interface* bus, corsair_dev_id dev);
+    ~CorsairController();
 
-    std::string     GetDeviceName();
-    std::string     GetDeviceLocation();
-    unsigned int    GetLEDCount();
-    void            SetMode(unsigned char mode);
+    char*         GetDeviceName();
+    unsigned int  GetLEDCount();
 
-    void            SetLEDColor(unsigned char red, unsigned char green, unsigned char blue);
+    void          SetAllColorsDirect(unsigned char red, unsigned char green, unsigned char blue);
 
 private:
     char                    device_name[32];
     unsigned int            led_count;
     i2c_smbus_interface *   bus;
     corsair_dev_id          dev;
-};
+
+};

OpenAuraSDK/I2CDetectDialog.cpp

@@ -0,0 +1,50 @@
+#include "I2CDetectDialog.h"
+#include "OpenAuraSDK.h"
+
+IMPLEMENT_DYNAMIC(I2CDetectDialog, CDialogEx)
+
+I2CDetectDialog::I2CDetectDialog(std::vector<i2c_smbus_interface *>& bus, CWnd* pParent)
+    : CDialogEx(IDD_DIALOG_I2C_DETECT, pParent), busses(bus)
+{
+
+}
+
+I2CDetectDialog::~I2CDetectDialog()
+{
+
+}
+
+void I2CDetectDialog::DoDataExchange(CDataExchange* pDX)
+{
+    CDialogEx::DoDataExchange(pDX);
+}
+
+BEGIN_MESSAGE_MAP(I2CDetectDialog, CDialogEx)
+    ON_BN_CLICKED(IDC_BUTTON_I2C_DETECT, &I2CDetectDialog::OnBnClickedButtonI2cDetect)
+END_MESSAGE_MAP()
+
+BOOL I2CDetectDialog::OnInitDialog()
+{
+    CComboBox* i2c_bus_box = (CComboBox*)GetDlgItem(IDC_COMBO_I2C_BUS);
+    for (int i = 0; i < busses.size(); i++)
+    {
+        i2c_bus_box->AddString(busses[i]->device_name);
+    }
+
+    i2c_bus_box->SetCurSel(0);
+
+    CFont* myFont = new CFont();
+    myFont->CreateFontA(16, 0, 0, 0, FW_DONTCARE, false, false, 0, ANSI_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN, _T("Consolas"));
+
+    CEdit* edit = (CEdit*)GetDlgItem(IDC_EDIT_I2C_DETECT);
+    edit->SetFont(myFont);
+
+    return TRUE;
+}
+
+void I2CDetectDialog::OnBnClickedButtonI2cDetect()
+{
+    i2c_smbus_interface* bus = busses[((CComboBox*)GetDlgItem(IDC_COMBO_I2C_BUS))->GetCurSel()];
+
+    SetDlgItemText(IDC_EDIT_I2C_DETECT, DetectI2C(bus, MODE_QUICK).c_str());
+}

OpenAuraSDK/I2CDetectDialog.h

@@ -0,0 +1,28 @@
+#ifndef I2CDETECT_DIALOG_H
+#define I2CDETECT_DIALOG_H
+
+#include <afxdialogex.h>
+#include <vector>
+#include "i2c_smbus.h"
+#include "resource.h"
+
+class I2CDetectDialog : public CDialogEx
+{
+    DECLARE_DYNAMIC(I2CDetectDialog)
+
+public:
+    I2CDetectDialog(std::vector<i2c_smbus_interface *>& bus, CWnd* pParent = NULL);
+    virtual ~I2CDetectDialog();
+    virtual BOOL OnInitDialog();
+
+private:
+
+protected:
+    std::vector<i2c_smbus_interface *>& busses;
+    virtual void DoDataExchange(CDataExchange* pDX);
+    DECLARE_MESSAGE_MAP()
+public:
+    afx_msg void OnBnClickedButtonI2cDetect();
+};
+
+#endif

OpenAuraSDK/OpenAuraSDK.cpp

@@ -0,0 +1,584 @@
+/******************************************************************************************\
+*                                                                                          *
+*   OpenAuraSDK.cpp                                                                        *
+*                                                                                          *
+*       Functions for communicating with Asus Aura devices on Windows and Linux            *
+*                                                                                          *
+\******************************************************************************************/
+
+#include "AuraController.h"
+#include "i2c_smbus.h"
+#include <vector>
+#include <stdio.h>
+#include <stdlib.h>
+
+#ifdef WIN32
+
+#include <tchar.h>
+#include <regex>
+#include "OpenAuraSDKDialog.h"
+#include "I2CDetectDialog.h"
+#include "i2c_smbus_piix4.h"
+#include "i2c_smbus_i801.h"
+#include "i2c_smbus_nuvoton_nct6793d.h"
+#include "wmi.h"
+#include "inpout32.h"
+
+#pragma comment(lib, "inpout32.lib")
+#else /* WIN32 */
+
+#include "OpenAuraSDKQtDialog.h"
+#include "i2c_smbus_linux.h"
+#include <fcntl.h>
+#include <unistd.h>
+#include <dirent.h>
+
+#endif /* WIN32 */
+
+std::vector<AuraController *> controllers;
+std::vector<i2c_smbus_interface *> busses;
+
+#ifdef WIN32
+/******************************************************************************************\
+*                                                                                          *
+*   Nuvoton Super IO constants                                                             *
+*                                                                                          *
+\******************************************************************************************/
+
+#define SIO_NCT5577_ID      0xC330  /* Device ID for NCT5577D (C333)        */
+#define SIO_NCT6102_ID      0x1060  /* Device ID for NCT6102D/6106D (1061)  */
+#define SIO_NCT6793_ID      0xd120  /* Device ID for NCT6793D (D121)        */
+#define SIO_NCT6796_ID      0xd420  /* Device ID for NCT6796D (D421)        */
+#define SIO_NCT6798_ID      0xd428  /* Device ID for NCT6798D (D428)        */
+#define SIO_REG_LOGDEV      0x07    /* Logical Device Register              */
+#define SIO_REG_DEVID       0x20    /* Device ID Register                   */
+#define SIO_REG_SMBA        0x62    /* SMBus Base Address Register          */
+#define SIO_LOGDEV_SMBUS    0x0B    /* Logical Device for SMBus             */
+#define SIO_ID_MASK         0xFFF8  /* Device ID mask                       */
+
+
+/******************************************************************************************\
+*                                                                                          *
+*   superio_enter                                                                          *
+*                                                                                          *
+*   Put the Super IO chip into Extended Function Mode                                      *
+*                                                                                          *
+\******************************************************************************************/
+
+void superio_enter(int ioreg)
+{
+    Out32(ioreg, 0x87);
+    Out32(ioreg, 0x87);
+}
+
+
+/******************************************************************************************\
+*                                                                                          *
+*   superio_outb                                                                           *
+*                                                                                          *
+*   Write a byte to the Super IO configuration register                                    *
+*                                                                                          *
+\******************************************************************************************/
+
+void superio_outb(int ioreg, int reg, int val)
+{
+    Out32(ioreg, reg);
+    Out32(ioreg + 1, val);
+}
+
+
+/******************************************************************************************\
+*                                                                                          *
+*   superio_inb                                                                            *
+*                                                                                          *
+*   Read a byte to the Super IO configuration register                                     *
+*                                                                                          *
+\******************************************************************************************/
+
+int superio_inb(int ioreg, int reg)
+{
+    Out32(ioreg, reg);
+    return Inp32(ioreg + 1);
+}
+
+
+/******************************************************************************************\
+*                                                                                          *
+*   DetectNuvotonI2CBusses (Windows)                                                       *
+*                                                                                          *
+*       Detects available Nuvoton Super IO SMBUS adapters and enumerates                   *
+*       i2c_smbus_interface objects for them                                               *
+*                                                                                          *
+\******************************************************************************************/
+
+void DetectNuvotonI2CBusses()
+{
+    i2c_smbus_interface* bus;
+    int sioaddr = 0x2E;
+    superio_enter(sioaddr);
+
+    int val = (superio_inb(sioaddr, SIO_REG_DEVID) << 8) | superio_inb(sioaddr, SIO_REG_DEVID + 1);
+
+    switch (val & SIO_ID_MASK)
+    {
+    case SIO_NCT5577_ID:
+    case SIO_NCT6102_ID:
+    case SIO_NCT6793_ID:
+    case SIO_NCT6796_ID:
+    case SIO_NCT6798_ID:
+        bus = new i2c_smbus_nuvoton_nct6793d();
+
+        // Set logical device register to get SMBus base address
+        superio_outb(sioaddr, SIO_REG_LOGDEV, SIO_LOGDEV_SMBUS);
+
+        // Get SMBus base address from configuration register
+        int smba = (superio_inb(sioaddr, SIO_REG_SMBA) << 8) | superio_inb(sioaddr, SIO_REG_SMBA + 1);
+        ((i2c_smbus_nuvoton_nct6793d*)bus)->nuvoton_nct6793d_smba = smba;
+
+        // Set device name string
+        switch (val & SIO_ID_MASK)
+        {
+        case SIO_NCT5577_ID:
+            sprintf(bus->device_name, "Nuvoton NCT5577D SMBus at %X", smba);
+            break;
+        case SIO_NCT6102_ID:
+            sprintf(bus->device_name, "Nuvoton NCT6102D/NCT6106D SMBus at %X", smba);
+            break;
+        case SIO_NCT6793_ID:
+            sprintf(bus->device_name, "Nuvoton NCT6793D SMBus at %X", smba);
+            break;
+        case SIO_NCT6796_ID:
+            sprintf(bus->device_name, "Nuvoton NCT6796D SMBus at %X", smba);
+            break;
+        case SIO_NCT6798_ID:
+            sprintf(bus->device_name, "Nuvoton NCT6798D SMBus at %X", smba);
+            break;
+        }
+
+        busses.push_back(bus);
+    }
+
+}   /* DetectNuvotonI2CBusses() */
+
+
+/******************************************************************************************\
+*                                                                                          *
+*   DetectI2CBusses (Windows)                                                              *
+*                                                                                          *
+*       Detects available AMD and Intel SMBUS adapters and enumerates i2c_smbus_interface  *
+*       objects for them                                                                   *
+*                                                                                          *
+\******************************************************************************************/
+
+void DetectI2CBusses()
+{
+    i2c_smbus_interface * bus;
+    HRESULT hres;
+    Wmi wmi;
+    wmi.init();
+
+    // Query WMI for Win32_PnPSignedDriver entries with names matching "SMBUS" or "SM BUS"
+    // These devices may be browsed under Device Manager -> System Devices
+    std::vector<QueryObj> q_res_PnPSignedDriver;
+    hres = wmi.query("SELECT * FROM Win32_PnPSignedDriver WHERE Description LIKE '\%SMBUS\%' OR Description LIKE '\%SM BUS\%'", q_res_PnPSignedDriver);
+
+    if (hres)
+    {
+        return;
+    }
+
+    // For each detected SMBus adapter, try enumerating it as either AMD or Intel
+    for (QueryObj &i : q_res_PnPSignedDriver)
+    {
+        // AMD SMBus controllers do not show any I/O resources allocated in Device Manager
+        // Analysis of many AMD boards has shown that AMD SMBus controllers have two adapters with fixed I/O spaces at 0x0B00 and 0x0B20
+        // AMD SMBus adapters use the PIIX4 driver
+        if (i["Manufacturer"].find("Advanced Micro Devices, Inc") != std::string::npos)
+        {
+            bus = new i2c_smbus_piix4();
+            strcpy(bus->device_name, i["Description"].c_str());
+            strcat(bus->device_name, " at 0x0B00");
+            ((i2c_smbus_piix4 *)bus)->piix4_smba = 0x0B00;
+            busses.push_back(bus);
+
+            bus = new i2c_smbus_piix4();
+            ((i2c_smbus_piix4 *)bus)->piix4_smba = 0x0B20;
+            strcpy(bus->device_name, i["Description"].c_str());
+            strcat(bus->device_name, " at 0x0B20");
+            busses.push_back(bus);
+        }
+
+        // Intel SMBus controllers do show I/O resources in Device Manager
+        // Analysis of many Intel boards has shown that Intel SMBus adapter I/O space varies between boards
+        // We can query Win32_PnPAllocatedResource entries and look up the PCI device ID to find the allocated I/O space
+        // Intel SMBus adapters use the i801 driver
+        else if ((i["Manufacturer"].find("Intel") != std::string::npos)
+              || (i["Manufacturer"].find("INTEL") != std::string::npos))
+        {
+            std::string rgx1 = ".+" + q_res_PnPSignedDriver[0]["DeviceID"].substr(4, 33) + ".+";
+
+            AdditionalFilters filters;
+            filters.emplace("Dependent", rgx1);
+            filters.emplace("Antecedent", ".*Port.*");
+
+            std::vector<QueryObj> q_res_PNPAllocatedResource;
+            hres = wmi.query("SELECT * FROM Win32_PnPAllocatedResource", q_res_PNPAllocatedResource, &filters);
+
+            std::regex rgx2(".*StartingAddress=\"(\\d+)\".*");
+            std::smatch matches;
+
+            // Query the StartingAddress for the matching device ID and use it to enumerate the bus
+            if (std::regex_search(q_res_PNPAllocatedResource[0]["Antecedent"], matches, rgx2))
+            {
+                unsigned int IORangeStart = std::stoi(matches[1].str());
+
+                bus = new i2c_smbus_i801();
+                strcpy(bus->device_name, i["Description"].c_str());
+                ((i2c_smbus_i801 *)bus)->i801_smba = IORangeStart;
+                busses.push_back(bus);
+            }
+        }
+    }
+
+    // Detect Nuvoton Super IO SMBus adapters
+    DetectNuvotonI2CBusses();
+
+}   /* DetectI2CBusses() */
+
+#else /* WIN32 */
+
+/******************************************************************************************\
+*                                                                                          *
+*   DetectI2CBusses (Linux)                                                                *
+*                                                                                          *
+*       Detects available SMBUS adapters and enumerates i2c_smbus_interface objects for    *
+*       them                                                                               *
+*                                                                                          *
+\******************************************************************************************/
+
+void DetectI2CBusses()
+{
+    i2c_smbus_linux *       bus;
+    char                    device_string[1024];
+    DIR *                   dir;
+    char                    driver_path[512];
+    struct dirent *         ent;
+    int                     test_fd;
+
+    // Start looking for I2C adapters in /sys/bus/i2c/devices/
+    strcpy(driver_path, "/sys/bus/i2c/devices/");
+    dir = opendir(driver_path);
+
+    if(dir == NULL)
+    {
+        return;
+    }
+
+    // Loop through all entries in i2c-adapter list
+    ent = readdir(dir);
+    while(ent != NULL)
+    {
+        if(ent->d_type == DT_DIR || ent->d_type == DT_LNK)
+        {
+            if(strncmp(ent->d_name, "i2c-", 4) == 0)
+            {
+                strcpy(device_string, driver_path);
+                strcat(device_string, ent->d_name);
+                strcat(device_string, "/name");
+                test_fd = open(device_string, O_RDONLY);
+
+                if(test_fd)
+                {
+                    read(test_fd, device_string, sizeof(device_string));
+                    close(test_fd);
+
+                    //ignore nvidia adapters for now
+                    if(strncmp(device_string, "NVIDIA", 6) == 0)
+                    {
+                        ent = readdir(dir);
+                        continue;
+                    }
+
+                    bus = new i2c_smbus_linux();
+                    strcpy(bus->device_name, device_string);
+
+                    strcpy(device_string, "/dev/");
+                    strcat(device_string, ent->d_name);
+                    test_fd = open(device_string, O_RDWR);
+
+                    if (test_fd < 0)
+                    {
+                        delete bus;
+                        ent = readdir(dir);
+                        continue;
+                    }
+
+                    bus->handle = test_fd;
+                    busses.push_back(bus);
+                }
+            }
+        }
+        ent = readdir(dir);
+    }
+
+}   /* DetectI2CBusses() */
+
+#endif  /* WIN32 */
+
+/******************************************************************************************\
+*                                                                                          *
+*   TestForAuraController                                                                  *
+*                                                                                          *
+*       Tests the given address to see if an Aura controller exists there.  First does a   *
+*       quick write to test for a response, and if so does a simple read at 0xA0 to test   *
+*       for incrementing values 0...F which was observed at this location during data dump *
+*                                                                                          *
+\******************************************************************************************/
+
+bool TestForAuraController(i2c_smbus_interface* bus, unsigned char address)
+{
+    bool pass = false;
+
+    int res = bus->i2c_smbus_write_quick(address, I2C_SMBUS_WRITE);
+    
+    if (res >= 0)
+    {
+        pass = true;
+
+        for (int i = 0xA0; i < 0xB0; i++)
+        {
+            res = bus->i2c_smbus_read_byte_data(address, i);
+
+            if (res != (i - 0xA0))
+            {
+                pass = false;
+            }
+        }
+    }
+
+    return(pass);
+
+}   /* TestForAuraController() */
+
+
+/******************************************************************************************\
+*                                                                                          *
+*   DetectAuraControllers                                                                  *
+*                                                                                          *
+*       Detect Aura controllers on the enumerated I2C busses.  Searches for Aura-enabled   *
+*       RAM at 0x77 and tries to initialize their slot addresses, then searches for them   *
+*       at their correct initialized addresses.  Also looks for motherboard controller at  *
+*       address 0x4E.                                                                      *
+*                                                                                          *
+*           bus - pointer to i2c_smbus_interface where Aura device is connected            *
+*           dev - I2C address of Aura device                                               *
+*                                                                                          *
+\******************************************************************************************/
+
+void DetectAuraControllers()
+{
+    AuraController* new_controller;
+
+    for (unsigned int bus = 0; bus < busses.size(); bus++)
+    {
+        // Remap Aura-enabled RAM modules on 0x77
+        for (unsigned int slot = 0; slot < 8; slot++)
+        {
+            int res = busses[bus]->i2c_smbus_write_quick(0x77, I2C_SMBUS_WRITE);
+
+            if (res < 0)
+            {
+                break;
+            }
+
+            AuraController temp_controller(busses[bus], 0x77);
+
+            temp_controller.AuraRegisterWrite(AURA_REG_SLOT_INDEX, slot);
+            temp_controller.AuraRegisterWrite(AURA_REG_I2C_ADDRESS, 0xE0 + (slot << 1));
+        }
+
+        // Add Aura-enabled controllers at their remapped addresses
+        for (unsigned int slot = 0; slot < 8; slot++)
+        {
+            if (TestForAuraController(busses[bus], 0x70 + slot))
+            {
+                new_controller = new AuraController(busses[bus], 0x70 + slot);
+                controllers.push_back(new_controller);
+            }
+        }
+
+        // Check for Aura controller at 0x40
+        if (TestForAuraController(busses[bus], 0x40))
+        {
+            new_controller = new AuraController(busses[bus], 0x40);
+            controllers.push_back(new_controller);
+        }
+
+        // Check for Aura controller at 0x4E
+        if (TestForAuraController(busses[bus], 0x4E))
+        {
+            new_controller = new AuraController(busses[bus], 0x4E);
+            controllers.push_back(new_controller);
+        }
+
+        // Check for Aura controller at 0x4F
+        if (TestForAuraController(busses[bus], 0x4F))
+        {
+            new_controller = new AuraController(busses[bus], 0x4F);
+            controllers.push_back(new_controller);
+        }
+
+        // Check for Aura controller at 0x66
+        if (TestForAuraController(busses[bus], 0x66))
+        {
+            new_controller = new AuraController(busses[bus], 0x66);
+            controllers.push_back(new_controller);
+        }
+    }
+
+}   /* DetectAuraControllers() */
+
+
+/******************************************************************************************\
+*                                                                                          *
+*   DetectI2C                                                                              *
+*                                                                                          *
+*       Prints a list of all detected I2C addresses on the given bus                       *
+*                                                                                          *
+*           bus - pointer to i2c_smbus_interface to scan                                   *
+*           mode - one of AUTO, QUICK, READ, FUNC - method of access                       *
+*                                                                                          *
+*       Code adapted from i2cdetect.c from i2c-tools Linux package                         *
+*                                                                                          *
+\******************************************************************************************/
+
+#define MODE_AUTO   0
+#define MODE_QUICK  1
+#define MODE_READ   2
+#define MODE_FUNC   3
+
+std::string DetectI2C(i2c_smbus_interface * bus, int mode)
+{
+    int i, j;
+    int res;
+    int slave_addr;
+    char line[128];
+    std::string text;
+
+    freopen("i2cdetect.txt", "a", stdout);
+
+    sprintf(line, "     0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f\r\n");
+    text.append(line);
+
+    for (i = 0; i < 128; i += 16)
+    {
+        sprintf(line, "%02x: ", i);
+        text.append(line);
+
+        for (j = 0; j < 16; j++)
+        {
+            /* Set slave address */
+            slave_addr = i + j;
+
+            /* Probe this address */
+            switch (mode)
+            {
+            case MODE_QUICK:
+                res = bus->i2c_smbus_write_quick(slave_addr, I2C_SMBUS_WRITE);
+                break;
+            case MODE_READ:
+                res = bus->i2c_smbus_read_byte(slave_addr);
+                break;
+            default:
+                if ((i + j >= 0x30 && i + j <= 0x37)
+                 || (i + j >= 0x50 && i + j <= 0x5F))
+                    res = bus->i2c_smbus_read_byte(slave_addr);
+                else
+                    res = bus->i2c_smbus_write_quick(slave_addr, I2C_SMBUS_WRITE);
+                break;
+            }
+
+            if (res < 0)
+            {
+                sprintf(line, "-- ");
+                text.append(line);
+            }
+            else
+            {
+                sprintf(line, "%02x ", i + j);
+                text.append(line);
+            }
+        }
+        sprintf(line, "\r\n");
+        text.append(line);
+    }
+
+    return text;
+
+}   /* DetectI2C() */
+
+
+/******************************************************************************************\
+*                                                                                          *
+*   DumpAuraRegisters                                                                      *
+*                                                                                          *
+*       Dumps register values from an Aura device                                          *
+*                                                                                          *
+\******************************************************************************************/
+
+void DumpAuraRegisters(AuraController * controller)
+{
+    int i, j;
+
+    int start = 0x0000;
+
+    FILE* file = freopen("auradump.txt", "a", stdout);
+
+    printf("       0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f\r\n");
+
+    for (i = 0; i < 0xFFFF; i += 16)
+    {
+        printf("%04x: ", i + start);
+
+        for (j = 0; j < 16; j++)
+        {
+            printf("%02x ", controller->AuraRegisterRead(start + i + j));
+        }
+
+        printf("\r\n");
+    }
+
+    fclose(file);
+
+}   /* DumpAuraRegisters() */
+
+
+/******************************************************************************************\
+*                                                                                          *
+*   main                                                                                   *
+*                                                                                          *
+*       Main function.  Detects busses and Aura controllers, then opens the main window    *
+*                                                                                          *
+\******************************************************************************************/
+
+int main(int argc, char *argv[])
+{
+    DetectI2CBusses();
+
+    DetectAuraControllers();
+
+#if WIN32
+    OpenAuraSDKDialog dlg(busses, controllers);
+    dlg.DoModal();
+
+    return 0;
+
+#else
+    QApplication a(argc, argv);
+
+    Ui::OpenAuraSDKQtDialog dlg(busses, controllers);
+    dlg.show();
+
+    return a.exec();
+#endif
+}

OpenAuraSDK/OpenAuraSDK.h

@@ -0,0 +1,11 @@
+#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);

OpenAuraSDK/OpenAuraSDK.vcxproj

@@ -0,0 +1,209 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <VCProjectVersion>15.0</VCProjectVersion>
+    <ProjectGuid>{6D22BFF3-C1DF-407A-8816-05D63919A991}</ProjectGuid>
+    <Keyword>Win32Proj</Keyword>
+    <RootNamespace>OpenAuraSDK</RootNamespace>
+    <WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v142</PlatformToolset>
+    <CharacterSet>Unicode</CharacterSet>
+    <UseOfMfc>Dynamic</UseOfMfc>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v142</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>Unicode</CharacterSet>
+    <UseOfMfc>Dynamic</UseOfMfc>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v142</PlatformToolset>
+    <CharacterSet>Unicode</CharacterSet>
+    <UseOfMfc>Dynamic</UseOfMfc>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v142</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>Unicode</CharacterSet>
+    <UseOfMfc>Dynamic</UseOfMfc>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="Shared">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <LinkIncremental>true</LinkIncremental>
+    <TargetExt>.exe</TargetExt>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <LinkIncremental>true</LinkIncremental>
+    <TargetExt>.exe</TargetExt>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <LinkIncremental>false</LinkIncremental>
+    <TargetExt>.exe</TargetExt>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <LinkIncremental>false</LinkIncremental>
+    <TargetExt>.exe</TargetExt>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <ClCompile>
+      <PrecompiledHeader>NotUsing</PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <SDLCheck>true</SDLCheck>
+      <PreprocessorDefinitions>WIN32;_CRT_SECURE_NO_WARNINGS;_AFXDLL</PreprocessorDefinitions>
+      <ConformanceMode>true</ConformanceMode>
+      <AdditionalIncludeDirectories>..\dependencies\inpout32_1501\Win32;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <MultiProcessorCompilation>true</MultiProcessorCompilation>
+      <PrecompiledHeaderFile />
+      <PrecompiledHeaderOutputFile />
+      <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalLibraryDirectories>..\dependencies\inpout32_1501\Win32;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <ClCompile>
+      <PrecompiledHeader>NotUsing</PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <SDLCheck>true</SDLCheck>
+      <PreprocessorDefinitions>WIN32;_CRT_SECURE_NO_WARNINGS;_AFXDLL</PreprocessorDefinitions>
+      <ConformanceMode>true</ConformanceMode>
+      <PrecompiledHeaderFile />
+      <PrecompiledHeaderOutputFile />
+      <AdditionalIncludeDirectories>..\dependencies\inpout32_1501\Win32;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalLibraryDirectories>..\dependencies\inpout32_1501\Win32;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <ClCompile>
+      <PrecompiledHeader>NotUsing</PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>MaxSpeed</Optimization>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <SDLCheck>true</SDLCheck>
+      <PreprocessorDefinitions>WIN32;_CRT_SECURE_NO_WARNINGS;_AFXDLL</PreprocessorDefinitions>
+      <ConformanceMode>true</ConformanceMode>
+      <AdditionalIncludeDirectories>..\dependencies\inpout32_1501\Win32;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <MultiProcessorCompilation>true</MultiProcessorCompilation>
+      <PrecompiledHeaderFile />
+      <PrecompiledHeaderOutputFile />
+      <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalLibraryDirectories>..\dependencies\inpout32_1501\Win32;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <ClCompile>
+      <PrecompiledHeader>NotUsing</PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>MaxSpeed</Optimization>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <SDLCheck>true</SDLCheck>
+      <PreprocessorDefinitions>WIN32;_CRT_SECURE_NO_WARNINGS;_AFXDLL</PreprocessorDefinitions>
+      <ConformanceMode>true</ConformanceMode>
+      <PrecompiledHeaderFile />
+      <PrecompiledHeaderOutputFile />
+      <AdditionalIncludeDirectories>..\dependencies\inpout32_1501\Win32;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalLibraryDirectories>..\dependencies\inpout32_1501\Win32;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClInclude Include="AuraController.h" />
+    <ClInclude Include="I2CDetectDialog.h" />
+    <ClInclude Include="i2c_smbus.h" />
+    <ClInclude Include="i2c_smbus_i801.h" />
+    <ClInclude Include="i2c_smbus_nuvoton_nct6793d.h" />
+    <ClInclude Include="i2c_smbus_piix4.h" />
+    <ClInclude Include="OpenAuraSDK.h" />
+    <ClInclude Include="OpenAuraSDKDialog.h" />
+    <ClInclude Include="resource.h" />
+    <ClInclude Include="wmi.h" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="AuraController.cpp" />
+    <ClCompile Include="dllmain.cpp" />
+    <ClCompile Include="I2CDetectDialog.cpp" />
+    <ClCompile Include="i2c_smbus.cpp" />
+    <ClCompile Include="i2c_smbus_i801.cpp" />
+    <ClCompile Include="i2c_smbus_nuvoton_nct6793d.cpp" />
+    <ClCompile Include="i2c_smbus_piix4.cpp" />
+    <ClCompile Include="OpenAuraSDKDialog.cpp" />
+    <ClCompile Include="wmi.cpp" />
+    <ClCompile Include="OpenAuraSDK.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <ResourceCompile Include="Resource.rc" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>

OpenAuraSDK/OpenAuraSDK.vcxproj.filters

@@ -0,0 +1,86 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <Filter Include="Source Files">
+      <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
+      <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
+    </Filter>
+    <Filter Include="Header Files">
+      <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
+      <Extensions>h;hh;hpp;hxx;hm;inl;inc;ipp;xsd</Extensions>
+    </Filter>
+    <Filter Include="Resource Files">
+      <UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
+      <Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
+    </Filter>
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="i2c_smbus.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="i2c_smbus_piix4.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="AuraController.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="i2c_smbus_i801.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="wmi.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="resource.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="OpenAuraSDKDialog.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="OpenAuraSDK.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="I2CDetectDialog.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="i2c_smbus_nuvoton_nct6793d.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="OpenAuraSDK.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="dllmain.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="i2c_smbus_piix4.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="AuraController.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="i2c_smbus_i801.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="i2c_smbus.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="wmi.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="OpenAuraSDKDialog.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="I2CDetectDialog.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="i2c_smbus_nuvoton_nct6793d.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+  </ItemGroup>
+  <ItemGroup>
+    <ResourceCompile Include="Resource.rc">
+      <Filter>Resource Files</Filter>
+    </ResourceCompile>
+  </ItemGroup>
+</Project>

OpenAuraSDK/OpenAuraSDKDialog.cpp

@@ -0,0 +1,441 @@
+#include "OpenAuraSDKDialog.h"
+#include "OpenAuraSDK.h"
+#include "I2CDetectDialog.h"
+
+IMPLEMENT_DYNAMIC(OpenAuraSDKDialog, CDialogEx)
+
+OpenAuraSDKDialog::OpenAuraSDKDialog(std::vector<i2c_smbus_interface *>& bus, std::vector<AuraController *>& control, CWnd* pParent)
+    : CDialogEx(IDD_DIALOG_OPENAURASDK, pParent), busses(bus), controllers (control)
+{
+
+}
+
+OpenAuraSDKDialog::~OpenAuraSDKDialog()
+{
+
+}
+
+void OpenAuraSDKDialog::DoDataExchange(CDataExchange* pDX)
+{
+    CDialogEx::DoDataExchange(pDX);
+}
+
+BEGIN_MESSAGE_MAP(OpenAuraSDKDialog, CDialogEx)
+    ON_BN_CLICKED(IDC_BUTTON_OPENAURASDK_I2CDETECT, &OpenAuraSDKDialog::OnBnClickedButtonOpenaurasdkI2cdetect)
+    ON_BN_CLICKED(IDC_RADIO_OPENAURASDK_DIRECT_MODE, &OpenAuraSDKDialog::OnBnClickedRadioOpenaurasdkDirectMode)
+    ON_BN_CLICKED(IDC_RADIO_OPENAURASDK_EFFECT_MODE, &OpenAuraSDKDialog::OnBnClickedRadioOpenaurasdkEffectMode)
+    ON_BN_CLICKED(IDC_RADIO_OPENAURASDK_EFFECT_OFF, &OpenAuraSDKDialog::OnBnClickedRadioOpenaurasdkEffectOff)
+    ON_BN_CLICKED(IDC_RADIO_OPENAURASDK_EFFECT_STATIC, &OpenAuraSDKDialog::OnBnClickedRadioOpenaurasdkEffectStatic)
+    ON_BN_CLICKED(IDC_RADIO_OPENAURASDK_EFFECT_BREATHING, &OpenAuraSDKDialog::OnBnClickedRadioOpenaurasdkEffectBreathing)
+    ON_BN_CLICKED(IDC_RADIO_OPENAURASDK_EFFECT_FLASHING, &OpenAuraSDKDialog::OnBnClickedRadioOpenaurasdkEffectFlashing)
+    ON_BN_CLICKED(IDC_RADIO_OPENAURASDK_EFFECT_SPECTRUM_CYCLE, &OpenAuraSDKDialog::OnBnClickedRadioOpenaurasdkEffectSpectrumCycle)
+    ON_BN_CLICKED(IDC_RADIO_OPENAURASDK_EFFECT_RAINBOW, &OpenAuraSDKDialog::OnBnClickedRadioOpenaurasdkEffectRainbow)
+    ON_BN_CLICKED(IDC_RADIO_OPENAURASDK_BREATHING_SPECTRUM, &OpenAuraSDKDialog::OnBnClickedRadioOpenaurasdkBreathingSpectrum)
+    ON_BN_CLICKED(IDC_RADIO_OPENAURASDK_EFFECT_CHASE_FADE, &OpenAuraSDKDialog::OnBnClickedRadioOpenaurasdkEffectChaseFade)
+    ON_BN_CLICKED(IDC_BUTTON_OPENAURASDK_SET_COLORS, &OpenAuraSDKDialog::OnBnClickedButtonOpenaurasdkSetColors)
+    ON_CBN_CLOSEUP(IDC_COMBO_OPENAURASDK_DEVICE, &OpenAuraSDKDialog::OnCbnCloseupComboOpenaurasdkDevice)
+    ON_BN_CLICKED(IDC_BUTTON_OPENAURASDK_SET_COLORS_ALL, &OpenAuraSDKDialog::OnBnClickedButtonOpenaurasdkSetColorsAll)
+    ON_BN_CLICKED(IDC_BUTTON_OPENAURASDK_DUMP, &OpenAuraSDKDialog::OnBnClickedButtonOpenaurasdkDump)
+END_MESSAGE_MAP()
+
+BOOL OpenAuraSDKDialog::OnInitDialog()
+{
+    CComboBox* aura_device_box = (CComboBox*)GetDlgItem(IDC_COMBO_OPENAURASDK_DEVICE);
+
+    aura_device_box->AddString("All Devices");
+
+    for (int i = 0; i < controllers.size(); i++)
+    {
+        aura_device_box->AddString(controllers[i]->GetDeviceName());
+    }
+
+    aura_device_box->SetCurSel(0);
+
+    CFont* myFont = new CFont();
+    myFont->CreateFontA(16, 0, 0, 0, FW_DONTCARE, false, false, 0, ANSI_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN, _T("Consolas"));
+
+    return TRUE;
+}
+
+
+void OpenAuraSDKDialog::OnBnClickedButtonOpenaurasdkI2cdetect()
+{
+    I2CDetectDialog dlg(busses);
+    dlg.DoModal();
+}
+
+
+void OpenAuraSDKDialog::OnBnClickedRadioOpenaurasdkDirectMode()
+{
+    unsigned int aura_device = ((CComboBox*)GetDlgItem(IDC_COMBO_OPENAURASDK_DEVICE))->GetCurSel();
+    if ( aura_device == 0)
+    {
+        for (int i = 0; i < controllers.size(); i++)
+        {
+            controllers[i]->SetDirect(true);
+        }
+    }
+    else
+    {
+        controllers[aura_device - 1]->SetDirect(true);
+    }
+}
+
+
+void OpenAuraSDKDialog::OnBnClickedRadioOpenaurasdkEffectMode()
+{
+    unsigned int aura_device = ((CComboBox*)GetDlgItem(IDC_COMBO_OPENAURASDK_DEVICE))->GetCurSel();
+    if (aura_device == 0)
+    {
+        for (int i = 0; i < controllers.size(); i++)
+        {
+            controllers[i]->SetDirect(false);
+        }
+    }
+    else
+    {
+        controllers[aura_device - 1]->SetDirect(false);
+    }
+}
+
+
+void OpenAuraSDKDialog::setMode(unsigned char mode_val)
+{
+    unsigned int aura_device = ((CComboBox*)GetDlgItem(IDC_COMBO_OPENAURASDK_DEVICE))->GetCurSel();
+    if (aura_device == 0)
+    {
+        for (int i = 0; i < controllers.size(); i++)
+        {
+            controllers[i]->SetMode(mode_val);
+        }
+    }
+    else
+    {
+        controllers[aura_device - 1]->SetMode(mode_val);
+    }
+}
+
+
+void OpenAuraSDKDialog::OnBnClickedRadioOpenaurasdkEffectOff()
+{
+    setMode(AURA_MODE_OFF);
+}
+
+
+void OpenAuraSDKDialog::OnBnClickedRadioOpenaurasdkEffectStatic()
+{
+    setMode(AURA_MODE_STATIC);
+}
+
+
+void OpenAuraSDKDialog::OnBnClickedRadioOpenaurasdkEffectBreathing()
+{
+    setMode(AURA_MODE_BREATHING);
+}
+
+
+void OpenAuraSDKDialog::OnBnClickedRadioOpenaurasdkEffectFlashing()
+{
+    setMode(AURA_MODE_FLASHING);
+}
+
+
+void OpenAuraSDKDialog::OnBnClickedRadioOpenaurasdkEffectSpectrumCycle()
+{
+    setMode(AURA_MODE_SPECTRUM_CYCLE);
+}
+
+
+void OpenAuraSDKDialog::OnBnClickedRadioOpenaurasdkEffectRainbow()
+{
+    setMode(AURA_MODE_RAINBOW);
+}
+
+
+void OpenAuraSDKDialog::OnBnClickedRadioOpenaurasdkBreathingSpectrum()
+{
+    setMode(AURA_MODE_SPECTRUM_CYCLE_BREATHING);
+}
+
+
+void OpenAuraSDKDialog::OnBnClickedRadioOpenaurasdkEffectChaseFade()
+{
+    setMode(AURA_MODE_CHASE_FADE);
+}
+
+
+void OpenAuraSDKDialog::OnBnClickedButtonOpenaurasdkSetColors()
+{
+    unsigned int aura_device = ((CComboBox*)GetDlgItem(IDC_COMBO_OPENAURASDK_DEVICE))->GetCurSel();
+
+    if (aura_device == 0)
+    {
+        unsigned char direct = ((CButton*)GetDlgItem(IDC_RADIO_OPENAURASDK_DIRECT_MODE))->GetCheck();
+
+        if (direct == 0)
+        {
+            for (int i = 0; i < controllers.size(); i++)
+            {
+                controllers[i]->SetLEDColorEffect( 0,
+                                                    GetDlgItemInt(IDC_EDIT_OPENAURASDK_LED_0_R),
+                                                    GetDlgItemInt(IDC_EDIT_OPENAURASDK_LED_0_G),
+                                                    GetDlgItemInt(IDC_EDIT_OPENAURASDK_LED_0_B) );
+                controllers[i]->SetLEDColorEffect( 1,
+                                                    GetDlgItemInt(IDC_EDIT_OPENAURASDK_LED_1_R),
+                                                    GetDlgItemInt(IDC_EDIT_OPENAURASDK_LED_1_G),
+                                                    GetDlgItemInt(IDC_EDIT_OPENAURASDK_LED_1_B) );
+                controllers[i]->SetLEDColorEffect( 2,
+                                                    GetDlgItemInt(IDC_EDIT_OPENAURASDK_LED_2_R),
+                                                    GetDlgItemInt(IDC_EDIT_OPENAURASDK_LED_2_G),
+                                                    GetDlgItemInt(IDC_EDIT_OPENAURASDK_LED_2_B) );
+                controllers[i]->SetLEDColorEffect( 3,
+                                                    GetDlgItemInt(IDC_EDIT_OPENAURASDK_LED_3_R),
+                                                    GetDlgItemInt(IDC_EDIT_OPENAURASDK_LED_3_G),
+                                                    GetDlgItemInt(IDC_EDIT_OPENAURASDK_LED_3_B) );
+                controllers[i]->SetLEDColorEffect( 4,
+                                                    GetDlgItemInt(IDC_EDIT_OPENAURASDK_LED_4_R),
+                                                    GetDlgItemInt(IDC_EDIT_OPENAURASDK_LED_4_G),
+                                                    GetDlgItemInt(IDC_EDIT_OPENAURASDK_LED_4_B) );
+
+                controllers[i]->SetDirect(false);
+            }
+        }
+        else
+        {
+            for (int i = 0; i < controllers.size(); i++)
+            {
+                controllers[i]->SetLEDColorDirect( 0,
+                                                   GetDlgItemInt(IDC_EDIT_OPENAURASDK_LED_0_R),
+                                                   GetDlgItemInt(IDC_EDIT_OPENAURASDK_LED_0_G),
+                                                   GetDlgItemInt(IDC_EDIT_OPENAURASDK_LED_0_B) );
+                controllers[i]->SetLEDColorDirect( 1,
+                                                   GetDlgItemInt(IDC_EDIT_OPENAURASDK_LED_1_R),
+                                                   GetDlgItemInt(IDC_EDIT_OPENAURASDK_LED_1_G),
+                                                   GetDlgItemInt(IDC_EDIT_OPENAURASDK_LED_1_B) );
+                controllers[i]->SetLEDColorDirect( 2,
+                                                   GetDlgItemInt(IDC_EDIT_OPENAURASDK_LED_2_R),
+                                                   GetDlgItemInt(IDC_EDIT_OPENAURASDK_LED_2_G),
+                                                   GetDlgItemInt(IDC_EDIT_OPENAURASDK_LED_2_B) );
+                controllers[i]->SetLEDColorDirect( 3,
+                                                   GetDlgItemInt(IDC_EDIT_OPENAURASDK_LED_3_R),
+                                                   GetDlgItemInt(IDC_EDIT_OPENAURASDK_LED_3_G),
+                                                   GetDlgItemInt(IDC_EDIT_OPENAURASDK_LED_3_B) );
+                controllers[i]->SetLEDColorDirect( 4,
+                                                   GetDlgItemInt(IDC_EDIT_OPENAURASDK_LED_4_R),
+                                                   GetDlgItemInt(IDC_EDIT_OPENAURASDK_LED_4_G),
+                                                   GetDlgItemInt(IDC_EDIT_OPENAURASDK_LED_4_B) );
+
+                controllers[i]->SetDirect(true);
+            }
+        }
+    }
+    else
+    {
+        unsigned char direct = controllers[aura_device - 1]->AuraRegisterRead(AURA_REG_DIRECT);
+
+        if (direct == 0)
+        {
+            controllers[aura_device - 1]->SetLEDColorEffect( 0,
+                                                GetDlgItemInt(IDC_EDIT_OPENAURASDK_LED_0_R),
+                                                GetDlgItemInt(IDC_EDIT_OPENAURASDK_LED_0_G),
+                                                GetDlgItemInt(IDC_EDIT_OPENAURASDK_LED_0_B) );
+            controllers[aura_device - 1]->SetLEDColorEffect( 1,
+                                                GetDlgItemInt(IDC_EDIT_OPENAURASDK_LED_1_R),
+                                                GetDlgItemInt(IDC_EDIT_OPENAURASDK_LED_1_G),
+                                                GetDlgItemInt(IDC_EDIT_OPENAURASDK_LED_1_B) );
+            controllers[aura_device - 1]->SetLEDColorEffect( 2,
+                                                GetDlgItemInt(IDC_EDIT_OPENAURASDK_LED_2_R),
+                                                GetDlgItemInt(IDC_EDIT_OPENAURASDK_LED_2_G),
+                                                GetDlgItemInt(IDC_EDIT_OPENAURASDK_LED_2_B) );
+            controllers[aura_device - 1]->SetLEDColorEffect( 3,
+                                                GetDlgItemInt(IDC_EDIT_OPENAURASDK_LED_3_R),
+                                                GetDlgItemInt(IDC_EDIT_OPENAURASDK_LED_3_G),
+                                                GetDlgItemInt(IDC_EDIT_OPENAURASDK_LED_3_B) );
+            controllers[aura_device - 1]->SetLEDColorEffect( 4,
+                                                GetDlgItemInt(IDC_EDIT_OPENAURASDK_LED_4_R),
+                                                GetDlgItemInt(IDC_EDIT_OPENAURASDK_LED_4_G),
+                                                GetDlgItemInt(IDC_EDIT_OPENAURASDK_LED_4_B) );
+        }
+        else
+        {
+            controllers[aura_device - 1]->SetLEDColorDirect( 0,
+                                               GetDlgItemInt(IDC_EDIT_OPENAURASDK_LED_0_R),
+                                               GetDlgItemInt(IDC_EDIT_OPENAURASDK_LED_0_G),
+                                               GetDlgItemInt(IDC_EDIT_OPENAURASDK_LED_0_B) );
+            controllers[aura_device - 1]->SetLEDColorDirect( 1,
+                                               GetDlgItemInt(IDC_EDIT_OPENAURASDK_LED_1_R),
+                                               GetDlgItemInt(IDC_EDIT_OPENAURASDK_LED_1_G),
+                                               GetDlgItemInt(IDC_EDIT_OPENAURASDK_LED_1_B) );
+            controllers[aura_device - 1]->SetLEDColorDirect( 2,
+                                               GetDlgItemInt(IDC_EDIT_OPENAURASDK_LED_2_R),
+                                               GetDlgItemInt(IDC_EDIT_OPENAURASDK_LED_2_G),
+                                               GetDlgItemInt(IDC_EDIT_OPENAURASDK_LED_2_B) );
+            controllers[aura_device - 1]->SetLEDColorDirect( 3,
+                                               GetDlgItemInt(IDC_EDIT_OPENAURASDK_LED_3_R),
+                                               GetDlgItemInt(IDC_EDIT_OPENAURASDK_LED_3_G),
+                                               GetDlgItemInt(IDC_EDIT_OPENAURASDK_LED_3_B) );
+            controllers[aura_device - 1]->SetLEDColorDirect( 4,
+                                               GetDlgItemInt(IDC_EDIT_OPENAURASDK_LED_4_R),
+                                               GetDlgItemInt(IDC_EDIT_OPENAURASDK_LED_4_G),
+                                               GetDlgItemInt(IDC_EDIT_OPENAURASDK_LED_4_B) );
+        }
+    }
+
+}
+
+
+void OpenAuraSDKDialog::OnBnClickedButtonOpenaurasdkSetColorsAll()
+{
+    unsigned int aura_device = ((CComboBox*)GetDlgItem(IDC_COMBO_OPENAURASDK_DEVICE))->GetCurSel();
+
+    if (aura_device == 0)
+    {
+        unsigned char direct = ((CButton*)GetDlgItem(IDC_RADIO_OPENAURASDK_DIRECT_MODE))->GetCheck();
+
+        if (direct == 0)
+        {
+            for (int i = 0; i < controllers.size(); i++)
+            {
+                controllers[i]->SetAllColorsEffect(GetDlgItemInt(IDC_EDIT_OPENAURASDK_LED_0_R),
+                                                   GetDlgItemInt(IDC_EDIT_OPENAURASDK_LED_0_G),
+                                                   GetDlgItemInt(IDC_EDIT_OPENAURASDK_LED_0_B));
+
+                controllers[i]->SetDirect(false);
+            }
+        }
+        else
+        {
+            for (int i = 0; i < controllers.size(); i++)
+            {
+                controllers[i]->SetAllColorsDirect(GetDlgItemInt(IDC_EDIT_OPENAURASDK_LED_0_R),
+                                                   GetDlgItemInt(IDC_EDIT_OPENAURASDK_LED_0_G),
+                                                   GetDlgItemInt(IDC_EDIT_OPENAURASDK_LED_0_B));
+
+                controllers[i]->SetDirect(true);
+            }
+        }
+    }
+    else
+    {
+        unsigned char direct = controllers[aura_device - 1]->AuraRegisterRead(AURA_REG_DIRECT);
+
+        if (direct == 0)
+        {
+            controllers[aura_device - 1]->SetAllColorsEffect(GetDlgItemInt(IDC_EDIT_OPENAURASDK_LED_0_R),
+                                                    GetDlgItemInt(IDC_EDIT_OPENAURASDK_LED_0_G),
+                                                    GetDlgItemInt(IDC_EDIT_OPENAURASDK_LED_0_B));
+        }
+        else
+        {
+            controllers[aura_device - 1]->SetAllColorsDirect(GetDlgItemInt(IDC_EDIT_OPENAURASDK_LED_0_R),
+                                                             GetDlgItemInt(IDC_EDIT_OPENAURASDK_LED_0_G),
+                                                             GetDlgItemInt(IDC_EDIT_OPENAURASDK_LED_0_B));
+        }
+    }
+
+}
+
+
+void OpenAuraSDKDialog::OnCbnCloseupComboOpenaurasdkDevice()
+{
+    unsigned int aura_device = ((CComboBox*)GetDlgItem(IDC_COMBO_OPENAURASDK_DEVICE))->GetCurSel();
+    if (aura_device == 0)
+    {
+        /*((CButton*)GetDlgItem(IDC_RADIO_OPENAURASDK_DIRECT_MODE))->SetCheck(false);
+        ((CButton*)GetDlgItem(IDC_RADIO_OPENAURASDK_EFFECT_MODE))->SetCheck(false);
+
+        ((CButton*)GetDlgItem(IDC_RADIO_OPENAURASDK_EFFECT_OFF))->SetCheck(false);
+        ((CButton*)GetDlgItem(IDC_RADIO_OPENAURASDK_EFFECT_STATIC))->SetCheck(false);
+        ((CButton*)GetDlgItem(IDC_RADIO_OPENAURASDK_EFFECT_BREATHING))->SetCheck(false);
+        ((CButton*)GetDlgItem(IDC_RADIO_OPENAURASDK_EFFECT_FLASHING))->SetCheck(false);
+        ((CButton*)GetDlgItem(IDC_RADIO_OPENAURASDK_EFFECT_SPECTRUM_CYCLE))->SetCheck(false);
+        ((CButton*)GetDlgItem(IDC_RADIO_OPENAURASDK_EFFECT_RAINBOW))->SetCheck(false);
+        ((CButton*)GetDlgItem(IDC_RADIO_OPENAURASDK_BREATHING_SPECTRUM))->SetCheck(false);
+        ((CButton*)GetDlgItem(IDC_RADIO_OPENAURASDK_EFFECT_CHASE_FADE))->SetCheck(false);
+
+        SetDlgItemText(IDC_EDIT_OPENAURASDK_LED_0_R, "");
+        SetDlgItemText(IDC_EDIT_OPENAURASDK_LED_0_G, "");
+        SetDlgItemText(IDC_EDIT_OPENAURASDK_LED_0_B, "");
+        SetDlgItemText(IDC_EDIT_OPENAURASDK_LED_1_R, "");
+        SetDlgItemText(IDC_EDIT_OPENAURASDK_LED_1_G, "");
+        SetDlgItemText(IDC_EDIT_OPENAURASDK_LED_1_B, "");
+        SetDlgItemText(IDC_EDIT_OPENAURASDK_LED_2_R, "");
+        SetDlgItemText(IDC_EDIT_OPENAURASDK_LED_2_G, "");
+        SetDlgItemText(IDC_EDIT_OPENAURASDK_LED_2_B, "");
+        SetDlgItemText(IDC_EDIT_OPENAURASDK_LED_3_R, "");
+        SetDlgItemText(IDC_EDIT_OPENAURASDK_LED_3_G, "");
+        SetDlgItemText(IDC_EDIT_OPENAURASDK_LED_3_B, "");
+        SetDlgItemText(IDC_EDIT_OPENAURASDK_LED_4_R, "");
+        SetDlgItemText(IDC_EDIT_OPENAURASDK_LED_4_G, "");
+        SetDlgItemText(IDC_EDIT_OPENAURASDK_LED_4_B, "");*/
+
+    }
+    else
+    {
+        unsigned char direct = controllers[aura_device - 1]->AuraRegisterRead(AURA_REG_DIRECT);
+
+        ((CButton*)GetDlgItem(IDC_RADIO_OPENAURASDK_DIRECT_MODE))->SetCheck(direct != 0);
+        ((CButton*)GetDlgItem(IDC_RADIO_OPENAURASDK_EFFECT_MODE))->SetCheck(direct == 0);
+
+        unsigned char mode = controllers[aura_device - 1]->AuraRegisterRead(AURA_REG_MODE);
+
+        ((CButton*)GetDlgItem(IDC_RADIO_OPENAURASDK_EFFECT_OFF))->SetCheck(mode == AURA_MODE_OFF);
+        ((CButton*)GetDlgItem(IDC_RADIO_OPENAURASDK_EFFECT_STATIC))->SetCheck(mode == AURA_MODE_STATIC);
+        ((CButton*)GetDlgItem(IDC_RADIO_OPENAURASDK_EFFECT_BREATHING))->SetCheck(mode == AURA_MODE_BREATHING);
+        ((CButton*)GetDlgItem(IDC_RADIO_OPENAURASDK_EFFECT_FLASHING))->SetCheck(mode == AURA_MODE_FLASHING);
+        ((CButton*)GetDlgItem(IDC_RADIO_OPENAURASDK_EFFECT_SPECTRUM_CYCLE))->SetCheck(mode == AURA_MODE_SPECTRUM_CYCLE);
+        ((CButton*)GetDlgItem(IDC_RADIO_OPENAURASDK_EFFECT_RAINBOW))->SetCheck(mode == AURA_MODE_RAINBOW);
+        ((CButton*)GetDlgItem(IDC_RADIO_OPENAURASDK_BREATHING_SPECTRUM))->SetCheck(mode == AURA_MODE_SPECTRUM_CYCLE_BREATHING);
+        ((CButton*)GetDlgItem(IDC_RADIO_OPENAURASDK_EFFECT_CHASE_FADE))->SetCheck(mode == AURA_MODE_CHASE_FADE);
+
+        if (direct == 0)
+        {
+            SetDlgItemInt(IDC_EDIT_OPENAURASDK_LED_0_R, controllers[aura_device - 1]->AuraRegisterRead(AURA_REG_COLORS_EFFECT + 0));
+            SetDlgItemInt(IDC_EDIT_OPENAURASDK_LED_0_G, controllers[aura_device - 1]->AuraRegisterRead(AURA_REG_COLORS_EFFECT + 2));
+            SetDlgItemInt(IDC_EDIT_OPENAURASDK_LED_0_B, controllers[aura_device - 1]->AuraRegisterRead(AURA_REG_COLORS_EFFECT + 1));
+            SetDlgItemInt(IDC_EDIT_OPENAURASDK_LED_1_R, controllers[aura_device - 1]->AuraRegisterRead(AURA_REG_COLORS_EFFECT + 3));
+            SetDlgItemInt(IDC_EDIT_OPENAURASDK_LED_1_G, controllers[aura_device - 1]->AuraRegisterRead(AURA_REG_COLORS_EFFECT + 5));
+            SetDlgItemInt(IDC_EDIT_OPENAURASDK_LED_1_B, controllers[aura_device - 1]->AuraRegisterRead(AURA_REG_COLORS_EFFECT + 4));
+            SetDlgItemInt(IDC_EDIT_OPENAURASDK_LED_2_R, controllers[aura_device - 1]->AuraRegisterRead(AURA_REG_COLORS_EFFECT + 6));
+            SetDlgItemInt(IDC_EDIT_OPENAURASDK_LED_2_G, controllers[aura_device - 1]->AuraRegisterRead(AURA_REG_COLORS_EFFECT + 8));
+            SetDlgItemInt(IDC_EDIT_OPENAURASDK_LED_2_B, controllers[aura_device - 1]->AuraRegisterRead(AURA_REG_COLORS_EFFECT + 7));
+            SetDlgItemInt(IDC_EDIT_OPENAURASDK_LED_3_R, controllers[aura_device - 1]->AuraRegisterRead(AURA_REG_COLORS_EFFECT + 9));
+            SetDlgItemInt(IDC_EDIT_OPENAURASDK_LED_3_G, controllers[aura_device - 1]->AuraRegisterRead(AURA_REG_COLORS_EFFECT + 11));
+            SetDlgItemInt(IDC_EDIT_OPENAURASDK_LED_3_B, controllers[aura_device - 1]->AuraRegisterRead(AURA_REG_COLORS_EFFECT + 10));
+            SetDlgItemInt(IDC_EDIT_OPENAURASDK_LED_4_R, controllers[aura_device - 1]->AuraRegisterRead(AURA_REG_COLORS_EFFECT + 12));
+            SetDlgItemInt(IDC_EDIT_OPENAURASDK_LED_4_G, controllers[aura_device - 1]->AuraRegisterRead(AURA_REG_COLORS_EFFECT + 14));
+            SetDlgItemInt(IDC_EDIT_OPENAURASDK_LED_4_B, controllers[aura_device - 1]->AuraRegisterRead(AURA_REG_COLORS_EFFECT + 13));
+        }
+        else
+        {
+            SetDlgItemInt(IDC_EDIT_OPENAURASDK_LED_0_R, controllers[aura_device - 1]->AuraRegisterRead(AURA_REG_COLORS_DIRECT + 0));
+            SetDlgItemInt(IDC_EDIT_OPENAURASDK_LED_0_G, controllers[aura_device - 1]->AuraRegisterRead(AURA_REG_COLORS_DIRECT + 2));
+            SetDlgItemInt(IDC_EDIT_OPENAURASDK_LED_0_B, controllers[aura_device - 1]->AuraRegisterRead(AURA_REG_COLORS_DIRECT + 1));
+            SetDlgItemInt(IDC_EDIT_OPENAURASDK_LED_1_R, controllers[aura_device - 1]->AuraRegisterRead(AURA_REG_COLORS_DIRECT + 3));
+            SetDlgItemInt(IDC_EDIT_OPENAURASDK_LED_1_G, controllers[aura_device - 1]->AuraRegisterRead(AURA_REG_COLORS_DIRECT + 5));
+            SetDlgItemInt(IDC_EDIT_OPENAURASDK_LED_1_B, controllers[aura_device - 1]->AuraRegisterRead(AURA_REG_COLORS_DIRECT + 4));
+            SetDlgItemInt(IDC_EDIT_OPENAURASDK_LED_2_R, controllers[aura_device - 1]->AuraRegisterRead(AURA_REG_COLORS_DIRECT + 6));
+            SetDlgItemInt(IDC_EDIT_OPENAURASDK_LED_2_G, controllers[aura_device - 1]->AuraRegisterRead(AURA_REG_COLORS_DIRECT + 8));
+            SetDlgItemInt(IDC_EDIT_OPENAURASDK_LED_2_B, controllers[aura_device - 1]->AuraRegisterRead(AURA_REG_COLORS_DIRECT + 7));
+            SetDlgItemInt(IDC_EDIT_OPENAURASDK_LED_3_R, controllers[aura_device - 1]->AuraRegisterRead(AURA_REG_COLORS_DIRECT + 9));
+            SetDlgItemInt(IDC_EDIT_OPENAURASDK_LED_3_G, controllers[aura_device - 1]->AuraRegisterRead(AURA_REG_COLORS_DIRECT + 11));
+            SetDlgItemInt(IDC_EDIT_OPENAURASDK_LED_3_B, controllers[aura_device - 1]->AuraRegisterRead(AURA_REG_COLORS_DIRECT + 10));
+            SetDlgItemInt(IDC_EDIT_OPENAURASDK_LED_4_R, controllers[aura_device - 1]->AuraRegisterRead(AURA_REG_COLORS_DIRECT + 12));
+            SetDlgItemInt(IDC_EDIT_OPENAURASDK_LED_4_G, controllers[aura_device - 1]->AuraRegisterRead(AURA_REG_COLORS_DIRECT + 14));
+            SetDlgItemInt(IDC_EDIT_OPENAURASDK_LED_4_B, controllers[aura_device - 1]->AuraRegisterRead(AURA_REG_COLORS_DIRECT + 13));
+        }
+    }
+
+}
+
+void OpenAuraSDKDialog::OnBnClickedButtonOpenaurasdkDump()
+{
+    unsigned int aura_device = ((CComboBox*)GetDlgItem(IDC_COMBO_OPENAURASDK_DEVICE))->GetCurSel();
+
+    if (aura_device > 0)
+    {
+        ((CButton*)GetDlgItem(IDC_BUTTON_OPENAURASDK_DUMP))->EnableWindow(false);
+        DumpAuraRegisters(controllers[aura_device - 1]);
+        ((CButton*)GetDlgItem(IDC_BUTTON_OPENAURASDK_DUMP))->EnableWindow(true);
+    }
+}

OpenAuraSDK/OpenAuraSDKDialog.h

@@ -0,0 +1,46 @@
+#ifndef OPENAURASDK_DIALOG_H
+#define OPENAURASDK_DIALOG_H
+
+#include <afxdialogex.h>
+#include <vector>
+#include "i2c_smbus.h"
+#include "AuraController.h"
+#include "resource.h"
+
+class OpenAuraSDKDialog : public CDialogEx
+{
+    DECLARE_DYNAMIC(OpenAuraSDKDialog)
+
+public:
+    OpenAuraSDKDialog(std::vector<i2c_smbus_interface *>& bus, std::vector<AuraController *>& control, CWnd* pParent = NULL);
+    virtual ~OpenAuraSDKDialog();
+    virtual BOOL OnInitDialog();
+
+private:
+    void setMode(unsigned char mode_val);
+
+protected:
+    std::vector<i2c_smbus_interface *>& busses;
+    std::vector<AuraController *>& controllers;
+    virtual void DoDataExchange(CDataExchange* pDX);
+    DECLARE_MESSAGE_MAP()
+
+public:
+    afx_msg void OnBnClickedButtonOpenaurasdkI2cdetect();
+    afx_msg void OnBnClickedRadioOpenaurasdkDirectMode();
+    afx_msg void OnBnClickedRadioOpenaurasdkEffectMode();
+    afx_msg void OnBnClickedRadioOpenaurasdkEffectOff();
+    afx_msg void OnBnClickedRadioOpenaurasdkEffectStatic();
+    afx_msg void OnBnClickedRadioOpenaurasdkEffectBreathing();
+    afx_msg void OnBnClickedRadioOpenaurasdkEffectFlashing();
+    afx_msg void OnBnClickedRadioOpenaurasdkEffectSpectrumCycle();
+    afx_msg void OnBnClickedRadioOpenaurasdkEffectRainbow();
+    afx_msg void OnBnClickedRadioOpenaurasdkBreathingSpectrum();
+    afx_msg void OnBnClickedRadioOpenaurasdkEffectChaseFade();
+    afx_msg void OnBnClickedButtonOpenaurasdkSetColors();
+    afx_msg void OnCbnCloseupComboOpenaurasdkDevice();
+    afx_msg void OnBnClickedButtonOpenaurasdkSetColorsAll();
+    afx_msg void OnBnClickedButtonOpenaurasdkDump();
+};
+
+#endif

OpenAuraSDK/OpenAuraSDKQtDialog.cpp

@@ -0,0 +1,356 @@
+#include "OpenAuraSDKQtDialog.h"
+#include "OpenAuraSDK.h"
+
+using namespace Ui;
+
+OpenAuraSDKQtDialog::OpenAuraSDKQtDialog(std::vector<i2c_smbus_interface *>& bus, std::vector<AuraController *>& control, QWidget *parent) : QMainWindow(parent), busses(bus), controllers (control), ui(new OpenAuraSDKQtDialogUi)
+{
+    ui->setupUi(this);
+
+    ui->ComboAuraDevices->addItem("All Devices");
+
+    for (int i = 0; i < controllers.size(); i++)
+    {
+        ui->ComboAuraDevices->addItem(controllers[i]->GetDeviceName());
+    }
+
+    ui->ComboAuraDevices->setCurrentIndex(0);
+}
+
+OpenAuraSDKQtDialog::~OpenAuraSDKQtDialog()
+{
+    delete ui;
+}
+
+void OpenAuraSDKQtDialog::show()
+{
+    QMainWindow::show();
+}
+
+void Ui::OpenAuraSDKQtDialog::on_ButtonSetAll_clicked()
+{
+    unsigned int aura_device = ui->ComboAuraDevices->currentIndex();
+
+    if (aura_device == 0)
+    {
+        unsigned char direct = ui->RadioDirect->isChecked();
+
+        if (direct == 0)
+        {
+            for (int i = 0; i < controllers.size(); i++)
+            {
+                controllers[i]->SetAllColorsEffect(ui->EditLED0R->text().toInt(),
+                                                   ui->EditLED0G->text().toInt(),
+                                                   ui->EditLED0B->text().toInt());
+
+                controllers[i]->SetDirect(false);
+            }
+        }
+        else
+        {
+            for (int i = 0; i < controllers.size(); i++)
+            {
+                controllers[i]->SetAllColorsDirect(ui->EditLED0R->text().toInt(),
+                                                   ui->EditLED0G->text().toInt(),
+                                                   ui->EditLED0B->text().toInt());
+
+                controllers[i]->SetDirect(true);
+            }
+        }
+    }
+    else
+    {
+        unsigned char direct = controllers[aura_device - 1]->AuraRegisterRead(AURA_REG_DIRECT);
+
+        if (direct == 0)
+        {
+            controllers[aura_device - 1]->SetAllColorsEffect(ui->EditLED0R->text().toInt(),
+                                                             ui->EditLED0G->text().toInt(),
+                                                             ui->EditLED0B->text().toInt());
+        }
+        else
+        {
+            controllers[aura_device - 1]->SetAllColorsDirect(ui->EditLED0R->text().toInt(),
+                                                             ui->EditLED0G->text().toInt(),
+                                                             ui->EditLED0B->text().toInt());
+        }
+    }
+}
+
+void Ui::OpenAuraSDKQtDialog::on_ButtonSetColors_clicked()
+{
+    unsigned int aura_device = ui->ComboAuraDevices->currentIndex();
+
+    if (aura_device == 0)
+    {
+        unsigned char direct = ui->RadioDirect->isChecked();
+
+        if (direct == 0)
+        {
+            for (int i = 0; i < controllers.size(); i++)
+            {
+                controllers[i]->SetLEDColorEffect( 0,
+                                                   ui->EditLED0R->text().toInt(),
+                                                   ui->EditLED0G->text().toInt(),
+                                                   ui->EditLED0B->text().toInt() );
+                controllers[i]->SetLEDColorEffect( 1,
+                                                   ui->EditLED1R->text().toInt(),
+                                                   ui->EditLED1G->text().toInt(),
+                                                   ui->EditLED1B->text().toInt() );
+                controllers[i]->SetLEDColorEffect( 2,
+                                                   ui->EditLED2R->text().toInt(),
+                                                   ui->EditLED2G->text().toInt(),
+                                                   ui->EditLED2B->text().toInt() );
+                controllers[i]->SetLEDColorEffect( 3,
+                                                   ui->EditLED3R->text().toInt(),
+                                                   ui->EditLED3G->text().toInt(),
+                                                   ui->EditLED3B->text().toInt() );
+                controllers[i]->SetLEDColorEffect( 4,
+                                                   ui->EditLED4R->text().toInt(),
+                                                   ui->EditLED4G->text().toInt(),
+                                                   ui->EditLED4B->text().toInt() );
+
+                controllers[i]->SetDirect(false);
+            }
+        }
+        else
+        {
+            for (int i = 0; i < controllers.size(); i++)
+            {
+                controllers[i]->SetLEDColorDirect( 0,
+                                                   ui->EditLED0R->text().toInt(),
+                                                   ui->EditLED0G->text().toInt(),
+                                                   ui->EditLED0B->text().toInt() );
+                controllers[i]->SetLEDColorDirect( 1,
+                                                   ui->EditLED1R->text().toInt(),
+                                                   ui->EditLED1G->text().toInt(),
+                                                   ui->EditLED1B->text().toInt() );
+                controllers[i]->SetLEDColorDirect( 2,
+                                                   ui->EditLED2R->text().toInt(),
+                                                   ui->EditLED2G->text().toInt(),
+                                                   ui->EditLED2B->text().toInt() );
+                controllers[i]->SetLEDColorDirect( 3,
+                                                   ui->EditLED3R->text().toInt(),
+                                                   ui->EditLED3G->text().toInt(),
+                                                   ui->EditLED3B->text().toInt() );
+                controllers[i]->SetLEDColorDirect( 4,
+                                                   ui->EditLED4R->text().toInt(),
+                                                   ui->EditLED4G->text().toInt(),
+                                                   ui->EditLED4B->text().toInt() );
+
+                controllers[i]->SetDirect(true);
+            }
+        }
+    }
+    else
+    {
+        unsigned char direct = controllers[aura_device - 1]->AuraRegisterRead(AURA_REG_DIRECT);
+
+        if (direct == 0)
+        {
+            controllers[aura_device - 1]->SetLEDColorEffect( 0,
+                                               ui->EditLED0R->text().toInt(),
+                                               ui->EditLED0G->text().toInt(),
+                                               ui->EditLED0B->text().toInt() );
+            controllers[aura_device - 1]->SetLEDColorEffect( 1,
+                                               ui->EditLED1R->text().toInt(),
+                                               ui->EditLED1G->text().toInt(),
+                                               ui->EditLED1B->text().toInt() );
+            controllers[aura_device - 1]->SetLEDColorEffect( 2,
+                                               ui->EditLED2R->text().toInt(),
+                                               ui->EditLED2G->text().toInt(),
+                                               ui->EditLED2B->text().toInt() );
+            controllers[aura_device - 1]->SetLEDColorEffect( 3,
+                                               ui->EditLED3R->text().toInt(),
+                                               ui->EditLED3G->text().toInt(),
+                                               ui->EditLED3B->text().toInt() );
+            controllers[aura_device - 1]->SetLEDColorEffect( 4,
+                                               ui->EditLED4R->text().toInt(),
+                                               ui->EditLED4G->text().toInt(),
+                                               ui->EditLED4B->text().toInt() );
+        }
+        else
+        {
+            controllers[aura_device - 1]->SetLEDColorDirect( 0,
+                                               ui->EditLED0R->text().toInt(),
+                                               ui->EditLED0G->text().toInt(),
+                                               ui->EditLED0B->text().toInt() );
+            controllers[aura_device - 1]->SetLEDColorDirect( 1,
+                                               ui->EditLED1R->text().toInt(),
+                                               ui->EditLED1G->text().toInt(),
+                                               ui->EditLED1B->text().toInt() );
+            controllers[aura_device - 1]->SetLEDColorDirect( 2,
+                                               ui->EditLED2R->text().toInt(),
+                                               ui->EditLED2G->text().toInt(),
+                                               ui->EditLED2B->text().toInt() );
+            controllers[aura_device - 1]->SetLEDColorDirect( 3,
+                                               ui->EditLED3R->text().toInt(),
+                                               ui->EditLED3G->text().toInt(),
+                                               ui->EditLED3B->text().toInt() );
+            controllers[aura_device - 1]->SetLEDColorDirect( 4,
+                                               ui->EditLED4R->text().toInt(),
+                                               ui->EditLED4G->text().toInt(),
+                                               ui->EditLED4B->text().toInt() );
+        }
+    }
+}
+
+void Ui::OpenAuraSDKQtDialog::on_RadioDirect_clicked()
+{
+    unsigned int aura_device = ui->ComboAuraDevices->currentIndex();
+    if ( aura_device == 0)
+    {
+        for (int i = 0; i < controllers.size(); i++)
+        {
+            controllers[i]->SetDirect(true);
+        }
+    }
+    else
+    {
+        controllers[aura_device - 1]->SetDirect(true);
+    }
+}
+
+void Ui::OpenAuraSDKQtDialog::on_RadioEffect_clicked()
+{
+    unsigned int aura_device = ui->ComboAuraDevices->currentIndex();
+    if (aura_device == 0)
+    {
+        for (int i = 0; i < controllers.size(); i++)
+        {
+            controllers[i]->SetDirect(false);
+        }
+    }
+    else
+    {
+        controllers[aura_device - 1]->SetDirect(false);
+    }
+}
+
+void Ui::OpenAuraSDKQtDialog::on_ComboAuraDevices_currentIndexChanged(int aura_device)
+{
+    if (aura_device != 0)
+    {
+        unsigned char direct = controllers[aura_device - 1]->AuraRegisterRead(AURA_REG_DIRECT);
+
+        ui->RadioDirect->setChecked(direct != 0);
+        ui->RadioEffect->setChecked(direct == 0);
+
+        unsigned char mode = controllers[aura_device - 1]->AuraRegisterRead(AURA_REG_MODE);
+
+        ui->RadioOff->setChecked(mode == AURA_MODE_OFF);
+        ui->RadioStatic->setChecked(mode == AURA_MODE_STATIC);
+        ui->RadioBreathing->setChecked(mode == AURA_MODE_BREATHING);
+        ui->RadioFlashing->setChecked(mode == AURA_MODE_FLASHING);
+        ui->RadioSpectrumCycle->setChecked(mode == AURA_MODE_SPECTRUM_CYCLE);
+        ui->RadioRainbow->setChecked(mode == AURA_MODE_RAINBOW);
+        ui->RadioBreathingSpectrum->setChecked(mode == AURA_MODE_SPECTRUM_CYCLE_BREATHING);
+        ui->RadioChaseFade->setChecked(mode == AURA_MODE_CHASE_FADE);
+
+        if (direct == 0)
+        {
+            ui->EditLED0R->setText(QString::number(controllers[aura_device - 1]->AuraRegisterRead(AURA_REG_COLORS_EFFECT + 0)));
+            ui->EditLED0B->setText(QString::number(controllers[aura_device - 1]->AuraRegisterRead(AURA_REG_COLORS_EFFECT + 1)));
+            ui->EditLED0G->setText(QString::number(controllers[aura_device - 1]->AuraRegisterRead(AURA_REG_COLORS_EFFECT + 2)));
+            ui->EditLED1R->setText(QString::number(controllers[aura_device - 1]->AuraRegisterRead(AURA_REG_COLORS_EFFECT + 3)));
+            ui->EditLED1B->setText(QString::number(controllers[aura_device - 1]->AuraRegisterRead(AURA_REG_COLORS_EFFECT + 4)));
+            ui->EditLED1G->setText(QString::number(controllers[aura_device - 1]->AuraRegisterRead(AURA_REG_COLORS_EFFECT + 5)));
+            ui->EditLED2R->setText(QString::number(controllers[aura_device - 1]->AuraRegisterRead(AURA_REG_COLORS_EFFECT + 6)));
+            ui->EditLED2B->setText(QString::number(controllers[aura_device - 1]->AuraRegisterRead(AURA_REG_COLORS_EFFECT + 7)));
+            ui->EditLED2G->setText(QString::number(controllers[aura_device - 1]->AuraRegisterRead(AURA_REG_COLORS_EFFECT + 8)));
+            ui->EditLED3R->setText(QString::number(controllers[aura_device - 1]->AuraRegisterRead(AURA_REG_COLORS_EFFECT + 9)));
+            ui->EditLED3B->setText(QString::number(controllers[aura_device - 1]->AuraRegisterRead(AURA_REG_COLORS_EFFECT + 10)));
+            ui->EditLED3G->setText(QString::number(controllers[aura_device - 1]->AuraRegisterRead(AURA_REG_COLORS_EFFECT + 11)));
+            ui->EditLED4R->setText(QString::number(controllers[aura_device - 1]->AuraRegisterRead(AURA_REG_COLORS_EFFECT + 12)));
+            ui->EditLED4B->setText(QString::number(controllers[aura_device - 1]->AuraRegisterRead(AURA_REG_COLORS_EFFECT + 13)));
+            ui->EditLED4G->setText(QString::number(controllers[aura_device - 1]->AuraRegisterRead(AURA_REG_COLORS_EFFECT + 14)));
+        }
+        else
+        {
+            ui->EditLED0R->setText(QString::number(controllers[aura_device - 1]->AuraRegisterRead(AURA_REG_COLORS_DIRECT + 0)));
+            ui->EditLED0B->setText(QString::number(controllers[aura_device - 1]->AuraRegisterRead(AURA_REG_COLORS_DIRECT + 1)));
+            ui->EditLED0G->setText(QString::number(controllers[aura_device - 1]->AuraRegisterRead(AURA_REG_COLORS_DIRECT + 2)));
+            ui->EditLED1R->setText(QString::number(controllers[aura_device - 1]->AuraRegisterRead(AURA_REG_COLORS_DIRECT + 3)));
+            ui->EditLED1B->setText(QString::number(controllers[aura_device - 1]->AuraRegisterRead(AURA_REG_COLORS_DIRECT + 4)));
+            ui->EditLED1G->setText(QString::number(controllers[aura_device - 1]->AuraRegisterRead(AURA_REG_COLORS_DIRECT + 5)));
+            ui->EditLED2R->setText(QString::number(controllers[aura_device - 1]->AuraRegisterRead(AURA_REG_COLORS_DIRECT + 6)));
+            ui->EditLED2B->setText(QString::number(controllers[aura_device - 1]->AuraRegisterRead(AURA_REG_COLORS_DIRECT + 7)));
+            ui->EditLED2G->setText(QString::number(controllers[aura_device - 1]->AuraRegisterRead(AURA_REG_COLORS_DIRECT + 8)));
+            ui->EditLED3R->setText(QString::number(controllers[aura_device - 1]->AuraRegisterRead(AURA_REG_COLORS_DIRECT + 9)));
+            ui->EditLED3B->setText(QString::number(controllers[aura_device - 1]->AuraRegisterRead(AURA_REG_COLORS_DIRECT + 10)));
+            ui->EditLED3G->setText(QString::number(controllers[aura_device - 1]->AuraRegisterRead(AURA_REG_COLORS_DIRECT + 11)));
+            ui->EditLED4R->setText(QString::number(controllers[aura_device - 1]->AuraRegisterRead(AURA_REG_COLORS_DIRECT + 12)));
+            ui->EditLED4B->setText(QString::number(controllers[aura_device - 1]->AuraRegisterRead(AURA_REG_COLORS_DIRECT + 13)));
+            ui->EditLED4G->setText(QString::number(controllers[aura_device - 1]->AuraRegisterRead(AURA_REG_COLORS_DIRECT + 14)));
+        }
+    }
+}
+
+void OpenAuraSDKQtDialog::setMode(unsigned char mode_val)
+{
+    unsigned int aura_device = ui->ComboAuraDevices->currentIndex();
+
+    if (aura_device == 0)
+    {
+        for (int i = 0; i < controllers.size(); i++)
+        {
+            controllers[i]->SetMode(mode_val);
+        }
+    }
+    else
+    {
+        controllers[aura_device - 1]->SetMode(mode_val);
+    }
+}
+
+void Ui::OpenAuraSDKQtDialog::on_RadioOff_clicked()
+{
+    setMode(AURA_MODE_OFF);
+}
+
+void Ui::OpenAuraSDKQtDialog::on_RadioStatic_clicked()
+{
+    setMode(AURA_MODE_STATIC);
+}
+
+void Ui::OpenAuraSDKQtDialog::on_RadioBreathing_clicked()
+{
+    setMode(AURA_MODE_BREATHING);
+}
+
+void Ui::OpenAuraSDKQtDialog::on_RadioFlashing_clicked()
+{
+    setMode(AURA_MODE_FLASHING);
+}
+
+void Ui::OpenAuraSDKQtDialog::on_RadioSpectrumCycle_clicked()
+{
+    setMode(AURA_MODE_SPECTRUM_CYCLE);
+}
+
+void Ui::OpenAuraSDKQtDialog::on_RadioRainbow_clicked()
+{
+    setMode(AURA_MODE_RAINBOW);
+}
+
+void Ui::OpenAuraSDKQtDialog::on_RadioBreathingSpectrum_clicked()
+{
+    setMode(AURA_MODE_SPECTRUM_CYCLE_BREATHING);
+}
+
+void Ui::OpenAuraSDKQtDialog::on_RadioChaseFade_clicked()
+{
+    setMode(AURA_MODE_CHASE_FADE);
+}
+
+void Ui::OpenAuraSDKQtDialog::on_ButtonDumpAura_clicked()
+{
+    unsigned int aura_device = ui->ComboAuraDevices->currentIndex();
+
+    if (aura_device > 0)
+    {
+        ui->ButtonDumpAura->setEnabled(false);
+        DumpAuraRegisters(controllers[aura_device - 1]);
+        ui->ButtonDumpAura->setEnabled(true);
+    }
+}

OpenAuraSDK/OpenAuraSDKQtDialog.h

@@ -0,0 +1,68 @@
+#ifndef OPENAURASDKQTDIALOG_H
+#define OPENAURASDKQTDIALOG_H
+
+#include "ui_openaurasdk.h"
+
+#include <vector>
+#include "i2c_smbus.h"
+#include "AuraController.h"
+
+#include <QMainWindow>
+#include <QTimer>
+#include <QSystemTrayIcon>
+#include <QMenu>
+
+namespace Ui
+{
+    class OpenAuraSDKQtDialog;
+}
+
+class Ui::OpenAuraSDKQtDialog : public QMainWindow
+{
+    Q_OBJECT
+
+public:
+    explicit OpenAuraSDKQtDialog(std::vector<i2c_smbus_interface *>& bus, std::vector<AuraController *>& control, QWidget *parent = 0);
+    ~OpenAuraSDKQtDialog();
+
+    void show();
+    void setMode(unsigned char mode_val);
+
+protected:
+    std::vector<i2c_smbus_interface *>& busses;
+    std::vector<AuraController *>& controllers;
+
+private slots:
+    void on_ButtonSetAll_clicked();
+
+    void on_ButtonSetColors_clicked();
+
+    void on_RadioDirect_clicked();
+
+    void on_RadioEffect_clicked();
+
+    void on_ComboAuraDevices_currentIndexChanged(int index);
+
+    void on_RadioOff_clicked();
+
+    void on_RadioStatic_clicked();
+
+    void on_RadioBreathing_clicked();
+
+    void on_RadioFlashing_clicked();
+
+    void on_RadioSpectrumCycle_clicked();
+
+    void on_RadioRainbow_clicked();
+
+    void on_RadioBreathingSpectrum_clicked();
+
+    void on_RadioChaseFade_clicked();
+
+    void on_ButtonDumpAura_clicked();
+
+private:
+    Ui::OpenAuraSDKQtDialogUi *ui;
+};
+
+#endif // OPENAURASDKQTDIALOG_H

OpenAuraSDK/i2c_smbus.h

@@ -54,8 +54,6 @@ class i2c_smbus_interface
 public:
     char device_name[512];
 
-    virtual ~i2c_smbus_interface() = default;
-
     //Functions derived from i2c-core.c
     s32 i2c_smbus_write_quick(u8 addr, u8 value);
     s32 i2c_smbus_read_byte(u8 addr);

OpenAuraSDK/i2c_smbus_i801.cpp

@@ -12,6 +12,8 @@
 #include <Windows.h>
 #include "inpout32.h"
 
+#pragma comment(lib, "inpout32.lib")
+
 /* Return negative errno on error. */
 s32 i2c_smbus_i801::i801_access(u16 addr, char read_write, u8 command, int size, i2c_smbus_data *data)
 {
@@ -478,4 +480,4 @@ int i2c_smbus_i801::i801_wait_intr()
 s32 i2c_smbus_i801::i2c_smbus_xfer(u8 addr, char read_write, u8 command, int size, i2c_smbus_data* data)
 {
     return i801_access(addr, read_write, command, size, data);
-}
+}

OpenAuraSDK/i2c_smbus_nuvoton_nct6793d.cpp

@@ -1,45 +1,40 @@
 /*-----------------------------------------*\
-|  i2c_smbus_nct6775.cpp                    |
+|  i2c_smbus_nuvoton_nct6793d.cpp           |
 |                                           |
-|  Nuvoton NCT67xx SMBUS driver for Windows |
+|  Nuvoton NCT6793D SMBUS driver for Windows|
 |                                           |
 |  Adam Honse (CalcProgrammer1) 5/19/2019   |
 \*-----------------------------------------*/
 
-#include "i2c_smbus_nct6775.h"
+#include "i2c_smbus_nuvoton_nct6793d.h"
 #include <Windows.h>
 #include "inpout32.h"
 
-s32 i2c_smbus_nct6775::nct6775_access(u16 addr, char read_write, u8 command, int size, i2c_smbus_data *data)
+#pragma comment(lib, "inpout32.lib")
+
+s32 i2c_smbus_nuvoton_nct6793d::nct6793d_access(u16 addr, char read_write, u8 command, int size, i2c_smbus_data *data)
 {
     int i, len, status, cnt;
-    i2c_smbus_data tmp_data;
-    int timeout = 0;
 
-    tmp_data.word = 0;
-    cnt = 0;
-    len = 0;
-
-    Out32(SMBHSTCTL, NCT6775_SOFT_RESET);
+    Out32(SMBHSTCTL, NCT6793D_SOFT_RESET);
 
     switch (size)
     {
     case I2C_SMBUS_QUICK:
         Out32(SMBHSTADD, (addr << 1) | read_write);
         break;
+	case I2C_SMBUS_BYTE:
     case I2C_SMBUS_BYTE_DATA:
-        tmp_data.byte = data->byte;
-    case I2C_SMBUS_BYTE:
         Out32(SMBHSTADD, (addr << 1) | read_write);
         Out32(SMBHSTIDX, command);
         if (read_write == I2C_SMBUS_WRITE)
         {
-            Out32(SMBHSTDAT, tmp_data.byte);
-            Out32(SMBHSTCMD, NCT6775_WRITE_BYTE);
+            Out32(SMBHSTDAT, data->byte);
+            Out32(SMBHSTCMD, NCT6793D_WRITE_BYTE);
         }
         else
         {
-            Out32(SMBHSTCMD, NCT6775_READ_BYTE);
+            Out32(SMBHSTCMD, NCT6793D_READ_BYTE);
         }
         break;
     case I2C_SMBUS_WORD_DATA:
@@ -49,11 +44,11 @@ s32 i2c_smbus_nct6775::nct6775_access(u16 addr, char read_write, u8 command, int
         {
 			Out32(SMBHSTDAT, data->word & 0xFF);
 			Out32(SMBHSTDAT, (data->word & 0xFF00) >> 8);
-            Out32(SMBHSTCMD, NCT6775_WRITE_WORD);
+            Out32(SMBHSTCMD, NCT6793D_WRITE_WORD);
         }
         else
         {
-            Out32(SMBHSTCMD, NCT6775_READ_WORD);
+            Out32(SMBHSTCMD, NCT6793D_READ_WORD);
         }
         break;
     case I2C_SMBUS_BLOCK_DATA:
@@ -90,34 +85,25 @@ s32 i2c_smbus_nct6775::nct6775_access(u16 addr, char read_write, u8 command, int
 				len = 0;
 			}
             
-            Out32(SMBHSTCMD, NCT6775_WRITE_BLOCK);
+            Out32(SMBHSTCMD, NCT6793D_WRITE_BLOCK);
         }
         else
         {
             return -EOPNOTSUPP;
-            //Out32(SMBHSTCMD, NCT6775_READ_BLOCK);
+            //Out32(SMBHSTCMD, NCT6793D_READ_BLOCK);
         }
         break;
     default:
         return -EOPNOTSUPP;
     }
 
-    Out32(SMBHSTCTL, NCT6775_MANUAL_START);
+    Out32(SMBHSTCTL, NCT6793D_MANUAL_START);
 
 	while ((size == I2C_SMBUS_BLOCK_DATA) && (len > 0))
 	{
 		if (read_write == I2C_SMBUS_WRITE)
 		{
-            timeout = 0;
-            while ((Inp32(SMBHSTSTS) & NCT6775_FIFO_EMPTY) == 0)
-            {
-                if(timeout > NCT6775_MAX_RETRIES)
-                {
-                    return -ETIMEDOUT;
-                }
-                Sleep(1);
-                timeout++;
-            }
+			while ((Inp32(SMBHSTSTS) & NCT6793D_FIFO_EMPTY) == 0);
 
 			//Load more bytes into FIFO
 			if (len >= 4)
@@ -140,25 +126,12 @@ s32 i2c_smbus_nct6775::nct6775_access(u16 addr, char read_write, u8 command, int
 				len = 0;
 			}
 		}
-        else
-        {
-            return -ENOTSUP;
-        }
 	}
 
 	//wait for manual mode to complete
-    timeout = 0;
-    while ((Inp32(SMBHSTSTS) & NCT6775_MANUAL_ACTIVE) != 0)
-    {
-        if(timeout > NCT6775_MAX_RETRIES)
-        {
-            return -ETIMEDOUT;
-        }
-        Sleep(1);
-        timeout++;
-    }
+	while ((Inp32(SMBHSTSTS) & NCT6793D_MANUAL_ACTIVE) != 0);
 
-	if ((Inp32(SMBHSTERR) & NCT6775_NO_ACK) != 0)
+	if ((Inp32(SMBHSTERR) & NCT6793D_NO_ACK) != 0)
 	{
 		return -EPROTO;
 	}
@@ -181,7 +154,7 @@ s32 i2c_smbus_nct6775::nct6775_access(u16 addr, char read_write, u8 command, int
     return 0;
 }
 
-s32 i2c_smbus_nct6775::i2c_smbus_xfer(u8 addr, char read_write, u8 command, int size, i2c_smbus_data* data)
+s32 i2c_smbus_nuvoton_nct6793d::i2c_smbus_xfer(u8 addr, char read_write, u8 command, int size, i2c_smbus_data* data)
 {
-    return nct6775_access(addr, read_write, command, size, data);
-}
+    return nct6793d_access(addr, read_write, command, size, data);
+}

OpenAuraSDK/i2c_smbus_nuvoton_nct6793d.h

@@ -0,0 +1,53 @@
+/*-----------------------------------------*\
+|  i2c_smbus_nuvoton_nct6793d.h             |
+|                                           |
+|  Nuvoton NCT6793D SMBUS driver for Windows|
+|                                           |
+|  Adam Honse (CalcProgrammer1) 5/19/2019   |
+\*-----------------------------------------*/
+
+#include "i2c_smbus.h"
+
+#pragma once
+
+#define SMBHSTDAT       (0 + nuvoton_nct6793d_smba)
+#define SMBBLKSZ        (1 + nuvoton_nct6793d_smba)
+#define SMBHSTCMD       (2 + nuvoton_nct6793d_smba)
+#define SMBHSTIDX       (3 + nuvoton_nct6793d_smba)  //Index field is the Command field on other controllers
+#define SMBHSTCTL       (4 + nuvoton_nct6793d_smba)
+#define SMBHSTADD       (5 + nuvoton_nct6793d_smba)
+#define SMBHSTERR		(9 + nuvoton_nct6793d_smba)
+#define SMBHSTSTS       (0xE + nuvoton_nct6793d_smba)
+
+/* Command register */
+#define NCT6793D_READ_BYTE      0
+#define NCT6793D_READ_WORD      1
+#define NCT6793D_READ_BLOCK     2
+#define NCT6793D_BLOCK_WRITE_READ_PROC_CALL 3
+#define NCT6793D_PROC_CALL      4
+#define NCT6793D_WRITE_BYTE     8
+#define NCT6793D_WRITE_WORD     9
+#define NCT6793D_WRITE_BLOCK    10
+
+/* Control register */
+#define NCT6793D_MANUAL_START   128
+#define NCT6793D_SOFT_RESET     64
+
+/* Error register */
+#define NCT6793D_NO_ACK         32
+
+/* Status register */
+#define NCT6793D_FIFO_EMPTY     1
+#define NCT6793D_FIFO_FULL      2
+#define NCT6793D_MANUAL_ACTIVE  4
+
+class i2c_smbus_nuvoton_nct6793d : public i2c_smbus_interface
+{
+public:
+    u16 nuvoton_nct6793d_smba = 0x0290;
+
+private:
+    s32 nct6793d_access(u16 addr, char read_write, u8 command, int size, i2c_smbus_data *data);
+    s32 i2c_smbus_xfer(u8 addr, char read_write, u8 command, int size, i2c_smbus_data* data);
+
+};

OpenAuraSDK/i2c_smbus_piix4.cpp

@@ -12,6 +12,8 @@
 #include <Windows.h>
 #include "inpout32.h"
 
+#pragma comment(lib, "inpout32.lib")
+
 //Logic adapted from piix4_transaction() in i2c-piix4.c
 int i2c_smbus_piix4::piix4_transaction()
 {
@@ -167,4 +169,4 @@ s32 i2c_smbus_piix4::piix4_access(u16 addr, char read_write, u8 command, int siz
 s32 i2c_smbus_piix4::i2c_smbus_xfer(u8 addr, char read_write, u8 command, int size, i2c_smbus_data* data)
 {
     return piix4_access(addr, read_write, command, size, data);
-}
+}

OpenAuraSDK/openaurasdk.ui

@@ -0,0 +1,428 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>OpenAuraSDKQtDialogUi</class>
+ <widget class="QMainWindow" name="OpenAuraSDKQtDialogUi">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>500</width>
+    <height>300</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string>OpenAuraSDK</string>
+  </property>
+  <widget class="QWidget" name="centralWidget">
+   <widget class="QPushButton" name="ButtonSetAll">
+    <property name="geometry">
+     <rect>
+      <x>10</x>
+      <y>10</y>
+      <width>80</width>
+      <height>20</height>
+     </rect>
+    </property>
+    <property name="text">
+     <string>Set All</string>
+    </property>
+   </widget>
+   <widget class="QPushButton" name="ButtonSetColors">
+    <property name="geometry">
+     <rect>
+      <x>100</x>
+      <y>10</y>
+      <width>80</width>
+      <height>20</height>
+     </rect>
+    </property>
+    <property name="text">
+     <string>Set Colors</string>
+    </property>
+   </widget>
+   <widget class="QLineEdit" name="EditLED0R">
+    <property name="geometry">
+     <rect>
+      <x>10</x>
+      <y>60</y>
+      <width>50</width>
+      <height>20</height>
+     </rect>
+    </property>
+   </widget>
+   <widget class="QLineEdit" name="EditLED0G">
+    <property name="geometry">
+     <rect>
+      <x>70</x>
+      <y>60</y>
+      <width>50</width>
+      <height>20</height>
+     </rect>
+    </property>
+   </widget>
+   <widget class="QLineEdit" name="EditLED0B">
+    <property name="geometry">
+     <rect>
+      <x>130</x>
+      <y>60</y>
+      <width>50</width>
+      <height>20</height>
+     </rect>
+    </property>
+   </widget>
+   <widget class="QLineEdit" name="EditLED1R">
+    <property name="geometry">
+     <rect>
+      <x>10</x>
+      <y>90</y>
+      <width>50</width>
+      <height>20</height>
+     </rect>
+    </property>
+   </widget>
+   <widget class="QLineEdit" name="EditLED1G">
+    <property name="geometry">
+     <rect>
+      <x>70</x>
+      <y>90</y>
+      <width>50</width>
+      <height>20</height>
+     </rect>
+    </property>
+   </widget>
+   <widget class="QLineEdit" name="EditLED1B">
+    <property name="geometry">
+     <rect>
+      <x>130</x>
+      <y>90</y>
+      <width>50</width>
+      <height>20</height>
+     </rect>
+    </property>
+   </widget>
+   <widget class="QLineEdit" name="EditLED2R">
+    <property name="geometry">
+     <rect>
+      <x>10</x>
+      <y>120</y>
+      <width>50</width>
+      <height>20</height>
+     </rect>
+    </property>
+   </widget>
+   <widget class="QLineEdit" name="EditLED2G">
+    <property name="geometry">
+     <rect>
+      <x>70</x>
+      <y>120</y>
+      <width>50</width>
+      <height>20</height>
+     </rect>
+    </property>
+   </widget>
+   <widget class="QLineEdit" name="EditLED2B">
+    <property name="geometry">
+     <rect>
+      <x>130</x>
+      <y>120</y>
+      <width>50</width>
+      <height>20</height>
+     </rect>
+    </property>
+   </widget>
+   <widget class="QLineEdit" name="EditLED3R">
+    <property name="geometry">
+     <rect>
+      <x>10</x>
+      <y>150</y>
+      <width>50</width>
+      <height>20</height>
+     </rect>
+    </property>
+   </widget>
+   <widget class="QLineEdit" name="EditLED3G">
+    <property name="geometry">
+     <rect>
+      <x>70</x>
+      <y>150</y>
+      <width>50</width>
+      <height>20</height>
+     </rect>
+    </property>
+   </widget>
+   <widget class="QLineEdit" name="EditLED3B">
+    <property name="geometry">
+     <rect>
+      <x>130</x>
+      <y>150</y>
+      <width>50</width>
+      <height>20</height>
+     </rect>
+    </property>
+   </widget>
+   <widget class="QLineEdit" name="EditLED4R">
+    <property name="geometry">
+     <rect>
+      <x>10</x>
+      <y>180</y>
+      <width>50</width>
+      <height>20</height>
+     </rect>
+    </property>
+   </widget>
+   <widget class="QLineEdit" name="EditLED4G">
+    <property name="geometry">
+     <rect>
+      <x>70</x>
+      <y>180</y>
+      <width>50</width>
+      <height>20</height>
+     </rect>
+    </property>
+   </widget>
+   <widget class="QLineEdit" name="EditLED4B">
+    <property name="geometry">
+     <rect>
+      <x>130</x>
+      <y>180</y>
+      <width>50</width>
+      <height>20</height>
+     </rect>
+    </property>
+   </widget>
+   <widget class="QLabel" name="LabelRed">
+    <property name="geometry">
+     <rect>
+      <x>10</x>
+      <y>40</y>
+      <width>50</width>
+      <height>20</height>
+     </rect>
+    </property>
+    <property name="text">
+     <string>Red</string>
+    </property>
+   </widget>
+   <widget class="QLabel" name="LabelGreen">
+    <property name="geometry">
+     <rect>
+      <x>70</x>
+      <y>40</y>
+      <width>50</width>
+      <height>20</height>
+     </rect>
+    </property>
+    <property name="text">
+     <string>Green</string>
+    </property>
+   </widget>
+   <widget class="QLabel" name="LabelBlue">
+    <property name="geometry">
+     <rect>
+      <x>130</x>
+      <y>40</y>
+      <width>50</width>
+      <height>20</height>
+     </rect>
+    </property>
+    <property name="text">
+     <string>Blue</string>
+    </property>
+   </widget>
+   <widget class="QComboBox" name="ComboAuraDevices">
+    <property name="geometry">
+     <rect>
+      <x>290</x>
+      <y>10</y>
+      <width>200</width>
+      <height>20</height>
+     </rect>
+    </property>
+   </widget>
+   <widget class="QLabel" name="LabelAuraDevice">
+    <property name="geometry">
+     <rect>
+      <x>200</x>
+      <y>10</y>
+      <width>90</width>
+      <height>20</height>
+     </rect>
+    </property>
+    <property name="text">
+     <string>Aura Device</string>
+    </property>
+   </widget>
+   <widget class="QGroupBox" name="GroupBoxDirect">
+    <property name="geometry">
+     <rect>
+      <x>290</x>
+      <y>40</y>
+      <width>200</width>
+      <height>60</height>
+     </rect>
+    </property>
+    <property name="title">
+     <string>Mode</string>
+    </property>
+    <widget class="QRadioButton" name="RadioDirect">
+     <property name="geometry">
+      <rect>
+       <x>10</x>
+       <y>30</y>
+       <width>70</width>
+       <height>20</height>
+      </rect>
+     </property>
+     <property name="text">
+      <string>Direct</string>
+     </property>
+    </widget>
+    <widget class="QRadioButton" name="RadioEffect">
+     <property name="geometry">
+      <rect>
+       <x>110</x>
+       <y>30</y>
+       <width>70</width>
+       <height>20</height>
+      </rect>
+     </property>
+     <property name="text">
+      <string>Effect</string>
+     </property>
+    </widget>
+   </widget>
+   <widget class="QGroupBox" name="GroupBoxEffect">
+    <property name="geometry">
+     <rect>
+      <x>290</x>
+      <y>100</y>
+      <width>200</width>
+      <height>180</height>
+     </rect>
+    </property>
+    <property name="title">
+     <string>Effect</string>
+    </property>
+    <widget class="QRadioButton" name="RadioOff">
+     <property name="geometry">
+      <rect>
+       <x>10</x>
+       <y>20</y>
+       <width>150</width>
+       <height>20</height>
+      </rect>
+     </property>
+     <property name="text">
+      <string>Off</string>
+     </property>
+    </widget>
+    <widget class="QRadioButton" name="RadioStatic">
+     <property name="geometry">
+      <rect>
+       <x>10</x>
+       <y>40</y>
+       <width>150</width>
+       <height>20</height>
+      </rect>
+     </property>
+     <property name="text">
+      <string>Static</string>
+     </property>
+    </widget>
+    <widget class="QRadioButton" name="RadioBreathing">
+     <property name="geometry">
+      <rect>
+       <x>10</x>
+       <y>60</y>
+       <width>150</width>
+       <height>20</height>
+      </rect>
+     </property>
+     <property name="text">
+      <string>Breathing</string>
+     </property>
+    </widget>
+    <widget class="QRadioButton" name="RadioFlashing">
+     <property name="geometry">
+      <rect>
+       <x>10</x>
+       <y>80</y>
+       <width>150</width>
+       <height>20</height>
+      </rect>
+     </property>
+     <property name="text">
+      <string>Flashing</string>
+     </property>
+    </widget>
+    <widget class="QRadioButton" name="RadioSpectrumCycle">
+     <property name="geometry">
+      <rect>
+       <x>10</x>
+       <y>100</y>
+       <width>150</width>
+       <height>20</height>
+      </rect>
+     </property>
+     <property name="text">
+      <string>Spectrum Cycle</string>
+     </property>
+    </widget>
+    <widget class="QRadioButton" name="RadioRainbow">
+     <property name="geometry">
+      <rect>
+       <x>10</x>
+       <y>120</y>
+       <width>150</width>
+       <height>20</height>
+      </rect>
+     </property>
+     <property name="text">
+      <string>Rainbow Wave</string>
+     </property>
+    </widget>
+    <widget class="QRadioButton" name="RadioBreathingSpectrum">
+     <property name="geometry">
+      <rect>
+       <x>10</x>
+       <y>140</y>
+       <width>180</width>
+       <height>20</height>
+      </rect>
+     </property>
+     <property name="text">
+      <string>Breathing Spectrum</string>
+     </property>
+    </widget>
+    <widget class="QRadioButton" name="RadioChaseFade">
+     <property name="geometry">
+      <rect>
+       <x>10</x>
+       <y>160</y>
+       <width>180</width>
+       <height>20</height>
+      </rect>
+     </property>
+     <property name="text">
+      <string>Chase Fade</string>
+     </property>
+    </widget>
+   </widget>
+   <widget class="QPushButton" name="ButtonDumpAura">
+    <property name="geometry">
+     <rect>
+      <x>190</x>
+      <y>260</y>
+      <width>89</width>
+      <height>25</height>
+     </rect>
+    </property>
+    <property name="text">
+     <string>Dump Aura</string>
+    </property>
+   </widget>
+  </widget>
+ </widget>
+ <resources/>
+ <connections/>
+</ui>

OpenAuraSDK/resource.h

@@ -0,0 +1,52 @@
+//{{NO_DEPENDENCIES}}
+// Microsoft Visual C++ generated include file.
+// Used by Resource.rc
+//
+#define IDD_DIALOG_I2C_DETECT           101
+#define IDD_DIALOG_OPENAURASDK          103
+#define IDC_COMBO_I2C_BUS               1001
+#define IDC_BUTTON_I2C_DETECT           1002
+#define IDC_EDIT_I2C_DETECT             1003
+#define IDC_BUTTON_OPENAURASDK_I2CDETECT 1004
+#define IDC_RADIO_OPENAURASDK_DIRECT_MODE 1006
+#define IDC_RADIO_OPENAURASDK_EFFECT_MODE 1007
+#define IDC_RADIO_OPENAURASDK_EFFECT_STATIC 1008
+#define IDC_RADIO_OPENAURASDK_EFFECT_OFF 1009
+#define IDC_RADIO_OPENAURASDK_EFFECT_BREATHING 1010
+#define IDC_RADIO_OPENAURASDK_EFFECT_FLASHING 1011
+#define IDC_RADIO_OPENAURASDK_EFFECT_SPECTRUM_CYCLE 1012
+#define IDC_RADIO_OPENAURASDK_EFFECT_RAINBOW 1013
+#define IDC_RADIO_OPENAURASDK_BREATHING_SPECTRUM 1014
+#define IDC_RADIO_OPENAURASDK_EFFECT_CHASE_FADE 1015
+#define IDC_EDIT_OPENAURASDK_LED_0_R    1016
+#define IDC_EDIT_OPENAURASDK_LED_0_G    1017
+#define IDC_EDIT_OPENAURASDK_LED_0_B    1018
+#define IDC_BUTTON_OPENAURASDK_SET_COLORS_ALL 1019
+#define IDC_COMBO_OPENAURASDK_DEVICE    1020
+#define IDC_EDIT_OPENAURASDK_LED_1_R    1021
+#define IDC_EDIT_OPENAURASDK_LED_1_G    1022
+#define IDC_EDIT_OPENAURASDK_LED_1_B    1023
+#define IDC_EDIT_OPENAURASDK_LED_2_R    1024
+#define IDC_EDIT_OPENAURASDK_LED_2_G    1025
+#define IDC_EDIT_OPENAURASDK_LED_2_B    1026
+#define IDC_EDIT_OPENAURASDK_LED_3_R    1027
+#define IDC_EDIT_OPENAURASDK_LED_3_G    1028
+#define IDC_EDIT_OPENAURASDK_LED_3_B    1029
+#define IDC_EDIT_OPENAURASDK_LED_4_R    1030
+#define IDC_EDIT_OPENAURASDK_LED_4_G    1031
+#define IDC_EDIT_OPENAURASDK_LED_4_B    1032
+#define IDC_BUTTON1                     1033
+#define IDC_BUTTON_OPENAURASDK_DUMP     1033
+#define IDC_BUTTON_OPENAURASDK_SET_COLORS2 1034
+#define IDC_BUTTON_OPENAURASDK_SET_COLORS 1034
+
+// Next default values for new objects
+// 
+#ifdef APSTUDIO_INVOKED
+#ifndef APSTUDIO_READONLY_SYMBOLS
+#define _APS_NEXT_RESOURCE_VALUE        105
+#define _APS_NEXT_COMMAND_VALUE         40001
+#define _APS_NEXT_CONTROL_VALUE         1034
+#define _APS_NEXT_SYMED_VALUE           101
+#endif
+#endif