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/SapphireGPUControllerDetect.cpp
+109
View File
@@ -0,0 +1,109 @@
/*---------------------------------------------------------*\
| SapphireGPUControllerDetect.cpp |
| |
| Detector for Sapphire Nitro Glow |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include "Detector.h"
#include "SapphireNitroGlowV1Controller.h"
#include "SapphireNitroGlowV3Controller.h"
#include "RGBController_SapphireNitroGlowV1.h"
#include "RGBController_SapphireNitroGlowV3.h"
#include "i2c_amd_gpu.h"
#include "i2c_smbus.h"
#include "pci_ids.h"
/*-----------------------------------------------------*\
| I2C Addresses for Sapphire Nitro Glow RGB |
\*-----------------------------------------------------*/
enum
{
SAPPHIRE_NITRO_GLOW_V1_ADDR = 0x55,
SAPPHIRE_NITRO_GLOW_V3_ADDR = 0x28,
};
/******************************************************************************************\
* *
* TestForSapphireGPUController *
* *
* Tests the given address to see if an Sapphire controller exists there. First *
* does a byte read to test for a response *
* *
\******************************************************************************************/
bool TestForSapphireGPUController(i2c_smbus_interface* bus, unsigned char address)
{
if(bus->pci_vendor == AMD_GPU_VEN && !is_amd_gpu_i2c_bus(bus))
{
return false;
}
//Read a byte to test for presence
return bus->i2c_smbus_read_byte(address) >= 0;
} /* TestForSapphireGPUController() */
/******************************************************************************************\
* *
* DetectSapphireGPUControllers *
* *
* Detect Sapphire GPU controllers on the enumerated I2C buses. *
* *
\******************************************************************************************/
void DetectSapphireV1Controllers(i2c_smbus_interface* bus, uint8_t i2c_addr, const std::string& name)
{
if(TestForSapphireGPUController(bus, i2c_addr))
{
SapphireNitroGlowV1Controller* new_sapphire_gpu = new SapphireNitroGlowV1Controller(bus, i2c_addr, name);
RGBController_SapphireNitroGlowV1* new_controller = new RGBController_SapphireNitroGlowV1(new_sapphire_gpu);
ResourceManager::get()->RegisterRGBController(new_controller);
}
} /* DetectSapphireV1Controllers() */
void DetectSapphireV3Controllers(i2c_smbus_interface* bus, uint8_t i2c_addr, const std::string& name)
{
if(TestForSapphireGPUController(bus, i2c_addr))
{
SapphireNitroGlowV3Controller* new_sapphire_gpu = new SapphireNitroGlowV3Controller(bus, i2c_addr, name);
RGBController_SapphireNitroGlowV3* new_controller = new RGBController_SapphireNitroGlowV3(new_sapphire_gpu);
ResourceManager::get()->RegisterRGBController(new_controller);
}
} /* DetectSapphireV3Controllers() */
REGISTER_I2C_PCI_DETECTOR("Sapphire Radeon RX 470/480 Nitro+", DetectSapphireV1Controllers, AMD_GPU_VEN, AMD_POLARIS_DEV, SAPPHIRE_LEGACY_SUB_VEN, SAPPHIRE_LEGACY_POLARIS_NITRO_PLUS_SUB_DEV, SAPPHIRE_NITRO_GLOW_V1_ADDR);
REGISTER_I2C_PCI_DETECTOR("Sapphire Radeon RX 570/580/590 Nitro+", DetectSapphireV1Controllers, AMD_GPU_VEN, AMD_POLARIS_DEV, SAPPHIRE_SUB_VEN, SAPPHIRE_POLARIS_NITRO_PLUS_SUB_DEV1, SAPPHIRE_NITRO_GLOW_V1_ADDR);
REGISTER_I2C_PCI_DETECTOR("Sapphire Radeon RX 570/580/590 Nitro+", DetectSapphireV1Controllers, AMD_GPU_VEN, AMD_POLARIS_DEV, SAPPHIRE_SUB_VEN, SAPPHIRE_POLARIS_NITRO_PLUS_SUB_DEV2, SAPPHIRE_NITRO_GLOW_V1_ADDR);
REGISTER_I2C_PCI_DETECTOR("Sapphire Radeon RX 580 Nitro+ (2048SP)", DetectSapphireV1Controllers, AMD_GPU_VEN, AMD_POLARIS20XL_DEV, SAPPHIRE_SUB_VEN, SAPPHIRE_POLARIS_NITRO_PLUS_SUB_DEV1, SAPPHIRE_NITRO_GLOW_V1_ADDR);
REGISTER_I2C_PCI_DETECTOR("Sapphire Radeon RX Vega 56/64 Nitro+", DetectSapphireV1Controllers, AMD_GPU_VEN, AMD_VEGA10_DEV, SAPPHIRE_SUB_VEN, SAPPHIRE_VEGA10_NITRO_PLUS_SUB_DEV, SAPPHIRE_NITRO_GLOW_V1_ADDR);
REGISTER_I2C_PCI_DETECTOR("Sapphire Radeon RX 5500 XT Nitro+", DetectSapphireV3Controllers, AMD_GPU_VEN, AMD_NAVI14_DEV, SAPPHIRE_SUB_VEN, SAPPHIRE_NAVI14_NITRO_PLUS_SUB_DEV, SAPPHIRE_NITRO_GLOW_V3_ADDR);
REGISTER_I2C_PCI_DETECTOR("Sapphire Radeon RX 5700 XT Nitro+", DetectSapphireV3Controllers, AMD_GPU_VEN, AMD_NAVI10_DEV, SAPPHIRE_SUB_VEN, SAPPHIRE_NAVI10_NITRO_PLUS_SUB_DEV1, SAPPHIRE_NITRO_GLOW_V3_ADDR);
REGISTER_I2C_PCI_DETECTOR("Sapphire Radeon RX 5700 XT Nitro+", DetectSapphireV3Controllers, AMD_GPU_VEN, AMD_NAVI10_DEV, SAPPHIRE_SUB_VEN, SAPPHIRE_NAVI10_NITRO_PLUS_SUB_DEV2, SAPPHIRE_NITRO_GLOW_V3_ADDR);
REGISTER_I2C_PCI_DETECTOR("Sapphire Radeon RX 5700 XT Nitro+", DetectSapphireV3Controllers, AMD_GPU_VEN, AMD_NAVI10_DEV, SAPPHIRE_SUB_VEN, SAPPHIRE_NAVI10_NITRO_PLUS_SUB_DEV3, SAPPHIRE_NITRO_GLOW_V3_ADDR);
REGISTER_I2C_PCI_DETECTOR("Sapphire Radeon RX 6600 XT Nitro+", DetectSapphireV3Controllers, AMD_GPU_VEN, AMD_NAVI23_DEV, SAPPHIRE_SUB_VEN, SAPPHIRE_NAVI23_NITRO_PLUS_SUB_DEV, SAPPHIRE_NITRO_GLOW_V3_ADDR);
REGISTER_I2C_PCI_DETECTOR("Sapphire Radeon RX 6650 XT Nitro+", DetectSapphireV3Controllers, AMD_GPU_VEN, AMD_NAVI23_DEV1, SAPPHIRE_SUB_VEN, SAPPHIRE_NAVI23_NITRO_PLUS_SUB_DEV, SAPPHIRE_NITRO_GLOW_V3_ADDR);
REGISTER_I2C_PCI_DETECTOR("Sapphire Radeon RX 6700 XT Nitro+", DetectSapphireV3Controllers, AMD_GPU_VEN, AMD_NAVI22_DEV, SAPPHIRE_SUB_VEN, SAPPHIRE_NAVI22_NITRO_PLUS_SUB_DEV, SAPPHIRE_NITRO_GLOW_V3_ADDR);
REGISTER_I2C_PCI_DETECTOR("Sapphire Radeon RX 6750 XT Nitro+", DetectSapphireV3Controllers, AMD_GPU_VEN, AMD_NAVI22_DEV, SAPPHIRE_SUB_VEN, SAPPHIRE_NAVI22_NITRO_PLUS_SUB_DEV1, SAPPHIRE_NITRO_GLOW_V3_ADDR);
REGISTER_I2C_PCI_DETECTOR("Sapphire Radeon RX 6800 Nitro+", DetectSapphireV3Controllers, AMD_GPU_VEN, AMD_NAVI21_DEV1, SAPPHIRE_SUB_VEN, SAPPHIRE_NAVI21_NITRO_PLUS_SUB_DEV3, SAPPHIRE_NITRO_GLOW_V3_ADDR);
REGISTER_I2C_PCI_DETECTOR("Sapphire Radeon RX 6800 XT Nitro+ SE", DetectSapphireV3Controllers, AMD_GPU_VEN, AMD_NAVI21_DEV1, SAPPHIRE_SUB_VEN, SAPPHIRE_NAVI21_NITRO_PLUS_SUB_DEV1, SAPPHIRE_NITRO_GLOW_V3_ADDR);
REGISTER_I2C_PCI_DETECTOR("Sapphire Radeon RX 6800 XT/6900 XT Nitro+", DetectSapphireV3Controllers, AMD_GPU_VEN, AMD_NAVI21_DEV1, SAPPHIRE_SUB_VEN, SAPPHIRE_NAVI21_NITRO_PLUS_SUB_DEV2, SAPPHIRE_NITRO_GLOW_V3_ADDR);
REGISTER_I2C_PCI_DETECTOR("Sapphire Radeon RX 6900 XT Nitro+ SE", DetectSapphireV3Controllers, AMD_GPU_VEN, AMD_NAVI21_DEV1, SAPPHIRE_SUB_VEN, SAPPHIRE_NAVI21_6900XT_NITRO_PLUS_SUB_DEV, SAPPHIRE_NITRO_GLOW_V3_ADDR);
REGISTER_I2C_PCI_DETECTOR("Sapphire Radeon RX 6900 XT Toxic", DetectSapphireV3Controllers, AMD_GPU_VEN, AMD_NAVI21_DEV2, SAPPHIRE_SUB_VEN, SAPPHIRE_NAVI21_TOXIC_SUB_DEV, SAPPHIRE_NITRO_GLOW_V3_ADDR);
REGISTER_I2C_PCI_DETECTOR("Sapphire Radeon RX 6900 XT Toxic", DetectSapphireV3Controllers, AMD_GPU_VEN, AMD_NAVI21_DEV1, SAPPHIRE_SUB_VEN, SAPPHIRE_NAVI21_6900XT_TOXIC_AC_SUB_DEV, SAPPHIRE_NITRO_GLOW_V3_ADDR);
REGISTER_I2C_PCI_DETECTOR("Sapphire Radeon RX 6900 XT Toxic Limited Edition", DetectSapphireV3Controllers, AMD_GPU_VEN, AMD_NAVI21_DEV1, SAPPHIRE_SUB_VEN, SAPPHIRE_NAVI21_TOXIC_SUB_DEV1, SAPPHIRE_NITRO_GLOW_V3_ADDR);
REGISTER_I2C_PCI_DETECTOR("Sapphire Radeon RX 6950 XT Toxic", DetectSapphireV3Controllers, AMD_GPU_VEN, AMD_NAVI21_DEV3, SAPPHIRE_SUB_VEN, SAPPHIRE_NAVI21_6950XT_TOXIC_AC_SUB_DEV, SAPPHIRE_NITRO_GLOW_V3_ADDR);
REGISTER_I2C_PCI_DETECTOR("Sapphire Radeon RX 6950 XT Nitro+", DetectSapphireV3Controllers, AMD_GPU_VEN, AMD_NAVI21_DEV3, SAPPHIRE_SUB_VEN, SAPPHIRE_NAVI21_6950XT_NITRO_PLUS_SUB_DEV, SAPPHIRE_NITRO_GLOW_V3_ADDR);
REGISTER_I2C_PCI_DETECTOR("Sapphire Radeon RX 6950 XT Nitro+ Pure", DetectSapphireV3Controllers, AMD_GPU_VEN, AMD_NAVI21_DEV3, SAPPHIRE_SUB_VEN, SAPPHIRE_NAVI21_6950XT_NITRO_PLUS_PURE_SUB_DEV, SAPPHIRE_NITRO_GLOW_V3_ADDR);
REGISTER_I2C_PCI_DETECTOR("Sapphire Radeon RX 7700 XT Nitro+", DetectSapphireV3Controllers, AMD_GPU_VEN, AMD_NAVI32_DEV, SAPPHIRE_SUB_VEN, SAPPHIRE_NAVI32_7700XT_NITRO_PLUS_SUB_DEV, SAPPHIRE_NITRO_GLOW_V3_ADDR);
REGISTER_I2C_PCI_DETECTOR("Sapphire Radeon RX 7800 XT Nitro+", DetectSapphireV3Controllers, AMD_GPU_VEN, AMD_NAVI32_DEV, SAPPHIRE_SUB_VEN, SAPPHIRE_NAVI32_7800XT_NITRO_PLUS_SUB_DEV, SAPPHIRE_NITRO_GLOW_V3_ADDR);
REGISTER_I2C_PCI_DETECTOR("Sapphire Radeon RX 7900 GRE Nitro+", DetectSapphireV3Controllers, AMD_GPU_VEN, AMD_NAVI31_DEV, SAPPHIRE_SUB_VEN, SAPPHIRE_NAVI31_GRE_NITRO_PLUS_SUB_DEV, SAPPHIRE_NITRO_GLOW_V3_ADDR);
REGISTER_I2C_PCI_DETECTOR("Sapphire Radeon RX 7900 XTX Nitro+", DetectSapphireV3Controllers, AMD_GPU_VEN, AMD_NAVI31_DEV, SAPPHIRE_SUB_VEN, SAPPHIRE_NAVI31_NITRO_PLUS_SUB_DEV, SAPPHIRE_NITRO_GLOW_V3_ADDR);
REGISTER_I2C_PCI_DETECTOR("Sapphire Radeon RX 9060 XT Pure", DetectSapphireV3Controllers, AMD_GPU_VEN, AMD_NAVI44_DEV, SAPPHIRE_SUB_VEN, SAPPHIRE_NAVI44_PURE_XT_SUB_DEV, SAPPHIRE_NITRO_GLOW_V3_ADDR);
REGISTER_I2C_PCI_DETECTOR("Sapphire Radeon RX 9060 XT Nitro+", DetectSapphireV3Controllers, AMD_GPU_VEN, AMD_NAVI48_DEV1, SAPPHIRE_SUB_VEN, SAPPHIRE_NAVI48_NITRO_PLUS_SUB_DEV1, SAPPHIRE_NITRO_GLOW_V3_ADDR);
REGISTER_I2C_PCI_DETECTOR("Sapphire Radeon RX 9070 Pure", DetectSapphireV3Controllers, AMD_GPU_VEN, AMD_NAVI48_DEV, SAPPHIRE_SUB_VEN, SAPPHIRE_NAVI48_PURE_SUB_DEV, SAPPHIRE_NITRO_GLOW_V3_ADDR);
REGISTER_I2C_PCI_DETECTOR("Sapphire Radeon RX 9070 XT Nitro+", DetectSapphireV3Controllers, AMD_GPU_VEN, AMD_NAVI48_DEV, SAPPHIRE_SUB_VEN, SAPPHIRE_NAVI48_NITRO_PLUS_SUB_DEV, SAPPHIRE_NITRO_GLOW_V3_ADDR);
REGISTER_I2C_PCI_DETECTOR("Sapphire Radeon RX 9070 XT Pure", DetectSapphireV3Controllers, AMD_GPU_VEN, AMD_NAVI48_DEV, SAPPHIRE_SUB_VEN, SAPPHIRE_NAVI48_PURE_XT_SUB_DEV, SAPPHIRE_NITRO_GLOW_V3_ADDR);
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;
};
Controllers/SapphireGPUController/SapphireNitroGlowV3Controller/RGBController_SapphireNitroGlowV3.cpp
+253
View File
@@ -0,0 +1,253 @@
/*---------------------------------------------------------*\
| RGBController_SapphireNitroGlowV3.cpp |
| |
| RGBController for Sapphire Nitro Glow V3 |
| |
| K900 03 Feb 2021 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include "RGBController_SapphireNitroGlowV3.h"
/**------------------------------------------------------------------*\
@name Sapphire Nitro Glow v3
@category GPU
@type I2C
@save :x:
@direct :x:
@effects :white_check_mark:
@detectors DetectSapphireV3Controllers
@comment
\*-------------------------------------------------------------------*/
RGBController_SapphireNitroGlowV3::RGBController_SapphireNitroGlowV3(SapphireNitroGlowV3Controller* controller_ptr)
{
controller = controller_ptr;
name = controller->GetDeviceName();
vendor = "Sapphire";
description = "Sapphire Nitro Glow V3 Device";
location = controller->GetDeviceLocation();
type = DEVICE_TYPE_GPU;
mode Static;
Static.name = "Static";
Static.value = SAPPHIRE_NITRO_GLOW_V3_MODE_CUSTOM;
Static.flags = MODE_FLAG_HAS_PER_LED_COLOR;
Static.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Static);
mode Rainbow;
Rainbow.name = "Rainbow Wave";
Rainbow.value = SAPPHIRE_NITRO_GLOW_V3_MODE_RAINBOW;
Rainbow.flags = MODE_FLAG_HAS_SPEED;
Rainbow.speed_min = 10;
Rainbow.speed_max = 250;
Rainbow.color_mode = MODE_COLORS_NONE;
modes.push_back(Rainbow);
mode Runway;
Runway.name = "Runway";
Runway.value = SAPPHIRE_NITRO_GLOW_V3_MODE_RUNWAY;
Runway.flags = MODE_FLAG_HAS_SPEED;
Runway.speed_min = 5;
Runway.speed_max = 50;
Runway.color_mode = MODE_COLORS_NONE;
modes.push_back(Runway);
mode ColorCycle;
ColorCycle.name = "Spectrum Cycle";
ColorCycle.value = SAPPHIRE_NITRO_GLOW_V3_MODE_COLOR_CYCLE;
ColorCycle.flags = MODE_FLAG_HAS_SPEED;
ColorCycle.speed_min = 30;
ColorCycle.speed_max = 1;
ColorCycle.color_mode = MODE_COLORS_NONE;
modes.push_back(ColorCycle);
mode Serial;
Serial.name = "Serial";
Serial.value = SAPPHIRE_NITRO_GLOW_V3_MODE_SERIAL;
Serial.flags = MODE_FLAG_HAS_SPEED;
Serial.speed_min = 255;
Serial.speed_max = 5;
Serial.color_mode = MODE_COLORS_NONE;
modes.push_back(Serial);
mode External;
External.name = "External Control";
External.value = SAPPHIRE_NITRO_GLOW_V3_MODE_EXTERNAL_CONTROL;
External.flags = 0;
External.color_mode = MODE_COLORS_NONE;
modes.push_back(External);
mode Off;
Off.name = "Off";
Off.value = SAPPHIRE_NITRO_GLOW_V3_MODE_OFF;
Off.flags = 0;
Off.color_mode = MODE_COLORS_NONE;
modes.push_back(Off);
SetupZones();
ReadConfiguration();
}
RGBController_SapphireNitroGlowV3::~RGBController_SapphireNitroGlowV3()
{
delete controller;
}
void RGBController_SapphireNitroGlowV3::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_SapphireNitroGlowV3::ReadConfiguration()
{
modes[1].speed = controller->GetRainbowAnimationSpeed();
modes[2].speed = controller->GetRunwayAnimationSpeed();
modes[3].speed = controller->GetColorCycleAnimationSpeed();
modes[4].speed = controller->GetSerialAnimationSpeed();
colors[0] = ToRGBColor(
controller->GetRed(),
controller->GetBlue(),
controller->GetGreen()
);
if(controller->GetExternalControl())
{
active_mode = 5;
return;
}
switch(controller->GetMode())
{
case SAPPHIRE_NITRO_GLOW_V3_MODE_CUSTOM:
active_mode = 0;
break;
case SAPPHIRE_NITRO_GLOW_V3_MODE_RAINBOW:
active_mode = 1;
break;
case SAPPHIRE_NITRO_GLOW_V3_MODE_RUNWAY:
active_mode = 2;
break;
case SAPPHIRE_NITRO_GLOW_V3_MODE_COLOR_CYCLE:
active_mode = 3;
break;
case SAPPHIRE_NITRO_GLOW_V3_MODE_SERIAL:
active_mode = 4;
break;
case SAPPHIRE_NITRO_GLOW_V3_MODE_OFF:
active_mode = 6;
colors[0] = ToRGBColor(0, 0, 0);
break;
default:
active_mode = 0;
break;
}
}
void RGBController_SapphireNitroGlowV3::ResizeZone(int /*zone*/, int /*new_size*/)
{
/*---------------------------------------------------------*\
| This device does not support resizing zones |
\*---------------------------------------------------------*/
}
void RGBController_SapphireNitroGlowV3::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_SapphireNitroGlowV3::UpdateZoneLEDs(int /*zone*/)
{
DeviceUpdateLEDs();
}
void RGBController_SapphireNitroGlowV3::UpdateSingleLED(int /*led*/)
{
DeviceUpdateLEDs();
}
void RGBController_SapphireNitroGlowV3::DeviceUpdateMode()
{
auto mode = modes[active_mode];
switch(mode.value)
{
case SAPPHIRE_NITRO_GLOW_V3_MODE_CUSTOM:
controller->SetExternalControl(false);
controller->SetMode(mode.value);
break;
case SAPPHIRE_NITRO_GLOW_V3_MODE_RAINBOW:
controller->SetExternalControl(false);
controller->SetRainbowAnimationSpeed(mode.speed);
controller->SetMode(mode.value);
break;
case SAPPHIRE_NITRO_GLOW_V3_MODE_RUNWAY:
controller->SetExternalControl(false);
controller->SetRunwayAnimationSpeed(mode.speed);
controller->SetMode(mode.value);
break;
case SAPPHIRE_NITRO_GLOW_V3_MODE_COLOR_CYCLE:
controller->SetExternalControl(false);
controller->SetColorCycleAnimationSpeed(mode.speed);
controller->SetMode(mode.value);
break;
case SAPPHIRE_NITRO_GLOW_V3_MODE_SERIAL:
controller->SetExternalControl(false);
controller->SetSerialAnimationSpeed(mode.speed);
controller->SetMode(mode.value);
break;
case SAPPHIRE_NITRO_GLOW_V3_MODE_EXTERNAL_CONTROL:
controller->SetExternalControl(true);
break;
case SAPPHIRE_NITRO_GLOW_V3_MODE_OFF:
controller->SetExternalControl(false);
controller->SetColor(0, 0, 0);
controller->SetMode(mode.value);
break;
}
}
Controllers/SapphireGPUController/SapphireNitroGlowV3Controller/RGBController_SapphireNitroGlowV3.h
+36
View File
@@ -0,0 +1,36 @@
/*---------------------------------------------------------*\
| RGBController_SapphireNitroGlowV3.h |
| |
| RGBController for Sapphire Nitro Glow V3 |
| |
| K900 03 Feb 2021 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#pragma once
#include "RGBController.h"
#include "SapphireNitroGlowV3Controller.h"
class RGBController_SapphireNitroGlowV3 : public RGBController
{
public:
RGBController_SapphireNitroGlowV3(SapphireNitroGlowV3Controller* controller_ptr);
~RGBController_SapphireNitroGlowV3();
void SetupZones();
void ResizeZone(int zone, int new_size);
void DeviceUpdateLEDs();
void UpdateZoneLEDs(int zone);
void UpdateSingleLED(int led);
void DeviceUpdateMode();
private:
SapphireNitroGlowV3Controller* controller;
void ReadConfiguration();
};
Controllers/SapphireGPUController/SapphireNitroGlowV3Controller/SapphireNitroGlowV3Controller.cpp
+141
View File
@@ -0,0 +1,141 @@
/*---------------------------------------------------------*\
| SapphireNitroGlowV3Controller.cpp |
| |
| Driver for Sapphire Nitro Glow V3 |
| |
| K900 03 Feb 2021 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include "SapphireNitroGlowV3Controller.h"
SapphireNitroGlowV3Controller::SapphireNitroGlowV3Controller(i2c_smbus_interface* bus, sapphire_dev_id dev, std::string dev_name)
{
this->bus = bus;
this->dev = dev;
this->name = dev_name;
}
SapphireNitroGlowV3Controller::~SapphireNitroGlowV3Controller()
{
}
std::string SapphireNitroGlowV3Controller::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 SapphireNitroGlowV3Controller::GetDeviceName()
{
return(name);
}
unsigned char SapphireNitroGlowV3Controller::GetRed()
{
return(bus->i2c_smbus_read_byte_data(dev, SAPPHIRE_NITRO_GLOW_V3_REG_RED));
}
unsigned char SapphireNitroGlowV3Controller::GetGreen()
{
return(bus->i2c_smbus_read_byte_data(dev, SAPPHIRE_NITRO_GLOW_V3_REG_GREEN));
}
unsigned char SapphireNitroGlowV3Controller::GetBlue()
{
return(bus->i2c_smbus_read_byte_data(dev, SAPPHIRE_NITRO_GLOW_V3_REG_BLUE));
}
void SapphireNitroGlowV3Controller::SetColor(unsigned char red, unsigned char green, unsigned char blue)
{
bus->i2c_smbus_write_byte_data(dev, SAPPHIRE_NITRO_GLOW_V3_REG_RED, red);
bus->i2c_smbus_write_byte_data(dev, SAPPHIRE_NITRO_GLOW_V3_REG_GREEN, green);
bus->i2c_smbus_write_byte_data(dev, SAPPHIRE_NITRO_GLOW_V3_REG_BLUE, blue);
}
unsigned char SapphireNitroGlowV3Controller::GetMode()
{
return(bus->i2c_smbus_read_byte_data(dev, SAPPHIRE_NITRO_GLOW_V3_REG_MODE));
}
void SapphireNitroGlowV3Controller::SetMode(unsigned char mode)
{
bus->i2c_smbus_write_byte_data(dev, SAPPHIRE_NITRO_GLOW_V3_REG_MODE, mode);
}
bool SapphireNitroGlowV3Controller::GetExternalControl()
{
return((bool)bus->i2c_smbus_read_byte_data(dev, SAPPHIRE_NITRO_GLOW_V3_REG_EXTERNAL_CONTROL));
}
void SapphireNitroGlowV3Controller::SetExternalControl(bool enabled)
{
bus->i2c_smbus_write_byte_data(dev, SAPPHIRE_NITRO_GLOW_V3_REG_EXTERNAL_CONTROL, (unsigned char)enabled);
}
unsigned char SapphireNitroGlowV3Controller::GetBrightness()
{
return(bus->i2c_smbus_read_byte_data(dev, SAPPHIRE_NITRO_GLOW_V3_REG_BRIGHTNESS));
}
void SapphireNitroGlowV3Controller::SetBrightness(unsigned char brightness)
{
bus->i2c_smbus_write_byte_data(dev, SAPPHIRE_NITRO_GLOW_V3_REG_BRIGHTNESS, brightness);
}
unsigned char SapphireNitroGlowV3Controller::GetRainbowAnimationSpeed()
{
return(bus->i2c_smbus_read_byte_data(dev, SAPPHIRE_NITRO_GLOW_V3_REG_RAINBOW_ANIMATION_SPEED));
}
void SapphireNitroGlowV3Controller::SetRainbowAnimationSpeed(unsigned char speed)
{
bus->i2c_smbus_write_byte_data(dev, SAPPHIRE_NITRO_GLOW_V3_REG_RAINBOW_ANIMATION_SPEED, speed);
}
unsigned char SapphireNitroGlowV3Controller::GetRunwayAnimationSpeed()
{
return(bus->i2c_smbus_read_byte_data(dev, SAPPHIRE_NITRO_GLOW_V3_REG_RUNWAY_ANIMATION_SPEED));
}
void SapphireNitroGlowV3Controller::SetRunwayAnimationSpeed(unsigned char speed)
{
bus->i2c_smbus_write_byte_data(dev, SAPPHIRE_NITRO_GLOW_V3_REG_RUNWAY_ANIMATION_SPEED, speed);
}
unsigned char SapphireNitroGlowV3Controller::GetRunwayAnimationRepeatCount()
{
return(bus->i2c_smbus_read_byte_data(dev, SAPPHIRE_NITRO_GLOW_V3_REG_RUNWAY_ANIMATION_REPEAT_COUNT));
}
void SapphireNitroGlowV3Controller::SetRunwayAnimationRepeatCount(unsigned char count)
{
bus->i2c_smbus_write_byte_data(dev, SAPPHIRE_NITRO_GLOW_V3_REG_RUNWAY_ANIMATION_REPEAT_COUNT, count);
}
unsigned char SapphireNitroGlowV3Controller::GetColorCycleAnimationSpeed()
{
return(bus->i2c_smbus_read_byte_data(dev, SAPPHIRE_NITRO_GLOW_V3_REG_COLOR_CYCLE_ANIMATION_SPEED));
}
void SapphireNitroGlowV3Controller::SetColorCycleAnimationSpeed(unsigned char speed)
{
bus->i2c_smbus_write_byte_data(dev, SAPPHIRE_NITRO_GLOW_V3_REG_COLOR_CYCLE_ANIMATION_SPEED, speed);
}
unsigned char SapphireNitroGlowV3Controller::GetSerialAnimationSpeed()
{
return(bus->i2c_smbus_read_byte_data(dev, SAPPHIRE_NITRO_GLOW_V3_REG_SERIAL_ANIMATION_SPEED));
}
void SapphireNitroGlowV3Controller::SetSerialAnimationSpeed(unsigned char speed)
{
bus->i2c_smbus_write_byte_data(dev, SAPPHIRE_NITRO_GLOW_V3_REG_SERIAL_ANIMATION_SPEED, speed);
}
Controllers/SapphireGPUController/SapphireNitroGlowV3Controller/SapphireNitroGlowV3Controller.h
+91
View File
@@ -0,0 +1,91 @@
/*---------------------------------------------------------*\
| SapphireNitroGlowV3Controller.h |
| |
| Driver for Sapphire Nitro Glow V3 |
| |
| K900 03 Feb 2021 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#pragma once
#include <string>
#include "i2c_smbus.h"
typedef unsigned char sapphire_dev_id;
enum
{
SAPPHIRE_NITRO_GLOW_V3_REG_MODE = 0x10,
SAPPHIRE_NITRO_GLOW_V3_REG_EXTERNAL_CONTROL = 0x0F,
SAPPHIRE_NITRO_GLOW_V3_REG_BRIGHTNESS = 0x3E,
SAPPHIRE_NITRO_GLOW_V3_REG_RUNWAY_ANIMATION_SPEED = 0x11,
SAPPHIRE_NITRO_GLOW_V3_REG_RUNWAY_ANIMATION_REPEAT_COUNT = 0x12,
SAPPHIRE_NITRO_GLOW_V3_REG_COLOR_CYCLE_ANIMATION_SPEED = 0x13,
SAPPHIRE_NITRO_GLOW_V3_REG_RAINBOW_ANIMATION_SPEED = 0x15,
SAPPHIRE_NITRO_GLOW_V3_REG_SERIAL_ANIMATION_SPEED = 0x16,
SAPPHIRE_NITRO_GLOW_V3_REG_MUSIC_VOLUME = 0x29,
SAPPHIRE_NITRO_GLOW_V3_REG_RED = 0x1A,
SAPPHIRE_NITRO_GLOW_V3_REG_GREEN = 0x1B,
SAPPHIRE_NITRO_GLOW_V3_REG_BLUE = 0x1C,
};
enum
{
SAPPHIRE_NITRO_GLOW_V3_MODE_RAINBOW = 0x00,
SAPPHIRE_NITRO_GLOW_V3_MODE_RUNWAY = 0x01,
SAPPHIRE_NITRO_GLOW_V3_MODE_COLOR_CYCLE = 0x02,
SAPPHIRE_NITRO_GLOW_V3_MODE_SERIAL = 0x03,
SAPPHIRE_NITRO_GLOW_V3_MODE_SAPPHIRE_BLUE = 0x04,
SAPPHIRE_NITRO_GLOW_V3_MODE_AUDIO_VISUALIZATION = 0x05,
SAPPHIRE_NITRO_GLOW_V3_MODE_CUSTOM = 0x06,
SAPPHIRE_NITRO_GLOW_V3_MODE_OFF = 0x07,
SAPPHIRE_NITRO_GLOW_V3_MODE_EXTERNAL_CONTROL = 0xFF,
};
class SapphireNitroGlowV3Controller
{
public:
SapphireNitroGlowV3Controller(i2c_smbus_interface* bus, sapphire_dev_id dev, std::string dev_name);
~SapphireNitroGlowV3Controller();
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);
bool GetExternalControl();
void SetExternalControl(bool enabled);
unsigned char GetBrightness();
void SetBrightness(unsigned char brightness);
unsigned char GetRainbowAnimationSpeed();
void SetRainbowAnimationSpeed(unsigned char speed);
unsigned char GetRunwayAnimationSpeed();
void SetRunwayAnimationSpeed(unsigned char speed);
unsigned char GetRunwayAnimationRepeatCount();
void SetRunwayAnimationRepeatCount(unsigned char count);
unsigned char GetColorCycleAnimationSpeed();
void SetColorCycleAnimationSpeed(unsigned char speed);
unsigned char GetSerialAnimationSpeed();
void SetSerialAnimationSpeed(unsigned char speed);
private:
i2c_smbus_interface* bus;
sapphire_dev_id dev;
std::string name;
};