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

First working version to support the Rival 110 mouse

Browse source
This commit is contained in:
B Horn 2020-05-13 12:46:05 +01:00 • committed by Adam Honse
parent bfa7f63486
commit be9711a021
9 changed files with 381 additions and 1 deletions
Download patch file Download diff file Expand all files Collapse all files

1
.gitignore vendored
View file

@ -1 +1,2 @@
*.pro.user*
*.o

88
Controllers/SteelSeriesController/SteelSeriesControllerDetect.cpp Normal file
View file

@ -0,0 +1,88 @@
#include "SteelSeriesRivalController.h"
#include "RGBController.h"
#include "RGBController_SteelSeriesRival.h"
#include <vector>
#include <hidapi/hidapi.h>
/*-----------------------------------------------------*\
| Mouse product IDs |
\*-----------------------------------------------------*/
#define STEELSERIES_RIVAL_110_VID 0x1038
#define STEELSERIES_RIVAL_110_PID 0x1729
typedef struct
{
unsigned short usb_vid;
unsigned short usb_pid;
unsigned char usb_interface;
device_type type;
const char * name;
} steelseries_device;
static const steelseries_device device_list[] =
{
/*-------------------------------------------------------------------------------------------------------------*\
| Mice |
\*-------------------------------------------------------------------------------------------------------------*/
{ STEELSERIES_RIVAL_110_VID, STEELSERIES_RIVAL_110_PID, 0, DEVICE_TYPE_MOUSE, "SteelSeries Rival 110" },
};
#define STEELSERIES_NUM_DEVICES (sizeof(device_list) / sizeof(device_list[ 0 ]))
/******************************************************************************************\
* *
* DetectSteelSeriesControllers *
* *
* Tests the USB address to find a SteelSeries Rival Mouse *
* *
\******************************************************************************************/
void DetectSteelSeriesControllers(std::vector<RGBController*>& rgb_controllers)
{
hid_device_info* info;
hid_device* dev;
hid_init();
for(int device_idx = 0; device_idx < STEELSERIES_NUM_DEVICES; device_idx++)
{
dev = NULL;
info = hid_enumerate(device_list[device_idx].usb_vid, device_list[device_idx].usb_pid);
//Look for SteelSeries RGB Peripheral
while(info)
{
if((info->vendor_id == device_list[device_idx].usb_vid)
&&(info->product_id == device_list[device_idx].usb_pid)
&&(info->interface_number == device_list[device_idx].usb_interface))
{
dev = hid_open_path(info->path);
break;
}
else
{
info = info->next;
}
}
if(dev)
{
switch(device_list[device_idx].type)
{
case DEVICE_TYPE_KEYBOARD:
/* Not yet supported */
break;
case DEVICE_TYPE_MOUSE:
SteelSeriesRivalController* controller = new SteelSeriesRivalController(dev);
RGBController_SteelSeriesRival* rgb_controller = new RGBController_SteelSeriesRival(controller);
rgb_controller->name = device_list[device_idx].name;
rgb_controllers.push_back(rgb_controller);
break;
}
}
}
}

86
Controllers/SteelSeriesController/SteelSeriesRivalController.cpp Normal file
View file

@ -0,0 +1,86 @@
/*-----------------------------------------*\
| SteelSeriesRivalController.h |
| |
| Definitions and types for SteelSeries |
| Rival lighting controller |
| |
| B Horn (bahorn) 13/5/2020 |
\*-----------------------------------------*/
#include "SteelSeriesRivalController.h"
#include <cstring>
#include <stdio.h>
#include <stdlib.h>
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(unsigned 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;
}
SteelSeriesRivalController::SteelSeriesRivalController(hid_device* dev_handle)
{
dev = dev_handle;
}
SteelSeriesRivalController::~SteelSeriesRivalController()
{
}
char* SteelSeriesRivalController::GetDeviceName()
{
return device_name;
}
/* Saves to the internal configuration */
void SteelSeriesRivalController::Save()
{
char usb_buf[9];
memset(usb_buf, 0x00, sizeof(usb_buf));
usb_buf[0x00] = 0x09;
send_usb_msg(dev, usb_buf, 9);
}
void SteelSeriesRivalController::SetLightEffect
(
unsigned char effect
)
{
char usb_buf[9];
memset(usb_buf, 0x00, sizeof(usb_buf));
usb_buf[0x00] = 0x07;
usb_buf[0x01] = 0x00;
usb_buf[0x02] = effect;
send_usb_msg(dev, usb_buf, 9);
}
void SteelSeriesRivalController::SetColor
(
unsigned char red,
unsigned char green,
unsigned char blue
)
{
char usb_buf[9];
memset(usb_buf, 0x00, sizeof(usb_buf));
usb_buf[0x00] = 0x05;
usb_buf[0x01] = 0x00;
usb_buf[0x02] = red;
usb_buf[0x03] = green;
usb_buf[0x04] = blue;
send_usb_msg(dev, usb_buf, 9);
}

54
Controllers/SteelSeriesController/SteelSeriesRivalController.h Normal file
View file

@ -0,0 +1,54 @@
/*-----------------------------------------*\
| SteelSeriesRivalController.h |
| |
| Definitions and types for SteelSeries |
| Rival lighting controller |
| |
| B Horn (bahorn) 13/5/2020 |
\*-----------------------------------------*/
#include <string>
#include <hidapi/hidapi.h>
#pragma once
/* Mode, we then use these to set actual effect based on speed. */
enum
{
STEELSERIES_RIVAL_STATIC = 0x00,
STEELSERIES_RIVAL_PULSATE = 0x01
};
/* Effects */
enum
{
STEELSERIES_RIVAL_EFFECT_STATIC = 0x01,
STEELSERIES_RIVAL_EFFECT_PULSATE_MIN = 0x02,
STEELSERIES_RIVAL_EFFECT_PULSATE_MID = 0x03,
STEELSERIES_RIVAL_EFFECT_PULSATE_MAX = 0x04
};
class SteelSeriesRivalController
{
public:
SteelSeriesRivalController(hid_device* dev_handle);
~SteelSeriesRivalController();
char* GetDeviceName();
void Save();
void SetLightEffect(unsigned char effect);
void SetColor
(
unsigned char red,
unsigned char green,
unsigned char blue
);
private:
char device_name[32];
hid_device* dev;
};

2
OpenRGB.cpp
View file

@ -314,6 +314,7 @@ void DetectRGBFusion2USBControllers(std::vector<RGBController*> &rgb_controllers
void DetectRedragonControllers(std::vector<RGBController*>& rgb_controllers);
void DetectLogitechControllers(std::vector<RGBController*>& rgb_controllers);
void DetectNZXTKrakenControllers(std::vector<RGBController*>& rgb_controllers);
void DetectSteelSeriesControllers(std::vector<RGBController*>& rgb_controllers);
/******************************************************************************************\
* *
@ -362,6 +363,7 @@ void DetectRGBControllers(void)
DetectRedragonControllers(rgb_controllers);
DetectLogitechControllers(rgb_controllers);
DetectNZXTKrakenControllers(rgb_controllers);
DetectSteelSeriesControllers(rgb_controllers);
DetectE131Controllers(rgb_controllers);

6
OpenRGB.pro
View file

@ -76,6 +76,7 @@ INCLUDEPATH += \
Controllers/RGBFusion2SMBusController/ \
Controllers/RGBFusion2USBController/ \
Controllers/RGBFusionGPUController/ \
Controllers/SteelSeriesController/ \
Controllers/ThermaltakeRiingController/ \
RGBController/ \
qt/
@ -133,6 +134,7 @@ HEADERS += \
Controllers/RGBFusionGPUController/RGBFusionGPUController.h \
Controllers/RedragonController/RedragonK556Controller.h \
Controllers/RedragonController/RedragonM711Controller.h \
Controllers/SteelSeriesRivalController/SteelSeriesRivalController.h \
Controllers/ThermaltakeRiingController/ThermaltakeRiingController.h \
RGBController/RGBController.h \
RGBController/RGBController_AMDWraithPrism.h \
@ -168,6 +170,7 @@ HEADERS += \
RGBController/RGBController_RGBFusion2SMBus.h \
RGBController/RGBController_RGBFusion2USB.h \
RGBController/RGBController_RGBFusionGPU.h \
RGBController/RGBController_SteelSeriesRival.h \
RGBController/RGBController_ThermaltakeRiing.h \
SOURCES += \
@ -256,6 +259,8 @@ SOURCES += \
Controllers/RedragonController/RedragonK556Controller.cpp \
Controllers/RedragonController/RedragonM711Controller.cpp \
Controllers/RedragonController/RedragonControllerDetect.cpp \
Controllers/SteelSeriesController/SteelSeriesRivalController.cpp \
Controllers/SteelSeriesController/SteelSeriesControllerDetect.cpp \
Controllers/ThermaltakeRiingController/ThermaltakeRiingController.cpp \
Controllers/ThermaltakeRiingController/ThermaltakeRiingControllerDetect.cpp \
RGBController/RGBController.cpp \
@ -294,6 +299,7 @@ SOURCES += \
RGBController/RGBController_RGBFusion2SMBus.cpp \
RGBController/RGBController_RGBFusion2USB.cpp \
RGBController/RGBController_RGBFusionGPU.cpp \
RGBController/RGBController_SteelSeriesRival.cpp \
RGBController/RGBController_ThermaltakeRiing.cpp \
RESOURCES += \

4
README.md
View file

@ -134,4 +134,6 @@ While no code from these projects directly made its way into OpenRGB, these proj
* OpenCorsairLink: https://github.com/audiohacked/OpenCorsairLink
* msi-keyboard: https://github.com/bparker06/msi-keyboard
* msi-keyboard: https://github.com/bparker06/msi-keyboard
* rivalcfg: https://github.com/flozz/rivalcfg

108
RGBController/RGBController_SteelSeriesRival.cpp Normal file
View file

@ -0,0 +1,108 @@
/*-----------------------------------------*\
| RGBController_SteelSeriesRival.cpp |
| |
| Generic RGB Interface SteelSeriesRival |
| Class |
| |
| B Horn (bahorn) 13/05/2020 |
\*-----------------------------------------*/
#include "RGBController_SteelSeriesRival.h"
RGBController_SteelSeriesRival::RGBController_SteelSeriesRival(SteelSeriesRivalController* rival_ptr)
{
rival = rival_ptr;
name = "SteelSeries Rival 110";
type = DEVICE_TYPE_MOUSE;
description = "SteelSeries Rival 110";
mode Static;
Static.name = "Static";
Static.value = STEELSERIES_RIVAL_STATIC;
Static.flags = MODE_FLAG_HAS_PER_LED_COLOR;
Static.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Static);
mode Pulsate;
Pulsate.name = "Pulsate";
Pulsate.value = STEELSERIES_RIVAL_PULSATE;
Pulsate.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
Pulsate.color_mode = MODE_COLORS_PER_LED;
Pulsate.speed_min = STEELSERIES_RIVAL_EFFECT_PULSATE_MIN;
Pulsate.speed_max = STEELSERIES_RIVAL_EFFECT_PULSATE_MAX;
Pulsate.speed = STEELSERIES_RIVAL_EFFECT_PULSATE_MID;
modes.push_back(Pulsate);
SetupZones();
}
void RGBController_SteelSeriesRival::SetupZones()
{
zone main_zone;
main_zone.name = "Main";
main_zone.type = ZONE_TYPE_SINGLE;
main_zone.leds_min = 1;
main_zone.leds_max = 1;
main_zone.leds_count = 1;
main_zone.matrix_map = NULL;
zones.push_back(main_zone);
led main_led;
main_led.name = "Main LED";
leds.push_back(main_led);
SetupColors();
}
void RGBController_SteelSeriesRival::ResizeZone(int /*zone*/, int /*new_size*/)
{
/*---------------------------------------------------------*\
| This device does not support resizing zones |
\*---------------------------------------------------------*/
}
void RGBController_SteelSeriesRival::DeviceUpdateLEDs()
{
unsigned char red = RGBGetRValue(colors[0]);
unsigned char grn = RGBGetGValue(colors[0]);
unsigned char blu = RGBGetBValue(colors[0]);
rival->SetColor(red, grn, blu);
}
void RGBController_SteelSeriesRival::UpdateZoneLEDs(int zone)
{
RGBColor color = colors[zone];
unsigned char red = RGBGetRValue(color);
unsigned char grn = RGBGetGValue(color);
unsigned char blu = RGBGetBValue(color);
if(zone == 0)
{
rival->SetColor(red, grn, blu);
}
}
void RGBController_SteelSeriesRival::UpdateSingleLED(int led)
{
UpdateZoneLEDs(led);
}
void RGBController_SteelSeriesRival::SetCustomMode()
{
active_mode = 0;
}
void RGBController_SteelSeriesRival::UpdateMode()
{
switch (modes[active_mode].value)
{
case STEELSERIES_RIVAL_STATIC:
rival->SetLightEffect(STEELSERIES_RIVAL_EFFECT_STATIC);
break;
case STEELSERIES_RIVAL_PULSATE:
rival->SetLightEffect(modes[active_mode].speed);
break;
}
DeviceUpdateLEDs();
}

33
RGBController/RGBController_SteelSeriesRival.h Normal file
View file

@ -0,0 +1,33 @@
/*-----------------------------------------*\
| RGBController_SteelSeriesRival.h |
| |
| Generic RGB Interface SteelSeriesRival |
| Class |
| |
| B Horn (bahorn) 13/05/2020 |
\*-----------------------------------------*/
#pragma once
#include "RGBController.h"
#include "SteelSeriesRivalController.h"
class RGBController_SteelSeriesRival : public RGBController
{
public:
RGBController_SteelSeriesRival(SteelSeriesRivalController* rival_ptr);
void SetupZones();
void ResizeZone(int zone, int new_size);
void DeviceUpdateLEDs();
void UpdateZoneLEDs(int zone);
void UpdateSingleLED(int led);
void SetCustomMode();
void UpdateMode();
private:
SteelSeriesRivalController* rival;
};