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

Refactored redragon mouse controller and added M808

Browse source
This commit is contained in:
flora 2023-01-03 13:08:41 +01:00 • committed by Adam Honse
parent 865312b7c6
commit fc1395dfe6
7 changed files with 154 additions and 153 deletions
Download patch file Download diff file Expand all files Collapse all files

83
Controllers/RedragonController/RGBController_RedragonM711.cpp → Controllers/RedragonController/RGBController_RedragonMouse.cpp
View file

@ -1,13 +1,12 @@
/*-----------------------------------------*\
| RGBController_RedragonM711.cpp |
| RGBController_RedragonMouse.cpp |
| |
| Generic RGB Interface for Redragon M711 |
| Cobra RGB Mouse |
| Generic RGB Interface for Redragon Mouse |
| |
| Adam Honse (CalcProgrammer1) 3/25/2020 |
\*-----------------------------------------*/
#include "RGBController_RedragonM711.h"
#include "RGBController_RedragonMouse.h"
/**------------------------------------------------------------------*\
@name Redragon Mice
@ -20,7 +19,7 @@
@comment
\*-------------------------------------------------------------------*/
RGBController_RedragonM711::RGBController_RedragonM711(RedragonM711Controller* controller_ptr)
RGBController_RedragonMouse::RGBController_RedragonMouse(RedragonMouseController* controller_ptr)
{
controller = controller_ptr;
@ -32,74 +31,74 @@ RGBController_RedragonM711::RGBController_RedragonM711(RedragonM711Controller* c
serial = controller->GetSerialString();
mode Static;
Static.name = "Static";
Static.value = REDRAGON_M711_MODE_STATIC;
Static.flags = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
Static.color_mode = MODE_COLORS_PER_LED;
Static.name = "Static";
Static.value = REDRAGON_MOUSE_MODE_STATIC;
Static.flags = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
Static.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Static);
mode Wave;
Wave.name = "Wave";
Wave.value = REDRAGON_M711_MODE_WAVE;
Wave.flags = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
Wave.color_mode = MODE_COLORS_PER_LED;
Wave.name = "Wave";
Wave.value = REDRAGON_MOUSE_MODE_WAVE;
Wave.flags = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
Wave.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Wave);
mode Breathing;
Breathing.name = "Breathing";
Breathing.value = REDRAGON_M711_MODE_BREATHING;
Breathing.value = REDRAGON_MOUSE_MODE_BREATHING;
Breathing.flags = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
Breathing.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Breathing);
mode Rainbow;
Rainbow.name = "Rainbow";
Rainbow.value = REDRAGON_M711_MODE_RAINBOW;
Rainbow.flags = MODE_FLAG_AUTOMATIC_SAVE;
Rainbow.color_mode = MODE_COLORS_NONE;
Rainbow.name = "Rainbow";
Rainbow.value = REDRAGON_MOUSE_MODE_RAINBOW;
Rainbow.flags = MODE_FLAG_AUTOMATIC_SAVE;
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 | MODE_FLAG_AUTOMATIC_SAVE;
Flashing.color_mode = MODE_COLORS_PER_LED;
Flashing.name = "Flashing";
Flashing.value = REDRAGON_MOUSE_MODE_FLASHING;
Flashing.flags = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
Flashing.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Flashing);
SetupZones();
}
RGBController_RedragonM711::~RGBController_RedragonM711()
RGBController_RedragonMouse::~RGBController_RedragonMouse()
{
delete controller;
}
void RGBController_RedragonM711::SetupZones()
void RGBController_RedragonMouse::SetupZones()
{
zone m711_zone;
m711_zone.name = "Mouse";
m711_zone.type = ZONE_TYPE_SINGLE;
m711_zone.leds_min = 1;
m711_zone.leds_max = 1;
m711_zone.leds_count = 1;
m711_zone.matrix_map = NULL;
zones.push_back(m711_zone);
zone mouse_zone;
mouse_zone.name = "Mouse";
mouse_zone.type = ZONE_TYPE_SINGLE;
mouse_zone.leds_min = REDRAGON_MOUSE_LED_COUNT;
mouse_zone.leds_max = REDRAGON_MOUSE_LED_COUNT;
mouse_zone.leds_count = REDRAGON_MOUSE_LED_COUNT;
mouse_zone.matrix_map = NULL;
zones.push_back(mouse_zone);
led m711_led;
m711_led.name = "Mouse";
leds.push_back(m711_led);
led mouse_led;
mouse_led.name = "Mouse";
leds.push_back(mouse_led);
SetupColors();
}
void RGBController_RedragonM711::ResizeZone(int /*zone*/, int /*new_size*/)
void RGBController_RedragonMouse::ResizeZone(int /*zone*/, int /*new_size*/)
{
/*---------------------------------------------------------*\
| This device does not support resizing zones |
\*---------------------------------------------------------*/
}
void RGBController_RedragonM711::DeviceUpdateLEDs()
void RGBController_RedragonMouse::DeviceUpdateLEDs()
{
unsigned char red = RGBGetRValue(colors[0]);
unsigned char grn = RGBGetGValue(colors[0]);
@ -109,26 +108,26 @@ void RGBController_RedragonM711::DeviceUpdateLEDs()
controller->SendMouseApply();
}
void RGBController_RedragonM711::UpdateZoneLEDs(int /*zone*/)
void RGBController_RedragonMouse::UpdateZoneLEDs(int /*zone*/)
{
DeviceUpdateLEDs();
}
void RGBController_RedragonM711::UpdateSingleLED(int /*led*/)
void RGBController_RedragonMouse::UpdateSingleLED(int /*led*/)
{
DeviceUpdateLEDs();
}
void RGBController_RedragonM711::DeviceUpdateMode()
void RGBController_RedragonMouse::DeviceUpdateMode()
{
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)
if((modes[active_mode].value == REDRAGON_MOUSE_MODE_BREATHING) && random)
{
controller->SendMouseMode(REDRAGON_M711_MODE_RANDOM_BREATHING, 0, red, grn, blu);
controller->SendMouseMode(REDRAGON_MOUSE_MODE_RANDOM_BREATHING, 0, red, grn, blu);
}
else
{

19
Controllers/RedragonController/RGBController_RedragonM711.h → Controllers/RedragonController/RGBController_RedragonMouse.h
View file

@ -1,21 +1,20 @@
/*-----------------------------------------*\
| RGBController_RedragonM711.h |
| RGBController_RedragonMouse.h |
| |
| Generic RGB Interface for Redragon M711 |
| Cobra RGB Mouse |
| Generic RGB Interface for Redragon Mouse |
| |
| Adam Honse (CalcProgrammer1) 3/25/2020 |
\*-----------------------------------------*/
#pragma once
#include "RGBController.h"
#include "RedragonM711Controller.h"
class RGBController_RedragonM711 : public RGBController
#include "RGBController.h"
#include "RedragonMouseController.h"
class RGBController_RedragonMouse : public RGBController
{
public:
RGBController_RedragonM711(RedragonM711Controller* controller_ptr);
~RGBController_RedragonM711();
RGBController_RedragonMouse(RedragonMouseController* controller_ptr);
~RGBController_RedragonMouse();
void SetupZones();
void ResizeZone(int zone, int new_size);
@ -27,5 +26,5 @@ public:
void DeviceUpdateMode();
private:
RedragonM711Controller* controller;
RedragonMouseController* controller;
};

12
Controllers/RedragonController/RedragonControllerDetect.cpp
View file

@ -1,7 +1,7 @@
#include "Detector.h"
#include "RedragonM711Controller.h"
#include "RedragonMouseController.h"
#include "RGBController.h"
#include "RGBController_RedragonM711.h"
#include "RGBController_RedragonMouse.h"
#include <vector>
#include <hidapi/hidapi.h>
@ -15,6 +15,7 @@
#define REDRAGON_M716_PID 0xFC3A
#define REDRAGON_M908_PID 0xFC4D
#define REDRAGON_M602_PID 0xFC38
#define REDRAGON_M808_PID 0xFC5F
/******************************************************************************************\
* *
@ -29,8 +30,8 @@ void DetectRedragonMice(hid_device_info* info, const std::string& name)
hid_device* dev = hid_open_path(info->path);
if( dev )
{
RedragonM711Controller* controller = new RedragonM711Controller(dev, info->path);
RGBController_RedragonM711* rgb_controller = new RGBController_RedragonM711(controller);
RedragonMouseController* controller = new RedragonMouseController(dev, info->path);
RGBController_RedragonMouse* rgb_controller = new RGBController_RedragonMouse(controller);
rgb_controller->name = name;
ResourceManager::get()->RegisterRGBController(rgb_controller);
}
@ -43,4 +44,5 @@ REGISTER_HID_DETECTOR_IP("Redragon M711 Cobra", DetectRedragonMice, RE
REGISTER_HID_DETECTOR_IP("Redragon M715 Dagger", DetectRedragonMice, REDRAGON_MOUSE_VID, REDRAGON_M715_PID, 2, REDRAGON_MOUSE_USAGE_PAGE);
REGISTER_HID_DETECTOR_IP("Redragon M716 Inquisitor", DetectRedragonMice, REDRAGON_MOUSE_VID, REDRAGON_M716_PID, 2, REDRAGON_MOUSE_USAGE_PAGE);
REGISTER_HID_DETECTOR_IP("Redragon M908 Impact", DetectRedragonMice, REDRAGON_MOUSE_VID, REDRAGON_M908_PID, 2, REDRAGON_MOUSE_USAGE_PAGE);
REGISTER_HID_DETECTOR_IP("Redragon M602 Griffin", DetectRedragonMice, REDRAGON_MOUSE_VID, REDRAGON_M602_PID, 2, REDRAGON_MOUSE_USAGE_PAGE);
REGISTER_HID_DETECTOR_IP("Redragon M602 Griffin", DetectRedragonMice, REDRAGON_MOUSE_VID, REDRAGON_M602_PID, 2, REDRAGON_MOUSE_USAGE_PAGE);
REGISTER_HID_DETECTOR_IP("Redragon M808 Storm", DetectRedragonMice, REDRAGON_MOUSE_VID, REDRAGON_M808_PID, 2, REDRAGON_MOUSE_USAGE_PAGE);

70
Controllers/RedragonController/RedragonM711Controller.h
View file

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

36
Controllers/RedragonController/RedragonM711Controller.cpp → Controllers/RedragonController/RedragonMouseController.cpp
View file

@ -1,8 +1,8 @@
#include "RedragonM711Controller.h"
#include "RedragonMouseController.h"
#include <cstring>
RedragonM711Controller::RedragonM711Controller(hid_device* dev_handle, const char* path)
RedragonMouseController::RedragonMouseController(hid_device* dev_handle, const char* path)
{
dev = dev_handle;
location = path;
@ -13,17 +13,17 @@ RedragonM711Controller::RedragonM711Controller(hid_device* dev_handle, const cha
SendMouseApply();
}
RedragonM711Controller::~RedragonM711Controller()
RedragonMouseController::~RedragonMouseController()
{
hid_close(dev);
}
std::string RedragonM711Controller::GetDeviceLocation()
std::string RedragonMouseController::GetDeviceLocation()
{
return("HID: " + location);
}
std::string RedragonM711Controller::GetSerialString()
std::string RedragonMouseController::GetSerialString()
{
wchar_t serial_string[128];
int ret = hid_get_serial_number_string(dev, serial_string, 128);
@ -39,7 +39,7 @@ std::string RedragonM711Controller::GetSerialString()
return(return_string);
}
void RedragonM711Controller::SendMouseColor
void RedragonMouseController::SendMouseColor
(
unsigned char red,
unsigned char green,
@ -55,7 +55,7 @@ void RedragonM711Controller::SendMouseColor
SendWritePacket(0x0449, 3, color_buf);
}
void RedragonM711Controller::SendMouseMode
void RedragonMouseController::SendMouseMode
(
unsigned char mode,
unsigned char speed
@ -70,7 +70,7 @@ void RedragonM711Controller::SendMouseMode
SendWritePacket(0x044C, 3, mode_buf);
}
void RedragonM711Controller::SendMouseMode
void RedragonMouseController::SendMouseMode
(
unsigned char mode,
unsigned char speed,
@ -95,19 +95,19 @@ void RedragonM711Controller::SendMouseMode
| Private packet sending functions. |
\*-------------------------------------------------------------------------------------------------*/
void RedragonM711Controller::SendMouseApply()
void RedragonMouseController::SendMouseApply()
{
char usb_buf[16];
char usb_buf[REDRAGON_MOUSE_REPORT_SIZE];
/*-----------------------------------------------------*\
| Zero out buffer |
\*-----------------------------------------------------*/
memset(usb_buf, 0x00, sizeof(usb_buf));
memset(usb_buf, 0x00, REDRAGON_MOUSE_REPORT_SIZE);
/*-----------------------------------------------------*\
| Set up Apply packet |
\*-----------------------------------------------------*/
usb_buf[0x00] = 0x02;
usb_buf[0x00] = REDRAGON_MOUSE_REPORT_ID;
usb_buf[0x01] = 0xF1;
usb_buf[0x02] = 0x02;
usb_buf[0x03] = 0x04;
@ -115,27 +115,27 @@ void RedragonM711Controller::SendMouseApply()
/*-----------------------------------------------------*\
| Send packet |
\*-----------------------------------------------------*/
hid_send_feature_report(dev, (unsigned char *)usb_buf, 16);
hid_send_feature_report(dev, (unsigned char *)usb_buf, REDRAGON_MOUSE_REPORT_SIZE);
}
void RedragonM711Controller::SendWritePacket
void RedragonMouseController::SendWritePacket
(
unsigned short address,
unsigned char data_size,
unsigned char * data
)
{
char usb_buf[16];
char usb_buf[REDRAGON_MOUSE_REPORT_SIZE];
/*-----------------------------------------------------*\
| Zero out buffer |
\*-----------------------------------------------------*/
memset(usb_buf, 0x00, sizeof(usb_buf));
memset(usb_buf, 0x00, REDRAGON_MOUSE_REPORT_SIZE);
/*-----------------------------------------------------*\
| Set up Lighting Control packet |
\*-----------------------------------------------------*/
usb_buf[0x00] = 0x02;
usb_buf[0x00] = REDRAGON_MOUSE_REPORT_ID;
usb_buf[0x01] = 0xF3;
usb_buf[0x02] = address & 0xFF;
usb_buf[0x03] = address >> 8;
@ -149,5 +149,5 @@ void RedragonM711Controller::SendWritePacket
/*-----------------------------------------------------*\
| Send packet |
\*-----------------------------------------------------*/
hid_send_feature_report(dev, (unsigned char *)usb_buf, 16);
hid_send_feature_report(dev, (unsigned char *)usb_buf, REDRAGON_MOUSE_REPORT_SIZE);
}

71
Controllers/RedragonController/RedragonMouseController.h Normal file
View file

@ -0,0 +1,71 @@
/*-----------------------------------------*\
| RedragonMouseController.h |
| |
| Definitions and types for Redragon Mouse |
| lighting controller |
| |
| Adam Honse (CalcProgrammer1) 3/15/2020 |
\*-----------------------------------------*/
#pragma once
#include <string>
#include <hidapi/hidapi.h>
#define REDRAGON_MOUSE_REPORT_ID 0x02
#define REDRAGON_MOUSE_REPORT_SIZE 16
#define REDRAGON_MOUSE_LED_COUNT 1
enum
{
REDRAGON_MOUSE_MODE_WAVE = 0x00,
REDRAGON_MOUSE_MODE_RANDOM_BREATHING = 0x01,
REDRAGON_MOUSE_MODE_STATIC = 0x02,
REDRAGON_MOUSE_MODE_BREATHING = 0x04,
REDRAGON_MOUSE_MODE_RAINBOW = 0x08,
REDRAGON_MOUSE_MODE_FLASHING = 0x10
};
class RedragonMouseController
{
public:
RedragonMouseController(hid_device* dev_handle, const char* path);
~RedragonMouseController();
std::string GetDeviceLocation();
std::string GetSerialString();
void SendMouseApply();
void SendMouseColor
(
unsigned char red,
unsigned char green,
unsigned char blue
);
void SendMouseMode
(
unsigned char mode,
unsigned char speed
);
void SendMouseMode
(
unsigned char mode,
unsigned char speed,
unsigned char red,
unsigned char green,
unsigned char blue
);
private:
hid_device* dev;
std::string location;
void SendWritePacket
(
unsigned short address,
unsigned char data_size,
unsigned char * data
);
};