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

Update Redragon code, split mouse and keyboard into their own controllers, and get mouse control working

Browse source
This commit is contained in:
Adam Honse 2020-03-25 20:44:59 -05:00
parent 7c221416cc
commit ad85efcb14
8 changed files with 383 additions and 152 deletions
Download patch file Download diff file Expand all files Collapse all files

32
Controllers/RedragonController/RedragonControllerDetect.cpp
View file

@ -1,5 +1,7 @@
#include "RedragonController.h" #include "RedragonK556Controller.h"
#include "RedragonM711Controller.h"
#include "RGBController.h" #include "RGBController.h"
#include "RGBController_RedragonM711.h"
#include "RGBController_Dummy.h" #include "RGBController_Dummy.h"
#include <vector> #include <vector>
#include <hidapi/hidapi.h> #include <hidapi/hidapi.h>
@ -81,16 +83,28 @@ void DetectRedragonControllers(std::vector<RGBController*>& rgb_controllers)
if( dev ) if( dev )
{ {
RedragonController* controller = new RedragonController(dev); switch(device_list[device_idx].type)
{
case DEVICE_TYPE_KEYBOARD:
{
RedragonK556Controller* controller = new RedragonK556Controller(dev);
RGBController_Dummy* rgb_controller = new RGBController_Dummy();
//if(controller->GetDeviceType() != DEVICE_TYPE_UNKNOWN) rgb_controller->name = device_list[device_idx].name;
//{
RGBController_Dummy* rgb_controller = new RGBController_Dummy(); rgb_controllers.push_back(rgb_controller);
}
break;
rgb_controller->name = device_list[device_idx].name; case DEVICE_TYPE_MOUSE:
{
rgb_controllers.push_back(rgb_controller); RedragonM711Controller* controller = new RedragonM711Controller(dev);
//}
RGBController_RedragonM711* rgb_controller = new RGBController_RedragonM711(controller);
rgb_controllers.push_back(rgb_controller);
}
break;
}
} }
} }
} }

176
Controllers/RedragonController/RedragonController.cpp → Controllers/RedragonController/RedragonK556Controller.cpp
View file

@ -1,74 +1,69 @@
#include "RedragonController.h" #include "RedragonK556Controller.h"
#include <cstring> #include <cstring>
static void send_usb_msg(hid_device* dev, char * data_pkt, unsigned int size) RedragonK556Controller::RedragonK556Controller(hid_device* dev_handle)
{
char* usb_pkt = new char[size + 1];
usb_pkt[0] = 0x04;
for(int i = 1; i < size + 1; i++)
{
usb_pkt[i] = data_pkt[i-1];
}
hid_write(dev, (unsigned char *)usb_pkt, size + 1);
delete usb_pkt;
}
static void get_usb_msg(hid_device* dev, char* data_pkt, unsigned int size)
{
char usb_pkt[65];
usb_pkt[0] = 0x00;
for(int i = 1; i < 65; i++)
{
usb_pkt[i] = data_pkt[i-1];
}
int bytes = hid_get_feature_report(dev, (unsigned char*)data_pkt, size);
}
RedragonController::RedragonController(hid_device* dev_handle)
{ {
dev = dev_handle; dev = dev_handle;
//SendMouseMode(REDRAGON_MODE_STATIC, 0x01, 0x00, 0xFF, 0xFF); unsigned char color_data[0x36 * 7];
//SendMouseApply();
unsigned char color_data[0x36];
for(int i = 0; i < 0x36; i += 3)
{
color_data[i] = 0xFF;
color_data[i+1] = 0x00;
color_data[i+2] = 0x00;
}
color_data[51] = 0xFF;
color_data[52] = 0xFF;
color_data[53] = 0xFF;
SendKeyboardBegin(); SendKeyboardBegin();
SendKeyboardMode(REDRAGON_K556_MODE_CUSTOM); SendKeyboardMode(20);
SendKeyboardData for(int i = 0; i < 0x36 * 7; i += 3)
{
color_data[i] = 0x00;
color_data[i+1] = 0xff;
color_data[i+2] = 0x00;
}
SetKeyboardColors
( (
color_data, color_data,
0x36, 0x36 * 6
0x36 + 0x36 + 0x36 + 0x36 + 0x36 + 0x36
); );
SendKeyboardEnd(); SendKeyboardEnd();
} }
void RedragonK556Controller::SetKeyboardColors
(
unsigned char * color_data,
unsigned int size
)
{
unsigned int packet_size = 0;
unsigned int packet_offset = 0;
while(size > 0)
{
if(size >= REDRAGON_K556_MAX_PACKET_SIZE)
{
packet_size = REDRAGON_K556_MAX_PACKET_SIZE;
}
else
{
packet_size = size;
}
SendKeyboardData
(
&color_data[packet_offset],
packet_size,
packet_offset
);
size -= packet_size;
packet_offset += packet_size;
}
}
/*-------------------------------------------------------------------------------------------------*\ /*-------------------------------------------------------------------------------------------------*\
| Private packet sending functions. | | Private packet sending functions. |
\*-------------------------------------------------------------------------------------------------*/ \*-------------------------------------------------------------------------------------------------*/
/*-----------------------------------------------------------------------------------------*\ void RedragonK556Controller::SendKeyboardBegin()
| Keyboard functions |
\*-----------------------------------------------------------------------------------------*/
void RedragonController::SendKeyboardBegin()
{ {
char usb_buf[64]; char usb_buf[64];
@ -92,7 +87,7 @@ void RedragonController::SendKeyboardBegin()
hid_read(dev, (unsigned char *)usb_buf, 64); hid_read(dev, (unsigned char *)usb_buf, 64);
} }
void RedragonController::SendKeyboardData void RedragonK556Controller::SendKeyboardData
( (
unsigned char * data, unsigned char * data,
unsigned char data_size, unsigned char data_size,
@ -129,7 +124,7 @@ void RedragonController::SendKeyboardData
hid_read(dev, (unsigned char *)usb_buf, 64); hid_read(dev, (unsigned char *)usb_buf, 64);
} }
void RedragonController::SendKeyboardMode void RedragonK556Controller::SendKeyboardMode
( (
unsigned char mode unsigned char mode
) )
@ -145,7 +140,7 @@ void RedragonController::SendKeyboardMode
| Set up Keyboard End packet | | Set up Keyboard End packet |
\*-----------------------------------------------------*/ \*-----------------------------------------------------*/
usb_buf[0x00] = 0x04; usb_buf[0x00] = 0x04;
usb_buf[0x01] = 0x08 + mode; usb_buf[0x01] = 0x00;
usb_buf[0x02] = 0x00; usb_buf[0x02] = 0x00;
usb_buf[0x03] = 0x06; usb_buf[0x03] = 0x06;
usb_buf[0x04] = 0x01; usb_buf[0x04] = 0x01;
@ -159,7 +154,7 @@ void RedragonController::SendKeyboardMode
hid_read(dev, (unsigned char *)usb_buf, 64); hid_read(dev, (unsigned char *)usb_buf, 64);
} }
void RedragonController::SendKeyboardEnd() void RedragonK556Controller::SendKeyboardEnd()
{ {
char usb_buf[64]; char usb_buf[64];
@ -181,71 +176,4 @@ void RedragonController::SendKeyboardEnd()
\*-----------------------------------------------------*/ \*-----------------------------------------------------*/
hid_write(dev, (unsigned char *)usb_buf, 64); hid_write(dev, (unsigned char *)usb_buf, 64);
hid_read(dev, (unsigned char *)usb_buf, 64); hid_read(dev, (unsigned char *)usb_buf, 64);
} }
/*-----------------------------------------------------------------------------------------*\
| Mouse functions |
\*-----------------------------------------------------------------------------------------*/
void RedragonController::SendMouseApply()
{
char usb_buf[16];
/*-----------------------------------------------------*\
| Zero out buffer |
\*-----------------------------------------------------*/
memset(usb_buf, 0x00, sizeof(usb_buf));
/*-----------------------------------------------------*\
| Set up Apply packet |
\*-----------------------------------------------------*/
usb_buf[0x00] = 0x02;
usb_buf[0x01] = 0xF1;
usb_buf[0x02] = 0x02;
usb_buf[0x03] = 0x04;
/*-----------------------------------------------------*\
| Send packet |
\*-----------------------------------------------------*/
send_usb_msg(dev, usb_buf, 16);
}
void RedragonController::SendMouseMode
(
unsigned char mode,
unsigned char speed,
unsigned char red,
unsigned char green,
unsigned char blue
)
{
char usb_buf[16];
/*-----------------------------------------------------*\
| Zero out buffer |
\*-----------------------------------------------------*/
memset(usb_buf, 0x00, sizeof(usb_buf));
/*-----------------------------------------------------*\
| Set up Lighting Control packet |
\*-----------------------------------------------------*/
usb_buf[0x00] = 0x02;
usb_buf[0x01] = 0xF3;
usb_buf[0x02] = 0x49;
usb_buf[0x03] = 0x04;
usb_buf[0x04] = 0x06;
usb_buf[0x08] = red;
usb_buf[0x09] = green;
usb_buf[0x0A] = blue;
usb_buf[0x0B] = 0x01; //on
usb_buf[0x0C] = speed;
usb_buf[0x0D] = mode;
/*-----------------------------------------------------*\
| Send packet |
\*-----------------------------------------------------*/
send_usb_msg(dev, usb_buf, 16);
}

32
Controllers/RedragonController/RedragonController.h → Controllers/RedragonController/RedragonK556Controller.h
View file

@ -1,9 +1,8 @@
/*-----------------------------------------*\ /*-----------------------------------------*\
| RedragonController.h | | RedragonK556Controller.h |
| | | |
| Definitions and types for Redragon RGB | | Definitions and types for Redragon K556 |
| keyboard, mouse, and mousemat lighting | | Devarajas keyboard lighting controller |
| controller |
| | | |
| Adam Honse (CalcProgrammer1) 3/15/2020 | | Adam Honse (CalcProgrammer1) 3/15/2020 |
\*-----------------------------------------*/ \*-----------------------------------------*/
@ -15,6 +14,9 @@
#pragma once #pragma once
#define REDRAGON_K556_MAX_PACKET_SIZE ( 0x36 ) /* max packet size for color*/
/* update packets */
enum enum
{ {
REDRAGON_K556_MODE_RAINBOW_WAVE_SHORT = 0x01, /* "Go with the stream" */ REDRAGON_K556_MODE_RAINBOW_WAVE_SHORT = 0x01, /* "Go with the stream" */
@ -37,22 +39,18 @@ enum
REDRAGON_K556_MODE_CUSTOM = 0x14, /* "Coastal" */ REDRAGON_K556_MODE_CUSTOM = 0x14, /* "Coastal" */
}; };
enum class RedragonK556Controller
{
REDRAGON_M117_MODE_WAVE = 0x00,
REDRAGON_M117_MODE_RANDOM_BREATHING = 0x01,
REDRAGON_M117_MODE_STATIC = 0x02,
REDRAGON_M117_MODE_BREATHING = 0x04,
REDRAGON_M117_MODE_RAINBOW = 0x08,
REDRAGON_M117_MODE_FLASHING = 0x10,
};
class RedragonController
{ {
public: public:
RedragonController(hid_device* dev_handle); RedragonK556Controller(hid_device* dev_handle);
~RedragonController(); ~RedragonK556Controller();
void SetKeyboardColors
(
unsigned char * color_data,
unsigned int size
);
private: private:
hid_device* dev; hid_device* dev;

90
Controllers/RedragonController/RedragonM711Controller.cpp Normal file
View file

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

46
Controllers/RedragonController/RedragonM711Controller.h Normal file
View file

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

8
OpenRGB.pro
View file

@ -118,7 +118,8 @@ SOURCES += \
Controllers/RGBFusion2USBController/RGBFusion2USBControllerDetect.cpp \ Controllers/RGBFusion2USBController/RGBFusion2USBControllerDetect.cpp \
Controllers/RGBFusionGPUController/RGBFusionGPUController.cpp \ Controllers/RGBFusionGPUController/RGBFusionGPUController.cpp \
Controllers/RGBFusionGPUController/RGBFusionGPUControllerDetect.cpp \ Controllers/RGBFusionGPUController/RGBFusionGPUControllerDetect.cpp \
Controllers/RedragonController/RedragonController.cpp \ Controllers/RedragonController/RedragonK556Controller.cpp \
Controllers/RedragonController/RedragonM711Controller.cpp \
Controllers/RedragonController/RedragonControllerDetect.cpp \ Controllers/RedragonController/RedragonControllerDetect.cpp \
Controllers/ThermaltakeRiingController/ThermaltakeRiingController.cpp \ Controllers/ThermaltakeRiingController/ThermaltakeRiingController.cpp \
Controllers/ThermaltakeRiingController/ThermaltakeRiingControllerDetect.cpp \ Controllers/ThermaltakeRiingController/ThermaltakeRiingControllerDetect.cpp \
@ -144,6 +145,7 @@ SOURCES += \
RGBController/RGBController_PatriotViper.cpp \ RGBController/RGBController_PatriotViper.cpp \
RGBController/RGBController_Polychrome.cpp \ RGBController/RGBController_Polychrome.cpp \
RGBController/RGBController_PoseidonZRGB.cpp \ RGBController/RGBController_PoseidonZRGB.cpp \
RGBController/RGBController_RedragonM711.cpp \
RGBController/RGBController_RGBFusion.cpp \ RGBController/RGBController_RGBFusion.cpp \
RGBController/RGBController_RGBFusion2USB.cpp \ RGBController/RGBController_RGBFusion2USB.cpp \
RGBController/RGBController_RGBFusionGPU.cpp \ RGBController/RGBController_RGBFusionGPU.cpp \
@ -186,7 +188,8 @@ HEADERS += \
Controllers/RGBFusionController/RGBFusionController.h \ Controllers/RGBFusionController/RGBFusionController.h \
Controllers/RGBFusion2USBController/RGBFusion2USBController.h \ Controllers/RGBFusion2USBController/RGBFusion2USBController.h \
Controllers/RGBFusionGPUController/RGBFusionGPUController.h \ Controllers/RGBFusionGPUController/RGBFusionGPUController.h \
Controllers/RedragonController/RedragonController.h \ Controllers/RedragonController/RedragonK556Controller.h \
Controllers/RedragonController/RedragonM711Controller.h \
Controllers/ThermaltakeRiingController/ThermaltakeRiingController.h \ Controllers/ThermaltakeRiingController/ThermaltakeRiingController.h \
RGBController/RGBController.h \ RGBController/RGBController.h \
RGBController/RGBController_AMDWraithPrism.h \ RGBController/RGBController_AMDWraithPrism.h \
@ -209,6 +212,7 @@ HEADERS += \
RGBController/RGBController_PatriotViper.h \ RGBController/RGBController_PatriotViper.h \
RGBController/RGBController_Polychrome.h \ RGBController/RGBController_Polychrome.h \
RGBController/RGBController_PoseidonZRGB.h \ RGBController/RGBController_PoseidonZRGB.h \
RGBController/RGBController_RedragonM711.h \
RGBController/RGBController_RGBFusion.h \ RGBController/RGBController_RGBFusion.h \
RGBController/RGBController_RGBFusion2USB.h \ RGBController/RGBController_RGBFusion2USB.h \
RGBController/RGBController_RGBFusionGPU.h \ RGBController/RGBController_RGBFusionGPU.h \

119
RGBController/RGBController_RedragonM711.cpp Normal file
View file

@ -0,0 +1,119 @@
/*-----------------------------------------*\
| RGBController_RedragonM711.h |
| |
| Generic RGB Interface for Redragon M711 |
| Cobra RGB Mouse |
| |
| Adam Honse (CalcProgrammer1) 3/25/2020 |
\*-----------------------------------------*/
#include "RGBController_RedragonM711.h"
RGBController_RedragonM711::RGBController_RedragonM711(RedragonM711Controller* redragon_ptr)
{
redragon = redragon_ptr;
name = "Redragon M711 Cobra";
type = DEVICE_TYPE_MOUSE;
description = "Redragon M711 Device";
mode Wave;
Wave.name = "Wave";
Wave.value = REDRAGON_M711_MODE_WAVE;
Wave.flags = MODE_FLAG_HAS_PER_LED_COLOR;
Wave.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Wave);
mode Breathing;
Breathing.name = "Breathing";
Breathing.value = REDRAGON_M711_MODE_BREATHING;
Breathing.flags = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
Breathing.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Breathing);
mode Static;
Static.name = "Static";
Static.value = REDRAGON_M711_MODE_STATIC;
Static.flags = MODE_FLAG_HAS_PER_LED_COLOR;
Static.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Static);
mode Rainbow;
Rainbow.name = "Rainbow";
Rainbow.value = REDRAGON_M711_MODE_RAINBOW;
Rainbow.flags = 0;
Rainbow.color_mode = MODE_COLORS_NONE;
modes.push_back(Rainbow);
mode Flashing;
Flashing.name = "Flashing";
Flashing.value = REDRAGON_M711_MODE_FLASHING;
Flashing.flags = MODE_FLAG_HAS_PER_LED_COLOR;
Flashing.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Flashing);
SetupZones();
}
void RGBController_RedragonM711::SetupZones()
{
zone m711_zone;
m711_zone.name = "Mouse Zone";
m711_zone.type = ZONE_TYPE_SINGLE;
m711_zone.leds_min = 1;
m711_zone.leds_max = 1;
m711_zone.leds_count = 1;
zones.push_back(m711_zone);
led m711_led;
m711_led.name = "Mouse LED";
leds.push_back(m711_led);
SetupColors();
}
void RGBController_RedragonM711::ResizeZone(int /*zone*/, int /*new_size*/)
{
/*---------------------------------------------------------*\
| This device does not support resizing zones |
\*---------------------------------------------------------*/
}
void RGBController_RedragonM711::UpdateLEDs()
{
bool random = (modes[active_mode].color_mode == MODE_COLORS_RANDOM);
unsigned char red = RGBGetRValue(colors[0]);
unsigned char grn = RGBGetGValue(colors[0]);
unsigned char blu = RGBGetBValue(colors[0]);
if((modes[active_mode].value == REDRAGON_M711_MODE_BREATHING) && random)
{
redragon->SendMouseMode(REDRAGON_M711_MODE_RANDOM_BREATHING, 0, red, grn, blu);
}
else
{
redragon->SendMouseMode(modes[active_mode].value, 0, red, grn, blu);
}
redragon->SendMouseApply();
}
void RGBController_RedragonM711::UpdateZoneLEDs(int /*zone*/)
{
UpdateLEDs();
}
void RGBController_RedragonM711::UpdateSingleLED(int /*led*/)
{
UpdateLEDs();
}
void RGBController_RedragonM711::SetCustomMode()
{
}
void RGBController_RedragonM711::UpdateMode()
{
UpdateLEDs();
}

32
RGBController/RGBController_RedragonM711.h Normal file
View file

@ -0,0 +1,32 @@
/*-----------------------------------------*\
| RGBController_RedragonM711.h |
| |
| Generic RGB Interface for Redragon M711 |
| Cobra RGB Mouse |
| |
| Adam Honse (CalcProgrammer1) 3/25/2020 |
\*-----------------------------------------*/
#pragma once
#include "RGBController.h"
#include "RedragonM711Controller.h"
class RGBController_RedragonM711 : public RGBController
{
public:
RGBController_RedragonM711(RedragonM711Controller* redragon_ptr);
void SetupZones();
void ResizeZone(int zone, int new_size);
void UpdateLEDs();
void UpdateZoneLEDs(int zone);
void UpdateSingleLED(int led);
void SetCustomMode();
void UpdateMode();
private:
RedragonM711Controller* redragon;
};