mirror/OpenRGB
1
0
Fork 0
mirror of https://github.com/CalcProgrammer1/OpenRGB.git synced 2026-04-26 00:38:10 -04:00
Code Issues Packages Projects Releases Wiki Activity

Initial controller for HyperX Alloy Origins

Browse Source
This commit is contained in:
Adam Honse
2020-07-12 00:31:40 -05:00
parent 30625548e5
commit 751961b3b3
6 changed files with 313 additions and 5 deletions
Download Patch File Download Diff File Expand all files Collapse all files

116
Controllers/HyperXKeyboardController/HyperXAlloyOriginsController.cpp Normal file
View File

@@ -0,0 +1,116 @@
/*-----------------------------------------*\
| HyperXAlloyOriginsController.cpp |
| |
| Driver for HyperX Alloy Origins RGB |
| Keyboard lighting controller |
| |
| Adam Honse (CalcProgrammer1) 7/11/2020 |
\*-----------------------------------------*/
#include "HyperXAlloyOriginsController.h"
#include <cstring>
HyperXAlloyOriginsController::HyperXAlloyOriginsController(hid_device* dev_handle)
{
dev = dev_handle;
}
HyperXAlloyOriginsController::~HyperXAlloyOriginsController()
{
}
void HyperXAlloyOriginsController::SetLEDsDirect(std::vector<RGBColor> colors)
{
int colors_to_send = colors.size();
int colors_sent = 0;
SendDirectInitialization();
for(int pkt_idx = 0; pkt_idx < 9; pkt_idx++)
{
if(colors_to_send > 16)
{
SendDirectColorPacket(&colors[colors_sent], 16);
colors_sent += 16;
colors_to_send -= 16;
}
else if(colors_to_send > 0)
{
SendDirectColorPacket(&colors[colors_sent], colors_to_send);
colors_sent += colors_to_send;
colors_to_send -= colors_to_send;
}
else
{
RGBColor temp = 0x00000000;
SendDirectColorPacket(&temp, 1);
}
}
}
void HyperXAlloyOriginsController::SendDirectInitialization()
{
unsigned char buf[65];
/*-----------------------------------------------------*\
| Zero out buffer |
\*-----------------------------------------------------*/
memset(buf, 0x00, sizeof(buf));
/*-----------------------------------------------------*\
| Set up Direct Initialization packet |
\*-----------------------------------------------------*/
buf[0x00] = 0x00;
buf[0x01] = 0x04;
buf[0x02] = 0x02;
/*-----------------------------------------------------*\
| Send packet |
\*-----------------------------------------------------*/
hid_send_feature_report(dev, buf, 65);
}
void HyperXAlloyOriginsController::SendDirectColorPacket
(
RGBColor* color_data,
unsigned int color_count
)
{
unsigned char buf[65];
/*-----------------------------------------------------*\
| Zero out buffer |
\*-----------------------------------------------------*/
memset(buf, 0x00, sizeof(buf));
/*-----------------------------------------------------*\
| Set up Direct Initialization packet |
\*-----------------------------------------------------*/
buf[0x00] = 0x00;
/*-----------------------------------------------------*\
| The maximum number of colors per packet is 16 |
\*-----------------------------------------------------*/
if(color_count > 16)
{
color_count = 16;
}
/*-----------------------------------------------------*\
| Copy in color data |
\*-----------------------------------------------------*/
for(int color_idx = 0; color_idx < color_count; color_idx++)
{
buf[(color_idx * 4) + 1] = 0x08;
buf[(color_idx * 4) + 2] = RGBGetRValue(color_data[color_idx]);
buf[(color_idx * 4) + 3] = RGBGetGValue(color_data[color_idx]);
buf[(color_idx * 4) + 4] = RGBGetBValue(color_data[color_idx]);
}
/*-----------------------------------------------------*\
| Send packet |
\*-----------------------------------------------------*/
hid_send_feature_report(dev, buf, 65);
}

34
Controllers/HyperXKeyboardController/HyperXAlloyOriginsController.h Normal file
View File

@@ -0,0 +1,34 @@
/*-----------------------------------------*\
| HyperXAlloyOriginsController.h |
| |
| Definitions and types for HyperX Alloy |
| Origins RGB Keyboard lighting controller |
| |
| Adam Honse (CalcProgrammer1) 7/11/2020 |
\*-----------------------------------------*/
#include "RGBController.h"
#include <string>
#include <hidapi/hidapi.h>
#pragma once
class HyperXAlloyOriginsController
{
public:
HyperXAlloyOriginsController(hid_device* dev_handle);
~HyperXAlloyOriginsController();
void SetLEDsDirect(std::vector<RGBColor> colors);
private:
hid_device* dev;
void SendDirectInitialization();
void SendDirectColorPacket
(
RGBColor* color_data,
unsigned int color_count
);
};

27
Controllers/HyperXKeyboardController/HyperXKeyboardControllerDetect.cpp
View File

@@ -1,5 +1,7 @@
#include "HyperXAlloyOriginsController.h"
#include "HyperXKeyboardController.h"
#include "RGBController.h"
#include "RGBController_HyperXAlloyOrigins.h"
#include "RGBController_HyperXKeyboard.h"
#include <vector>
#include <hidapi/hidapi.h>
@@ -10,6 +12,7 @@
#define HYPERX_KEYBOARD_VID 0x0951
#define HYPERX_ALLOY_ELITE_PID 0x16BE
#define HYPERX_ALLOY_FPS_RGB_PID 0x16DC
#define HYPERX_ALLOY_ORIGINS_PID 0x16E5
typedef struct
{
@@ -28,6 +31,7 @@ static const hyperx_device device_list[] =
\*-----------------------------------------------------------------------------------------------------*/
{ HYPERX_KEYBOARD_VID, HYPERX_ALLOY_ELITE_PID, 2, "HyperX Alloy Elite RGB" },
{ HYPERX_KEYBOARD_VID, HYPERX_ALLOY_FPS_RGB_PID, 2, "HyperX Alloy FPS RGB" },
{ HYPERX_KEYBOARD_VID, HYPERX_ALLOY_ORIGINS_PID, 2, "HyperX Alloy Origins" },
};
/******************************************************************************************\
@@ -69,13 +73,26 @@ void DetectHyperXKeyboardControllers(std::vector<RGBController*>& rgb_controller
if( dev )
{
HyperXKeyboardController* controller = new HyperXKeyboardController(dev);
if(device_list[device_idx].usb_pid == HYPERX_ALLOY_ORIGINS_PID)
{
HyperXAlloyOriginsController* controller = new HyperXAlloyOriginsController(dev);
RGBController_HyperXKeyboard* rgb_controller = new RGBController_HyperXKeyboard(controller);
RGBController_HyperXAlloyOrigins* rgb_controller = new RGBController_HyperXAlloyOrigins(controller);
rgb_controller->name = device_list[device_idx].name;
rgb_controllers.push_back(rgb_controller);
rgb_controller->name = device_list[device_idx].name;
rgb_controllers.push_back(rgb_controller);
}
else
{
HyperXKeyboardController* controller = new HyperXKeyboardController(dev);
RGBController_HyperXKeyboard* rgb_controller = new RGBController_HyperXKeyboard(controller);
rgb_controller->name = device_list[device_idx].name;
rgb_controllers.push_back(rgb_controller);
}
}
}
}

4
OpenRGB.pro
View File

@@ -124,6 +124,7 @@ HEADERS += \
Controllers/GloriousModelOController/GloriousModelOController.h \
Controllers/HuePlusController/HuePlusController.h \
Controllers/HyperXDRAMController/HyperXDRAMController.h \
Controllers/HyperXKeyboardController/HyperXAlloyOriginsController.h \
Controllers/HyperXKeyboardController/HyperXKeyboardController.h \
Controllers/LEDStripController/LEDStripController.h \
Controllers/LogitechController/LogitechG203Controller.h \
@@ -165,6 +166,7 @@ HEADERS += \
RGBController/RGBController_E131.h \
RGBController/RGBController_GloriousModelO.h \
RGBController/RGBController_HuePlus.h \
RGBController/RGBController_HyperXAlloyOrigins.h \
RGBController/RGBController_HyperXDRAM.h \
RGBController/RGBController_HyperXKeyboard.h \
RGBController/RGBController_LEDStrip.h \
@@ -250,6 +252,7 @@ SOURCES += \
Controllers/HuePlusController/HuePlusControllerDetect.cpp \
Controllers/HyperXDRAMController/HyperXDRAMController.cpp \
Controllers/HyperXDRAMController/HyperXDRAMControllerDetect.cpp \
Controllers/HyperXKeyboardController/HyperXAlloyOriginsController.cpp \
Controllers/HyperXKeyboardController/HyperXKeyboardController.cpp \
Controllers/HyperXKeyboardController/HyperXKeyboardControllerDetect.cpp \
Controllers/LEDStripController/LEDStripController.cpp \
@@ -310,6 +313,7 @@ SOURCES += \
RGBController/RGBController_Dummy.cpp \
RGBController/RGBController_GloriousModelO.cpp \
RGBController/RGBController_HuePlus.cpp \
RGBController/RGBController_HyperXAlloyOrigins.cpp \
RGBController/RGBController_HyperXDRAM.cpp \
RGBController/RGBController_HyperXKeyboard.cpp \
RGBController/RGBController_E131.cpp \

103
RGBController/RGBController_HyperXAlloyOrigins.cpp Normal file
View File

@@ -0,0 +1,103 @@
/*-----------------------------------------*\
| RGBController_HyperXAlloyOrigins.cpp |
| |
| Generic RGB Interface for HyperX Alloy |
| Origins RGB Keyboard |
| |
| Adam Honse (CalcProgrammer1) 7/11/2020 |
\*-----------------------------------------*/
#include "RGBController_HyperXAlloyOrigins.h"
//0xFFFFFFFF indicates an unused entry in matrix
#define NA 0xFFFFFFFF
static unsigned int matrix_map[6][23] =
{ { 0, NA, 12, 18, 24, 30, NA, 42, 48, 54, 60, NA, 66, 72, 78, 84, 90, 96, 102, NA, NA, NA, NA },
{ 1, 7, 13, 19, 25, 31, 37, 43, 49, 55, 61, NA, 67, 73, 85, NA, 91, 97, 103, NA, NA, NA, NA },
{ 2, NA, 8, 14, 20, 26, NA, 32, 38, 44, 50, 56, 62, 68, 74, 86, 92, 98, 104, NA, NA, NA, NA },
{ 3, NA, 9, 15, 21, 27, NA, 33, 39, 45, 51, 57, 63, 69, 87, NA, NA, NA, NA, NA, NA, NA, NA },
{ 4, NA, 16, 22, 28, 34, NA, 40, NA, 46, 52, 58, 64, 70, 82, NA, NA, 100, NA, NA, NA, NA, NA },
{ 5, 11, 17, NA, NA, NA, NA, 41, NA, NA, NA, NA, 65, 77, 83, 89, 95, 101, 107, NA, NA, NA, NA } };
RGBController_HyperXAlloyOrigins::RGBController_HyperXAlloyOrigins(HyperXAlloyOriginsController* hyperx_ptr)
{
hyperx = hyperx_ptr;
name = "HyperX Alloy Origins Keyboard Device";
type = DEVICE_TYPE_KEYBOARD;
description = "HyperX Alloy Origins Keyboard Device";
mode Custom;
Custom.name = "Custom";
Custom.value = 0xFFFF;
Custom.flags = MODE_FLAG_HAS_PER_LED_COLOR;
Custom.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Custom);
SetupZones();
}
RGBController_HyperXAlloyOrigins::~RGBController_HyperXAlloyOrigins()
{
}
void RGBController_HyperXAlloyOrigins::SetupZones()
{
zone new_zone;
new_zone.name = "Keyboard";
new_zone.type = ZONE_TYPE_MATRIX;
new_zone.leds_min = 155;
new_zone.leds_max = 155;
new_zone.leds_count = 155;
new_zone.matrix_map = new matrix_map_type;
new_zone.matrix_map->height = 6;
new_zone.matrix_map->width = 23;
new_zone.matrix_map->map = (unsigned int *)&matrix_map;
zones.push_back(new_zone);
for(int led_idx = 0; led_idx < 155; led_idx++)
{
led new_led;
new_led.name = "Keyboard LED ";
new_led.name.append(std::to_string(led_idx));
leds.push_back(new_led);
}
SetupColors();
}
void RGBController_HyperXAlloyOrigins::ResizeZone(int zone, int new_size)
{
}
void RGBController_HyperXAlloyOrigins::DeviceUpdateLEDs()
{
hyperx->SetLEDsDirect(colors);
}
void RGBController_HyperXAlloyOrigins::UpdateZoneLEDs(int zone)
{
DeviceUpdateLEDs();
}
void RGBController_HyperXAlloyOrigins::UpdateSingleLED(int led)
{
DeviceUpdateLEDs();
}
void RGBController_HyperXAlloyOrigins::SetCustomMode()
{
}
void RGBController_HyperXAlloyOrigins::UpdateMode()
{
}

34
RGBController/RGBController_HyperXAlloyOrigins.h Normal file
View File

@@ -0,0 +1,34 @@
/*-----------------------------------------*\
| RGBController_HyperXAlloyOrigins.h |
| |
| Generic RGB Interface for HyperX Alloy |
| Origins RGB Keyboard |
| |
| Adam Honse (CalcProgrammer1) 7/11/2020 |
\*-----------------------------------------*/
#pragma once
#include "RGBController.h"
#include "HyperXAlloyOriginsController.h"
class RGBController_HyperXAlloyOrigins : public RGBController
{
public:
RGBController_HyperXAlloyOrigins(HyperXAlloyOriginsController* hyperx_ptr);
~RGBController_HyperXAlloyOrigins();
void SetupZones();
void ResizeZone(int zone, int new_size);
void DeviceUpdateLEDs();
void UpdateZoneLEDs(int zone);
void UpdateSingleLED(int led);
void SetCustomMode();
void UpdateMode();
private:
HyperXAlloyOriginsController* hyperx;
};