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

Initial commit for LightSalt Peripherals

Browse source
This commit is contained in:
James Buren 2024-07-24 10:01:56 -05:00 • committed by Adam Honse
parent c87efc5d67
commit 4d8466cd60
9 changed files with 1361 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

314
Controllers/LightSaltController/LightSaltController.cpp Normal file
View file

@ -0,0 +1,314 @@
/*---------------------------------------------------------*\
| LightSaltController.cpp |
| |
| Driver for LightSalt Peripherals |
| |
| James Buren (braewoods) 23 Jul 2024 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-only |
\*---------------------------------------------------------*/
#include <cstring>
#include "LightSaltController.h"
static const int mode_map[LIGHTSALT_MODE_MAXIMUM][6] =
{
{0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
{0x0100, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
{0x0400, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
{0x0700, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
{0x0A00, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
{0x0D00, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
{0x0E00, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
{0x0F00, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
{0x1100, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
{0x0000, 0x0000, 0x0000, 0x0000, 0x3301, 0x3302},
{0x3402, 0x3401, 0x0000, 0x0000, 0x0000, 0x0000},
{0x3502, 0x3501, 0x0000, 0x0000, 0x0000, 0x0000},
{0x3602, 0x3601, 0x0000, 0x0000, 0x0000, 0x0000},
{0x3802, 0x3801, 0x0000, 0x0000, 0x0000, 0x0000},
{0x0000, 0x0000, 0x3901, 0x3902, 0x0000, 0x0000},
{0x0000, 0x0000, 0x3A01, 0x3A02, 0x0000, 0x0000},
{0x0000, 0x0000, 0x0000, 0x0000, 0x3702, 0x3701},
{0x3B02, 0x3B01, 0x0000, 0x0000, 0x0000, 0x0000}
};
LightSaltController::LightSaltController(hid_device* dev_handle, const hid_device_info& info)
{
wchar_t usb_string[128];
dev = dev_handle;
device_location = info.path;
if(hid_get_serial_number_string(dev, usb_string, 128) == 0)
{
std::wstring tmp_wstring = usb_string;
serial = std::string(tmp_wstring.begin(), tmp_wstring.end());
}
else
{
serial = "";
}
if(hid_get_manufacturer_string(dev, usb_string, 128) == 0)
{
std::wstring tmp_wstring = usb_string;
manufacturer = std::string(tmp_wstring.begin(), tmp_wstring.end());
}
else
{
manufacturer = "";
}
if(hid_get_product_string(dev, usb_string, 128) == 0)
{
std::wstring tmp_wstring = usb_string;
product = std::string(tmp_wstring.begin(), tmp_wstring.end());
}
else
{
product = "";
}
if(strstr(manufacturer.c_str(), "Light&Salt") && strstr(product.c_str(), "Light&Salt"))
{
QueryDeviceModel();
QueryDeviceClass();
SetDeviceType();
}
else
{
device_model = "";
device_class = "";
firmware_version = "";
device_type = LIGHTSALT_TYPE_MAXIMUM;
}
}
LightSaltController::~LightSaltController()
{
hid_close(dev);
}
std::string LightSaltController::GetDeviceLocation()
{
return("HID: " + device_location);
}
std::string LightSaltController::GetSerial()
{
return(serial);
}
std::string LightSaltController::GetManufacturer()
{
return(manufacturer);
}
std::string LightSaltController::GetProduct()
{
return(product);
}
std::string LightSaltController::GetDeviceModel()
{
return(device_model);
}
std::string LightSaltController::GetDeviceClass()
{
return(device_class);
}
std::string LightSaltController::GetFirmwareVersion()
{
return(firmware_version);
}
int LightSaltController::GetDeviceType()
{
return(device_type);
}
void LightSaltController::SetColors(RGBColor* colors, int sets, int rows, int columns)
{
uint8_t write_buffer[LIGHTSALT_WRITE_LENGTH];
int color_idx = 0;
write_buffer[0] = 0x00;
for(int set_idx = 0; set_idx < sets; set_idx++)
{
write_buffer[1] = 0x03 + set_idx;
for(int row_idx = 0; row_idx < rows; row_idx++)
{
int write_idx = 2;
write_buffer[write_idx++] = 0x01 + row_idx * columns;
for(int column_idx = 0; column_idx < columns; column_idx++)
{
RGBColor color = colors[color_idx++];
write_buffer[write_idx++] = RGBGetRValue(color);
write_buffer[write_idx++] = RGBGetGValue(color);
write_buffer[write_idx++] = RGBGetBValue(color);
}
hid_write(dev, write_buffer, sizeof(write_buffer));
}
}
}
void LightSaltController::ApplyColors(int sets)
{
uint8_t write_buffer[LIGHTSALT_WRITE_LENGTH];
int write_idx = 1;
memset(write_buffer, 0x00, sizeof(write_buffer));
write_buffer[write_idx++] = 0xFE;
write_buffer[write_idx++] = 0x01;
for(int set_idx = 0; set_idx < sets; set_idx++)
{
write_buffer[write_idx++] = 0x03 + set_idx;
}
hid_write(dev, write_buffer, sizeof(write_buffer));
}
void LightSaltController::SaveColors(int sets)
{
uint8_t write_buffer[LIGHTSALT_WRITE_LENGTH];
int write_idx = 1;
memset(write_buffer, 0x00, sizeof(write_buffer));
write_buffer[write_idx++] = 0xFE;
write_buffer[write_idx++] = 0xF0;
for(int set_idx = 0; set_idx < sets; set_idx++)
{
write_buffer[write_idx++] = 0x03 + set_idx;
}
hid_write(dev, write_buffer, sizeof(write_buffer));
}
void LightSaltController::SetMode(int mode, int direction, int speed)
{
uint8_t write_buffer[LIGHTSALT_WRITE_LENGTH];
int actual_mode = mode_map[mode][direction];
memset(write_buffer, 0x00, sizeof(write_buffer));
write_buffer[1] = 0xFE;
write_buffer[2] = 0x03;
write_buffer[3] = (actual_mode & 0xFF00) >> 8;
write_buffer[4] = (actual_mode & 0x00FF) >> 0;
write_buffer[5] = speed;
hid_write(dev, write_buffer, sizeof(write_buffer));
}
void LightSaltController::SetFilter(RGBColor color)
{
uint8_t write_buffer[LIGHTSALT_WRITE_LENGTH];
memset(write_buffer, 0x00, sizeof(write_buffer));
write_buffer[1] = 0xFE;
write_buffer[2] = 0x04;
write_buffer[3] = RGBGetRValue(color);
write_buffer[4] = RGBGetGValue(color);
write_buffer[5] = RGBGetBValue(color);
hid_write(dev, write_buffer, sizeof(write_buffer));
}
void LightSaltController::SetBrightness(uint8_t brightness)
{
uint8_t write_buffer[LIGHTSALT_WRITE_LENGTH];
memset(write_buffer, 0x00, sizeof(write_buffer));
write_buffer[1] = 0xFE;
write_buffer[2] = 0x05;
write_buffer[3] = brightness;
hid_write(dev, write_buffer, sizeof(write_buffer));
}
void LightSaltController::QueryDeviceModel()
{
uint8_t write_buffer[LIGHTSALT_WRITE_LENGTH];
uint8_t read_buffer[LIGHTSALT_READ_LENGTH];
memset(write_buffer, 0x00, sizeof(write_buffer));
write_buffer[1] = 0xFE;
write_buffer[2] = 0xF5;
write_buffer[3] = 0x06;
if(hid_write(dev, write_buffer, sizeof(write_buffer)) != sizeof(write_buffer))
{
device_model = "";
return;
}
if(hid_read_timeout(dev, read_buffer, sizeof(read_buffer), 100) != sizeof(read_buffer))
{
device_model = "";
return;
}
device_model = (char *)(read_buffer + 3);
}
void LightSaltController::QueryDeviceClass()
{
uint8_t write_buffer[LIGHTSALT_WRITE_LENGTH];
uint8_t read_buffer[LIGHTSALT_READ_LENGTH];
memset(write_buffer, 0x00, sizeof(write_buffer));
write_buffer[1] = 0xFE;
write_buffer[2] = 0xFF;
if(hid_write(dev, write_buffer, sizeof(write_buffer)) != sizeof(write_buffer))
{
device_class = "";
firmware_version = "";
return;
}
if(hid_read_timeout(dev, read_buffer, sizeof(read_buffer), 100) != sizeof(read_buffer))
{
device_class = "";
firmware_version = "";
return;
}
device_class = (char *)(read_buffer );
firmware_version = (char *)(read_buffer + device_class.size() + 1);
}
void LightSaltController::SetDeviceType()
{
struct device_class_table
{
std::string device_class;
int device_type;
};
static const device_class_table table[] =
{
{"Light&Salt_keyboard1", LIGHTSALT_TYPE_KEYBOARD},
{"Light&Salt_KEY_PAD", LIGHTSALT_TYPE_KEYPAD }
};
device_type = LIGHTSALT_TYPE_MAXIMUM;
for(const device_class_table& match : table)
{
if(match.device_class == device_class)
{
device_type = match.device_type;
break;
}
}
}

103
Controllers/LightSaltController/LightSaltController.h Normal file
View file

@ -0,0 +1,103 @@
/*---------------------------------------------------------*\
| LightSaltController.h |
| |
| Driver for LightSalt Peripherals |
| |
| James Buren (braewoods) 23 Jul 2024 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-only |
\*---------------------------------------------------------*/
#pragma once
#include <string>
#include <hidapi/hidapi.h>
#include "RGBController.h"
#define LIGHTSALT_PACKET_LENGTH 32
#define LIGHTSALT_WRITE_LENGTH (LIGHTSALT_PACKET_LENGTH + 1)
#define LIGHTSALT_READ_LENGTH (LIGHTSALT_PACKET_LENGTH)
enum
{
LIGHTSALT_TYPE_KEYBOARD,
LIGHTSALT_TYPE_KEYPAD,
LIGHTSALT_TYPE_MAXIMUM
};
enum
{
LIGHTSALT_MODE_CUSTOM,
LIGHTSALT_MODE_POINT,
LIGHTSALT_MODE_AREA,
LIGHTSALT_MODE_COLLAPSE,
LIGHTSALT_MODE_EXPAND,
LIGHTSALT_MODE_EXPLODE,
LIGHTSALT_MODE_DART,
LIGHTSALT_MODE_FLAME,
LIGHTSALT_MODE_LASER,
LIGHTSALT_MODE_BREATHING,
LIGHTSALT_MODE_TRICOLOR_RADAR,
LIGHTSALT_MODE_WHEEL_1,
LIGHTSALT_MODE_WHEEL_2,
LIGHTSALT_MODE_WAVE_1,
LIGHTSALT_MODE_WAVE_2,
LIGHTSALT_MODE_WAVE_3,
LIGHTSALT_MODE_RAINBOW_1,
LIGHTSALT_MODE_RAINBOW_2,
LIGHTSALT_MODE_MAXIMUM
};
enum
{
LIGHTSALT_SPEED_MINIMUM = 0x01,
LIGHTSALT_SPEED_MAXIMUM = 0x32,
LIGHTSALT_SPEED_DEFAULT = 0x19
};
enum
{
LIGHTSALT_BRIGHTNESS_MINIMUM = 0x00,
LIGHTSALT_BRIGHTNESS_MAXIMUM = 0xFF,
LIGHTSALT_BRIGHTNESS_DEFAULT = 0x80
};
class LightSaltController
{
public:
LightSaltController(hid_device* dev_handle, const hid_device_info& info);
~LightSaltController();
std::string GetDeviceLocation();
std::string GetSerial();
std::string GetManufacturer();
std::string GetProduct();
std::string GetDeviceModel();
std::string GetDeviceClass();
std::string GetFirmwareVersion();
int GetDeviceType();
void SetColors(RGBColor* colors, int sets, int rows, int columns);
void ApplyColors(int sets);
void SaveColors(int sets);
void SetMode(int mode, int direction, int speed);
void SetFilter(RGBColor color);
void SetBrightness(uint8_t brightness);
private:
hid_device* dev;
std::string device_location;
std::string serial;
std::string manufacturer;
std::string product;
std::string device_model;
std::string device_class;
std::string firmware_version;
int device_type;
void QueryDeviceModel();
void QueryDeviceClass();
void SetDeviceType();
};

52
Controllers/LightSaltController/LightSaltControllerDetect.cpp Normal file
View file

@ -0,0 +1,52 @@
/*---------------------------------------------------------*\
| LightSaltControllerDetect.cpp |
| |
| Detector for LightSalt Peripherals |
| |
| James Buren (braewoods) 23 Jul 2024 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-only |
\*---------------------------------------------------------*/
#include <hidapi/hidapi.h>
#include "Detector.h"
#include "LightSaltController.h"
#include "RGBController_LightSaltKeyboard.h"
#include "RGBController_LightSaltKeypad.h"
#define LIGHTSALT_VID 0x0483
#define LIGHTSALT_PID 0x5750
void DetectLightSaltControllers(hid_device_info* info, const std::string &)
{
hid_device* dev = hid_open_path(info->path);
if(dev)
{
LightSaltController* controller = new LightSaltController(dev, *info);
RGBController* rgb_controller = nullptr;
switch(controller->GetDeviceType())
{
case LIGHTSALT_TYPE_KEYBOARD:
rgb_controller = new RGBController_LightSaltKeyboard(controller);
break;
case LIGHTSALT_TYPE_KEYPAD:
rgb_controller = new RGBController_LightSaltKeypad(controller);
break;
default:
delete controller;
break;
}
if(rgb_controller != nullptr)
{
ResourceManager::get()->RegisterRGBController(rgb_controller);
}
}
} /* DetectLightSaltControllers() */
REGISTER_HID_DETECTOR_IPU("LightSalt Peripherals", DetectLightSaltControllers, LIGHTSALT_VID, LIGHTSALT_PID, 1, 1, 0);

452
Controllers/LightSaltController/RGBController_LightSalt.cpp Normal file
View file

@ -0,0 +1,452 @@
/*---------------------------------------------------------*\
| RGBController_LightSalt.cpp |
| |
| RGBController for LightSalt Peripherals |
| |
| James Buren (braewoods) 23 Jul 2024 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-only |
\*---------------------------------------------------------*/
#include <cstring>
#include "RGBControllerKeyNames.h"
#include "RGBController_LightSalt.h"
static RGBColor DeflectColor(bool deflection, RGBColor color)
{
if(deflection)
{
int old_red = RGBGetRValue(color);
int old_grn = RGBGetGValue(color);
int old_blu = RGBGetBValue(color);
int new_red = old_red + ((255 - old_red) * 50 / 100);
int new_grn = old_grn + ((255 - old_grn) * 50 / 100);
int new_blu = old_blu + ((255 - old_blu) * 50 / 100);
return ToRGBColor(new_red, new_grn, new_blu);
}
else
{
return color;
}
}
RGBController_LightSalt::~RGBController_LightSalt()
{
/*---------------------------------------------------------*\
| Delete the matrix map |
\*---------------------------------------------------------*/
for(unsigned int zone_index = 0; zone_index < zones.size(); zone_index++)
{
if(zones[zone_index].matrix_map != nullptr)
{
delete zones[zone_index].matrix_map;
}
}
delete controller;
}
void RGBController_LightSalt::SetupData(LightSaltController* controller_ptr)
{
controller = controller_ptr;
name = "LightSalt " + table.device.name;
vendor = "LightSalt";
type = table.device.type;
description = "LightSalt " + table.device.name + " (" + controller->GetDeviceModel() + ")";
location = controller->GetDeviceLocation();
serial = controller->GetSerial();
version = controller->GetFirmwareVersion();
}
void RGBController_LightSalt::SetupModes()
{
{
mode mode;
mode.name = "Custom";
mode.value = LIGHTSALT_MODE_CUSTOM;
mode.flags = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
mode.brightness_min = LIGHTSALT_BRIGHTNESS_MINIMUM;
mode.brightness_max = LIGHTSALT_BRIGHTNESS_MAXIMUM;
mode.brightness = LIGHTSALT_BRIGHTNESS_DEFAULT;
mode.color_mode = MODE_COLORS_PER_LED;
modes.push_back(mode);
}
{
mode mode;
mode.name = "Reactive Point";
mode.value = LIGHTSALT_MODE_POINT;
mode.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
mode.speed_min = LIGHTSALT_SPEED_MINIMUM;
mode.speed_max = LIGHTSALT_SPEED_MAXIMUM;
mode.speed = LIGHTSALT_SPEED_DEFAULT;
mode.brightness_min = LIGHTSALT_BRIGHTNESS_MINIMUM;
mode.brightness_max = LIGHTSALT_BRIGHTNESS_MAXIMUM;
mode.brightness = LIGHTSALT_BRIGHTNESS_DEFAULT;
mode.color_mode = MODE_COLORS_NONE;
modes.push_back(mode);
}
{
mode mode;
mode.name = "Reactive Area";
mode.value = LIGHTSALT_MODE_AREA;
mode.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
mode.speed_min = LIGHTSALT_SPEED_MINIMUM;
mode.speed_max = LIGHTSALT_SPEED_MAXIMUM;
mode.speed = LIGHTSALT_SPEED_DEFAULT;
mode.brightness_min = LIGHTSALT_BRIGHTNESS_MINIMUM;
mode.brightness_max = LIGHTSALT_BRIGHTNESS_MAXIMUM;
mode.brightness = LIGHTSALT_BRIGHTNESS_DEFAULT;
mode.color_mode = MODE_COLORS_NONE;
modes.push_back(mode);
}
{
mode mode;
mode.name = "Reactive Collapse";
mode.value = LIGHTSALT_MODE_COLLAPSE;
mode.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
mode.speed_min = LIGHTSALT_SPEED_MINIMUM;
mode.speed_max = LIGHTSALT_SPEED_MAXIMUM;
mode.speed = LIGHTSALT_SPEED_DEFAULT;
mode.brightness_min = LIGHTSALT_BRIGHTNESS_MINIMUM;
mode.brightness_max = LIGHTSALT_BRIGHTNESS_MAXIMUM;
mode.brightness = LIGHTSALT_BRIGHTNESS_DEFAULT;
mode.color_mode = MODE_COLORS_NONE;
modes.push_back(mode);
}
{
mode mode;
mode.name = "Reactive Expand";
mode.value = LIGHTSALT_MODE_EXPAND;
mode.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
mode.speed_min = LIGHTSALT_SPEED_MINIMUM;
mode.speed_max = LIGHTSALT_SPEED_MAXIMUM;
mode.speed = LIGHTSALT_SPEED_DEFAULT;
mode.brightness_min = LIGHTSALT_BRIGHTNESS_MINIMUM;
mode.brightness_max = LIGHTSALT_BRIGHTNESS_MAXIMUM;
mode.brightness = LIGHTSALT_BRIGHTNESS_DEFAULT;
mode.color_mode = MODE_COLORS_NONE;
modes.push_back(mode);
}
{
mode mode;
mode.name = "Reactive Explode";
mode.value = LIGHTSALT_MODE_EXPLODE;
mode.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
mode.speed_min = LIGHTSALT_SPEED_MINIMUM;
mode.speed_max = LIGHTSALT_SPEED_MAXIMUM;
mode.speed = LIGHTSALT_SPEED_DEFAULT;
mode.brightness_min = LIGHTSALT_BRIGHTNESS_MINIMUM;
mode.brightness_max = LIGHTSALT_BRIGHTNESS_MAXIMUM;
mode.brightness = LIGHTSALT_BRIGHTNESS_DEFAULT;
mode.color_mode = MODE_COLORS_NONE;
modes.push_back(mode);
}
{
mode mode;
mode.name = "Reactive Dart";
mode.value = LIGHTSALT_MODE_DART;
mode.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
mode.speed_min = LIGHTSALT_SPEED_MINIMUM;
mode.speed_max = LIGHTSALT_SPEED_MAXIMUM;
mode.speed = LIGHTSALT_SPEED_DEFAULT;
mode.brightness_min = LIGHTSALT_BRIGHTNESS_MINIMUM;
mode.brightness_max = LIGHTSALT_BRIGHTNESS_MAXIMUM;
mode.brightness = LIGHTSALT_BRIGHTNESS_DEFAULT;
mode.color_mode = MODE_COLORS_NONE;
modes.push_back(mode);
}
{
mode mode;
mode.name = "Reactive Flame";
mode.value = LIGHTSALT_MODE_FLAME;
mode.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
mode.speed_min = LIGHTSALT_SPEED_MINIMUM;
mode.speed_max = LIGHTSALT_SPEED_MAXIMUM;
mode.speed = LIGHTSALT_SPEED_DEFAULT;
mode.brightness_min = LIGHTSALT_BRIGHTNESS_MINIMUM;
mode.brightness_max = LIGHTSALT_BRIGHTNESS_MAXIMUM;
mode.brightness = LIGHTSALT_BRIGHTNESS_DEFAULT;
mode.color_mode = MODE_COLORS_NONE;
modes.push_back(mode);
}
{
mode mode;
mode.name = "Reactive Laser";
mode.value = LIGHTSALT_MODE_LASER;
mode.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
mode.speed_min = LIGHTSALT_SPEED_MINIMUM;
mode.speed_max = LIGHTSALT_SPEED_MAXIMUM;
mode.speed = LIGHTSALT_SPEED_DEFAULT;
mode.brightness_min = LIGHTSALT_BRIGHTNESS_MINIMUM;
mode.brightness_max = LIGHTSALT_BRIGHTNESS_MAXIMUM;
mode.brightness = LIGHTSALT_BRIGHTNESS_DEFAULT;
mode.color_mode = MODE_COLORS_NONE;
modes.push_back(mode);
}
{
mode mode;
mode.name = "Breathing";
mode.value = LIGHTSALT_MODE_BREATHING;
mode.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_HV | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
mode.speed_min = LIGHTSALT_SPEED_MINIMUM;
mode.speed_max = LIGHTSALT_SPEED_MAXIMUM;
mode.speed = LIGHTSALT_SPEED_DEFAULT;
mode.direction = MODE_DIRECTION_HORIZONTAL;
mode.brightness_min = LIGHTSALT_BRIGHTNESS_MINIMUM;
mode.brightness_max = LIGHTSALT_BRIGHTNESS_MAXIMUM;
mode.brightness = LIGHTSALT_BRIGHTNESS_DEFAULT;
mode.color_mode = MODE_COLORS_NONE;
modes.push_back(mode);
}
{
mode mode;
mode.name = "Tricolor Radar";
mode.value = LIGHTSALT_MODE_TRICOLOR_RADAR;
mode.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
mode.speed_min = LIGHTSALT_SPEED_MINIMUM;
mode.speed_max = LIGHTSALT_SPEED_MAXIMUM;
mode.speed = LIGHTSALT_SPEED_DEFAULT;
mode.direction = MODE_DIRECTION_LEFT;
mode.brightness_min = LIGHTSALT_BRIGHTNESS_MINIMUM;
mode.brightness_max = LIGHTSALT_BRIGHTNESS_MAXIMUM;
mode.brightness = LIGHTSALT_BRIGHTNESS_DEFAULT;
mode.color_mode = MODE_COLORS_NONE;
modes.push_back(mode);
}
{
mode mode;
mode.name = "Wheel 1";
mode.value = LIGHTSALT_MODE_WHEEL_1;
mode.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
mode.speed_min = LIGHTSALT_SPEED_MINIMUM;
mode.speed_max = LIGHTSALT_SPEED_MAXIMUM;
mode.speed = LIGHTSALT_SPEED_DEFAULT;
mode.direction = MODE_DIRECTION_LEFT;
mode.brightness_min = LIGHTSALT_BRIGHTNESS_MINIMUM;
mode.brightness_max = LIGHTSALT_BRIGHTNESS_MAXIMUM;
mode.brightness = LIGHTSALT_BRIGHTNESS_DEFAULT;
mode.color_mode = MODE_COLORS_NONE;
modes.push_back(mode);
}
{
mode mode;
mode.name = "Wheel 2";
mode.value = LIGHTSALT_MODE_WHEEL_2;
mode.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
mode.speed_min = LIGHTSALT_SPEED_MINIMUM;
mode.speed_max = LIGHTSALT_SPEED_MAXIMUM;
mode.speed = LIGHTSALT_SPEED_DEFAULT;
mode.direction = MODE_DIRECTION_LEFT;
mode.brightness_min = LIGHTSALT_BRIGHTNESS_MINIMUM;
mode.brightness_max = LIGHTSALT_BRIGHTNESS_MAXIMUM;
mode.brightness = LIGHTSALT_BRIGHTNESS_DEFAULT;
mode.color_mode = MODE_COLORS_NONE;
modes.push_back(mode);
}
{
mode mode;
mode.name = "Wave 1";
mode.value = LIGHTSALT_MODE_WAVE_1;
mode.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
mode.speed_min = LIGHTSALT_SPEED_MINIMUM;
mode.speed_max = LIGHTSALT_SPEED_MAXIMUM;
mode.speed = LIGHTSALT_SPEED_DEFAULT;
mode.direction = MODE_DIRECTION_LEFT;
mode.brightness_min = LIGHTSALT_BRIGHTNESS_MINIMUM;
mode.brightness_max = LIGHTSALT_BRIGHTNESS_MAXIMUM;
mode.brightness = LIGHTSALT_BRIGHTNESS_DEFAULT;
mode.color_mode = MODE_COLORS_NONE;
modes.push_back(mode);
}
{
mode mode;
mode.name = "Wave 2";
mode.value = LIGHTSALT_MODE_WAVE_2;
mode.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_UD | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
mode.speed_min = LIGHTSALT_SPEED_MINIMUM;
mode.speed_max = LIGHTSALT_SPEED_MAXIMUM;
mode.speed = LIGHTSALT_SPEED_DEFAULT;
mode.direction = MODE_DIRECTION_UP;
mode.brightness_min = LIGHTSALT_BRIGHTNESS_MINIMUM;
mode.brightness_max = LIGHTSALT_BRIGHTNESS_MAXIMUM;
mode.brightness = LIGHTSALT_BRIGHTNESS_DEFAULT;
mode.color_mode = MODE_COLORS_NONE;
modes.push_back(mode);
}
{
mode mode;
mode.name = "Wave 3";
mode.value = LIGHTSALT_MODE_WAVE_3;
mode.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_UD | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
mode.speed_min = LIGHTSALT_SPEED_MINIMUM;
mode.speed_max = LIGHTSALT_SPEED_MAXIMUM;
mode.speed = LIGHTSALT_SPEED_DEFAULT;
mode.direction = MODE_DIRECTION_UP;
mode.brightness_min = LIGHTSALT_BRIGHTNESS_MINIMUM;
mode.brightness_max = LIGHTSALT_BRIGHTNESS_MAXIMUM;
mode.brightness = LIGHTSALT_BRIGHTNESS_DEFAULT;
mode.color_mode = MODE_COLORS_NONE;
modes.push_back(mode);
}
{
mode mode;
mode.name = "Rainbow 1";
mode.value = LIGHTSALT_MODE_RAINBOW_1;
mode.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_HV | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
mode.speed_min = LIGHTSALT_SPEED_MINIMUM;
mode.speed_max = LIGHTSALT_SPEED_MAXIMUM;
mode.speed = LIGHTSALT_SPEED_DEFAULT;
mode.direction = MODE_DIRECTION_HORIZONTAL;
mode.brightness_min = LIGHTSALT_BRIGHTNESS_MINIMUM;
mode.brightness_max = LIGHTSALT_BRIGHTNESS_MAXIMUM;
mode.brightness = LIGHTSALT_BRIGHTNESS_DEFAULT;
mode.color_mode = MODE_COLORS_NONE;
modes.push_back(mode);
}
{
mode mode;
mode.name = "Rainbow 2";
mode.value = LIGHTSALT_MODE_RAINBOW_2;
mode.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
mode.speed_min = LIGHTSALT_SPEED_MINIMUM;
mode.speed_max = LIGHTSALT_SPEED_MAXIMUM;
mode.speed = LIGHTSALT_SPEED_DEFAULT;
mode.direction = MODE_DIRECTION_LEFT;
mode.brightness_min = LIGHTSALT_BRIGHTNESS_MINIMUM;
mode.brightness_max = LIGHTSALT_BRIGHTNESS_MAXIMUM;
mode.brightness = LIGHTSALT_BRIGHTNESS_DEFAULT;
mode.color_mode = MODE_COLORS_NONE;
modes.push_back(mode);
}
}
void RGBController_LightSalt::SetupZones()
{
{
zone zone;
zone.name = table.device.name;
zone.type = ZONE_TYPE_MATRIX;
zone.leds_min = table.led.count;
zone.leds_max = table.led.count;
zone.leds_count = table.led.count;
zone.matrix_map = new matrix_map_type;
zone.matrix_map->height = table.map.height;
zone.matrix_map->width = table.map.width;
zone.matrix_map->map = table.map.matrix;
zones.push_back(zone);
}
for(int led_idx = 0; led_idx < table.led.count; led_idx++)
{
led led;
led.name = table.led.names[led_idx];
leds.push_back(led);
}
{
zone zone;
zone.name = "Color Filter";
zone.type = ZONE_TYPE_SINGLE;
zone.leds_min = 1;
zone.leds_max = 1;
zone.leds_count = 1;
zone.matrix_map = NULL;
zones.push_back(zone);
}
{
led led;
led.name = "Color Filter";
leds.push_back(led);
}
SetupColors();
colors[colors.size() - 1] = ToRGBColor(0xFF, 0xFF, 0xFF);
}
void RGBController_LightSalt::ResizeZone(int /*zone*/, int /*new_size*/)
{
/*---------------------------------------------------------*\
| This device does not support resizing zones |
\*---------------------------------------------------------*/
}
void RGBController_LightSalt::DeviceUpdateColors(bool save)
{
int sets = table.led.sets;
int rows = table.led.rows;
int columns = table.led.columns;
RGBColor colors_data[sets][rows][columns];
memset(colors_data, 0x00, sizeof(colors_data));
for(int led_idx = 0; led_idx < table.led.count; led_idx++)
{
int index = table.led.indices[led_idx];
int deflection = table.led.deflections[led_idx];
int row = index / columns;
int column = index % columns;
RGBColor color = colors[led_idx];
for(int set_idx = 0; set_idx < sets; set_idx++)
{
colors_data[set_idx][row][column] = DeflectColor(deflection & (1 << set_idx), color);
}
}
controller->SetFilter(colors[colors.size() - 1]);
controller->SetColors((RGBColor*)colors_data, sets, rows, columns);
controller->ApplyColors(sets);
if(save)
{
controller->SaveColors(sets);
}
}
void RGBController_LightSalt::DeviceUpdateLEDs()
{
DeviceUpdateColors(false);
}
void RGBController_LightSalt::UpdateZoneLEDs(int /*zone*/)
{
DeviceUpdateLEDs();
}
void RGBController_LightSalt::UpdateSingleLED(int /*led*/)
{
DeviceUpdateLEDs();
}
void RGBController_LightSalt::DeviceUpdateMode()
{
const mode& mode = modes[active_mode];
controller->SetBrightness(mode.brightness);
std::this_thread::sleep_for(std::chrono::milliseconds(25));
controller->SetMode(mode.value, mode.direction, mode.speed);
}
void RGBController_LightSalt::DeviceSaveMode()
{
DeviceUpdateColors(true);
}

62
Controllers/LightSaltController/RGBController_LightSalt.h Normal file
View file

@ -0,0 +1,62 @@
/*---------------------------------------------------------*\
| RGBController_LightSalt.h |
| |
| RGBController for LightSalt Peripherals |
| |
| James Buren (braewoods) 23 Jul 2024 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-only |
\*---------------------------------------------------------*/
#pragma once
#include "RGBController.h"
#include "LightSaltController.h"
class RGBController_LightSalt : public RGBController
{
public:
~RGBController_LightSalt();
void SetupData(LightSaltController* controller_ptr);
void SetupModes();
void SetupZones();
void ResizeZone(int zone, int new_size);
void DeviceUpdateColors(bool save);
void DeviceUpdateLEDs();
void UpdateZoneLEDs(int zone);
void UpdateSingleLED(int led);
void DeviceUpdateMode();
void DeviceSaveMode();
protected:
struct
{
struct
{
std::string name;
int type;
} device;
struct
{
int sets;
int rows;
int columns;
int count;
char const * const * names;
const int* indices;
const int* deflections;
} led;
struct
{
unsigned int height;
unsigned int width;
unsigned int* matrix;
} map;
} table;
LightSaltController* controller;
};

207
Controllers/LightSaltController/RGBController_LightSaltKeyboard.cpp Normal file
View file

@ -0,0 +1,207 @@
/*---------------------------------------------------------*\
| RGBController_LightSaltKeyboard.cpp |
| |
| RGBController for LightSalt Keyboard |
| |
| James Buren (braewoods) 23 Jul 2024 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-only |
\*---------------------------------------------------------*/
#include "RGBControllerKeyNames.h"
#include "RGBController_LightSaltKeyboard.h"
// 0xFFFFFFFF indicates an unused entry in matrix
#define NA 0xFFFFFFFF
enum
{
LED_SETS = 4,
LED_ROWS = 9,
LED_COLUMNS = 10,
LED_COUNT = 83,
MAP_HEIGHT = 6,
MAP_WIDTH = 15,
};
static char const * const led_names[LED_COUNT] =
{
/* Row 1 */
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,
/* Row 2 */
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_DELETE,
/* Row 3 */
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_PRINT_SCREEN,
/* Row 4 */
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,
/* Row 5 */
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,
/* Row 6 */
KEY_EN_LEFT_CONTROL,
KEY_EN_LEFT_WINDOWS,
KEY_EN_LEFT_ALT,
KEY_EN_SPACE,
KEY_EN_SPACE,
KEY_EN_SPACE,
KEY_EN_SPACE,
KEY_EN_SPACE,
KEY_EN_RIGHT_ALT,
KEY_EN_RIGHT_FUNCTION,
KEY_EN_RIGHT_CONTROL,
KEY_EN_LEFT_ARROW,
KEY_EN_DOWN_ARROW,
KEY_EN_RIGHT_ARROW
};
static const int led_indices[LED_COUNT] =
{
/* Row 1 */
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
/* Row 2 */
15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
/* Row 3 */
30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
/* Row 4 */
45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
/* Row 5 */
60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 73,
/* Row 6 */
75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 87, 88, 89
};
static const int led_deflections[LED_COUNT] =
{
/* Row 1 */
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
/* Row 2 */
0xA, 0xA, 0xA, 0xA, 0xA, 0xA, 0xA, 0xA, 0xA, 0xA, 0xA, 0xA, 0xA, 0x0, 0x0,
/* Row 3 */
0x0, 0x6, 0x6, 0x6, 0x6, 0x6, 0x6, 0x6, 0x6, 0x6, 0x6, 0xA, 0xA, 0xA, 0x0,
/* Row 4 */
0x0, 0x6, 0x6, 0x6, 0x6, 0x6, 0x6, 0x6, 0x6, 0x6, 0xA, 0xA, 0x0,
/* Row 5 */
0x0, 0x6, 0x6, 0x6, 0x6, 0x6, 0x6, 0x6, 0xA, 0xA, 0xA, 0x0, 0x0,
/* Row 6 */
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0
};
static const unsigned int matrix_map[MAP_HEIGHT][MAP_WIDTH] =
{
/* Row 1 */
{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, NA, NA },
/* Row 2 */
{ 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27 },
/* Row 3 */
{ 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42 },
/* Row 4 */
{ 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, NA, NA },
/* Row 5 */
{ 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, NA, 68, NA },
/* Row 6 */
{ 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, NA, 80, 81, 82 }
};
RGBController_LightSaltKeyboard::RGBController_LightSaltKeyboard(LightSaltController* controller_ptr)
{
table.device.name = "Keyboard";
table.device.type = DEVICE_TYPE_KEYBOARD;
table.led.sets = LED_SETS;
table.led.rows = LED_ROWS;
table.led.columns = LED_COLUMNS;
table.led.count = LED_COUNT;
table.led.names = led_names;
table.led.indices = led_indices;
table.led.deflections = led_deflections;
table.map.height = MAP_HEIGHT;
table.map.width = MAP_WIDTH;
table.map.matrix = (unsigned int *)matrix_map;
SetupData(controller_ptr);
SetupModes();
SetupZones();
}

20
Controllers/LightSaltController/RGBController_LightSaltKeyboard.h Normal file
View file

@ -0,0 +1,20 @@
/*---------------------------------------------------------*\
| RGBController_LightSaltKeyboard.h |
| |
| RGBController for LightSalt Keyboard |
| |
| James Buren (braewoods) 23 Jul 2024 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-only |
\*---------------------------------------------------------*/
#pragma once
#include "RGBController_LightSalt.h"
class RGBController_LightSaltKeyboard : public RGBController_LightSalt
{
public:
RGBController_LightSaltKeyboard(LightSaltController* controller_ptr);
};

131
Controllers/LightSaltController/RGBController_LightSaltKeypad.cpp Normal file
View file

@ -0,0 +1,131 @@
/*---------------------------------------------------------*\
| RGBController_LightSaltKeypad.cpp |
| |
| RGBController for LightSalt Keypad |
| |
| James Buren (braewoods) 23 Jul 2024 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-only |
\*---------------------------------------------------------*/
#include "RGBControllerKeyNames.h"
#include "RGBController_LightSaltKeypad.h"
// 0xFFFFFFFF indicates an unused entry in matrix
#define NA 0xFFFFFFFF
enum
{
LED_SETS = 1,
LED_ROWS = 5,
LED_COLUMNS = 10,
LED_COUNT = 18,
MAP_HEIGHT = 5,
MAP_WIDTH = 4
};
static char const * const led_names[LED_COUNT] =
{
/* Row 1 */
KEY_EN_TAB,
KEY_EN_NUMPAD_DIVIDE,
KEY_EN_NUMPAD_TIMES,
KEY_EN_BACKSPACE,
/* Row 2 */
KEY_EN_NUMPAD_7,
KEY_EN_NUMPAD_8,
KEY_EN_NUMPAD_9,
KEY_EN_NUMPAD_MINUS,
/* Row 3 */
KEY_EN_NUMPAD_4,
KEY_EN_NUMPAD_5,
KEY_EN_NUMPAD_6,
KEY_EN_PLUS,
/* Row 4 */
KEY_EN_NUMPAD_1,
KEY_EN_NUMPAD_2,
KEY_EN_NUMPAD_3,
/* Row 5 */
KEY_EN_NUMPAD_0,
KEY_EN_NUMPAD_PERIOD,
KEY_EN_NUMPAD_ENTER
};
static const int led_indices[LED_COUNT] =
{
/* Row 1 */
0, 1, 2, 3,
/* Row 2 */
4, 5, 6, 7,
/* Row 3 */
8, 9, 10, 11,
/* Row 4 */
12, 13, 14,
/* Row 5 */
16, 17, 18
};
static const int led_deflections[LED_COUNT] =
{
/* Row 1 */
0x0, 0x0, 0x0, 0x0,
/* Row 2 */
0x0, 0x0, 0x0, 0x0,
/* Row 3 */
0x0, 0x0, 0x0, 0x0,
/* Row 4 */
0x0, 0x0, 0x0,
/* Row 5 */
0x0, 0x0, 0x0
};
static const unsigned int matrix_map[MAP_HEIGHT][MAP_WIDTH] =
{
/* Row 1 */
{ 0, 1 , 2, 3},
/* Row 2 */
{ 4, 5, 6, 7},
/* Row 3 */
{ 8, 9, 10, 11},
/* Row 4 */
{12, 13, 14, NA},
/* Row 5 */
{15, NA, 16, 17}
};
RGBController_LightSaltKeypad::RGBController_LightSaltKeypad(LightSaltController* controller_ptr)
{
table.device.name = "Keypad";
table.device.type = DEVICE_TYPE_KEYPAD;
table.led.sets = LED_SETS;
table.led.rows = LED_ROWS;
table.led.columns = LED_COLUMNS;
table.led.count = LED_COUNT;
table.led.names = led_names;
table.led.indices = led_indices;
table.led.deflections = led_deflections;
table.map.height = MAP_HEIGHT;
table.map.width = MAP_WIDTH;
table.map.matrix = (unsigned int *)matrix_map;
SetupData(controller_ptr);
SetupModes();
SetupZones();
}

20
Controllers/LightSaltController/RGBController_LightSaltKeypad.h Normal file
View file

@ -0,0 +1,20 @@
/*---------------------------------------------------------*\
| RGBController_LightSaltKeypad.h |
| |
| RGBController for LightSalt Keypad |
| |
| James Buren (braewoods) 23 Jul 2024 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-only |
\*---------------------------------------------------------*/
#pragma once
#include "RGBController_LightSalt.h"
class RGBController_LightSaltKeypad : public RGBController_LightSalt
{
public:
RGBController_LightSaltKeypad(LightSaltController* controller_ptr);
};