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

Added Reactive Mode For Aerox 9 in General Aerox Controller And Deleted Old Controller

Browse source
This commit is contained in:
rom4ster 2024-11-02 23:00:49 +00:00 • committed by Adam Honse
parent 1368f83d77
commit d627c91a4a
5 changed files with 30 additions and 223 deletions
Download patch file Download diff file Expand all files Collapse all files

146
Controllers/SteelSeriesController/SteelSeriesAerox9Controller/SteelSeriesAerox9Controller.cpp
View file

@ -1,146 +0,0 @@
/*---------------------------------------------------------*\
| SteelSeriesAerox9Controller.cpp |
| |
| Driver for the Steelseries Aerox 9 |
| |
| rom4ster 11 Oct 2022 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-only |
\*---------------------------------------------------------*/
#include "SteelSeriesAerox9Controller.h"
#include "LogManager.h"
SteelSeriesAerox9Controller::SteelSeriesAerox9Controller(hid_device* dev_handle, steelseries_type proto_type, const char* path)
: SteelSeriesMouseController(dev_handle, proto_type, path)
{
SendInit();
}
SteelSeriesAerox9Controller::~SteelSeriesAerox9Controller()
{
hid_close(dev);
}
void SteelSeriesAerox9Controller::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_AEORX9_PACKET_SIZE] = { 0x00, 0x2D };
hid_send_feature_report(dev, buffer, STEELSERIES_AEORX9_PACKET_SIZE);
}
std::string SteelSeriesAerox9Controller::GetFirmwareVersion()
{
uint8_t result = 0;
const uint8_t CMD = 0x90;
const uint8_t sz = 16;
char version[sz + 1];
uint8_t buffer[STEELSERIES_AEORX9_PACKET_SIZE] = { 0x00, CMD, 0x00 };
hid_send_feature_report(dev, buffer, STEELSERIES_AEORX9_PACKET_SIZE);
do
{
result = hid_read_timeout(dev, buffer, STEELSERIES_AEORX9_PACKET_SIZE, STEELSERIES_AEORX9_TIMEOUT);
LOG_DEBUG("[%s] Reading version buffer: Bytes Read %d Buffer %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X", STEELSERIES_AEORX9_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);
version[sz] = 0;
std::string tmp = std::string(version);
LOG_DEBUG("[%s] Version: %s as string %s", STEELSERIES_AEORX9_NAME, version, tmp.c_str());
return tmp;
}
else
{
LOG_DEBUG("[%s] Unable to get version: giving up!", STEELSERIES_AEORX9_NAME);
return "";
}
}
steelseries_mouse SteelSeriesAerox9Controller::GetMouse()
{
return aerox_9;
}
void SteelSeriesAerox9Controller::SetLightEffectAll(uint8_t /*effect*/)
{
/*-----------------------------------------------------------------*\
| Not used by this device |
\*-----------------------------------------------------------------*/
}
void SteelSeriesAerox9Controller::SetColor
(
unsigned char zone_id,
unsigned char red,
unsigned char green,
unsigned char blue,
unsigned char brightness
)
{
uint8_t buffer[STEELSERIES_AEORX9_PACKET_SIZE] =
{
0x00,
0x21
};
buffer[0x02] = 0x1;
uint8_t offset = 0x3;
if (zone_id == 3)
{
offset = 0x3;
buffer[0x01] = 0x26;
buffer[offset] = 0x00;
} else {
buffer[offset] = zone_id;
}
buffer[offset + 1] = red;
buffer[offset + 2] = green;
buffer[offset + 3] = blue;
hid_write(dev, buffer, STEELSERIES_AEORX9_PACKET_SIZE);
if(brightness != current_brightness)
{
SetBrightness(brightness);
current_brightness = brightness;
}
Save();
}
void SteelSeriesAerox9Controller::SetBrightness(uint8_t brightness)
{
uint8_t buffer[STEELSERIES_AEORX9_PACKET_SIZE] = { 0x00, 0x23, brightness };
hid_write(dev, buffer, STEELSERIES_AEORX9_PACKET_SIZE);
}
void SteelSeriesAerox9Controller::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_AEORX9_PACKET_SIZE] = { 0x00, 0x11, 0x00 };
hid_write(dev, buffer2, STEELSERIES_AEORX9_PACKET_SIZE);
}

60
Controllers/SteelSeriesController/SteelSeriesAerox9Controller/SteelSeriesAerox9Controller.h
View file

@ -1,60 +0,0 @@
/*---------------------------------------------------------*\
| SteelSeriesAerox9Controller.h |
| |
| Driver for the Steelseries Aerox 9 |
| |
| rom4ster 11 Oct 2022 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-only |
\*---------------------------------------------------------*/
#pragma once
#include <cstring>
#include <string>
#include <hidapi.h>
#include "RGBController.h"
#include "SteelSeriesGeneric.h"
#include "SteelSeriesMouseController.h"
#define STEELSERIES_AEORX9_NAME "SteelSeries Aerox 9"
#define STEELSERIES_AEORX9_PACKET_SIZE 65
#define STEELSERIES_AEORX9_TIMEOUT 250
static const steelseries_mouse aerox_9 =
{
{ 0x04 },
{
{"Front", 0 },
{"Middle", 1 },
{"Rear", 2 },
{"Reactive", 3 },
}
};
class SteelSeriesAerox9Controller: public SteelSeriesMouseController
{
public:
SteelSeriesAerox9Controller(hid_device* dev_handle, steelseries_type proto_type, const char* path);
~SteelSeriesAerox9Controller();
std::string GetFirmwareVersion() override;
steelseries_mouse GetMouse() override;
void Save() override;
void SetLightEffectAll(uint8_t effect) override;
void SetColor
(
unsigned char zone_id,
unsigned char red,
unsigned char green,
unsigned char blue,
unsigned char brightness
) override;
private:
void SendInit();
void SetBrightness(uint8_t brightness);
uint8_t current_brightness;
};

22
Controllers/SteelSeriesController/SteelSeriesAeroxWirelessController/SteelSeriesAeroxWirelessController.cpp
View file

@ -132,7 +132,16 @@ std::string SteelSeriesAeroxWirelessController::GetFirmwareVersion()
steelseries_mouse SteelSeriesAeroxWirelessController::GetMouse()
{
return aerox_3_wireless;
switch(proto)
{
case AEROX_9_WIRELESS:
case AEROX_9_WIRELESS_WIRED:
return aerox_9;
break;
default:
return aerox_3_wireless;
break;
}
}
void SteelSeriesAeroxWirelessController::SetLightEffectAll(uint8_t effect)
@ -155,10 +164,17 @@ void SteelSeriesAeroxWirelessController::SetColor
)
{
uint8_t buffer[STEELSERIES_AEROX_WIRELESS_PACKET_SIZE] = { 0x00, 0x21, 0x01 };
buffer[0x03] = zone_id;
uint8_t offset = 0x04;
if (zone_id == 3 && (proto == AEROX_9_WIRELESS_WIRED || proto == AEROX_9_WIRELESS))
{
buffer[0x03] = 0x00;
buffer[0x01] = 0x26;
}
else
{
buffer[0x03] = zone_id;
}
buffer[offset] = red;
buffer[offset + 1] = green;
buffer[offset + 2] = blue;

11
Controllers/SteelSeriesController/SteelSeriesAeroxWirelessController/SteelSeriesAeroxWirelessController.h
View file

@ -42,6 +42,17 @@ static const steelseries_mouse aerox_3_wireless =
}
};
static const steelseries_mouse aerox_9 =
{
{ 0x04, 0x05 },
{
{"Front", 0 },
{"Middle", 1 },
{"Rear", 2 },
{"Reactive", 3 },
}
};
class SteelSeriesAeroxWirelessController: public SteelSeriesMouseController
{
public:

14
Controllers/SteelSeriesController/SteelSeriesControllerDetect.cpp
View file

@ -12,7 +12,6 @@
#include "SteelSeriesGeneric.h"
#include "SteelSeriesAeroxWirelessController.h"
#include "SteelSeriesAerox5Controller.h"
#include "SteelSeriesAerox9Controller.h"
#include "SteelSeriesArctis5Controller.h"
#include "SteelSeriesApex8ZoneController.h"
#include "SteelSeriesApexController.h"
@ -192,18 +191,6 @@ void DetectSteelSeriesAerox5DiabloWirelessWired(hid_device_info* info, const std
DetectSteelSeriesAeroxWireless(info, name, AEROX_5_DIABLO_WIRELESS_WIRED);
}
void DetectSteelSeriesAerox9(hid_device_info* info, const std::string& name)
{
hid_device* dev = hid_open_path(info->path);
if(dev)
{
SteelSeriesAerox9Controller* controller = new SteelSeriesAerox9Controller(dev, AEROX_3, info->path);
RGBController_SteelSeriesRival3* rgb_controller = new RGBController_SteelSeriesRival3(controller);
rgb_controller->name = name;
ResourceManager::get()->RegisterRGBController(rgb_controller);
}
}
void DetectSteelSeriesAerox9Wireless(hid_device_info* info, const std::string& name)
{
DetectSteelSeriesAeroxWireless(info, name, AEROX_9_WIRELESS);
@ -412,7 +399,6 @@ REGISTER_HID_DETECTOR_IPU("SteelSeries Aerox 5 Diablo IV Edition Wireless Wired"
REGISTER_HID_DETECTOR_IPU("SteelSeries Aerox 5 Wired", DetectSteelSeriesAerox5, STEELSERIES_VID, STEELSERIES_AEROX_5_PID, 3, 0xFFC0, 1 );
REGISTER_HID_DETECTOR_IPU("SteelSeries Aerox 9 Wireless", DetectSteelSeriesAerox9Wireless, STEELSERIES_VID, STEELSERIES_AEROX_9_WIRELESS_PID, 3, 0xFFC0, 1 );
REGISTER_HID_DETECTOR_IPU("SteelSeries Aerox 9 Wireless Wired", DetectSteelSeriesAerox9WirelessWired, STEELSERIES_VID, STEELSERIES_AEROX_9_WIRELESS_WIRED_PID, 3, 0xFFC0, 1 );
REGISTER_HID_DETECTOR_IPU("SteelSeries Aerox 9 Wired", DetectSteelSeriesAerox9, STEELSERIES_VID, STEELSERIES_AEROX_9_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);