Jens/LumaOps-Public
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Publish LumaOps source

Browse Source
This commit is contained in:
LumaOps release export
2026-09-03 01:18:36 +02:00
commit 7f1c0e5f71
2363 changed files with 501543 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Controllers/SinowealthController/SinowealthKeyboardController/RGBController_SinowealthKeyboard.cpp
+479
View File
@@ -0,0 +1,479 @@
/*------------------------------------------*\
| RGBController_SinowealthKeyboard.cpp |
| |
| Definitions and types for Sinowealth |
| Keyboard, Hopefully generic, this was |
| made spefically for FL eSports F11 KB |
| |
| Dmitri Kalinichenko (Dima-Kal) 23/06/2021 |
\*-----------------------------------------=*/
#include "RGBControllerKeyNames.h"
#include "RGBController_SinowealthKeyboard.h"
#define NA 0xFFFFFFFF
static unsigned int tkl_matrix_map[6][17] =
{ { 8, NA, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24},
{ 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45},
{ 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66},
{ 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 84, NA, NA, NA, NA},
{ 93, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 106, NA, NA, NA, 107, NA},
{ 113, 114, 115, NA, NA, NA, 118, NA, NA, NA, NA, 121, 122, 123, 127, 128, 129}};
static const char *led_names_tkl[] =
{
KEY_EN_ESCAPE,
KEY_EN_F1,
KEY_EN_F2,
KEY_EN_F3,
KEY_EN_F4,
KEY_EN_F5,
KEY_EN_F6,
KEY_EN_F7,
KEY_EN_F8,
KEY_EN_F9,
KEY_EN_F10,
KEY_EN_F11,
KEY_EN_F12,
KEY_EN_PRINT_SCREEN,
KEY_EN_SCROLL_LOCK,
"Key: Pause",
KEY_EN_BACK_TICK,
KEY_EN_1,
KEY_EN_2,
KEY_EN_3,
KEY_EN_4,
KEY_EN_5,
KEY_EN_6,
KEY_EN_7,
KEY_EN_8,
KEY_EN_9,
KEY_EN_0,
KEY_EN_MINUS,
KEY_EN_EQUALS,
KEY_EN_BACKSPACE,
KEY_EN_INSERT,
KEY_EN_HOME,
KEY_EN_PAGE_UP,
KEY_EN_TAB,
KEY_EN_Q,
KEY_EN_W,
KEY_EN_E,
KEY_EN_R,
KEY_EN_T,
KEY_EN_Y,
KEY_EN_U,
KEY_EN_I,
KEY_EN_O,
KEY_EN_P,
KEY_EN_LEFT_BRACKET,
KEY_EN_RIGHT_BRACKET,
KEY_EN_ANSI_BACK_SLASH,
KEY_EN_DELETE,
KEY_EN_END,
KEY_EN_PAGE_DOWN,
KEY_EN_CAPS_LOCK,
KEY_EN_A,
KEY_EN_S,
KEY_EN_D,
KEY_EN_F,
KEY_EN_G,
KEY_EN_H,
KEY_EN_J,
KEY_EN_K,
KEY_EN_L,
KEY_EN_SEMICOLON,
KEY_EN_QUOTE,
KEY_EN_ANSI_ENTER,
KEY_EN_LEFT_SHIFT,
KEY_EN_Z,
KEY_EN_X,
KEY_EN_C,
KEY_EN_V,
KEY_EN_B,
KEY_EN_N,
KEY_EN_M,
KEY_EN_COMMA,
KEY_EN_PERIOD,
KEY_EN_FORWARD_SLASH,
KEY_EN_RIGHT_SHIFT,
KEY_EN_UP_ARROW,
KEY_EN_LEFT_CONTROL,
KEY_EN_LEFT_WINDOWS,
KEY_EN_LEFT_ALT,
KEY_EN_SPACE,
KEY_EN_RIGHT_CONTROL,
KEY_EN_RIGHT_ALT,
KEY_EN_RIGHT_WINDOWS,
KEY_EN_RIGHT_FUNCTION,
KEY_EN_LEFT_ARROW,
KEY_EN_DOWN_ARROW,
KEY_EN_RIGHT_ARROW,
};
/**------------------------------------------------------------------*\
@name Sinowealth Keyboard
@category Keyboard
@type USB
@save :x:
@direct :x:
@effects :white_check_mark:
@detectors DetectSinowealthKeyboard
@comment
\*-------------------------------------------------------------------*/
RGBController_SinowealthKeyboard::RGBController_SinowealthKeyboard(SinowealthKeyboardController* controller_ptr)
{
controller = controller_ptr;
name = controller->GetName();
type = DEVICE_TYPE_KEYBOARD;
description = "Sinowealth Keyboard Device";
location = controller->GetLocation();
serial = controller->GetSerialString();
mode Static;
Static.name = "Static";
Static.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
Static.color_mode = MODE_COLORS_MODE_SPECIFIC;
Static.value = MODE_STATIC;
Static.colors_min = 1;
Static.colors_max = 1;
Static.colors.resize(1);
modes.push_back(Static);
mode Custom;
Custom.name = "Custom";
Custom.flags = MODE_FLAG_HAS_PER_LED_COLOR;
Custom.color_mode = MODE_COLORS_PER_LED;
Custom.value = MODE_PER_KEY;
modes.push_back(Custom);
mode Off;
Off.name = "Off";
Off.flags = 0;
Off.color_mode = MODE_COLORS_NONE;
Off.value = MODE_OFF;
modes.push_back(Off);
mode Respire;
Respire.name = "Respire";
Respire.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
Respire.speed_min = SPEED_SLOW;
Respire.speed = SPEED_NORMAL;
Respire.speed_max = SPEED_FASTEST;
Respire.color_mode = MODE_COLORS_RANDOM;
Respire.value = MODE_RESPIRE;
Respire.colors_min = 1;
Respire.colors_max = 1;
Respire.colors.resize(1);
modes.push_back(Respire);
mode Rainbow;
Rainbow.name = "Rainbow";
Rainbow.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
Rainbow.speed_min = SPEED_SLOW;
Rainbow.speed = SPEED_NORMAL;
Rainbow.speed_max = SPEED_FASTEST;
Rainbow.color_mode = MODE_COLORS_NONE;
Rainbow.value = MODE_RAINBOW;
modes.push_back(Rainbow);
mode FlashAway;
FlashAway.name = "Flash Away";
FlashAway.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
FlashAway.speed_min = SPEED_SLOW;
FlashAway.speed = SPEED_NORMAL;
FlashAway.speed_max = SPEED_FASTEST;
FlashAway.color_mode = MODE_COLORS_RANDOM;
FlashAway.value = MODE_FLASH_AWAY;
FlashAway.colors_min = 1;
FlashAway.colors_max = 1;
FlashAway.colors.resize(1);
modes.push_back(FlashAway);
mode Raindrops;
Raindrops.name = "Raindrops";
Raindrops.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
Raindrops.speed_min = SPEED_SLOW;
Raindrops.speed = SPEED_NORMAL;
Raindrops.speed_max = SPEED_FASTEST;
Raindrops.color_mode = MODE_COLORS_RANDOM;
Raindrops.value = MODE_RAINDROPS;
Raindrops.colors_min = 1;
Raindrops.colors_max = 1;
Raindrops.colors.resize(1);
modes.push_back(Raindrops);
mode RainbowWheel;
RainbowWheel.name = "Rainbow Wheel";
RainbowWheel.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
RainbowWheel.speed_min = SPEED_SLOW;
RainbowWheel.speed = SPEED_NORMAL;
RainbowWheel.speed_max = SPEED_FASTEST;
RainbowWheel.color_mode = MODE_COLORS_RANDOM;
RainbowWheel.value = MODE_RAINBOW_WHEEL;
RainbowWheel.colors_min = 1;
RainbowWheel.colors_max = 1;
RainbowWheel.colors.resize(1);
modes.push_back(RainbowWheel);
mode RipplesShining;
RipplesShining.name = "Ripples Shining";
RipplesShining.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
RipplesShining.speed_min = SPEED_SLOW;
RipplesShining.speed = SPEED_NORMAL;
RipplesShining.speed_max = SPEED_FASTEST;
RipplesShining.color_mode = MODE_COLORS_RANDOM;
RipplesShining.value = MODE_RIPPLES_SHINING;
RipplesShining.colors_min = 1;
RipplesShining.colors_max = 1;
RipplesShining.colors.resize(1);
modes.push_back(RipplesShining);
mode StarsTwinkle;
StarsTwinkle.name = "Stars Twinkle";
StarsTwinkle.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
StarsTwinkle.speed_min = SPEED_SLOW;
StarsTwinkle.speed = SPEED_NORMAL;
StarsTwinkle.speed_max = SPEED_FASTEST;
StarsTwinkle.color_mode = MODE_COLORS_RANDOM;
StarsTwinkle.value = MODE_STARS_TWINKLE;
StarsTwinkle.colors_min = 1;
StarsTwinkle.colors_max = 1;
StarsTwinkle.colors.resize(1);
modes.push_back(StarsTwinkle);
mode ShadowDisappear;
ShadowDisappear.name = "Shadow Disappear";
ShadowDisappear.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
ShadowDisappear.speed_min = SPEED_SLOW;
ShadowDisappear.speed = SPEED_NORMAL;
ShadowDisappear.speed_max = SPEED_FASTEST;
ShadowDisappear.color_mode = MODE_COLORS_RANDOM;
ShadowDisappear.value = MODE_SHADOW_DISAPPEAR;
ShadowDisappear.colors_min = 1;
ShadowDisappear.colors_max = 1;
ShadowDisappear.colors.resize(1);
modes.push_back(ShadowDisappear);
mode RetroSnake;
RetroSnake.name = "Retro Snake";
RetroSnake.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
RetroSnake.speed_min = SPEED_SLOW;
RetroSnake.speed = SPEED_NORMAL;
RetroSnake.speed_max = SPEED_FASTEST;
RetroSnake.color_mode = MODE_COLORS_RANDOM;
RetroSnake.value = MODE_RETRO_SNAKE;
RetroSnake.colors_min = 1;
RetroSnake.colors_max = 1;
RetroSnake.colors.resize(1);
modes.push_back(RetroSnake);
mode NeonStream;
NeonStream.name = "Neon Stream";
NeonStream.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
NeonStream.speed_min = SPEED_SLOW;
NeonStream.speed = SPEED_NORMAL;
NeonStream.speed_max = SPEED_FASTEST;
NeonStream.color_mode = MODE_COLORS_RANDOM;
NeonStream.value = MODE_NEON_STREAM;
NeonStream.colors_min = 1;
NeonStream.colors_max = 1;
NeonStream.colors.resize(1);
modes.push_back(NeonStream);
mode Reaction;
Reaction.name = "Reaction";
Reaction.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
Reaction.speed_min = SPEED_SLOW;
Reaction.speed = SPEED_NORMAL;
Reaction.speed_max = SPEED_FASTEST;
Reaction.color_mode = MODE_COLORS_RANDOM;
Reaction.value = MODE_REACTION;
Reaction.colors_min = 1;
Reaction.colors_max = 1;
Reaction.colors.resize(1);
modes.push_back(Reaction);
mode SineWave;
SineWave.name = "Sine Wave";
SineWave.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
SineWave.speed_min = SPEED_SLOW;
SineWave.speed = SPEED_NORMAL;
SineWave.speed_max = SPEED_FASTEST;
SineWave.color_mode = MODE_COLORS_RANDOM;
SineWave.value = MODE_SINE_WAVE;
SineWave.colors_min = 1;
SineWave.colors_max = 1;
SineWave.colors.resize(1);
modes.push_back(SineWave);
mode RetinueScanning;
RetinueScanning.name = "Retinue Scanning";
RetinueScanning.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
RetinueScanning.speed_min = SPEED_SLOW;
RetinueScanning.speed = SPEED_NORMAL;
RetinueScanning.speed_max = SPEED_FASTEST;
RetinueScanning.color_mode = MODE_COLORS_RANDOM;
RetinueScanning.value = MODE_RETINUE_SCANNING;
RetinueScanning.colors_min = 1;
RetinueScanning.colors_max = 1;
RetinueScanning.colors.resize(1);
modes.push_back(RetinueScanning);
mode RotatingWindmill;
RotatingWindmill.name = "Rotating Windmill";
RotatingWindmill.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
RotatingWindmill.speed_min = SPEED_SLOW;
RotatingWindmill.speed = SPEED_NORMAL;
RotatingWindmill.speed_max = SPEED_FASTEST;
RotatingWindmill.color_mode = MODE_COLORS_RANDOM;
RotatingWindmill.value = MODE_ROTATING_WINDMILL;
RotatingWindmill.colors_min = 1;
RotatingWindmill.colors_max = 1;
RotatingWindmill.colors.resize(1);
modes.push_back(RotatingWindmill);
mode ColorfulWaterfall;
ColorfulWaterfall.name = "Colorful Waterfall";
ColorfulWaterfall.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
ColorfulWaterfall.speed_min = SPEED_SLOW;
ColorfulWaterfall.speed = SPEED_NORMAL;
ColorfulWaterfall.speed_max = SPEED_FASTEST;
ColorfulWaterfall.color_mode = MODE_COLORS_NONE;
ColorfulWaterfall.value = MODE_COLORFUL_WATERFALL;
modes.push_back(ColorfulWaterfall);
mode Blossoming;
Blossoming.name = "Blossoming";
Blossoming.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
Blossoming.speed_min = SPEED_SLOW;
Blossoming.speed = SPEED_NORMAL;
Blossoming.speed_max = SPEED_FASTEST;
Blossoming.color_mode = MODE_COLORS_NONE;
Blossoming.value = MODE_BLOSSOMING;
modes.push_back(Blossoming);
mode RotatingStorm;
RotatingStorm.name = "Rotating Storm";
RotatingStorm.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
RotatingStorm.speed_min = SPEED_SLOW;
RotatingStorm.speed = SPEED_NORMAL;
RotatingStorm.speed_max = SPEED_FASTEST;
RotatingStorm.color_mode = MODE_COLORS_RANDOM;
RotatingStorm.value = MODE_ROTATING_STORM;
RotatingStorm.colors_min = 1;
RotatingStorm.colors_max = 1;
RotatingStorm.colors.resize(1);
modes.push_back(RotatingStorm);
mode Collision;
Collision.name = "Collision";
Collision.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
Collision.speed_min = SPEED_SLOW;
Collision.speed = SPEED_NORMAL;
Collision.speed_max = SPEED_FASTEST;
Collision.color_mode = MODE_COLORS_RANDOM;
Collision.value = MODE_COLLISION;
Collision.colors_min = 1;
Collision.colors_max = 1;
Collision.colors.resize(1);
modes.push_back(Collision);
mode Perfect;
Perfect.name = "Perfect";
Perfect.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
Perfect.speed_min = SPEED_SLOW;
Perfect.speed = SPEED_NORMAL;
Perfect.speed_max = SPEED_FASTEST;
Perfect.color_mode = MODE_COLORS_RANDOM;
Perfect.value = MODE_PERFECT;
Perfect.colors_min = 1;
Perfect.colors_max = 1;
Perfect.colors.resize(1);
modes.push_back(Perfect);
SetupZones();
}
RGBController_SinowealthKeyboard::~RGBController_SinowealthKeyboard()
{
delete controller;
}
void RGBController_SinowealthKeyboard::SetupZones()
{
/*---------------------------------------------------------*\
| Set up zones |
\*---------------------------------------------------------*/
zone new_zone;
new_zone.name = ZONE_EN_KEYBOARD;
new_zone.type = ZONE_TYPE_MATRIX;
new_zone.leds_min = 86;
new_zone.leds_max = 86;
new_zone.leds_count = 86;
new_zone.matrix_map = new matrix_map_type;
new_zone.matrix_map->height = 6;
new_zone.matrix_map->width = 17;
new_zone.matrix_map->map = (unsigned int *)&tkl_matrix_map;
zones.push_back(new_zone);
/*---------------------------------------------------------*\
| Set up LEDs |
\*---------------------------------------------------------*/
for(unsigned int led_idx = 0; led_idx < 86; led_idx++)
{
led new_led;
new_led.name = led_names_tkl[led_idx];
leds.push_back(new_led);
}
SetupColors();
}
void RGBController_SinowealthKeyboard::ResizeZone(int /*zone*/, int /*new_size*/)
{
/*---------------------------------------------------------*\
| This device does not support resizing zones |
\*---------------------------------------------------------*/
}
void RGBController_SinowealthKeyboard::DeviceUpdateLEDs()
{
controller->SetLEDsDirect(colors);
}
void RGBController_SinowealthKeyboard::UpdateZoneLEDs(int /*zone*/)
{
DeviceUpdateLEDs();
}
void RGBController_SinowealthKeyboard::UpdateSingleLED(int /*led*/)
{
DeviceUpdateLEDs();
}
void RGBController_SinowealthKeyboard::DeviceUpdateMode()
{
unsigned int brightness = BRIGHTNESS_FULL;
RGBColor* selected_color = (modes[active_mode].color_mode == MODE_COLORS_NONE) ? 0 : &modes[active_mode].colors[0];
if(modes[active_mode].value == MODE_STATIC)
{
controller->SetStaticColor(selected_color);
}
else
{
controller->SetMode(modes[active_mode].value, brightness, modes[active_mode].speed, modes[active_mode].color_mode);
}
}
Controllers/SinowealthController/SinowealthKeyboardController/RGBController_SinowealthKeyboard.h
+33
View File
@@ -0,0 +1,33 @@
/*------------------------------------------*\
| RGBController_SinowealthKeyboard.h |
| |
| Definitions and types for Sinowealth |
| Keyboard, Hopefully generic, this was |
| made spefically for FL eSports F11 KB |
| |
| Dmitri Kalinichenko (Dima-Kal) 23/06/2021 |
\*-----------------------------------------=*/
#pragma once
#include "RGBController.h"
#include "SinowealthKeyboardController.h"
class RGBController_SinowealthKeyboard : public RGBController
{
public:
RGBController_SinowealthKeyboard(SinowealthKeyboardController* controller_ptr);
~RGBController_SinowealthKeyboard();
void SetupZones();
void ResizeZone(int zone, int new_size);
void DeviceUpdateLEDs();
void UpdateZoneLEDs(int zone);
void UpdateSingleLED(int led);
void DeviceUpdateMode();
private:
SinowealthKeyboardController* controller;
};
Controllers/SinowealthController/SinowealthKeyboardController/SinowealthKeyboardController.cpp
+283
View File
@@ -0,0 +1,283 @@
/*------------------------------------------*\
| SinowealthKeyboardController.cpp |
| |
| Definitions and types for Sinowealth |
| Keyboard, Hopefully generic, this was |
| made spefically for FL eSports F11 KB |
| |
| Dmitri Kalinichenko (Dima-Kal) 23/06/2021 |
\*-----------------------------------------=*/
#include <cstring>
#include "SinowealthKeyboardController.h"
#include "StringUtils.h"
static unsigned char send_per_key_part_of_command_packet[] = { 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0x00,
0x00, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0x00,
0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
static unsigned char mode_brightness_speed_packet[] = { 0x06, 0x03, 0xB6, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x5A, 0xA5, 0x03, 0x03, 0x00, 0x00, 0x00, 0x02, 0x20, 0x01, 0x00, 0x00, 0x00, 0x00,
0x55, 0x55, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x20, 0x00, 0x44, 0x07, 0x30,
0x07, 0x23, 0x00, 0x23, 0x00, 0x23, 0x07, 0x33, 0x07, 0x23, 0x07, 0x23, 0x07, 0x23, 0x07, 0x23,
0x07, 0x23, 0x07, 0x23, 0x07, 0x23, 0x07, 0x23, 0x07, 0x23, 0x07, 0x23, 0x07, 0x23, 0x07, 0x23,
0x07, 0x23, 0x00, 0x10, 0x00, 0x10, 0x07, 0x44, 0x07, 0x44, 0x07, 0x44, 0x07, 0x44, 0x07, 0x44,
0x07, 0x44, 0x07, 0x44, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5A, 0xA5, 0x03, 0x03 };
static unsigned char tkl_keys_per_key_index[] = { 0x08, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x1d, 0x1E, 0x1F,
0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D,
0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x3F,
0x40, 0x41, 0x42, 0x47, 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F,
0x50, 0x51, 0x52, 0x54, 0x5D, 0x5f,
0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x6A, 0x6B,
0x71, 0x72, 0x73, 0x76, 0x79, 0x7A, 0x7B, 0x7F, 0x80, 0x81 };
static unsigned int keys_tkl_keys_indices_static_command[] = { 0x0022, 0x0024, 0x0026, 0x0027, 0x0029, 0x002B, 0x002D, 0x002E, 0x002F,
0x0030, 0x0031, 0x0032, 0x0037, 0x0039, 0x003B, 0x003C, 0x003E,
0x0040, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047, 0x004C, 0x004E,
0x0050, 0x0051, 0x0053, 0x0055, 0x0057, 0x0058, 0x0059, 0x005A, 0x005B, 0x005C,
0x0061, 0x0063, 0x0065, 0x0066, 0x0068, 0x006A, 0x006C, 0x006D, 0x006E, 0x006F,
0x0070, 0x0071, 0x0076, 0x0078, 0x007A, 0x007B, 0x007D, 0x007F,
0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x008B, 0x008D, 0x008F,
0x0090, 0x0092, 0x0094, 0x0096, 0x0097, 0x0098, 0x0099, 0x009A, 0x009B,
0x00A0, 0x00A2, 0x00A4, 0x00A5, 0x00A7, 0x00A9, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x00AF,
0x00B0, 0x00B5, 0x00B7, 0x00B9, 0x00BA, 0x00BC, 0x00BE,
0x00C0, 0x00E1, 0x00C2, 0x00C3, 0x00C4, 0x00C5, 0x00CA, 0x00CC, 0x00CE, 0x00CF,
0x00D1, 0x00D3, 0x00D5, 0x00D6, 0x00D7, 0x00D8, 0x00D9, 0x00DA, 0x00DF,
0x00E1, 0x00E3, 0x00E4, 0x00E6, 0x00E8, 0x00EA, 0x00EB, 0x00EC, 0x00ED, 0x00EE, 0x00EF,
0x00F4, 0x00F6, 0x00F8, 0x00F9, 0x00FB, 0x00FD, 0x00FF,
0x0100, 0x0101, 0x0102, 0x0103, 0x0104, 0x0109, 0x010B, 0x010D, 0x010E,
0x0110, 0x0112, 0x0114, 0x0115, 0x0116, 0x0117, 0x0118, 0x0119, 0x011E,
0x0120, 0x0122, 0x0123, 0x0125, 0x0127, 0x0129, 0x012A, 0x012B, 0x012C, 0x012D, 0x012E,
0x0133, 0x0135, 0x0137, 0x0138, 0x013A, 0x013C, 0x013E, 0x013F,
0x0140, 0x0141, 0x0142, 0x0143, 0x0148, 0x014A, 0x014C, 0x014D, 0x014F,
0x0151, 0x0153, 0x0154, 0x0155, 0x0156, 0x0157, 0x0158, 0x015D, 0x015F,
0x0161, 0x0162, 0x0164, 0x0166, 0x0168, 0x0169, 0x016A, 0x016B, 0x016C, 0x016D,
0x0172, 0x0174, 0x0176, 0x0177, 0x0179, 0x017B, 0x017D, 0x017E, 0x017F,
0x0180, 0x0181, 0x0182, 0x0187, 0x0189, 0x018B, 0x018C, 0x018E,
0x0190, 0x0192, 0x0193, 0x0194, 0x0195, 0x0196, 0x0197, 0x019C, 0x019E,
0x01A0, 0x01A1, 0x01A3, 0x01A5, 0x01A7, 0x01A8, 0x01A9, 0x01AA, 0x01AB, 0x01AC,
0x01B1, 0x01B3, 0x01B5, 0x01B6, 0x01B8, 0x01BA, 0x01BC, 0x01BD, 0x01BE, 0x01BF,
0x01C0, 0x01C1, 0x01C6, 0x01C8, 0x01CA, 0x01Cb, 0x01CD, 0x01CF,
0x01D1, 0x01D2, 0x01D3, 0x01D4, 0x01D5, 0x01D6, 0x01DB, 0x01DD, 0x01DF,
0x01E0, 0x01E2, 0x01E4, 0x01E6, 0x01E7, 0x01E8, 0x01E9, 0x01EA};
SinowealthKeyboardController::SinowealthKeyboardController(hid_device* dev_cmd_handle, hid_device* dev_data_handle, char* path, std::string dev_name)
{
dev_cmd = dev_cmd_handle;
dev_data = dev_data_handle;
name = dev_name;
led_count = sizeof(tkl_keys_per_key_index) / sizeof(*tkl_keys_per_key_index);
current_mode = MODE_STATIC;
current_speed = SPEED_NORMAL;
location = path;
}
SinowealthKeyboardController::~SinowealthKeyboardController()
{
hid_close(dev_cmd);
hid_close(dev_data);
}
std::string SinowealthKeyboardController::GetLocation()
{
return("HID: " + location);
}
std::string SinowealthKeyboardController::GetName()
{
return(name);
}
unsigned char SinowealthKeyboardController::GetCurrentMode()
{
return current_mode;
}
unsigned int SinowealthKeyboardController::GetLEDCount()
{
return(sizeof(tkl_keys_per_key_index) / sizeof(*tkl_keys_per_key_index));
}
std::string SinowealthKeyboardController::GetSerialString()
{
wchar_t serial_string[128];
int ret = hid_get_serial_number_string(dev_cmd, serial_string, 128);
if(ret != 0)
{
return("");
}
return(StringUtils::wstring_to_string(serial_string));
}
void SinowealthKeyboardController::SetLEDsDirect(std::vector<RGBColor> colors)
{
const int buffer_size = 1032;
unsigned char buf[buffer_size];
unsigned int num_keys = sizeof(tkl_keys_per_key_index) / sizeof(*tkl_keys_per_key_index);
/*-----------------------------------------------------*\
| Zero out buffer |
\*-----------------------------------------------------*/
memset(buf, 0x00, sizeof(buf));
/*-----------------------------------------------------*\
| Set up Direct packet |
\*-----------------------------------------------------*/
buf[0x00] = 0x06;
buf[0x01] = 0x09;
buf[0x02] = 0xBC;
buf[0x03] = 0x00;
buf[0x04] = 0x40;
for(unsigned int i = 0 ; i < (sizeof(send_per_key_part_of_command_packet) / sizeof(char)); i++)
{
buf[0x027C + i] = send_per_key_part_of_command_packet[i];
}
/*-----------------------------------------------------*\
| Fill in color data |
\*-----------------------------------------------------*/
for(unsigned int i = 0; i < num_keys; i++)
{
buf[tkl_keys_per_key_index[i]] = RGBGetBValue(colors[i]);
buf[tkl_keys_per_key_index[i] + 0x7E] = RGBGetGValue(colors[i]);
buf[tkl_keys_per_key_index[i] + 0x7E + 0x7E] = RGBGetRValue(colors[i]);
}
/*-----------------------------------------------------*\
| Send packet |
\*-----------------------------------------------------*/
hid_send_feature_report(dev_data, buf, sizeof(buf));
}
void SinowealthKeyboardController::SetStaticColor(RGBColor* color_buf)
{
const int buffer_size = 1032;
unsigned char usb_buf[buffer_size];
memset(usb_buf, 0x00, sizeof(usb_buf));
int offset = 0;
usb_buf[offset] = 0x06;
offset += 1;
usb_buf[offset] = 0x08;
offset += 1;
usb_buf[offset] = 0xB8;
offset += 2;
usb_buf[offset] = 0x40;
usb_buf[0x1D] = RGBGetRValue(color_buf[0]);
usb_buf[0x1E] = RGBGetGValue(color_buf[0]);
usb_buf[0x1F] = RGBGetBValue(color_buf[0]);
unsigned int size_of_keys_array = sizeof (keys_tkl_keys_indices_static_command)/ sizeof(int);
for(unsigned int i = 0x00; i < size_of_keys_array; i++)
{
unsigned int key_code = keys_tkl_keys_indices_static_command[i];
usb_buf[key_code] = 0xFF;
}
hid_send_feature_report(dev_data, usb_buf, sizeof(usb_buf));
}
void SinowealthKeyboardController::SetMode(unsigned char mode, unsigned char brightness, unsigned char speed, unsigned char color_mode)
{
const int buffer_size = 1032;
int mode_byte_index = 0x15;
const int speed_and_brightness_byte_index_start = 0x29; // Speed + brightnes level value, Seriously?
unsigned int color_mode_value = color_mode == MODE_COLORS_RANDOM ? 0x07 : 0x00; // 0x07 - Value to set random color mode
unsigned char usb_buf[buffer_size];
memset(usb_buf, 0x00, sizeof(usb_buf));
unsigned int mode_brightness_speed_packet_length = sizeof(mode_brightness_speed_packet)/sizeof(char);
for(unsigned int i = 0x00; i < mode_brightness_speed_packet_length; i++)
{
usb_buf[i] = mode_brightness_speed_packet[i];
}
usb_buf[mode_byte_index] = mode;
int speed_and_brightness_byte_index = speed_and_brightness_byte_index_start + ((mode - 2) * 2);
switch(mode)
{
case MODE_OFF:
break;
case MODE_RAINBOW:
break;
case MODE_FLASH_AWAY:
break;
case MODE_RAINDROPS:
break;
case MODE_RAINBOW_WHEEL:
break;
case MODE_RIPPLES_SHINING:
break;
case MODE_STARS_TWINKLE:
break;
case MODE_SHADOW_DISAPPEAR:
break;
case MODE_RETRO_SNAKE:
break;
case MODE_NEON_STREAM:
break;
case MODE_REACTION:
break;
case MODE_SINE_WAVE:
break;
case MODE_RETINUE_SCANNING:
break;
case MODE_ROTATING_WINDMILL:
break;
case MODE_COLORFUL_WATERFALL:
break;
case MODE_BLOSSOMING:
break;
case MODE_ROTATING_STORM:
break;
case MODE_COLLISION:
break;
case MODE_PERFECT:
break;
case MODE_PER_KEY:
usb_buf[mode_byte_index - 1] = 0x01;
usb_buf[0x27] = 0x24;
break;
}
int color_mode_byte_index = speed_and_brightness_byte_index - 1;
usb_buf[speed_and_brightness_byte_index] = speed + brightness;
usb_buf[color_mode_byte_index] = color_mode_value;
int result = hid_send_feature_report(dev_data, usb_buf, sizeof(usb_buf));
if(result != -1)
{
current_mode = mode;
}
}
Controllers/SinowealthController/SinowealthKeyboardController/SinowealthKeyboardController.h
+88
View File
@@ -0,0 +1,88 @@
/*------------------------------------------*\
| SinowealthKeyboardController.h |
| |
| Definitions and types for Sinowealth |
| Keyboard, Hopefully generic, this was |
| made spefically for FL eSports F11 KB |
| |
| Dmitri Kalinichenko (Dima-Kal) 23/06/2021 |
\*-----------------------------------------=*/
#include "RGBController.h"
#include <vector>
#include <hidapi.h>
#pragma once
enum
{
MODE_OFF = 0x0,
MODE_STATIC = 0x1,
MODE_RESPIRE = 0x2,
MODE_RAINBOW = 0x3,
MODE_FLASH_AWAY = 0x4,
MODE_RAINDROPS = 0x5,
MODE_RAINBOW_WHEEL = 0x6,
MODE_RIPPLES_SHINING = 0x7,
MODE_STARS_TWINKLE = 0x8,
MODE_SHADOW_DISAPPEAR = 0x9,
MODE_RETRO_SNAKE = 0xA,
MODE_NEON_STREAM = 0xB,
MODE_REACTION = 0xC,
MODE_SINE_WAVE = 0xD,
MODE_RETINUE_SCANNING = 0xE,
MODE_ROTATING_WINDMILL = 0xF,
MODE_COLORFUL_WATERFALL = 0x10,
MODE_BLOSSOMING = 0x11,
MODE_ROTATING_STORM = 0x12,
MODE_COLLISION = 0x13,
MODE_PERFECT = 0x14,
MODE_PER_KEY = 0x15
};
enum
{
SPEED_SLOW = 0x12,
SPEED_NORMAL = 0x22,
SPEED_FASTER = 0x32,
SPEED_FASTEST = 0x42,
};
enum
{
BRIGHTNESS_OFF = 0x0,
BRIGHTNESS_QUARTER = 0x1,
BRIGHTNESS_HALF = 0x2,
BRIGHTNESS_THREE_QUARTERS = 0x3,
BRIGHTNESS_FULL = 0x4
};
class SinowealthKeyboardController
{
public:
SinowealthKeyboardController(hid_device* dev_cmd_handle, hid_device* dev_data_handle, char *_path, std::string dev_name); //RGB, Command, path
~SinowealthKeyboardController();
unsigned int GetLEDCount();
std::string GetLocation();
std::string GetName();
std::string GetSerialString();
unsigned char GetCurrentMode();
void SetLEDColor(RGBColor* color_buf);
void SetStaticColor(RGBColor* color_buf);
void SetMode(unsigned char mode, unsigned char brightness, unsigned char speed, unsigned char color_mode);
void GetProfile();
void ReadFirmwareInfo();
void SetLEDsDirect(std::vector<RGBColor> colors);
private:
hid_device* dev_cmd;
hid_device* dev_data;
device_type type;
unsigned int led_count;
unsigned char current_mode;
unsigned char current_speed;
std::string location;
std::string name;
};