Salastil/OpenRGB
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add SteelSeries Rival 5 support

Browse Source
This commit is contained in:
Andrew Ingram authored and Adam Honse committed 2026-08-02 00:23:32 -05:00
1 parent 286514b509
commit 4ee39b0dc8
7 files changed
+483 -1
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

Controllers/SteelSeriesController/SteelSeriesControllerDetect.cpp
+29
View File
@@ -22,6 +22,7 @@
#include "SteelSeriesQCKMatController.h"
#include "SteelSeriesRivalController.h"
#include "SteelSeriesRival3Controller.h"
#include "SteelSeriesRival5Controller.h"
#include "SteelSeriesSenseiController.h"
#include "SteelSeriesSiberiaController.h"
#include "RGBController_SteelSeriesArctisNova3.h"
@@ -32,6 +33,7 @@
#include "RGBController_SteelSeriesQCKMat.h"
#include "RGBController_SteelSeriesRival.h"
#include "RGBController_SteelSeriesRival3.h"
#include "RGBController_SteelSeriesRival5.h"
#include "RGBController_SteelSeriesSensei.h"
#include "RGBController_SteelSeriesSiberia.h"
@@ -434,6 +436,32 @@ DetectedControllers DetectSteelSeriesArctis5(hid_device_info* info, const std::s
return(detected_controllers);
}
DetectedControllers DetectSteelSeriesRival5(
hid_device_info* info,
const std::string& name)
{
DetectedControllers detected_controllers;
hid_device* dev = hid_open_path(info->path);
if(dev)
{
SteelSeriesRival5Controller* controller =
new SteelSeriesRival5Controller(
dev,
RIVAL_5,
info->path,
name
);
RGBController_SteelSeriesRival5* rgb_controller =
new RGBController_SteelSeriesRival5(controller);
detected_controllers.push_back(rgb_controller);
}
return detected_controllers;
}
/*-------------------------------------------------------------------------------------------------------------------------------------------------------------------------*\
| Mice |
@@ -477,6 +505,7 @@ REGISTER_HID_DETECTOR_I("SteelSeries Rival 700",
REGISTER_HID_DETECTOR_I("SteelSeries Rival 710", DetectSteelSeriesRival700, STEELSERIES_VID, STEELSERIES_RIVAL_710_PID, 0);
REGISTER_HID_DETECTOR_I("SteelSeries Rival 3 (Old Firmware)", DetectSteelSeriesRival3, STEELSERIES_VID, STEELSERIES_RIVAL_3_OLD_PID, 3);
REGISTER_HID_DETECTOR_I("SteelSeries Rival 3", DetectSteelSeriesRival3, STEELSERIES_VID, STEELSERIES_RIVAL_3_PID, 3);
REGISTER_HID_DETECTOR_IPU("SteelSeries Rival 5", DetectSteelSeriesRival5, STEELSERIES_VID, STEELSERIES_RIVAL_5_PID, 0, 0xFFC0, 1 );
REGISTER_HID_DETECTOR_I("SteelSeries Sensei TEN", DetectSteelSeriesSensei, STEELSERIES_VID, STEELSERIES_SENSEI_TEN_PID, 0);
REGISTER_HID_DETECTOR_I("SteelSeries Sensei TEN CS:GO Neon Rider Edition", DetectSteelSeriesSensei, STEELSERIES_VID, STEELSERIES_SENSEI_TEN_CSGO_NEON_RIDER_PID, 0);
REGISTER_HID_DETECTOR_I("SteelSeries Sensei 310", DetectSteelSeriesSensei, STEELSERIES_VID, STEELSERIES_SENSEI_310_PID, 0);
Controllers/SteelSeriesController/SteelSeriesDevices.h
+2
View File
@@ -49,6 +49,7 @@
#define STEELSERIES_RIVAL_310_PID 0x1720
#define STEELSERIES_RIVAL_310_CSGO_HOWL_PID 0x171E
#define STEELSERIES_RIVAL_310_PUBG_PID 0x1736
#define STEELSERIES_RIVAL_5_PID 0x183C
#define STEELSERIES_RIVAL_600_PID 0x1724
#define STEELSERIES_RIVAL_600_DOTA_2_PID 0x172E
#define STEELSERIES_RIVAL_650_PID 0x172B
@@ -137,4 +138,5 @@ typedef enum
AEROX_9_WIRELESS = 0x16,
AEROX_9_WIRELESS_WIRED = 0x17,
AEROX_3_GEN2_WIRELESS = 0x18,
RIVAL_5 = 0x19
} steelseries_type;
Controllers/SteelSeriesController/SteelSeriesMouseController/SteelSeriesMouseController.h
+3 -1
View File
@@ -30,7 +30,9 @@ enum
STEELSERIES_MOUSE_EFFECT_BREATHING_MIN = 0x03,
STEELSERIES_MOUSE_EFFECT_DIRECT = 0x04,
STEELSERIES_MOUSE_EFFECT_RAINBOW_BREATHING = 0x05,
STEELSERIES_MOUSE_EFFECT_DISCO = 0x06
STEELSERIES_MOUSE_EFFECT_DISCO = 0x06,
STEELSERIES_MOUSE_EFFECT_REACTIVE = 0x07,
STEELSERIES_MOUSE_EFFECT_RAINBOW = 0x08
};
typedef struct
Controllers/SteelSeriesController/SteelSeriesRival5Controller/RGBController_SteelSeriesRival5.cpp
+159
View File
@@ -0,0 +1,159 @@
/*---------------------------------------------------------*\
| RGBController_SteelSeriesRival5.cpp |
| |
| RGBController for SteelSeries Rival 5 |
| |
| A Ingram (Woodsy900) 20 Jul 2026 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include "RGBController_SteelSeriesRival5.h"
RGBController_SteelSeriesRival5::RGBController_SteelSeriesRival5(SteelSeriesMouseController* controller_ptr)
{
controller = controller_ptr;
name = controller->GetNameString();
vendor = "SteelSeries";
type = DEVICE_TYPE_MOUSE;
description = "SteelSeries Mouse Device";
location = controller->GetDeviceLocation();
serial = controller->GetSerialString();
version = controller->GetFirmwareVersion();
mode Direct;
Direct.name = "Direct";
Direct.value = STEELSERIES_MOUSE_EFFECT_DIRECT;
Direct.flags = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
Direct.color_mode = MODE_COLORS_PER_LED;
Direct.brightness_min = 0x00;
Direct.brightness_max = STEELSERIES_MOUSE_BRIGHTNESS_MAX;
Direct.brightness = STEELSERIES_MOUSE_BRIGHTNESS_MAX;
mode Reactive;
Reactive.name = "Reactive";
Reactive.value = STEELSERIES_MOUSE_EFFECT_REACTIVE; // any unique value; define e.g. 0x26
Reactive.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
Reactive.color_mode = MODE_COLORS_MODE_SPECIFIC;
Reactive.colors_min = 1;
Reactive.colors_max = 1;
Reactive.colors.resize(1);
Reactive.colors[0] = ToRGBColor(255, 255, 255);
mode Rainbow;
Rainbow.name = "Rainbow";
Rainbow.value = STEELSERIES_MOUSE_EFFECT_RAINBOW;
Rainbow.color_mode = MODE_COLORS_NONE;
Rainbow.flags = MODE_FLAG_HAS_BRIGHTNESS;
Rainbow.brightness_min = 0x00;
Rainbow.brightness_max = STEELSERIES_MOUSE_BRIGHTNESS_MAX;
Rainbow.brightness = STEELSERIES_MOUSE_BRIGHTNESS_MAX;
steelseries_mouse mouse = controller->GetMouse();
for(const uint8_t i: mouse.modes)
{
switch(i)
{
case STEELSERIES_MOUSE_EFFECT_DIRECT:
modes.push_back(Direct);
break;
case STEELSERIES_MOUSE_EFFECT_REACTIVE:
modes.push_back(Reactive);
break;
case STEELSERIES_MOUSE_EFFECT_RAINBOW:
modes.push_back(Rainbow);
break;
}
}
SetupZones();
}
RGBController_SteelSeriesRival5::~RGBController_SteelSeriesRival5()
{
Shutdown();
delete controller;
}
void RGBController_SteelSeriesRival5::SetupZones()
{
steelseries_mouse mouse = controller->GetMouse();
zone lighting_zone;
lighting_zone.name = "Whole Mouse";
lighting_zone.type = ZONE_TYPE_LINEAR;
lighting_zone.leds_min = static_cast<unsigned int>(mouse.leds.size());
lighting_zone.leds_max = static_cast<unsigned int>(mouse.leds.size());
lighting_zone.leds_count = static_cast<unsigned int>(mouse.leds.size());
zones.push_back(lighting_zone);
for(const led_info& info : mouse.leds)
{
led mouse_led;
mouse_led.name = info.name;
mouse_led.value = info.value;
leds.push_back(mouse_led);
}
SetupColors();
}
void RGBController_SteelSeriesRival5::DeviceUpdateLEDs()
{
SteelSeriesRival5Controller* ctrl = static_cast<SteelSeriesRival5Controller*>(controller);
ctrl->SetBrightness((uint8_t)modes[active_mode].brightness); // guarded, so ~free under effects
ctrl->UpdateLEDs(colors);
}
void RGBController_SteelSeriesRival5::DeviceUpdateZoneLEDs(int)
{
DeviceUpdateLEDs();
}
void RGBController_SteelSeriesRival5::DeviceUpdateSingleLED(int)
{
DeviceUpdateLEDs();
}
void RGBController_SteelSeriesRival5::DeviceUpdateMode()
{
SteelSeriesRival5Controller* ctrl = static_cast<SteelSeriesRival5Controller*>(controller);
if(modes[active_mode].name == "Reactive")
{
RGBColor c = modes[active_mode].colors[0];
ctrl->SetReactiveColor(
true,
RGBGetRValue(c),
RGBGetGValue(c),
RGBGetBValue(c)
);
}
else if(modes[active_mode].name == "Rainbow")
{
ctrl->SetRainbowEffect(true);
}
else
{
ctrl->SetReactiveColor(false,0,0,0); // leaving Reactive must disable it (it's persistent in HW)
DeviceUpdateLEDs();
}
}
void RGBController_SteelSeriesRival5::DeviceSaveMode()
{
/*--------------------------------------------------------*\
| Note: Rival 5 does not have a "save" command |
| The Rival 5 saves the current state automatically |
\*--------------------------------------------------------*/
}
Controllers/SteelSeriesController/SteelSeriesRival5Controller/RGBController_SteelSeriesRival5.h
+32
View File
@@ -0,0 +1,32 @@
/*---------------------------------------------------------*\
| RGBController_SteelSeriesRival5.h |
| |
| RGBController for SteelSeries Rival 5 |
| |
| A Ingram (Woodsy900) 20 Jul 2026 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#pragma once
#include "RGBController.h"
#include "SteelSeriesRival5Controller.h"
class RGBController_SteelSeriesRival5 : public RGBController
{
public:
RGBController_SteelSeriesRival5(SteelSeriesMouseController* controller_ptr);
~RGBController_SteelSeriesRival5();
void SetupZones();
void DeviceUpdateLEDs();
void DeviceUpdateZoneLEDs(int zone);
void DeviceUpdateSingleLED(int led);
void DeviceUpdateMode();
void DeviceSaveMode();
private:
SteelSeriesMouseController* controller;
};
Controllers/SteelSeriesController/SteelSeriesRival5Controller/SteelSeriesRival5Controller.cpp
+174
View File
@@ -0,0 +1,174 @@
/*---------------------------------------------------------*\
| SteelSeriesRival5Controller.cpp |
| |
| Controller for SteelSeries Rival 5 |
| |
| A Ingram (Woodsy900) 20 Jul 2026 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include "SteelSeriesRival5Controller.h"
#include "LogManager.h"
#include <cstring>
SteelSeriesRival5Controller::SteelSeriesRival5Controller(
hid_device* dev_handle,
steelseries_type proto_type,
const char* path,
std::string dev_name
)
: SteelSeriesMouseController(
dev_handle,
proto_type,
path,
dev_name
)
{
memset(zone_colors, 0, sizeof(zone_colors));
}
SteelSeriesRival5Controller::~SteelSeriesRival5Controller()
{
hid_close(dev);
}
steelseries_mouse SteelSeriesRival5Controller::GetMouse()
{
return rival_5;
}
std::string SteelSeriesRival5Controller::GetFirmwareVersion()
{
return "";
/*--------------------------------------------------------*\
| Note: Rival 5 does not have a "Get firmware" command |
\*--------------------------------------------------------*/
}
void SteelSeriesRival5Controller::SetLightEffectAll(uint8_t)
{
/*--------------------------------------------------------*\
| Note: Not Used |
\*--------------------------------------------------------*/
}
void SteelSeriesRival5Controller::SetRainbowEffect(bool enable)
{
uint8_t report[64] = {0};
if(enable)
{
report[1] = 0x22;
report[2] = 0xFF;
report[3] = 0x03;
}
hid_send_feature_report(
dev,
report,
sizeof(report)
);
}
void SteelSeriesRival5Controller::Save()
{
/*--------------------------------------------------------*\
| Note: Rival 5 does not have a "save" command |
| The Rival 5 saves the current state automatically |
\*--------------------------------------------------------*/
}
void SteelSeriesRival5Controller::SetColor(
unsigned char zone_id,
unsigned char red,
unsigned char green,
unsigned char blue,
unsigned char /*brightness*/
)
{
if(zone_id >= 10)
{
return;
}
zone_colors[zone_id][0] = red;
zone_colors[zone_id][1] = green;
zone_colors[zone_id][2] = blue;
}
void SteelSeriesRival5Controller::UpdateLEDs(const std::vector<RGBColor>& colors)
{
uint8_t report[64] = {0};
report[0] = 0x00;
report[1] = 0x21;
report[2] = 0xFF;
report[3] = 0x03;
for(size_t i = 0; i < 10 && i < colors.size(); i++)
{
report[4 + (i * 3) + 0] = RGBGetRValue(colors[i]);
report[4 + (i * 3) + 1] = RGBGetGValue(colors[i]);
report[4 + (i * 3) + 2] = RGBGetBValue(colors[i]);
}
int result =
hid_send_feature_report(
dev,
report,
sizeof(report)
);
}
void SteelSeriesRival5Controller::SetBrightness(uint8_t brightness)
{
if(brightness == current_brightness) return; // only on change
current_brightness = brightness;
uint8_t report[64] = {0};
report[1] = 0x23;
//report[2] = brightness;
if(brightness >= 88)
{
report[2] = 0x64;
}
else if(brightness >= 63)
{
report[2] = 0x32;
}
else if(brightness >= 38)
{
report[2] = 0x19;
}
else if(brightness >= 13)
{
report[2] = 0x0C;
}
else
{
report[2] = 0x00;
} // 0x00–0x64
hid_send_feature_report(dev, report, sizeof(report));
}
void SteelSeriesRival5Controller::SetReactiveColor(bool on, uint8_t r, uint8_t g, uint8_t b)
{
uint8_t report[64] = {0};
report[1] = 0x26;
if(on)
{
report[2] = 0x01;
report[3] = 0x00;
report[4] = r;
report[5] = g;
report[6] = b;
}
// off → bytes stay 0x00 → [00 26 00 00 00 00 00]
hid_send_feature_report(dev, report, sizeof(report));
}
Controllers/SteelSeriesController/SteelSeriesRival5Controller/SteelSeriesRival5Controller.h
+84
View File
@@ -0,0 +1,84 @@
/*---------------------------------------------------------*\
| SteelSeriesRival5Controller.h |
| |
| SteelSeriesRival5Controller for SteelSeries Rival 5 |
| |
| A Ingram (Woodsy900) 20 Jul 2026 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#pragma once
#include <string>
#include <vector>
#include <hidapi.h>
#include <cstring>
#include "RGBController.h"
#include "SteelSeriesDevices.h"
#include "SteelSeriesMouseController.h"
#define STEELSERIES_RIVAL5_NAME "SteelSeries Rival 5"
static const steelseries_mouse rival_5 =
{
{
0x04, // Direct
0x07, // Reactive
0x08 // Rainbow (for Rival 5, this is a static rainbow effect that cannot be changed)
},
{
{ "Scroll Wheel", 0 },
{ "Body Left 1", 1 },
{ "Body Right 1", 2 },
{ "Body Left 2", 3 },
{ "Body Right 2", 4 },
{ "Body Left 3", 5 },
{ "Body Right 3", 6 },
{ "Body Left 4", 7 },
{ "Body Right 4", 8 },
{ "Logo", 9 }
}
};
class SteelSeriesRival5Controller : public SteelSeriesMouseController
{
public:
SteelSeriesRival5Controller(
hid_device* dev_handle,
steelseries_type proto_type,
const char* path,
std::string dev_name
);
~SteelSeriesRival5Controller();
std::string GetFirmwareVersion() override;
steelseries_mouse GetMouse() override;
void Save() override;
void SetLightEffectAll(uint8_t effect) override;
void SetRainbowEffect(bool enable);
void SetBrightness(uint8_t brightness);
void SetColor(
unsigned char zone_id,
unsigned char red,
unsigned char green,
unsigned char blue,
unsigned char brightness
) override;
void SetReactiveColor(
bool on,
uint8_t r,
uint8_t g,
uint8_t b
);
void UpdateLEDs(const std::vector<RGBColor>& colors);
private:
uint8_t zone_colors[10][3];
uint8_t current_brightness = 0xFF;
};