jalr/OpenRGB
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Initial work on interface for HyperX Predator RGB, color and mode setting works

Browse source
This commit is contained in:
Adam Honse 2019-06-30 11:54:51 -05:00
parent 9c5f592618
commit 60b9fd08bb
9 changed files with 391 additions and 2 deletions
Download patch file Download diff file Expand all files Collapse all files

1
OpenAuraSDK/AuraController.h
View file

@ -8,7 +8,6 @@
\*-----------------------------------------*/
#include "i2c_smbus.h"
#include "RGBController.h"
#pragma once

1
OpenAuraSDK/CorsairController.h
View file

@ -8,7 +8,6 @@
\*-----------------------------------------*/
#include "i2c_smbus.h"
#include "RGBController.h"
#pragma once

102
OpenAuraSDK/HyperXController.cpp Normal file
View file

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

76
OpenAuraSDK/HyperXController.h Normal file
View file

@ -0,0 +1,76 @@
/*-----------------------------------------*\
| HyperXController.h |
| |
| Definitions and types for HyperX Predator|
| RGB RAM lighting controller |
| |
| Adam Honse (CalcProgrammer1) 6/29/2019 |
\*-----------------------------------------*/
#include "i2c_smbus.h"
#pragma once
typedef unsigned char hyperx_dev_id;
typedef unsigned short hyperx_register;
enum
{
HYPERX_REG_BRIGHTNESS = 0xDD, /* Brightness control register (0-100) */
HYPERX_REG_APPLY = 0xE1, /* Apply changes register */
HYPERX_REG_MODE1 = 0xE3, /* Mode control register 1 */
HYPERX_REG_MODE2 = 0xE4, /* Mode control register 2 */
HYPERX_REG_RED = 0xEC, /* Red color register */
HYPERX_REG_GREEN = 0xED, /* Green color register */
HYPERX_REG_BLUE = 0xEE, /* Blue color register */
};
enum
{
HYPERX_MODE1_RAINBOW = 0x05, /* Mode 1 rainbow effect */
HYPERX_MODE1_CYCLE = 0x04, /* Mode 1 cycle effect */
};
enum
{
HYPERX_MODE2_BOUNCE = 0x02, /* Mode 2 bounce effect */
HYPERX_MODE2_BREATHING = 0x03, /* Mode 2 breathing effect */
HYPERX_MODE2_BLINK = 0x06, /* Mode 2 blink effect */
HYPERX_MODE2_HEARTBEAT = 0x07, /* Mode 2 heartbeat effect */
HYPERX_MODE2_COMET = 0x08, /* Mode 2 comet effect */
HYPERX_MODE2_STATIC = 0x09, /* Mode 2 static effect */
};
enum
{
HYPERX_MODE_STATIC = 0, /* Static color mode */
HYPERX_MODE_RAINBOW = 1, /* Rainbow wave mode */
HYPERX_MODE_COMET = 2, /* Comet (chase) mode */
HYPERX_MODE_HEARTBEAT = 3, /* Heartbeat (pulsing) mode */
HYPERX_MODE_CYCLE = 4, /* Spectrum cycle mode */
HYPERX_MODE_BREATHING = 5, /* Breathing mode */
HYPERX_MODE_BOUNCE = 6, /* Bounce mode */
HYPERX_MODE_BLINK = 7, /* Blinking mode */
HYPERX_NUMBER_MODES /* Number of HyperX modes */
};
class HyperXController
{
public:
HyperXController(i2c_smbus_interface* bus, hyperx_dev_id dev);
~HyperXController();
char* GetDeviceName();
unsigned int GetLEDCount();
void SetMode(unsigned char mode);
void SetAllColors(unsigned char red, unsigned char green, unsigned char blue);
void SetLEDColor(unsigned int led, unsigned char red, unsigned char green, unsigned char blue);
private:
char device_name[32];
unsigned int led_count;
i2c_smbus_interface* bus;
hyperx_dev_id dev;
};

63
OpenAuraSDK/OpenAuraSDK.cpp
View file

@ -8,9 +8,11 @@
#include "AuraController.h"
#include "CorsairController.h"
#include "HyperXController.h"
#include "RGBController.h"
#include "RGBController_Aura.h"
#include "RGBController_Corsair.h"
#include "RGBController_HyperX.h"
#include "RGBController_OpenRazer.h"
#include "RGBController_AorusGPU.h"
#include "RGBController_LEDStrip.h"
@ -42,6 +44,7 @@
std::vector<AuraController*> aura_controllers;
std::vector<CorsairController*> corsair_controllers;
std::vector<HyperXController*> hyperx_controllers;
std::vector<i2c_smbus_interface*> busses;
std::vector<RGBController*> rgb_controllers;
@ -387,6 +390,30 @@ bool TestForCorsairController(i2c_smbus_interface* bus, unsigned char address)
} /* TestForCorsairController() */
/******************************************************************************************\
* *
* TestForHyperXController *
* *
* Tests the given address to see if a HyperX controller exists there. *
* *
\******************************************************************************************/
bool TestForHyperXController(i2c_smbus_interface* bus, unsigned char address)
{
bool pass = false;
int res = bus->i2c_smbus_write_quick(address, I2C_SMBUS_WRITE);
if (res >= 0)
{
pass = true;
}
return(pass);
} /* TestForHyperXController() */
/******************************************************************************************\
* *
* DetectAuraControllers *
@ -528,6 +555,34 @@ void DetectCorsairControllers()
} /* DetectCorsairControllers() */
/******************************************************************************************\
* *
* DetectHyperXControllers *
* *
* Detect HyperX controllers on the enumerated I2C busses. *
* *
* bus - pointer to i2c_smbus_interface where Aura device is connected *
* dev - I2C address of Aura device *
* *
\******************************************************************************************/
void DetectHyperXControllers()
{
HyperXController* new_controller;
for (unsigned int bus = 0; bus < busses.size(); bus++)
{
// Check for HyperX controller at 0x27
if (TestForCorsairController(busses[bus], 0x27))
{
new_controller = new HyperXController(busses[bus], 0x27);
hyperx_controllers.push_back(new_controller);
}
}
} /* DetectHyperXControllers() */
/******************************************************************************************\
* *
* DetectI2C *
@ -654,6 +709,7 @@ void DetectRGBControllers(void)
DetectAuraControllers();
DetectCorsairControllers();
DetectHyperXControllers();
for (int i = 0; i < aura_controllers.size(); i++)
{
@ -669,6 +725,13 @@ void DetectRGBControllers(void)
rgb_controllers.push_back(corsair_rgb);
}
for (int i = 0; i < hyperx_controllers.size(); i++)
{
RGBController_HyperX* hyperx_rgb = new RGBController_HyperX(hyperx_controllers[i]);
rgb_controllers.push_back(hyperx_rgb);
}
//This is only for testing, hard-coding the OpenRazer path for my mouse
#if 0
RGBController_OpenRazer * razer_rgb = new RGBController_OpenRazer("/sys/bus/hid/drivers/razermouse/0003:1532:0046.0004");

4
OpenAuraSDK/OpenAuraSDK.vcxproj
View file

@ -179,6 +179,7 @@
<ItemGroup>
<ClInclude Include="AuraController.h" />
<ClInclude Include="CorsairController.h" />
<ClInclude Include="HyperXController.h" />
<ClInclude Include="I2CDetectDialog.h" />
<ClInclude Include="i2c_smbus.h" />
<ClInclude Include="i2c_smbus_i801.h" />
@ -189,6 +190,7 @@
<ClInclude Include="OpenAuraSDKDialog.h" />
<ClInclude Include="resource.h" />
<ClInclude Include="RGBController.h" />
<ClInclude Include="RGBController_HyperX.h" />
<ClInclude Include="RGBController_AorusGPU.h" />
<ClInclude Include="RGBController_Aura.h" />
<ClInclude Include="RGBController_Corsair.h" />
@ -200,6 +202,7 @@
<ClCompile Include="AuraController.cpp" />
<ClCompile Include="CorsairController.cpp" />
<ClCompile Include="dllmain.cpp" />
<ClCompile Include="HyperXController.cpp" />
<ClCompile Include="I2CDetectDialog.cpp" />
<ClCompile Include="i2c_smbus.cpp" />
<ClCompile Include="i2c_smbus_i801.cpp" />
@ -211,6 +214,7 @@
<ClCompile Include="RGBController_AorusGPU.cpp" />
<ClCompile Include="RGBController_Aura.cpp" />
<ClCompile Include="RGBController_Corsair.cpp" />
<ClCompile Include="RGBController_HyperX.cpp" />
<ClCompile Include="RGBController_LEDStrip.cpp" />
<ClCompile Include="serial_port.cpp" />
<ClCompile Include="wmi.cpp" />

12
OpenAuraSDK/OpenAuraSDK.vcxproj.filters
View file

@ -69,6 +69,12 @@
<ClInclude Include="LEDStrip.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="HyperXController.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="RGBController_HyperX.h">
<Filter>Header Files</Filter>
</ClInclude>
</ItemGroup>
<ItemGroup>
<ClCompile Include="OpenAuraSDK.cpp">
@ -125,6 +131,12 @@
<ClCompile Include="serial_port.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="HyperXController.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="RGBController_HyperX.cpp">
<Filter>Source Files</Filter>
</ClCompile>
</ItemGroup>
<ItemGroup>
<ResourceCompile Include="Resource.rc">

106
OpenAuraSDK/RGBController_HyperX.cpp Normal file
View file

@ -0,0 +1,106 @@
/*-----------------------------------------*\
| RGBController_HyperX.cpp |
| |
| Generic RGB Interface for OpenAuraSDK |
| HyperX Predator RGB interface |
| |
| Adam Honse (CalcProgrammer1) 6/29/2019 |
\*-----------------------------------------*/
#include "RGBController_HyperX.h"
int RGBController_HyperX::GetMode()
{
return(0);
}
void RGBController_HyperX::SetMode(int mode)
{
hyperx->SetMode(mode);
}
void RGBController_HyperX::SetCustomMode()
{
hyperx->SetMode(HYPERX_MODE_STATIC);
}
void RGBController_HyperX::SetAllLEDs(RGBColor color)
{
unsigned char red = RGBGetRValue(color);
unsigned char grn = RGBGetGValue(color);
unsigned char blu = RGBGetBValue(color);
hyperx->SetAllColors(red, grn, blu);
}
void RGBController_HyperX::SetAllZoneLEDs(int zone, RGBColor color)
{
unsigned char red = RGBGetRValue(color);
unsigned char grn = RGBGetGValue(color);
unsigned char blu = RGBGetBValue(color);
for (int x = 0; x < zones[zone].map.size(); x++)
{
for (int y = 0; y < zones[zone].map[x].size(); y++)
{
hyperx->SetLEDColor(zones[zone].map[x][y], red, grn, blu);
}
}
}
void RGBController_HyperX::SetLED(int led, RGBColor color)
{
unsigned char red = RGBGetRValue(color);
unsigned char grn = RGBGetGValue(color);
unsigned char blu = RGBGetBValue(color);
hyperx->SetLEDColor(led, red, grn, blu);
}
RGBController_HyperX::RGBController_HyperX(HyperXController* hyperx_ptr)
{
hyperx = hyperx_ptr;
name = hyperx->GetDeviceName();
mode hyperx_modes[HYPERX_NUMBER_MODES];
hyperx_modes[0].name = "Static";
hyperx_modes[1].name = "Rainbow";
hyperx_modes[2].name = "Comet";
hyperx_modes[3].name = "Heartbeat";
hyperx_modes[4].name = "Spectrum Cycle";
hyperx_modes[5].name = "Breathing";
hyperx_modes[6].name = "Bounce";
hyperx_modes[7].name = "Blink";
for (int i = 0; i < HYPERX_NUMBER_MODES; i++)
{
modes.push_back(hyperx_modes[i]);
}
for (int i = 0; i < hyperx->GetLEDCount(); i++)
{
led* new_led = new led();
new_led->name = "HyperX LED";
leds.push_back(*new_led);
}
zone new_zone;
new_zone.name = "HyperX Zone";
new_zone.type = ZONE_TYPE_SINGLE;
std::vector<int> zone_row;
for (int i = 0; i < hyperx->GetLEDCount(); i++)
{
zone_row.push_back(i);
}
new_zone.map.push_back(zone_row);
zones.push_back(new_zone);
}

28
OpenAuraSDK/RGBController_HyperX.h Normal file
View file

@ -0,0 +1,28 @@
/*-----------------------------------------*\
| RGBController_HyperX.h |
| |
| Generic RGB Interface for OpenAuraSDK |
| HyperX Predator RGB interface |
| |
| Adam Honse (CalcProgrammer1) 6/29/2019 |
\*-----------------------------------------*/
#pragma once
#include "RGBController.h"
#include "HyperXController.h"
class RGBController_HyperX : public RGBController
{
public:
RGBController_HyperX(HyperXController* hyperx_ptr);
int GetMode();
void SetMode(int mode);
void SetCustomMode();
void SetAllLEDs(RGBColor color);
void SetAllZoneLEDs(int zone, RGBColor color);
void SetLED(int led, RGBColor color);
private:
HyperXController* hyperx;
};