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/NollieController/NollieController.cpp
+192
View File
@@ -0,0 +1,192 @@
/*---------------------------------------------------------*\
| NollieController.cpp |
| |
| Driver for Nollie |
| |
| Name (cnn1236661) 25 Jun 2023 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include <cstring>
#include "NollieController.h"
#include "StringUtils.h"
using namespace std::chrono_literals;
NollieController::NollieController(hid_device* dev_handle, const char* path, unsigned short vid, unsigned short pid, std::string dev_name)
{
dev = dev_handle;
location = path;
name = dev_name;
usb_vid = vid;
usb_pid = pid;
}
std::string NollieController::GetLocationString()
{
return("HID: " + location);
}
std::string NollieController::GetNameString()
{
return(name);
}
std::string NollieController::GetSerialString()
{
wchar_t serial_string[128];
int ret = hid_get_serial_number_string(dev, serial_string, 128);
if(ret != 0)
{
return("");
}
return(StringUtils::wstring_to_string(serial_string));
}
unsigned short NollieController::GetUSBPID()
{
return(usb_pid);
}
unsigned short NollieController::GetUSBVID()
{
return(usb_vid);
}
void NollieController::InitChLEDs(int *led_num_list,int ch_num)
{
unsigned char usb_buf[65];
memset(usb_buf, 0x00, sizeof(usb_buf));
usb_buf[1] = 0xFE;
usb_buf[2] = 0x03;
for(int i = 0; i < ch_num; i++)
{
usb_buf[3+(i*2)] = led_num_list[i]& 0xFF;
usb_buf[4+(i*2)] = (led_num_list[i] >> 8) & 0xFF;
}
hid_write(dev, usb_buf, 65);
}
void NollieController::SetMos(bool mos)
{
unsigned char usb_buf[65];
memset(usb_buf, 0x00, sizeof(usb_buf));
usb_buf[0x01] = 0x80;
usb_buf[0x02] = mos;
hid_write(dev, usb_buf, 65);
}
void NollieController::SetChannelLEDs(unsigned char channel, RGBColor* colors, unsigned int num_colors)
{
if(usb_pid == NOLLIE32_PID || usb_pid == NOLLIE16_PID || usb_pid == NOLLIE32_OS21_PID || usb_pid == NOLLIE16_OS21_PID)
{
SendPacket(channel,&colors[0], num_colors);
}
else
{
unsigned int num_packets = (num_colors / 21) + ((num_colors % 21) > 0);
unsigned int color_idx = 0;
for(unsigned int packet_idx = 0; packet_idx < num_packets; packet_idx++)
{
unsigned int colors_in_packet = 21;
if(num_colors - color_idx < colors_in_packet)
{
colors_in_packet = num_colors - color_idx;
}
SendPacketFS(channel,packet_idx,&colors[color_idx], colors_in_packet);
color_idx += colors_in_packet;
}
}
}
void NollieController::SendUpdate()
{
unsigned char usb_buf[65] ;
memset(usb_buf, 0x00, sizeof(usb_buf));
usb_buf[1] = 0xff;
hid_write(dev, usb_buf, 65);
}
void NollieController::SendPacket(unsigned char channel,RGBColor* colors,unsigned int num_colors)
{
unsigned char usb_buf[1025];
memset(usb_buf, 0x00, sizeof(usb_buf));
usb_buf[1] = channel;
usb_buf[2] = 0;
usb_buf[3] = num_colors / 256;
usb_buf[4] = num_colors % 256;
if(num_colors)
{
for(unsigned int color_idx = 0; color_idx < num_colors; color_idx++)
{
usb_buf[0x05 + (color_idx * 3)] = RGBGetGValue(colors[color_idx]);
usb_buf[0x06 + (color_idx * 3)] = RGBGetRValue(colors[color_idx]);
usb_buf[0x07 + (color_idx * 3)] = RGBGetBValue(colors[color_idx]);
}
}
/*-----------------------------------------------------*\
| Send packet |
\*-----------------------------------------------------*/
if(channel == NOLLIE32_FLAG1_CHANNEL)
{
usb_buf[2] = 1;
hid_write(dev, usb_buf, 1025);
std::this_thread::sleep_for(std::chrono::milliseconds(8));
}
else if(channel == NOLLIE32_FLAG2_CHANNEL)
{
usb_buf[2] = 2;
hid_write(dev, usb_buf, 1025);
std::this_thread::sleep_for(std::chrono::milliseconds(8));
}
else
{
hid_write(dev, usb_buf, 1025);
}
}
void NollieController::SendPacketFS(unsigned char channel,unsigned char packet_id,RGBColor* colors,unsigned int num_colors)
{
unsigned char usb_buf[65];
unsigned int packet_interval;
unsigned int dev_pid = GetUSBPID();
switch(dev_pid)
{
case NOLLIE28_12_PID:
packet_interval = 2;
break;
case NOLLIE8_PID:
case NOLLIE8_OS21_PID:
case PRISM8_OS21_PID:
packet_interval = 6;
break;
case NOLLIE1_PID:
case NOLLIE1_OS21_PID:
packet_interval = 30;
break;
default:
packet_interval = 25;
break;
}
memset(usb_buf, 0x00, sizeof(usb_buf));
usb_buf[0x00] = 0x00;
usb_buf[0x01] = packet_id + channel * packet_interval;
for(unsigned int color_idx = 0; color_idx < num_colors; color_idx++)
{
usb_buf[0x02 + (color_idx * 3)] = RGBGetRValue(colors[color_idx]);
usb_buf[0x03 + (color_idx * 3)] = RGBGetGValue(colors[color_idx]);
usb_buf[0x04 + (color_idx * 3)] = RGBGetBValue(colors[color_idx]);
if(dev_pid == NOLLIE8_PID || dev_pid == NOLLIE1_PID || dev_pid == NOLLIE8_OS21_PID || dev_pid == PRISM8_OS21_PID || dev_pid == NOLLIE1_OS21_PID)
{
usb_buf[0x02 + (color_idx * 3)] = RGBGetGValue(colors[color_idx]);
usb_buf[0x03 + (color_idx * 3)] = RGBGetRValue(colors[color_idx]);
}
}
hid_write(dev, usb_buf, 65);
}
Controllers/NollieController/NollieController.h
+84
View File
@@ -0,0 +1,84 @@
/*---------------------------------------------------------*\
| NollieController.h |
| |
| Driver for Nollie |
| |
| Name (cnn1236661) 25 Jun 2023 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#pragma once
#include <chrono>
#include <vector>
#include <hidapi.h>
#include "RGBController.h"
#define NOLLIE_12_CH_LED_NUM 42
#define NOLLIE_8_CH_LED_NUM 126
#define NOLLIE_1_CH_LED_NUM 630
#define NOLLIE_HS_CH_LED_NUM 256
#define NOLLIE_FS_CH_LED_NUM 525
#define NOLLIERGBOS_2_VID 0x16D5
#define NOLLIE32_CHANNELS_NUM 32
#define NOLLIE32_PID 0x4714
#define NOLLIE32_OS21_PID 0x2A32
#define NOLLIE32_VID 0x3061
#define NOLLIE16_CHANNELS_NUM 16
#define NOLLIE16_PID 0x4716
#define NOLLIE16_OS21_PID 0x2A16
#define NOLLIE16_VID 0x3061
#define NOLLIE8_CHANNELS_NUM 8
#define NOLLIE8_PID 0x1F01
#define NOLLIE8_OS21_PID 0x2A08
#define PRISM8_OS21_PID 0x2C08
#define NOLLIE8_VID 0x16D2
#define NOLLIE1_CHANNELS_NUM 1
#define NOLLIE1_PID 0x1F11
#define NOLLIE1_OS21_PID 0x2A01
#define NOLLIE1_VID 0x16D2
#define NOLLIE28_12_CHANNELS_NUM 12
#define NOLLIE28_12_VID 0x16D2
#define NOLLIE28_12_PID 0x1616
#define NOLLIE28_L1_PID 0x1617
#define NOLLIE28_L2_PID 0x1618
#define NOLLIE32_MOS_TRIGGER_CH 26
#define NOLLIE32_MOS_TRIGGER_LED 20
#define NOLLIE32_FLAG1_CHANNEL 15
#define NOLLIE32_FLAG2_CHANNEL 31
class NollieController
{
public:
NollieController(hid_device* dev_handle, const char* path, unsigned short vid, unsigned short pid, std::string dev_name);
std::string GetLocationString();
std::string GetNameString();
std::string GetSerialString();
unsigned short GetUSBVID();
unsigned short GetUSBPID();
void SetMos(bool mos);
void InitChLEDs(int *led_num_list,int ch_num);
void SendUpdate();
void SetChannelLEDs(unsigned char channel, RGBColor * colors, unsigned int num_colors);
private:
hid_device* dev;
std::string location;
std::string name;
unsigned short usb_vid;
unsigned short usb_pid;
void SendPacket(unsigned char channel,RGBColor * colors,unsigned int num_colors);
void SendPacketFS(unsigned char channel,unsigned char packet_id,RGBColor * colors,unsigned int num_colors);
};
Controllers/NollieController/NollieControllerDetect.cpp
+64
View File
@@ -0,0 +1,64 @@
/*---------------------------------------------------------*\
| NollieControllerDetect.cpp |
| |
| Detector for Nollie |
| |
| Name (cnn1236661) 25 Jun 2023 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include <hidapi.h>
#include "Detector.h"
#include "NollieController.h"
#include "RGBController_Nollie.h"
void DetectNollieControllers(hid_device_info* info, const std::string& name)
{
if((info->product_id == NOLLIE1_OS21_PID || info->product_id == NOLLIE8_OS21_PID || info->product_id == PRISM8_OS21_PID)
&& info->interface_number != 2)
{
return;
}
if((info->product_id == NOLLIE16_OS21_PID || info->product_id == NOLLIE32_OS21_PID)
&& info->interface_number != 0)
{
return;
}
hid_device* dev = hid_open_path(info->path);
if(dev)
{
wchar_t product[128];
hid_get_product_string(dev, product, 128);
std::wstring product_str(product);
NollieController* controller = new NollieController(dev, info->path, info->vendor_id, info->product_id, name);
RGBController_Nollie* rgb_controller = new RGBController_Nollie(controller);
ResourceManager::get()->RegisterRGBController(rgb_controller);
}
}
REGISTER_HID_DETECTOR("Nollie 32CH", DetectNollieControllers, NOLLIE32_VID, NOLLIE32_PID);
REGISTER_HID_DETECTOR("Nollie 16CH", DetectNollieControllers, NOLLIE16_VID, NOLLIE16_PID);
REGISTER_HID_DETECTOR("Nollie 8CH", DetectNollieControllers, NOLLIE8_VID, NOLLIE8_PID);
REGISTER_HID_DETECTOR("Nollie 1CH", DetectNollieControllers, NOLLIE1_VID, NOLLIE1_PID);
REGISTER_HID_DETECTOR("Nollie 32_OS2.1", DetectNollieControllers, NOLLIERGBOS_2_VID, NOLLIE32_OS21_PID);
REGISTER_HID_DETECTOR("Nollie 16_OS2.1", DetectNollieControllers, NOLLIERGBOS_2_VID, NOLLIE16_OS21_PID);
REGISTER_HID_DETECTOR("Nollie 8_OS2.1", DetectNollieControllers, NOLLIERGBOS_2_VID, NOLLIE8_OS21_PID);
REGISTER_HID_DETECTOR("Prism 8_OS2.1", DetectNollieControllers, NOLLIERGBOS_2_VID, PRISM8_OS21_PID);
REGISTER_HID_DETECTOR("Nollie 1_OS2.1", DetectNollieControllers, NOLLIERGBOS_2_VID, NOLLIE1_OS21_PID);
REGISTER_HID_DETECTOR("Nollie 28 12", DetectNollieControllers, NOLLIE28_12_VID, NOLLIE28_12_PID);
REGISTER_HID_DETECTOR("Nollie 28 L1", DetectNollieControllers, NOLLIE28_12_VID, NOLLIE28_L1_PID);
REGISTER_HID_DETECTOR("Nollie 28 L2", DetectNollieControllers, NOLLIE28_12_VID, NOLLIE28_L2_PID);
//Nollie OS2 Firmware
REGISTER_HID_DETECTOR("Nollie 32_OS2", DetectNollieControllers, NOLLIERGBOS_2_VID, NOLLIE32_PID);
REGISTER_HID_DETECTOR("Nollie 16_OS2", DetectNollieControllers, NOLLIERGBOS_2_VID, NOLLIE16_PID);
REGISTER_HID_DETECTOR("Nollie 8_OS2", DetectNollieControllers, NOLLIERGBOS_2_VID, NOLLIE8_PID);
REGISTER_HID_DETECTOR("Nollie 1_OS2", DetectNollieControllers, NOLLIERGBOS_2_VID, NOLLIE1_PID);
Controllers/NollieController/RGBController_Nollie.cpp
+251
View File
@@ -0,0 +1,251 @@
/*---------------------------------------------------------*\
| RGBController_Nollie.cpp |
| |
| RGBController for Nollie |
| |
| Name (cnn1236661) 25 Jun 2023 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include <algorithm>
#include <iostream>
#include "RGBController_Nollie.h"
/**------------------------------------------------------------------*\
@name Nollie Controller
@category LEDStrip
@type USB
@save :x:
@direct :white_check_mark:
@effects :x:
@detectors DetectNollieControllers
@comment
\*-------------------------------------------------------------------*/
RGBController_Nollie::RGBController_Nollie(NollieController* controller_ptr)
{
controller = controller_ptr;
name = controller->GetNameString();
vendor = "Nollie";
description = "Nollie Controller Device";
type = DEVICE_TYPE_LEDSTRIP;
location = controller->GetLocationString();
serial = controller->GetSerialString();
mode Direct;
Direct.name = "Direct";
Direct.value = 0xFFFF;
Direct.flags = MODE_FLAG_HAS_PER_LED_COLOR;
Direct.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Direct);
SetupZones();
}
RGBController_Nollie::~RGBController_Nollie()
{
delete controller;
}
void RGBController_Nollie::SetupZones()
{
bool first_run = false;
unsigned int channels_num = 0;
unsigned int ch_led_num = 0;
if(zones.size() == 0)
{
first_run = true;
}
leds.clear();
colors.clear();
switch(controller->GetUSBPID())
{
case NOLLIE32_PID:
case NOLLIE32_OS21_PID:
channels_num = NOLLIE32_CHANNELS_NUM;
ch_led_num = NOLLIE_HS_CH_LED_NUM;
channel_index = ch32;
break;
case NOLLIE16_PID:
case NOLLIE16_OS21_PID:
channels_num = NOLLIE16_CHANNELS_NUM;
ch_led_num = NOLLIE_HS_CH_LED_NUM;
channel_index = ch16;
if (controller->GetUSBVID() == NOLLIERGBOS_2_VID)
channel_index = n16;
break;
case NOLLIE28_12_PID:
channels_num = NOLLIE28_12_CHANNELS_NUM;
ch_led_num = NOLLIE_12_CH_LED_NUM;
break;
case NOLLIE8_PID:
case NOLLIE8_OS21_PID:
case PRISM8_OS21_PID:
channels_num = NOLLIE8_CHANNELS_NUM;
ch_led_num = NOLLIE_8_CH_LED_NUM;
break;
case NOLLIE1_PID:
case NOLLIE1_OS21_PID:
channels_num = NOLLIE1_CHANNELS_NUM;
ch_led_num = NOLLIE_1_CH_LED_NUM;
break;
default:
channels_num = NOLLIE8_CHANNELS_NUM;
ch_led_num = NOLLIE_FS_CH_LED_NUM;
break;
}
zones.resize(channels_num);
for(unsigned int channel_idx = 0; channel_idx < channels_num; channel_idx++)
{
if(channel_idx > 27 )
{
char ch_idx_string[4];
snprintf(ch_idx_string, 4, "%d", channel_idx + 1 - 28);
zones[channel_idx].name = "Channel EXT ";
zones[channel_idx].name.append(ch_idx_string);
}
else if(channel_idx > 21 )
{
char ch_idx_string[4];
snprintf(ch_idx_string, 4, "%d", channel_idx + 1 - 22);
zones[channel_idx].name = "Channel GPU ";
zones[channel_idx].name.append(ch_idx_string);
}
else if(channel_idx > 15 )
{
char ch_idx_string[4];
snprintf(ch_idx_string, 4, "%d", channel_idx + 1 - 16);
zones[channel_idx].name = "Channel ATX ";
zones[channel_idx].name.append(ch_idx_string);
}
else
{
char ch_idx_string[4];
snprintf(ch_idx_string, 4, "%d", channel_idx + 1);
zones[channel_idx].name = "Channel ";
zones[channel_idx].name.append(ch_idx_string);
}
zones[channel_idx].type = ZONE_TYPE_LINEAR;
zones[channel_idx].leds_min = 0;
zones[channel_idx].leds_max = ch_led_num;
if(first_run)
{
zones[channel_idx].leds_count = 0;
}
zones[channel_idx].matrix_map = NULL;
for(unsigned int led_ch_idx = 0; led_ch_idx < zones[channel_idx].leds_count; led_ch_idx++)
{
char led_idx_string[4];
snprintf(led_idx_string, 4, "%d", led_ch_idx + 1);
led new_led;
new_led.name = "LED ";
new_led.name.append(led_idx_string);
leds.push_back(new_led);
leds_channel.push_back(channel_idx);
}
}
SetupColors();
}
void RGBController_Nollie::ResizeZone(int zone, int new_size)
{
/*-----------------------------------------------------*\
| Set whether MOS is enabled or not |
\*-----------------------------------------------------*/
if(controller->GetUSBVID() == NOLLIE32_VID && NOLLIE32_PID == controller->GetUSBPID())
{
if(zone == NOLLIE32_MOS_TRIGGER_CH && new_size > NOLLIE32_MOS_TRIGGER_LED)
{
controller->SetMos(false);
}
else if(zone == NOLLIE32_MOS_TRIGGER_CH)
{
controller->SetMos(true);
}
}
/*-----------------------------------------------------*\
| Nollie1 needs to report the number of LEDs |
\*-----------------------------------------------------*/
if(controller->GetUSBPID() == NOLLIE1_PID)
{
controller->InitChLEDs(&new_size,NOLLIE1_CHANNELS_NUM);
}
if((size_t) zone >= zones.size())
{
return;
}
if(((unsigned int)new_size >= zones[zone].leds_min) && ((unsigned int)new_size <= zones[zone].leds_max))
{
zones[zone].leds_count = new_size;
SetupZones();
}
}
void RGBController_Nollie::DeviceUpdateLEDs()
{
unsigned int DevPid = controller->GetUSBPID();
if(DevPid == NOLLIE32_PID || DevPid == NOLLIE16_PID || DevPid == NOLLIE32_OS21_PID || DevPid == NOLLIE16_OS21_PID)
{
std::vector<int> ChSort;
for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
{
unsigned int channel = channel_index[zone_idx];
if(zones[zone_idx].leds_count > 0)
{
ChSort.push_back(channel);
}
else if(channel == NOLLIE32_FLAG1_CHANNEL || channel == NOLLIE32_FLAG2_CHANNEL)
{
ChSort.push_back(channel);
}
}
std::sort(ChSort.begin(), ChSort.end());
for(std::size_t i = 0; i < ChSort.size(); i++)
{
int* ptr = std::find(channel_index, channel_index + 32, ChSort[i]);
int zone_idx = (int)(ptr - channel_index);
controller->SetChannelLEDs(ChSort[i], zones[zone_idx].colors, zones[zone_idx].leds_count);
}
}
else
{
for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
{
if(zones[zone_idx].leds_count > 0)
{
controller->SetChannelLEDs((unsigned char)zone_idx, zones[zone_idx].colors, zones[zone_idx].leds_count);
}
}
controller->SendUpdate();
}
}
void RGBController_Nollie::UpdateZoneLEDs(int zone)
{
controller->SetChannelLEDs(channel_index[zone], zones[zone].colors, zones[zone].leds_count);
}
void RGBController_Nollie::UpdateSingleLED(int led)
{
unsigned int channel = leds_channel[led];
controller->SetChannelLEDs(channel_index[channel], zones[channel].colors, zones[channel].leds_count);
}
void RGBController_Nollie::DeviceUpdateMode()
{
DeviceUpdateLEDs();
}
Controllers/NollieController/RGBController_Nollie.h
+42
View File
@@ -0,0 +1,42 @@
/*---------------------------------------------------------*\
| RGBController_Nollie.h |
| |
| RGBController for Nollie |
| |
| Name (cnn1236661) 25 Jun 2023 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#pragma once
#include "RGBController.h"
#include "NollieController.h"
class RGBController_Nollie : public RGBController
{
public:
RGBController_Nollie(NollieController* controller_ptr);
~RGBController_Nollie();
void SetupZones();
void ResizeZone(int zone, int new_size);
void DeviceUpdateLEDs();
void UpdateZoneLEDs(int zone);
void UpdateSingleLED(int led);
void DeviceUpdateMode();
private:
NollieController* controller;
std::vector<unsigned int> leds_channel;
std::vector<unsigned int> zones_channel;
int* channel_index;
int ch32[32] = {5, 4, 3, 2, 1, 0, 15, 14, 26, 27, 28, 29, 30, 31, 8, 9, 19, 18, 17, 16, 7, 6, 25, 24, 23, 22, 21, 20, 13, 12, 11, 10};
int ch16[32] = {19, 18, 17, 16, 24, 25, 26, 27, 20, 21, 22, 23, 31, 30, 29, 28, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
int n16[16] = {3, 2, 1, 0, 8, 9, 10, 11, 4, 5, 6, 7, 15, 14, 13, 12};
};