diff --git a/.gitlab/CODEOWNERS b/.gitlab/CODEOWNERS index 288c599b..f17c3308 100644 --- a/.gitlab/CODEOWNERS +++ b/.gitlab/CODEOWNERS @@ -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 diff --git a/Controllers/ASRockSMBusController/ASRockPolychromeV1SMBusController.cpp b/Controllers/ASRockSMBusController/ASRockPolychromeV1SMBusController.cpp index 4199454e..7679d162 100644 --- a/Controllers/ASRockSMBusController/ASRockPolychromeV1SMBusController.cpp +++ b/Controllers/ASRockSMBusController/ASRockPolychromeV1SMBusController.cpp @@ -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() { - 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 }; - uint8_t select_led_pkt[1] = { led }; - + LOG_TRACE("[%s] Reading color from zone %02d", device_name.c_str(), zone); + 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); } - 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); } diff --git a/Controllers/ASRockSMBusController/ASRockPolychromeV1SMBusController.h b/Controllers/ASRockSMBusController/ASRockPolychromeV1SMBusController.h index 4a5b7058..fa61ed58 100644 --- a/Controllers/ASRockSMBusController/ASRockPolychromeV1SMBusController.h +++ b/Controllers/ASRockSMBusController/ASRockPolychromeV1SMBusController.h @@ -9,6 +9,7 @@ \*-----------------------------------------*/ #include "i2c_smbus.h" +#include "RGBController.h" #include #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(); }; diff --git a/Controllers/ASRockSMBusController/RGBController_ASRockPolychromeV1SMBus.cpp b/Controllers/ASRockSMBusController/RGBController_ASRockPolychromeV1SMBus.cpp index 7f09189c..18b8da59 100644 --- a/Controllers/ASRockSMBusController/RGBController_ASRockPolychromeV1SMBus.cpp +++ b/Controllers/ASRockSMBusController/RGBController_ASRockPolychromeV1SMBus.cpp @@ -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(); + /*---------------------------------------------------------*\ + | 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; - - new_led->value = zone_idx; - - /*---------------------------------------------------------*\ - | Push new LED to LEDs vector | - \*---------------------------------------------------------*/ - leds.push_back(*new_led); - - led_count++; - - 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) { - 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(); } diff --git a/Controllers/ASRockSMBusController/RGBController_ASRockPolychromeV1SMBus.h b/Controllers/ASRockSMBusController/RGBController_ASRockPolychromeV1SMBus.h index efbfec2e..63544e87 100644 --- a/Controllers/ASRockSMBusController/RGBController_ASRockPolychromeV1SMBus.h +++ b/Controllers/ASRockSMBusController/RGBController_ASRockPolychromeV1SMBus.h @@ -31,4 +31,6 @@ public: private: ASRockPolychromeV1SMBusController* controller; + uint8_t getModeIndex(uint8_t mode_value); + std::vector zoneIndexMap; };