jalr/OpenRGB
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Rework and fix Polychrome v1 controller

Browse source
This commit is contained in:
TheRogueZeta 2022-07-15 00:10:10 +00:00 • committed by Adam Honse
parent ce9895412a
commit c8ce5dc973
5 changed files with 297 additions and 127 deletions
Download patch file Download diff file Expand all files Collapse all files

12
.gitlab/CODEOWNERS
View file

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

176
Controllers/ASRockSMBusController/ASRockPolychromeV1SMBusController.cpp
View file

@ -22,7 +22,6 @@ ASRockPolychromeV1SMBusController::ASRockPolychromeV1SMBusController(i2c_smbus_i
this->dev = dev; this->dev = dev;
DMIInfo dmi; DMIInfo dmi;
device_name = "ASRock " + dmi.getMainboard(); device_name = "ASRock " + dmi.getMainboard();
ReadLEDConfiguration(); ReadLEDConfiguration();
@ -62,9 +61,9 @@ void ASRockPolychromeV1SMBusController::ReadLEDConfiguration()
| The LED configuration register holds 6 bytes, so the first read should return 6 | | The LED configuration register holds 6 bytes, so the first read should return 6 |
| If not, set all zone sizes to zero | | 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 }; 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_1] = asrock_zone_count[0];
zone_led_count[POLYCHROME_V1_ZONE_2] = asrock_zone_count[1]; 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()
{ {
return(active_mode); 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;
}
} }
void ASRockPolychromeV1SMBusController::SetColorsAndSpeed(uint8_t led, uint8_t red, uint8_t green, uint8_t blue) RGBColor ASRockPolychromeV1SMBusController::GetZoneColor(uint8_t zone)
{ {
uint8_t color_speed_pkt[4] = { red, green, blue, active_speed }; LOG_TRACE("[%s] Reading color from zone %02d", device_name.c_str(), zone);
uint8_t select_led_pkt[1] = { led }; return zone_config[zone].color;
}
uint8_t ASRockPolychromeV1SMBusController::GetZoneMode(uint8_t zone)
{
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); 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 | | 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_NEON:
case POLYCHROME_V1_MODE_WATER: 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; break;
/*-----------------------------------------------------*\ /*-----------------------------------------------------*\
@ -131,7 +259,7 @@ void ASRockPolychromeV1SMBusController::SetColorsAndSpeed(uint8_t led, uint8_t r
default: default:
case POLYCHROME_V1_MODE_STATIC: case POLYCHROME_V1_MODE_STATIC:
case POLYCHROME_V1_MODE_MUSIC: 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; break;
/*-----------------------------------------------------*\ /*-----------------------------------------------------*\
@ -140,7 +268,7 @@ void ASRockPolychromeV1SMBusController::SetColorsAndSpeed(uint8_t led, uint8_t r
case POLYCHROME_V1_MODE_RANDOM: case POLYCHROME_V1_MODE_RANDOM:
case POLYCHROME_V1_MODE_WAVE: case POLYCHROME_V1_MODE_WAVE:
case POLYCHROME_V1_MODE_RAINBOW: 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; 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 }; LOG_TRACE("[%s] Updating mode for zone %02d, Mode 0x%02X, Speed 0x%02X", device_name.c_str(), zone, mode, speed);
active_zone = zone; uint8_t led_count_pkt[1] = { 0x00 };
active_mode = mode; zone_config[zone].mode = mode;
active_speed = speed; zone_config[zone].speed = speed;
/*-----------------------------------------------------*\ /*-----------------------------------------------------*\
| Make sure set all register is set to 0 | | 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 | | 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); std::this_thread::sleep_for(1ms);
/*-----------------------------------------------------*\ /*-----------------------------------------------------*\
| Write the mode | | Write the mode |
\*-----------------------------------------------------*/ \*-----------------------------------------------------*/
bus->i2c_smbus_write_block_data(dev, POLYCHROME_V1_REG_MODE, 1, &active_mode); bus->i2c_smbus_write_block_data(dev, POLYCHROME_V1_REG_MODE, 1, &zone_config[zone].mode);
std::this_thread::sleep_for(1ms); std::this_thread::sleep_for(1ms);
} }

40
Controllers/ASRockSMBusController/ASRockPolychromeV1SMBusController.h
View file

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

194
Controllers/ASRockSMBusController/RGBController_ASRockPolychromeV1SMBus.cpp
View file

@ -7,6 +7,7 @@
| Adam Honse (CalcProgrammer1) 12/15/2019 | | Adam Honse (CalcProgrammer1) 12/15/2019 |
\*-----------------------------------------*/ \*-----------------------------------------*/
#include "LogManager.h"
#include "RGBController_ASRockPolychromeV1SMBus.h" #include "RGBController_ASRockPolychromeV1SMBus.h"
static const char* polychrome_v1_zone_names[] = static const char* polychrome_v1_zone_names[] =
@ -29,6 +30,10 @@ static const char* polychrome_v1_zone_names[] =
@detectors DetectASRockSMBusControllers @detectors DetectASRockSMBusControllers
@comment ASRock Polychrome v1 controllers will save with each update. @comment ASRock Polychrome v1 controllers will save with each update.
Per ARGB LED support is not possible with these devices. 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) RGBController_ASRockPolychromeV1SMBus::RGBController_ASRockPolychromeV1SMBus(ASRockPolychromeV1SMBusController* controller_ptr)
@ -46,21 +51,21 @@ RGBController_ASRockPolychromeV1SMBus::RGBController_ASRockPolychromeV1SMBus(ASR
mode Off; mode Off;
Off.name = "Off"; Off.name = "Off";
Off.value = POLYCHROME_V1_MODE_OFF; Off.value = POLYCHROME_V1_MODE_OFF;
Off.flags = 0; Off.flags = MODE_FLAG_AUTOMATIC_SAVE;
Off.color_mode = MODE_COLORS_NONE; Off.color_mode = MODE_COLORS_NONE;
modes.push_back(Off); modes.push_back(Off);
mode Static; mode Static;
Static.name = "Static"; Static.name = "Static";
Static.value = POLYCHROME_V1_MODE_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; Static.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Static); modes.push_back(Static);
mode Breathing; mode Breathing;
Breathing.name = "Breathing"; Breathing.name = "Breathing";
Breathing.value = POLYCHROME_V1_MODE_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_min = POLYCHROME_V1_SPEED_MIN_BREATHING;
Breathing.speed_max = POLYCHROME_V1_SPEED_MAX_BREATHING; Breathing.speed_max = POLYCHROME_V1_SPEED_MAX_BREATHING;
Breathing.speed = POLYCHROME_V1_SPEED_DEFAULT_BREATHING; Breathing.speed = POLYCHROME_V1_SPEED_DEFAULT_BREATHING;
@ -70,7 +75,7 @@ RGBController_ASRockPolychromeV1SMBus::RGBController_ASRockPolychromeV1SMBus(ASR
mode Strobe; mode Strobe;
Strobe.name = "Strobe"; Strobe.name = "Strobe";
Strobe.value = POLYCHROME_V1_MODE_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_min = POLYCHROME_V1_SPEED_MIN_STROBE;
Strobe.speed_max = POLYCHROME_V1_SPEED_MAX_STROBE; Strobe.speed_max = POLYCHROME_V1_SPEED_MAX_STROBE;
Strobe.speed = POLYCHROME_V1_SPEED_DEFAULT_STROBE; Strobe.speed = POLYCHROME_V1_SPEED_DEFAULT_STROBE;
@ -80,17 +85,17 @@ RGBController_ASRockPolychromeV1SMBus::RGBController_ASRockPolychromeV1SMBus(ASR
mode SpectrumCycle; mode SpectrumCycle;
SpectrumCycle.name = "Spectrum Cycle"; SpectrumCycle.name = "Spectrum Cycle";
SpectrumCycle.value = POLYCHROME_V1_MODE_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_min = POLYCHROME_V1_SPEED_MIN_CYCLE;
SpectrumCycle.speed_max = POLYCHROME_V1_SPEED_MAX_CYCLE; SpectrumCycle.speed_max = POLYCHROME_V1_SPEED_MAX_CYCLE;
SpectrumCycle.speed = POLYCHROME_V1_SPEED_DEFAULT_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); modes.push_back(SpectrumCycle);
mode Random; mode Random;
Random.name = "Random"; Random.name = "Random";
Random.value = POLYCHROME_V1_MODE_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_min = POLYCHROME_V1_SPEED_MIN_RANDOM;
Random.speed_max = POLYCHROME_V1_SPEED_MAX_RANDOM; Random.speed_max = POLYCHROME_V1_SPEED_MAX_RANDOM;
Random.speed = POLYCHROME_V1_SPEED_DEFAULT_RANDOM; Random.speed = POLYCHROME_V1_SPEED_DEFAULT_RANDOM;
@ -98,16 +103,16 @@ RGBController_ASRockPolychromeV1SMBus::RGBController_ASRockPolychromeV1SMBus(ASR
modes.push_back(Random); modes.push_back(Random);
mode Music; mode Music;
Music.name = "Music"; Music.name = "Music";
Music.value = POLYCHROME_V1_MODE_MUSIC; Music.value = POLYCHROME_V1_MODE_MUSIC;
Music.flags = MODE_FLAG_HAS_PER_LED_COLOR; Music.flags = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
Music.color_mode = MODE_COLORS_PER_LED; Music.color_mode = MODE_COLORS_NONE;
modes.push_back(Music); modes.push_back(Music);
mode Wave; mode Wave;
Wave.name = "Wave"; Wave.name = "Wave";
Wave.value = POLYCHROME_V1_MODE_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_min = POLYCHROME_V1_SPEED_MIN_WAVE;
Wave.speed_max = POLYCHROME_V1_SPEED_MAX_WAVE; Wave.speed_max = POLYCHROME_V1_SPEED_MAX_WAVE;
Wave.speed = POLYCHROME_V1_SPEED_DEFAULT_WAVE; Wave.speed = POLYCHROME_V1_SPEED_DEFAULT_WAVE;
@ -121,7 +126,7 @@ RGBController_ASRockPolychromeV1SMBus::RGBController_ASRockPolychromeV1SMBus(ASR
mode Spring; mode Spring;
Spring.name = "Spring"; Spring.name = "Spring";
Spring.value = POLYCHROME_V1_MODE_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_min = POLYCHROME_V1_SPEED_MIN_ARGB;
Spring.speed_max = POLYCHROME_V1_SPEED_MAX_ARGB; Spring.speed_max = POLYCHROME_V1_SPEED_MAX_ARGB;
Spring.speed = POLYCHROME_V1_SPEED_DEFAULT_SPRING; Spring.speed = POLYCHROME_V1_SPEED_DEFAULT_SPRING;
@ -131,7 +136,7 @@ RGBController_ASRockPolychromeV1SMBus::RGBController_ASRockPolychromeV1SMBus(ASR
mode Stack; mode Stack;
Stack.name = "Stack"; Stack.name = "Stack";
Stack.value = POLYCHROME_V1_MODE_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_min = POLYCHROME_V1_SPEED_MIN_ARGB;
Stack.speed_max = POLYCHROME_V1_SPEED_MAX_ARGB; Stack.speed_max = POLYCHROME_V1_SPEED_MAX_ARGB;
Stack.speed = POLYCHROME_V1_SPEED_DEFAULT_STACK; Stack.speed = POLYCHROME_V1_SPEED_DEFAULT_STACK;
@ -141,7 +146,7 @@ RGBController_ASRockPolychromeV1SMBus::RGBController_ASRockPolychromeV1SMBus(ASR
mode Cram; mode Cram;
Cram.name = "Cram"; Cram.name = "Cram";
Cram.value = POLYCHROME_V1_MODE_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_min = POLYCHROME_V1_SPEED_MIN_ARGB;
Cram.speed_max = POLYCHROME_V1_SPEED_MAX_ARGB; Cram.speed_max = POLYCHROME_V1_SPEED_MAX_ARGB;
Cram.speed = POLYCHROME_V1_SPEED_DEFAULT_CRAM; Cram.speed = POLYCHROME_V1_SPEED_DEFAULT_CRAM;
@ -151,7 +156,7 @@ RGBController_ASRockPolychromeV1SMBus::RGBController_ASRockPolychromeV1SMBus(ASR
mode Scan; mode Scan;
Scan.name = "Scan"; Scan.name = "Scan";
Scan.value = POLYCHROME_V1_MODE_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_min = POLYCHROME_V1_SPEED_MIN_ARGB;
Scan.speed_max = POLYCHROME_V1_SPEED_MAX_ARGB; Scan.speed_max = POLYCHROME_V1_SPEED_MAX_ARGB;
Scan.speed = POLYCHROME_V1_SPEED_DEFAULT_SCAN; Scan.speed = POLYCHROME_V1_SPEED_DEFAULT_SCAN;
@ -161,7 +166,7 @@ RGBController_ASRockPolychromeV1SMBus::RGBController_ASRockPolychromeV1SMBus(ASR
mode Neon; mode Neon;
Neon.name = "Neon"; Neon.name = "Neon";
Neon.value = POLYCHROME_V1_MODE_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_min = POLYCHROME_V1_SPEED_MIN_ARGB;
Neon.speed_max = POLYCHROME_V1_SPEED_MAX_ARGB; Neon.speed_max = POLYCHROME_V1_SPEED_MAX_ARGB;
Neon.speed = POLYCHROME_V1_SPEED_DEFAULT_NEON; Neon.speed = POLYCHROME_V1_SPEED_DEFAULT_NEON;
@ -171,7 +176,7 @@ RGBController_ASRockPolychromeV1SMBus::RGBController_ASRockPolychromeV1SMBus(ASR
mode Water; mode Water;
Water.name = "Water"; Water.name = "Water";
Water.value = POLYCHROME_V1_MODE_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_min = POLYCHROME_V1_SPEED_MIN_ARGB;
Water.speed_max = POLYCHROME_V1_SPEED_MAX_ARGB; Water.speed_max = POLYCHROME_V1_SPEED_MAX_ARGB;
Water.speed = POLYCHROME_V1_SPEED_DEFAULT_WATER; Water.speed = POLYCHROME_V1_SPEED_DEFAULT_WATER;
@ -181,7 +186,7 @@ RGBController_ASRockPolychromeV1SMBus::RGBController_ASRockPolychromeV1SMBus(ASR
mode Rainbow; mode Rainbow;
Rainbow.name = "Rainbow"; Rainbow.name = "Rainbow";
Rainbow.value = POLYCHROME_V1_MODE_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_min = POLYCHROME_V1_SPEED_MIN_RAINBOW;
Rainbow.speed_max = POLYCHROME_V1_SPEED_MAX_RAINBOW; Rainbow.speed_max = POLYCHROME_V1_SPEED_MAX_RAINBOW;
Rainbow.speed = POLYCHROME_V1_SPEED_DEFAULT_RAINBOW; Rainbow.speed = POLYCHROME_V1_SPEED_DEFAULT_RAINBOW;
@ -189,7 +194,37 @@ RGBController_ASRockPolychromeV1SMBus::RGBController_ASRockPolychromeV1SMBus(ASR
modes.push_back(Rainbow); 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(); 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() RGBController_ASRockPolychromeV1SMBus::~RGBController_ASRockPolychromeV1SMBus()
@ -197,6 +232,18 @@ RGBController_ASRockPolychromeV1SMBus::~RGBController_ASRockPolychromeV1SMBus()
delete controller; 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() void RGBController_ASRockPolychromeV1SMBus::SetupZones()
{ {
/*---------------------------------------------------------*\ /*---------------------------------------------------------*\
@ -210,118 +257,97 @@ void RGBController_ASRockPolychromeV1SMBus::SetupZones()
{ {
if(controller->zone_led_count[zone_idx] > 0) if(controller->zone_led_count[zone_idx] > 0)
{ {
zone* new_zone = new zone(); zone* new_zone = new zone();
/*---------------------------------------------------------*\ /*---------------------------------------------------------*\
| Set zone name to channel name | | Set zone name to channel name |
\*---------------------------------------------------------*/ \*---------------------------------------------------------*/
new_zone->name = polychrome_v1_zone_names[zone_idx]; new_zone->name = polychrome_v1_zone_names[zone_idx];
new_zone->type = ZONE_TYPE_SINGLE;
new_zone->leds_min = 1; new_zone->leds_min = 1;
new_zone->leds_max = 1; new_zone->leds_max = 1;
//new_zone->leds_count = zone_led_count[zone_idx];
new_zone->leds_count = 1; new_zone->leds_count = 1;
new_zone->type = ZONE_TYPE_SINGLE;
new_zone->matrix_map = NULL; 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 | | Push new zone to zones vector |
\*---------------------------------------------------------*/ \*---------------------------------------------------------*/
zones.push_back(*new_zone); zones.push_back(*new_zone);
}
}
uint8_t led_count = 0; /*---------------------------------------------------------*\
/*---------------------------------------------------------*\ | Each zone only has one LED |
| Set up LEDs | \*---------------------------------------------------------*/
\*---------------------------------------------------------*/ led* new_led = new led();
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 = polychrome_v1_zone_names[zone_idx];
new_led->value = zone_idx;
new_led->name.append(" " + std::to_string(led_idx + 1)); /*---------------------------------------------------------*\
new_led->value = 0; | Push new LED to LEDs vector |
\*---------------------------------------------------------*/
new_led->value = zone_idx; leds.push_back(*new_led);
zoneIndexMap.push_back(zone_idx);
/*---------------------------------------------------------*\
| Push new LED to LEDs vector |
\*---------------------------------------------------------*/
leds.push_back(*new_led);
led_count++;
if(zone_idx == POLYCHROME_V1_ZONE_ADDRESSABLE)
{
break;
}
}
} }
} }
SetupColors(); SetupColors();
} }
void RGBController_ASRockPolychromeV1SMBus::ResizeZone(int /*zone*/, int /*new_size*/) void RGBController_ASRockPolychromeV1SMBus::ResizeZone(int zone, int new_size)
{ {
/*---------------------------------------------------------*\ LOG_TRACE("[%s] ResizeZone(%02X, %02X)", name.c_str(), zone, new_size);
| This device does not support resizing zones | controller-> SetARGBSize(new_size & 0xFF);
\*---------------------------------------------------------*/ zones[POLYCHROME_V1_ZONE_ADDRESSABLE].leds_count = 1;
} }
void RGBController_ASRockPolychromeV1SMBus::DeviceUpdateLEDs() 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*/) void RGBController_ASRockPolychromeV1SMBus::UpdateZoneLEDs(int /*zone*/)
{ {
LOG_TRACE("[%s] UpdateZoneLEDs()", name.c_str());
DeviceUpdateLEDs(); DeviceUpdateLEDs();
} }
void RGBController_ASRockPolychromeV1SMBus::UpdateSingleLED(int led) void RGBController_ASRockPolychromeV1SMBus::UpdateSingleLED(int zone)
{ {
unsigned char red = RGBGetRValue(colors[led]); LOG_TRACE("[%s] UpdateSingleLED(%02X)", name.c_str(), zone);
unsigned char grn = RGBGetGValue(colors[led]);
unsigned char blu = RGBGetBValue(colors[led]);
/*---------------------------------------------------------*\ uint8_t red = RGBGetRValue(colors[zone]);
| If the LED value is non-zero, this LED overrides the LED | uint8_t grn = RGBGetGValue(colors[zone]);
| index | uint8_t blu = RGBGetBValue(colors[zone]);
\*---------------------------------------------------------*/
if(leds[led].value != 0)
{
led = leds[led].value;
}
controller->SetColorsAndSpeed(led, red, grn, blu); controller->SetColorsAndSpeed(zoneIndexMap[zone], red, grn, blu);
} }
void RGBController_ASRockPolychromeV1SMBus::SetCustomMode() void RGBController_ASRockPolychromeV1SMBus::SetCustomMode()
{ {
active_mode = 1; active_mode = getModeIndex(POLYCHROME_V1_MODE_STATIC);
} }
void RGBController_ASRockPolychromeV1SMBus::DeviceUpdateMode() 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)
{ {
controller->SetMode(led_idx, modes[active_mode].value, modes[active_mode].speed); 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-> SetARGBColorOrder(modes[active_mode].direction);
controller-> SetARGBSize(modes[active_mode].speed);
} }
DeviceUpdateLEDs();
} }

2
Controllers/ASRockSMBusController/RGBController_ASRockPolychromeV1SMBus.h
View file

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