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/LEDStripController/LEDStripController.cpp
+415
View File
@@ -0,0 +1,415 @@
/*---------------------------------------------------------*\
| LEDStripController.cpp |
| |
| Driver for serial LED strips |
| |
| Adam Honse (calcprogrammer1@gmail.com) 11 Dec 2016 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include <fstream>
#include <iostream>
#include <string>
#include "LEDStripController.h"
#include "ResourceManager.h"
LEDStripController::LEDStripController(std::string dev_name)
{
name = dev_name;
}
LEDStripController::~LEDStripController()
{
}
void LEDStripController::Initialize(char* ledstring, led_protocol proto)
{
LPSTR numleds = NULL;
LPSTR source = NULL;
LPSTR udpport_baud = NULL;
LPSTR next = NULL;
//Set the protocol
protocol = proto;
//Assume serial device unless a different protocol is specified
bool serial = TRUE;
//Default i2c address out of range
i2c_addr = 255;
source = strtok_s(ledstring, ",", &next);
//Check if we are setting up a Keyboard Visualizer UDP protocol device
if (strncmp(source, "udp:", 4) == 0)
{
source = source + 4;
serial = FALSE;
}
//Check for either the UDP port or the serial baud rate
if (strlen(next))
{
udpport_baud = strtok_s(next, ",", &next);
}
//Check for the number of LEDs
if (strlen(next))
{
numleds = strtok_s(next, ",", &next);
}
if (serial)
{
if (protocol == LED_PROTOCOL_BASIC_I2C)
{
//I2C uses the baud field for address
i2c_addr = atoi(udpport_baud);
InitializeI2C(source);
}
else if (udpport_baud == NULL)
{
//Initialize with default baud rate
InitializeSerial(source, 115200);
}
else
{
//Initialize with custom baud rate
InitializeSerial(source, atoi(udpport_baud));
}
}
else
{
if (udpport_baud == NULL)
{
//Do something
}
else
{
//Initialize UDP port
InitializeUDP(source, udpport_baud);
}
}
if (numleds != NULL && strlen(numleds))
{
num_leds = atoi(numleds);
}
}
void LEDStripController::InitializeI2C(char* i2cname)
{
for(unsigned int i2c_idx = 0; i2c_idx < ResourceManager::get()->GetI2CBusses().size(); i2c_idx++)
{
if(ResourceManager::get()->GetI2CBusses()[i2c_idx]->device_name == std::string(i2cname))
{
if(i2c_addr < 128)
{
i2cport = ResourceManager::get()->GetI2CBusses()[i2c_idx];
break;
}
}
}
serialport = NULL;
udpport = NULL;
}
void LEDStripController::InitializeSerial(char* portname, int baud)
{
portname = strtok(portname, "\r");
port_name = portname;
baud_rate = baud;
serialport = new serial_port(port_name.c_str(), baud_rate);
udpport = NULL;
i2cport = NULL;
}
void LEDStripController::InitializeUDP(char * clientname, char * port)
{
client_name = clientname;
port_name = port;
udpport = new net_port(client_name.c_str(), port_name.c_str());
serialport = NULL;
i2cport = NULL;
}
char* LEDStripController::GetLEDString()
{
return(led_string);
}
std::string LEDStripController::GetLocation()
{
if(serialport != NULL)
{
return("COM: " + port_name);
}
else if(udpport != NULL)
{
return("UDP: " + client_name + ":" + port_name);
}
else if(i2cport != NULL)
{
return("I2C: " + std::string(i2cport->device_name) + ", Address " + std::to_string(i2c_addr));
}
else
{
return("");
}
}
std::string LEDStripController::GetName()
{
return(name);
}
void LEDStripController::SetLEDs(std::vector<RGBColor> colors)
{
switch(protocol)
{
case LED_PROTOCOL_KEYBOARD_VISUALIZER:
SetLEDsKeyboardVisualizer(colors);
break;
case LED_PROTOCOL_ADALIGHT:
SetLEDsAdalight(colors);
break;
case LED_PROTOCOL_TPM2:
SetLEDsTPM2(colors);
break;
case LED_PROTOCOL_BASIC_I2C:
SetLEDsBasicI2C(colors);
break;
}
}
void LEDStripController::SetLEDsKeyboardVisualizer(std::vector<RGBColor> colors)
{
unsigned char *serial_buf;
/*-------------------------------------------------------------*\
| Keyboard Visualizer Arduino Protocol |
| |
| Packet size: Number of data bytes + 3 |
| |
| 0: Packet Start Byte (0xAA) |
| 1-n: Data bytes |
| n+1: Checksum MSB |
| n+2: Checksum LSB |
\*-------------------------------------------------------------*/
unsigned int payload_size = (unsigned int)(colors.size() * 3);
unsigned int packet_size = payload_size + 3;
serial_buf = new unsigned char[packet_size];
/*-------------------------------------------------------------*\
| Set up header |
\*-------------------------------------------------------------*/
serial_buf[0x00] = 0xAA;
/*-------------------------------------------------------------*\
| Copy in color data in RGB order |
\*-------------------------------------------------------------*/
for(unsigned int color_idx = 0; color_idx < colors.size(); color_idx++)
{
unsigned int color_offset = color_idx * 3;
serial_buf[0x01 + color_offset] = RGBGetRValue(colors[color_idx]);
serial_buf[0x02 + color_offset] = RGBGetGValue(colors[color_idx]);
serial_buf[0x03 + color_offset] = RGBGetBValue(colors[color_idx]);
}
/*-------------------------------------------------------------*\
| Calculate the checksum |
\*-------------------------------------------------------------*/
unsigned short sum = 0;
for(unsigned int i = 0; i < (payload_size + 1); i++)
{
sum += serial_buf[i];
}
/*-------------------------------------------------------------*\
| Fill in the checksum bytes |
\*-------------------------------------------------------------*/
serial_buf[(num_leds * 3) + 1] = sum >> 8;
serial_buf[(num_leds * 3) + 2] = sum & 0x00FF;
/*-------------------------------------------------------------*\
| Send the packet |
\*-------------------------------------------------------------*/
if (serialport != NULL)
{
serialport->serial_write((char *)serial_buf, packet_size);
}
else if (udpport != NULL)
{
udpport->udp_write((char *)serial_buf, packet_size);
}
delete[] serial_buf;
}
void LEDStripController::SetLEDsAdalight(std::vector<RGBColor> colors)
{
unsigned char *serial_buf;
/*-------------------------------------------------------------*\
| Adalight Protocol |
| |
| Packet size: Number of data bytes + 6 |
| |
| 0: 'A' (0x41) |
| 1: 'd' (0x64) |
| 2: 'a' (0x61) |
| 3: LED count MSB |
| 4: LED count LSB |
| 5: Checksum (MSB xor LSB xor 0x55) |
| 6-n: Data Bytes |
\*-------------------------------------------------------------*/
unsigned int led_count = (unsigned int)colors.size();
unsigned int payload_size = (led_count * 3);
unsigned int packet_size = payload_size + 6;
serial_buf = new unsigned char[packet_size];
/*-------------------------------------------------------------*\
| Set up header |
\*-------------------------------------------------------------*/
serial_buf[0x00] = 0x41;
serial_buf[0x01] = 0x64;
serial_buf[0x02] = 0x61;
serial_buf[0x03] = (led_count >> 8);
serial_buf[0x04] = (led_count & 0xFF);
serial_buf[0x05] = (serial_buf[0x03] ^ serial_buf[0x04] ^ 0x55);
/*-------------------------------------------------------------*\
| Copy in color data in RGB order |
\*-------------------------------------------------------------*/
for(unsigned int color_idx = 0; color_idx < led_count; color_idx++)
{
unsigned int color_offset = color_idx * 3;
serial_buf[0x06 + color_offset] = RGBGetRValue(colors[color_idx]);
serial_buf[0x07 + color_offset] = RGBGetGValue(colors[color_idx]);
serial_buf[0x08 + color_offset] = RGBGetBValue(colors[color_idx]);
}
/*-------------------------------------------------------------*\
| Send the packet |
\*-------------------------------------------------------------*/
if (serialport != NULL)
{
serialport->serial_write((char *)serial_buf, packet_size);
}
delete[] serial_buf;
}
void LEDStripController::SetLEDsTPM2(std::vector<RGBColor> colors)
{
unsigned char *serial_buf;
/*-------------------------------------------------------------*\
| TPM2 Protocol |
| |
| Packet size: Number of data bytes + 5 |
| |
| 0: Packet Start Byte (0xC9) |
| 1: Packet Type (0xDA - Data, 0xC0 - Command, 0xAA - Read) |
| 2: Payload Size MSB |
| 3: Payload Size LSB |
| 4-n: Data Bytes |
| n+1: Packet End Byte (0x36) |
\*-------------------------------------------------------------*/
unsigned int payload_size = (unsigned int)(colors.size() * 3);
unsigned int packet_size = payload_size + 5;
serial_buf = new unsigned char[packet_size];
/*-------------------------------------------------------------*\
| Set up header and end byte |
\*-------------------------------------------------------------*/
serial_buf[0x00] = 0xC9;
serial_buf[0x01] = 0xDA;
serial_buf[0x02] = (payload_size >> 8);
serial_buf[0x03] = (payload_size & 0xFF);
serial_buf[packet_size - 1] = 0x36;
/*-------------------------------------------------------------*\
| Copy in color data in RGB order |
\*-------------------------------------------------------------*/
for(unsigned int color_idx = 0; color_idx < colors.size(); color_idx++)
{
unsigned int color_offset = color_idx * 3;
serial_buf[0x04 + color_offset] = RGBGetRValue(colors[color_idx]);
serial_buf[0x05 + color_offset] = RGBGetGValue(colors[color_idx]);
serial_buf[0x06 + color_offset] = RGBGetBValue(colors[color_idx]);
}
/*-------------------------------------------------------------*\
| Send the packet |
\*-------------------------------------------------------------*/
if (serialport != NULL)
{
serialport->serial_write((char *)serial_buf, packet_size);
}
delete[] serial_buf;
}
void LEDStripController::SetLEDsBasicI2C(std::vector<RGBColor> colors)
{
unsigned char serial_buf[30];
/*-------------------------------------------------------------*\
| Basic I2C Protocol |
| |
| Packet size: At most 32 bytes (SMBus block size) |
| |
| Packet is in RGBRGBRGB... format, also provide start index |
\*-------------------------------------------------------------*/
unsigned char index = 0;
unsigned char offset = 0;
for(unsigned int color_idx = 0; color_idx < colors.size(); color_idx++)
{
serial_buf[index + 0] = RGBGetRValue(colors[color_idx]);
serial_buf[index + 1] = RGBGetGValue(colors[color_idx]);
serial_buf[index + 2] = RGBGetBValue(colors[color_idx]);
index += 3;
if(index >= 30)
{
if(i2cport != NULL)
{
i2cport->i2c_smbus_write_i2c_block_data(i2c_addr, offset, 30, serial_buf);
offset += 30;
index = 0;
}
}
}
if(index > 0)
{
if(i2cport != NULL)
{
i2cport->i2c_smbus_write_i2c_block_data(i2c_addr, offset, index, serial_buf);
}
}
if(i2cport != NULL)
{
i2cport->i2c_smbus_write_byte(i2c_addr, 0xFF);
}
}
Controllers/LEDStripController/LEDStripController.h
+86
View File
@@ -0,0 +1,86 @@
/*---------------------------------------------------------*\
| LEDStripController.h |
| |
| Driver for serial LED strips |
| |
| Adam Honse (calcprogrammer1@gmail.com) Dec 11 2016 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#pragma once
#include <vector>
#include "RGBController.h"
#include "i2c_smbus.h"
#include "serial_port.h"
#include "net_port.h"
#ifndef TRUE
#define TRUE true
#define FALSE false
#endif
#ifndef WIN32
#define LPSTR char *
#define strtok_s strtok_r
#endif
typedef unsigned int led_protocol;
enum
{
LED_PROTOCOL_KEYBOARD_VISUALIZER,
LED_PROTOCOL_ADALIGHT,
LED_PROTOCOL_TPM2,
LED_PROTOCOL_BASIC_I2C
};
struct LEDStripDevice
{
std::string name;
std::string port;
unsigned int baud = 0;
unsigned int num_leds = 0;
led_protocol protocol;
};
class LEDStripController
{
public:
LEDStripController(std::string dev_name);
~LEDStripController();
void Initialize(char* ledstring, led_protocol proto);
void InitializeI2C(char* i2cname);
void InitializeSerial(char* portname, int baud);
void InitializeUDP(char* clientname, char* port);
char* GetLEDString();
std::string GetLocation();
std::string GetName();
void SetLEDs(std::vector<RGBColor> colors);
void SetLEDsKeyboardVisualizer(std::vector<RGBColor> colors);
void SetLEDsAdalight(std::vector<RGBColor> colors);
void SetLEDsTPM2(std::vector<RGBColor> colors);
void SetLEDsBasicI2C(std::vector<RGBColor> colors);
int num_leds;
private:
int baud_rate;
char led_string[1024];
std::string port_name;
std::string client_name;
std::string name;
serial_port *serialport;
net_port *udpport;
i2c_smbus_interface *i2cport;
unsigned char i2c_addr;
led_protocol protocol;
};
Controllers/LEDStripController/LEDStripControllerDetect.cpp
+135
View File
@@ -0,0 +1,135 @@
/*---------------------------------------------------------*\
| LEDStripControllerDetect.cpp |
| |
| Detector for serial LED strips |
| |
| Adam Honse (calcprogrammer1@gmail.com) 11 Dec 2016 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include "Detector.h"
#include "LEDStripController.h"
#include "RGBController_LEDStrip.h"
#include "SettingsManager.h"
#include "LogManager.h"
/******************************************************************************************\
* *
* DetectLEDStripControllers *
* *
* Detect devices supported by the LEDStrip driver *
* *
\******************************************************************************************/
void DetectLEDStripControllers()
{
json ledstrip_settings;
LEDStripDevice dev;
/*-------------------------------------------------*\
| Get LED Strip settings from settings manager |
\*-------------------------------------------------*/
ledstrip_settings = ResourceManager::get()->GetSettingsManager()->GetSettings("LEDStripDevices");
/*-------------------------------------------------*\
| If the LEDStrip settings contains devices, process|
\*-------------------------------------------------*/
if(ledstrip_settings.contains("devices"))
{
for(unsigned int device_idx = 0; device_idx < ledstrip_settings["devices"].size(); device_idx++)
{
if(ledstrip_settings["devices"][device_idx].contains("name"))
{
dev.name = ledstrip_settings["devices"][device_idx]["name"];
}
else
{
/*-------------------------------------------------*\
| Default name |
\*-------------------------------------------------*/
dev.name = "LED Strip";
}
if(ledstrip_settings["devices"][device_idx].contains("port"))
{
dev.port = ledstrip_settings["devices"][device_idx]["port"];
}
if(ledstrip_settings["devices"][device_idx].contains("baud"))
{
dev.baud = ledstrip_settings["devices"][device_idx]["baud"];
}
if(ledstrip_settings["devices"][device_idx].contains("num_leds"))
{
dev.num_leds = ledstrip_settings["devices"][device_idx]["num_leds"];
}
if(ledstrip_settings["devices"][device_idx].contains("protocol"))
{
std::string protocol_string = ledstrip_settings["devices"][device_idx]["protocol"];
if(protocol_string == "keyboard_visualizer")
{
dev.protocol = LED_PROTOCOL_KEYBOARD_VISUALIZER;
}
else if(protocol_string == "adalight")
{
dev.protocol = LED_PROTOCOL_ADALIGHT;
}
else if(protocol_string == "tpm2")
{
dev.protocol = LED_PROTOCOL_TPM2;
}
else if(protocol_string == "basic_i2c")
{
dev.protocol = LED_PROTOCOL_BASIC_I2C;
}
else
{
LOG_WARNING("[LEDStripController] '%s' is not a valid value for protocol", protocol_string.c_str());
return;
}
}
else
{
/*-------------------------------------------------*\
| Default to the Keyboard Visualizer protocol |
\*-------------------------------------------------*/
dev.protocol = LED_PROTOCOL_KEYBOARD_VISUALIZER;
}
if(dev.port.empty())
{
LOG_WARNING("[LEDStripController] port value cannot be left empty.");
return;
}
if(dev.baud <= 0)
{
LOG_WARNING("[LEDStripController] baud value cannot be left empty.");
return;
}
if(dev.num_leds <= 0)
{
LOG_WARNING("[LEDStripController] num_leds value cannot be left empty.");
return;
}
std::string value = dev.port + "," + std::to_string(dev.baud) + "," + std::to_string(dev.num_leds);
LEDStripController* controller = new LEDStripController(dev.name);
controller->Initialize((char *)value.c_str(), dev.protocol);
RGBController_LEDStrip* rgb_controller = new RGBController_LEDStrip(controller);
ResourceManager::get()->RegisterRGBController(rgb_controller);
}
}
} /* DetectLEDStripControllers() */
REGISTER_DETECTOR("LED Strip", DetectLEDStripControllers);
Controllers/LEDStripController/RGBController_LEDStrip.cpp
+97
View File
@@ -0,0 +1,97 @@
/*---------------------------------------------------------*\
| RGBController_LEDStrip.cpp |
| |
| RGBController for serial LED strips |
| |
| Adam Honse (calcprogrammer1@gmail.com) 20 Jun 2019 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include "RGBController_LEDStrip.h"
/**------------------------------------------------------------------*\
@name Serial LED Strip
@category LEDStrip
@type Serial
@save :x:
@direct :white_check_mark:
@effects :x:
@detectors DetectLEDStripControllers
@comment
\*-------------------------------------------------------------------*/
RGBController_LEDStrip::RGBController_LEDStrip(LEDStripController* controller_ptr)
{
controller = controller_ptr;
name = controller->GetName();
type = DEVICE_TYPE_LEDSTRIP;
description = "Serial LED Strip Device";
location = controller->GetLocation();
mode Direct;
Direct.name = "Direct";
Direct.value = 0;
Direct.flags = MODE_FLAG_HAS_PER_LED_COLOR;
Direct.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Direct);
SetupZones();
}
RGBController_LEDStrip::~RGBController_LEDStrip()
{
delete controller;
}
void RGBController_LEDStrip::SetupZones()
{
zone led_zone;
led_zone.name = "LED Strip";
led_zone.type = ZONE_TYPE_LINEAR;
led_zone.leds_min = controller->num_leds;
led_zone.leds_max = controller->num_leds;
led_zone.leds_count = controller->num_leds;
led_zone.matrix_map = NULL;
zones.push_back(led_zone);
for(int led_idx = 0; led_idx < controller->num_leds; led_idx++)
{
led new_led;
new_led.name = "LED ";
new_led.name.append(std::to_string(led_idx));
leds.push_back(new_led);
}
SetupColors();
}
void RGBController_LEDStrip::ResizeZone(int /*zone*/, int /*new_size*/)
{
/*---------------------------------------------------------*\
| This device does not support resizing zones |
\*---------------------------------------------------------*/
}
void RGBController_LEDStrip::DeviceUpdateLEDs()
{
controller->SetLEDs(colors);
}
void RGBController_LEDStrip::UpdateZoneLEDs(int /*zone*/)
{
controller->SetLEDs(colors);
}
void RGBController_LEDStrip::UpdateSingleLED(int /*led*/)
{
controller->SetLEDs(colors);
}
void RGBController_LEDStrip::DeviceUpdateMode()
{
}
Controllers/LEDStripController/RGBController_LEDStrip.h
+36
View File
@@ -0,0 +1,36 @@
/*---------------------------------------------------------*\
| RGBController_LEDStrip.h |
| |
| RGBController for serial LED strips |
| |
| Adam Honse (calcprogrammer1@gmail.com) 20 Jun 2019 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#pragma once
#include "RGBController.h"
#include "serial_port.h"
#include "LEDStripController.h"
class RGBController_LEDStrip : public RGBController
{
public:
RGBController_LEDStrip(LEDStripController* controller_ptr);
~RGBController_LEDStrip();
void SetupZones();
void ResizeZone(int zone, int new_size);
void DeviceUpdateLEDs();
void UpdateZoneLEDs(int zone);
void UpdateSingleLED(int led);
void DeviceUpdateMode();
private:
LEDStripController* controller;
};