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/LIFXController/LIFXController.cpp
+480
View File
@@ -0,0 +1,480 @@
/*---------------------------------------------------------*\
| LIFXController.cpp |
| |
| Driver for LIFX |
| |
| Adam Honse (calcprogrammer1@gmail.com) 05 Feb 2022 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include "LIFXController.h"
#include <nlohmann/json.hpp>
#include "hsv.h"
using json = nlohmann::json;
using namespace std::chrono_literals;
LIFXController::LIFXController(std::string ip, std::string name, bool multizone, bool extended_multizone)
{
this->name = name;
zone_count = 1;
this->multizone = multizone;
this->extended_multizone = extended_multizone;
/*-----------------------------------------------------------------*\
| Fill in location string with device's IP address |
\*-----------------------------------------------------------------*/
location = "IP: " + ip;
/*-----------------------------------------------------------------*\
| Open a UDP client sending to the device's IP, port 56700 |
\*-----------------------------------------------------------------*/
port.udp_client(ip.c_str(), LIFX_UDP_PORT);
}
LIFXController::~LIFXController()
{
}
std::string LIFXController::GetLocation()
{
return(location);
}
std::string LIFXController::GetName()
{
return(name);
}
std::string LIFXController::GetVersion()
{
return(module_name + " " + firmware_version);
}
std::string LIFXController::GetManufacturer()
{
return(LIFX_MANUFACTURER);
}
std::string LIFXController::GetUniqueID()
{
return(module_mac);
}
unsigned int LIFXController::GetZoneCount()
{
return(zone_count);
}
void LIFXController::SetColors(std::vector<RGBColor> colors)
{
/*-------------------------*\
| Non-multizone lifx device |
\*-------------------------*/
if(!multizone)
{
SetColor(colors[0]);
return;
}
/*-------------------------------------------*\
| Multizone lifx device with extended support |
\*-------------------------------------------*/
if(extended_multizone)
{
SetZoneColors(colors);
return;
}
/*----------------------------------------------*\
| Multizone lifx device without extended support |
\*----------------------------------------------*/
for(size_t i = 0; i < zone_count; i++)
{
/*-----------------------------------------------------------------*\
| Utilize caching to avoid setting all zones when 1 zone is changed |
\*-----------------------------------------------------------------*/
if(cached_colors[i] == colors[i])
{
continue;
}
SetZoneColor(colors[i], (unsigned int)i);
cached_colors[i] = colors[i];
}
}
void LIFXController::FetchZoneCount()
{
if(!multizone)
{
return;
}
/*---------------------------*\
| Send get color zones packet |
\*---------------------------*/
data_buf_size = LIFX_PACKET_HEADER_LENGTH + LIFX_GET_COLOR_ZONES_PACKET_LENGTH;
data = new unsigned char[data_buf_size];
memset(data, 0, data_buf_size);
HeaderPacketSetDefaults(LIFX_PACKET_TYPE_GET_COLOR_ZONES);
GetColorZonesPacketSetStartIndex(0);
GetColorZonesPacketSetEndIndex(0);
port.udp_write((char*)data, (int)data_buf_size);
delete[] data;
/*----------------------------*\
| Listen for state zone packet |
\*----------------------------*/
data_buf_size = LIFX_PACKET_HEADER_LENGTH + LIFX_STATE_ZONE_PACKET_LENGTH;
data = new unsigned char[data_buf_size];
memset(data, 0, data_buf_size);
port.set_receive_timeout(5, 0);
port.udp_listen((char*)data, (int)data_buf_size);
/*-----------------*\
| Validate response |
\*-----------------*/
if(HeaderPacketGetSize() != data_buf_size || HeaderPacketGetProtocol() != LIFX_PROTOCOL || HeaderPacketGetPacketType() != LIFX_PACKET_TYPE_STATE_ZONE)
{
return;
}
zone_count = StateZonePacketGetZonesCount();
delete[] data;
}
void LIFXController::SetColor(RGBColor color)
{
/*---------------------*\
| Send set color packet |
\*---------------------*/
data_buf_size = LIFX_PACKET_HEADER_LENGTH + LIFX_SET_COLOR_PACKET_LENGTH;
data = new unsigned char[data_buf_size];
memset(data, 0, data_buf_size);
HeaderPacketSetDefaults(LIFX_PACKET_TYPE_SET_COLOR);
hsbk_t hsbk;
RGBColorToHSBK(color, &hsbk);
SetColorPacketSetHSBK(&hsbk);
SetColorPacketSetDuration(0);
port.udp_write((char*)data, (int)data_buf_size);
delete[] data;
}
void LIFXController::SetZoneColor(RGBColor color, unsigned int zone)
{
/*---------------------------*\
| Send set color zones packet |
\*---------------------------*/
data_buf_size = LIFX_PACKET_HEADER_LENGTH + LIFX_SET_COLOR_ZONES_PACKET_LENGTH;
data = new unsigned char[data_buf_size];
memset(data, 0, data_buf_size);
HeaderPacketSetDefaults(LIFX_PACKET_TYPE_SET_COLOR_ZONES);
SetColorZonesPacketSetStartIndex(zone);
SetColorZonesPacketSetEndIndex(zone);
hsbk_t hsbk;
RGBColorToHSBK(color, &hsbk);
SetColorZonesPacketSetHSBK(&hsbk);
SetColorZonesPacketSetDuration(0);
SetColorZonesPacketSetApply(LIFX_MULTIZONE_APPLICATION_REQUEST_APPLY);
port.udp_write((char*)data, (int)data_buf_size);
delete[] data;
}
void LIFXController::SetZoneColors(std::vector<RGBColor> colors)
{
/*------------------------------------*\
| Send set extended color zones packet |
\*------------------------------------*/
data_buf_size = LIFX_PACKET_HEADER_LENGTH + LIFX_SET_EXTENDED_COLOR_ZONES_PACKET_LENGTH;
data = new unsigned char[data_buf_size];
memset(data, 0, data_buf_size);
HeaderPacketSetDefaults(LIFX_PACKET_TYPE_SET_EXTENDED_COLOR_ZONES);
SetExtendedColorZonesPacketSetDuration(0);
SetExtendedColorZonesPacketSetApply(LIFX_MULTIZONE_APPLICATION_REQUEST_APPLY);
SetExtendedColorZonesPacketSetZoneIndex(0);
SetExtendedColorZonesPacketSetColors(colors);
port.udp_write((char*)data, (int)data_buf_size);
delete[] data;
}
void LIFXController::RGBColorToHSBK(RGBColor color, hsbk_t* hsbk)
{
hsv_t hsv;
rgb2hsv(color, &hsv);
hsbk->hue = hsv.hue * (USHRT_MAX/360);
hsbk->saturation = hsv.saturation * (USHRT_MAX/256);
hsbk->brightness = hsv.value * (USHRT_MAX/256);
hsbk->kelvin = DEFAULT_KELVIN;
}
/*----------------------------*\
| Header packet helper methods |
\*----------------------------*/
void LIFXController::HeaderPacketSetDefaults(unsigned short packet_type)
{
/*-----*\
| Frame |
\*-----*/
HeaderPacketSetSize((unsigned short)data_buf_size);
HeaderPacketSetProtocol();
HeaderPacketSetAddressable(true);
HeaderPacketSetTagged(false);
HeaderPacketSetOrigin(0);
HeaderPacketSetSource(2);
/*-------------*\
| Frame address |
\*-------------*/
unsigned char target[TARGET_LENGTH] = {0};
HeaderPacketSetTarget(target);
HeaderPacketSetResponseRequired(false);
HeaderPacketSetAcknowledgeRequired(false);
HeaderPacketSetSequence(++sequence);
/*---------------*\
| Protocol header |
\*---------------*/
HeaderPacketSetPacketType(packet_type);
}
unsigned short LIFXController::HeaderPacketGetSize()
{
return data[LIFX_HEADER_PACKET_OFFSET_SIZE];
}
void LIFXController::HeaderPacketSetSize(unsigned short size)
{
memcpy(&data[LIFX_HEADER_PACKET_OFFSET_SIZE], &size, sizeof(unsigned short));
}
unsigned short LIFXController::HeaderPacketGetProtocol()
{
unsigned short protocol;
memcpy(&protocol, &data[LIFX_HEADER_PACKET_OFFSET_PROTOCOL], sizeof(unsigned short));
return protocol & 0x0FFF;
}
void LIFXController::HeaderPacketSetProtocol(unsigned short protocol)
{
data[LIFX_HEADER_PACKET_OFFSET_PROTOCOL] = protocol & 0xFF;
unsigned char current = data[LIFX_HEADER_PACKET_OFFSET_ADDRESSABLE_TAGGED_ORIGIN];
data[LIFX_HEADER_PACKET_OFFSET_ADDRESSABLE_TAGGED_ORIGIN] = (current & 0xF0) | ((protocol >> 8) & 0x0F);
}
void LIFXController::HeaderPacketSetAddressable(bool addressable)
{
if(addressable)
{
data[LIFX_HEADER_PACKET_OFFSET_ADDRESSABLE_TAGGED_ORIGIN] |= 0x10;
}
else
{
data[LIFX_HEADER_PACKET_OFFSET_ADDRESSABLE_TAGGED_ORIGIN] &= ~0x10;
}
}
void LIFXController::HeaderPacketSetTagged(bool tagged)
{
if(tagged)
{
data[LIFX_HEADER_PACKET_OFFSET_ADDRESSABLE_TAGGED_ORIGIN] |= 0x20;
}
else
{
data[LIFX_HEADER_PACKET_OFFSET_ADDRESSABLE_TAGGED_ORIGIN] &= ~0x20;
}
}
void LIFXController::HeaderPacketSetOrigin(unsigned char origin)
{
data[LIFX_HEADER_PACKET_OFFSET_ADDRESSABLE_TAGGED_ORIGIN] =
(data[LIFX_HEADER_PACKET_OFFSET_ADDRESSABLE_TAGGED_ORIGIN] & 0xFC) | (origin & 0x03);
}
void LIFXController::HeaderPacketSetSource(unsigned int source)
{
memcpy(&data[LIFX_HEADER_PACKET_OFFSET_SOURCE], &source, sizeof(unsigned int));
}
void LIFXController::HeaderPacketSetTarget(unsigned char* target)
{
memcpy(&data[LIFX_HEADER_PACKET_OFFSET_TARGET], target, TARGET_LENGTH);
}
void LIFXController::HeaderPacketSetResponseRequired(bool response_required)
{
if(response_required)
{
data[LIFX_HEADER_PACKET_OFFSET_RESPONSE_REQUIRED_ACKNOWLEDGE_REQUIRED] |= 0x01;
}
else
{
data[LIFX_HEADER_PACKET_OFFSET_RESPONSE_REQUIRED_ACKNOWLEDGE_REQUIRED] &= ~0x01;
}
}
void LIFXController::HeaderPacketSetAcknowledgeRequired(bool acknowledge_required)
{
if(acknowledge_required)
{
data[LIFX_HEADER_PACKET_OFFSET_RESPONSE_REQUIRED_ACKNOWLEDGE_REQUIRED] |= 0x02;
}
else
{
data[LIFX_HEADER_PACKET_OFFSET_RESPONSE_REQUIRED_ACKNOWLEDGE_REQUIRED] &= ~0x02;
}
}
void LIFXController::HeaderPacketSetSequence(unsigned char sequence)
{
data[LIFX_HEADER_PACKET_OFFSET_SEQUENCE] = sequence;
}
unsigned short LIFXController::HeaderPacketGetPacketType()
{
unsigned short packet_type_value;
memcpy(&packet_type_value, &data[LIFX_HEADER_PACKET_OFFSET_PACKET_TYPE], sizeof(unsigned short));
return packet_type_value;
}
void LIFXController::HeaderPacketSetPacketType(unsigned short packet_type)
{
memcpy(&data[LIFX_HEADER_PACKET_OFFSET_PACKET_TYPE], &packet_type, sizeof(unsigned short));
}
/*-------------------------------*\
| Set color packet helper methods |
\*-------------------------------*/
void LIFXController::SetColorPacketSetHSBK(hsbk_t* hsbk)
{
memcpy(&data[LIFX_SET_COLOR_PACKET_OFFSET_HUE], &hsbk->hue, sizeof(unsigned short));
memcpy(&data[LIFX_SET_COLOR_PACKET_OFFSET_SATURATION], &hsbk->saturation, sizeof(unsigned short));
memcpy(&data[LIFX_SET_COLOR_PACKET_OFFSET_BRIGHTNESS], &hsbk->brightness, sizeof(unsigned short));
memcpy(&data[LIFX_SET_COLOR_PACKET_OFFSET_KELVIN], &hsbk->kelvin, sizeof(unsigned short));
}
void LIFXController::SetColorPacketSetDuration(unsigned int duration)
{
memcpy(&data[LIFX_SET_COLOR_PACKET_OFFSET_DURATION], &duration, sizeof(unsigned int));
}
/*-------------------------------------*\
| Set color zones packet helper methods |
\*-------------------------------------*/
void LIFXController::SetColorZonesPacketSetStartIndex(unsigned char start_index)
{
memcpy(&data[LIFX_SET_COLOR_ZONES_PACKET_OFFSET_START_INDEX], &start_index, sizeof(unsigned char));
}
void LIFXController::SetColorZonesPacketSetEndIndex(unsigned char end_index)
{
memcpy(&data[LIFX_SET_COLOR_ZONES_PACKET_OFFSET_END_INDEX], &end_index, sizeof(unsigned char));
}
void LIFXController::SetColorZonesPacketSetHSBK(hsbk_t* hsbk)
{
memcpy(&data[LIFX_SET_COLOR_ZONES_PACKET_OFFSET_HUE], &hsbk->hue, sizeof(unsigned short));
memcpy(&data[LIFX_SET_COLOR_ZONES_PACKET_OFFSET_SATURATION], &hsbk->saturation, sizeof(unsigned short));
memcpy(&data[LIFX_SET_COLOR_ZONES_PACKET_OFFSET_BRIGHTNESS], &hsbk->brightness, sizeof(unsigned short));
memcpy(&data[LIFX_SET_COLOR_ZONES_PACKET_OFFSET_KELVIN], &hsbk->kelvin, sizeof(unsigned short));
}
void LIFXController::SetColorZonesPacketSetDuration(unsigned int duration)
{
memcpy(&data[LIFX_SET_COLOR_ZONES_PACKET_OFFSET_DURATION], &duration, sizeof(unsigned int));
}
void LIFXController::SetColorZonesPacketSetApply(unsigned char apply)
{
memcpy(&data[LIFX_SET_COLOR_ZONES_PACKET_OFFSET_APPLY], &apply, sizeof(unsigned char));
}
/*-------------------------------------*\
| Get color zones packet helper methods |
\*-------------------------------------*/
void LIFXController::GetColorZonesPacketSetStartIndex(unsigned char start_index)
{
memcpy(&data[LIFX_GET_COLOR_ZONES_PACKET_OFFSET_START_INDEX], &start_index, sizeof(unsigned char));
}
void LIFXController::GetColorZonesPacketSetEndIndex(unsigned char end_index)
{
memcpy(&data[LIFX_GET_COLOR_ZONES_PACKET_OFFSET_END_INDEX], &end_index, sizeof(unsigned char));
}
/*--------------------------------*\
| State zone packet helper methods |
\*--------------------------------*/
unsigned char LIFXController::StateZonePacketGetZonesCount()
{
unsigned char zones_count;
memcpy(&zones_count, &data[LIFX_STATE_ZONE_PACKET_OFFSET_ZONES_COUNT], sizeof(unsigned char));
return zones_count;
}
/*----------------------------------------------*\
| Set extended color zones packet helper methods |
\*----------------------------------------------*/
void LIFXController::SetExtendedColorZonesPacketSetDuration(unsigned int duration)
{
memcpy(&data[LIFX_SET_EXTENDED_COLOR_ZONES_PACKET_OFFSET_DURATION], &duration, sizeof(unsigned int));
}
void LIFXController::SetExtendedColorZonesPacketSetApply(unsigned char apply)
{
memcpy(&data[LIFX_SET_EXTENDED_COLOR_ZONES_PACKET_OFFSET_APPLY], &apply, sizeof(unsigned char));
}
void LIFXController::SetExtendedColorZonesPacketSetZoneIndex(unsigned short zone_index)
{
memcpy(&data[LIFX_SET_EXTENDED_COLOR_ZONES_PACKET_OFFSET_ZONE_INDEX], &zone_index, sizeof(unsigned short));
}
void LIFXController::SetExtendedColorZonesPacketSetColors(std::vector<RGBColor> colors)
{
unsigned char colors_count = (unsigned char)colors.size();
memcpy(&data[LIFX_SET_EXTENDED_COLOR_ZONES_PACKET_OFFSET_COLORS_COUNT], &colors_count, sizeof(unsigned char));
for(size_t i = 0; i < colors.size(); i++)
{
hsbk_t hsbk;
RGBColorToHSBK(colors[i], &hsbk);
size_t current_color_offset = LIFX_SET_EXTENDED_COLOR_ZONES_PACKET_OFFSET_COLORS + (i * HSBK_LENGTH);
size_t hue_offset = current_color_offset;
size_t saturation_offset = hue_offset + sizeof(unsigned short);
size_t brightness_offset = saturation_offset + sizeof(unsigned short);
size_t kelvin_offset = brightness_offset + sizeof(unsigned short);
memcpy(&data[hue_offset], &hsbk.hue, sizeof(unsigned short));
memcpy(&data[saturation_offset], &hsbk.saturation, sizeof(unsigned short));
memcpy(&data[brightness_offset], &hsbk.brightness, sizeof(unsigned short));
memcpy(&data[kelvin_offset], &hsbk.kelvin, sizeof(unsigned short));
}
}
Controllers/LIFXController/LIFXController.h
+240
View File
@@ -0,0 +1,240 @@
/*---------------------------------------------------------*\
| LIFXController.h |
| |
| Driver for LIFX |
| |
| Adam Honse (calcprogrammer1@gmail.com) 05 Feb 2022 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#pragma once
#include <string>
#include <vector>
#include <climits>
#include "RGBController.h"
#include "net_port.h"
#define LIFX_MANUFACTURER "LIFX"
#define LIFX_UDP_PORT "56700"
#define LIFX_PROTOCOL 1024
#define TARGET_LENGTH 8
#define DEFAULT_KELVIN 3500
#define HSBK_LENGTH 8
/*---------------------*\
| Packet size constants |
\*---------------------*/
#define LIFX_PACKET_HEADER_LENGTH 36
#define LIFX_SET_COLOR_PACKET_LENGTH 13
#define LIFX_SET_COLOR_ZONES_PACKET_LENGTH 15
#define LIFX_GET_COLOR_ZONES_PACKET_LENGTH 2
#define LIFX_STATE_ZONE_PACKET_LENGTH 10
#define LIFX_SET_EXTENDED_COLOR_ZONES_PACKET_LENGTH 664
/*---------------------------------------------------------------------------*\
| https://lan.developer.lifx.com/docs/field-types#multizoneapplicationrequest |
\*---------------------------------------------------------------------------*/
enum
{
LIFX_MULTIZONE_APPLICATION_REQUEST_NO_APPLY = 0,
LIFX_MULTIZONE_APPLICATION_REQUEST_APPLY = 1,
LIFX_MULTIZONE_APPLICATION_REQUEST_APPLY_ONLY = 2
};
/*----------------------------------------------------------------*\
| https://lan.developer.lifx.com/docs/representing-color-with-hsbk |
\*----------------------------------------------------------------*/
typedef struct
{
unsigned short hue; /* 0-360 value normalized to 0-65535 */
unsigned short saturation; /* 0-1 value normalized to 0-65535 */
unsigned short brightness; /* 0-1 value normalized to 0-65535 */
unsigned short kelvin; /* 0-65535 value */
/* Note: Devices may only support a subset of the full range. */
} hsbk_t;
/*-----------------*\
| LIFX packet types |
\*-----------------*/
enum
{
LIFX_PACKET_TYPE_SET_COLOR = 102,
LIFX_PACKET_TYPE_SET_COLOR_ZONES = 501,
LIFX_PACKET_TYPE_GET_COLOR_ZONES = 502,
LIFX_PACKET_TYPE_STATE_ZONE = 503,
LIFX_PACKET_TYPE_SET_EXTENDED_COLOR_ZONES = 510
};
/*-----------------------------------------------------*\
| LIFX header packet offsets |
| https://lan.developer.lifx.com/docs/encoding-a-packet |
\*-----------------------------------------------------*/
enum
{
LIFX_HEADER_PACKET_OFFSET_SIZE = 0, /* 2 bytes, size of the entire message in bytes */
LIFX_HEADER_PACKET_OFFSET_PROTOCOL = 2, /* Protocol number, must be 1024 */
LIFX_HEADER_PACKET_OFFSET_ADDRESSABLE_TAGGED_ORIGIN = 3, /* Bits 0-3 are part of Protocol */
/* Bit 4, addressable flag */
/* Bit 5, tagged flag */
/* Bit 6/7, origin value */
LIFX_HEADER_PACKET_OFFSET_SOURCE = 4, /* Source identifier, unique value set by client */
LIFX_HEADER_PACKET_OFFSET_TARGET = 8, /* 6 byte device address (MAC) or zero */
/* Last two bytes should be 0 */
LIFX_HEADER_PACKET_OFFSET_RESPONSE_REQUIRED_ACKNOWLEDGE_REQUIRED = 22, /* Bit 0, res_required flag */
/* Bit 1, ack_required flag */
LIFX_HEADER_PACKET_OFFSET_SEQUENCE = 23, /* Wrap around message sequence number */
LIFX_HEADER_PACKET_OFFSET_PACKET_TYPE = 32 /* Message type determines the payload used */
};
/*---------------------------------------------------------------------------*\
| LIFX set color packet offsets |
| https://lan.developer.lifx.com/docs/changing-a-device#setcolor---packet-102 |
\*---------------------------------------------------------------------------*/
enum
{
/* 1 byte, reserved */
LIFX_SET_COLOR_PACKET_OFFSET_HUE = LIFX_PACKET_HEADER_LENGTH + 1, /* 2 bytes, hue as a 0-65535 value */
LIFX_SET_COLOR_PACKET_OFFSET_SATURATION = LIFX_PACKET_HEADER_LENGTH + 3, /* 2 bytes, saturation as a 0-65535 value */
LIFX_SET_COLOR_PACKET_OFFSET_BRIGHTNESS = LIFX_PACKET_HEADER_LENGTH + 5, /* 2 bytes, brightness as a 0-65535 value */
LIFX_SET_COLOR_PACKET_OFFSET_KELVIN = LIFX_PACKET_HEADER_LENGTH + 7, /* 2 bytes, kelvin as a 0-65535 value. */
/* Note: The actual max for this is device specific */
LIFX_SET_COLOR_PACKET_OFFSET_DURATION = LIFX_PACKET_HEADER_LENGTH + 9, /* 4 bytes, transition time in ms */
};
/*--------------------------------------------------------------------------------*\
| LIFX set color zones packet offsets |
| https://lan.developer.lifx.com/docs/changing-a-device#setcolorzones---packet-501 |
\*--------------------------------------------------------------------------------*/
enum
{
LIFX_SET_COLOR_ZONES_PACKET_OFFSET_START_INDEX = LIFX_PACKET_HEADER_LENGTH + 0, /* 1 byte, the first zone in the segment we are changing */
LIFX_SET_COLOR_ZONES_PACKET_OFFSET_END_INDEX = LIFX_PACKET_HEADER_LENGTH + 1, /* 1 byte, the last zone in the segment we are changing */
LIFX_SET_COLOR_ZONES_PACKET_OFFSET_HUE = LIFX_PACKET_HEADER_LENGTH + 2, /* 2 bytes, hue as a 0-65535 value */
LIFX_SET_COLOR_ZONES_PACKET_OFFSET_SATURATION = LIFX_PACKET_HEADER_LENGTH + 4, /* 2 bytes, saturation as a 0-65535 value */
LIFX_SET_COLOR_ZONES_PACKET_OFFSET_BRIGHTNESS = LIFX_PACKET_HEADER_LENGTH + 6, /* 2 bytes, brightness as a 0-65535 value */
LIFX_SET_COLOR_ZONES_PACKET_OFFSET_KELVIN = LIFX_PACKET_HEADER_LENGTH + 8, /* 2 bytes, kelvin as a 0-65535 value. */
/* Note: The actual max for this is device specific */
LIFX_SET_COLOR_ZONES_PACKET_OFFSET_DURATION = LIFX_PACKET_HEADER_LENGTH + 10, /* 4 bytes, transition time in ms */
LIFX_SET_COLOR_ZONES_PACKET_OFFSET_APPLY = LIFX_PACKET_HEADER_LENGTH + 14 /* 1 byte, multizone application request */
};
/*-------------------------------------------------------------------------------------------*\
| LIFX get color zones packet offsets |
| https://lan.developer.lifx.com/docs/querying-the-device-for-data#getcolorzones---packet-502 |
\*-------------------------------------------------------------------------------------------*/
enum
{
LIFX_GET_COLOR_ZONES_PACKET_OFFSET_START_INDEX = LIFX_PACKET_HEADER_LENGTH + 0, /* 1 byte, The first zone you want to get information from */
LIFX_GET_COLOR_ZONES_PACKET_OFFSET_END_INDEX = LIFX_PACKET_HEADER_LENGTH + 1, /* 1 byte, The second zone you want to get information from */
};
/*-------------------------------------------------------------------------------*\
| LIFX state zone packet offsets |
| https://lan.developer.lifx.com/docs/information-messages#statezone---packet-503 |
\*-------------------------------------------------------------------------------*/
enum
{
LIFX_STATE_ZONE_PACKET_OFFSET_ZONES_COUNT = LIFX_PACKET_HEADER_LENGTH + 0, /* 1 byte, the total number of zones on the strip. */
LIFX_STATE_ZONE_PACKET_OFFSET_ZONE_INDEX = LIFX_PACKET_HEADER_LENGTH + 1, /* 1 byte, the zone this packet refers to. */
LIFX_STATE_ZONE_PACKET_OFFSET_HUE = LIFX_PACKET_HEADER_LENGTH + 2, /* 2 bytes, hue as a 0-65535 value */
LIFX_STATE_ZONE_PACKET_OFFSET_SATURATION = LIFX_PACKET_HEADER_LENGTH + 4, /* 2 bytes, saturation as a 0-65535 value */
LIFX_STATE_ZONE_PACKET_OFFSET_BRIGHTNESS = LIFX_PACKET_HEADER_LENGTH + 6, /* 2 bytes, brightness as a 0-65535 value */
LIFX_STATE_ZONE_PACKET_OFFSET_KELVIN = LIFX_PACKET_HEADER_LENGTH + 8, /* 2 bytes, kelvin as a 0-65535 value. */
/* Note: The actual max for this is device specific */
};
/*----------------------------------------------------------------------------------------*\
| LIFX set extended color zones packet offsets |
| https://lan.developer.lifx.com/docs/changing-a-device#setextendedcolorzones---packet-510 |
\*----------------------------------------------------------------------------------------*/
enum
{
LIFX_SET_EXTENDED_COLOR_ZONES_PACKET_OFFSET_DURATION = LIFX_PACKET_HEADER_LENGTH + 0, /* 4 bytes, transition time in ms */
LIFX_SET_EXTENDED_COLOR_ZONES_PACKET_OFFSET_APPLY = LIFX_PACKET_HEADER_LENGTH + 4, /* 1 byte, multizone application request */
LIFX_SET_EXTENDED_COLOR_ZONES_PACKET_OFFSET_ZONE_INDEX = LIFX_PACKET_HEADER_LENGTH + 5, /* 2 bytes, The first zone to apply colors from. */
/* If the light has more than 82 zones, then */
/* send multiple messages with different indices */
/* to update the whole device. */
LIFX_SET_EXTENDED_COLOR_ZONES_PACKET_OFFSET_COLORS_COUNT = LIFX_PACKET_HEADER_LENGTH + 7, /* 1 byte, The number of colors in the colors field */
LIFX_SET_EXTENDED_COLOR_ZONES_PACKET_OFFSET_COLORS = LIFX_PACKET_HEADER_LENGTH + 8, /* 656 bytes (82 * 4 * 2), 82 HSBK values to change */
/* the device with */
};
class LIFXController
{
public:
LIFXController(std::string ip, std::string name, bool multizone, bool extended_multizone);
~LIFXController();
std::string GetLocation();
std::string GetName();
std::string GetVersion();
std::string GetManufacturer();
std::string GetUniqueID();
unsigned int GetZoneCount();
void FetchZoneCount();
void SetColors(std::vector<RGBColor> colors);
private:
RGBColor cached_colors[UCHAR_MAX];
unsigned int zone_count;
size_t data_buf_size;
unsigned char* data;
unsigned char sequence;
std::string name;
std::string firmware_version;
std::string module_name;
std::string module_mac;
std::string location;
net_port port;
bool multizone;
bool extended_multizone;
void SetColor(RGBColor color);
void SetZoneColor(RGBColor color, unsigned int zone);
void SetZoneColors(std::vector<RGBColor> colors);
void RGBColorToHSBK(RGBColor color, hsbk_t* hsbk);
/*---------------------*\
| Packet helper methods |
\*---------------------*/
void HeaderPacketSetDefaults(unsigned short packet_type);
unsigned short HeaderPacketGetSize();
void HeaderPacketSetSize(unsigned short size);
unsigned short HeaderPacketGetProtocol();
void HeaderPacketSetProtocol(unsigned short protocol=LIFX_PROTOCOL);
void HeaderPacketSetAddressable(bool addressable=true);
void HeaderPacketSetTagged(bool tagged=false);
void HeaderPacketSetOrigin(unsigned char origin=0);
void HeaderPacketSetSource(unsigned int source=2);
void HeaderPacketSetTarget(unsigned char* target);
void HeaderPacketSetResponseRequired(bool response_required=false);
void HeaderPacketSetAcknowledgeRequired(bool acknowledge_required=false);
void HeaderPacketSetSequence(unsigned char sequence);
unsigned short HeaderPacketGetPacketType();
void HeaderPacketSetPacketType(unsigned short packet_type);
void SetColorPacketSetDuration(unsigned int duration=0);
void SetColorPacketSetHSBK(hsbk_t* hsbk);
void SetColorZonesPacketSetStartIndex(unsigned char start_index);
void SetColorZonesPacketSetEndIndex(unsigned char end_index);
void SetColorZonesPacketSetHSBK(hsbk_t* hsbk);
void SetColorZonesPacketSetDuration(unsigned int duration=0);
void SetColorZonesPacketSetApply(unsigned char apply=LIFX_MULTIZONE_APPLICATION_REQUEST_APPLY);
void GetColorZonesPacketSetStartIndex(unsigned char start_index=0);
void GetColorZonesPacketSetEndIndex(unsigned char end_index=0);
unsigned char StateZonePacketGetZonesCount();
void SetExtendedColorZonesPacketSetDuration(unsigned int duration=0);
void SetExtendedColorZonesPacketSetApply(unsigned char apply=LIFX_MULTIZONE_APPLICATION_REQUEST_APPLY);
void SetExtendedColorZonesPacketSetZoneIndex(unsigned short zone_index=0);
void SetExtendedColorZonesPacketSetColors(std::vector<RGBColor> colors);
};
Controllers/LIFXController/LIFXControllerDetect.cpp
+60
View File
@@ -0,0 +1,60 @@
/*---------------------------------------------------------*\
| LIFXControllerDetect.cpp |
| |
| Detector for LIFX |
| |
| Adam Honse (calcprogrammer1@gmail.com) 05 Feb 2022 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include "Detector.h"
#include "LIFXController.h"
#include "RGBController_LIFX.h"
#include "SettingsManager.h"
/******************************************************************************************\
* *
* DetectLIFXControllers *
* *
* Detect LIFX devices *
* *
\******************************************************************************************/
void DetectLIFXControllers()
{
json lifx_settings;
/*-------------------------------------------------*\
| Get LIFX settings from settings manager |
\*-------------------------------------------------*/
lifx_settings = ResourceManager::get()->GetSettingsManager()->GetSettings("LIFXDevices");
/*-------------------------------------------------*\
| If the Wiz settings contains devices, process |
\*-------------------------------------------------*/
if(lifx_settings.contains("devices"))
{
for(unsigned int device_idx = 0; device_idx < lifx_settings["devices"].size(); device_idx++)
{
if(lifx_settings["devices"][device_idx].contains("ip"))
{
std::string lifx_ip = lifx_settings["devices"][device_idx]["ip"];
std::string name = lifx_settings["devices"][device_idx]["name"];
bool multizone = lifx_settings["devices"][device_idx]["multizone"];
bool extended_multizone = lifx_settings["devices"][device_idx]["extended_multizone"];
LIFXController* controller = new LIFXController(lifx_ip, name, multizone, extended_multizone);
controller->FetchZoneCount();
RGBController_LIFX* rgb_controller = new RGBController_LIFX(controller);
ResourceManager::get()->RegisterRGBController(rgb_controller);
}
}
}
} /* DetectLIFXControllers() */
REGISTER_DETECTOR("LIFX", DetectLIFXControllers);
Controllers/LIFXController/RGBController_LIFX.cpp
+132
View File
@@ -0,0 +1,132 @@
/*---------------------------------------------------------*\
| RGBController_LIFX.cpp |
| |
| RGBController for LIFX |
| |
| Adam Honse (calcprogrammer1@gmail.com) 05 Feb 2022 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include "RGBController_LIFX.h"
/**------------------------------------------------------------------*\
@name LIFX Globes
@category Light
@type USB
@save :x:
@direct :white_check_mark:
@effects :x:
@detectors DetectLIFXControllers
@comment
\*-------------------------------------------------------------------*/
RGBController_LIFX::RGBController_LIFX(LIFXController* controller_ptr)
{
controller = controller_ptr;
name = controller->GetManufacturer() + " " + controller->GetName();
vendor = controller->GetManufacturer();
type = DEVICE_TYPE_LIGHT;
version = controller->GetVersion();
description = "LIFX Device";
serial = controller->GetUniqueID();
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_LIFX::~RGBController_LIFX()
{
delete controller;
}
void RGBController_LIFX::SetupZones()
{
zone led_zone;
unsigned int zone_count = controller->GetZoneCount();
/*---------------------------------------------------------*\
| If there is only one zone, set up a single LED |
\*---------------------------------------------------------*/
if(zone_count <= 1)
{
led_zone.name = "RGB Light";
led_zone.type = ZONE_TYPE_SINGLE;
led_zone.leds_min = 1;
led_zone.leds_max = 1;
led_zone.leds_count = 1;
led_zone.matrix_map = NULL;
zones.push_back(led_zone);
led new_led;
new_led.name = "RGB Light";
leds.push_back(new_led);
}
else
{
/*---------------------------------------------------------*\
| Set up multiple LEDs |
\*---------------------------------------------------------*/
led_zone.name = "RGB Light Strip";
led_zone.type = ZONE_TYPE_LINEAR;
led_zone.leds_min = 1;
led_zone.leds_max = zone_count;
led_zone.leds_count = zone_count;
led_zone.matrix_map = NULL;
zones.push_back(led_zone);
for(size_t zone_idx = 0; zone_idx < zone_count; zone_idx++)
{
/*---------------------------------------------------------*\
| Set up LEDs |
\*---------------------------------------------------------*/
led new_led;
new_led.name = "LED " + std::to_string(zone_idx);
leds.push_back(new_led);
}
}
SetupColors();
}
void RGBController_LIFX::ResizeZone(int /*zone*/, int /*new_size*/)
{
/*---------------------------------------------------------*\
| This device does not support resizing zones |
\*---------------------------------------------------------*/
}
void RGBController_LIFX::DeviceUpdateLEDs()
{
controller->SetColors(colors);
}
void RGBController_LIFX::UpdateZoneLEDs(int /*zone*/)
{
DeviceUpdateLEDs();
}
void RGBController_LIFX::UpdateSingleLED(int /*led*/)
{
DeviceUpdateLEDs();
}
void RGBController_LIFX::DeviceUpdateMode()
{
}
Controllers/LIFXController/RGBController_LIFX.h
+35
View File
@@ -0,0 +1,35 @@
/*---------------------------------------------------------*\
| RGBController_LIFX.cpp |
| |
| RGBController for LIFX |
| |
| Adam Honse (calcprogrammer1@gmail.com) 05 Feb 2022 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#pragma once
#include "RGBController.h"
#include "LIFXController.h"
class RGBController_LIFX : public RGBController
{
public:
RGBController_LIFX(LIFXController* controller_ptr);
~RGBController_LIFX();
void SetupZones();
void ResizeZone(int zone, int new_size);
void DeviceUpdateLEDs();
void UpdateZoneLEDs(int zone);
void UpdateSingleLED(int led);
void DeviceUpdateMode();
private:
LIFXController* controller;
};