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/SapphireGPUController/SapphireNitroGlowV1Controller/RGBController_SapphireNitroGlowV1.cpp
+202
View File
@@ -0,0 +1,202 @@
/*---------------------------------------------------------*\
| RGBController_SapphireNitroGlowV1.cpp |
| |
| RGBController for Sapphire Nitro Glow V1 |
| |
| Adam Honse (CalcProgrammer1) 15 Jul 2020 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include "RGBController_SapphireNitroGlowV1.h"
/**------------------------------------------------------------------*\
@name Sapphire Nitro Glow v1
@category GPU
@type I2C
@save :x:
@direct :x:
@effects :white_check_mark:
@detectors DetectSapphireV1Controllers
@comment
\*-------------------------------------------------------------------*/
RGBController_SapphireNitroGlowV1::RGBController_SapphireNitroGlowV1(SapphireNitroGlowV1Controller* controller_ptr)
{
controller = controller_ptr;
name = controller->GetDeviceName();
vendor = "Sapphire";
description = "Sapphire Nitro Glow V1 Device";
location = controller->GetDeviceLocation();
type = DEVICE_TYPE_GPU;
mode Sapphire;
Sapphire.name = "Sapphire Blue";
Sapphire.value = SAPPHIRE_NITRO_GLOW_V1_MODE_SAPPHIRE_BLUE;
Sapphire.flags = MODE_FLAG_HAS_BRIGHTNESS;
Sapphire.color_mode = MODE_COLORS_NONE;
Sapphire.brightness_min = SAPPHITE_NITRO_GLOW_V1_BRIGHTNESS_MIN;
Sapphire.brightness_max = SAPPHITE_NITRO_GLOW_V1_BRIGHTNESS_MAX;
Sapphire.brightness = SAPPHITE_NITRO_GLOW_V1_BRIGHTNESS_MAX;
modes.push_back(Sapphire);
mode Rainbow;
Rainbow.name = "Rainbow Wave";
Rainbow.value = SAPPHIRE_NITRO_GLOW_V1_MODE_RAINBOW;
Rainbow.flags = MODE_FLAG_HAS_BRIGHTNESS;
Rainbow.color_mode = MODE_COLORS_NONE;
Rainbow.brightness_min = SAPPHITE_NITRO_GLOW_V1_BRIGHTNESS_MIN;
Rainbow.brightness_max = SAPPHITE_NITRO_GLOW_V1_BRIGHTNESS_MAX;
Rainbow.brightness = SAPPHITE_NITRO_GLOW_V1_BRIGHTNESS_MAX;
modes.push_back(Rainbow);
mode Temperature;
Temperature.name = "PCB Temperature";
Temperature.value = SAPPHIRE_NITRO_GLOW_V1_MODE_BOARD_TEMPERATURE;
Temperature.flags = MODE_FLAG_HAS_BRIGHTNESS;
Temperature.color_mode = MODE_COLORS_NONE;
Temperature.brightness_min = SAPPHITE_NITRO_GLOW_V1_BRIGHTNESS_MIN;
Temperature.brightness_max = SAPPHITE_NITRO_GLOW_V1_BRIGHTNESS_MAX;
Temperature.brightness = SAPPHITE_NITRO_GLOW_V1_BRIGHTNESS_MAX;
modes.push_back(Temperature);
mode FanSpeed;
FanSpeed.name = "Fan Speed";
FanSpeed.value = SAPPHIRE_NITRO_GLOW_V1_MODE_FAN_SPEED;
FanSpeed.flags = MODE_FLAG_HAS_BRIGHTNESS;
FanSpeed.color_mode = MODE_COLORS_NONE;
FanSpeed.brightness_min = SAPPHITE_NITRO_GLOW_V1_BRIGHTNESS_MIN;
FanSpeed.brightness_max = SAPPHITE_NITRO_GLOW_V1_BRIGHTNESS_MAX;
FanSpeed.brightness = SAPPHITE_NITRO_GLOW_V1_BRIGHTNESS_MAX;
modes.push_back(FanSpeed);
mode Static;
Static.name = "Static";
Static.value = SAPPHIRE_NITRO_GLOW_V1_MODE_CUSTOM;
Static.flags = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
Static.color_mode = MODE_COLORS_PER_LED;
Static.brightness_min = SAPPHITE_NITRO_GLOW_V1_BRIGHTNESS_MIN;
Static.brightness_max = SAPPHITE_NITRO_GLOW_V1_BRIGHTNESS_MAX;
Static.brightness = SAPPHITE_NITRO_GLOW_V1_BRIGHTNESS_MAX;
modes.push_back(Static);
mode Off;
Off.name = "Off";
Off.value = SAPPHIRE_NITRO_GLOW_V1_MODE_OFF;
Off.flags = 0;
Off.color_mode = MODE_COLORS_NONE;
modes.push_back(Off);
SetupZones();
ReadConfiguration();
}
RGBController_SapphireNitroGlowV1::~RGBController_SapphireNitroGlowV1()
{
delete controller;
}
void RGBController_SapphireNitroGlowV1::SetupZones()
{
/*---------------------------------------------------------*\
| This device only has one LED, so create a single zone and |
| LED for it |
\*---------------------------------------------------------*/
zone* new_zone = new zone();
led* new_led = new led();
new_zone->name = "GPU Zone";
new_zone->type = ZONE_TYPE_SINGLE;
new_zone->leds_min = 1;
new_zone->leds_max = 1;
new_zone->leds_count = 1;
new_zone->matrix_map = NULL;
new_led->name = "GPU LED";
/*---------------------------------------------------------*\
| Push the zone and LED on to device vectors |
\*---------------------------------------------------------*/
leds.push_back(*new_led);
zones.push_back(*new_zone);
SetupColors();
}
void RGBController_SapphireNitroGlowV1::ReadConfiguration()
{
colors[0] = ToRGBColor(
controller->GetRed(),
controller->GetGreen(),
controller->GetBlue()
);
switch(controller->GetMode())
{
case SAPPHIRE_NITRO_GLOW_V1_MODE_SAPPHIRE_BLUE:
active_mode = 0;
break;
case SAPPHIRE_NITRO_GLOW_V1_MODE_RAINBOW:
active_mode = 1;
break;
case SAPPHIRE_NITRO_GLOW_V1_MODE_BOARD_TEMPERATURE:
active_mode = 2;
break;
case SAPPHIRE_NITRO_GLOW_V1_MODE_FAN_SPEED:
active_mode = 3;
break;
case SAPPHIRE_NITRO_GLOW_V1_MODE_CUSTOM:
active_mode = 4;
break;
case SAPPHIRE_NITRO_GLOW_V1_MODE_OFF:
active_mode = 5;
break;
default:
active_mode = 0;
break;
}
modes[(unsigned int)active_mode].brightness = controller->GetBrightness();
}
void RGBController_SapphireNitroGlowV1::ResizeZone(int /*zone*/, int /*new_size*/)
{
/*---------------------------------------------------------*\
| This device does not support resizing zones |
\*---------------------------------------------------------*/
}
void RGBController_SapphireNitroGlowV1::DeviceUpdateLEDs()
{
RGBColor color = colors[0];
unsigned char red = RGBGetRValue(color);
unsigned char grn = RGBGetGValue(color);
unsigned char blu = RGBGetBValue(color);
controller->SetColor(red, grn, blu);
}
void RGBController_SapphireNitroGlowV1::UpdateZoneLEDs(int /*zone*/)
{
DeviceUpdateLEDs();
}
void RGBController_SapphireNitroGlowV1::UpdateSingleLED(int /*led*/)
{
DeviceUpdateLEDs();
}
void RGBController_SapphireNitroGlowV1::DeviceUpdateMode()
{
controller->SetMode((unsigned char)modes[(unsigned int)active_mode].value);
controller->SetBrightness((unsigned char)modes[(unsigned int)active_mode].brightness);
}
Controllers/SapphireGPUController/SapphireNitroGlowV1Controller/RGBController_SapphireNitroGlowV1.h
+36
View File
@@ -0,0 +1,36 @@
/*---------------------------------------------------------*\
| RGBController_SapphireNitroGlowV1.h |
| |
| RGBController for Sapphire Nitro Glow V1 |
| |
| Adam Honse (CalcProgrammer1) 15 Jul 2020 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#pragma once
#include "RGBController.h"
#include "SapphireNitroGlowV1Controller.h"
class RGBController_SapphireNitroGlowV1 : public RGBController
{
public:
RGBController_SapphireNitroGlowV1(SapphireNitroGlowV1Controller* controller_ptr);
~RGBController_SapphireNitroGlowV1();
void SetupZones();
void ResizeZone(int zone, int new_size);
void DeviceUpdateLEDs();
void UpdateZoneLEDs(int zone);
void UpdateSingleLED(int led);
void DeviceUpdateMode();
private:
SapphireNitroGlowV1Controller* controller;
void ReadConfiguration();
};
Controllers/SapphireGPUController/SapphireNitroGlowV1Controller/SapphireNitroGlowV1Controller.cpp
+81
View File
@@ -0,0 +1,81 @@
/*---------------------------------------------------------*\
| SapphireNitroGlowV1Controller.cpp |
| |
| Driver for Sapphire Nitro Glow V1 |
| |
| Adam Honse (CalcProgrammer1) 15 Jul 2020 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include "SapphireNitroGlowV1Controller.h"
SapphireNitroGlowV1Controller::SapphireNitroGlowV1Controller(i2c_smbus_interface* bus, sapphire_dev_id dev, std::string dev_name)
{
this->bus = bus;
this->dev = dev;
this->name = dev_name;
}
SapphireNitroGlowV1Controller::~SapphireNitroGlowV1Controller()
{
}
std::string SapphireNitroGlowV1Controller::GetDeviceLocation()
{
std::string return_string(bus->device_name);
char addr[5];
snprintf(addr, 5, "0x%02X", dev);
return_string.append(", address ");
return_string.append(addr);
return("I2C: " + return_string);
}
std::string SapphireNitroGlowV1Controller::GetDeviceName()
{
return(name);
}
unsigned char SapphireNitroGlowV1Controller::GetRed()
{
return(bus->i2c_smbus_read_byte_data(dev, SAPPHIRE_NITRO_GLOW_V1_REG_RED));
}
unsigned char SapphireNitroGlowV1Controller::GetGreen()
{
return(bus->i2c_smbus_read_byte_data(dev, SAPPHIRE_NITRO_GLOW_V1_REG_GREEN));
}
unsigned char SapphireNitroGlowV1Controller::GetBlue()
{
return(bus->i2c_smbus_read_byte_data(dev, SAPPHIRE_NITRO_GLOW_V1_REG_BLUE));
}
void SapphireNitroGlowV1Controller::SetColor(unsigned char red, unsigned char green, unsigned char blue)
{
bus->i2c_smbus_write_byte_data(dev, SAPPHIRE_NITRO_GLOW_V1_REG_RED, red);
bus->i2c_smbus_write_byte_data(dev, SAPPHIRE_NITRO_GLOW_V1_REG_GREEN, green);
bus->i2c_smbus_write_byte_data(dev, SAPPHIRE_NITRO_GLOW_V1_REG_BLUE, blue);
}
unsigned char SapphireNitroGlowV1Controller::GetMode()
{
return(bus->i2c_smbus_read_byte_data(dev, SAPPHIRE_NITRO_GLOW_V1_REG_MODE));
}
void SapphireNitroGlowV1Controller::SetMode(unsigned char mode)
{
bus->i2c_smbus_write_byte_data(dev, SAPPHIRE_NITRO_GLOW_V1_REG_MODE, mode);
}
unsigned char SapphireNitroGlowV1Controller::GetBrightness()
{
return(bus->i2c_smbus_read_byte_data(dev, SAPPHIRE_NITRO_GLOW_V1_REG_BRIGHTNESS));
}
void SapphireNitroGlowV1Controller::SetBrightness(unsigned char brightness)
{
bus->i2c_smbus_write_byte_data(dev, SAPPHIRE_NITRO_GLOW_V1_REG_BRIGHTNESS, brightness);
}
Controllers/SapphireGPUController/SapphireNitroGlowV1Controller/SapphireNitroGlowV1Controller.h
+66
View File
@@ -0,0 +1,66 @@
/*---------------------------------------------------------*\
| SapphireNitroGlowV1Controller.h |
| |
| Driver for Sapphire Nitro Glow V1 |
| |
| Adam Honse (CalcProgrammer1) 15 Jul 2020 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#pragma once
#include <string>
#include "i2c_smbus.h"
#define SAPPHITE_NITRO_GLOW_V1_BRIGHTNESS_MIN 2;
#define SAPPHITE_NITRO_GLOW_V1_BRIGHTNESS_MAX 0;
typedef unsigned char sapphire_dev_id;
enum
{
SAPPHIRE_NITRO_GLOW_V1_REG_MODE = 0x00,
SAPPHIRE_NITRO_GLOW_V1_REG_BRIGHTNESS = 0x01,
SAPPHIRE_NITRO_GLOW_V1_REG_RED = 0x03,
SAPPHIRE_NITRO_GLOW_V1_REG_GREEN = 0x04,
SAPPHIRE_NITRO_GLOW_V1_REG_BLUE = 0x05,
};
enum
{
SAPPHIRE_NITRO_GLOW_V1_MODE_SAPPHIRE_BLUE = 0x00,
SAPPHIRE_NITRO_GLOW_V1_MODE_RAINBOW = 0x01,
SAPPHIRE_NITRO_GLOW_V1_MODE_BOARD_TEMPERATURE = 0x02,
SAPPHIRE_NITRO_GLOW_V1_MODE_FAN_SPEED = 0x03,
SAPPHIRE_NITRO_GLOW_V1_MODE_CUSTOM = 0x04,
SAPPHIRE_NITRO_GLOW_V1_MODE_OFF = 0x05,
};
class SapphireNitroGlowV1Controller
{
public:
SapphireNitroGlowV1Controller(i2c_smbus_interface* bus, sapphire_dev_id dev, std::string dev_name);
~SapphireNitroGlowV1Controller();
std::string GetDeviceLocation();
std::string GetDeviceName();
unsigned char GetRed();
unsigned char GetGreen();
unsigned char GetBlue();
void SetColor(unsigned char red, unsigned char green, unsigned char blue);
unsigned char GetMode();
void SetMode(unsigned char mode);
unsigned char GetBrightness();
void SetBrightness(unsigned char brightness);
private:
i2c_smbus_interface* bus;
sapphire_dev_id dev;
std::string name;
};