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

Add Roccat Kone Pro Air

Browse source
This commit is contained in:
Plunti 2024-06-10 02:05:02 +02:00
parent a0adf9f47d
commit ea9369f799
5 changed files with 449 additions and 7 deletions
Download patch file Download diff file Expand all files Collapse all files

42
Controllers/RoccatController/RoccatControllerDetect.cpp
View file

@ -1,8 +1,18 @@
/*---------------------------------------------------------*\
| RoccatControllerDetect.cpp |
| |
| Detector for Roccat devices |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-only |
\*---------------------------------------------------------*/
#include "Detector.h"
#include "RoccatBurstController.h"
#include "RoccatBurstProAirController.h"
#include "RoccatKoneAimoController.h"
#include "RoccatKoneProController.h"
#include "RoccatKoneProAirController.h"
#include "RoccatSenseAimoController.h"
#include "RoccatVulcanKeyboardController.h"
#include "RoccatKovaController.h"
@ -13,6 +23,7 @@
#include "RGBController_RoccatHordeAimo.h"
#include "RGBController_RoccatKoneAimo.h"
#include "RGBController_RoccatKonePro.h"
#include "RGBController_RoccatKoneProAir.h"
#include "RGBController_RoccatSenseAimo.h"
#include "RGBController_RoccatVulcanKeyboard.h"
#include "RGBController_RoccatKova.h"
@ -31,13 +42,15 @@
/*-----------------------------------------------------------------*\
| MICE |
\*-----------------------------------------------------------------*/
#define ROCCAT_BURST_CORE_PID 0x2DE6
#define ROCCAT_BURST_PRO_PID 0x2DE1
#define ROCCAT_BURST_PRO_AIR_PID 0x2CA6
#define ROCCAT_KONE_AIMO_PID 0x2E27
#define ROCCAT_KONE_AIMO_16K_PID 0x2E2C
#define ROCCAT_KONE_PRO_PID 0x2C88
#define ROCCAT_KOVA_PID 0x2CEE
#define ROCCAT_BURST_CORE_PID 0x2DE6
#define ROCCAT_BURST_PRO_PID 0x2DE1
#define ROCCAT_BURST_PRO_AIR_PID 0x2CA6
#define ROCCAT_KONE_AIMO_PID 0x2E27
#define ROCCAT_KONE_AIMO_16K_PID 0x2E2C
#define ROCCAT_KONE_PRO_PID 0x2C88
#define ROCCAT_KONE_PRO_AIR_PID 0x2C8E
#define ROCCAT_KONE_PRO_AIR_WIRED_PID 0x2C92
#define ROCCAT_KOVA_PID 0x2CEE
/*-----------------------------------------------------------------*\
| MOUSEMATS |
@ -224,6 +237,19 @@ void DetectRoccatKoneProControllers(hid_device_info* info, const std::string& na
}
}
void DetectRoccatKoneProAirControllers(hid_device_info* info, const std::string& name)
{
hid_device* dev = hid_open_path(info->path);
if(dev)
{
RoccatKoneProAirController * controller = new RoccatKoneProAirController(dev, *info);
RGBController_RoccatKoneProAir * rgb_controller = new RGBController_RoccatKoneProAir(controller);
rgb_controller->name = name;
ResourceManager::get()->RegisterRGBController(rgb_controller);
}
}
void DetectRoccatKovaControllers(hid_device_info* info, const std::string& name)
{
hid_device* dev = hid_open_path(info->path);
@ -289,6 +315,8 @@ REGISTER_HID_DETECTOR_IPU("Roccat Kone Aimo", DetectRoccatMouseCon
REGISTER_HID_DETECTOR_IPU("Roccat Kone Aimo 16K", DetectRoccatMouseControllers, ROCCAT_VID, ROCCAT_KONE_AIMO_16K_PID, 0, 0x0B, 0 );
REGISTER_HID_DETECTOR_IPU("Roccat Kone Pro", DetectRoccatKoneProControllers, ROCCAT_VID, ROCCAT_KONE_PRO_PID, 3, 0xFF01, 1 );
REGISTER_HID_DETECTOR_IPU("Roccat Kone Pro Air", DetectRoccatKoneProAirControllers, ROCCAT_VID, ROCCAT_KONE_PRO_AIR_PID, 2, 0xFF00, 1 );
REGISTER_HID_DETECTOR_IPU("Roccat Kone Pro Air (Wired)", DetectRoccatKoneProAirControllers, ROCCAT_VID, ROCCAT_KONE_PRO_AIR_WIRED_PID, 1, 0xFF13, 1 );
REGISTER_HID_DETECTOR_IPU("Roccat Kova", DetectRoccatKovaControllers, ROCCAT_VID, ROCCAT_KOVA_PID, 0, 0x0B, 0 );

194
Controllers/RoccatController/RoccatKoneProAirController/RGBController_RoccatKoneProAir.cpp Normal file
View file

@ -0,0 +1,194 @@
/*---------------------------------------------------------*\
| RGBController_RoccatKoneProAir.cpp |
| |
| RGBController for Roccat Kone Pro Air |
| |
| Plunti 10 Jun 2024 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-only |
\*---------------------------------------------------------*/
#include "RGBController_RoccatKoneProAir.h"
/**------------------------------------------------------------------*\
@name Roccat Kone Pro Air Mouse
@category Mouse
@type USB
@save :robot:
@direct :white_check_mark:
@effects :white_check_mark:
@detectors DetectRoccatKoneProAirControllers
@comment
\*-------------------------------------------------------------------*/
RGBController_RoccatKoneProAir::RGBController_RoccatKoneProAir(RoccatKoneProAirController* controller_ptr)
{
controller = controller_ptr;
name = "Roccat Kone Pro Air";
vendor = "Roccat";
type = DEVICE_TYPE_MOUSE;
description = "Roccat Kone Pro Air Mouse";
serial = controller->GetSerialString();
location = controller->GetDeviceLocation();
version = controller->GetFirmwareVersion();
mode Direct;
Direct.name = "Direct";
Direct.value = ROCCAT_KONE_PRO_AIR_DIRECT_MODE_VALUE;
Direct.flags = MODE_FLAG_HAS_PER_LED_COLOR;
Direct.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Direct);
mode Off;
Off.name = "Off";
Off.value = ROCCAT_KONE_PRO_AIR_OFF_MODE_VALUE;
Off.flags = MODE_FLAG_AUTOMATIC_SAVE;
Off.color_mode = MODE_COLORS_NONE;
modes.push_back(Off);
mode Static;
Static.name = "Static";
Static.value = ROCCAT_KONE_PRO_AIR_STATIC_MODE_VALUE;
Static.flags = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_BRIGHTNESS;
Static.color_mode = MODE_COLORS_PER_LED;
Static.brightness = ROCCAT_KONE_PRO_AIR_BRIGHTNESS_MAX;
Static.brightness_min = ROCCAT_KONE_PRO_AIR_BRIGHTNESS_MIN;
Static.brightness_max = ROCCAT_KONE_PRO_AIR_BRIGHTNESS_MAX;
modes.push_back(Static);
mode RainbowWave;
RainbowWave.name = "Rainbow Wave";
RainbowWave.value = ROCCAT_KONE_PRO_AIR_RAINBOW_WAVE_MODE_VALUE;
RainbowWave.flags = MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
RainbowWave.color_mode = MODE_COLORS_NONE;
RainbowWave.brightness = ROCCAT_KONE_PRO_AIR_BRIGHTNESS_MAX;
RainbowWave.brightness_min = ROCCAT_KONE_PRO_AIR_BRIGHTNESS_MIN;
RainbowWave.brightness_max = ROCCAT_KONE_PRO_AIR_BRIGHTNESS_MAX;
RainbowWave.speed = ROCCAT_KONE_PRO_AIR_SPEED_MID;
RainbowWave.speed_min = ROCCAT_KONE_PRO_AIR_SPEED_MIN;
RainbowWave.speed_max = ROCCAT_KONE_PRO_AIR_SPEED_MAX;
modes.push_back(RainbowWave);
mode Heartbeat;
Heartbeat.name = "Heartbeat";
Heartbeat.value = ROCCAT_KONE_PRO_AIR_HEARTBEAT_MODE_VALUE;
Heartbeat.flags = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
Heartbeat.color_mode = MODE_COLORS_PER_LED;
Heartbeat.brightness = ROCCAT_KONE_PRO_AIR_BRIGHTNESS_MAX;
Heartbeat.brightness_min = ROCCAT_KONE_PRO_AIR_BRIGHTNESS_MIN;
Heartbeat.brightness_max = ROCCAT_KONE_PRO_AIR_BRIGHTNESS_MAX;
Heartbeat.speed = ROCCAT_KONE_PRO_AIR_SPEED_MID;
Heartbeat.speed_min = ROCCAT_KONE_PRO_AIR_SPEED_MIN;
Heartbeat.speed_max = ROCCAT_KONE_PRO_AIR_SPEED_MAX;
modes.push_back(Heartbeat);
mode Breathing;
Breathing.name = "Breathing";
Breathing.value = ROCCAT_KONE_PRO_AIR_BREATHING_MODE_VALUE;
Breathing.flags = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
Breathing.color_mode = MODE_COLORS_PER_LED;
Breathing.brightness = ROCCAT_KONE_PRO_AIR_BRIGHTNESS_MAX;
Breathing.brightness_min = ROCCAT_KONE_PRO_AIR_BRIGHTNESS_MIN;
Breathing.brightness_max = ROCCAT_KONE_PRO_AIR_BRIGHTNESS_MAX;
Breathing.speed = ROCCAT_KONE_PRO_AIR_SPEED_MID;
Breathing.speed_min = ROCCAT_KONE_PRO_AIR_SPEED_MIN;
Breathing.speed_max = ROCCAT_KONE_PRO_AIR_SPEED_MAX;
modes.push_back(Breathing);
mode Flashing;
Flashing.name = "Flashing";
Flashing.value = ROCCAT_KONE_PRO_AIR_FLASHING_MODE_VALUE;
Flashing.flags = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_AUTOMATIC_SAVE | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
Flashing.color_mode = MODE_COLORS_PER_LED;
Flashing.brightness = ROCCAT_KONE_PRO_AIR_BRIGHTNESS_MAX;
Flashing.brightness_min = ROCCAT_KONE_PRO_AIR_BRIGHTNESS_MIN;
Flashing.brightness_max = ROCCAT_KONE_PRO_AIR_BRIGHTNESS_MAX;
Flashing.speed = ROCCAT_KONE_PRO_AIR_SPEED_MID;
Flashing.speed_min = ROCCAT_KONE_PRO_AIR_SPEED_MIN;
Flashing.speed_max = ROCCAT_KONE_PRO_AIR_SPEED_MAX;
modes.push_back(Flashing);
mode Battery;
Battery.name = "Battery";
Battery.value = ROCCAT_KONE_PRO_AIR_BATTERY_MODE_VALUE;
Battery.flags = MODE_FLAG_AUTOMATIC_SAVE;
Battery.color_mode = MODE_COLORS_NONE;
modes.push_back(Battery);
SetupZones();
}
RGBController_RoccatKoneProAir::~RGBController_RoccatKoneProAir()
{
delete controller;
}
void RGBController_RoccatKoneProAir::SetupZones()
{
zone new_zone;
new_zone.name = "Mouse";
new_zone.type = ZONE_TYPE_LINEAR;
new_zone.leds_min = ROCCAT_KONE_PRO_AIR_LED_COUNT;
new_zone.leds_max = ROCCAT_KONE_PRO_AIR_LED_COUNT;
new_zone.leds_count = ROCCAT_KONE_PRO_AIR_LED_COUNT;
new_zone.matrix_map = NULL;
zones.push_back(new_zone);
std::string led_names[2] =
{
"Left Button",
"Right Button"
};
for(unsigned int i = 0; i < ROCCAT_KONE_PRO_AIR_LED_COUNT; i++)
{
led new_led;
new_led.name = led_names[i];
leds.push_back(new_led);
}
SetupColors();
}
void RGBController_RoccatKoneProAir::ResizeZone(int /*zone*/, int /*new_size*/)
{
/*---------------------------------------------------------*\
| This device does not support resizing zones |
\*---------------------------------------------------------*/
}
void RGBController_RoccatKoneProAir::DeviceUpdateLEDs()
{
const mode& active = modes[active_mode];
if(active.value == ROCCAT_KONE_PRO_AIR_DIRECT_MODE_VALUE)
{
controller->SendDirect(colors);
}
else
{
controller->SetMode(colors, active.value, active.speed, active.brightness, active.flags);
}
}
void RGBController_RoccatKoneProAir::UpdateZoneLEDs(int /*zone_idx*/)
{
DeviceUpdateLEDs();
}
void RGBController_RoccatKoneProAir::UpdateSingleLED(int /*led_idx*/)
{
DeviceUpdateLEDs();
}
void RGBController_RoccatKoneProAir::DeviceUpdateMode()
{
const mode& active = modes[active_mode];
if(!(active.flags & MODE_FLAG_HAS_PER_LED_COLOR))
{
DeviceUpdateLEDs();
}
}

34
Controllers/RoccatController/RoccatKoneProAirController/RGBController_RoccatKoneProAir.h Normal file
View file

@ -0,0 +1,34 @@
/*---------------------------------------------------------*\
| RGBController_RoccatKoneProAir.h |
| |
| RGBController for Roccat Kone Pro Air |
| |
| Plunti 10 Jun 2024 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-only |
\*---------------------------------------------------------*/
#pragma once
#include "RGBController.h"
#include "RoccatKoneProAirController.h"
class RGBController_RoccatKoneProAir : public RGBController
{
public:
RGBController_RoccatKoneProAir(RoccatKoneProAirController* controller_ptr);
~RGBController_RoccatKoneProAir();
void SetupZones();
void ResizeZone(int zone, int new_size);
void DeviceUpdateLEDs();
void UpdateZoneLEDs(int zone);
void UpdateSingleLED(int led);
void DeviceUpdateMode();
private:
RoccatKoneProAirController* controller;
};

123
Controllers/RoccatController/RoccatKoneProAirController/RoccatKoneProAirController.cpp Normal file
View file

@ -0,0 +1,123 @@
/*---------------------------------------------------------*\
| RoccatKoneProAirController.cpp |
| |
| Driver for Roccat Kone Pro Air |
| |
| Plunti 10 Jun 2024 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-only |
\*---------------------------------------------------------*/
#include <cstring>
#include "RoccatKoneProAirController.h"
RoccatKoneProAirController::RoccatKoneProAirController(hid_device* dev_handle, const hid_device_info& info)
{
dev = dev_handle;
version = "";
location = info.path;
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());
}
}
RoccatKoneProAirController::~RoccatKoneProAirController()
{
hid_close(dev);
}
std::string RoccatKoneProAirController::GetFirmwareVersion()
{
return version;
}
std::string RoccatKoneProAirController::GetSerialString()
{
return serial_number;
}
std::string RoccatKoneProAirController::GetDeviceLocation()
{
return("HID: " + location);
}
void RoccatKoneProAirController::SendDirect(std::vector<RGBColor> colors)
{
SendRGB(true, colors, ROCCAT_KONE_PRO_AIR_DIRECT_MODE_VALUE, ROCCAT_KONE_PRO_AIR_SPEED_MAX, ROCCAT_KONE_PRO_AIR_BRIGHTNESS_MAX);
}
void RoccatKoneProAirController::SetMode(std::vector<RGBColor> colors, unsigned char mode_value, unsigned char speed, unsigned char brightness, unsigned int mode_flags)
{
/*---------------------------------------------------------*\
| 1. Read settings |
\*---------------------------------------------------------*/
unsigned char active_settings[ROCCAT_KONE_PRO_AIR_SETTINGS_READ_PACKET_LENGTH];
unsigned char settings_request[] = {0x00, 0x90, 0x00, 0x04, 0x00, 0x18, 0x25, 0x51, 0x32};
hid_write(dev, settings_request, sizeof(settings_request));
do
{
hid_read(dev, active_settings, ROCCAT_KONE_PRO_AIR_SETTINGS_READ_PACKET_LENGTH);
} while( (active_settings[0] != 0x90) || (active_settings[2] != 0x26) );
/*---------------------------------------------------------*\
| 2. Send settings and select profile |
\*---------------------------------------------------------*/
unsigned char usb_buf[ROCCAT_KONE_PRO_AIR_SETTINGS_WRITE_PACKET_LENGTH];
memset(usb_buf, 0x00, ROCCAT_KONE_PRO_AIR_SETTINGS_WRITE_PACKET_LENGTH);
usb_buf[1] = 0x10;
usb_buf[2] = 0x50;
usb_buf[3] = 0x14;
memcpy(usb_buf + 5, active_settings + 10, 19);
usb_buf[24] = active_settings[41];
hid_write(dev, usb_buf, ROCCAT_KONE_PRO_AIR_SETTINGS_WRITE_PACKET_LENGTH);
/*---------------------------------------------------------*\
| 3. Send RGB |
\*---------------------------------------------------------*/
SendRGB(false,
colors,
mode_value,
mode_flags & MODE_FLAG_HAS_SPEED ? speed : ROCCAT_KONE_PRO_AIR_SPEED_MAX,
mode_flags & MODE_FLAG_HAS_BRIGHTNESS ? brightness : ROCCAT_KONE_PRO_AIR_BRIGHTNESS_MAX
);
}
void RoccatKoneProAirController::SendRGB(bool direct, std::vector<RGBColor> colors, unsigned char mode_value, unsigned char speed, unsigned char brightness)
{
unsigned char usb_buf[ROCCAT_KONE_PRO_AIR_RGB_PACKET_LENGTH];
memset(usb_buf, 0x00, ROCCAT_KONE_PRO_AIR_RGB_PACKET_LENGTH);
usb_buf[1] = 0x10;
usb_buf[2] = direct ? 0x10 : 0x50;
usb_buf[3] = 0x0B;
usb_buf[4] = direct ? 0x00 : 0x01;
usb_buf[5] = mode_value;
usb_buf[6] = ROCCAT_KONE_PRO_AIR_BRIGHTNESS_MAX; // Explicit brightness for first LED, not used by OpenRGB
usb_buf[7] = ROCCAT_KONE_PRO_AIR_BRIGHTNESS_MAX; // Explicit brightness for second LED, not used by OpenRGB
usb_buf[8] = brightness;
usb_buf[9] = speed;
for(unsigned int i = 0; i < colors.size(); i++)
{
usb_buf[10 + 3 * i] = RGBGetRValue(colors[i]);
usb_buf[11 + 3 * i] = RGBGetGValue(colors[i]);
usb_buf[12 + 3 * i] = RGBGetBValue(colors[i]);
}
hid_write(dev, usb_buf, ROCCAT_KONE_PRO_AIR_RGB_PACKET_LENGTH);
}

63
Controllers/RoccatController/RoccatKoneProAirController/RoccatKoneProAirController.h Normal file
View file

@ -0,0 +1,63 @@
/*---------------------------------------------------------*\
| RoccatKoneProAirController.h |
| |
| Driver for Roccat Kone Pro Air |
| |
| Plunti 10 Jun 2024 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-only |
\*---------------------------------------------------------*/
#pragma once
#include <hidapi/hidapi.h>
#include "RGBController.h"
#define ROCCAT_KONE_PRO_AIR_RGB_PACKET_LENGTH 16
#define ROCCAT_KONE_PRO_AIR_SETTINGS_WRITE_PACKET_LENGTH 25
#define ROCCAT_KONE_PRO_AIR_SETTINGS_READ_PACKET_LENGTH 42
#define ROCCAT_KONE_PRO_AIR_LED_COUNT 2
enum
{
ROCCAT_KONE_PRO_AIR_DIRECT_MODE_VALUE = 0x09,
ROCCAT_KONE_PRO_AIR_OFF_MODE_VALUE = 0x00,
ROCCAT_KONE_PRO_AIR_STATIC_MODE_VALUE = 0x01,
ROCCAT_KONE_PRO_AIR_RAINBOW_WAVE_MODE_VALUE = 0x06,
ROCCAT_KONE_PRO_AIR_HEARTBEAT_MODE_VALUE = 0x05,
ROCCAT_KONE_PRO_AIR_BREATHING_MODE_VALUE = 0x02,
ROCCAT_KONE_PRO_AIR_FLASHING_MODE_VALUE = 0x08,
ROCCAT_KONE_PRO_AIR_BATTERY_MODE_VALUE = 0x0A
};
enum
{
ROCCAT_KONE_PRO_AIR_SPEED_MIN = 0x01,
ROCCAT_KONE_PRO_AIR_SPEED_MAX = 0x0B,
ROCCAT_KONE_PRO_AIR_SPEED_MID = (ROCCAT_KONE_PRO_AIR_SPEED_MAX - ROCCAT_KONE_PRO_AIR_SPEED_MIN) / 2,
ROCCAT_KONE_PRO_AIR_BRIGHTNESS_MIN = 0x00,
ROCCAT_KONE_PRO_AIR_BRIGHTNESS_MAX = 0x64
};
class RoccatKoneProAirController
{
public:
RoccatKoneProAirController(hid_device* dev_handle, const hid_device_info& info);
~RoccatKoneProAirController();
std::string GetSerialString();
std::string GetDeviceLocation();
std::string GetFirmwareVersion();
void SendDirect(std::vector<RGBColor> colors);
void SetMode(std::vector<RGBColor> colors, unsigned char mode_value, unsigned char speed, unsigned char brightness, unsigned int mode_flags);
private:
hid_device* dev;
std::string location;
std::string serial_number;
std::string version;
void SendRGB(bool direct, std::vector<RGBColor> colors, unsigned char mode_value, unsigned char speed, unsigned char brightness);
};