mirror/OpenRGB
1
0
Fork 0
mirror of https://github.com/CalcProgrammer1/OpenRGB.git synced 2026-04-04 22:24:12 -04:00
Code Issues Packages Projects Releases Wiki Activity

Added SteelSeries Sensei TEN

Browse Source 
Commits squashed and amended for code style by Adam Honse <calcprogrammer1@gmail.com>
This commit is contained in:
jeffp1
2021-04-15 15:04:28 -04:00
committed by Adam Honse
parent b342e9a993
commit 6c2013a6bf
7 changed files with 623 additions and 29 deletions
Download Patch File Download Diff File Expand all files Collapse all files

143
Controllers/SteelSeriesController/RGBController_SteelSeriesSenseiTen.cpp Normal file
View File

@@ -0,0 +1,143 @@
/*------------------------------------------*\
| RGBController_SteelSeriesSenseiTen.cpp |
| |
| Generic RGB Interface SteelSeriesSenseiTen|
| Class |
| Based on Rival Controller by |
| B Horn (bahorn) 13/05/2020 |
\*------------------------------------------*/
#include "RGBController_SteelSeriesSenseiTen.h"
RGBController_SteelSeriesSenseiTen::RGBController_SteelSeriesSenseiTen(SteelSeriesSenseiTenController* sensei_ptr)
{
sensei = sensei_ptr;
name = sensei->GetDeviceName();
vendor = "SteelSeries";
type = DEVICE_TYPE_MOUSE;
description = "SteelSeries Sensei Device";
location = sensei->GetDeviceLocation();
serial = sensei->GetSerialString();
mode Direct;
Direct.name = "Direct";
Direct.value = STEELSERIES_SENSEI_MODE_DIRECT;
Direct.flags = MODE_FLAG_HAS_PER_LED_COLOR;
Direct.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Direct);
mode Breathing;
Breathing.name = "Breathing";
Breathing.value = STEELSERIES_SENSEI_MODE_BREATHING;
Breathing.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
Breathing.color_mode = MODE_COLORS_PER_LED;
Breathing.speed_min = STEELSERIES_SENSEI_EFFECT_BREATHING_MIN;
Breathing.speed_max = STEELSERIES_SENSEI_EFFECT_BREATHING_MAX;
Breathing.speed = STEELSERIES_SENSEI_EFFECT_BREATHING_MID;
modes.push_back(Breathing);
mode Rainbow;
Rainbow.name = "Rainbow";
Rainbow.value = STEELSERIES_SENSEI_MODE_RAINBOW;
Rainbow.flags = MODE_FLAG_HAS_SPEED;
Rainbow.color_mode = MODE_COLORS_NONE;
Rainbow.speed_min = STEELSERIES_SENSEI_EFFECT_RAINBOW_MIN;
Rainbow.speed_max = STEELSERIES_SENSEI_EFFECT_RAINBOW_MAX;
Rainbow.speed = STEELSERIES_SENSEI_EFFECT_RAINBOW_MID;
modes.push_back(Rainbow);
SetupZones();
}
RGBController_SteelSeriesSenseiTen::~RGBController_SteelSeriesSenseiTen()
{
delete sensei;
}
void RGBController_SteelSeriesSenseiTen::SetupZones()
{
zone logo_zone;
logo_zone.name = "Logo";
logo_zone.type = ZONE_TYPE_SINGLE;
logo_zone.leds_min = 1;
logo_zone.leds_max = 1;
logo_zone.leds_count = 1;
logo_zone.matrix_map = NULL;
zones.push_back(logo_zone);
led logo_led;
logo_led.name = "Logo";
leds.push_back(logo_led);
zone wheel_zone;
wheel_zone.name = "Scroll Wheel";
wheel_zone.type = ZONE_TYPE_SINGLE;
wheel_zone.leds_min = 1;
wheel_zone.leds_max = 1;
wheel_zone.leds_count = 1;
wheel_zone.matrix_map = NULL;
zones.push_back(wheel_zone);
led wheel_led;
wheel_led.name = "Scroll Wheel";
leds.push_back(wheel_led);
SetupColors();
}
void RGBController_SteelSeriesSenseiTen::ResizeZone(int /*zone*/, int /*new_size*/)
{
/*---------------------------------------------------------*\
| This device does not support resizing zones |
\*---------------------------------------------------------*/
}
void RGBController_SteelSeriesSenseiTen::DeviceUpdateLEDs()
{
UpdateZoneLEDs(0);
UpdateZoneLEDs(1);
}
void RGBController_SteelSeriesSenseiTen::UpdateZoneLEDs(int zone)
{
RGBColor color = colors[zone];
unsigned char red = RGBGetRValue(color);
unsigned char grn = RGBGetGValue(color);
unsigned char blu = RGBGetBValue(color);
switch(modes[active_mode].value)
{
case STEELSERIES_SENSEI_MODE_DIRECT:
sensei->SetColor(zone, red, grn, blu);
break;
case STEELSERIES_SENSEI_MODE_BREATHING:
case STEELSERIES_SENSEI_MODE_RAINBOW:
sensei->SetLightEffect(zone, modes[active_mode].value, modes[active_mode].speed, red, grn, blu);
break;
}
}
void RGBController_SteelSeriesSenseiTen::UpdateSingleLED(int led)
{
/*---------------------------------------------------------*\
| Each zone only has a single LED, so we can use the LED ID |
| to reference the existing zone code. |
\*---------------------------------------------------------*/
UpdateZoneLEDs(led);
}
void RGBController_SteelSeriesSenseiTen::SetCustomMode()
{
active_mode = 0;
}
void RGBController_SteelSeriesSenseiTen::DeviceUpdateMode()
{
/*---------------------------------------------------------*\
| Strictly, the device actually does support different modes|
| for the different zones, but we don't support that. |
\*---------------------------------------------------------*/
DeviceUpdateLEDs();
}

34
Controllers/SteelSeriesController/RGBController_SteelSeriesSenseiTen.h Normal file
View File

@@ -0,0 +1,34 @@
/*------------------------------------------*\
| RGBController_SteelSeriesSenseiTen.h |
| |
| Generic RGB Interface SteelSeriesSenseiTen|
| Class |
| Based on Rival controller by |
| B Horn (bahorn) 13/05/2020 |
\*------------------------------------------*/
#pragma once
#include "RGBController.h"
#include "SteelSeriesSenseiTenController.h"
class RGBController_SteelSeriesSenseiTen : public RGBController
{
public:
RGBController_SteelSeriesSenseiTen(SteelSeriesSenseiTenController* sensei_ptr);
~RGBController_SteelSeriesSenseiTen();
void SetupZones();
void ResizeZone(int zone, int new_size);
void DeviceUpdateLEDs();
void UpdateZoneLEDs(int zone);
void UpdateSingleLED(int led);
void SetCustomMode();
void DeviceUpdateMode();
private:
SteelSeriesSenseiTenController* sensei;
};

74
Controllers/SteelSeriesController/SteelSeriesControllerDetect.cpp
View File

@@ -4,12 +4,14 @@
#include "SteelSeriesApexController.h"
#include "SteelSeriesOldApexController.h"
#include "SteelSeriesApexMController.h"
#include "SteelSeriesSenseiTenController.h"
#include "SteelSeriesGeneric.h"
#include "RGBController.h"
#include "RGBController_SteelSeriesRival.h"
#include "RGBController_SteelSeriesSiberia.h"
#include "RGBController_SteelSeriesApex.h"
#include "RGBController_SteelSeriesOldApex.h"
#include "RGBController_SteelSeriesSenseiTen.h"
#include <hidapi/hidapi.h>
/*-----------------------------------------------------*\
@@ -31,6 +33,7 @@
#define STEELSERIES_RIVAL_300_DOTA_PID 0x1392
#define STEELSERIES_RIVAL_300_HP_PID 0x1718
#define STEELSERIES_RIVAL_300_BLACKOPS_PID 0x1710
#define STEELSERIES_SENSEI_TEN_PID 0x1832
/*-----------------------------------------------------*\
| Headset product IDs |
\*-----------------------------------------------------*/
@@ -130,32 +133,45 @@ void DetectSteelSeriesRival300(hid_device_info* info, const std::string& name)
}
}
/*-----------------------------------------------------------------------------------------------------------------------------------------------------------------*\
| Mice |
\*-----------------------------------------------------------------------------------------------------------------------------------------------------------------*/
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);
REGISTER_HID_DETECTOR_I("SteelSeries Rival 110", DetectSteelSeriesRival100, STEELSERIES_VID, STEELSERIES_RIVAL_110_PID, 0);
REGISTER_HID_DETECTOR_I("SteelSeries Rival 300", DetectSteelSeriesRival300, STEELSERIES_VID, STEELSERIES_RIVAL_300_PID, 0);
REGISTER_HID_DETECTOR_I("Acer Predator Gaming Mouse (Rival 300)", DetectSteelSeriesRival300, STEELSERIES_VID, ACER_PREDATOR_RIVAL_300_PID, 0);
REGISTER_HID_DETECTOR_I("SteelSeries Rival 300 CS:GO Fade Edition", DetectSteelSeriesRival300, STEELSERIES_VID, STEELSERIES_RIVAL_300_CSGO_PID, 0);
REGISTER_HID_DETECTOR_I("SteelSeries Rival 300 CS:GO Fade Edition (stm32)", DetectSteelSeriesRival300, STEELSERIES_VID, STEELSERIES_RIVAL_300_CSGO_STM32_PID, 0);
REGISTER_HID_DETECTOR_I("SteelSeries Rival 300 CS:GO Hyperbeast Edition", DetectSteelSeriesRival300, STEELSERIES_VID, STEELSERIES_RIVAL_300_CSGO_HYPERBEAST_PID, 0);
REGISTER_HID_DETECTOR_I("SteelSeries Rival 300 Dota 2 Edition", DetectSteelSeriesRival300, STEELSERIES_VID, STEELSERIES_RIVAL_300_DOTA_PID, 0);
REGISTER_HID_DETECTOR_I("SteelSeries Rival 300 HP Omen Edition", DetectSteelSeriesRival300, STEELSERIES_VID, STEELSERIES_RIVAL_300_HP_PID, 0);
REGISTER_HID_DETECTOR_I("SteelSeries Rival 300 Black Ops Edition", DetectSteelSeriesRival300, STEELSERIES_VID, STEELSERIES_RIVAL_300_BLACKOPS_PID, 0);
/*-----------------------------------------------------------------------------------------------------------------------------------------------------------------*\
| Headsets |
\*-----------------------------------------------------------------------------------------------------------------------------------------------------------------*/
REGISTER_HID_DETECTOR_I("SteelSeries Siberia 350", DetectSteelSeriesHeadset, STEELSERIES_VID, STEELSERIES_SIBERIA_350_PID, 3);
/*-----------------------------------------------------------------------------------------------------------------------------------------------------------------*\
| Keyboards |
\*-----------------------------------------------------------------------------------------------------------------------------------------------------------------*/
REGISTER_HID_DETECTOR_I("SteelSeries Apex 5", DetectSteelSeriesApex, STEELSERIES_VID, STEELSERIES_APEX_5_PID, 1);
REGISTER_HID_DETECTOR_I("SteelSeries Apex 7", DetectSteelSeriesApex, STEELSERIES_VID, STEELSERIES_APEX_7_PID, 1);
REGISTER_HID_DETECTOR_I("SteelSeries Apex 7 TKL", DetectSteelSeriesApexTKL, STEELSERIES_VID, STEELSERIES_APEX_7_TKL_PID, 1);
REGISTER_HID_DETECTOR_I("SteelSeries Apex Pro", DetectSteelSeriesApex, STEELSERIES_VID, STEELSERIES_APEX_PRO_PID, 1);
REGISTER_HID_DETECTOR_I("SteelSeries Apex Pro TKL", DetectSteelSeriesApexTKL, STEELSERIES_VID, STEELSERIES_APEX_PRO_TKL_PID, 1);
REGISTER_HID_DETECTOR_I("SteelSeries Apex M750", DetectSteelSeriesApexM, STEELSERIES_VID, STEELSERIES_APEX_M750_PID, 2);
REGISTER_HID_DETECTOR_I("Steelseries Apex (OG)/Apex Fnatic/Apex 350", DetectSteelSeriesApexOld, STEELSERIES_VID, STEELSERIES_APEX_OG_PID, 0);
void DetectSteelSeriesSenseiTen(hid_device_info* info, const std::string& name)
{
hid_device* dev = hid_open_path(info->path);
if(dev)
{
SteelSeriesSenseiTenController* controller = new SteelSeriesSenseiTenController(dev, SENSEI_TEN, info->path);
RGBController_SteelSeriesSenseiTen* rgb_controller = new RGBController_SteelSeriesSenseiTen(controller);
rgb_controller->name = name;
ResourceManager::get()->RegisterRGBController(rgb_controller);
}
}
/*---------------------------------------------------------------------------------------------------------------------------------------------------------------------*\
| Mice |
\*---------------------------------------------------------------------------------------------------------------------------------------------------------------------*/
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 );
REGISTER_HID_DETECTOR_I("SteelSeries Rival 110", DetectSteelSeriesRival100, STEELSERIES_VID, STEELSERIES_RIVAL_110_PID, 0 );
REGISTER_HID_DETECTOR_I("SteelSeries Rival 300", DetectSteelSeriesRival300, STEELSERIES_VID, STEELSERIES_RIVAL_300_PID, 0 );
REGISTER_HID_DETECTOR_I("Acer Predator Gaming Mouse (Rival 300)", DetectSteelSeriesRival300, STEELSERIES_VID, ACER_PREDATOR_RIVAL_300_PID, 0 );
REGISTER_HID_DETECTOR_I("SteelSeries Rival 300 CS:GO Fade Edition", DetectSteelSeriesRival300, STEELSERIES_VID, STEELSERIES_RIVAL_300_CSGO_PID, 0 );
REGISTER_HID_DETECTOR_I("SteelSeries Rival 300 CS:GO Fade Edition (stm32)", DetectSteelSeriesRival300, STEELSERIES_VID, STEELSERIES_RIVAL_300_CSGO_STM32_PID, 0 );
REGISTER_HID_DETECTOR_I("SteelSeries Rival 300 CS:GO Hyperbeast Edition", DetectSteelSeriesRival300, STEELSERIES_VID, STEELSERIES_RIVAL_300_CSGO_HYPERBEAST_PID, 0 );
REGISTER_HID_DETECTOR_I("SteelSeries Rival 300 Dota 2 Edition", DetectSteelSeriesRival300, STEELSERIES_VID, STEELSERIES_RIVAL_300_DOTA_PID, 0 );
REGISTER_HID_DETECTOR_I("SteelSeries Rival 300 HP Omen Edition", DetectSteelSeriesRival300, STEELSERIES_VID, STEELSERIES_RIVAL_300_HP_PID, 0 );
REGISTER_HID_DETECTOR_I("SteelSeries Rival 300 Black Ops Edition", DetectSteelSeriesRival300, STEELSERIES_VID, STEELSERIES_RIVAL_300_BLACKOPS_PID, 0 );
REGISTER_HID_DETECTOR_I("SteelSeries Sensei TEN", DetectSteelSeriesSenseiTen, STEELSERIES_VID, STEELSERIES_SENSEI_TEN_PID, 0 );
/*---------------------------------------------------------------------------------------------------------------------------------------------------------------------*\
| Headsets |
\*---------------------------------------------------------------------------------------------------------------------------------------------------------------------*/
REGISTER_HID_DETECTOR_I("SteelSeries Siberia 350", DetectSteelSeriesHeadset, STEELSERIES_VID, STEELSERIES_SIBERIA_350_PID, 3 );
/*---------------------------------------------------------------------------------------------------------------------------------------------------------------------*\
| Keyboards |
\*---------------------------------------------------------------------------------------------------------------------------------------------------------------------*/
REGISTER_HID_DETECTOR_I("SteelSeries Apex 5", DetectSteelSeriesApex, STEELSERIES_VID, STEELSERIES_APEX_5_PID, 1 );
REGISTER_HID_DETECTOR_I("SteelSeries Apex 7", DetectSteelSeriesApex, STEELSERIES_VID, STEELSERIES_APEX_7_PID, 1 );
REGISTER_HID_DETECTOR_I("SteelSeries Apex 7 TKL", DetectSteelSeriesApexTKL, STEELSERIES_VID, STEELSERIES_APEX_7_TKL_PID, 1 );
REGISTER_HID_DETECTOR_I("SteelSeries Apex Pro", DetectSteelSeriesApex, STEELSERIES_VID, STEELSERIES_APEX_PRO_PID, 1 );
REGISTER_HID_DETECTOR_I("SteelSeries Apex Pro TKL", DetectSteelSeriesApexTKL, STEELSERIES_VID, STEELSERIES_APEX_PRO_TKL_PID, 1 );
REGISTER_HID_DETECTOR_I("SteelSeries Apex M750", DetectSteelSeriesApexM, STEELSERIES_VID, STEELSERIES_APEX_M750_PID, 2 );
REGISTER_HID_DETECTOR_I("Steelseries Apex (OG)/Apex Fnatic/Apex 350", DetectSteelSeriesApexOld, STEELSERIES_VID, STEELSERIES_APEX_OG_PID, 0 );

1
Controllers/SteelSeriesController/SteelSeriesGeneric.h
View File

@@ -24,5 +24,6 @@ typedef enum
APEX_TKL = 0x05,
APEX_M = 0x06,
APEX_OLD = 0x07,
SENSEI_TEN = 0x08,
} steelseries_type;

297
Controllers/SteelSeriesController/SteelSeriesSenseiTenController.cpp Normal file
View File

@@ -0,0 +1,297 @@
/*-----------------------------------------*\
| SteelSeriesSenseiTenController.h |
| |
| Definitions and types for SteelSeries |
| Sensei TEN lighting controller |
| Based on Rival controller by |
| B Horn (bahorn) 13/5/2020 |
\*-----------------------------------------*/
#include "SteelSeriesSenseiTenController.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;
}
SteelSeriesSenseiTenController::SteelSeriesSenseiTenController
(
hid_device* dev_handle,
steelseries_type proto_type,
const char* path
)
{
dev = dev_handle;
location = path;
proto = proto_type;
}
SteelSeriesSenseiTenController::~SteelSeriesSenseiTenController()
{
hid_close(dev);
}
std::string SteelSeriesSenseiTenController::GetDeviceLocation()
{
return("HID: " + location);
}
char* SteelSeriesSenseiTenController::GetDeviceName()
{
return device_name;
}
std::string SteelSeriesSenseiTenController::GetSerialString()
{
wchar_t serial_string[128];
hid_get_serial_number_string(dev, serial_string, 128);
std::wstring return_wstring = serial_string;
std::string return_string(return_wstring.begin(), return_wstring.end());
return(return_string);
}
steelseries_type SteelSeriesSenseiTenController::GetMouseType()
{
return proto;
}
void SteelSeriesSenseiTenController::Save()
{
/*-----------------------------------------------------*\
| Saves to the internal configuration |
\*-----------------------------------------------------*/
char usb_buf[9];
/*-----------------------------------------------------*\
| Zero out buffer |
\*-----------------------------------------------------*/
memset(usb_buf, 0x00, sizeof(usb_buf));
/*-----------------------------------------------------*\
| Set up Save packet |
\*-----------------------------------------------------*/
usb_buf[0x00] = 0x09;
/*-----------------------------------------------------*\
| Send packet |
\*-----------------------------------------------------*/
send_usb_msg(dev, usb_buf, 9);
}
void SteelSeriesSenseiTenController::SetLightEffect
(
unsigned char zone_id,
unsigned char effect,
unsigned char speed,
unsigned char red,
unsigned char green,
unsigned char blue
)
{
char usb_buf[65];
/*-----------------------------------------------------*\
| Zero out buffer |
\*-----------------------------------------------------*/
memset(usb_buf, 0x00, sizeof(usb_buf));
/*-----------------------------------------------------*\
| Set up Light Effect packet |
\*-----------------------------------------------------*/
char dur1;
char dur2;
switch(effect)
{
case STEELSERIES_SENSEI_MODE_BREATHING:
switch(speed)
{
case STEELSERIES_SENSEI_EFFECT_BREATHING_MIN:
dur1 = 0x27;
dur2 = 0x10; //10 sec cycle
break;
case STEELSERIES_SENSEI_EFFECT_BREATHING_MID:
dur1 = 0x13;
dur2 = 0x88; //5 sec cycle
break;
case STEELSERIES_SENSEI_EFFECT_BREATHING_MAX:
dur1 = 0x09;
dur2 = 0xc4; //2.5 sec cycle
break;
}
usb_buf[0x00] = 0x5B; //command byte
usb_buf[0x02] = zone_id;
usb_buf[0x04] = dur1; //duration in ms 1st byte
usb_buf[0x03] = dur2; //duration in ms 2nd byte
usb_buf[0x1B] = 0x03; //Number of colors
/*---------------------------------------------*\
| Original software duplicates these RGB bytes, |
| but seems unnecessary |
\*---------------------------------------------*/
usb_buf[0x1C] = red;
usb_buf[0x1D] = green;
usb_buf[0x1E] = blue;
usb_buf[0x1F] = red;
usb_buf[0x20] = green;
usb_buf[0x21] = blue;
usb_buf[0x26] = 0x7F; //percent of duration out of 0xFF
usb_buf[0x27] = red;
usb_buf[0x28] = green;
usb_buf[0x29] = blue;
usb_buf[0x2A] = 0x7F; //percent of duration out of 0xFF
break;
case STEELSERIES_SENSEI_MODE_RAINBOW:
switch(speed)
{
case STEELSERIES_SENSEI_EFFECT_RAINBOW_MIN:
dur1 = 0x4E;
dur2 = 0x20; //20 sec cycle
break;
case STEELSERIES_SENSEI_EFFECT_RAINBOW_MID:
dur1 = 0x27;
dur2 = 0x10; //10 sec cycle
break;
case STEELSERIES_SENSEI_EFFECT_RAINBOW_MAX:
dur1 = 0x13;
dur2 = 0x88; //5 sec cycle
break;
}
usb_buf[0x00] = 0x5B; //command byte
usb_buf[0x02] = zone_id;
usb_buf[0x04] = dur1; //duration in ms 1st byte
usb_buf[0x03] = dur2; //duration in ms 2nd byte
usb_buf[0x1B] = 0x07; //Number of colors
/*---------------------------------------------*\
| Original software duplicates these RGB bytes, |
| but seems unnecessary |
\*---------------------------------------------*/
usb_buf[0x1C] = red;
usb_buf[0x1D] = green;
usb_buf[0x1E] = blue;
usb_buf[0x1C] = 0xFF;
usb_buf[0x1F] = 0xFF;
usb_buf[0x22] = 0x14;
usb_buf[0x23] = 0xFF;
usb_buf[0x24] = 0xFF;
usb_buf[0x26] = 0x2B; //percent of duration out of 0xFF
usb_buf[0x28] = 0xFF;
usb_buf[0x2A] = 0x2B;
usb_buf[0x2C] = 0xFF;
usb_buf[0x2D] = 0xFF; //percent of duration out of 0xFF
usb_buf[0x2E] = 0x28;
usb_buf[0x31] = 0xFF;
usb_buf[0x32] = 0x2B;
usb_buf[0x33] = 0xFF;
usb_buf[0x35] = 0xFF;
usb_buf[0x36] = 0x2B;
usb_buf[0x37] = 0xFF;
usb_buf[0x3A] = 0x14;
break;
}
/*-----------------------------------------------------*\
| Send packet |
\*-----------------------------------------------------*/
send_usb_msg(dev, usb_buf, sizeof(usb_buf));
}
void SteelSeriesSenseiTenController::SetLightEffectAll
(
unsigned char effect,
unsigned char speed,
unsigned char red,
unsigned char green,
unsigned char blue
)
{
SetLightEffect(0, effect, speed, red, green, blue);
SetLightEffect(1, effect, speed, red, green, blue);
}
void SteelSeriesSenseiTenController::SetColor
(
unsigned char zone_id,
unsigned char red,
unsigned char green,
unsigned char blue
)
{
char usb_buf[65];
/*-----------------------------------------------------*\
| Zero out buffer |
\*-----------------------------------------------------*/
memset(usb_buf, 0x00, sizeof(usb_buf));
/*-----------------------------------------------------*\
| Set up Set Color packet |
\*-----------------------------------------------------*/
usb_buf[0x00] = 0x5B; //command byte
usb_buf[0x02] = zone_id;
/*-----------------------------------------------------*\
| Original software duplicates these RGB bytes, |
| but seems unnecessary |
\*-----------------------------------------------------*/
usb_buf[0x1C] = red;
usb_buf[0x1D] = green;
usb_buf[0x1E] = blue;
usb_buf[0x1F] = red;
usb_buf[0x20] = green;
usb_buf[0x21] = blue;
usb_buf[0x13] = 0x01; //Static color flag
usb_buf[0x1B] = 0x01; //Number of colors
/*-----------------------------------------------------*\
| Send packet |
\*-----------------------------------------------------*/
send_usb_msg(dev, usb_buf, sizeof(usb_buf));
}
void SteelSeriesSenseiTenController::SetColorAll
(
unsigned char red,
unsigned char green,
unsigned char blue
)
{
switch(proto)
{
case SENSEI_TEN:
SetColor(0, red, green, blue);
SetColor(1, red, green, blue);
break;
default:
break;
}
}

99
Controllers/SteelSeriesController/SteelSeriesSenseiTenController.h Normal file
View File

@@ -0,0 +1,99 @@
/*-----------------------------------------*\
| SteelSeriesSenseiTenController.h |
| |
| Definitions and types for SteelSeries |
| Sensei Ten lighting controller |
| Based on Rival controller by |
| B Horn (bahorn) 13/5/2020 |
\*-----------------------------------------*/
#include <string>
#include <hidapi/hidapi.h>
#include "SteelSeriesGeneric.h"
#pragma once
/*-------------------------------------------------------------*\
| Mode, we then use these to set actual effect based on speed. |
\*-------------------------------------------------------------*/
enum
{
STEELSERIES_SENSEI_MODE_DIRECT = 0x00,
STEELSERIES_SENSEI_MODE_BREATHING = 0x01,
STEELSERIES_SENSEI_MODE_RAINBOW = 0x02
};
/*-------------------------------------------------------------*\
| Effects |
\*-------------------------------------------------------------*/
enum
{
STEELSERIES_SENSEI_EFFECT_DIRECT = 0x01,
STEELSERIES_SENSEI_EFFECT_BREATHING_MIN = 0x02,
STEELSERIES_SENSEI_EFFECT_BREATHING_MID = 0x03,
STEELSERIES_SENSEI_EFFECT_BREATHING_MAX = 0x04,
STEELSERIES_SENSEI_EFFECT_RAINBOW_MIN = 0x05,
STEELSERIES_SENSEI_EFFECT_RAINBOW_MID = 0x06,
STEELSERIES_SENSEI_EFFECT_RAINBOW_MAX = 0x07
};
class SteelSeriesSenseiTenController
{
public:
SteelSeriesSenseiTenController
(
hid_device* dev_handle,
steelseries_type proto_type,
const char* path
);
~SteelSeriesSenseiTenController();
std::string GetDeviceLocation();
char* GetDeviceName();
std::string GetSerialString();
steelseries_type GetMouseType();
void Save();
void SetLightEffect
(
unsigned char zone_id,
unsigned char effect,
unsigned char speed,
unsigned char red,
unsigned char green,
unsigned char blue
);
void SetLightEffectAll
(
unsigned char effect,
unsigned char speed,
unsigned char red,
unsigned char green,
unsigned char blue
);
void SetColor
(
unsigned char zone_id,
unsigned char red,
unsigned char green,
unsigned char blue
);
void SetColorAll
(
unsigned char red,
unsigned char green,
unsigned char blue
);
private:
char device_name[32];
hid_device* dev;
std::string location;
steelseries_type proto;
};

4
OpenRGB.pro
View File

@@ -321,10 +321,12 @@ HEADERS +=
Controllers/SteelSeriesController/SteelSeriesGeneric.h \
Controllers/SteelSeriesController/SteelSeriesOldApexController.h \
Controllers/SteelSeriesController/SteelSeriesRivalController.h \
Controllers/SteelSeriesController/SteelSeriesSenseiTenController.h \
Controllers/SteelSeriesController/SteelSeriesSiberiaController.h \
Controllers/SteelSeriesController/RGBController_SteelSeriesApex.h \
Controllers/SteelSeriesController/RGBController_SteelSeriesOldApex.h \
Controllers/SteelSeriesController/RGBController_SteelSeriesRival.h \
Controllers/SteelSeriesController/RGBController_SteelSeriesSenseiTen.h \
Controllers/SteelSeriesController/RGBController_SteelSeriesSiberia.h \
Controllers/TecknetController/TecknetController.h \
Controllers/TecknetController/RGBController_Tecknet.h \
@@ -593,11 +595,13 @@ SOURCES +=
Controllers/SteelSeriesController/SteelSeriesApexMController.cpp \
Controllers/SteelSeriesController/SteelSeriesOldApexController.cpp \
Controllers/SteelSeriesController/SteelSeriesRivalController.cpp \
Controllers/SteelSeriesController/SteelSeriesSenseiTenController.cpp \
Controllers/SteelSeriesController/SteelSeriesSiberiaController.cpp \
Controllers/SteelSeriesController/SteelSeriesControllerDetect.cpp \
Controllers/SteelSeriesController/RGBController_SteelSeriesApex.cpp \
Controllers/SteelSeriesController/RGBController_SteelSeriesOldApex.cpp \
Controllers/SteelSeriesController/RGBController_SteelSeriesRival.cpp \
Controllers/SteelSeriesController/RGBController_SteelSeriesSenseiTen.cpp \
Controllers/SteelSeriesController/RGBController_SteelSeriesSiberia.cpp \
Controllers/TecknetController/TecknetController.cpp \
Controllers/TecknetController/TecknetControllerDetect.cpp \