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

Initial commit for the Steelseries Aerox 3 mouse to resolve #2492

Browse source 
+ Adding STEELSERIES_AEROX_3_PID and registering detector
+ Adding Abstract SteelSeriesMouseController class to accomodate new mouse
+ Adding SteelSeriesAerox3Controller class
* Rewrote SteelSeriesRival3Controller to align with abstract class
* Adjusted RGBController_SteelSeriesRival3 class to align with both mice
This commit is contained in:
Chris 2022-06-10 01:32:16 +10:00
parent d193c93e6d
commit a961bf87b4
11 changed files with 480 additions and 122 deletions
Download patch file Download diff file Expand all files Collapse all files

94
Controllers/SteelSeriesController/RGBController_SteelSeriesRival3.cpp
View file

@ -9,20 +9,6 @@
#include "RGBController_SteelSeriesRival3.h"
typedef struct
{
const char* name;
const int value;
} steelseries_rival_led_info;
static const steelseries_rival_led_info rival_3_leds[]=
{
{"Front", 0x01},
{"Middle", 0x02},
{"Rear", 0x03},
{"Logo", 0x04}
};
/**------------------------------------------------------------------*\
@name Steel Series Rival 3
@category Mouse
@ -34,49 +20,45 @@ static const steelseries_rival_led_info rival_3_leds[]=
@comment
\*-------------------------------------------------------------------*/
RGBController_SteelSeriesRival3::RGBController_SteelSeriesRival3(SteelSeriesRival3Controller* rival_ptr)
RGBController_SteelSeriesRival3::RGBController_SteelSeriesRival3(SteelSeriesMouseController *controller_ptr)
{
rival = rival_ptr;
controller = controller_ptr;
name = rival->GetDeviceName();
vendor = "SteelSeries";
type = DEVICE_TYPE_MOUSE;
description = "SteelSeries Rival 3 Device";
location = rival->GetDeviceLocation();
serial = rival->GetSerialString();
version = rival->GetFirmwareVersion();
name = controller->GetDeviceName();
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_RIVAL_3_EFFECT_DIRECT;
Direct.value = STEELSERIES_MOUSE_EFFECT_DIRECT;
Direct.flags = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
Direct.color_mode = MODE_COLORS_PER_LED;
Direct.brightness_min = 0x00;
Direct.brightness_max = STEELSERIES_RIVAL_3_BRIGHTNESS_MAX;
Direct.brightness = STEELSERIES_RIVAL_3_BRIGHTNESS_MAX;
modes.push_back(Direct);
Direct.brightness_max = STEELSERIES_MOUSE_BRIGHTNESS_MAX;
Direct.brightness = STEELSERIES_MOUSE_BRIGHTNESS_MAX;
mode Breathing;
Breathing.name = "Breathing";
Breathing.value = STEELSERIES_RIVAL_3_EFFECT_BREATHING_MIN;
Breathing.value = STEELSERIES_MOUSE_EFFECT_BREATHING_MIN;
Breathing.flags = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_MANUAL_SAVE;
Breathing.color_mode = MODE_COLORS_PER_LED;
Breathing.speed_min = 0;
Breathing.speed_max = 2;
Breathing.speed = 1;
modes.push_back(Breathing);
mode SpectrumCycle;
SpectrumCycle.name = "Spectrum Cycle";
SpectrumCycle.value = STEELSERIES_RIVAL_3_EFFECT_SPECTRUM_CYCLE;
SpectrumCycle.value = STEELSERIES_MOUSE_EFFECT_SPECTRUM_CYCLE;
SpectrumCycle.flags = MODE_FLAG_MANUAL_SAVE;
modes.push_back(SpectrumCycle);
mode RainbowBreathing;
RainbowBreathing.name = "Rainbow Breathing";
RainbowBreathing.value = STEELSERIES_RIVAL_3_EFFECT_RAINBOW_BREATHING;
RainbowBreathing.value = STEELSERIES_MOUSE_EFFECT_RAINBOW_BREATHING;
RainbowBreathing.flags = MODE_FLAG_MANUAL_SAVE;
modes.push_back(RainbowBreathing);
/*------------------------------------------------------------------------*\
| This is a pretty cool mode where it flashes random colors. |
@ -93,30 +75,53 @@ RGBController_SteelSeriesRival3::RGBController_SteelSeriesRival3(SteelSeriesRiva
/*
mode Disco;
Disco.name = "Disco";
Disco.value = STEELSERIES_RIVAL_3_EFFECT_DISCO;
Disco.value = STEELSERIES_MOUSE_EFFECT_DISCO;
Disco.flags = MODE_FLAG_MANUAL_SAVE;
modes.push_back(Disco);
*/
steelseries_mouse mouse = controller->GetMouse();
for(const uint8_t i: mouse.modes)
{
switch(i)
{
case STEELSERIES_MOUSE_EFFECT_SPECTRUM_CYCLE:
modes.push_back(SpectrumCycle);
break;
case STEELSERIES_MOUSE_EFFECT_BREATHING_MIN:
modes.push_back(Breathing);
break;
case STEELSERIES_MOUSE_EFFECT_DIRECT:
modes.push_back(Direct);
break;
case STEELSERIES_MOUSE_EFFECT_RAINBOW_BREATHING:
modes.push_back(RainbowBreathing);
break;
}
}
SetupZones();
}
void RGBController_SteelSeriesRival3::DeviceSaveMode()
{
rival->Save();
controller->Save();
}
RGBController_SteelSeriesRival3::~RGBController_SteelSeriesRival3()
{
delete rival;
delete controller;
}
void RGBController_SteelSeriesRival3::SetupZones()
{
for(const steelseries_rival_led_info led_info: rival_3_leds)
steelseries_mouse mouse = controller->GetMouse();
for(const led_info info: mouse.leds)
{
zone zone;
zone.name = led_info.name;
zone.name = info.name;
zone.type = ZONE_TYPE_SINGLE;
zone.leds_min = 1;
zone.leds_max = 1;
@ -125,8 +130,8 @@ void RGBController_SteelSeriesRival3::SetupZones()
zones.push_back(zone);
led mouse_led;
mouse_led.name = led_info.name;
mouse_led.value = led_info.value;
mouse_led.name = info.name;
mouse_led.value = info.value;
leds.push_back(mouse_led);
}
SetupColors();
@ -150,10 +155,7 @@ void RGBController_SteelSeriesRival3::DeviceUpdateLEDs()
void RGBController_SteelSeriesRival3::UpdateZoneLEDs(int zone)
{
/*--------------------------------------------------*\
| Subtracting one as the zone and led indexes differ |
\*--------------------------------------------------*/
UpdateSingleLED(zones[zone].leds[0].value - 1);
UpdateSingleLED(zone);
}
void RGBController_SteelSeriesRival3::UpdateSingleLED(int led)
@ -161,7 +163,7 @@ void RGBController_SteelSeriesRival3::UpdateSingleLED(int led)
unsigned char red = RGBGetRValue(colors[led]);
unsigned char grn = RGBGetGValue(colors[led]);
unsigned char blu = RGBGetBValue(colors[led]);
rival->SetColor(leds[led].value, red, grn, blu, modes[active_mode].brightness);
controller->SetColor(leds[led].value, red, grn, blu, modes[active_mode].brightness);
}
void RGBController_SteelSeriesRival3::SetCustomMode()
@ -171,5 +173,5 @@ void RGBController_SteelSeriesRival3::SetCustomMode()
void RGBController_SteelSeriesRival3::DeviceUpdateMode()
{
rival->SetLightEffectAll(modes[active_mode].value - modes[active_mode].speed);
controller->SetLightEffectAll(modes[active_mode].value - modes[active_mode].speed);
}

5
Controllers/SteelSeriesController/RGBController_SteelSeriesRival3.h
View file

@ -10,12 +10,13 @@
#pragma once
#include "RGBController.h"
#include "SteelSeriesAerox3Controller.h"
#include "SteelSeriesRival3Controller.h"
class RGBController_SteelSeriesRival3 : public RGBController
{
public:
RGBController_SteelSeriesRival3(SteelSeriesRival3Controller* rival_ptr);
RGBController_SteelSeriesRival3(SteelSeriesMouseController* controller_ptr);
~RGBController_SteelSeriesRival3();
void SetupZones();
@ -32,5 +33,5 @@ public:
private:
SteelSeriesRival3Controller* rival;
SteelSeriesMouseController* controller;
};

125
Controllers/SteelSeriesController/SteelSeriesAerox3Controller.cpp Normal file
View file

@ -0,0 +1,125 @@
/*-------------------------------------------------------------------*\
| SteelSeriesAerox3Controller.cpp |
| |
| OpenRGB controller driver for the Steelseries Aerox3 Wired |
| |
| Chris M (Dr_No) 9th June 2022 |
\*-------------------------------------------------------------------*/
#include "SteelSeriesAerox3Controller.h"
#include "LogManager.h"
SteelSeriesAerox3Controller::SteelSeriesAerox3Controller(hid_device* dev_handle, steelseries_type proto_type, const char* path)
: SteelSeriesMouseController(dev_handle, proto_type, path)
{
SendInit();
}
SteelSeriesAerox3Controller::~SteelSeriesAerox3Controller()
{
hid_close(dev);
}
void SteelSeriesAerox3Controller::SendInit()
{
/*-----------------------------------------------------------------*\
| This sets sensitivity and allows software mode?? max 5 uint8 |
| buffer[2] = Count eg. 0 thru 5 |
| buffer[4] to [8] = dpi / 50 range = 0x04 - 0xC7 eg. 400 = 0x08 |
\*-----------------------------------------------------------------*/
uint8_t buffer[STEELSERIES_AEORX3_PACKET_SIZE] = { 0x00, 0x2D };
hid_send_feature_report(dev, buffer, STEELSERIES_AEORX3_PACKET_SIZE);
}
std::string SteelSeriesAerox3Controller::GetFirmwareVersion()
{
uint8_t result = 0;
const uint8_t CMD = 0x90;
const uint8_t sz = 16;
char version[sz];
uint8_t buffer[STEELSERIES_AEORX3_PACKET_SIZE] = { 0x00, CMD, 0x00 };
hid_send_feature_report(dev, buffer, STEELSERIES_AEORX3_PACKET_SIZE);
do
{
result = hid_read_timeout(dev, buffer, STEELSERIES_AEORX3_PACKET_SIZE, STEELSERIES_AEORX3_TIMEOUT);
LOG_DEBUG("[%s] Reading version buffer: Bytes Read %d Buffer %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X", device_name, result,
buffer[0], buffer[1], buffer[2], buffer[3], buffer[4], buffer[5], buffer[6], buffer[7], buffer[8], buffer[9], buffer[10]);
} while(result > 0 && buffer[0] != CMD);
if(buffer[0] == CMD)
{
/*-----------------------------------------------------------------*\
| Read the version from the second character |
\*-----------------------------------------------------------------*/
memcpy(version, &buffer[1], sz);
std::string tmp = std::string(version);
LOG_DEBUG("[%s] Version: %s as string %s", device_name, version, tmp.c_str());
return tmp;
}
else
{
LOG_DEBUG("[%s] Unable to get version: giving up!", device_name);
return "";
}
}
steelseries_mouse SteelSeriesAerox3Controller::GetMouse()
{
return aerox_3;
}
void SteelSeriesAerox3Controller::SetLightEffectAll(uint8_t effect)
{
/*-----------------------------------------------------------------*\
| Not used by this device |
\*-----------------------------------------------------------------*/
}
void SteelSeriesAerox3Controller::SetColor
(
unsigned char zone_id,
unsigned char red,
unsigned char green,
unsigned char blue,
unsigned char brightness
)
{
uint8_t buffer[STEELSERIES_AEORX3_PACKET_SIZE] = { 0x00, 0x21 };
buffer[0x02] = 1 << zone_id;
uint8_t offset = 3 + zone_id * 3;
buffer[offset] = red;
buffer[offset + 1] = green;
buffer[offset + 2] = blue;
hid_write(dev, buffer, STEELSERIES_AEORX3_PACKET_SIZE);
if(brightness != current_brightness)
{
SetBrightness(brightness);
current_brightness = brightness;
}
}
void SteelSeriesAerox3Controller::SetBrightness(uint8_t brightness)
{
uint8_t buffer[STEELSERIES_AEORX3_PACKET_SIZE] = { 0x00, 0x23, brightness };
hid_write(dev, buffer, STEELSERIES_AEORX3_PACKET_SIZE);
}
void SteelSeriesAerox3Controller::Save()
{
/*---------------------------------------------------------------------------------*\
| Save packet was not confirmed as working but packet is verified as correct. |
| https://github.com/flozz/rivalcfg/blob/master/rivalcfg/devices/aerox3.py#L141 |
\*---------------------------------------------------------------------------------*/
uint8_t buffer2[STEELSERIES_AEORX3_PACKET_SIZE] = { 0x00, 0x11, 0x00 };
hid_write(dev, buffer2, STEELSERIES_AEORX3_PACKET_SIZE);
}

55
Controllers/SteelSeriesController/SteelSeriesAerox3Controller.h Normal file
View file

@ -0,0 +1,55 @@
/*-------------------------------------------------------------------*\
| SteelSeriesAerox3Controller.h |
| |
| OpenRGB controller driver for the Steelseries Aerox3 Wired |
| |
| Chris M (Dr_No) 9th June 2022 |
\*-------------------------------------------------------------------*/
#include <string>
#include <cstring>
#include <hidapi/hidapi.h>
#include "RGBController.h"
#include "SteelSeriesGeneric.h"
#include "SteelSeriesMouseController.h"
#pragma once
#define STEELSERIES_AEORX3_PACKET_SIZE 65
#define STEELSERIES_AEORX3_TIMEOUT 250
static const steelseries_mouse aerox_3 =
{
{ 0x04 },
{
{"Front", 0 },
{"Middle", 1 },
{"Rear", 2 },
}
};
class SteelSeriesAerox3Controller: public SteelSeriesMouseController
{
public:
SteelSeriesAerox3Controller(hid_device* dev_handle, steelseries_type proto_type, const char* path);
~SteelSeriesAerox3Controller();
std::string GetFirmwareVersion();
steelseries_mouse GetMouse();
void Save() override;
void SetLightEffectAll(uint8_t effect);
void SetColor
(
unsigned char zone_id,
unsigned char red,
unsigned char green,
unsigned char blue,
unsigned char brightness
);
private:
void SendInit();
void SetBrightness(uint8_t brightness);
uint8_t current_brightness;
};

98
Controllers/SteelSeriesController/SteelSeriesControllerDetect.cpp
View file

@ -29,6 +29,7 @@
/*-----------------------------------------------------*\
| Mouse product IDs |
\*-----------------------------------------------------*/
#define STEELSERIES_AEROX_3_PID 0x1836
#define STEELSERIES_RIVAL_100_PID 0x1702
#define STEELSERIES_RIVAL_100_DOTA_PID 0x170c
#define STEELSERIES_RIVAL_105_PID 0x1814
@ -82,14 +83,26 @@
#define STEELSERIES_APEX_OG_PID 0x1202
#define STEELSERIES_APEX_350_PID 0x1206
void DetectSteelSeriesAerox3(hid_device_info* info, const std::string& name)
{
hid_device* dev = hid_open_path(info->path);
if(dev)
{
SteelSeriesAerox3Controller* controller = new SteelSeriesAerox3Controller(dev, AEROX_3, info->path);
RGBController_SteelSeriesRival3* rgb_controller = new RGBController_SteelSeriesRival3(controller);
rgb_controller->name = name;
ResourceManager::get()->RegisterRGBController(rgb_controller);
}
}
void DetectSteelSeriesApexTZone(hid_device_info* info, const std::string& name)
{
hid_device* dev = hid_open_path(info->path);
if(dev)
{
SteelSeriesApexTZoneController* controller = new SteelSeriesApexTZoneController(dev, APEX_TZONE, info->path);
RGBController_SteelSeriesApexTZone* rgb_controller = new RGBController_SteelSeriesApexTZone(controller);
rgb_controller->name = name;
SteelSeriesApexTZoneController* controller = new SteelSeriesApexTZoneController(dev, APEX_TZONE, info->path);
RGBController_SteelSeriesApexTZone* rgb_controller = new RGBController_SteelSeriesApexTZone(controller);
rgb_controller->name = name;
ResourceManager::get()->RegisterRGBController(rgb_controller);
}
}
@ -99,9 +112,9 @@ void DetectSteelSeriesApex(hid_device_info* info, const std::string& name)
hid_device* dev = hid_open_path(info->path);
if(dev)
{
SteelSeriesApexController* controller = new SteelSeriesApexController(dev, APEX, info->path);
RGBController_SteelSeriesApex* rgb_controller = new RGBController_SteelSeriesApex(controller);
rgb_controller->name = name;
SteelSeriesApexController* controller = new SteelSeriesApexController(dev, APEX, info->path);
RGBController_SteelSeriesApex* rgb_controller = new RGBController_SteelSeriesApex(controller);
rgb_controller->name = name;
ResourceManager::get()->RegisterRGBController(rgb_controller);
}
}
@ -111,9 +124,9 @@ void DetectSteelSeriesApexTKL(hid_device_info* info, const std::string& name)
hid_device* dev = hid_open_path(info->path);
if(dev)
{
SteelSeriesApexController* controller = new SteelSeriesApexController(dev, APEX_TKL, info->path);
RGBController_SteelSeriesApex* rgb_controller = new RGBController_SteelSeriesApex(controller);
rgb_controller->name = name;
SteelSeriesApexController* controller = new SteelSeriesApexController(dev, APEX_TKL, info->path);
RGBController_SteelSeriesApex* rgb_controller = new RGBController_SteelSeriesApex(controller);
rgb_controller->name = name;
ResourceManager::get()->RegisterRGBController(rgb_controller);
}
}
@ -123,9 +136,9 @@ void DetectSteelSeriesApexM(hid_device_info* info, const std::string& name)
hid_device* dev = hid_open_path(info->path);
if(dev)
{
SteelSeriesApexMController* controller = new SteelSeriesApexMController(dev, APEX_M, info->path);
RGBController_SteelSeriesApex* rgb_controller = new RGBController_SteelSeriesApex(controller);
rgb_controller->name = name;
SteelSeriesApexMController* controller = new SteelSeriesApexMController(dev, APEX_M, info->path);
RGBController_SteelSeriesApex* rgb_controller = new RGBController_SteelSeriesApex(controller);
rgb_controller->name = name;
ResourceManager::get()->RegisterRGBController(rgb_controller);
}
}
@ -135,9 +148,9 @@ void DetectSteelSeriesApexOld(hid_device_info* info, const std::string& name)
hid_device* dev = hid_open_path(info->path);
if(dev)
{
SteelSeriesOldApexController* controller = new SteelSeriesOldApexController(dev, APEX_OLD, info->path);
RGBController_SteelSeriesOldApex* rgb_controller = new RGBController_SteelSeriesOldApex(controller);
rgb_controller->name = name;
SteelSeriesOldApexController* controller = new SteelSeriesOldApexController(dev, APEX_OLD, info->path);
RGBController_SteelSeriesOldApex* rgb_controller = new RGBController_SteelSeriesOldApex(controller);
rgb_controller->name = name;
ResourceManager::get()->RegisterRGBController(rgb_controller);
}
}
@ -147,9 +160,9 @@ void DetectSteelSeriesHeadset(hid_device_info* info, const std::string& name)
hid_device* dev = hid_open_path(info->path);
if(dev)
{
SteelSeriesSiberiaController* controller = new SteelSeriesSiberiaController(dev, info->path);
RGBController_SteelSeriesSiberia* rgb_controller = new RGBController_SteelSeriesSiberia(controller);
rgb_controller->name = name;
SteelSeriesSiberiaController* controller = new SteelSeriesSiberiaController(dev, info->path);
RGBController_SteelSeriesSiberia* rgb_controller = new RGBController_SteelSeriesSiberia(controller);
rgb_controller->name = name;
ResourceManager::get()->RegisterRGBController(rgb_controller);
}
}
@ -159,9 +172,9 @@ void DetectSteelSeriesMousemat(hid_device_info* info, const std::string& name)
hid_device* dev = hid_open_path(info->path);
if(dev)
{
SteelSeriesQCKMatController* controller = new SteelSeriesQCKMatController(dev, info->path);
RGBController_SteelSeriesQCKMat* rgb_controller = new RGBController_SteelSeriesQCKMat(controller);
rgb_controller->name = name;
SteelSeriesQCKMatController* controller = new SteelSeriesQCKMatController(dev, info->path);
RGBController_SteelSeriesQCKMat* rgb_controller = new RGBController_SteelSeriesQCKMat(controller);
rgb_controller->name = name;
ResourceManager::get()->RegisterRGBController(rgb_controller);
}
}
@ -171,9 +184,9 @@ void DetectSteelSeriesRival100(hid_device_info* info, const std::string& name)
hid_device* dev = hid_open_path(info->path);
if(dev)
{
SteelSeriesRivalController* controller = new SteelSeriesRivalController(dev, RIVAL_100, info->path);
RGBController_SteelSeriesRival* rgb_controller = new RGBController_SteelSeriesRival(controller);
rgb_controller->name = name;
SteelSeriesRivalController* controller = new SteelSeriesRivalController(dev, RIVAL_100, info->path);
RGBController_SteelSeriesRival* rgb_controller = new RGBController_SteelSeriesRival(controller);
rgb_controller->name = name;
ResourceManager::get()->RegisterRGBController(rgb_controller);
}
}
@ -183,9 +196,9 @@ void DetectSteelSeriesRival300(hid_device_info* info, const std::string& name)
hid_device* dev = hid_open_path(info->path);
if(dev)
{
SteelSeriesRivalController* controller = new SteelSeriesRivalController(dev, RIVAL_300, info->path);
RGBController_SteelSeriesRival* rgb_controller = new RGBController_SteelSeriesRival(controller);
rgb_controller->name = name;
SteelSeriesRivalController* controller = new SteelSeriesRivalController(dev, RIVAL_300, info->path);
RGBController_SteelSeriesRival* rgb_controller = new RGBController_SteelSeriesRival(controller);
rgb_controller->name = name;
ResourceManager::get()->RegisterRGBController(rgb_controller);
}
}
@ -195,9 +208,9 @@ void DetectSteelSeriesRival600(hid_device_info* info, const std::string& name)
hid_device* dev = hid_open_path(info->path);
if(dev)
{
SteelSeriesRivalController* controller = new SteelSeriesRivalController(dev, RIVAL_600, info->path);
RGBController_SteelSeriesRival* rgb_controller = new RGBController_SteelSeriesRival(controller);
rgb_controller->name = name;
SteelSeriesRivalController* controller = new SteelSeriesRivalController(dev, RIVAL_600, info->path);
RGBController_SteelSeriesRival* rgb_controller = new RGBController_SteelSeriesRival(controller);
rgb_controller->name = name;
ResourceManager::get()->RegisterRGBController(rgb_controller);
}
}
@ -208,9 +221,9 @@ void DetectSteelSeriesRival650(hid_device_info* info, const std::string& name)
hid_device* dev = hid_open_path(info->path);
if(dev)
{
SteelSeriesRivalController* controller = new SteelSeriesRivalController(dev, RIVAL_650, info->path);
RGBController_SteelSeriesRival* rgb_controller = new RGBController_SteelSeriesRival(controller);
rgb_controller->name = name;
SteelSeriesRivalController* controller = new SteelSeriesRivalController(dev, RIVAL_650, info->path);
RGBController_SteelSeriesRival* rgb_controller = new RGBController_SteelSeriesRival(controller);
rgb_controller->name = name;
ResourceManager::get()->RegisterRGBController(rgb_controller);
}
}
@ -220,9 +233,9 @@ void DetectSteelSeriesRival700(hid_device_info* info, const std::string& name)
hid_device* dev = hid_open_path(info->path);
if(dev)
{
SteelSeriesRivalController* controller = new SteelSeriesRivalController(dev, RIVAL_700, info->path);
RGBController_SteelSeriesRival* rgb_controller = new RGBController_SteelSeriesRival(controller);
rgb_controller->name = name;
SteelSeriesRivalController* controller = new SteelSeriesRivalController(dev, RIVAL_700, info->path);
RGBController_SteelSeriesRival* rgb_controller = new RGBController_SteelSeriesRival(controller);
rgb_controller->name = name;
ResourceManager::get()->RegisterRGBController(rgb_controller);
}
}
@ -233,9 +246,9 @@ void DetectSteelSeriesRival3(hid_device_info* info, const std::string& name)
hid_device* dev = hid_open_path(info->path);
if(dev)
{
SteelSeriesRival3Controller* controller = new SteelSeriesRival3Controller(dev, RIVAL_3, info->path);
RGBController_SteelSeriesRival3* rgb_controller = new RGBController_SteelSeriesRival3(controller);
rgb_controller->name = name;
SteelSeriesRival3Controller* controller = new SteelSeriesRival3Controller(dev, RIVAL_3, info->path);
RGBController_SteelSeriesRival3* rgb_controller = new RGBController_SteelSeriesRival3(controller);
rgb_controller->name = name;
ResourceManager::get()->RegisterRGBController(rgb_controller);
}
}
@ -245,9 +258,9 @@ void DetectSteelSeriesSensei(hid_device_info* info, const std::string& name)
hid_device* dev = hid_open_path(info->path);
if(dev)
{
SteelSeriesSenseiController* controller = new SteelSeriesSenseiController(dev, SENSEI, info->path);
RGBController_SteelSeriesSensei* rgb_controller = new RGBController_SteelSeriesSensei(controller);
rgb_controller->name = name;
SteelSeriesSenseiController* controller = new SteelSeriesSenseiController(dev, SENSEI, info->path);
RGBController_SteelSeriesSensei* rgb_controller = new RGBController_SteelSeriesSensei(controller);
rgb_controller->name = name;
ResourceManager::get()->RegisterRGBController(rgb_controller);
}
}
@ -268,6 +281,7 @@ void DetectSteelSeriesArctis5(hid_device_info* info, const std::string& name)
/*-------------------------------------------------------------------------------------------------------------------------------------------------------------------------*\
| Mice |
\*-------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/
REGISTER_HID_DETECTOR_IPU("SteelSeries Aerox 3 Wired", DetectSteelSeriesAerox3, STEELSERIES_VID, STEELSERIES_AEROX_3_PID, 3, 0xFFC0, 1 );
REGISTER_HID_DETECTOR_I("SteelSeries Rival 100", DetectSteelSeriesRival100, STEELSERIES_VID, STEELSERIES_RIVAL_100_PID, 0 );
REGISTER_HID_DETECTOR_I("SteelSeries Rival 100 DotA 2 Edition", DetectSteelSeriesRival100, STEELSERIES_VID, STEELSERIES_RIVAL_100_DOTA_PID, 0 );
REGISTER_HID_DETECTOR_I("SteelSeries Rival 105", DetectSteelSeriesRival100, STEELSERIES_VID, STEELSERIES_RIVAL_105_PID, 0 );

1
Controllers/SteelSeriesController/SteelSeriesGeneric.h
View file

@ -30,5 +30,6 @@ typedef enum
RIVAL_3 = 0x0a,
APEX_TZONE = 0x0b,
RIVAL_700 = 0x0c,
AEROX_3 = 0x0d,
} steelseries_type;

61
Controllers/SteelSeriesController/SteelSeriesMouseController.cpp Normal file
View file

@ -0,0 +1,61 @@
/*-------------------------------------------------------------------*\
| SteelSeriesMouseController.cpp |
| |
| OpenRGB abstract driver for SteelSeries Mice |
| |
| Chris M (Dr_No) 9th June 2022 |
\*-------------------------------------------------------------------*/
#include <cstring>
#include "SteelSeriesMouseController.h"
SteelSeriesMouseController::SteelSeriesMouseController(hid_device* dev_handle, steelseries_type proto_type, const char* path)
{
dev = dev_handle;
location = path;
proto = proto_type;
}
SteelSeriesMouseController::~SteelSeriesMouseController()
{
}
std::string SteelSeriesMouseController::GetDeviceLocation()
{
return("HID: " + location);
}
char* SteelSeriesMouseController::GetDeviceName()
{
return device_name;
}
std::string SteelSeriesMouseController::GetSerialString()
{
wchar_t serial_string[128];
int ret = hid_get_serial_number_string(dev, serial_string, 128);
if (ret != 0)
{
return("");
}
std::wstring return_wstring = serial_string;
std::string return_string(return_wstring.begin(), return_wstring.end());
return(return_string);
}
steelseries_type SteelSeriesMouseController::GetMouseType()
{
return proto;
}
void SteelSeriesMouseController::Save()
{
const uint8_t SAVE_BUFFER_SIZE = 10;
uint8_t usb_buf[SAVE_BUFFER_SIZE] = { 0x00, 0x09 };
hid_write(dev, usb_buf, SAVE_BUFFER_SIZE);
}

80
Controllers/SteelSeriesController/SteelSeriesMouseController.h Normal file
View file

@ -0,0 +1,80 @@
/*-------------------------------------------------------------------*\
| SteelSeriesMouseController.h |
| |
| OpenRGB abstract driver for SteelSeries Mice |
| |
| Chris M (Dr_No) 9th June 2022 |
\*-------------------------------------------------------------------*/
#include <string>
#include <hidapi/hidapi.h>
#include <vector>
#include "SteelSeriesGeneric.h"
#pragma once
#define STEELSERIES_MOUSE_BRIGHTNESS_MAX 0x64
/*-----------------------------------------------------------*\
| Theses are the specific values that get sent to set a mode |
\*-----------------------------------------------------------*/
enum
{
STEELSERIES_MOUSE_EFFECT_SPECTRUM_CYCLE = 0x00,
STEELSERIES_MOUSE_EFFECT_BREATHING_MAX = 0x01,
STEELSERIES_MOUSE_EFFECT_BREATHING_MID = 0x02,
STEELSERIES_MOUSE_EFFECT_BREATHING_MIN = 0x03,
STEELSERIES_MOUSE_EFFECT_DIRECT = 0x04,
STEELSERIES_MOUSE_EFFECT_RAINBOW_BREATHING = 0x05,
STEELSERIES_MOUSE_EFFECT_DISCO = 0x06
};
typedef struct
{
const char* name;
const int value;
} led_info;
typedef struct
{
std::vector<uint8_t> modes;
std::vector<led_info> leds;
} steelseries_mouse;
class SteelSeriesMouseController
{
public:
SteelSeriesMouseController(hid_device* dev_handle, steelseries_type proto_type, const char* path);
~SteelSeriesMouseController();
std::string GetDeviceLocation();
char* GetDeviceName();
std::string GetSerialString();
steelseries_type GetMouseType();
/*-----------------------------------------------------------------*\
| Save has a common function but can be overridden |
\*-----------------------------------------------------------------*/
virtual void Save();
virtual steelseries_mouse GetMouse() = 0;
virtual std::string GetFirmwareVersion() = 0;
virtual void SetLightEffectAll(uint8_t effect) = 0;
virtual void SetColor
(
unsigned char zone_id,
unsigned char red,
unsigned char green,
unsigned char blue,
unsigned char brightness
) = 0;
protected:
char device_name[32];
hid_device* dev;
std::string location;
steelseries_type proto;
private:
};

21
Controllers/SteelSeriesController/SteelSeriesRival3Controller.cpp
View file

@ -17,11 +17,11 @@ SteelSeriesRival3Controller::SteelSeriesRival3Controller
hid_device* dev_handle,
steelseries_type proto_type,
const char* path
)
) : SteelSeriesMouseController(dev_handle, proto_type, path)
{
dev = dev_handle;
location = path;
proto = proto_type;
//dev = dev_handle;
//location = path;
//proto = proto_type;
}
SteelSeriesRival3Controller::~SteelSeriesRival3Controller()
@ -29,6 +29,7 @@ SteelSeriesRival3Controller::~SteelSeriesRival3Controller()
hid_close(dev);
}
/*
std::string SteelSeriesRival3Controller::GetDeviceLocation()
{
return("HID: " + location);
@ -43,7 +44,7 @@ std::string SteelSeriesRival3Controller::GetSerialString()
{
wchar_t serial_string[128];
int ret = hid_get_serial_number_string(dev, serial_string, 128);
if (ret != 0)
{
return("");
@ -54,6 +55,7 @@ std::string SteelSeriesRival3Controller::GetSerialString()
return(return_string);
}
*/
std::string SteelSeriesRival3Controller::GetFirmwareVersion()
{
@ -69,6 +71,12 @@ std::string SteelSeriesRival3Controller::GetFirmwareVersion()
return return_string;
}
steelseries_mouse SteelSeriesRival3Controller::GetMouse()
{
return rival_3;
}
/*
steelseries_type SteelSeriesRival3Controller::GetMouseType()
{
return proto;
@ -78,9 +86,10 @@ void SteelSeriesRival3Controller::Save()
{
const uint8_t SAVE_BUFFER_SIZE = 10;
uint8_t usb_buf[SAVE_BUFFER_SIZE] = { 0x00, 0x09 };
hid_write(dev, usb_buf, SAVE_BUFFER_SIZE);
}
*/
void SteelSeriesRival3Controller::SetLightEffectAll(uint8_t effect)
{

52
Controllers/SteelSeriesController/SteelSeriesRival3Controller.h
View file

@ -11,26 +11,32 @@
#include <hidapi/hidapi.h>
#include "SteelSeriesGeneric.h"
#include "SteelSeriesMouseController.h"
#pragma once
#define STEELSERIES_RIVAL_3_BRIGHTNESS_MAX 0x64
//#define STEELSERIES_RIVAL_3_BRIGHTNESS_MAX 0x64
/*-----------------------------------------------------------*\
| Theses are the specific values that get sent to set a mode |
\*-----------------------------------------------------------*/
enum
/*static const steelseries_mouse_led_info rival_3_leds[]=
{
STEELSERIES_RIVAL_3_EFFECT_SPECTRUM_CYCLE = 0x00,
STEELSERIES_RIVAL_3_EFFECT_BREATHING_MAX = 0x01,
STEELSERIES_RIVAL_3_EFFECT_BREATHING_MID = 0x02,
STEELSERIES_RIVAL_3_EFFECT_BREATHING_MIN = 0x03,
STEELSERIES_RIVAL_3_EFFECT_DIRECT = 0x04,
STEELSERIES_RIVAL_3_EFFECT_RAINBOW_BREATHING = 0x05,
STEELSERIES_RIVAL_3_EFFECT_DISCO = 0x06
{"Front", 0x01},
{"Middle", 0x02},
{"Rear", 0x03},
{"Logo", 0x04}
};*/
static const steelseries_mouse rival_3 =
{
{ 0x04, 0x03, 0x00, 0x05 },
{
{"Front", 0x01},
{"Middle", 0x02},
{"Rear", 0x03},
{"Logo", 0x04}
}
};
class SteelSeriesRival3Controller
class SteelSeriesRival3Controller: public SteelSeriesMouseController
{
public:
SteelSeriesRival3Controller
@ -42,14 +48,14 @@ public:
~SteelSeriesRival3Controller();
std::string GetDeviceLocation();
char* GetDeviceName();
std::string GetSerialString();
//std::string GetDeviceLocation();
//char* GetDeviceName();
//std::string GetSerialString();
std::string GetFirmwareVersion();
steelseries_mouse GetMouse();
//steelseries_type GetMouseType();
steelseries_type GetMouseType();
void Save();
//void Save();
void SetLightEffectAll(uint8_t effect);
@ -63,8 +69,8 @@ public:
);
private:
char device_name[32];
hid_device* dev;
std::string location;
steelseries_type proto;
//char device_name[32];
//hid_device* dev;
//std::string location;
//steelseries_type proto;
};

10
OpenRGB.pro
View file

@ -525,12 +525,14 @@ HEADERS +=
Controllers/SonyDS4Controller/SonyDS4Controller.h \
Controllers/SonyDS4Controller/RGBController_SonyDS4.h \
Controllers/SteelSeriesController/color32.h \
Controllers/SteelSeriesController/SteelSeriesAerox3Controller.h \
Controllers/SteelSeriesController/SteelSeriesApexBaseController.h \
Controllers/SteelSeriesController/SteelSeriesApexController.h \
Controllers/SteelSeriesController/SteelSeriesApexTZoneController.h \
Controllers/SteelSeriesController/SteelSeriesApexMController.h \
Controllers/SteelSeriesController/SteelSeriesApexTZoneController.h \
Controllers/SteelSeriesController/SteelSeriesArctis5Controller.h \
Controllers/SteelSeriesController/SteelSeriesGeneric.h \
Controllers/SteelSeriesController/SteelSeriesMouseController.h \
Controllers/SteelSeriesController/SteelSeriesOldApexController.h \
Controllers/SteelSeriesController/SteelSeriesRivalController.h \
Controllers/SteelSeriesController/SteelSeriesRival3Controller.h \
@ -1048,17 +1050,19 @@ SOURCES +=
Controllers/SonyDS4Controller/SonyDS4Controller.cpp \
Controllers/SonyDS4Controller/SonyDS4ControllerDetect.cpp \
Controllers/SonyDS4Controller/RGBController_SonyDS4.cpp \
Controllers/SteelSeriesController/SteelSeriesAerox3Controller.cpp \
Controllers/SteelSeriesController/SteelSeriesApexController.cpp \
Controllers/SteelSeriesController/SteelSeriesApexTZoneController.cpp \
Controllers/SteelSeriesController/SteelSeriesApexMController.cpp \
Controllers/SteelSeriesController/SteelSeriesApexTZoneController.cpp \
Controllers/SteelSeriesController/SteelSeriesArctis5Controller.cpp \
Controllers/SteelSeriesController/SteelSeriesControllerDetect.cpp \
Controllers/SteelSeriesController/SteelSeriesMouseController.cpp \
Controllers/SteelSeriesController/SteelSeriesOldApexController.cpp \
Controllers/SteelSeriesController/SteelSeriesRivalController.cpp \
Controllers/SteelSeriesController/SteelSeriesRival3Controller.cpp \
Controllers/SteelSeriesController/SteelSeriesSenseiController.cpp \
Controllers/SteelSeriesController/SteelSeriesSiberiaController.cpp \
Controllers/SteelSeriesController/SteelSeriesQCKMatController.cpp \
Controllers/SteelSeriesController/SteelSeriesControllerDetect.cpp \
Controllers/SteelSeriesController/RGBController_SteelSeriesApex.cpp \
Controllers/SteelSeriesController/RGBController_SteelSeriesApexTZone.cpp \
Controllers/SteelSeriesController/RGBController_SteelSeriesArctis5.cpp \