grayhook
/
OpenRGB
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Rework and fix Polychrome v1 controller

Browse Source
master
TheRogueZeta 4 years ago committed by Adam Honse
parent ce9895412a
commit c8ce5dc973
5 changed files with 297 additions and 127 deletions
Show Stats Download Patch File Download Diff File

12
.gitlab/CODEOWNERS
Unescape Escape View File

@ -10,8 +10,8 @@ CODEOWNERS @Calcprogrammer1
#-----------------------------------------------------------------------------#
[Controllers]
/Controllers/AMDWraithPrismController/
/Controllers/ASRockPolychromeSMBusController/
/Controllers/ASRockPolychromeUSBController/
/Controllers/ASRockSMBusController/
/Controllers/AlienwareController/
/Controllers/AlienwareKeyboardController/
/Controllers/AnnePro2Controller/
@ -40,8 +40,8 @@ CODEOWNERS @Calcprogrammer1
/Controllers/EKController/ @Dr_No
/Controllers/ENESMBusController/
/Controllers/EVGAAmpereGPUController/ @TheRogueZeta
/Controllers/EVGAGP102GPUController/
/Controllers/EVGAPascalGPUController/
/Controllers/EVGAGP102GPUController/
/Controllers/EVGAPascalGPUController/
/Controllers/EVGATuringGPUController/ @TheRogueZeta
/Controllers/EVGAUSBController/ @Dr_No
/Controllers/EVisionKeyboardController/
@ -102,5 +102,7 @@ CODEOWNERS @Calcprogrammer1
# that is an exception to the above should be explicitly named here #
#-----------------------------------------------------------------------------#
[Controllers]
/Controllers/ASRockPolychromeSMBusController/ASRockPolychromeSMBusController.cpp @TheRogueZeta
/Controllers/ASRockPolychromeSMBusController/ASRockPolychromeSMBusController.h @TheRogueZeta
/Controllers/ASRockSMBusController/ASRockPolychromeV1SMBusController.cpp @TheRogueZeta
/Controllers/ASRockSMBusController/ASRockPolychromeV1SMBusController.h @TheRogueZeta
/Controllers/ASRockSMBusController/RGBController_ASRockPolychromeV1SMBus.cpp @TheRogueZeta
/Controllers/ASRockSMBusController/RGBController_ASRockPolychromeV1SMBus.h @TheRogueZeta

176
Controllers/ASRockSMBusController/ASRockPolychromeV1SMBusController.cpp
Unescape Escape View File

@ -22,7 +22,6 @@ ASRockPolychromeV1SMBusController::ASRockPolychromeV1SMBusController(i2c_smbus_i
this->dev = dev;
DMIInfo dmi;
device_name = "ASRock " + dmi.getMainboard();
ReadLEDConfiguration();
@ -62,9 +61,9 @@ void ASRockPolychromeV1SMBusController::ReadLEDConfiguration()
| The LED configuration register holds 6 bytes, so the first read should return 6 |
| If not, set all zone sizes to zero |
\*---------------------------------------------------------------------------------*/
LOG_DEBUG("[%s] Reading LED config from controller", device_name.c_str());
LOG_DEBUG("[%s] Reading Zone sizes from controller", device_name.c_str());
uint8_t asrock_zone_count[I2C_SMBUS_BLOCK_MAX] = { 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 };
if (bus->i2c_smbus_read_block_data(dev, POLYCHROME_V1_REG_LED_CONFIG, asrock_zone_count) == 0x06)
if (bus->i2c_smbus_read_block_data(dev, POLYCHROME_V1_REG_ZONE_SIZE, asrock_zone_count) == 0x06)
{
zone_led_count[POLYCHROME_V1_ZONE_1] = asrock_zone_count[0];
zone_led_count[POLYCHROME_V1_ZONE_2] = asrock_zone_count[1];
@ -86,27 +85,156 @@ void ASRockPolychromeV1SMBusController::ReadLEDConfiguration()
}
}
uint8_t ASRockPolychromeV1SMBusController::GetMode()
uint8_t ASRockPolychromeV1SMBusController::GetARGBColorOrder()
{
uint8_t temp[1] = { 0x00 };
LOG_TRACE("[%s] Reading ARGB color order config from the controller", device_name.c_str());
//Read the data
if(bus->i2c_smbus_read_block_data(dev, POLYCHROME_V1_REG_ARGB_GRB, temp) == 0x01)
{
if(temp[0] == 1)
{
LOG_DEBUG("[%s] Color order is GRB for the ARGB header", device_name.c_str());
}
else
{
LOG_DEBUG("[%s] Color order is RGB for the ARGB header", device_name.c_str());
}
return temp[0];
}
else
{
return 0;
}
}
RGBColor ASRockPolychromeV1SMBusController::GetZoneColor(uint8_t zone)
{
return(active_mode);
LOG_TRACE("[%s] Reading color from zone %02d", device_name.c_str(), zone);
return zone_config[zone].color;
}
void ASRockPolychromeV1SMBusController::SetColorsAndSpeed(uint8_t led, uint8_t red, uint8_t green, uint8_t blue)
uint8_t ASRockPolychromeV1SMBusController::GetZoneMode(uint8_t zone)
{
uint8_t color_speed_pkt[4] = { red, green, blue, active_speed };
uint8_t select_led_pkt[1] = { led };
LOG_TRACE("[%s] Retreving mode %02X from zone_modes for zone %02d", device_name.c_str(), zone_config[zone].mode, zone);
return(zone_config[zone].mode);
}
void ASRockPolychromeV1SMBusController::LoadZoneConfig()
{
uint8_t zone[1] = { 0x00 };
uint8_t mode[1] = { 0xFF };
uint8_t color_speed_pkt[4] = { 0, 0, 0, 0 };
LOG_TRACE("[%s] Reading modes from all zones", device_name.c_str());
//Polychrome v1 supports per zone modes so we need to set the zone before we can read the mode.
//Write the zone index.
for(uint8_t zone_idx = 0 ; zone_idx < POLYCHROME_V1_ZONE_COUNT; zone_idx ++)
{
if(zone_led_count[zone_idx] > 0)
{
zone[0] = zone_idx;
bus->i2c_smbus_write_block_data(dev, POLYCHROME_V1_REG_ZONE_SELECT, 1, zone);
//Read the data back.
if(bus->i2c_smbus_read_block_data(dev, POLYCHROME_V1_REG_ZONE_SELECT, zone) == 0x01)
{
//Validate that we changed correctly.
if(zone[0] == zone_idx)
{
//Read the mode for the zone.
if(bus->i2c_smbus_read_block_data(dev, POLYCHROME_V1_REG_MODE, mode) == 0x01)
{
LOG_DEBUG("[%s] Mode 0x%02x for zone %02d", device_name.c_str(), mode[0], zone_idx);
zone_config[zone_idx].mode = mode[0];
bus->i2c_smbus_read_block_data(dev, zone_config[zone_idx].mode, color_speed_pkt);
zone_config[zone_idx].color = color_speed_pkt[0] << 16 | color_speed_pkt[1] << 8 | color_speed_pkt[2];
zone_config[zone_idx].speed = color_speed_pkt [3];
LOG_TRACE("[%s] Mode config: %06X, %02X", device_name.c_str(), zone_config[zone_idx].color, zone_config[zone_idx].speed );
}
}
else
{
LOG_WARNING("[%s] Zone mode register failed to change!", device_name.c_str() );
}
}
}
else
{
zone_config[zone_idx].mode = 0;
zone_config[zone_idx].color = 0;
zone_config[zone_idx].speed = 0;
}
}
}
void ASRockPolychromeV1SMBusController::SetARGBColorOrder(bool value)
{
uint8_t temp[1] = { 0x00 };
LOG_TRACE("[%s] Setting ARGB color order config to the controller", device_name.c_str());
temp[0] = (value) ? 0x01 : 0x00;
bus->i2c_smbus_write_block_data(dev, POLYCHROME_V1_REG_ARGB_GRB, 1, temp);
GetARGBColorOrder();
}
bool ASRockPolychromeV1SMBusController::SetARGBSize(uint8_t new_size)
{
LOG_DEBUG("[%s] Setting ARGB header to %02d.", device_name.c_str(), new_size);
uint8_t asrock_zone_count[6] = { 0x0 };
uint8_t new_asrock_zone_count[6] = { 0x0 };
//memcpy(new_asrock_zone_count, zone_led_count, sizeof(new_asrock_zone_count - 1));
new_asrock_zone_count[POLYCHROME_V1_ZONE_1] = zone_led_count[POLYCHROME_V1_ZONE_1];
new_asrock_zone_count[POLYCHROME_V1_ZONE_2] = zone_led_count[POLYCHROME_V1_ZONE_2];
new_asrock_zone_count[POLYCHROME_V1_ZONE_3] = zone_led_count[POLYCHROME_V1_ZONE_3];
new_asrock_zone_count[POLYCHROME_V1_ZONE_4] = zone_led_count[POLYCHROME_V1_ZONE_4];
new_asrock_zone_count[POLYCHROME_V1_ZONE_5] = zone_led_count[POLYCHROME_V1_ZONE_5];
new_asrock_zone_count[POLYCHROME_V1_ZONE_ADDRESSABLE] = new_size;
//Write the new config to the register
bus->i2c_smbus_write_block_data(dev, POLYCHROME_V1_REG_ZONE_SIZE, 6, new_asrock_zone_count);
//Validate the write
if (bus->i2c_smbus_read_block_data(dev, POLYCHROME_V1_REG_ZONE_SIZE, asrock_zone_count) == 0x06)
{
for (uint8_t i = 0; i < 6; i++)
{
if (new_asrock_zone_count[i] != asrock_zone_count[i])
{
LOG_WARNING("[%s] Failed to validate zone %02d size!", device_name.c_str(), i);
return false;
}
}
LOG_DEBUG("[%s] Zone configuration validation completed.", device_name.c_str());
return true;
}
return false;
}
void ASRockPolychromeV1SMBusController::SetColorsAndSpeed(uint8_t zone, uint8_t red, uint8_t green, uint8_t blue)
{
LOG_TRACE("[%s] Updating color and speed for zone %02d: 0x%06X", device_name.c_str(), zone, (red << 16 | green << 8 | blue));
uint8_t color_speed_pkt[4] = { red, green, blue, zone_config[zone].speed };
uint8_t select_zone_pkt[1] = { zone };
/*-----------------------------------------------------*\
| Select LED |
| Select Zone |
\*-----------------------------------------------------*/
if(active_mode != POLYCHROME_V1_MODE_OFF)
if(zone_config[zone].mode != POLYCHROME_V1_MODE_OFF)
{
bus->i2c_smbus_write_block_data(dev, POLYCHROME_V1_REG_LED_SELECT, 1, select_led_pkt);
bus->i2c_smbus_write_block_data(dev, POLYCHROME_V1_REG_ZONE_SELECT, 1, select_zone_pkt);
std::this_thread::sleep_for(1ms);
}
switch(active_mode)
switch(zone_config[zone].mode)
{
/*-----------------------------------------------------*\
| These modes take 4 bytes in R/G/B/S order |
@ -122,7 +250,7 @@ void ASRockPolychromeV1SMBusController::SetColorsAndSpeed(uint8_t led, uint8_t r
case POLYCHROME_V1_MODE_NEON:
case POLYCHROME_V1_MODE_WATER:
bus->i2c_smbus_write_block_data(dev, active_mode, 4, color_speed_pkt);
bus->i2c_smbus_write_block_data(dev, zone_config[zone].mode, 4, color_speed_pkt);
break;
/*-----------------------------------------------------*\
@ -131,7 +259,7 @@ void ASRockPolychromeV1SMBusController::SetColorsAndSpeed(uint8_t led, uint8_t r
default:
case POLYCHROME_V1_MODE_STATIC:
case POLYCHROME_V1_MODE_MUSIC:
bus->i2c_smbus_write_block_data(dev, active_mode, 3, color_speed_pkt);
bus->i2c_smbus_write_block_data(dev, zone_config[zone].mode, 3, color_speed_pkt);
break;
/*-----------------------------------------------------*\
@ -140,7 +268,7 @@ void ASRockPolychromeV1SMBusController::SetColorsAndSpeed(uint8_t led, uint8_t r
case POLYCHROME_V1_MODE_RANDOM:
case POLYCHROME_V1_MODE_WAVE:
case POLYCHROME_V1_MODE_RAINBOW:
bus->i2c_smbus_write_block_data(dev, active_mode, 1, &active_speed);
bus->i2c_smbus_write_block_data(dev, zone_config[zone].mode, 1, &zone_config[zone].speed);
break;
/*-----------------------------------------------------*\
@ -153,12 +281,12 @@ void ASRockPolychromeV1SMBusController::SetColorsAndSpeed(uint8_t led, uint8_t r
}
void ASRockPolychromeV1SMBusController::SetMode(uint8_t zone,uint8_t mode, uint8_t speed)
void ASRockPolychromeV1SMBusController::SetMode(uint8_t zone, uint8_t mode, uint8_t speed)
{
uint8_t led_count_pkt[1] = { 0x00 };
active_zone = zone;
active_mode = mode;
active_speed = speed;
LOG_TRACE("[%s] Updating mode for zone %02d, Mode 0x%02X, Speed 0x%02X", device_name.c_str(), zone, mode, speed);
uint8_t led_count_pkt[1] = { 0x00 };
zone_config[zone].mode = mode;
zone_config[zone].speed = speed;
/*-----------------------------------------------------*\
| Make sure set all register is set to 0 |
@ -169,12 +297,12 @@ void ASRockPolychromeV1SMBusController::SetMode(uint8_t zone,uint8_t mode, uint8
/*-----------------------------------------------------*\
| Set the zone we are working on |
\*-----------------------------------------------------*/
bus->i2c_smbus_write_block_data(dev, POLYCHROME_V1_REG_LED_SELECT, 1, &active_zone);
bus->i2c_smbus_write_block_data(dev, POLYCHROME_V1_REG_ZONE_SELECT, 1, &zone);
std::this_thread::sleep_for(1ms);
/*-----------------------------------------------------*\
| Write the mode |
\*-----------------------------------------------------*/
bus->i2c_smbus_write_block_data(dev, POLYCHROME_V1_REG_MODE, 1, &active_mode);
std::this_thread::sleep_for(1ms);
bus->i2c_smbus_write_block_data(dev, POLYCHROME_V1_REG_MODE, 1, &zone_config[zone].mode);
std::this_thread::sleep_for(1ms);
}

40
Controllers/ASRockSMBusController/ASRockPolychromeV1SMBusController.h
Unescape Escape View File

@ -9,6 +9,7 @@
\*-----------------------------------------*/
#include "i2c_smbus.h"
#include "RGBController.h"
#include <string>
#pragma once
@ -24,22 +25,22 @@ enum
\*------------------------------------------------------------------------------------------*/
POLYCHROME_V1_REG_FIRMWARE_VER = 0x00, /* Firmware version Major.Minor */
POLYCHROME_V1_REG_MODE = 0x30, /* Mode selection register */
POLYCHROME_V1_REG_LED_SELECT = 0x31, /* LED selection register */
POLYCHROME_V1_REG_ZONE_SELECT = 0x31, /* Zone selection register */
POLYCHROME_V1_REG_SET_ALL = 0x32, /* Set All register 0x1 = set all */
POLYCHROME_V1_REG_LED_CONFIG = 0x33, /* LED configuration register */
POLYCHROME_V1_REG_ARGB_GRB = 0x35, /* ARGB bistream reversing register */
POLYCHROME_V1_REG_ZONE_SIZE = 0x33, /* Zone size configuration register */
POLYCHROME_V1_REG_ARGB_GRB = 0x35, /* ARGB bitstream reversing register */
};
enum
{
POLYCHROME_V1_ZONE_1 = 0x00, /* RGB LED 1 Header */
POLYCHROME_V1_ZONE_2 = 0x01, /* RGB LED 2 Header */
POLYCHROME_V1_ZONE_3 = 0x02, /* Audio/PCH Zone LEDs */
POLYCHROME_V1_ZONE_4 = 0x03, /* Audio/PCH Zone LEDs */
POLYCHROME_V1_ZONE_5 = 0x04, /* IO Cover Zone LEDs */
POLYCHROME_V1_ZONE_3 = 0x02, /* PCH Zone */
POLYCHROME_V1_ZONE_4 = 0x03, /* IO Cover Zone */
POLYCHROME_V1_ZONE_5 = 0x04, /* Audio Zone LEDs */
POLYCHROME_V1_ZONE_ADDRESSABLE = 0x05, /* Addressable LED header */
POLYCHROME_V1_ZONE_COUNT = 0x06, /* Total number of zones */
POLYCHROME_V1_ZONE_ADDRESSABLE_MAX = 0x64, /* Maxinum number of ARGB LEDs */
POLYCHROME_V1_ZONE_ADDRESSABLE_MAX = 0x64, /* Maximum number of ARGB LEDs */
};
/*----------------------------------------------------------------------------------------------*\
@ -51,7 +52,7 @@ enum
{
POLYCHROME_V1_MODE_OFF = 0x10, /* OFF mode */
POLYCHROME_V1_MODE_STATIC = 0x11, /* Static color mode */
POLYCHROME_V1_MODE_BREATHING = 0x12, /* Breating effect mode */
POLYCHROME_V1_MODE_BREATHING = 0x12, /* Breathing effect mode */
POLYCHROME_V1_MODE_STROBE = 0x13, /* Strobe effect mode */
POLYCHROME_V1_MODE_SPECTRUM_CYCLE = 0x14, /* Spectrum Cycle effect mode */
POLYCHROME_V1_MODE_RANDOM = 0x15, /* Random effect mode */
@ -119,6 +120,13 @@ enum
POLYCHROME_V1_SPEED_MAX_ARGB = 0x02, /* Fastest speed */
};
struct zone_cfg
{
uint8_t mode;
uint8_t speed;
RGBColor color;
};
class ASRockPolychromeV1SMBusController
{
public:
@ -128,20 +136,24 @@ public:
std::string GetDeviceLocation();
std::string GetDeviceName();
std::string GetFirmwareVersion();
uint8_t GetMode();
uint8_t GetARGBColorOrder();
RGBColor GetZoneColor(uint8_t zone);
uint8_t GetZoneMode(uint8_t zone);
void LoadZoneConfig();
void SetARGBColorOrder(bool value);
bool SetARGBSize(uint8_t led_count);
void SetColorsAndSpeed(uint8_t led, uint8_t red, uint8_t green, uint8_t blue);
void SetMode(uint8_t zone, uint8_t mode, uint8_t speed);
uint8_t zone_led_count[6];
zone_cfg zone_config[6];
uint16_t fw_version;
private:
std::string device_name;
uint8_t active_zone;
uint8_t active_mode;
uint8_t active_speed;
i2c_smbus_interface* bus;
polychrome_dev_id dev;
void ReadLEDConfiguration();
void ReadLEDConfiguration();
};

194
Controllers/ASRockSMBusController/RGBController_ASRockPolychromeV1SMBus.cpp
Unescape Escape View File

@ -7,6 +7,7 @@
| Adam Honse (CalcProgrammer1) 12/15/2019 |
\*-----------------------------------------*/
#include "LogManager.h"
#include "RGBController_ASRockPolychromeV1SMBus.h"
static const char* polychrome_v1_zone_names[] =
@ -29,6 +30,10 @@ static const char* polychrome_v1_zone_names[] =
@detectors DetectASRockSMBusControllers
@comment ASRock Polychrome v1 controllers will save with each update.
Per ARGB LED support is not possible with these devices.
ARGB size and color order is set using the `ARGB Header Config mode`
`Right` = GRB mode that is needed for WS2812B ARGB devices and `Left` = RGB used for WS2811 strips
The modes speed slider will set the size of the header
Spectrum Cycles uses the RGB values to set the individual color brightness.
\*-------------------------------------------------------------------*/
RGBController_ASRockPolychromeV1SMBus::RGBController_ASRockPolychromeV1SMBus(ASRockPolychromeV1SMBusController* controller_ptr)
@ -46,21 +51,21 @@ RGBController_ASRockPolychromeV1SMBus::RGBController_ASRockPolychromeV1SMBus(ASR
mode Off;
Off.name = "Off";
Off.value = POLYCHROME_V1_MODE_OFF;
Off.flags = 0;
Off.flags = MODE_FLAG_AUTOMATIC_SAVE;
Off.color_mode = MODE_COLORS_NONE;
modes.push_back(Off);
mode Static;
Static.name = "Static";
Static.value = POLYCHROME_V1_MODE_STATIC;
Static.flags = MODE_FLAG_HAS_PER_LED_COLOR;
Static.flags = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
Static.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Static);
mode Breathing;
Breathing.name = "Breathing";
Breathing.value = POLYCHROME_V1_MODE_BREATHING;
Breathing.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
Breathing.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
Breathing.speed_min = POLYCHROME_V1_SPEED_MIN_BREATHING;
Breathing.speed_max = POLYCHROME_V1_SPEED_MAX_BREATHING;
Breathing.speed = POLYCHROME_V1_SPEED_DEFAULT_BREATHING;
@ -70,7 +75,7 @@ RGBController_ASRockPolychromeV1SMBus::RGBController_ASRockPolychromeV1SMBus(ASR
mode Strobe;
Strobe.name = "Strobe";
Strobe.value = POLYCHROME_V1_MODE_STROBE;
Strobe.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
Strobe.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
Strobe.speed_min = POLYCHROME_V1_SPEED_MIN_STROBE;
Strobe.speed_max = POLYCHROME_V1_SPEED_MAX_STROBE;
Strobe.speed = POLYCHROME_V1_SPEED_DEFAULT_STROBE;
@ -80,17 +85,17 @@ RGBController_ASRockPolychromeV1SMBus::RGBController_ASRockPolychromeV1SMBus(ASR
mode SpectrumCycle;
SpectrumCycle.name = "Spectrum Cycle";
SpectrumCycle.value = POLYCHROME_V1_MODE_SPECTRUM_CYCLE;
SpectrumCycle.flags = MODE_FLAG_HAS_SPEED;
SpectrumCycle.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
SpectrumCycle.speed_min = POLYCHROME_V1_SPEED_MIN_CYCLE;
SpectrumCycle.speed_max = POLYCHROME_V1_SPEED_MAX_CYCLE;
SpectrumCycle.speed = POLYCHROME_V1_SPEED_DEFAULT_CYCLE;
SpectrumCycle.color_mode = MODE_COLORS_NONE;
SpectrumCycle.color_mode = MODE_COLORS_PER_LED;
modes.push_back(SpectrumCycle);
mode Random;
Random.name = "Random";
Random.value = POLYCHROME_V1_MODE_RANDOM;
Random.flags = MODE_FLAG_HAS_SPEED;
Random.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
Random.speed_min = POLYCHROME_V1_SPEED_MIN_RANDOM;
Random.speed_max = POLYCHROME_V1_SPEED_MAX_RANDOM;
Random.speed = POLYCHROME_V1_SPEED_DEFAULT_RANDOM;
@ -98,16 +103,16 @@ RGBController_ASRockPolychromeV1SMBus::RGBController_ASRockPolychromeV1SMBus(ASR
modes.push_back(Random);
mode Music;
Music.name = "Music";
Music.value = POLYCHROME_V1_MODE_MUSIC;
Music.flags = MODE_FLAG_HAS_PER_LED_COLOR;
Music.color_mode = MODE_COLORS_PER_LED;
Music.name = "Music";
Music.value = POLYCHROME_V1_MODE_MUSIC;
Music.flags = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
Music.color_mode = MODE_COLORS_NONE;
modes.push_back(Music);
mode Wave;
Wave.name = "Wave";
Wave.value = POLYCHROME_V1_MODE_WAVE;
Wave.flags = MODE_FLAG_HAS_SPEED;
Wave.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
Wave.speed_min = POLYCHROME_V1_SPEED_MIN_WAVE;
Wave.speed_max = POLYCHROME_V1_SPEED_MAX_WAVE;
Wave.speed = POLYCHROME_V1_SPEED_DEFAULT_WAVE;
@ -121,7 +126,7 @@ RGBController_ASRockPolychromeV1SMBus::RGBController_ASRockPolychromeV1SMBus(ASR
mode Spring;
Spring.name = "Spring";
Spring.value = POLYCHROME_V1_MODE_SPRING;
Spring.flags = MODE_FLAG_HAS_SPEED;
Spring.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
Spring.speed_min = POLYCHROME_V1_SPEED_MIN_ARGB;
Spring.speed_max = POLYCHROME_V1_SPEED_MAX_ARGB;
Spring.speed = POLYCHROME_V1_SPEED_DEFAULT_SPRING;
@ -131,7 +136,7 @@ RGBController_ASRockPolychromeV1SMBus::RGBController_ASRockPolychromeV1SMBus(ASR
mode Stack;
Stack.name = "Stack";
Stack.value = POLYCHROME_V1_MODE_STACK;
Stack.flags = MODE_FLAG_HAS_SPEED;
Stack.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
Stack.speed_min = POLYCHROME_V1_SPEED_MIN_ARGB;
Stack.speed_max = POLYCHROME_V1_SPEED_MAX_ARGB;
Stack.speed = POLYCHROME_V1_SPEED_DEFAULT_STACK;
@ -141,7 +146,7 @@ RGBController_ASRockPolychromeV1SMBus::RGBController_ASRockPolychromeV1SMBus(ASR
mode Cram;
Cram.name = "Cram";
Cram.value = POLYCHROME_V1_MODE_CRAM;
Cram.flags = MODE_FLAG_HAS_SPEED;
Cram.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
Cram.speed_min = POLYCHROME_V1_SPEED_MIN_ARGB;
Cram.speed_max = POLYCHROME_V1_SPEED_MAX_ARGB;
Cram.speed = POLYCHROME_V1_SPEED_DEFAULT_CRAM;
@ -151,7 +156,7 @@ RGBController_ASRockPolychromeV1SMBus::RGBController_ASRockPolychromeV1SMBus(ASR
mode Scan;
Scan.name = "Scan";
Scan.value = POLYCHROME_V1_MODE_SCAN;
Scan.flags = MODE_FLAG_HAS_SPEED;
Scan.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
Scan.speed_min = POLYCHROME_V1_SPEED_MIN_ARGB;
Scan.speed_max = POLYCHROME_V1_SPEED_MAX_ARGB;
Scan.speed = POLYCHROME_V1_SPEED_DEFAULT_SCAN;
@ -161,7 +166,7 @@ RGBController_ASRockPolychromeV1SMBus::RGBController_ASRockPolychromeV1SMBus(ASR
mode Neon;
Neon.name = "Neon";
Neon.value = POLYCHROME_V1_MODE_NEON;
Neon.flags = MODE_FLAG_HAS_SPEED;
Neon.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
Neon.speed_min = POLYCHROME_V1_SPEED_MIN_ARGB;
Neon.speed_max = POLYCHROME_V1_SPEED_MAX_ARGB;
Neon.speed = POLYCHROME_V1_SPEED_DEFAULT_NEON;
@ -171,7 +176,7 @@ RGBController_ASRockPolychromeV1SMBus::RGBController_ASRockPolychromeV1SMBus(ASR
mode Water;
Water.name = "Water";
Water.value = POLYCHROME_V1_MODE_WATER;
Water.flags = MODE_FLAG_HAS_SPEED;
Water.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
Water.speed_min = POLYCHROME_V1_SPEED_MIN_ARGB;
Water.speed_max = POLYCHROME_V1_SPEED_MAX_ARGB;
Water.speed = POLYCHROME_V1_SPEED_DEFAULT_WATER;
@ -181,7 +186,7 @@ RGBController_ASRockPolychromeV1SMBus::RGBController_ASRockPolychromeV1SMBus(ASR
mode Rainbow;
Rainbow.name = "Rainbow";
Rainbow.value = POLYCHROME_V1_MODE_RAINBOW;
Rainbow.flags = MODE_FLAG_HAS_SPEED;
Rainbow.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
Rainbow.speed_min = POLYCHROME_V1_SPEED_MIN_RAINBOW;
Rainbow.speed_max = POLYCHROME_V1_SPEED_MAX_RAINBOW;
Rainbow.speed = POLYCHROME_V1_SPEED_DEFAULT_RAINBOW;
@ -189,7 +194,37 @@ RGBController_ASRockPolychromeV1SMBus::RGBController_ASRockPolychromeV1SMBus(ASR
modes.push_back(Rainbow);
*/
/*---------------------------------------------------------------------*\
| This ARGB_Config section is a hack to allow users to configure the |
| RGB vs GRB mode using the direction of the mode as well as set the |
| size of the devices connected to the header using the brightness |
| value. |
| |
| The mode should be removed onece the device settings are avaiable. |
\*---------------------------------------------------------------------*/
mode ARGB_Config;
ARGB_Config.name = "ARGB Header Config";
ARGB_Config.value = POLYCHROME_V1_REG_ARGB_GRB;
ARGB_Config.flags = MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
ARGB_Config.speed = controller->zone_led_count[POLYCHROME_V1_ZONE_ADDRESSABLE];
ARGB_Config.speed_min = 1;
ARGB_Config.speed_max = POLYCHROME_V1_ZONE_ADDRESSABLE_MAX;
ARGB_Config.direction = controller -> GetARGBColorOrder();
ARGB_Config.color_mode = MODE_COLORS_NONE;
modes.push_back(ARGB_Config);
SetupZones();
controller->LoadZoneConfig();
active_mode = getModeIndex(controller->zone_config[0].mode); // Hard coding zone 0 until per zone modes are available.
if(active_mode != POLYCHROME_V1_MODE_OFF)
{
for( uint8_t zone_idx = 0; zone_idx < zoneIndexMap.size(); zone_idx++)
{
zones[zone_idx].colors[0] = controller->GetZoneColor(zoneIndexMap[zone_idx]);
}
}
}
RGBController_ASRockPolychromeV1SMBus::~RGBController_ASRockPolychromeV1SMBus()
@ -197,6 +232,18 @@ RGBController_ASRockPolychromeV1SMBus::~RGBController_ASRockPolychromeV1SMBus()
delete controller;
}
uint8_t RGBController_ASRockPolychromeV1SMBus::getModeIndex(uint8_t mode_value)
{
for(uint8_t mode_index = 0; mode_index < modes.size(); mode_index++)
{
if (modes[mode_index].value == mode_value)
{
return mode_index;
}
}
return 0;
}
void RGBController_ASRockPolychromeV1SMBus::SetupZones()
{
/*---------------------------------------------------------*\
@ -210,118 +257,97 @@ void RGBController_ASRockPolychromeV1SMBus::SetupZones()
{
if(controller->zone_led_count[zone_idx] > 0)
{
zone* new_zone = new zone();
zone* new_zone = new zone();
/*---------------------------------------------------------*\
| Set zone name to channel name |
\*---------------------------------------------------------*/
new_zone->name = polychrome_v1_zone_names[zone_idx];
new_zone->type = ZONE_TYPE_SINGLE;
new_zone->leds_min = 1;
new_zone->leds_max = 1;
//new_zone->leds_count = zone_led_count[zone_idx];
new_zone->leds_count = 1;
new_zone->type = ZONE_TYPE_SINGLE;
new_zone->matrix_map = NULL;
if(zone_idx == POLYCHROME_V1_ZONE_ADDRESSABLE)
{
new_zone->leds_max = POLYCHROME_V1_ZONE_ADDRESSABLE_MAX;
}
/*---------------------------------------------------------*\
| Push new zone to zones vector |
\*---------------------------------------------------------*/
zones.push_back(*new_zone);
}
}
uint8_t led_count = 0;
/*---------------------------------------------------------*\
| Set up LEDs |
\*---------------------------------------------------------*/
for(uint8_t zone_idx = 0; zone_idx < POLYCHROME_V1_ZONE_COUNT; zone_idx++)
{
if(controller->zone_led_count[zone_idx] > 0)
{
for(uint8_t led_idx = 0; led_idx < controller->zone_led_count[zone_idx]; led_idx++)
{
/*---------------------------------------------------------*\
| Each zone only has one LED |
\*---------------------------------------------------------*/
led* new_led = new led();
new_led->name = polychrome_v1_zone_names[zone_idx];
new_led->name.append(" " + std::to_string(led_idx + 1));
new_led->value = 0;
new_led->value = zone_idx;
/*---------------------------------------------------------*\
| Push new LED to LEDs vector |
\*---------------------------------------------------------*/
leds.push_back(*new_led);
/*---------------------------------------------------------*\
| Each zone only has one LED |
\*---------------------------------------------------------*/
led* new_led = new led();
led_count++;
new_led->name = polychrome_v1_zone_names[zone_idx];
new_led->value = zone_idx;
if(zone_idx == POLYCHROME_V1_ZONE_ADDRESSABLE)
{
break;
}
}
/*---------------------------------------------------------*\
| Push new LED to LEDs vector |
\*---------------------------------------------------------*/
leds.push_back(*new_led);
zoneIndexMap.push_back(zone_idx);
}
}
SetupColors();
}
void RGBController_ASRockPolychromeV1SMBus::ResizeZone(int /*zone*/, int /*new_size*/)
void RGBController_ASRockPolychromeV1SMBus::ResizeZone(int zone, int new_size)
{
/*---------------------------------------------------------*\
| This device does not support resizing zones |
\*---------------------------------------------------------*/
LOG_TRACE("[%s] ResizeZone(%02X, %02X)", name.c_str(), zone, new_size);
controller-> SetARGBSize(new_size & 0xFF);
zones[POLYCHROME_V1_ZONE_ADDRESSABLE].leds_count = 1;
}
void RGBController_ASRockPolychromeV1SMBus::DeviceUpdateLEDs()
{
for (std::size_t led = 0; led < colors.size(); led++)
LOG_TRACE("[%s] DeviceUpdateLEDs()", name.c_str());
for (uint8_t zone_idx = 0; zone_idx < zoneIndexMap.size(); zone_idx++)
{
UpdateSingleLED(led);
UpdateSingleLED(zone_idx);
}
}
void RGBController_ASRockPolychromeV1SMBus::UpdateZoneLEDs(int /*zone*/)
{
LOG_TRACE("[%s] UpdateZoneLEDs()", name.c_str());
DeviceUpdateLEDs();
}
void RGBController_ASRockPolychromeV1SMBus::UpdateSingleLED(int led)
void RGBController_ASRockPolychromeV1SMBus::UpdateSingleLED(int zone)
{
unsigned char red = RGBGetRValue(colors[led]);
unsigned char grn = RGBGetGValue(colors[led]);
unsigned char blu = RGBGetBValue(colors[led]);
LOG_TRACE("[%s] UpdateSingleLED(%02X)", name.c_str(), zone);
/*---------------------------------------------------------*\
| If the LED value is non-zero, this LED overrides the LED |
| index |
\*---------------------------------------------------------*/
if(leds[led].value != 0)
{
led = leds[led].value;
}
uint8_t red = RGBGetRValue(colors[zone]);
uint8_t grn = RGBGetGValue(colors[zone]);
uint8_t blu = RGBGetBValue(colors[zone]);
controller->SetColorsAndSpeed(led, red, grn, blu);
controller->SetColorsAndSpeed(zoneIndexMap[zone], red, grn, blu);
}
void RGBController_ASRockPolychromeV1SMBus::SetCustomMode()
{
active_mode = 1;
active_mode = getModeIndex(POLYCHROME_V1_MODE_STATIC);
}
void RGBController_ASRockPolychromeV1SMBus::DeviceUpdateMode()
{
for(uint8_t led_idx = 0; led_idx < leds.size(); led_idx++)
LOG_TRACE("[%s] DeviceUpdateMode()", name.c_str());
if(modes[active_mode].value != POLYCHROME_V1_REG_ARGB_GRB)
{
for(uint8_t zone_idx = 0; zone_idx < zoneIndexMap.size(); zone_idx++)
{
controller->SetMode(zoneIndexMap[zone_idx], modes[active_mode].value, modes[active_mode].speed);
UpdateSingleLED(zone_idx);
}
}
else
{
controller->SetMode(led_idx, modes[active_mode].value, modes[active_mode].speed);
controller-> SetARGBColorOrder(modes[active_mode].direction);
controller-> SetARGBSize(modes[active_mode].speed);
}
DeviceUpdateLEDs();
}

2
Controllers/ASRockSMBusController/RGBController_ASRockPolychromeV1SMBus.h
Unescape Escape View File

@ -31,4 +31,6 @@ public:
private:
ASRockPolychromeV1SMBusController* controller;
uint8_t getModeIndex(uint8_t mode_value);
std::vector<uint8_t> zoneIndexMap;
};

Write Preview
Loading…
Cancel
Save