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/GigabyteRGBFusion2SMBusController/GigabyteRGBFusion2SMBusController.cpp
+196
View File
@@ -0,0 +1,196 @@
/*---------------------------------------------------------*\
| GigabyteRGBFusion2SMBusController.cpp |
| |
| Driver for Gigabyte Aorus RGB Fusion 2 SMBus |
| motherboard |
| |
| Adam Honse (CalcProgrammer1) 12 Mar 2020 |
| Matt Harper 05 May 2020 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include <cstring>
#include <stdio.h>
#include <stdlib.h>
#include "GigabyteRGBFusion2SMBusController.h"
RGBFusion2SMBusController::RGBFusion2SMBusController(i2c_smbus_interface* bus, rgb_fusion_dev_id dev, std::string mb_name)
{
this->bus = bus;
this->dev = dev;
this->name = mb_name;
memset(led_data, 0, 10*16);
led_count = 10; // Protocol supports 10 'slots'
}
RGBFusion2SMBusController::~RGBFusion2SMBusController()
{
}
unsigned int RGBFusion2SMBusController::GetLEDCount()
{
return(led_count);
}
std::string RGBFusion2SMBusController::GetDeviceName()
{
return(name);
}
std::string RGBFusion2SMBusController::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);
}
/* Writes are performed in 32 byte chunks. If we need to write the second 16 bytes,
* we must necessarily write the first 16 as well. Given that reading the existing state
* from the device is not yet possible, unfortunately we may overwrite existing device
* states if the state transition did not occur within in the same OpenRGB instance.
* That is to say, the current behavior is non-deal but the best we have
*/
void RGBFusion2SMBusController::WriteLED(int led)
{
unsigned short register_offset = led / 2; // Relying on integer division to truncate
unsigned short write_register = RGB_FUSION_2_LED_START_ADDR + 2*register_offset;
// Adjust if we are writing the second 16 bytes
if(led % 2)
{
led -= 1;
}
bus->i2c_smbus_write_block_data(RGB_FUSION_2_SMBUS_ADDR, (u8)write_register, 32, led_data[led]);
}
void RGBFusion2SMBusController::Apply()
{
// Protocol expects terminating sequence 0x01ff written to register 0x17
bus->i2c_smbus_write_word_data(RGB_FUSION_2_SMBUS_ADDR,
RGB_FUSION_2_APPLY_ADDR,
RGB_FUSION_2_ACTION_APPLY);
}
void RGBFusion2SMBusController::SetLEDEffect
(
unsigned int led,
int mode,
unsigned int brightness,
unsigned int speed,
unsigned char red,
unsigned char green,
unsigned char blue
)
{
led_data[led][RGB_FUSION_2_IDX_MODE] = mode;
led_data[led][RGB_FUSION_2_IDX_RED] = red;
led_data[led][RGB_FUSION_2_IDX_GREEN] = green;
led_data[led][RGB_FUSION_2_IDX_BLUE] = blue;
led_data[led][RGB_FUSION_2_IDX_BRIGHTNESS] = 0x64;
switch (mode)
{
case RGB_FUSION_2_MODE_PULSE:
// Timer 1: On time
// Timer 2: Off time
led_data[led][RGB_FUSION_2_TIMER_1_LSB] = 0x20 * speed;
led_data[led][RGB_FUSION_2_TIMER_1_MSB] = 0x03 * speed;
led_data[led][RGB_FUSION_2_TIMER_2_LSB] = 0x20 * speed;
led_data[led][RGB_FUSION_2_TIMER_2_MSB] = 0x03 * speed;
break;
case RGB_FUSION_2_MODE_DIGITAL_WAVE:
// Timer 1: Wave Speed
led_data[led][RGB_FUSION_2_TIMER_1_LSB] = speed;
led_data[led][RGB_FUSION_2_TIMER_1_MSB] = 0x00;
led_data[led][RGB_FUSION_2_IDX_BRIGHTNESS] = brightness;
break;
case RGB_FUSION_2_MODE_DIGITAL_A:
// Timer 1: Directly controls speed of LED sections
led_data[led][RGB_FUSION_2_TIMER_1_LSB] = speed;
led_data[led][RGB_FUSION_2_TIMER_1_MSB] = 0x00; // Setting this to any number other than 0 slows down the effect
led_data[led][RGB_FUSION_2_IDX_OPT_1] = 0x01; // Doesn't do anything, but always defaults to 0x01
break;
case RGB_FUSION_2_MODE_DIGITAL_B:
// Timer 1: Direct control of section speed and pulsing
led_data[led][RGB_FUSION_2_TIMER_1_LSB] = speed; // Main effect speed
led_data[led][RGB_FUSION_2_TIMER_1_MSB] = 0x00; // Only sets to 0x01 in min speed. Makes light section blink for shorter periods
led_data[led][RGB_FUSION_2_IDX_OPT_1] = 0x05 - (speed / 60); // Changes between 0x01 and 0x04 along with speed. Controls light trail length.
break;
case RGB_FUSION_2_MODE_DIGITAL_C:
// Timer 1: Effect Speed
led_data[led][RGB_FUSION_2_TIMER_1_LSB] = speed;
led_data[led][RGB_FUSION_2_TIMER_1_MSB] = 0x00; // Like Digital A, slows down the effect, but never sets to another number.
led_data[led][RGB_FUSION_2_IDX_OPT_1] = 0x04; // Fixed at 0x04. Does nothing.
break;
case RGB_FUSION_2_MODE_DIGITAL_D:
// Timer 1: Effect Speed
led_data[led][RGB_FUSION_2_TIMER_1_LSB] = speed;
led_data[led][RGB_FUSION_2_TIMER_1_MSB] = 0x00; // Like Digital A, slows down the effect, but never sets to another number.
led_data[led][RGB_FUSION_2_IDX_OPT_1] = 0x04; // Fixed at 0x04. Does nothing.
led_data[led][RGB_FUSION_2_IDX_BRIGHTNESS] = brightness;
break;
case RGB_FUSION_2_MODE_DIGITAL_E:
// Timer 1: Effect Speed
led_data[led][RGB_FUSION_2_TIMER_1_LSB] = speed;
led_data[led][RGB_FUSION_2_TIMER_1_MSB] = 0; // Like Digital A, slows down the effect, but never sets to another number.
led_data[led][RGB_FUSION_2_IDX_OPT_1] = 0x05 - (speed / 50); // Changes between 0x02 and 0x04 according to speed, might be similar to Digital B.
break;
case RGB_FUSION_2_MODE_DIGITAL_F:
// Timer 1: Effect Speed
led_data[led][RGB_FUSION_2_TIMER_1_LSB] = speed;
led_data[led][RGB_FUSION_2_TIMER_1_MSB] = 0x00; // Like Digital A, slows down the effect, but never sets to another number.
led_data[led][RGB_FUSION_2_IDX_OPT_1] = 0x04; // Fixed at 0x04. Does nothing.
led_data[led][RGB_FUSION_2_IDX_BRIGHTNESS] = brightness;
break;
case RGB_FUSION_2_MODE_DIGITAL_G:
// Timer 1: Effect Speed
led_data[led][RGB_FUSION_2_TIMER_1_LSB] = speed;
led_data[led][RGB_FUSION_2_TIMER_1_MSB] = 0x00; // Like Digital A, slows down the effect, but never sets to another number.
led_data[led][RGB_FUSION_2_IDX_OPT_1] = 0x04; // Fixed at 0x04. Does nothing.
led_data[led][RGB_FUSION_2_IDX_BRIGHTNESS] = brightness;
break;
case RGB_FUSION_2_MODE_COLOR_CYCLE:
// Timer 1: Cycle time
led_data[led][RGB_FUSION_2_TIMER_1_LSB] = 0x00;
led_data[led][RGB_FUSION_2_TIMER_1_MSB] = 0x03 * speed;
led_data[led][RGB_FUSION_2_IDX_OPT_1] = 0x07; // Number of colors to cycle through. Valid range [1-7]
led_data[led][RGB_FUSION_2_IDX_OPT_2] = 0x00; // Color cycle, or color cycle and pulse. [0,1]
led_data[led][RGB_FUSION_2_IDX_BRIGHTNESS] = brightness;
break;
case RGB_FUSION_2_MODE_FLASHING:
/* Timer 1: On time
* Timer 2: Interval
* Timer 3: Cycle time */
led_data[led][RGB_FUSION_2_TIMER_1_LSB] = 0x64;
led_data[led][RGB_FUSION_2_TIMER_1_MSB] = 0;
led_data[led][RGB_FUSION_2_TIMER_2_LSB] = 0xc8;
led_data[led][RGB_FUSION_2_TIMER_2_MSB] = 0;
led_data[led][RGB_FUSION_2_TIMER_3_LSB] = 0xd0;
led_data[led][RGB_FUSION_2_TIMER_3_MSB] = 0x07;
led_data[led][RGB_FUSION_2_IDX_OPT_1] = speed; // Controls number of flashes
break;
}
WriteLED(led);
}
Controllers/GigabyteRGBFusion2SMBusController/GigabyteRGBFusion2SMBusController.h
+120
View File
@@ -0,0 +1,120 @@
/*---------------------------------------------------------*\
| GigabyteRGBFusion2SMBusController.h |
| |
| Driver for Gigabyte Aorus RGB Fusion 2 SMBus |
| motherboard |
| |
| Adam Honse (CalcProgrammer1) 12 Mar 2020 |
| Matt Harper 05 May 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"
typedef unsigned char rgb_fusion_dev_id;
enum
{
RGB_FUSION_2_IDX_MODE = 0x01, /* Mode index */
RGB_FUSION_2_IDX_BRIGHTNESS = 0x02, /* Brightness index */
RGB_FUSION_2_IDX_MAX_BRIGHTNESS = 0x02, /* Max brightness index */
RGB_FUSION_2_IDX_MIN_BRIGHTNESS = 0x03, /* Minimum brightness index */
RGB_FUSION_2_IDX_BLUE = 0x04, /* Blue index */
RGB_FUSION_2_IDX_GREEN = 0x05, /* Green index */
RGB_FUSION_2_IDX_RED = 0x06, /* Red index */
RGB_FUSION_2_IDX_WHITE = 0x07, /* White index */
RGB_FUSION_2_TIMER_1_LSB = 0x08, /* Timer 1 LSB. Valid timer values [0-65535] */
RGB_FUSION_2_TIMER_1_MSB = 0x09, /* Timer 1 MSB. Timer unis are milliseconds */
RGB_FUSION_2_TIMER_2_LSB = 0x0A, /* Timer 2 LSB */
RGB_FUSION_2_TIMER_2_MSB = 0x0B, /* Timer 2 MSB */
RGB_FUSION_2_TIMER_3_LSB = 0x0C, /* Timer 3 LSB */
RGB_FUSION_2_TIMER_3_MSB = 0x0D, /* Timer 3 MSB */
RGB_FUSION_2_IDX_OPT_1 = 0x0E, /* Option 1. Use case varies by mode */
RGB_FUSION_2_IDX_OPT_2 = 0x0F, /* Option 2. Use case varies by mode */
};
enum
{
RGB_FUSION_2_APPLY_ADDR = 0x17,
RGB_FUSION_2_LED_START_ADDR = 0x20,
RGB_FUSION_2_SMBUS_ADDR = 0x68,
};
enum
{
RGB_FUSION_2_ACTION_APPLY = 0x01ff,
};
enum
{
RGB_FUSION_2_MODE_PULSE = 0x01, /* Pulse mode */
RGB_FUSION_2_MODE_MUSIC = 0x02, /* Music mode */
RGB_FUSION_2_MODE_COLOR_CYCLE = 0x03, /* Color cycle mode */
RGB_FUSION_2_MODE_STATIC = 0x04, /* Static color mode */
RGB_FUSION_2_MODE_FLASHING = 0x05, /* Flashing / Double Flashing mode */
RGB_FUSION_2_MODE_TRANSITION = 0x09, /* Gradual transition from current */
RGB_FUSION_2_MODE_DIGITAL_WAVE = 0x0A, /* Wave mode */
RGB_FUSION_2_MODE_DIGITAL_A = 0x0B, /* */
RGB_FUSION_2_MODE_DIGITAL_B = 0x0C, /* */
RGB_FUSION_2_MODE_DIGITAL_C = 0x0D, /* */
RGB_FUSION_2_MODE_DIGITAL_D = 0x0F, /* */
RGB_FUSION_2_MODE_DIGITAL_E = 0x10, /* */
RGB_FUSION_2_MODE_DIGITAL_F = 0x11, /* */
RGB_FUSION_2_MODE_DIGITAL_G = 0x12, /* */
// RGB_FUSION_2_MODE_DIGITAL_H = 0x11,
// RGB_FUSION_2_MODE_DIGITAL_I = 0x12, They are variants of DIGITAL F and G
};
enum
{
RGB_FUSION_2_SPEED_FAST = 0x01,
RGB_FUSION_2_SPEED_NORMAL = 0x02,
RGB_FUSION_2_SPEED_SLOW = 0x04,
RGB_FUSION_2_DIGITAL_SPEED = 0x91,
RGB_FUSION_2_DIGITAL_SPEED_MIN = 0xe6,
RGB_FUSION_2_DIGITAL_SPEED_MAX = 0x32,
};
enum
{
RGB_FUSION_2_BRIGHTNESS_MAX = 0x64,
RGB_FUSION_2_BRIGHTNESS_MIN = 0x0f,
};
class RGBFusion2SMBusController
{
public:
RGBFusion2SMBusController(i2c_smbus_interface* bus, rgb_fusion_dev_id dev, std::string mb_name);
~RGBFusion2SMBusController();
std::string GetDeviceName();
std::string GetDeviceLocation();
unsigned int GetLEDCount();
void Apply();
void SetLEDEffect
(
unsigned int led,
int mode,
unsigned int brightness,
unsigned int speed,
unsigned char red,
unsigned char green,
unsigned char blue
);
private:
unsigned int led_count;
i2c_smbus_interface* bus;
rgb_fusion_dev_id dev;
std::string name;
unsigned char led_data[10][16];
void WriteLED(int);
};
Controllers/GigabyteRGBFusion2SMBusController/GigabyteRGBFusion2SMBusControllerDetect.cpp
+169
View File
@@ -0,0 +1,169 @@
/*---------------------------------------------------------*\
| GigabyteRGBFusion2SMBusControllerDetect.cpp |
| |
| Detector for Gigabyte Aorus RGB Fusion 2 SMBus |
| motherboard |
| |
| Matt Harper 05 May 2020 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include <string>
#include <vector>
#include "Detector.h"
#include "GigabyteRGBFusion2SMBusController.h"
#include "LogManager.h"
#include "RGBController_GigabyteRGBFusion2SMBus.h"
#include "SettingsManager.h"
#include "i2c_smbus.h"
#include "pci_ids.h"
#include "dmiinfo.h"
#define DETECTOR_NAME "Gigabyte RGB Fusion 2 SMBus"
#define VENDOR_NAME "Gigabyte Technology Co., Ltd."
#define GIGABYTE_FOUND_MB_MESSAGE_EN "[%s] Success - Found '%s' in the JSON list"
#define GIGABYTE_NOT_FOUND_MB_MESSAGE_EN "[%s] FAILED - '%s' was not found in the JSON list. Do NOT enable if this is a USB based board."
#define SMBUS_ADDRESS 0x68
typedef struct
{
const std::string manufacturer;
const std::string motherboard;
} motherboard_info;
#define RGB_FUSION_2_SMBUS_NUM_DEVICES (sizeof(rgb_fusion_2_smbus_motherboards) / sizeof(rgb_fusion_2_smbus_motherboards[ 0 ]))
json rgb_fusion_2_smbus_motherboards[] =
{
"B450 AORUS ELITE",
"B450 AORUS ELITE V2",
"B450 AORUS M",
"B450 AORUS PRO WIFI-CF",
"B450 AORUS PRO-CF",
"B450 AORUS PRO-CF4",
"B450 I AORUS PRO WIFI-CF",
"B450M DS3H-CF",
"X299 DESIGNARE EX-CF",
"X399 AORUS XTREME-CF",
"X399 DESIGNARE EX-CF",
"X470 AORUS GAMING 5 WIFI",
"X470 AORUS GAMING 5 WIFI-CF",
"X470 AORUS GAMING 7 WIFI-CF",
"X470 AORUS GAMING 7 WIFI-50-CF",
"X470 AORUS ULTRA GAMING",
"X470 AORUS ULTRA GAMING-CF",
"B360M AORUS Gaming 3-CF",
"Z370 AORUS Gaming 5-CF",
"Z370 AORUS Ultra Gaming-CF"
};
/******************************************************************************************\
* *
* TestForGigabyteRGBFusion2SMBusController *
* *
* Tests the given address to see if an RGB 2 Fusion controller exists there. First *
* does a quick write to test for a response *
* *
\******************************************************************************************/
bool TestForGigabyteRGBFusion2SMBusController(i2c_smbus_interface* bus, unsigned char address)
{
bool pass = false;
int res = bus->i2c_smbus_write_quick(address, I2C_SMBUS_WRITE);
if (res >= 0)
{
pass = true;
}
return(pass);
} /* TestForRGBFusion2SMBusController() */
/******************************************************************************************\
* *
* DetectGigabyteRGBFusion2SMBusControllers *
* *
* Detect RGB Fusion 2 controllers on the enumerated I2C busses at address 0x68. *
* *
* bus - pointer to i2c_smbus_interface where RGB Fusion device is connected *
* dev - I2C address of RGB Fusion device *
* *
\******************************************************************************************/
void DetectGigabyteRGBFusion2SMBusControllers(std::vector<i2c_smbus_interface*>& busses)
{
SettingsManager* set_man = ResourceManager::get()->GetSettingsManager();
json device_settings;
DMIInfo dmi;
bool found = false;
/*-------------------------------------------------*\
| Get Linux LED settings from settings manager |
\*-------------------------------------------------*/
device_settings = set_man->GetSettings(DETECTOR_NAME);
if(!device_settings.contains("SupportedDevices"))
{
//If supported devices is not found then write it to settings
device_settings["SupportedDevices"] = rgb_fusion_2_smbus_motherboards;
set_man->SetSettings(DETECTOR_NAME, device_settings);
set_man->SaveSettings();
}
bool boolVendor = ( dmi.getManufacturer() == VENDOR_NAME );
bool boolMotherboard = false;
nlohmann::detail::iter_impl<nlohmann::json> result = std::find(std::begin(device_settings["SupportedDevices"]), std::end(device_settings["SupportedDevices"]), dmi.getMainboard() );
if(result != std::end(device_settings["SupportedDevices"]))
{
boolMotherboard = true;
}
found = ( boolVendor && boolMotherboard );
if(found)
{
LOG_DEBUG(GIGABYTE_FOUND_MB_MESSAGE_EN, DETECTOR_NAME, dmi.getMainboard().c_str());
for(unsigned int bus = 0; bus < busses.size(); bus++)
{
IF_MOBO_SMBUS(busses[bus]->pci_vendor, busses[bus]->pci_device)
{
if(busses[bus]->pci_subsystem_vendor == GIGABYTE_SUB_VEN)
{
// TODO - Is this necessary? Or an artifact of my own system?
// Skip dmcd devices
std::string device_name = std::string(busses[bus]->device_name);
if(device_name.find("dmdc") == std::string::npos)
{
LOG_DEBUG(SMBUS_CHECK_DEVICE_MESSAGE_EN, DETECTOR_NAME, bus, VENDOR_NAME, SMBUS_ADDRESS);
// Check for RGB Fusion 2 controller at 0x68
if(TestForGigabyteRGBFusion2SMBusController(busses[bus], SMBUS_ADDRESS))
{
RGBFusion2SMBusController* controller = new RGBFusion2SMBusController(busses[bus], SMBUS_ADDRESS, dmi.getMainboard() );
RGBController_RGBFusion2SMBus* rgb_controller = new RGBController_RGBFusion2SMBus(controller);
ResourceManager::get()->RegisterRGBController(rgb_controller);
}
}
}
else
{
LOG_DEBUG(SMBUS_CHECK_DEVICE_FAILURE_EN, DETECTOR_NAME, bus, VENDOR_NAME);
}
}
}
}
else
{
LOG_DEBUG(GIGABYTE_NOT_FOUND_MB_MESSAGE_EN, DETECTOR_NAME, dmi.getMainboard().c_str());
}
} /* DetectRGBFusion2SMBusControllers() */
REGISTER_I2C_DETECTOR(DETECTOR_NAME, DetectGigabyteRGBFusion2SMBusControllers);
Controllers/GigabyteRGBFusion2SMBusController/RGBController_GigabyteRGBFusion2SMBus.cpp
+298
View File
@@ -0,0 +1,298 @@
/*---------------------------------------------------------*\
| RGBController_GigabyteRGBFusion2SMBus.cpp |
| |
| RGBController for Gigabyte Aorus RGB Fusion 2 SMBus |
| motherboard |
| |
| Matt Harper 05 May 2020 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include "RGBController_GigabyteRGBFusion2SMBus.h"
/* TODO - Validate all of these
* CPU
* ???
* Mobo logo - Verified
* Case rear
* Case
* ???
* ???
* ARGB header 1
* ARGB header 2
*
* Do ??? actually map to anything? Are they even supported?
* If not, what is an elegant way to display but not wreck existing logic?
*/
static const char* rgb_fusion_zone_names[] =
{
"CPU",
"???",
"Motherboard Logo",
"Case Rear",
"Case",
"???",
"???",
"ARGB Header 1",
"ARGB Header 2",
"???"
};
/**------------------------------------------------------------------*\
@name Gigabyte Fusion2 SMBus
@category Motherboard
@type I2C
@save :x:
@direct :white_check_mark:
@effects :white_check_mark:
@detectors DetectGigabyteRGBFusion2SMBusControllers
@comment
\*-------------------------------------------------------------------*/
RGBController_RGBFusion2SMBus::RGBController_RGBFusion2SMBus(RGBFusion2SMBusController* controller_ptr)
{
controller = controller_ptr;
name = controller->GetDeviceName();
vendor = "Gigabyte";
description = "RGB Fusion 2 SMBus";
location = controller->GetDeviceLocation();
type = DEVICE_TYPE_MOTHERBOARD;
mode Direct;
Direct.name = "Direct";
Direct.value = RGB_FUSION_2_MODE_STATIC;
Direct.flags = MODE_FLAG_HAS_PER_LED_COLOR;
Direct.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Direct);
mode Pulse;
Pulse.name = "Pulse";
Pulse.value = RGB_FUSION_2_MODE_PULSE;
Pulse.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
Pulse.speed_min = RGB_FUSION_2_SPEED_SLOW;
Pulse.speed_max = RGB_FUSION_2_SPEED_FAST;
Pulse.speed = RGB_FUSION_2_SPEED_NORMAL;
Pulse.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Pulse);
mode Flashing;
Flashing.name = "Flashing";
Flashing.value = RGB_FUSION_2_MODE_FLASHING;
Flashing.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
Flashing.speed_min = 0x01;
Flashing.speed_max = 0x04;
Flashing.speed = 0x02;
Flashing.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Flashing);
mode ColorCycle;
ColorCycle.name = "Color Cycle";
ColorCycle.value = RGB_FUSION_2_MODE_COLOR_CYCLE;
ColorCycle.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
ColorCycle.speed_min = RGB_FUSION_2_SPEED_SLOW;
ColorCycle.speed_max = RGB_FUSION_2_SPEED_FAST;
ColorCycle.speed = RGB_FUSION_2_SPEED_NORMAL;
ColorCycle.brightness_min = RGB_FUSION_2_BRIGHTNESS_MIN;
ColorCycle.brightness_max = RGB_FUSION_2_BRIGHTNESS_MAX;
ColorCycle.brightness = RGB_FUSION_2_BRIGHTNESS_MAX;
ColorCycle.color_mode = MODE_COLORS_PER_LED;
modes.push_back(ColorCycle);
mode DigitalWave;
DigitalWave.name = "Digital Wave";
DigitalWave.value = RGB_FUSION_2_MODE_DIGITAL_WAVE;
DigitalWave.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
DigitalWave.speed_min = 0xff;
DigitalWave.speed_max = 0x49;
DigitalWave.speed = 0xc1;
DigitalWave.brightness_min = RGB_FUSION_2_BRIGHTNESS_MIN;
DigitalWave.brightness_max = RGB_FUSION_2_BRIGHTNESS_MAX;
DigitalWave.brightness = RGB_FUSION_2_BRIGHTNESS_MAX;
DigitalWave.color_mode = MODE_COLORS_PER_LED;
modes.push_back(DigitalWave);
mode DigitalA;
DigitalA.name = "Digital A";
DigitalA.value = RGB_FUSION_2_MODE_DIGITAL_A;
DigitalA.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
DigitalA.speed_min = RGB_FUSION_2_DIGITAL_SPEED_MIN;
DigitalA.speed_max = RGB_FUSION_2_DIGITAL_SPEED_MAX;
DigitalA.speed = RGB_FUSION_2_DIGITAL_SPEED;
DigitalA.color_mode = MODE_COLORS_PER_LED;
modes.push_back(DigitalA);
mode DigitalB;
DigitalB.name = "Digital B";
DigitalB.value = RGB_FUSION_2_MODE_DIGITAL_B;
DigitalB.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
DigitalB.speed_min = 0xf0;
DigitalB.speed_max = 0x3c;
DigitalB.speed = 0xa0;
DigitalB.color_mode = MODE_COLORS_PER_LED;
modes.push_back(DigitalB);
mode DigitalC;
DigitalC.name = "Digital C";
DigitalC.value = RGB_FUSION_2_MODE_DIGITAL_C;
DigitalC.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
DigitalC.speed_min = RGB_FUSION_2_DIGITAL_SPEED_MIN;
DigitalC.speed_max = RGB_FUSION_2_DIGITAL_SPEED_MAX;
DigitalC.speed = RGB_FUSION_2_DIGITAL_SPEED;
DigitalC.color_mode = MODE_COLORS_PER_LED;
modes.push_back(DigitalC);
mode DigitalD;
DigitalD.name = "Digital D";
DigitalD.value = RGB_FUSION_2_MODE_DIGITAL_D;
DigitalD.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
DigitalD.speed_min = RGB_FUSION_2_DIGITAL_SPEED_MIN;
DigitalD.speed_max = RGB_FUSION_2_DIGITAL_SPEED_MAX;
DigitalD.speed = RGB_FUSION_2_DIGITAL_SPEED;
DigitalD.brightness_min = RGB_FUSION_2_BRIGHTNESS_MIN;
DigitalD.brightness_max = RGB_FUSION_2_BRIGHTNESS_MAX;
DigitalD.brightness = RGB_FUSION_2_BRIGHTNESS_MAX;
DigitalD.color_mode = MODE_COLORS_PER_LED;
modes.push_back(DigitalD);
mode DigitalE;
DigitalE.name = "Digital E";
DigitalE.value = RGB_FUSION_2_MODE_DIGITAL_E;
DigitalE.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
DigitalE.speed_min = 0x96;
DigitalE.speed_max = RGB_FUSION_2_DIGITAL_SPEED_MAX;
DigitalE.speed = 0x6e;
DigitalE.color_mode = MODE_COLORS_PER_LED;
modes.push_back(DigitalE);
mode DigitalF;
DigitalF.name = "Digital F";
DigitalF.value = RGB_FUSION_2_MODE_DIGITAL_F;
DigitalF.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS; // F technically needs brightness when in color cycle mode (no color selected)
DigitalF.speed_min = RGB_FUSION_2_DIGITAL_SPEED_MIN;
DigitalF.speed_max = RGB_FUSION_2_DIGITAL_SPEED_MAX;
DigitalF.speed = RGB_FUSION_2_DIGITAL_SPEED;
DigitalF.brightness_min = RGB_FUSION_2_BRIGHTNESS_MIN;
DigitalF.brightness_max = RGB_FUSION_2_BRIGHTNESS_MAX;
DigitalF.brightness = RGB_FUSION_2_BRIGHTNESS_MAX;
DigitalF.color_mode = MODE_COLORS_PER_LED;
modes.push_back(DigitalF);
mode DigitalG;
DigitalG.name = "Digital G";
DigitalG.value = RGB_FUSION_2_MODE_DIGITAL_G;
DigitalG.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
DigitalG.speed_min = 0x8c;
DigitalG.speed_max = 0x46;
DigitalG.speed = 0x6e;
DigitalG.brightness_min = RGB_FUSION_2_BRIGHTNESS_MIN;
DigitalG.brightness_max = RGB_FUSION_2_BRIGHTNESS_MAX;
DigitalG.brightness = RGB_FUSION_2_BRIGHTNESS_MAX;
DigitalG.color_mode = MODE_COLORS_PER_LED;
modes.push_back(DigitalG);
SetupZones();
// Initialize active mode
// TODO - broken. Need to complete GetDeviceMode
active_mode = GetDeviceMode();
}
RGBController_RGBFusion2SMBus::~RGBController_RGBFusion2SMBus()
{
delete controller;
}
void RGBController_RGBFusion2SMBus::SetupZones()
{
/*---------------------------------------------------------*\
| Search through all LEDs and create zones for each channel |
| type |
\*---------------------------------------------------------*/
for(unsigned int zone_idx = 0; zone_idx < controller->GetLEDCount(); zone_idx++)
{
zone* new_zone = new zone();
// Set zone name to channel name
new_zone->name = rgb_fusion_zone_names[zone_idx];
new_zone->leds_min = 1;
new_zone->leds_max = 1;
new_zone->leds_count = 1;
// Push new zone to zones vector
zones.push_back(*new_zone);
}
for(unsigned int led_idx = 0; led_idx < zones.size(); led_idx++)
{
led* new_led = new led();
// Set LED name to channel name
new_led->name = rgb_fusion_zone_names[led_idx];
// Push new LED to LEDs vector
leds.push_back(*new_led);
}
SetupColors();
}
void RGBController_RGBFusion2SMBus::ResizeZone(int /*zone*/, int /*new_size*/)
{
/*---------------------------------------------------------*\
| This device does not support resizing zones |
\*---------------------------------------------------------*/
}
void RGBController_RGBFusion2SMBus::DeviceUpdateLEDs()
{
for(unsigned int led = 0; led < (unsigned int)colors.size(); led++)
{
RGBColor color = colors[led];
unsigned char red = RGBGetRValue(color);
unsigned char grn = RGBGetGValue(color);
unsigned char blu = RGBGetBValue(color);
int mode = modes[active_mode].value;
unsigned int speed = modes[active_mode].speed;
unsigned int brightness = modes[active_mode].brightness;
controller->SetLEDEffect(led, mode, brightness, speed, red, grn, blu);
}
controller->Apply();
}
void RGBController_RGBFusion2SMBus::UpdateZoneLEDs(int zone)
{
RGBColor color = colors[zone];
unsigned char red = RGBGetRValue(color);
unsigned char grn = RGBGetGValue(color);
unsigned char blu = RGBGetBValue(color);
int mode = modes[active_mode].value;
unsigned int speed = modes[active_mode].speed;
unsigned int brightness = modes[active_mode].brightness;
controller->SetLEDEffect(zone, mode, brightness, speed, red, grn, blu);
controller->Apply();
}
void RGBController_RGBFusion2SMBus::UpdateSingleLED(int led)
{
UpdateZoneLEDs(led);
}
void RGBController_RGBFusion2SMBus::DeviceUpdateMode()
{
}
// TODO - Research if possible to read device state
int RGBController_RGBFusion2SMBus::GetDeviceMode()
{
return(0);
}
Controllers/GigabyteRGBFusion2SMBusController/RGBController_GigabyteRGBFusion2SMBus.h
+38
View File
@@ -0,0 +1,38 @@
/*---------------------------------------------------------*\
| RGBController_GigabyteRGBFusion2SMBus.h |
| |
| RGBController for Gigabyte Aorus RGB Fusion 2 SMBus |
| motherboard |
| |
| Matt Harper 05 May 2020 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#pragma once
#include "RGBController.h"
#include "GigabyteRGBFusion2SMBusController.h"
class RGBController_RGBFusion2SMBus : public RGBController
{
public:
RGBController_RGBFusion2SMBus(RGBFusion2SMBusController* controller_ptr);
~RGBController_RGBFusion2SMBus();
void SetupZones();
void ResizeZone(int zone, int new_size);
void DeviceUpdateLEDs();
void UpdateZoneLEDs(int zone);
void UpdateSingleLED(int led);
void DeviceUpdateMode();
private:
RGBFusion2SMBusController* controller;
int GetDeviceMode();
};