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

Add support for HyperX Pulsefire Raid mouse. Closes #1745

Browse source
This commit is contained in:
morg 2022-06-02 18:03:43 +00:00 • committed by Adam Honse
parent 7495fe998e
commit e8e24ac243
6 changed files with 331 additions and 1 deletions
Download patch file Download diff file Expand all files Collapse all files

21
Controllers/HyperXMouseController/HyperXMouseControllerDetect.cpp
View file

@ -2,11 +2,13 @@
#include "HyperXPulsefireFPSProController.h"
#include "HyperXPulsefireSurgeController.h"
#include "HyperXPulsefireDartController.h"
#include "HyperXPulsefireRaidController.h"
#include "RGBController.h"
#include "RGBController_HyperXPulsefireFPSPro.h"
#include "RGBController_HyperXPulsefireHaste.h"
#include "RGBController_HyperXPulsefireSurge.h"
#include "RGBController_HyperXPulsefireDart.h"
#include "RGBController_HyperXPulsefireRaid.h"
#include <hidapi/hidapi.h>
/*-----------------------------------------------------*\
@ -18,6 +20,7 @@
#define HYPERX_PULSEFIRE_CORE_PID 0x16DE
#define HYPERX_PULSEFIRE_DART_WIRELESS_PID 0x16E1
#define HYPERX_PULSEFIRE_DART_WIRED_PID 0x16E2
#define HYPERX_PULSEFIRE_RAID_PID 0x16E4
#define HYPERX_PULSEFIRE_HASTE_PID 0x1727
void DetectHyperXPulsefireSurgeControllers(hid_device_info* info, const std::string& name)
@ -76,14 +79,30 @@ void DetectHyperXPulsefireDartControllers(hid_device_info* info, const std::stri
}
} /* DetectHyperXPulsefireDartControllers() */
void DetectHyperXPulsefireRaidControllers(hid_device_info* info, const std::string& name)
{
hid_device* dev = hid_open_path(info->path);
if(dev)
{
HyperXPulsefireRaidController* controller = new HyperXPulsefireRaidController(dev, *info);
RGBController_HyperXPulsefireRaid* rgb_controller = new RGBController_HyperXPulsefireRaid(controller);
rgb_controller->name = name;
ResourceManager::get()->RegisterRGBController(rgb_controller);
}
} /* DetectHyperXPulsefireRaidControllers() */
REGISTER_HID_DETECTOR_IP("HyperX Pulsefire Surge", DetectHyperXPulsefireSurgeControllers, HYPERX_VID, HYPERX_PULSEFIRE_SURGE_PID, 1, 0xFF01);
REGISTER_HID_DETECTOR_IP("HyperX Pulsefire FPS Pro", DetectHyperXPulsefireFPSProControllers, HYPERX_VID, HYPERX_PULSEFIRE_FPS_PRO_PID, 1, 0xFF01);
REGISTER_HID_DETECTOR_IP("HyperX Pulsefire Core", DetectHyperXPulsefireFPSProControllers, HYPERX_VID, HYPERX_PULSEFIRE_CORE_PID, 1, 0xFF01);
REGISTER_HID_DETECTOR_IP("HyperX Pulsefire Dart (Wireless)", DetectHyperXPulsefireDartControllers, HYPERX_VID, HYPERX_PULSEFIRE_DART_WIRELESS_PID, 2, 0xFF00);
REGISTER_HID_DETECTOR_IP("HyperX Pulsefire Dart (Wired)", DetectHyperXPulsefireDartControllers, HYPERX_VID, HYPERX_PULSEFIRE_DART_WIRED_PID, 1, 0xFF13);
REGISTER_HID_DETECTOR_IPU("HyperX Pulsefire Raid", DetectHyperXPulsefireRaidControllers, HYPERX_VID, HYPERX_PULSEFIRE_RAID_PID, 1, 0xFF01, 0x01);
#ifdef _WIN32
REGISTER_HID_DETECTOR_IP("HyperX Pulsefire Haste", DetectHyperXPulsefireHasteControllers, HYPERX_VID, HYPERX_PULSEFIRE_HASTE_PID, 3, 0xFF90);
#else
REGISTER_HID_DETECTOR_PU("HyperX Pulsefire Haste", DetectHyperXPulsefireHasteControllers, HYPERX_VID, HYPERX_PULSEFIRE_HASTE_PID, 1, 2);
#endif
#endif

81
Controllers/HyperXMouseController/HyperXPulsefireRaidController.cpp Normal file
View file

@ -0,0 +1,81 @@
/*-------------------------------------------*\
| HyperXPulsefireRaidController.cpp |
| |
| Driver for HyperX Pulsefire Raid |
| lighting controller |
| |
| Morgan Guimard (morg) 04/06/2022 |
\*-------------------------------------------*/
#include "HyperXPulsefireRaidController.h"
#include <cstring>
using namespace std::chrono_literals;
HyperXPulsefireRaidController::HyperXPulsefireRaidController(hid_device* dev_handle, const hid_device_info& info)
{
dev = dev_handle;
location = info.path;
version = "";
wchar_t serial_string[128];
int ret = hid_get_serial_number_string(dev, serial_string, 128);
if(ret != 0)
{
serial_number = "";
}
else
{
std::wstring return_wstring = serial_string;
serial_number = std::string(return_wstring.begin(), return_wstring.end());
}
}
HyperXPulsefireRaidController::~HyperXPulsefireRaidController()
{
hid_close(dev);
}
std::string HyperXPulsefireRaidController::GetDeviceLocation()
{
return("HID: " + location);
}
std::string HyperXPulsefireRaidController::GetSerialString()
{
return(serial_number);
}
std::string HyperXPulsefireRaidController::GetFirmwareVersion()
{
return(version);
}
void HyperXPulsefireRaidController::SendColors(std::vector<RGBColor> colors)
{
unsigned char usb_buf[HYPERX_PULSFIRE_RAID_PACKET_DATA_LENGTH];
memset(usb_buf, 0x00, HYPERX_PULSFIRE_RAID_PACKET_DATA_LENGTH);
usb_buf[0] = HYPERX_PULSFIRE_RAID_REPORT_ID;
usb_buf[1] = HYPERX_PULSFIRE_RAID_DIRECT_MODE_START_PACKET;
for(unsigned int i = 0; i < 2; i++)
{
usb_buf[3 * i + 2] = RGBGetRValue(colors[i]);
usb_buf[3 * i + 3] = RGBGetGValue(colors[i]);
usb_buf[3 * i + 4] = RGBGetBValue(colors[i]);
}
usb_buf[8] = HYPERX_PULSFIRE_RAID_DIRECT_MODE_END_PACKET;
Send(usb_buf);
}
void HyperXPulsefireRaidController::Send(unsigned char* packet)
{
hid_send_feature_report(dev, packet, HYPERX_PULSFIRE_RAID_PACKET_DATA_LENGTH);
std::this_thread::sleep_for(10ms);
}

50
Controllers/HyperXMouseController/HyperXPulsefireRaidController.h Normal file
View file

@ -0,0 +1,50 @@
/*-------------------------------------------*\
| HyperXPulsefireRaidController.h |
| |
| Definitions and types for HyperX |
| Pulsefire Raid lighting controller |
| |
| Morgan Guimard (morg) 04/06/2022 |
\*-------------------------------------------*/
#include "RGBController.h"
#include <string>
#include <hidapi/hidapi.h>
#pragma once
#define HYPERX_PULSFIRE_RAID_PACKET_DATA_LENGTH 264
#define HYPERX_PULSFIRE_RAID_REPORT_ID 0x07
#define HYPERX_PULSFIRE_RAID_LEDS_COUNT 2
#define HYPERX_PULSFIRE_RAID_DIRECT_MODE_START_PACKET 0x0A
#define HYPERX_PULSFIRE_RAID_DIRECT_MODE_END_PACKET 0xA0
enum
{
HYPERX_PULSFIRE_RAID_BRIGHTNESS_MIN = 0x00,
HYPERX_PULSFIRE_RAID_BRIGHTNESS_MAX = 0x64
};
class HyperXPulsefireRaidController
{
public:
HyperXPulsefireRaidController(hid_device* dev_handle, const hid_device_info& info);
~HyperXPulsefireRaidController();
std::string GetSerialString();
std::string GetDeviceLocation();
std::string GetFirmwareVersion();
void SendColors(std::vector<RGBColor> colors);
void SetBrightness(unsigned char brightness);
protected:
hid_device* dev;
private:
std::string location;
std::string serial_number;
std::string version;
void Send(unsigned char* packet);
};

139
Controllers/HyperXMouseController/RGBController_HyperXPulsefireRaid.cpp Normal file
View file

@ -0,0 +1,139 @@
/*-------------------------------------------*\
| RGBController_HyperXPulsefireRaid.cpp |
| |
| Generic RGB Interface for HyperX |
| Pulsefire Raid |
| |
| Morgan Guimard (morg) 04/06/2022 |
\*-------------------------------------------*/
#include "RGBController_HyperXPulsefireRaid.h"
/**------------------------------------------------------------------*\
@name HyoerX Pulsefire Raid
@category Mouse
@type USB
@save :x:
@direct :white_check_mark:
@effects :x:
@detectors DetectHyperXPulsefireRaidControllers
@comment
\*-------------------------------------------------------------------*/
using namespace std::chrono_literals;
RGBController_HyperXPulsefireRaid::RGBController_HyperXPulsefireRaid(HyperXPulsefireRaidController* controller_ptr)
{
controller = controller_ptr;
name = "HyperX Pulsefire Raid Device";
vendor = "HyperX";
type = DEVICE_TYPE_MOUSE;
description = "HyperX Pulsefire Raid Device";
location = controller->GetDeviceLocation();
serial = controller->GetSerialString();
version = controller->GetFirmwareVersion();
mode Direct;
Direct.name = "Direct";
Direct.value = 0x00;
Direct.flags = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
Direct.color_mode = MODE_COLORS_PER_LED;
Direct.brightness = HYPERX_PULSFIRE_RAID_BRIGHTNESS_MAX;
Direct.brightness_min = HYPERX_PULSFIRE_RAID_BRIGHTNESS_MIN;
Direct.brightness_max = HYPERX_PULSFIRE_RAID_BRIGHTNESS_MAX;
modes.push_back(Direct);
SetupZones();
/*-----------------------------------------------------*\
| This devices requires a keepalive thread or it will |
| reset to default (flash) |
\*-----------------------------------------------------*/
keepalive_thread_run = 1;
keepalive_thread = new std::thread(&RGBController_HyperXPulsefireRaid::KeepaliveThread, this);
}
RGBController_HyperXPulsefireRaid::~RGBController_HyperXPulsefireRaid()
{
}
void RGBController_HyperXPulsefireRaid::SetupZones()
{
std::string led_names[HYPERX_PULSFIRE_RAID_LEDS_COUNT] =
{
"Scroll Wheel", "Logo"
};
for(unsigned int i = 0; i < HYPERX_PULSFIRE_RAID_LEDS_COUNT; i++)
{
zone new_zone;
new_zone.name = led_names[i];
new_zone.type = ZONE_TYPE_SINGLE;
new_zone.leds_min = 1;
new_zone.leds_max = 1;
new_zone.leds_count = 1;
new_zone.matrix_map = NULL;
zones.push_back(new_zone);
led new_led;
new_led.name = led_names[i];
leds.push_back(new_led);
}
SetupColors();
}
void RGBController_HyperXPulsefireRaid::ResizeZone(int /*zone*/, int /*new_size*/)
{
}
void RGBController_HyperXPulsefireRaid::DeviceUpdateLEDs()
{
UpdateSingleLED(0);
}
void RGBController_HyperXPulsefireRaid::UpdateZoneLEDs(int zone)
{
UpdateSingleLED(zone);
}
void RGBController_HyperXPulsefireRaid::UpdateSingleLED(int /*led*/)
{
last_update_time = std::chrono::steady_clock::now();
controller->SendColors(colors);
}
void RGBController_HyperXPulsefireRaid::SetCustomMode()
{
active_mode = 0;
}
void RGBController_HyperXPulsefireRaid::DeviceUpdateMode()
{
}
void RGBController_HyperXPulsefireRaid::DeviceSaveMode()
{
}
void RGBController_HyperXPulsefireRaid::KeepaliveThread()
{
while(keepalive_thread_run.load())
{
if(active_mode == 0)
{
if((std::chrono::steady_clock::now() - last_update_time) > 1s)
{
UpdateLEDs();
}
}
std::this_thread::sleep_for(10ms);
}
}

37
Controllers/HyperXMouseController/RGBController_HyperXPulsefireRaid.h Normal file
View file

@ -0,0 +1,37 @@
/*-------------------------------------------*\
| RGBController_HyperXPulsefireRaid.h |
| |
| Generic RGB Interface for HyperX |
| Pulsefire Raid |
| |
| Morgan Guimard (morg) 04/06/2022 |
\*-------------------------------------------*/
#pragma once
#include <chrono>
#include "RGBController.h"
#include "HyperXPulsefireRaidController.h"
class RGBController_HyperXPulsefireRaid : public RGBController
{
public:
RGBController_HyperXPulsefireRaid(HyperXPulsefireRaidController* controller_ptr);
~RGBController_HyperXPulsefireRaid();
void SetupZones();
void ResizeZone(int zone, int new_size);
void DeviceUpdateLEDs();
void UpdateZoneLEDs(int zone);
void UpdateSingleLED(int led);
void SetCustomMode();
void DeviceUpdateMode();
void DeviceSaveMode();
private:
HyperXPulsefireRaidController* controller;
std::thread* keepalive_thread;
std::atomic<bool> keepalive_thread_run;
std::chrono::time_point<std::chrono::steady_clock> last_update_time;
void KeepaliveThread();
};

4
OpenRGB.pro
View file

@ -396,10 +396,12 @@ HEADERS +=
Controllers/HyperXMouseController/HyperXPulsefireHasteController.h \
Controllers/HyperXMouseController/HyperXPulsefireSurgeController.h \
Controllers/HyperXMouseController/HyperXPulsefireDartController.h \
Controllers/HyperXMouseController/HyperXPulsefireRaidController.h \
Controllers/HyperXMouseController/RGBController_HyperXPulsefireFPSPro.h \
Controllers/HyperXMouseController/RGBController_HyperXPulsefireHaste.h \
Controllers/HyperXMouseController/RGBController_HyperXPulsefireSurge.h \
Controllers/HyperXMouseController/RGBController_HyperXPulsefireDart.h \
Controllers/HyperXMouseController/RGBController_HyperXPulsefireRaid.h \
Controllers/HyperXMousematController/HyperXMousematController.h \
Controllers/HyperXMousematController/RGBController_HyperXMousemat.h \
Controllers/KeychronKeyboardController/KeychronKeyboardController.h \
@ -880,10 +882,12 @@ SOURCES +=
Controllers/HyperXMouseController/HyperXPulsefireHasteController.cpp \
Controllers/HyperXMouseController/HyperXPulsefireSurgeController.cpp \
Controllers/HyperXMouseController/HyperXPulsefireDartController.cpp \
Controllers/HyperXMouseController/HyperXPulsefireRaidController.cpp \
Controllers/HyperXMouseController/RGBController_HyperXPulsefireFPSPro.cpp \
Controllers/HyperXMouseController/RGBController_HyperXPulsefireHaste.cpp \
Controllers/HyperXMouseController/RGBController_HyperXPulsefireSurge.cpp \
Controllers/HyperXMouseController/RGBController_HyperXPulsefireDart.cpp \
Controllers/HyperXMouseController/RGBController_HyperXPulsefireRaid.cpp \
Controllers/HyperXMousematController/HyperXMousematController.cpp \
Controllers/HyperXMousematController/HyperXMousematControllerDetect.cpp \
Controllers/HyperXMousematController/RGBController_HyperXMousemat.cpp \