Update I801 sniffer to support multiple read/write sizes

Signed-off-by: Stavros Avramidis <[email protected]>

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

@@ -8,6 +8,144 @@
 \*-----------------------------------------*/
 
 #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;
+    }
+    // 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)
 {
@@ -31,10 +169,10 @@ void AuraController::AuraRegisterWrite(aura_register reg, unsigned char val)
 
 void AuraController::AuraRegisterWriteBlock(aura_register reg, unsigned char * data, unsigned char sz)
 {
-    //Write Aura register (0x8000 for colors)
+    //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

@@ -18,6 +18,7 @@ typedef unsigned short	aura_register;
 
 enum
 {
+    AURA_REG_DEVICE_NAME                = 0x1000,   /* Device String 16 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   */
@@ -25,21 +26,23 @@ enum
     AURA_REG_APPLY                      = 0x80A0,   /* AURA Apply Changes Register          */
     AURA_REG_SLOT_INDEX                 = 0x80F8,   /* AURA Slot Index Register (RAM only)  */
     AURA_REG_I2C_ADDRESS                = 0x80F9,   /* AURA I2C Address Register (RAM only) */
+    AURA_REG_COLORS_DIRECT_V2           = 0x8100,   /* Direct Colors (v2) 30 bytes          */
+    AURA_REG_COLORS_EFFECT_V2           = 0x8160,   /* Internal Colors (v2) 30 bytes        */
 };
 
 enum
 {
-    AURA_MODE_OFF                       = 0,        /* OFF mode								*/
-    AURA_MODE_STATIC                    = 1,        /* Static color mode					*/
-    AURA_MODE_BREATHING                 = 2,        /* Breathing effect mode				*/
-    AURA_MODE_FLASHING                  = 3,        /* Flashing effect mode					*/
-    AURA_MODE_SPECTRUM_CYCLE            = 4,        /* Spectrum Cycle mode   				*/
-    AURA_MODE_RAINBOW                   = 5,        /* Rainbow effect mode					*/
-    AURA_MODE_SPECTRUM_CYCLE_BREATHING  = 6,        /* Rainbow Breathing effect mode		*/
-    AURA_MODE_CHASE_FADE                = 7,        /* Chase with Fade effect mode			*/
-    AURA_MODE_SPECTRUM_CYCLE_CHASE_FADE = 8,        /* Chase with Fade, Rainbow effect mode	*/
-    AURA_MODE_CHASE                     = 9,        /* Chase effect mode					*/
-    AURA_MODE_SPECTRUM_CYCLE_CHASE      = 10,       /* Chase with Rainbow effect mode		*/
+    AURA_MODE_OFF                       = 0,        /* OFF mode                             */
+    AURA_MODE_STATIC                    = 1,        /* Static color mode                    */
+    AURA_MODE_BREATHING                 = 2,        /* Breathing effect mode                */
+    AURA_MODE_FLASHING                  = 3,        /* Flashing effect mode                 */
+    AURA_MODE_SPECTRUM_CYCLE            = 4,        /* Spectrum Cycle mode                  */
+    AURA_MODE_RAINBOW                   = 5,        /* Rainbow effect mode                  */
+    AURA_MODE_SPECTRUM_CYCLE_BREATHING  = 6,        /* Rainbow Breathing effect mode        */
+    AURA_MODE_CHASE_FADE                = 7,        /* Chase with Fade effect mode          */
+    AURA_MODE_SPECTRUM_CYCLE_CHASE_FADE = 8,        /* Chase with Fade, Rainbow effect mode */
+    AURA_MODE_CHASE                     = 9,        /* Chase effect mode                    */
+    AURA_MODE_SPECTRUM_CYCLE_CHASE      = 10,       /* Chase with Rainbow effect mode       */
     AURA_MODE_SPECTRUM_CYCLE_WAVE       = 11,       /* Wave effect mode                     */
     AURA_MODE_CHASE_RAINBOW_PULSE       = 12,       /* Chase with  Rainbow Pulse effect mode*/
     AURA_MODE_RANDOM_FLICKER            = 13,       /* Random flicker effect mode           */
@@ -48,13 +51,31 @@ enum
 class AuraController
 {
 public:
+    AuraController(i2c_smbus_interface* bus, aura_dev_id dev);
+    ~AuraController();
+
+    char*         GetDeviceName();
+    unsigned int  GetLEDCount();
+    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);
+    void          SetLEDColorDirect(unsigned int led, unsigned char red, unsigned char green, unsigned char blue);
+    void          SetLEDColorEffect(unsigned int led, unsigned char red, unsigned char green, unsigned char blue);
+    void          SetMode(unsigned char mode);
+
+    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);
-    i2c_smbus_interface * bus;
-    aura_dev_id   dev;
 
 private:
+    char                    device_name[16];
+    unsigned int            led_count;
+    aura_register           direct_reg;
+    aura_register           effect_reg;
+    i2c_smbus_interface *   bus;
+    aura_dev_id             dev;
 	
 
 };

OpenAuraSDK/CorsairController.cpp

@@ -0,0 +1,44 @@
+/*-----------------------------------------*\
+|  CorsairController.h                      |
+|                                           |
+|  Driver for Corsair Vengeance RGB RAM     |
+|  lighting controller                      |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 3/8/2019    |
+\*-----------------------------------------*/
+
+#include "CorsairController.h"
+#include <cstring>
+
+CorsairController::CorsairController(i2c_smbus_interface* bus, corsair_dev_id dev)
+{
+    this->bus = bus;
+    this->dev = dev;
+
+    strcpy(device_name, "Corsair Vengeance RGB");
+    led_count = 1;
+}
+
+CorsairController::~CorsairController()
+{
+
+}
+
+char * CorsairController::GetDeviceName()
+{
+    return(device_name);
+}
+
+unsigned int CorsairController::GetLEDCount()
+{
+    return(led_count);
+}
+
+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);
+}

OpenAuraSDK/CorsairController.h

@@ -0,0 +1,51 @@
+/*-----------------------------------------*\
+|  CorsairController.h                      |
+|                                           |
+|  Definitions and types for Corsair        |
+|  Vengeance RGB RAM lighting controller    |
+|                                           |
+|  Adam Honse (CalcProgrammer1) 3/8/2019    |
+\*-----------------------------------------*/
+
+#include "i2c_smbus.h"
+
+#pragma once
+
+typedef unsigned char	corsair_dev_id;
+typedef unsigned char   corsair_cmd;
+
+enum
+{
+    CORSAIR_VENGEANCE_RGB_CMD_FADE_TIME = 0xA4,     /* Fade Time, 0 for Static              */
+    CORSAIR_VENGEANCE_RGB_CMD_HOLD_TIME = 0xA5,     /* Hold Time                            */
+    CORSAIR_VENGEANCE_RGB_CMD_MODE      = 0xA6,     /* Mode Control Value                   */
+    CORSAIR_VENGEANCE_RGB_CMD_RED_VAL   = 0xB0,     /* Red Color Value                      */
+    CORSAIR_VENGEANCE_RGB_CMD_GREEN_VAL = 0xB1,     /* Green Color Value                    */
+    CORSAIR_VENGEANCE_RGB_CMD_BLUE_VAL  = 0xB2,     /* Blue Color Value                     */
+};
+
+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                 */
+};
+
+class CorsairController
+{
+public:
+    CorsairController(i2c_smbus_interface* bus, corsair_dev_id dev);
+    ~CorsairController();
+
+    char*         GetDeviceName();
+    unsigned int  GetLEDCount();
+
+    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

@@ -14,14 +14,21 @@
 
 #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 <regex>
 #include <fcntl.h>
 #include <unistd.h>
 #include <dirent.h>
@@ -32,6 +39,123 @@ 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_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:
+        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;
+        }
+
+        busses.push_back(bus);
+    }
+
+}   /* DetectNuvotonI2CBusses() */
+
+
 /******************************************************************************************\
 *                                                                                          *
 *   DetectI2CBusses (Windows)                                                              *
@@ -67,11 +191,15 @@ void DetectI2CBusses()
         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);
         }
 
@@ -79,7 +207,8 @@ void DetectI2CBusses()
         // 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)
+        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) + ".+";
 
@@ -99,12 +228,16 @@ void DetectI2CBusses()
                 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 */
@@ -189,27 +322,116 @@ void DetectI2CBusses()
 
 /******************************************************************************************\
 *                                                                                          *
-*   CreateAuraDevice                                                                       *
+*   TestForAuraController                                                                  *
 *                                                                                          *
-*       Enumerates an ASUS Aura compatibler I2C device with the given address on the given *
-*       bus                                                                                *
+*       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                                               *
 *                                                                                          *
 \******************************************************************************************/
 
-AuraController * CreateAuraDevice(i2c_smbus_interface * bus, aura_dev_id dev)
+void DetectAuraControllers()
 {
-    AuraController * aura;
+    AuraController* new_controller;
 
-    aura = new AuraController();
-    aura->bus = bus;
-    aura->dev = dev;
+    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);
 
-    return(aura);
+            if (res < 0)
+            {
+                break;
+            }
 
-}   /* CreateAuraDevice() */
+            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() */
 
 
 /******************************************************************************************\
@@ -230,19 +452,23 @@ AuraController * CreateAuraDevice(i2c_smbus_interface * bus, aura_dev_id dev)
 #define MODE_READ   2
 #define MODE_FUNC   3
 
-void DetectI2C(i2c_smbus_interface * bus, int mode)
+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);
 
-    printf("     0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f\r\n");
+    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)
     {
-        printf("%02x: ", i);
+        sprintf(line, "%02x: ", i);
+        text.append(line);
 
         for (j = 0; j < 16; j++)
         {
@@ -269,16 +495,21 @@ void DetectI2C(i2c_smbus_interface * bus, int mode)
 
             if (res < 0)
             {
-                printf("-- ");
+                sprintf(line, "-- ");
+                text.append(line);
             }
             else
             {
-                printf("%02x ", i + j);
+                sprintf(line, "%02x ", i + j);
+                text.append(line);
             }
         }
-        printf("\r\n");
+        sprintf(line, "\r\n");
+        text.append(line);
     }
 
+    return text;
+
 }   /* DetectI2C() */
 
 
@@ -294,13 +525,13 @@ void DumpAuraRegisters(AuraController * controller)
 {
     int i, j;
 
-    int start = 0x8000;
+    int start = 0x0000;
 
-    freopen("auradump.txt", "a", stdout);
+    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 < 512; i += 16)
+    for (i = 0; i < 0xFFFF; i += 16)
     {
         printf("%04x: ", i + start);
 
@@ -312,87 +543,160 @@ void DumpAuraRegisters(AuraController * controller)
         printf("\r\n");
     }
 
+    fclose(file);
+
 }   /* DumpAuraRegisters() */
 
 
 /******************************************************************************************\
 *                                                                                          *
-*   main/WinMain                                                                           *
+*   main                                                                                   *
 *                                                                                          *
-*       Main function.  Has no defined purpose yet, but is where you can call the other    *
-*       functions in this project to test them out                                         *
-*                                                                                          *
-*       Currently, this program will enumerate all detected SMBus adapters and then detect *
-*       all attached devices, similar to i2cdetect on Linux                                *
+*       Main function.  Detects busses and Aura controllers, then opens the main window    *
 *                                                                                          *
 \******************************************************************************************/
+/* I801 SMBus address offsets */
+#define SMBHSTSTS       (0 + i801_smba)
+#define SMBHSTCNT       (2 + i801_smba)
+#define SMBHSTCMD       (3 + i801_smba)
+#define SMBHSTADD       (4 + i801_smba)
+#define SMBHSTDAT0      (5 + i801_smba)
+#define SMBHSTDAT1      (6 + i801_smba)
+#define SMBBLKDAT       (7 + i801_smba)
+#define SMBPEC          (8 + i801_smba)     /* ICH3 and later */
+#define SMBAUXSTS       (12 + i801_smba)    /* ICH4 and later */
+#define SMBAUXCTL       (13 + i801_smba)    /* ICH4 and later */
+#define SMBSLVSTS       (16 + i801_smba)    /* ICH3 and later */
+#define SMBSLVCMD       (17 + i801_smba)    /* ICH3 and later */
+#define SMBNTFDADD      (20 + i801_smba)    /* ICH3 and later */
 
-#ifdef WIN32
-INT WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, PSTR lpCmdLine, INT nCmdShow)
-#else /* WIN32 */
-int main()
-#endif /* WIN32 */
+int main(int argc, char *argv[])
 {
-    // Colors Array              R    B    G
-    unsigned char colors[15] = { 255, 0,   0,
-                                 0,   255, 0,
-                                 0,   0,   255,
-                                 255, 0,   255,
-                                 0,   255, 255  };
     DetectI2CBusses();
 
-    for (unsigned int bus = 0; bus < busses.size(); bus++)
+    int i801_smba = ((i2c_smbus_i801*)busses[0])->i801_smba;
+
+    while(1)
     {
-        // Remap Aura-enabled RAM modules on 0x77
-        for (unsigned int slot = 0; slot < 8; slot++)
+        while ((Inp32(SMBHSTSTS) & 0x02) != 0)
         {
-            int res = busses[bus]->i2c_smbus_write_quick(0x77, I2C_SMBUS_WRITE);
-
-            if (res < 0)
-            {
-                break;
-            }
-
-            AuraController * temp_controller = CreateAuraDevice(busses[bus], 0x77);
-
-            temp_controller->AuraRegisterWrite(AURA_REG_SLOT_INDEX,  slot);
-            temp_controller->AuraRegisterWrite(AURA_REG_I2C_ADDRESS, 0xE0 + ( slot << 1 ) );
-
-            delete temp_controller;
+            for (int i = 0; i < 5000; i++);
         }
 
-        // Add Aura-enabled controllers at their remapped addresses
-        for (unsigned int slot = 0; slot < 8; slot++)
+        while ((Inp32(SMBHSTSTS) & 0x02) == 0)
         {
-            int res = busses[bus]->i2c_smbus_write_quick(0x70 + slot, I2C_SMBUS_WRITE);
+            for (int i = 0; i < 5000; i++);
+        }
+        {
+            unsigned char addr = Inp32(SMBHSTADD);
+            unsigned char size = Inp32(SMBHSTCNT);
+            unsigned char cmnd = Inp32(SMBHSTCMD);
+            unsigned char dat0 = Inp32(SMBHSTDAT0);
+            unsigned char dat1 = Inp32(SMBHSTDAT1);
 
-            if (res >= 0)
+            if (addr & 1)
             {
-               AuraController * new_controller = CreateAuraDevice(busses[bus], 0x70 + slot);
-               controllers.push_back(new_controller);
+                switch (size & 0x1C)
+                {
+                case I801_QUICK:
+                    printf("Read %02x from address %02x \n",
+                        dat0,
+                        addr >> 1);
+                    break;
+
+                case I801_BYTE_DATA:
+                    printf("Read %02x from %02x, address %02x \n",
+                        dat0,
+                        cmnd,
+                        addr >> 1);
+                    break;
+
+                case I801_WORD_DATA:
+                    printf("Read %02x %02x from %02x, address %02x \n",
+                        dat0,
+                        dat1,
+                        cmnd,
+                        addr >> 1);
+                    break;
+
+                case I801_BLOCK_DATA:
+                    printf("Read block of length %02x from %02x, address %02x, contents: ",
+                        dat0,
+                        cmnd,
+                        addr >> 1);
+
+                    // Read SMBHSTCNT to reset SMBBLKDAT read pointer
+                    Inp32(SMBHSTCNT);
+
+                    for (int byte = 0; byte < dat0; byte++)
+                    {
+                        printf("%02x ", Inp32(SMBBLKDAT));
+                    }
+
+                    printf("\n");
+
+                    break;
+                }
+            }
+            else
+            {
+                switch (size & 0x1C)
+                {
+                case I801_QUICK:
+                    printf("Wrote %02x to address %02x \n",
+                        dat0,
+                        addr >> 1);
+                    break;
+
+                case I801_BYTE_DATA:
+                    printf("Wrote %02x to %02x, address %02x \n",
+                        dat0,
+                        cmnd,
+                        addr >> 1);
+                    break;
+
+                case I801_WORD_DATA:
+                    printf("Wrote %02x %02x to %02x, address %02x \n",
+                        dat0,
+                        dat1,
+                        cmnd,
+                        addr >> 1);
+                    break;
+
+                case I801_BLOCK_DATA:
+                    printf("Wrote block of length %02x to %02x, address %02x, contents: ",
+                        dat0,
+                        cmnd,
+                        addr >> 1);
+
+                    // Read SMBHSTCNT to reset SMBBLKDAT read pointer
+                    Inp32(SMBHSTCNT);
+
+                    for (int byte = 0; byte < dat0; byte++)
+                    {
+                        printf("%02x ", Inp32(SMBBLKDAT));
+                    }
+
+                    printf("\n");
+
+                    break;
+                }
             }
         }
-
-        // Check for Aura controller at 0x4E
-        int res = busses[bus]->i2c_smbus_write_quick(0x4E, I2C_SMBUS_WRITE);
-
-        if (res >= 0)
-        {
-            AuraController * new_controller = CreateAuraDevice(busses[bus], 0x4E);
-            controllers.push_back(new_controller);
-        }
     }
 
-    for (unsigned int i = 0; i < controllers.size(); i++)
-    {
-        controllers[i]->AuraRegisterWrite(AURA_REG_DIRECT, 1);
-        controllers[i]->AuraRegisterWrite(AURA_REG_APPLY, AURA_APPLY_VAL);
-    }
+#if WIN32
+    //OpenAuraSDKDialog dlg(busses, controllers);
+    //dlg.DoModal();
 
-    for (unsigned int i = 0; i < controllers.size(); i++)
-    {
-        controllers[i]->AuraRegisterWriteBlock(AURA_REG_COLORS_DIRECT, colors, 15);
-    }
+    return 0;
 
-    return 1;
+#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.pro

@@ -1,17 +0,0 @@
-TEMPLATE = app
-CONFIG += console c++11
-CONFIG -= app_bundle
-CONFIG -= qt
-
-SOURCES += \
-    i2c_smbus.cpp \
-    AuraController.cpp \
-    OpenAuraSDK.cpp \
-    i2c_smbus_linux.cpp
-
-HEADERS += \
-    i2c_smbus.h \
-    i2c_smbus_linux.h \
-    AuraController.h
-
-FORMS +=

OpenAuraSDK/OpenAuraSDK.vcxproj

@@ -23,34 +23,38 @@
     <ProjectGuid>{6D22BFF3-C1DF-407A-8816-05D63919A991}</ProjectGuid>
     <Keyword>Win32Proj</Keyword>
     <RootNamespace>OpenAuraSDK</RootNamespace>
-    <WindowsTargetPlatformVersion>10.0.17134.0</WindowsTargetPlatformVersion>
+    <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>v141</PlatformToolset>
+    <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>v141</PlatformToolset>
+    <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>v141</PlatformToolset>
+    <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>v141</PlatformToolset>
+    <PlatformToolset>v142</PlatformToolset>
     <WholeProgramOptimization>true</WholeProgramOptimization>
     <CharacterSet>Unicode</CharacterSet>
+    <UseOfMfc>Dynamic</UseOfMfc>
   </PropertyGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
   <ImportGroup Label="ExtensionSettings">
@@ -92,15 +96,16 @@
       <WarningLevel>Level3</WarningLevel>
       <Optimization>Disabled</Optimization>
       <SDLCheck>true</SDLCheck>
-      <PreprocessorDefinitions>WIN32;_CRT_SECURE_NO_WARNINGS</PreprocessorDefinitions>
+      <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>Windows</SubSystem>
+      <SubSystem>Console</SubSystem>
       <GenerateDebugInformation>true</GenerateDebugInformation>
       <AdditionalLibraryDirectories>..\dependencies\inpout32_1501\Win32;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
     </Link>
@@ -111,14 +116,15 @@
       <WarningLevel>Level3</WarningLevel>
       <Optimization>Disabled</Optimization>
       <SDLCheck>true</SDLCheck>
-      <PreprocessorDefinitions>WIN32;_CRT_SECURE_NO_WARNINGS</PreprocessorDefinitions>
+      <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>Windows</SubSystem>
+      <SubSystem>Console</SubSystem>
       <GenerateDebugInformation>true</GenerateDebugInformation>
       <AdditionalLibraryDirectories>..\dependencies\inpout32_1501\Win32;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
     </Link>
@@ -131,15 +137,16 @@
       <FunctionLevelLinking>true</FunctionLevelLinking>
       <IntrinsicFunctions>true</IntrinsicFunctions>
       <SDLCheck>true</SDLCheck>
-      <PreprocessorDefinitions>WIN32;_CRT_SECURE_NO_WARNINGS</PreprocessorDefinitions>
+      <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>Windows</SubSystem>
+      <SubSystem>Console</SubSystem>
       <EnableCOMDATFolding>true</EnableCOMDATFolding>
       <OptimizeReferences>true</OptimizeReferences>
       <GenerateDebugInformation>true</GenerateDebugInformation>
@@ -154,14 +161,15 @@
       <FunctionLevelLinking>true</FunctionLevelLinking>
       <IntrinsicFunctions>true</IntrinsicFunctions>
       <SDLCheck>true</SDLCheck>
-      <PreprocessorDefinitions>WIN32;_CRT_SECURE_NO_WARNINGS</PreprocessorDefinitions>
+      <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>Windows</SubSystem>
+      <SubSystem>Console</SubSystem>
       <EnableCOMDATFolding>true</EnableCOMDATFolding>
       <OptimizeReferences>true</OptimizeReferences>
       <GenerateDebugInformation>true</GenerateDebugInformation>
@@ -170,21 +178,31 @@
   </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="wmi.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>

OpenAuraSDK/OpenAuraSDK.vcxproj.filters

@@ -24,15 +24,27 @@
     <ClInclude Include="AuraController.h">
       <Filter>Header Files</Filter>
     </ClInclude>
-    <ClInclude Include="OpenAuraSDK.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">
@@ -56,5 +68,19 @@
     <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_nuvoton_nct6793d.cpp

@@ -0,0 +1,160 @@
+/*-----------------------------------------*\
+|  i2c_smbus_nuvoton_nct6793d.cpp           |
+|                                           |
+|  Nuvoton NCT6793D SMBUS driver for Windows|
+|                                           |
+|  Adam Honse (CalcProgrammer1) 5/19/2019   |
+\*-----------------------------------------*/
+
+#include "i2c_smbus_nuvoton_nct6793d.h"
+#include <Windows.h>
+#include "inpout32.h"
+
+#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;
+
+    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:
+        Out32(SMBHSTADD, (addr << 1) | read_write);
+        Out32(SMBHSTIDX, command);
+        if (read_write == I2C_SMBUS_WRITE)
+        {
+            Out32(SMBHSTDAT, data->byte);
+            Out32(SMBHSTCMD, NCT6793D_WRITE_BYTE);
+        }
+        else
+        {
+            Out32(SMBHSTCMD, NCT6793D_READ_BYTE);
+        }
+        break;
+    case I2C_SMBUS_WORD_DATA:
+        Out32(SMBHSTADD, (addr << 1) | read_write);
+        Out32(SMBHSTIDX, command);
+        if (read_write == I2C_SMBUS_WRITE)
+        {
+			Out32(SMBHSTDAT, data->word & 0xFF);
+			Out32(SMBHSTDAT, (data->word & 0xFF00) >> 8);
+            Out32(SMBHSTCMD, NCT6793D_WRITE_WORD);
+        }
+        else
+        {
+            Out32(SMBHSTCMD, NCT6793D_READ_WORD);
+        }
+        break;
+    case I2C_SMBUS_BLOCK_DATA:
+        Out32(SMBHSTADD, (addr << 1) | read_write);
+        Out32(SMBHSTIDX, command);
+        if (read_write == I2C_SMBUS_WRITE)
+        {
+            len = data->block[0];
+            if (len == 0 || len > I2C_SMBUS_BLOCK_MAX)
+            {
+                return -EINVAL;
+            }
+            Out32(SMBBLKSZ, len);
+
+			//Load 4 bytes into FIFO
+			cnt = 1;
+			if (len >= 4)
+			{
+				for (i = cnt; i <= 4; i++)
+				{
+					Out32(SMBHSTDAT, data->block[i]);
+				}
+
+				len -= 4;
+				cnt += 4;
+			}
+			else
+			{
+				for (i = cnt; i <= len; i++)
+				{
+					Out32(SMBHSTDAT, data->block[i]);
+				}
+
+				len = 0;
+			}
+            
+            Out32(SMBHSTCMD, NCT6793D_WRITE_BLOCK);
+        }
+        else
+        {
+            return -EOPNOTSUPP;
+            //Out32(SMBHSTCMD, NCT6793D_READ_BLOCK);
+        }
+        break;
+    default:
+        return -EOPNOTSUPP;
+    }
+
+    Out32(SMBHSTCTL, NCT6793D_MANUAL_START);
+
+	while ((size == I2C_SMBUS_BLOCK_DATA) && (len > 0))
+	{
+		if (read_write == I2C_SMBUS_WRITE)
+		{
+			while ((Inp32(SMBHSTSTS) & NCT6793D_FIFO_EMPTY) == 0);
+
+			//Load more bytes into FIFO
+			if (len >= 4)
+			{
+				for (i = cnt; i <= (cnt + 4); i++)
+				{
+					Out32(SMBHSTDAT, data->block[i]);
+				}
+
+				len -= 4;
+				cnt += 4;
+			}
+			else
+			{
+				for (i = cnt; i <= (cnt + len); i++)
+				{
+					Out32(SMBHSTDAT, data->block[i]);
+				}
+
+				len = 0;
+			}
+		}
+	}
+
+	//wait for manual mode to complete
+	while ((Inp32(SMBHSTSTS) & NCT6793D_MANUAL_ACTIVE) != 0);
+
+	if ((Inp32(SMBHSTERR) & NCT6793D_NO_ACK) != 0)
+	{
+		return -EPROTO;
+	}
+	else if ((read_write == I2C_SMBUS_WRITE) || (size == I2C_SMBUS_QUICK))
+	{
+		return 0;
+	}
+
+    switch (size)
+    {
+    case I2C_SMBUS_QUICK:
+    case I2C_SMBUS_BYTE_DATA:
+        data->byte = (u8)Inp32(SMBHSTDAT);
+        break;
+    case I2C_SMBUS_WORD_DATA:
+        data->word = Inp32(SMBHSTDAT) + (Inp32(SMBHSTDAT) << 8);
+        break;
+    }
+
+    return 0;
+}
+
+s32 i2c_smbus_nuvoton_nct6793d::i2c_smbus_xfer(u8 addr, char read_write, u8 command, int size, i2c_smbus_data* 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/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

OpenAuraSDK/wmi.cpp

@@ -155,7 +155,7 @@ HRESULT Wmi::query(std::string queryStr, std::vector<QueryObj>& queryVectorOut,
 
     while (pEnumerator)
     {
-        hres = pEnumerator->Next(WBEM_INFINITE, 1, &pclsObj, &uReturn);
+        hres = pEnumerator->Next(WMI_WAIT_TIME, 1, &pclsObj, &uReturn);
 
         if (0==uReturn)
         {

OpenAuraSDK/wmi.h

@@ -9,6 +9,8 @@
 #include <Wbemidl.h>
 #include <Windows.h>
 
+#define WMI_WAIT_TIME 2000 /// Max time to wait for next object in when enumerating next object in wmi query in milliseconds
+
 #pragma comment(lib, "wbemuuid.lib")
 
 

README.md

@@ -0,0 +1,25 @@
+OpenAuraSDK
+
+This project is an open-source implementation of the Asus Aura RGB controller software.  It currently only supports a limited number of motherboard and RAM module lighting controllers.
+
+It supports both Windows and Linux.  To build on Windows, download the latest Visual Studio Community edition and open the .sln.  You may have to retarget the project to the latest version of the Windows SDK and build tools and stuff.  Build for x86, the InpOut32 library I use does not support x64.
+
+To build on Linux, you can either open the project using QT Creator or build it using qmake.
+
+To build with qmake:
+
+cd OpenAuraSDK
+
+qmake OpenAuraSDK.pro
+
+make
+
+You'll have to enable user access to your SMbus if you don't run as root, for instance:
+
+sudo chmod 777 /dev/i2c-0
+
+You can figure out which SMBus is your motherboard's by using i2cdetect -l. For AMD boards, the second SMBus isn't currently picked up by the kernel driver and that seems to be where Asus wired the Aura controllers so I have a kernel patch here:
+
+https://gitlab.com/CalcProgrammer1/OpenAuraSDK/issues/9
+
+that will allow the kernel to use the second bus (at 0x0b20). Additionally, the AMD SMBus driver adds duplicate entries for the first bus (at 0x0b00) so I've just been giving access to only one of them, otherwise devices will show up multiple times in the list.