SDK v6: Implement client and server flags to indicate capabilities and negotiate local client status

* Split detection system out into its own class, DetectionManager
    * Clean up ResourceManger's many callbacks into just two, one for detection and one general purpose

.gitlab/CODEOWNERS

@@ -22,12 +22,13 @@ CODEOWNERS @Calcprogrammer1
 /Controllers/BlinkyTapeController/
 /Controllers/CoolerMasterController/                        @Dr_No
 /Controllers/CorsairCommanderCoreController/
-/Controllers/CorsairDRAMController/
+/Controllers/CorsairDominatorPlatinumController/
 /Controllers/CorsairHydroController/
 /Controllers/CorsairHydroPlatinumController/
 /Controllers/CorsairLightingNodeController/
 /Controllers/CorsairPeripheralController/
 /Controllers/CorsairVengeanceController/
+/Controllers/CorsairVengeanceProController/
 /Controllers/CorsairWirelessController/
 /Controllers/CreativeController/
 /Controllers/CrucialController/

Controllers/A4TechController/BloodyB820RController/RGBController_BloodyB820R.cpp

@@ -173,8 +173,6 @@ RGBController_BloodyB820R::RGBController_BloodyB820R(BloodyB820RController *cont
 
 RGBController_BloodyB820R::~RGBController_BloodyB820R()
 {
-    Shutdown();
-
     delete controller;
 }
 

Controllers/A4TechController/BloodyMouseController/RGBController_BloodyMouse.cpp

@@ -89,8 +89,6 @@ RGBController_BloodyMouse::RGBController_BloodyMouse(BloodyMouseController *cont
 
 RGBController_BloodyMouse::~RGBController_BloodyMouse()
 {
-    Shutdown();
-
     delete controller;
 }
 

Controllers/AMBXController/RGBController_AMBX.cpp

@@ -44,8 +44,6 @@ RGBController_AMBX::RGBController_AMBX(AMBXController* controller_ptr)
 
 RGBController_AMBX::~RGBController_AMBX()
 {
-    Shutdown();
-
     delete controller;
 }
 

Controllers/AMDWraithPrismController/RGBController_AMDWraithPrism.cpp

@@ -132,8 +132,6 @@ RGBController_AMDWraithPrism::RGBController_AMDWraithPrism(AMDWraithPrismControl
 
 RGBController_AMDWraithPrism::~RGBController_AMDWraithPrism()
 {
-    Shutdown();
-
     delete controller;
 }
 

Controllers/AOCKeyboardController/RGBController_AOCKeyboard.cpp

@@ -257,8 +257,6 @@ RGBController_AOCKeyboard::RGBController_AOCKeyboard(AOCKeyboardController* cont
 
 RGBController_AOCKeyboard::~RGBController_AOCKeyboard()
 {
-    Shutdown();
-
     delete controller;
 }
 

Controllers/AOCMouseController/RGBController_AOCMouse.cpp

@@ -123,8 +123,6 @@ RGBController_AOCMouse::RGBController_AOCMouse(AOCMouseController* controller_pt
 
 RGBController_AOCMouse::~RGBController_AOCMouse()
 {
-    Shutdown();
-
     delete controller;
 }
 

Controllers/AOCMousematController/RGBController_AOCMousemat.cpp

@@ -113,8 +113,6 @@ RGBController_AOCMousemat::RGBController_AOCMousemat(AOCMousematController* cont
 
 RGBController_AOCMousemat::~RGBController_AOCMousemat()
 {
-    Shutdown();
-
     delete controller;
 }
 

Controllers/ASRockPolychromeUSBController/ASRockPolychromeUSBController.cpp

@@ -191,7 +191,7 @@ void PolychromeUSBController::SetDeviceInfo()
     WriteRGSwap(rgswap_final[0], rgswap_final[1], rgswap_final[2], rgswap_final[3], rgswap_final[4], rgswap_final[5], rgswap_final[6], rgswap_final[7]);
 }
 
-void PolychromeUSBController::SetZoneSize(int zone, int new_size)
+void PolychromeUSBController::DeviceResizeZone(int zone, int new_size)
 {
     unsigned char zonecfg[POLYCHROME_USB_ZONE_MAX_NUM];
 

Controllers/ASRockPolychromeUSBController/ASRockPolychromeUSBController.h

@@ -135,7 +135,7 @@ public:
                                                     unsigned int    configsize
                                                     );
 
-    void                                        SetZoneSize(int zone, int new_size);
+    void                                        DeviceResizeZone(int zone, int new_size);
     void                                        SetRGSwap(bool reset);
 
 protected:

Controllers/ASRockPolychromeUSBController/RGBController_ASRockPolychromeUSB.cpp

@@ -185,25 +185,8 @@ RGBController_PolychromeUSB::RGBController_PolychromeUSB(PolychromeUSBController
     SetupZones();
 }
 
-RGBController_PolychromeUSB::~RGBController_PolychromeUSB()
-{
-    Shutdown();
-
-    delete controller;
-}
-
 void RGBController_PolychromeUSB::SetupZones()
 {
-    /*-----------------------------------------------------*\
-    | Only set LED count on the first run                   |
-    \*-----------------------------------------------------*/
-    bool first_run = false;
-
-    if(zones.size() == 0)
-    {
-        first_run = true;
-    }
-
     /*-------------------------------------------------*\
     | Clear any existing color/LED configuration        |
     \*-------------------------------------------------*/
@@ -214,55 +197,28 @@ void RGBController_PolychromeUSB::SetupZones()
     /*-------------------------------------------------*\
     | Set zones and leds                                |
     \*-------------------------------------------------*/
-    for(std::size_t channel_idx = 0; channel_idx < zones.size(); channel_idx++)
+    for(unsigned int channel_idx = 0; channel_idx < zones.size(); channel_idx++)
     {
         PolychromeDeviceInfo device_info = controller->GetPolychromeDevices()[channel_idx];
 
+        zones[channel_idx].type     = ZONE_TYPE_LINEAR;
+
         if(device_info.device_type== PolychromeDeviceType::ADDRESSABLE)
         {
-            zones[channel_idx].leds_min                 = 0;
-            zones[channel_idx].leds_max                 = ASROCK_ADDRESSABLE_MAX_LEDS;
-
-            if(first_run)
-            {
-                zones[channel_idx].flags                = ZONE_FLAG_MANUALLY_CONFIGURABLE_SIZE
-                                                        | ZONE_FLAG_MANUALLY_CONFIGURABLE_NAME
-                                                        | ZONE_FLAG_MANUALLY_CONFIGURABLE_TYPE
-                                                        | ZONE_FLAG_MANUALLY_CONFIGURABLE_MATRIX_MAP
-                                                        | ZONE_FLAG_MANUALLY_CONFIGURABLE_SEGMENTS;
-            }
-
-            if(!(zones[channel_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_NAME))
-            {
-                zones[channel_idx].name                 = polychrome_USB_zone_names[device_info.zone_type];
-            }
-
-            if(!(zones[channel_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_SIZE))
-            {
-                zones[channel_idx].leds_count           = device_info.num_leds;
-            }
-
-            if(!(zones[channel_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_TYPE))
-            {
-                zones[channel_idx].type                 = ZONE_TYPE_LINEAR;
-            }
-
-            if(!(zones[channel_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_MATRIX_MAP))
-            {
-                zones[channel_idx].matrix_map.width     = 0;
-                zones[channel_idx].matrix_map.height    = 0;
-                zones[channel_idx].matrix_map.map.resize(0);
-            }
+            zones[channel_idx].name       = polychrome_USB_zone_names[device_info.zone_type];
+            zones[channel_idx].leds_min   = 0;
+            zones[channel_idx].leds_max   = ASROCK_ADDRESSABLE_MAX_LEDS;
+            zones[channel_idx].leds_count = device_info.num_leds;
         }
         else if(device_info.device_type==PolychromeDeviceType::FIXED)
         {
-            zones[channel_idx].name                     = polychrome_USB_zone_names[device_info.zone_type];
-            zones[channel_idx].type                     = ZONE_TYPE_LINEAR;
-            zones[channel_idx].leds_min                 = device_info.num_leds;
-            zones[channel_idx].leds_max                 = device_info.num_leds;
-            zones[channel_idx].leds_count               = device_info.num_leds;
+            zones[channel_idx].name       = polychrome_USB_zone_names[device_info.zone_type];
+            zones[channel_idx].leds_min   = device_info.num_leds;
+            zones[channel_idx].leds_max   = device_info.num_leds;
+            zones[channel_idx].leds_count = device_info.num_leds;
         }
 
+
         for(unsigned int led_ch_idx = 0; led_ch_idx < zones[channel_idx].leds_count; led_ch_idx++)
         {
             led new_led;
@@ -315,14 +271,10 @@ void RGBController_PolychromeUSB::SetupZones()
      }
 }
 
-void RGBController_PolychromeUSB::DeviceConfigureZone(int zone_idx)
+void RGBController_PolychromeUSB::DeviceResizeZone(int zone, int new_size)
 {
-    if((size_t)zone_idx < zones.size())
-    {
-        controller->SetZoneSize(zones_info[zone_idx].zone, zones[zone_idx].leds_count);
-
-        SetupZones();
-    }
+    zones[zone].leds_count = (unsigned char) new_size;
+    controller->DeviceResizeZone(zones_info[zone].zone, new_size);
 }
 
 void RGBController_PolychromeUSB::DeviceUpdateLEDs()

Controllers/ASRockPolychromeUSBController/RGBController_ASRockPolychromeUSB.h

@@ -19,11 +19,10 @@ class RGBController_PolychromeUSB : public RGBController
 {
 public:
     RGBController_PolychromeUSB(PolychromeUSBController* controller_ptr);
-    ~RGBController_PolychromeUSB();
 
     void        SetupZones();
 
-    void        DeviceConfigureZone(int zone_idx);
+    void        DeviceResizeZone(int zone, int new_size);
 
     void        DeviceUpdateLEDs();
     void        DeviceUpdateZoneLEDs(int zone);

Controllers/ASRockSMBusController/ASRockASRRGBSMBusController/RGBController_ASRockASRRGBSMBus.cpp

@@ -113,8 +113,6 @@ RGBController_ASRockASRRGBSMBus::RGBController_ASRockASRRGBSMBus(ASRockASRRGBSMB
 
 RGBController_ASRockASRRGBSMBus::~RGBController_ASRockASRRGBSMBus()
 {
-    Shutdown();
-
     delete controller;
 }
 
@@ -161,6 +159,13 @@ void RGBController_ASRockASRRGBSMBus::SetupZones()
     SetupColors();
 }
 
+void RGBController_ASRockASRRGBSMBus::DeviceResizeZone(int /*zone*/, int /*new_size*/)
+{
+    /*---------------------------------------------------------*\
+    | This device does not support resizing zones               |
+    \*---------------------------------------------------------*/
+}
+
 void RGBController_ASRockASRRGBSMBus::DeviceUpdateLEDs()
 {
     for(unsigned int led = 0; led < colors.size(); led++)

Controllers/ASRockSMBusController/ASRockASRRGBSMBusController/RGBController_ASRockASRRGBSMBus.h

@@ -22,6 +22,8 @@ public:
 
     void        SetupZones();
 
+    void        DeviceResizeZone(int zone, int new_size);
+
     void        DeviceUpdateLEDs();
     void        DeviceUpdateZoneLEDs(int zone);
     void        DeviceUpdateSingleLED(int led);

Controllers/ASRockSMBusController/ASRockPolychromeV1SMBusController/RGBController_ASRockPolychromeV1SMBus.cpp

@@ -230,8 +230,6 @@ RGBController_ASRockPolychromeV1SMBus::RGBController_ASRockPolychromeV1SMBus(ASR
 
 RGBController_ASRockPolychromeV1SMBus::~RGBController_ASRockPolychromeV1SMBus()
 {
-    Shutdown();
-
     delete controller;
 }
 
@@ -298,9 +296,10 @@ void RGBController_ASRockPolychromeV1SMBus::SetupZones()
     SetupColors();
 }
 
-void RGBController_ASRockPolychromeV1SMBus::DeviceConfigureZone(int zone_idx)
+void RGBController_ASRockPolychromeV1SMBus::DeviceResizeZone(int zone, int new_size)
 {
-    controller-> SetARGBSize(zones[zone_idx].leds_count & 0xFF);
+    LOG_TRACE("[%s] DeviceResizeZone(%02X, %02X)", name.c_str(), zone, new_size);
+    controller-> SetARGBSize(new_size & 0xFF);
     zones[POLYCHROME_V1_ZONE_ADDRESSABLE].leds_count = 1;
 }
 

Controllers/ASRockSMBusController/ASRockPolychromeV1SMBusController/RGBController_ASRockPolychromeV1SMBus.h

@@ -23,7 +23,7 @@ public:
 
     void        SetupZones();
 
-    void        DeviceConfigureZone(int zone_idx);
+    void        DeviceResizeZone(int zone, int new_size);
 
     void        DeviceUpdateLEDs();
     void        DeviceUpdateZoneLEDs(int zone);

Controllers/ASRockSMBusController/ASRockPolychromeV2SMBusController/RGBController_ASRockPolychromeV2SMBus.cpp

@@ -185,8 +185,6 @@ RGBController_ASRockPolychromeV2SMBus::RGBController_ASRockPolychromeV2SMBus(ASR
 
 RGBController_ASRockPolychromeV2SMBus::~RGBController_ASRockPolychromeV2SMBus()
 {
-    Shutdown();
-
     delete controller;
 }
 
@@ -281,7 +279,7 @@ void RGBController_ASRockPolychromeV2SMBus::SetupZones()
     SetupColors();
 }
 
-void RGBController_ASRockPolychromeV2SMBus::DeviceConfigureZone(int /*zone_idx*/)
+void RGBController_ASRockPolychromeV2SMBus::DeviceResizeZone(int /*zone*/, int /*new_size*/)
 {
     /*---------------------------------------------------------*\
     | This device does not support resizing zones               |

Controllers/ASRockSMBusController/ASRockPolychromeV2SMBusController/RGBController_ASRockPolychromeV2SMBus.h

@@ -23,7 +23,7 @@ public:
 
     void        SetupZones();
 
-    void        DeviceConfigureZone(int zone_idx);
+    void        DeviceResizeZone(int zone, int new_size);
 
     void        DeviceUpdateLEDs();
     void        DeviceUpdateZoneLEDs(int zone);

Controllers/ASRockSMBusController/ASRockSMBusControllerDetect.cpp

@@ -85,31 +85,31 @@ uint16_t GetFirmwareVersion(i2c_smbus_interface* bus, uint8_t address)
     }
 }
 
-DetectedControllers DetectASRockSMBusControllers(std::vector<i2c_smbus_interface*>& buses)
+DetectedControllers DetectASRockSMBusControllers(std::vector<i2c_smbus_interface*>& busses)
 {
     DetectedControllers detected_controllers;
 
-    for(unsigned int bus = 0; bus < buses.size(); bus++)
+    for(unsigned int bus = 0; bus < busses.size(); bus++)
     {
-        IF_MOBO_SMBUS(buses[bus]->pci_vendor, buses[bus]->pci_device)
+        IF_MOBO_SMBUS(busses[bus]->pci_vendor, busses[bus]->pci_device)
         {
-            if(buses[bus]->pci_subsystem_vendor == ASROCK_SUB_VEN)
+            if(busses[bus]->pci_subsystem_vendor == ASROCK_SUB_VEN)
             {
                 LOG_DEBUG(SMBUS_CHECK_DEVICE_MESSAGE_EN, ASROCK_DETECTOR_NAME, bus, VENDOR_NAME, SMBUS_ADDRESS);
                 // Check for Polychrome controller at 0x6A
-                if(TestForPolychromeSMBusController(buses[bus], SMBUS_ADDRESS))
+                if(TestForPolychromeSMBusController(busses[bus], SMBUS_ADDRESS))
                 {
                     LOG_DEBUG("[%s] Detected a device at address 0x%02X, testing for a known controller",  ASROCK_DETECTOR_NAME, SMBUS_ADDRESS);
 
                     u16_to_u8 version;
-                    version.u16 = GetFirmwareVersion(buses[bus], SMBUS_ADDRESS);
+                    version.u16 = GetFirmwareVersion(busses[bus], SMBUS_ADDRESS);
 
                     switch(version.msb)
                     {
                         case ASROCK_TYPE_ASRLED:
                             {
                                 LOG_DEBUG("[%s] Found a ASR RGB LED Controller", ASROCK_DETECTOR_NAME);
-                                ASRockASRRGBSMBusController* controller = new ASRockASRRGBSMBusController(buses[bus], SMBUS_ADDRESS);
+                                ASRockASRRGBSMBusController* controller = new ASRockASRRGBSMBusController(busses[bus], SMBUS_ADDRESS);
                                 controller-> fw_version = version.u16;
                                 RGBController_ASRockASRRGBSMBus* rgb_controller = new RGBController_ASRockASRRGBSMBus(controller);
                                 detected_controllers.push_back(rgb_controller);
@@ -119,7 +119,7 @@ DetectedControllers DetectASRockSMBusControllers(std::vector<i2c_smbus_interface
                             case ASROCK_TYPE_POLYCHROME_V1:
                             {
                                 LOG_DEBUG("[%s] Found a Polychrome v1 Controller", ASROCK_DETECTOR_NAME);
-                                ASRockPolychromeV1SMBusController* controller = new ASRockPolychromeV1SMBusController(buses[bus], SMBUS_ADDRESS);
+                                ASRockPolychromeV1SMBusController* controller = new ASRockPolychromeV1SMBusController(busses[bus], SMBUS_ADDRESS);
                                 controller-> fw_version = version.u16;
                                 RGBController_ASRockPolychromeV1SMBus* rgb_controller = new RGBController_ASRockPolychromeV1SMBus(controller);
                                 detected_controllers.push_back(rgb_controller);
@@ -129,7 +129,7 @@ DetectedControllers DetectASRockSMBusControllers(std::vector<i2c_smbus_interface
                             case ASROCK_TYPE_POLYCHROME_V2:
                             {
                                 LOG_DEBUG("[%s] Found a Polychrome v2 Controller", ASROCK_DETECTOR_NAME);
-                                ASRockPolychromeV2SMBusController* controller = new ASRockPolychromeV2SMBusController(buses[bus], SMBUS_ADDRESS);
+                                ASRockPolychromeV2SMBusController* controller = new ASRockPolychromeV2SMBusController(busses[bus], SMBUS_ADDRESS);
                                 controller-> fw_version = version.u16;
                                 RGBController_ASRockPolychromeV2SMBus* rgb_controller = new RGBController_ASRockPolychromeV2SMBus(controller);
                                 detected_controllers.push_back(rgb_controller);

Controllers/AlienwareController/RGBController_Alienware.cpp

@@ -125,13 +125,6 @@ RGBController_Alienware::RGBController_Alienware(AlienwareController* controller
     controller->UpdateDim();
 }
 
-RGBController_Alienware::~RGBController_Alienware()
-{
-    Shutdown();
-
-    delete controller;
-}
-
 void RGBController_Alienware::SetupZones()
 {
     /*-------------------------------------------------*\

Controllers/AlienwareController/RGBController_Alienware.h

@@ -19,7 +19,6 @@ class RGBController_Alienware : public RGBController
 {
 public:
     RGBController_Alienware(AlienwareController* controller_ptr);
-    ~RGBController_Alienware();
 
     void        SetupZones();
 

Controllers/AlienwareKeyboardController/AlienwareAW410KController/RGBController_AlienwareAW410K.cpp

@@ -278,8 +278,6 @@ RGBController_AlienwareAW410K::RGBController_AlienwareAW410K(AlienwareAW410KCont
 
 RGBController_AlienwareAW410K::~RGBController_AlienwareAW410K()
 {
-    Shutdown();
-
     delete controller;
 }
 

Controllers/AlienwareKeyboardController/AlienwareAW510KController/RGBController_AlienwareAW510K.cpp

@@ -277,8 +277,6 @@ RGBController_AlienwareAW510K::RGBController_AlienwareAW510K(AlienwareAW510KCont
 
 RGBController_AlienwareAW510K::~RGBController_AlienwareAW510K()
 {
-    Shutdown();
-
     delete controller;
 }
 

Controllers/AlienwareMonitorController/RGBController_AlienwareAW3423DWF.cpp

@@ -46,8 +46,6 @@ RGBController_AlienwareAW3423DWF::RGBController_AlienwareAW3423DWF(AlienwareAW34
 
 RGBController_AlienwareAW3423DWF::~RGBController_AlienwareAW3423DWF()
 {
-    Shutdown();
-
     delete controller;
 }
 

Controllers/AlienwareMonitorController/RGBController_AlienwareMonitor.cpp

@@ -46,8 +46,6 @@ RGBController_AlienwareMonitor::RGBController_AlienwareMonitor(AlienwareMonitorC
 
 RGBController_AlienwareMonitor::~RGBController_AlienwareMonitor()
 {
-    Shutdown();
-
     delete controller;
 }
 

Controllers/AnnePro2Controller/RGBController_AnnePro2.cpp

@@ -144,8 +144,6 @@ RGBController_AnnePro2::RGBController_AnnePro2(AnnePro2Controller* controller_pt
 
 RGBController_AnnePro2::~RGBController_AnnePro2()
 {
-    Shutdown();
-
     delete controller;
 }
 

Controllers/ArcticController/RGBController_Arctic.cpp

@@ -55,8 +55,6 @@ RGBController_Arctic::RGBController_Arctic(ArcticController* controller_ptr)
 
 RGBController_Arctic::~RGBController_Arctic()
 {
-    Shutdown();
-
     keepalive_thread_run = false;
     keepalive_thread.join();
     delete controller;

Controllers/AresonController/RGBController_Areson.cpp

@@ -125,8 +125,6 @@ RGBController_Areson::RGBController_Areson(AresonController* controller_ptr)
 
 RGBController_Areson::~RGBController_Areson()
 {
-    Shutdown();
-
     delete controller;
 }
 

Controllers/AsusAuraCoreController/AsusAuraCoreController/RGBController_AsusAuraCore.cpp

@@ -45,13 +45,6 @@ RGBController_AuraCore::RGBController_AuraCore(AuraCoreController* controller_pt
     SetupZones();
 }
 
-RGBController_AuraCore::~RGBController_AuraCore()
-{
-    Shutdown();
-
-    delete controller;
-}
-
 void RGBController_AuraCore::SetupKeyboard()
 {
     name                    = "ASUS Aura Keyboard";
@@ -177,6 +170,11 @@ void RGBController_AuraCore::SetupGA15DH()
     modes.push_back(Static);
 }
 
+RGBController_AuraCore::~RGBController_AuraCore()
+{
+    delete controller;
+}
+
 void RGBController_AuraCore::SetupZones()
 {
     zone auraZone;

Controllers/AsusAuraCoreController/AsusAuraCoreLaptopController/RGBController_AsusAuraCoreLaptop.cpp

@@ -268,8 +268,6 @@ RGBController_AsusAuraCoreLaptop::RGBController_AsusAuraCoreLaptop(AsusAuraCoreL
 
 RGBController_AsusAuraCoreLaptop::~RGBController_AsusAuraCoreLaptop()
 {
-    Shutdown();
-
     delete controller;
 }
 

Controllers/AsusAuraGPUController/RGBController_AsusAuraGPU.cpp

@@ -124,8 +124,6 @@ RGBController_AuraGPU::RGBController_AuraGPU(AuraGPUController * controller_ptr)
 
 RGBController_AuraGPU::~RGBController_AuraGPU()
 {
-    Shutdown();
-
     delete controller;
 }
 

Controllers/AsusAuraUSBController/AsusAuraHeadsetStandController/RGBController_AsusAuraHeadsetStand.cpp

@@ -112,8 +112,6 @@ RGBController_AuraHeadsetStand::RGBController_AuraHeadsetStand(AuraHeadsetStandC
 
 RGBController_AuraHeadsetStand::~RGBController_AuraHeadsetStand()
 {
-    Shutdown();
-
     delete controller;
 }
 

Controllers/AsusAuraUSBController/AsusAuraKeyboardController/RGBController_AsusAuraKeyboard.cpp

@@ -380,8 +380,6 @@ RGBController_AuraKeyboard::RGBController_AuraKeyboard(AuraKeyboardController* c
 
 RGBController_AuraKeyboard::~RGBController_AuraKeyboard()
 {
-    Shutdown();
-
     delete controller;
 }
 

Controllers/AsusAuraUSBController/AsusAuraMonitorController/RGBController_AsusAuraMonitor.cpp

@@ -45,8 +45,6 @@ RGBController_AuraMonitor::RGBController_AuraMonitor(AuraMonitorController* cont
 
 RGBController_AuraMonitor::~RGBController_AuraMonitor()
 {
-    Shutdown();
-
     delete controller;
 }
 

Controllers/AsusAuraUSBController/AsusAuraMouseController/RGBController_AsusAuraMouse.cpp

@@ -185,8 +185,6 @@ RGBController_AuraMouse::RGBController_AuraMouse(AuraMouseController* controller
 
 RGBController_AuraMouse::~RGBController_AuraMouse()
 {
-    Shutdown();
-
     delete controller;
 }
 

Controllers/AsusAuraUSBController/AsusAuraMouseGen1Controller/RGBController_AsusROGSpatha.cpp

@@ -116,8 +116,6 @@ RGBController_AsusROGSpatha::RGBController_AsusROGSpatha(AsusAuraMouseGen1Contro
 
 RGBController_AsusROGSpatha::~RGBController_AsusROGSpatha()
 {
-    Shutdown();
-
     delete controller;
 }
 

Controllers/AsusAuraUSBController/AsusAuraMouseGen1Controller/RGBController_AsusROGStrixEvolve.cpp

@@ -79,8 +79,6 @@ RGBController_AsusROGStrixEvolve::RGBController_AsusROGStrixEvolve(AsusAuraMouse
 
 RGBController_AsusROGStrixEvolve::~RGBController_AsusROGStrixEvolve()
 {
-    Shutdown();
-
     delete controller;
 }
 

Controllers/AsusAuraUSBController/AsusAuraMousematController/RGBController_AsusAuraMousemat.cpp

@@ -182,8 +182,6 @@ RGBController_AuraMousemat::RGBController_AuraMousemat(AuraMousematController* c
 
 RGBController_AuraMousemat::~RGBController_AuraMousemat()
 {
-    Shutdown();
-
     delete controller;
 }
 

Controllers/AsusAuraUSBController/AsusAuraRyuoAIOController/RGBController_AsusAuraRyuoAIO.cpp

@@ -128,8 +128,6 @@ RGBController_AsusAuraRyuoAIO::RGBController_AsusAuraRyuoAIO(AsusAuraRyuoAIOCont
 
 RGBController_AsusAuraRyuoAIO::~RGBController_AsusAuraRyuoAIO()
 {
-    Shutdown();
-
     delete controller;
 }
 

Controllers/AsusAuraUSBController/AsusAuraTUFKeyboardController/RGBController_AsusAuraTUFKeyboard.cpp

@@ -410,8 +410,6 @@ RGBController_AuraTUFKeyboard::RGBController_AuraTUFKeyboard(AuraTUFKeyboardCont
 
 RGBController_AuraTUFKeyboard::~RGBController_AuraTUFKeyboard()
 {
-    Shutdown();
-
     delete controller;
 }
 

Controllers/AsusAuraUSBController/AsusAuraUSBController/RGBController_AsusAuraUSB.cpp

@@ -119,8 +119,6 @@ RGBController_AuraUSB::RGBController_AuraUSB(AuraUSBController* controller_ptr)
 
 RGBController_AuraUSB::~RGBController_AuraUSB()
 {
-    Shutdown();
-
     delete controller;
 }
 
@@ -147,68 +145,41 @@ void RGBController_AuraUSB::SetupZones()
     | Set zones and leds                                |
     \*-------------------------------------------------*/
     int addressableCounter = 1;
-
-    for(std::size_t channel_idx = 0; channel_idx < zones.size(); channel_idx++)
+    for (unsigned int channel_idx = 0; channel_idx < zones.size(); channel_idx++)
     {
         AuraDeviceInfo device_info  = controller->GetAuraDevices()[channel_idx];
 
+        zones[channel_idx].type     = ZONE_TYPE_LINEAR;
+
         if(device_info.device_type == AuraDeviceType::FIXED)
         {
-            zones[channel_idx].name                     = "Aura Mainboard";
-            zones[channel_idx].type                     = ZONE_TYPE_LINEAR;
-            zones[channel_idx].leds_min                 = device_info.num_leds;
-            zones[channel_idx].leds_max                 = device_info.num_leds;
-            zones[channel_idx].leds_count               = device_info.num_leds;
+            zones[channel_idx].name       = "Aura Mainboard";
+            zones[channel_idx].leds_min   = device_info.num_leds;
+            zones[channel_idx].leds_max   = device_info.num_leds;
+            zones[channel_idx].leds_count = device_info.num_leds;
         }
         else
         {
-            zones[channel_idx].leds_min                 = 0;
-            zones[channel_idx].leds_max                 = AURA_ADDRESSABLE_MAX_LEDS;
+            zones[channel_idx].name       = "Aura Addressable ";
+            zones[channel_idx].name.append(std::to_string(addressableCounter));
+            zones[channel_idx].leds_min   = 0;
+            zones[channel_idx].leds_max   = AURA_ADDRESSABLE_MAX_LEDS;
+
+            addressableCounter++;
 
             if(first_run)
             {
-                zones[channel_idx].flags                = ZONE_FLAG_MANUALLY_CONFIGURABLE_SIZE
-                                                        | ZONE_FLAG_MANUALLY_CONFIGURABLE_NAME
-                                                        | ZONE_FLAG_MANUALLY_CONFIGURABLE_TYPE
-                                                        | ZONE_FLAG_MANUALLY_CONFIGURABLE_MATRIX_MAP
-                                                        | ZONE_FLAG_MANUALLY_CONFIGURABLE_SEGMENTS;
+                zones[channel_idx].leds_count = 0;
             }
-
-            if(!(zones[channel_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_NAME))
-            {
-                zones[channel_idx].name                 = "Addressable RGB Header ";
-                zones[channel_idx].name.append(std::to_string(addressableCounter));
-            }
-
-            if(!(zones[channel_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_SIZE))
-            {
-                zones[channel_idx].leds_count           = 0;
-            }
-
-            if(!(zones[channel_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_TYPE))
-            {
-                zones[channel_idx].type                 = ZONE_TYPE_LINEAR;
-            }
-
-            if(!(zones[channel_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_MATRIX_MAP))
-            {
-                zones[channel_idx].matrix_map.width     = 0;
-                zones[channel_idx].matrix_map.height    = 0;
-                zones[channel_idx].matrix_map.map.resize(0);
-            }
-
-            addressableCounter++;
         }
 
         unsigned int num_mainboard_leds = device_info.num_leds - device_info.num_headers;
-
-        for(unsigned int led_ch_idx = 0; led_ch_idx < zones[channel_idx].leds_count; led_ch_idx++)
+        for (unsigned int led_ch_idx = 0; led_ch_idx < zones[channel_idx].leds_count; led_ch_idx++)
         {
             unsigned led_idx = led_ch_idx + 1;
             led new_led;
 
             new_led.name = zones[channel_idx].name;
-
             if(device_info.device_type == AuraDeviceType::FIXED && led_ch_idx >= num_mainboard_leds)
             {
                 new_led.name.append(", RGB Header ");
@@ -218,7 +189,6 @@ void RGBController_AuraUSB::SetupZones()
             {
                 new_led.name.append(", LED ");
             }
-
             new_led.name.append(std::to_string(led_idx));
 
             new_led.value = channel_idx;
@@ -230,10 +200,17 @@ void RGBController_AuraUSB::SetupZones()
     SetupColors();
 }
 
-void RGBController_AuraUSB::DeviceConfigureZone(int zone_idx)
+void RGBController_AuraUSB::DeviceResizeZone(int zone, int new_size)
 {
-    if((size_t)zone_idx < zones.size())
+    if((size_t) zone >= zones.size())
     {
+        return;
+    }
+
+    if(((unsigned int)new_size >= zones[zone].leds_min) && ((unsigned int)new_size <= zones[zone].leds_max))
+    {
+        zones[zone].leds_count = new_size;
+
         SetupZones();
     }
 }

Controllers/AsusAuraUSBController/AsusAuraUSBController/RGBController_AsusAuraUSB.h

@@ -24,7 +24,7 @@ public:
 
     void        SetupZones();
 
-    void        DeviceConfigureZone(int zone_idx);
+    void        DeviceResizeZone(int zone, int new_size);
 
     void        DeviceUpdateLEDs();
     void        DeviceUpdateZoneLEDs(int zone);

Controllers/AsusAuraUSBController/AsusROGAllyController/RGBController_AsusROGAlly.cpp

@@ -117,8 +117,6 @@ RGBController_AsusROGAlly::RGBController_AsusROGAlly(ROGAllyController* controll
 
 RGBController_AsusROGAlly::~RGBController_AsusROGAlly()
 {
-    Shutdown();
-
     delete controller;
 }
 

Controllers/AsusAuraUSBController/AsusROGStrixLCController/RGBController_AsusROGStrixLC.cpp

@@ -129,8 +129,6 @@ RGBController_AsusROGStrixLC::RGBController_AsusROGStrixLC(AsusROGStrixLCControl
 
 RGBController_AsusROGStrixLC::~RGBController_AsusROGStrixLC()
 {
-    Shutdown();
-
     delete controller;
 }
 

Controllers/AsusLegacyUSBController/AsusCerberusKeyboardController/RGBController_AsusCerberusKeyboard.cpp

@@ -283,8 +283,6 @@ RGBController_AsusCerberusKeyboard::RGBController_AsusCerberusKeyboard(AsusCerbe
 
 RGBController_AsusCerberusKeyboard::~RGBController_AsusCerberusKeyboard()
 {
-    Shutdown();
-
     delete controller;
 }
 

Controllers/AsusLegacyUSBController/AsusSagarisKeyboardController/RGBController_AsusSagarisKeyboard.cpp

@@ -165,8 +165,6 @@ RGBController_AsusSagarisKeyboard::RGBController_AsusSagarisKeyboard(AsusSagaris
 
 RGBController_AsusSagarisKeyboard::~RGBController_AsusSagarisKeyboard()
 {
-    Shutdown();
-
     delete controller;
 }
 

Controllers/AsusMonitorController/AsusMonitorController.cpp

@@ -89,7 +89,7 @@ void AsusMonitorController::SetDirect(std::vector<RGBColor> colors)
     usb_buf[0x00] = 0xEC;
     usb_buf[0x01] = 0x40;
     usb_buf[0x02] = 0x84;
-    usb_buf[0x04] = (uint8_t)colors.size();
+    usb_buf[0x04] = colors.size();
 
     for(size_t i = 0; i < colors.size(); i++)
     {

Controllers/AsusMonitorController/RGBController_AsusMonitor.cpp

@@ -46,8 +46,6 @@ RGBController_AsusMonitor::RGBController_AsusMonitor(AsusMonitorController* cont
 
 RGBController_AsusMonitor::~RGBController_AsusMonitor()
 {
-    Shutdown();
-
     delete controller;
 }
 

Controllers/AsusTUFLaptopController/RGBController_AsusTUFLaptop_Linux.cpp

@@ -92,13 +92,6 @@ RGBController_AsusTUFLaptopLinux::RGBController_AsusTUFLaptopLinux(AsusTUFLaptop
     SetupZones();
 }
 
-RGBController_AsusTUFLaptopLinux::~RGBController_AsusTUFLaptopLinux()
-{
-    Shutdown();
-
-    delete controller;
-}
-
 void RGBController_AsusTUFLaptopLinux::SetupZones()
 {
     /*---------------------------------------------------------*\

Controllers/AsusTUFLaptopController/RGBController_AsusTUFLaptop_Linux.h

@@ -16,7 +16,6 @@ class RGBController_AsusTUFLaptopLinux : public RGBController
 {
 public:
     RGBController_AsusTUFLaptopLinux(AsusTUFLaptopLinuxController* controller_ptr);
-    ~RGBController_AsusTUFLaptopLinux();
 
     void SetupZones();
 

Controllers/AsusTUFLaptopController/RGBController_AsusTUFLaptop_Windows.cpp

@@ -85,8 +85,6 @@ RGBController_AsusTUFLaptopWMI::RGBController_AsusTUFLaptopWMI(AsusTUFLaptopCont
 
 RGBController_AsusTUFLaptopWMI::~RGBController_AsusTUFLaptopWMI()
 {
-    Shutdown();
-
     delete controller;
 }
 

Controllers/BlinkyTapeController/RGBController_BlinkyTape.cpp

@@ -44,88 +44,84 @@ RGBController_BlinkyTape::RGBController_BlinkyTape(BlinkyTapeController* control
 
 RGBController_BlinkyTape::~RGBController_BlinkyTape()
 {
-    Shutdown();
-
     delete controller;
 }
 
 void RGBController_BlinkyTape::SetupZones()
 {
-    /*-------------------------------------------------*\
-    | Only set LED count on the first run               |
-    \*-------------------------------------------------*/
-    bool first_run = false;
-
-    if(zones.size() == 0)
-    {
-        first_run = true;
-    }
-
-    /*-------------------------------------------------*\
-    | Clear any existing color/LED configuration        |
-    \*-------------------------------------------------*/
+    zones.clear();
     leds.clear();
-    colors.clear();
-    zones.resize(1);
 
-    /*-----------------------------------------------------*\
-    | Set up zones                                          |
-    \*-----------------------------------------------------*/
-    zones[0].leds_min                   = 0;
-    zones[0].leds_max                   = 512;
+    zone led_zone;
+    led_zone.name       = "LED Strip";
+    led_zone.type       = ZONE_TYPE_LINEAR;
+    led_zone.leds_min   = 0;
+    led_zone.leds_max   = 512;
+    led_zone.leds_count = 0;
+    zones.push_back(led_zone);
 
-    if(first_run)
-    {
-        zones[0].flags                  = ZONE_FLAG_MANUALLY_CONFIGURABLE_SIZE
-                                        | ZONE_FLAG_MANUALLY_CONFIGURABLE_NAME
-                                        | ZONE_FLAG_MANUALLY_CONFIGURABLE_TYPE
-                                        | ZONE_FLAG_MANUALLY_CONFIGURABLE_MATRIX_MAP
-                                        | ZONE_FLAG_MANUALLY_CONFIGURABLE_SEGMENTS;
-    }
-
-    if(!(zones[0].flags & ZONE_FLAG_MANUALLY_CONFIGURED_NAME))
-    {
-        zones[0].name                   = "Addressable RGB Header";
-    }
-
-    if(!(zones[0].flags & ZONE_FLAG_MANUALLY_CONFIGURED_SIZE))
-    {
-        zones[0].leds_count             = 0;
-    }
-
-    if(!(zones[0].flags & ZONE_FLAG_MANUALLY_CONFIGURED_TYPE))
-    {
-        zones[0].type                   = ZONE_TYPE_LINEAR;
-    }
-
-    if(!(zones[0].flags & ZONE_FLAG_MANUALLY_CONFIGURED_MATRIX_MAP))
-    {
-        zones[0].matrix_map.width       = 0;
-        zones[0].matrix_map.height      = 0;
-        zones[0].matrix_map.map.resize(0);
-    }
-
-    /*-----------------------------------------------------*\
-    | Set up LEDs                                           |
-    \*-----------------------------------------------------*/
-    for(size_t led_idx = leds.size(); led_idx < zones[0].leds_count; led_idx++)
-    {
-        led new_led;
-        new_led.name = zones[0].name + ", LED ";
-        new_led.name.append(std::to_string(led_idx));
-
-        leds.push_back(new_led);
-    }
-
-    SetupColors();
+    DeviceResizeZone(0, led_zone.leds_count);
 }
 
-void RGBController_BlinkyTape::DeviceConfigureZone(int zone_idx)
+void RGBController_BlinkyTape::DeviceResizeZone(int zone, int new_size)
 {
-    if((size_t)zone_idx < zones.size())
+    /*-------------------------------------------------*\
+    | Explicitly cast these to avoid compiler warnings  |
+    \*-------------------------------------------------*/
+    const unsigned int zone_u       = static_cast<unsigned int>(zone);
+    const unsigned int new_size_u   = static_cast<unsigned int>(new_size);
+
+    /*-------------------------------------------------*\
+    | Check that the zone is in bounds                  |
+    \*-------------------------------------------------*/
+    if((zone_u > zones.size()) || (zone < 0))
     {
-        SetupZones();
+        return;
     }
+
+    /*-------------------------------------------------*\
+    | And that the new size is in bounds                |
+    \*-------------------------------------------------*/
+    if((new_size_u > zones.at(zone).leds_max) || (new_size_u < zones.at(zone).leds_min))
+    {
+        return;
+    }
+
+    /*-------------------------------------------------*\
+    | And that there's actually a change                |
+    \*-------------------------------------------------*/
+    if(zones.at(zone).leds_count == new_size_u)
+    {
+        return;
+    }
+
+    /*-------------------------------------------------*\
+    | If the new size is less than the current size,    |
+    | just chop off the end                             |
+    \*-------------------------------------------------*/
+    if(leds.size() > new_size_u)
+    {
+        leds.resize(new_size);
+    }
+
+    /*-------------------------------------------------*\
+    | Otherwise, add new LEDs to the end                |
+    \*-------------------------------------------------*/
+    if(leds.size() < new_size_u)
+    {
+        for(size_t led_idx = leds.size(); led_idx < new_size_u; led_idx++)
+        {
+            led new_led;
+            new_led.name = "LED ";
+            new_led.name.append(std::to_string(led_idx));
+
+            leds.push_back(new_led);
+        }
+    }
+
+    zones.at(zone).leds_count = new_size;
+
+    SetupColors();
 }
 
 void RGBController_BlinkyTape::DeviceUpdateLEDs()

Controllers/BlinkyTapeController/RGBController_BlinkyTape.h

@@ -23,7 +23,7 @@ public:
 
     void        SetupZones();
 
-    void        DeviceConfigureZone(int zone_idx);
+    void        DeviceResizeZone(int zone, int new_size);
 
     void        DeviceUpdateLEDs();
     void        DeviceUpdateZoneLEDs(int zone);

Controllers/CherryKeyboardController/RGBController_CherryKeyboard.cpp

@@ -312,8 +312,6 @@ RGBController_CherryKeyboard::RGBController_CherryKeyboard(CherryKeyboardControl
 
 RGBController_CherryKeyboard::~RGBController_CherryKeyboard()
 {
-    Shutdown();
-
     delete controller;
 }
 

Controllers/ClevoKeyboardController/ClevoKeyboardController.cpp

@@ -10,9 +10,8 @@
 |   SPDX-License-Identifier: GPL-2.0-or-later               |
 \*---------------------------------------------------------*/
 
-#include <cstring>
 #include "ClevoKeyboardController.h"
-#include "StringUtils.h"
+#include <cstring>
 
 ClevoKeyboardController::ClevoKeyboardController(hid_device* dev_handle, const hid_device_info& info)
 {
@@ -41,7 +40,10 @@ std::string ClevoKeyboardController::GetSerialString()
         return("");
     }
 
-    return(StringUtils::wstring_to_string(serial_string));
+    std::wstring return_wstring = serial_string;
+    std::string return_string(return_wstring.begin(), return_wstring.end());
+
+    return(return_string);
 }
 
 std::string ClevoKeyboardController::GetFirmwareVersion()

Controllers/ClevoKeyboardController/ClevoKeyboardControllerDetect.cpp

@@ -9,8 +9,8 @@
 |   SPDX-License-Identifier: GPL-2.0-or-later               |
 \*---------------------------------------------------------*/
 
-#include "ClevoKeyboardController.h"
 #include "DetectionManager.h"
+#include "ClevoKeyboardController.h"
 #include "RGBController_ClevoKeyboard.h"
 #include "RGBController.h"
 #include <hidapi.h>
@@ -26,7 +26,7 @@
 \*---------------------------------------------------------*/
 #define CLEVO_KEYBOARD_PID_600B                 0x600B
 
-DetectedControllers DetectClevoKeyboardControllers(hid_device_info* info, const std::string& /*name*/)
+DetectedControllers DetectClevoKeyboardControllers(hid_device_info* info, const std::string& name)
 {
     DetectedControllers detected_controllers;
     hid_device*         dev;

Controllers/ClevoKeyboardController/RGBController_ClevoKeyboard.cpp

@@ -199,8 +199,6 @@ RGBController_ClevoKeyboard::RGBController_ClevoKeyboard(ClevoKeyboardController
 
 RGBController_ClevoKeyboard::~RGBController_ClevoKeyboard()
 {
-    Shutdown();
-
     delete controller;
 }
 

Controllers/ClevoLightbarController/ClevoLightbarController.cpp

@@ -10,9 +10,8 @@
 |   SPDX-License-Identifier: GPL-2.0-or-later               |
 \*---------------------------------------------------------*/
 
-#include <cstring>
 #include "ClevoLightbarController.h"
-#include "StringUtils.h"
+#include <cstring>
 
 ClevoLightbarController::ClevoLightbarController(hid_device* dev_handle, const hid_device_info& info)
 {
@@ -41,7 +40,10 @@ std::string ClevoLightbarController::GetSerialString()
         return("");
     }
 
-    return(StringUtils::wstring_to_string(serial_string));
+    std::wstring return_wstring = serial_string;
+    std::string return_string(return_wstring.begin(), return_wstring.end());
+
+    return(return_string);
 }
 
 std::string ClevoLightbarController::GetFirmwareVersion()

Controllers/ClevoLightbarController/ClevoLightbarControllerDetect.cpp

@@ -9,8 +9,8 @@
 |   SPDX-License-Identifier: GPL-2.0-or-later               |
 \*---------------------------------------------------------*/
 
-#include "ClevoLightbarController.h"
 #include "DetectionManager.h"
+#include "ClevoLightbarController.h"
 #include "RGBController_ClevoLightbar.h"
 #include "RGBController.h"
 #include <hidapi.h>
@@ -25,7 +25,7 @@
 \*---------------------------------------------------------*/
 #define CLEVO_LIGHTBAR_PID                      0x7001
 
-DetectedControllers DetectClevoLightbarControllers(hid_device_info* info, const std::string& /*name*/)
+DetectedControllers DetectClevoLightbarControllers(hid_device_info* info, const std::string& name)
 {
     DetectedControllers detected_controllers;
     hid_device*         dev;

Controllers/ClevoLightbarController/RGBController_ClevoLightbar.cpp

@@ -121,8 +121,6 @@ RGBController_ClevoLightbar::RGBController_ClevoLightbar(ClevoLightbarController
 
 RGBController_ClevoLightbar::~RGBController_ClevoLightbar()
 {
-    Shutdown();
-
     delete controller;
 }
 

Controllers/ColorfulGPUController/ColorfulGPUControllerDetect.cpp

@@ -76,6 +76,3 @@ REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 4080 Ultra W OC-V",           Detec
 REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 4080 Ultra W OC-V",           DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX4080_DEV,          COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_4080_ULTRAW_OCV2,            0x61);
 REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 4090 Advanced OC-V",          DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX4090_DEV,          COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_4090_ADVANCED_OCV,           0x61);
 REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 4090 Advanced OC-V",          DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX4090_DEV,          COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_4090_ADVANCED_OCV2,          0x61);
-REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 5060 Ti Ultra W DUO OC",      DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX5060TI_DEV,        COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_5060TI_ULTRAW_DUO_OC,          0x61);
-REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 5070 Ultra W OC-V",           DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX5070_DEV,          COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_5070_ULTRAW_OCV,             0x61);
-REGISTER_I2C_PCI_DETECTOR("iGame GeForce RTX 5070 Ultra W OC-V",           DetectColorfulGPUControllers,   NVIDIA_VEN, NVIDIA_RTX5070_DEV,          COLORFUL_SUB_VEN,   COLORFUL_IGAME_RTX_5070_ULTRAW_OCV2,            0x61);

Controllers/ColorfulGPUController/RGBController_ColorfulGPU.cpp

@@ -44,8 +44,6 @@ RGBController_ColorfulGPU::RGBController_ColorfulGPU(ColorfulGPUController * col
 
 RGBController_ColorfulGPU::~RGBController_ColorfulGPU()
 {
-    Shutdown();
-
     delete controller;
 }
 

Controllers/ColorfulTuringGPUController/RGBController_ColorfulTuringGPU.cpp

@@ -75,8 +75,6 @@ RGBController_ColorfulTuringGPU::RGBController_ColorfulTuringGPU(ColorfulTuringG
 
 RGBController_ColorfulTuringGPU::~RGBController_ColorfulTuringGPU()
 {
-    Shutdown();
-
     delete controller;
 }
 

Controllers/CoolerMasterController/CMARGBController/CMARGBController.cpp

@@ -12,27 +12,16 @@
 #include "CMARGBController.h"
 #include "StringUtils.h"
 
-/*---------------------------------------------------------*\
-| Map to convert port index to port ID used in protocol     |
-\*---------------------------------------------------------*/
-static unsigned char cm_argb_port_index_to_id[5] =
+CMARGBController::CMARGBController(hid_device* dev_handle, char *_path, unsigned char _zone_idx, std::shared_ptr<std::mutex> cm_mutex)
 {
-    CM_ARGB_PORT_ARGB_1,
-    CM_ARGB_PORT_ARGB_2,
-    CM_ARGB_PORT_ARGB_3,
-    CM_ARGB_PORT_ARGB_4,
-    CM_ARGB_PORT_RGB
-};
+    dev                     = dev_handle;
+    location                = _path;
+    zone_index              = _zone_idx;
+    mutex_ptr               = cm_mutex;
 
-CMARGBController::CMARGBController(hid_device* dev_handle, char *path)
-{
-    dev         = dev_handle;
-    location    = path;
-
-    /*-----------------------------------------------------*\
-    | Get device name from HID manufacturer and product     |
-    | strings                                               |
-    \*-----------------------------------------------------*/
+    /*---------------------------------------------------------*\
+    | Get device name from HID manufacturer and product strings |
+    \*---------------------------------------------------------*/
     wchar_t name_string[HID_MAX_STR];
 
     hid_get_manufacturer_string(dev, name_string, HID_MAX_STR);
@@ -40,11 +29,57 @@ CMARGBController::CMARGBController(hid_device* dev_handle, char *path)
 
     hid_get_product_string(dev, name_string, HID_MAX_STR);
     device_name.append(" ").append(StringUtils::wstring_to_string(name_string));
+
+    GetStatus();
 }
 
 CMARGBController::~CMARGBController()
 {
-    hid_close(dev);
+    if(mutex_ptr.use_count() <= 1)
+    {
+        hid_close(dev);
+    }
+}
+
+void CMARGBController::GetStatus()
+{
+    unsigned char buffer[CM_ARGB_PACKET_SIZE]   = { 0x00, 0x80, 0x0B, 0x01 };
+    int buffer_size                             = (sizeof(buffer) / sizeof(buffer[0]));
+    int rgb_offset                              = 0;
+    int zone;
+
+    if (argb_header_data[zone_index].digital)
+    {
+        zone                                    = argb_header_data[zone_index].header;
+        buffer[CM_ARGB_COMMAND_BYTE]            = 0x0B;
+    }
+    else
+    {
+        zone                                    = 0x00;
+        buffer[CM_ARGB_COMMAND_BYTE]            = 0x0A;
+        rgb_offset                              = 1;
+    }
+
+    /*---------------------------------------------*\
+    | Guard the writes to the controller until the  |
+    |   for loop has completed to avoid collisons   |
+    \*---------------------------------------------*/
+    std::lock_guard<std::mutex> guard(*mutex_ptr);
+
+    /*---------------------------------------------------------*\
+    | If this is the group then just return the first status    |
+    \*---------------------------------------------------------*/
+    buffer[CM_ARGB_ZONE_BYTE]                   = ( zone > 0x08 ) ? 0x01 : zone;
+    hid_write(dev, buffer, buffer_size);
+    hid_read_timeout(dev, buffer, buffer_size, CM_ARGB_INTERRUPT_TIMEOUT);
+
+    current_mode                                = buffer[4 - rgb_offset];
+    bool_random                                 = ( buffer[5 - rgb_offset] == 0x00 );
+    current_speed                               = buffer[6 - rgb_offset];
+    current_brightness                          = buffer[7 - rgb_offset];
+    current_red                                 = buffer[8 - rgb_offset];
+    current_green                               = buffer[9 - rgb_offset];
+    current_blue                                = buffer[10 - rgb_offset];
 }
 
 std::string CMARGBController::GetDeviceName()
@@ -52,33 +87,6 @@ std::string CMARGBController::GetDeviceName()
     return(device_name);
 }
 
-std::string CMARGBController::GetLocation()
-{
-    return("HID: " + location);
-}
-
-std::string CMARGBController::GetVersion()
-{
-    /*-----------------------------------------------------*\
-    | This device uses the serial value to determine the    |
-    | version.  It does not report a proper unique serial.  |
-    \*-----------------------------------------------------*/
-    std::string serial_string = GetSerial();
-
-    if(serial_string == CM_ARGB_FW0023)
-    {
-        return("0023");
-    }
-    else if(serial_string == CM_ARGB_FW0028)
-    {
-        return("0028");
-    }
-    else
-    {
-        return("Unsupported");
-    }
-}
-
 std::string CMARGBController::GetSerial()
 {
     wchar_t serial_string[HID_MAX_STR];
@@ -92,187 +100,118 @@ std::string CMARGBController::GetSerial()
     return(StringUtils::wstring_to_string(serial_string));
 }
 
-void CMARGBController::GetPortStatus
-    (
-    unsigned char   port_idx,
-    unsigned char*  port_mode,
-    unsigned char*  port_speed,
-    unsigned char*  port_brightness,
-    bool*           port_random,
-    unsigned char*  port_red,
-    unsigned char*  port_green,
-    unsigned char*  port_blue
-    )
+std::string CMARGBController::GetLocation()
 {
-    unsigned char buffer[CM_ARGB_PACKET_SIZE]   = {0x00, 0x80, 0x0B, 0x01};
-    int buffer_size                             = (sizeof(buffer) / sizeof(buffer[0]));
-    int rgb_offset                              = 0;
-    int zone;
-
-    /*-----------------------------------------------------*\
-    | RGB port is handled differently from ARGB ports       |
-    \*-----------------------------------------------------*/
-    if(cm_argb_port_index_to_id[port_idx] != CM_ARGB_PORT_RGB)
-    {
-        zone                                    = cm_argb_port_index_to_id[port_idx];
-        buffer[CM_ARGB_COMMAND_BYTE]            = 0x0B;
-    }
-    else
-    {
-        zone                                    = 0x00;
-        buffer[CM_ARGB_COMMAND_BYTE]            = 0x0A;
-        rgb_offset                              = 1;
-    }
-
-    /*-----------------------------------------------------*\
-    | If this is the group then just return the first       |
-    | status                                                |
-    \*-----------------------------------------------------*/
-    buffer[CM_ARGB_ZONE_BYTE]                   = ( zone > 0x08 ) ? 0x01 : zone;
-
-    /*-----------------------------------------------------*\
-    | Send the command and read the response                |
-    \*-----------------------------------------------------*/
-    hid_write(dev, buffer, buffer_size);
-    hid_read_timeout(dev, buffer, buffer_size, CM_ARGB_INTERRUPT_TIMEOUT);
-
-    /*-----------------------------------------------------*\
-    | Read data out of response                             |
-    \*-----------------------------------------------------*/
-    *port_mode                                  = buffer[4 - rgb_offset];
-    *port_random                                = (buffer[5 - rgb_offset] == 0x00);
-    *port_speed                                 = buffer[6 - rgb_offset];
-    *port_brightness                            = buffer[7 - rgb_offset];
-    *port_red                                   = buffer[8 - rgb_offset];
-    *port_green                                 = buffer[9 - rgb_offset];
-    *port_blue                                  = buffer[10 - rgb_offset];
+    return("HID: " + location);
 }
 
-void CMARGBController::SetPortLEDCount(unsigned char port_idx, unsigned char led_count)
+unsigned char CMARGBController::GetZoneIndex()
 {
-    unsigned char buffer[CM_ARGB_PACKET_SIZE]   = {0x00, 0x80, 0x0D, 0x02};
+    return(zone_index);
+}
+
+unsigned char CMARGBController::GetMode()
+{
+    return(current_mode);
+}
+
+unsigned char CMARGBController::GetLedRed()
+{
+    return(current_red);
+}
+
+unsigned char CMARGBController::GetLedGreen()
+{
+    return(current_green);
+}
+
+unsigned char CMARGBController::GetLedBlue()
+{
+    return(current_blue);
+}
+
+unsigned char CMARGBController::GetLedSpeed()
+{
+    return(current_speed);
+}
+
+bool CMARGBController::GetRandomColours()
+{
+    return(bool_random);
+}
+
+void CMARGBController::SetLedCount(int zone, int led_count)
+{
+    unsigned char buffer[CM_ARGB_PACKET_SIZE]   = { 0x00, 0x80, 0x0D, 0x02 };
     int  buffer_size                            = (sizeof(buffer) / sizeof(buffer[0]));
 
-    buffer[CM_ARGB_ZONE_BYTE]                   = cm_argb_port_index_to_id[port_idx];
+    buffer[CM_ARGB_ZONE_BYTE]                   = zone;
     buffer[CM_ARGB_MODE_BYTE]                   = led_count;
-    buffer[CM_ARGB_COLOUR_INDEX_BYTE]           = 1;
+    buffer[CM_ARGB_COLOUR_INDEX_BYTE]           = (0x0F - led_count > 0) ? 0x0F - led_count : 0x01;
+
+    /*---------------------------------------------*\
+    | Guard the writes to the controller until the  |
+    |   for loop has completed to avoid collisons   |
+    \*---------------------------------------------*/
+    std::lock_guard<std::mutex> guard(*mutex_ptr);
 
-    /*-----------------------------------------------------*\
-    | Send the command                                      |
-    \*-----------------------------------------------------*/
     hid_write(dev, buffer, buffer_size);
 }
 
-void CMARGBController::SetPortMode
-    (
-    unsigned char   port_idx,
-    unsigned char   port_mode,
-    unsigned char   port_speed,
-    unsigned char   port_brightness,
-    bool            port_random,
-    unsigned char   port_red,
-    unsigned char   port_green,
-    unsigned char   port_blue
-    )
+void CMARGBController::SetMode(uint8_t mode, uint8_t speed, uint8_t brightness, RGBColor colour, bool random_colours)
 {
-    unsigned char buffer[CM_ARGB_PACKET_SIZE]   = {0x00};
-    int  buffer_size                            = (sizeof(buffer) / sizeof(buffer[0]));
-    bool boolARGB_header                        = (cm_argb_port_index_to_id[port_idx] != CM_ARGB_PORT_RGB);
-    bool boolPassthru                           = (port_mode == CM_ARGB_MODE_PASSTHRU) || (port_mode == CM_RGB_MODE_PASSTHRU);
-    bool boolDirect                             = (port_mode == CM_ARGB_MODE_DIRECT);
-    unsigned char function                      = boolPassthru ? (boolARGB_header ? 0x02 : 0x04) : (boolARGB_header ? 0x01 : 0x03);
-    buffer[CM_ARGB_REPORT_BYTE]                 = 0x80;
-    buffer[CM_ARGB_COMMAND_BYTE]                = 0x01;
+    bool needs_update   = !( (current_mode == mode) && (current_speed == speed) && (current_brightness == brightness) && (ToRGBColor(current_red, current_green, current_blue) == colour));
 
-    if(boolDirect)
+    if (needs_update)
     {
-        buffer[CM_ARGB_FUNCTION_BYTE]           = 0x01;
-        buffer[CM_ARGB_ZONE_BYTE]               = 0x02;
+        current_mode        = mode;
+        current_speed       = speed;
+        current_brightness  = brightness;
+        current_red         = RGBGetRValue(colour);
+        current_green       = RGBGetGValue(colour);
+        current_blue        = RGBGetBValue(colour);
+        bool_random         = random_colours;
 
-        /*-------------------------------------------------*\
-        | Send the command                                  |
-        \*-------------------------------------------------*/
-        hid_write(dev, buffer, buffer_size);
-
-        /*-------------------------------------------------*\
-        | Direct mode is now set up and no other mode       |
-        | packet is required                                |
-        \*-------------------------------------------------*/
-        return;
+        SendUpdate();
     }
-
-    buffer[CM_ARGB_FUNCTION_BYTE]               = function;
-
-    /*-----------------------------------------------------*\
-    | Send the command                                      |
-    \*-----------------------------------------------------*/
-    hid_write(dev, buffer, buffer_size);
-
-    /*-----------------------------------------------------*\
-    | ARGB ports send command 0x0B, RGB port sends 0x04     |
-    \*-----------------------------------------------------*/
-    if(boolARGB_header)
-    {
-        buffer[CM_ARGB_COMMAND_BYTE]                        = 0x0B;
-        buffer[CM_ARGB_FUNCTION_BYTE]                       = (false) ? 0x01 : 0x02;
-        buffer[CM_ARGB_ZONE_BYTE]                           = cm_argb_port_index_to_id[port_idx];
-        buffer[CM_ARGB_MODE_BYTE]                           = port_mode;
-        buffer[CM_ARGB_COLOUR_INDEX_BYTE]                   = port_random ? 0x00 : 0x10;
-        buffer[CM_ARGB_SPEED_BYTE]                          = port_speed;
-        buffer[CM_ARGB_BRIGHTNESS_BYTE]                     = port_brightness;
-        buffer[CM_ARGB_RED_BYTE]                            = port_red;
-        buffer[CM_ARGB_GREEN_BYTE]                          = port_green;
-        buffer[CM_ARGB_BLUE_BYTE]                           = port_blue;
-    }
-    else
-    {
-        buffer[CM_ARGB_COMMAND_BYTE]                        = boolPassthru ? 0x01 : 0x04;
-        buffer[CM_ARGB_MODE_BYTE + CM_RGB_OFFSET]           = port_mode;
-        buffer[CM_ARGB_COLOUR_INDEX_BYTE + CM_RGB_OFFSET]   = port_random ? 0x00 : 0x10;
-        buffer[CM_ARGB_SPEED_BYTE + CM_RGB_OFFSET]          = port_speed;
-        buffer[CM_ARGB_BRIGHTNESS_BYTE + CM_RGB_OFFSET]     = port_brightness;
-        buffer[CM_ARGB_RED_BYTE + CM_RGB_OFFSET]            = port_red;
-        buffer[CM_ARGB_GREEN_BYTE + CM_RGB_OFFSET]          = port_green;
-        buffer[CM_ARGB_BLUE_BYTE + CM_RGB_OFFSET]           = port_blue;
-    }
-
-    /*-----------------------------------------------------*\
-    | Send the command and wait for response                |
-    \*-----------------------------------------------------*/
-    hid_write(dev, buffer, buffer_size);
 }
 
-void CMARGBController::SetPortLEDsDirect(unsigned char port_idx, RGBColor *led_colours, unsigned int led_count)
+void CMARGBController::SetLedsDirect(RGBColor *led_colours, unsigned int led_count)
 {
     const unsigned char buffer_size     = CM_ARGB_PACKET_SIZE;
     unsigned char buffer[buffer_size]   = { 0x00, 0x00, 0x07, 0x02 };
     unsigned char packet_count          = 0;
     std::vector<uint8_t> colours;
 
-    /*-----------------------------------------------------*\
-    | Set up the RGB triplets to send                       |
-    \*-----------------------------------------------------*/
+    /*---------------------------------------------*\
+    | Set up the RGB triplets to send               |
+    \*---------------------------------------------*/
     for(unsigned int i = 0; i < led_count; i++)
     {
         RGBColor      colour            = led_colours[i];
 
-        colours.push_back(RGBGetRValue(colour));
-        colours.push_back(RGBGetGValue(colour));
-        colours.push_back(RGBGetBValue(colour));
+        colours.push_back( RGBGetRValue(colour) );
+        colours.push_back( RGBGetGValue(colour) );
+        colours.push_back( RGBGetBValue(colour) );
     }
 
-    buffer[CM_ARGB_FUNCTION_BYTE]       = port_idx;
+    buffer[CM_ARGB_FUNCTION_BYTE]       = zone_index - 1;
     buffer[CM_ARGB_ZONE_BYTE]           = led_count;
     unsigned char buffer_idx            = CM_ARGB_MODE_BYTE;
 
+    /*---------------------------------------------*\
+    | Guard the writes to the controller until the  |
+    |   for loop has completed to avoid collisons   |
+    \*---------------------------------------------*/
+    std::lock_guard<std::mutex> guard(*mutex_ptr);
+
     for(std::vector<unsigned char>::iterator it = colours.begin(); it != colours.end(); buffer_idx = CM_ARGB_COMMAND_BYTE)
     {
-        /*-------------------------------------------------*\
-        | Fill the write buffer till its full or the        |
-        | colour buffer is empty                            |
-        \*-------------------------------------------------*/
+        /*-----------------------------------------------------------------*\
+        | Fill the write buffer till its full or the colour buffer is empty |
+        \*-----------------------------------------------------------------*/
         buffer[CM_ARGB_REPORT_BYTE] = packet_count;
-        while((buffer_idx < buffer_size) && (it != colours.end()))
+        while (( buffer_idx < buffer_size) && ( it != colours.end() ))
         {
             buffer[buffer_idx] = *it;
             buffer_idx++;
@@ -284,15 +223,76 @@ void CMARGBController::SetPortLEDsDirect(unsigned char port_idx, RGBColor *led_c
             buffer[CM_ARGB_REPORT_BYTE] += 0x80;
         }
 
-        /*-------------------------------------------------*\
-        | Send the buffer                                   |
-        \*-------------------------------------------------*/
         hid_write(dev, buffer, buffer_size);
 
-        /*-------------------------------------------------*\
-        | Reset the write buffer                            |
-        \*-------------------------------------------------*/
+        /*-----------------------------------------------------------------*\
+        | Reset the write buffer                                            |
+        \*-----------------------------------------------------------------*/
         memset(buffer, 0x00, buffer_size );
         packet_count++;
     }
 }
+
+void CMARGBController::SendUpdate()
+{
+    /*---------------------------------------------*\
+    | Guard the writes to the controller            |
+    \*---------------------------------------------*/
+    std::lock_guard<std::mutex> guard(*mutex_ptr);
+
+    unsigned char buffer[CM_ARGB_PACKET_SIZE]   = { 0x00 };
+    int  buffer_size                            = (sizeof(buffer) / sizeof(buffer[0]));
+    bool boolARGB_header                        = argb_header_data[zone_index].digital;
+    bool boolPassthru                           = ( current_mode == CM_ARGB_MODE_PASSTHRU ) || ( current_mode == CM_RGB_MODE_PASSTHRU );
+    bool boolDirect                             = ( current_mode == CM_ARGB_MODE_DIRECT );
+    unsigned char function                      = boolPassthru ? (boolARGB_header ? 0x02 : 0x04) : (boolARGB_header ? 0x01 : 0x03);
+    buffer[CM_ARGB_REPORT_BYTE]                 = 0x80;
+    buffer[CM_ARGB_COMMAND_BYTE]                = 0x01;
+
+    if(boolDirect)
+    {
+        buffer[CM_ARGB_FUNCTION_BYTE]           = 0x01;
+        buffer[CM_ARGB_ZONE_BYTE]               = 0x02;
+
+        hid_write(dev, buffer, buffer_size);
+        hid_read_timeout(dev, buffer, buffer_size, CM_ARGB_INTERRUPT_TIMEOUT);
+
+        /*-----------------------------------------------------------------*\
+        | Direct mode is now set up and no other mode packet is required    |
+        \*-----------------------------------------------------------------*/
+        return;
+    }
+
+    buffer[CM_ARGB_FUNCTION_BYTE]           = function;
+
+    hid_write(dev, buffer, buffer_size);
+    hid_read_timeout(dev, buffer, buffer_size, CM_ARGB_INTERRUPT_TIMEOUT);
+
+    if(boolARGB_header)
+    {
+        buffer[CM_ARGB_COMMAND_BYTE]            = 0x0B;                                     //ARGB sends 0x0B (1011) RGB sends 0x04 (0100)
+        buffer[CM_ARGB_FUNCTION_BYTE]           = (false) ? 0x01 : 0x02;                    //This controls direct mode TODO
+        buffer[CM_ARGB_ZONE_BYTE]               = argb_header_data[zone_index].header;
+        buffer[CM_ARGB_MODE_BYTE]               = current_mode;
+        buffer[CM_ARGB_COLOUR_INDEX_BYTE]       = bool_random ? 0x00 : 0x10;
+        buffer[CM_ARGB_SPEED_BYTE]              = current_speed;
+        buffer[CM_ARGB_BRIGHTNESS_BYTE]         = current_brightness;
+        buffer[CM_ARGB_RED_BYTE]                = current_red;
+        buffer[CM_ARGB_GREEN_BYTE]              = current_green;
+        buffer[CM_ARGB_BLUE_BYTE]               = current_blue;
+    }
+    else
+    {
+        buffer[CM_ARGB_COMMAND_BYTE]                        = boolPassthru ? 0x01 : 0x04;   //ARGB sends 0x0b (1011) RGB sends 0x04 (0100)
+        buffer[CM_ARGB_MODE_BYTE + CM_RGB_OFFSET]           = current_mode;
+        buffer[CM_ARGB_COLOUR_INDEX_BYTE + CM_RGB_OFFSET]   = bool_random ? 0x00 : 0x10;
+        buffer[CM_ARGB_SPEED_BYTE + CM_RGB_OFFSET]          = current_speed;
+        buffer[CM_ARGB_BRIGHTNESS_BYTE + CM_RGB_OFFSET]     = current_brightness;
+        buffer[CM_ARGB_RED_BYTE + CM_RGB_OFFSET]            = current_red;
+        buffer[CM_ARGB_GREEN_BYTE + CM_RGB_OFFSET]          = current_green;
+        buffer[CM_ARGB_BLUE_BYTE + CM_RGB_OFFSET]           = current_blue;
+    }
+
+    hid_write(dev, buffer, buffer_size);
+    hid_read_timeout(dev, buffer, buffer_size, CM_ARGB_INTERRUPT_TIMEOUT);
+}

Controllers/CoolerMasterController/CMARGBController/CMARGBController.h

@@ -16,20 +16,19 @@
 #include <array>
 #include <memory>
 #include <hidapi.h>
-#include "RGBController.h"
+#include "RGBController.h"  //Needed to set the direct mode
 
-#define CM_ARGB_COLOUR_MODE_DATA_SIZE   (sizeof(colour_mode_data[0]) / sizeof(colour_mode_data[0][0]))
-#define CM_ARGB_HEADER_DATA_SIZE        (sizeof(argb_header_data) / sizeof(argb_headers) )
-#define CM_ARGB_INTERRUPT_TIMEOUT       250
-#define CM_ARGB_PACKET_SIZE             65
-#define CM_ARGB_DEVICE_NAME_SIZE        (sizeof(device_name) / sizeof(device_name[ 0 ]))
-#define CM_RGB_OFFSET                   -2
-#define HID_MAX_STR                     255
+#define CM_ARGB_COLOUR_MODE_DATA_SIZE (sizeof(colour_mode_data[0]) / sizeof(colour_mode_data[0][0]))
+#define CM_ARGB_HEADER_DATA_SIZE (sizeof(argb_header_data) / sizeof(argb_headers) )
+#define CM_ARGB_INTERRUPT_TIMEOUT 250
+#define CM_ARGB_PACKET_SIZE 65
+#define CM_ARGB_DEVICE_NAME_SIZE (sizeof(device_name) / sizeof(device_name[ 0 ]))
+#define CM_RGB_OFFSET -2
+#define HID_MAX_STR 255
 
-#define CM_ARGB_BRIGHTNESS_MAX          255
-#define CM_ARGB_FW0000                  std::string("A201804091608")
-#define CM_ARGB_FW0023                  std::string("A202011171238")
-#define CM_ARGB_FW0028                  std::string("A202105291658")
+#define CM_ARGB_BRIGHTNESS_MAX  255
+#define CM_ARGB_FW0023          std::string("A202011171238")
+#define CM_ARGB_FW0028          std::string("A202105291658")
 
 enum
 {
@@ -46,13 +45,22 @@ enum
     CM_ARGB_BLUE_BYTE           = 11
 };
 
-enum
+struct argb_headers
 {
-    CM_ARGB_PORT_ARGB_1         = 0x01,
-    CM_ARGB_PORT_ARGB_2         = 0x02,
-    CM_ARGB_PORT_ARGB_3         = 0x04,
-    CM_ARGB_PORT_ARGB_4         = 0x08,
-    CM_ARGB_PORT_RGB            = 0xFE,
+    const char*     name;
+    unsigned char   header;
+    bool            digital;
+    unsigned int    count;
+};
+
+static argb_headers argb_header_data[] =
+{
+    { "RGB Header",         0xFE, false,  1 },
+    { "Digital ARGB1",      0x01, true,  12 },
+    { "Digital ARGB2",      0x02, true,  12 },
+    { "Digital ARGB3",      0x04, true,  12 },
+    { "Digital ARGB4",      0x08, true,  12 },
+    //{ "All Digital ARGB",   0xFF, true,  12 }
 };
 
 enum
@@ -93,44 +101,40 @@ enum
 class CMARGBController
 {
 public:
-    CMARGBController(hid_device* dev_handle, char* path);
+    CMARGBController(hid_device* dev_handle, char *_path, unsigned char _zone_idx, std::shared_ptr<std::mutex> cm_mutex);
     ~CMARGBController();
 
     std::string GetDeviceName();
     std::string GetSerial();
     std::string GetLocation();
-    std::string GetVersion();
 
-    void GetPortStatus
-        (
-        unsigned char   port_idx,
-        unsigned char*  port_mode,
-        unsigned char*  port_speed,
-        unsigned char*  port_brightness,
-        bool*           port_random,
-        unsigned char*  port_red,
-        unsigned char*  port_green,
-        unsigned char*  port_blue
-        );
-
-    void SetPortLEDCount(unsigned char port_idx, unsigned char led_count);
-
-    void SetPortMode
-        (
-        unsigned char   port_idx,
-        unsigned char   port_mode,
-        unsigned char   port_speed,
-        unsigned char   port_brightness,
-        bool            port_random,
-        unsigned char   port_red,
-        unsigned char   port_green,
-        unsigned char   port_blue
-        );
-
-    void SetPortLEDsDirect(unsigned char port_idx, RGBColor *led_colours, unsigned int led_count);
+    unsigned char GetZoneIndex();
+    unsigned char GetMode();
+    unsigned char GetLedRed();
+    unsigned char GetLedGreen();
+    unsigned char GetLedBlue();
+    unsigned char GetLedSpeed();
+    bool GetRandomColours();
+    void SetLedCount(int zone, int led_count);
+    void SetMode(uint8_t mode, uint8_t speed, uint8_t brightness, RGBColor colour, bool random_colours);
+    void SetLedsDirect(RGBColor * led_colours, unsigned int led_count);
 
 private:
-    hid_device*         dev;
-    std::string         device_name;
-    std::string         location;
+    std::string                 device_name;
+    std::string                 location;
+    hid_device*                 dev;
+    std::shared_ptr<std::mutex> mutex_ptr;
+
+    unsigned char               zone_index;
+    unsigned char               current_mode;
+    unsigned char               current_speed;
+
+    unsigned char               current_red;
+    unsigned char               current_green;
+    unsigned char               current_blue;
+    unsigned char               current_brightness;
+    bool                        bool_random;
+
+    void GetStatus();
+    void SendUpdate();
 };

Controllers/CoolerMasterController/CMARGBController/RGBController_CMARGBController.cpp

@@ -27,594 +27,401 @@
 RGBController_CMARGBController::RGBController_CMARGBController(CMARGBController* controller_ptr)
 {
     controller                      = controller_ptr;
+    unsigned char speed             = controller->GetLedSpeed();
 
-    name                            = controller->GetDeviceName();
+    name                            = argb_header_data[controller->GetZoneIndex()].name;
     vendor                          = "Cooler Master";
     type                            = DEVICE_TYPE_LEDSTRIP;
-    description                     = "Cooler Master ARGB Controller Device";
-    version                         = controller->GetVersion();
+    description                     = controller->GetDeviceName();
+    version                         = "3.0 for FW0028";
     serial                          = controller->GetSerial();
     location                        = controller->GetLocation();
 
-    SetupZones();
-    SetupModes();
-
-    /*-----------------------------------------------------*\
-    | Initialize the active mode to port 0                  |
-    \*-----------------------------------------------------*/
-    unsigned char   port_mode;
-    unsigned char   port_speed;
-    unsigned char   port_brightness;
-    bool            port_random;
-    unsigned char   port_red;
-    unsigned char   port_green;
-    unsigned char   port_blue;
-
-    controller->GetPortStatus(0, &port_mode, &port_speed, &port_brightness, &port_random, &port_red, &port_green, &port_blue);
-
-    for(std::size_t mode_idx = 0; mode_idx < modes.size(); mode_idx++)
+    if(argb_header_data[controller->GetZoneIndex()].digital)
     {
-        if(modes[mode_idx].value == port_mode)
+        mode Off;
+        Off.name                    = "Turn Off";
+        Off.value                   = CM_ARGB_MODE_OFF;
+        Off.color_mode              = MODE_COLORS_NONE;
+        modes.push_back(Off);
+
+        mode Reload;
+        Reload.name                 = "Reload";
+        Reload.value                = CM_ARGB_MODE_RELOAD;
+        Reload.flags                = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
+        Reload.colors_min           = 1;
+        Reload.colors_max           = 1;
+        Reload.colors.resize(Reload.colors_max);
+        Reload.brightness_min       = 0;
+        Reload.brightness_max       = CM_ARGB_BRIGHTNESS_MAX;
+        Reload.brightness           = CM_ARGB_BRIGHTNESS_MAX;
+        Reload.speed_min            = CM_ARGB_SPEED_SLOWEST;
+        Reload.speed_max            = CM_ARGB_SPEED_FASTEST;
+        Reload.color_mode           = MODE_COLORS_MODE_SPECIFIC;
+        Reload.speed                = speed;
+        modes.push_back(Reload);
+
+        mode Recoil;
+        Recoil.name                 = "Recoil";
+        Recoil.value                = CM_ARGB_MODE_RECOIL;
+        Recoil.flags                = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
+        Recoil.colors_min           = 1;
+        Recoil.colors_max           = 1;
+        Recoil.colors.resize(Recoil.colors_max);
+        Recoil.brightness_min       = 0;
+        Recoil.brightness_max       = CM_ARGB_BRIGHTNESS_MAX;
+        Recoil.brightness           = CM_ARGB_BRIGHTNESS_MAX;
+        Recoil.speed_min            = CM_ARGB_SPEED_SLOWEST;
+        Recoil.speed_max            = CM_ARGB_SPEED_FASTEST;
+        Recoil.color_mode           = MODE_COLORS_MODE_SPECIFIC;
+        Recoil.speed                = speed;
+        modes.push_back(Recoil);
+
+        mode Breathing;
+        Breathing.name              = "Breathing";
+        Breathing.value             = CM_ARGB_MODE_BREATHING;
+        Breathing.flags             = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
+        Breathing.colors_min        = 1;
+        Breathing.colors_max        = 1;
+        Breathing.colors.resize(Breathing.colors_max);
+        Breathing.brightness_min    = 0;
+        Breathing.brightness_max    = CM_ARGB_BRIGHTNESS_MAX;
+        Breathing.brightness        = CM_ARGB_BRIGHTNESS_MAX;
+        Breathing.speed_min         = CM_ARGB_SPEED_SLOWEST;
+        Breathing.speed_max         = CM_ARGB_SPEED_FASTEST;
+        Breathing.color_mode        = MODE_COLORS_MODE_SPECIFIC;
+        Breathing.speed             = speed;
+        modes.push_back(Breathing);
+
+        mode Refill;
+        Refill.name                 = "Refill";
+        Refill.value                = CM_ARGB_MODE_REFILL;
+        Refill.flags                = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
+        Refill.colors_min           = 1;
+        Refill.colors_max           = 1;
+        Refill.colors.resize(Refill.colors_max);
+        Refill.brightness_min       = 0;
+        Refill.brightness_max       = CM_ARGB_BRIGHTNESS_MAX;
+        Refill.brightness           = CM_ARGB_BRIGHTNESS_MAX;
+        Refill.speed_min            = CM_ARGB_SPEED_SLOWEST;
+        Refill.speed_max            = CM_ARGB_SPEED_FASTEST;
+        Refill.color_mode           = MODE_COLORS_MODE_SPECIFIC;
+        Refill.speed                = speed;
+        modes.push_back(Refill);
+
+        mode Demo;
+        Demo.name                   = "Demo";
+        Demo.value                  = CM_ARGB_MODE_DEMO;
+        Demo.flags                  = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
+        Demo.brightness_min         = 0;
+        Demo.brightness_max         = CM_ARGB_BRIGHTNESS_MAX;
+        Demo.brightness             = CM_ARGB_BRIGHTNESS_MAX;
+        Demo.speed_min              = CM_ARGB_SPEED_SLOWEST;
+        Demo.speed_max              = CM_ARGB_SPEED_FASTEST;
+        Demo.color_mode             = MODE_COLORS_NONE;
+        Demo.speed                  = speed;
+        modes.push_back(Demo);
+
+        mode Spectrum;
+        Spectrum.name               = "Spectrum";
+        Spectrum.value              = CM_ARGB_MODE_SPECTRUM;
+        Spectrum.flags              = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
+        Spectrum.brightness_min     = 0;
+        Spectrum.brightness_max     = CM_ARGB_BRIGHTNESS_MAX;
+        Spectrum.brightness         = CM_ARGB_BRIGHTNESS_MAX;
+        Spectrum.speed_min          = CM_ARGB_SPEED_SLOWEST;
+        Spectrum.speed_max          = CM_ARGB_SPEED_FASTEST;
+        Spectrum.color_mode         = MODE_COLORS_NONE;
+        Spectrum.speed              = speed;
+        modes.push_back(Spectrum);
+
+        mode FillFlow;
+        FillFlow.name               = "Fill Flow";
+        FillFlow.value              = CM_ARGB_MODE_FILLFLOW;
+        FillFlow.flags              = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
+        FillFlow.brightness_min     = 0;
+        FillFlow.brightness_max     = CM_ARGB_BRIGHTNESS_MAX;
+        FillFlow.brightness         = CM_ARGB_BRIGHTNESS_MAX;
+        FillFlow.speed_min          = CM_ARGB_SPEED_SLOWEST;
+        FillFlow.speed_max          = CM_ARGB_SPEED_FASTEST;
+        FillFlow.color_mode         = MODE_COLORS_NONE;
+        FillFlow.speed              = speed;
+        modes.push_back(FillFlow);
+
+        mode Rainbow;
+        Rainbow.name                = "Rainbow";
+        Rainbow.value               = CM_ARGB_MODE_RAINBOW;
+        Rainbow.flags               = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
+        Rainbow.brightness_min      = 0;
+        Rainbow.brightness_max      = CM_ARGB_BRIGHTNESS_MAX;
+        Rainbow.brightness          = CM_ARGB_BRIGHTNESS_MAX;
+        Rainbow.speed_min           = CM_ARGB_SPEED_SLOWEST;
+        Rainbow.speed_max           = CM_ARGB_SPEED_FASTEST;
+        Rainbow.color_mode          = MODE_COLORS_NONE;
+        Rainbow.speed               = speed;
+        modes.push_back(Rainbow);
+
+        mode Static;
+        Static.name                 = "Static";
+        Static.value                = CM_ARGB_MODE_STATIC;
+        Static.flags                = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
+        Static.colors_min           = 1;
+        Static.colors_max           = 1;
+        Static.colors.resize(Static.colors_max);
+        Static.brightness_min       = 0;
+        Static.brightness_max       = CM_ARGB_BRIGHTNESS_MAX;
+        Static.brightness           = CM_ARGB_BRIGHTNESS_MAX;
+        Static.speed_min            = CM_ARGB_SPEED_SLOWEST;
+        Static.speed_max            = CM_ARGB_SPEED_FASTEST;
+        Static.color_mode           = MODE_COLORS_MODE_SPECIFIC;
+        Static.speed                = speed;
+        modes.push_back(Static);
+
+        mode Direct;
+        Direct.name                 = (serial >= CM_ARGB_FW0028) ? "Direct" : "Custom";
+        Direct.value                = CM_ARGB_MODE_DIRECT;
+        Direct.flags                = MODE_FLAG_HAS_PER_LED_COLOR;
+        Direct.color_mode           = MODE_COLORS_PER_LED;
+        modes.push_back(Direct);
+
+        mode PassThru;
+        PassThru.name               = "Pass Thru";
+        PassThru.value              = CM_ARGB_MODE_PASSTHRU;
+        PassThru.flags              = 0;
+        PassThru.color_mode         = MODE_COLORS_NONE;
+        modes.push_back(PassThru);
+    }
+    else
+    {
+        mode Static;
+        Static.name                 = "Static";
+        Static.value                = CM_RGB_MODE_STATIC;
+        Static.flags                = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
+        Static.colors_min           = 1;
+        Static.colors_max           = 1;
+        Static.colors.resize(Static.colors_max);
+        Static.brightness_min       = 0;
+        Static.brightness_max       = CM_ARGB_BRIGHTNESS_MAX;
+        Static.brightness           = CM_ARGB_BRIGHTNESS_MAX;
+        Static.color_mode           = MODE_COLORS_MODE_SPECIFIC;
+        Static.speed                = 0;
+        modes.push_back(Static);
+
+        mode Breathing;
+        Breathing.name              = "Breathing";
+        Breathing.value             = CM_RGB_MODE_BREATHING;
+        Breathing.flags             = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
+        Breathing.colors_min        = 1;
+        Breathing.colors_max        = 1;
+        Breathing.colors.resize(Breathing.colors_max);
+        Breathing.brightness_min    = 0;
+        Breathing.brightness_max    = CM_ARGB_BRIGHTNESS_MAX;
+        Breathing.brightness        = CM_ARGB_BRIGHTNESS_MAX;
+        Breathing.speed_min         = CM_ARGB_SPEED_SLOWEST;
+        Breathing.speed_max         = CM_ARGB_SPEED_FASTEST;
+        Breathing.color_mode        = MODE_COLORS_MODE_SPECIFIC;
+        Breathing.speed             = CM_ARGB_SPEED_NORMAL;
+        modes.push_back(Breathing);
+
+        mode Flash;
+        Flash.name                  = "Flash";
+        Flash.value                 = CM_RGB_MODE_FLASH;
+        Flash.flags                 = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
+        Flash.colors_min            = 1;
+        Flash.colors_max            = 1;
+        Flash.colors.resize(Flash.colors_max);
+        Flash.brightness_min        = 0;
+        Flash.brightness_max        = CM_ARGB_BRIGHTNESS_MAX;
+        Flash.brightness            = CM_ARGB_BRIGHTNESS_MAX;
+        Flash.speed_min             = CM_ARGB_SPEED_SLOWEST;
+        Flash.speed_max             = CM_ARGB_SPEED_FASTEST;
+        Flash.color_mode            = MODE_COLORS_MODE_SPECIFIC;
+        Flash.speed                 = CM_ARGB_SPEED_NORMAL;
+        modes.push_back(Flash);
+
+        mode Mirage;
+        Mirage.name                 = "Mirage";
+        Mirage.value                = CM_RGB_MODE_MIRAGE;
+        Mirage.flags                = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
+        Mirage.colors_min           = 1;
+        Mirage.colors_max           = 1;
+        Mirage.colors.resize(Mirage.colors_max);
+        Mirage.brightness_min       = 0;
+        Mirage.brightness_max       = CM_ARGB_BRIGHTNESS_MAX;
+        Mirage.brightness           = CM_ARGB_BRIGHTNESS_MAX;
+        Mirage.speed_min            = CM_ARGB_SPEED_SLOWEST;
+        Mirage.speed_max            = CM_ARGB_SPEED_FASTEST;
+        Mirage.color_mode           = MODE_COLORS_MODE_SPECIFIC;
+        Mirage.speed                = CM_ARGB_SPEED_NORMAL;
+        modes.push_back(Mirage);
+
+        mode PassThru;
+        PassThru.name               = "Pass Thru";
+        PassThru.value              = CM_RGB_MODE_PASSTHRU;
+        PassThru.color_mode         = MODE_COLORS_NONE;
+        modes.push_back(PassThru);
+
+        mode Off;
+        Off.name                    = "Turn Off";
+        Off.value                   = CM_RGB_MODE_OFF;
+        Off.color_mode              = MODE_COLORS_NONE;
+        modes.push_back(Off);
+    }
+
+    Init_Controller();
+    SetupZones();
+
+    int temp_mode   = controller->GetMode();
+    for(int mode_idx = 0; mode_idx < (int)modes.size() ; mode_idx++)
+    {
+        if (temp_mode == modes[mode_idx].value)
         {
-            active_mode = (int)mode_idx;
-
-            if((modes[mode_idx].flags & MODE_FLAG_HAS_MODE_SPECIFIC_COLOR) && (modes[mode_idx].colors.size() > 0))
-            {
-                modes[mode_idx].colors[0] = ToRGBColor(port_red, port_green, port_blue);
-            }
-
-            if(modes[mode_idx].flags & MODE_FLAG_HAS_SPEED)
-            {
-                modes[mode_idx].speed = port_speed;
-            }
-
-            if(modes[mode_idx].flags & MODE_FLAG_HAS_BRIGHTNESS)
-            {
-                modes[mode_idx].brightness = port_brightness;
-            }
-
-            if(modes[mode_idx].flags & MODE_FLAG_HAS_RANDOM_COLOR)
-            {
-                if(port_random)
-                {
-                    modes[mode_idx].color_mode = MODE_COLORS_RANDOM;
-                }
-            }
-
+            active_mode = mode_idx;
             break;
         }
     }
+    if (modes[active_mode].flags & MODE_FLAG_HAS_MODE_SPECIFIC_COLOR)
+    {
+        modes[active_mode].colors[0] = ToRGBColor(controller->GetLedRed(), controller->GetLedGreen(), controller->GetLedBlue());
+        modes[active_mode].color_mode = (controller->GetRandomColours()) ? MODE_COLORS_RANDOM : MODE_COLORS_MODE_SPECIFIC;
+    }
+    if (modes[active_mode].flags & MODE_FLAG_HAS_SPEED)
+    {
+        modes[active_mode].speed = controller->GetLedSpeed();
+    }
 }
 
 RGBController_CMARGBController::~RGBController_CMARGBController()
 {
-    Shutdown();
-
     delete controller;
 }
 
-void RGBController_CMARGBController::SetupModes()
+void RGBController_CMARGBController::Init_Controller()
 {
-    /*-----------------------------------------------------*\
-    | Define Direct and Passthrough modes as require entire |
-    | device, these are not available as per-zone modes     |
-    \*-----------------------------------------------------*/
-    mode Direct;
-    Direct.name                     = (serial >= CM_ARGB_FW0028) ? "Direct" : "Custom";
-    Direct.value                    = CM_ARGB_MODE_DIRECT;
-    Direct.flags                    = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_REQUIRES_ENTIRE_DEVICE;
-    Direct.color_mode               = MODE_COLORS_PER_LED;
-    modes.push_back(Direct);
+    int zone_idx            = controller->GetZoneIndex();
+    int zone_led_count      = argb_header_data[zone_idx].count;
 
-    mode PassThru;
-    PassThru.name                   = "Passthrough";
-    PassThru.value                  = CM_ARGB_MODE_PASSTHRU | MODE_FLAG_REQUIRES_ENTIRE_DEVICE;
-    PassThru.flags                  = 0;
-    PassThru.color_mode             = MODE_COLORS_NONE;
-    modes.push_back(PassThru);
+    /*-------------------------------------------------*\
+    | If argb_header_data[zone_idx].count == 1 then the |
+    | zone is ZONE_TYPE_SINGLE                          |
+    \*-------------------------------------------------*/
+    bool boolSingleLED      = ( zone_led_count == 1 );
 
-    /*-----------------------------------------------------*\
-    | The ARGB ports support more modes than the RGB port.  |
-    | Define all of the modes the ARGB ports support and    |
-    | map RGB modes to them as best as we can.              |
-    \*-----------------------------------------------------*/
-    mode Off;
-    Off.name                        = "Off";
-    Off.value                       = CM_ARGB_MODE_OFF;
-    Off.color_mode                  = MODE_COLORS_NONE;
-    modes.push_back(Off);
-
-    for(std::size_t zone_idx = 0; zone_idx < 4; zone_idx++)
-    {
-        zones[zone_idx].modes.push_back(Off);
-    }
-
-    mode Reload;
-    Reload.name                     = "Reload";
-    Reload.value                    = CM_ARGB_MODE_RELOAD;
-    Reload.flags                    = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
-    Reload.speed_min                = CM_ARGB_SPEED_SLOWEST;
-    Reload.speed_max                = CM_ARGB_SPEED_FASTEST;
-    Reload.speed                    = CM_ARGB_SPEED_NORMAL;
-    Reload.brightness_min           = 0;
-    Reload.brightness_max           = CM_ARGB_BRIGHTNESS_MAX;
-    Reload.brightness               = CM_ARGB_BRIGHTNESS_MAX;
-    Reload.color_mode               = MODE_COLORS_MODE_SPECIFIC;
-    Reload.colors_min               = 1;
-    Reload.colors_max               = 1;
-    Reload.colors.resize(Reload.colors_max);
-    modes.push_back(Reload);
-
-    for(std::size_t zone_idx = 0; zone_idx < 4; zone_idx++)
-    {
-        zones[zone_idx].modes.push_back(Reload);
-    }
-
-    mode Recoil;
-    Recoil.name                     = "Recoil";
-    Recoil.value                    = CM_ARGB_MODE_RECOIL;
-    Recoil.flags                    = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
-    Recoil.color_mode               = MODE_COLORS_MODE_SPECIFIC;
-    Recoil.speed_min                = CM_ARGB_SPEED_SLOWEST;
-    Recoil.speed_max                = CM_ARGB_SPEED_FASTEST;
-    Recoil.speed                    = CM_ARGB_SPEED_NORMAL;
-    Recoil.brightness_min           = 0;
-    Recoil.brightness_max           = CM_ARGB_BRIGHTNESS_MAX;
-    Recoil.brightness               = CM_ARGB_BRIGHTNESS_MAX;
-    Recoil.colors_min               = 1;
-    Recoil.colors_max               = 1;
-    Recoil.colors.resize(Recoil.colors_max);
-    modes.push_back(Recoil);
-
-    for(std::size_t zone_idx = 0; zone_idx < 4; zone_idx++)
-    {
-        zones[zone_idx].modes.push_back(Recoil);
-    }
-
-    mode Breathing;
-    Breathing.name                  = "Breathing";
-    Breathing.value                 = CM_ARGB_MODE_BREATHING;
-    Breathing.flags                 = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
-    Breathing.color_mode            = MODE_COLORS_MODE_SPECIFIC;
-    Breathing.speed_min             = CM_ARGB_SPEED_SLOWEST;
-    Breathing.speed_max             = CM_ARGB_SPEED_FASTEST;
-    Breathing.speed                 = CM_ARGB_SPEED_NORMAL;
-    Breathing.brightness_min        = 0;
-    Breathing.brightness_max        = CM_ARGB_BRIGHTNESS_MAX;
-    Breathing.brightness            = CM_ARGB_BRIGHTNESS_MAX;
-    Breathing.colors_min            = 1;
-    Breathing.colors_max            = 1;
-    Breathing.colors.resize(Breathing.colors_max);
-    modes.push_back(Breathing);
-
-    for(std::size_t zone_idx = 0; zone_idx < 4; zone_idx++)
-    {
-        zones[zone_idx].modes.push_back(Breathing);
-    }
-
-    mode Refill;
-    Refill.name                     = "Refill";
-    Refill.value                    = CM_ARGB_MODE_REFILL;
-    Refill.flags                    = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
-    Refill.color_mode               = MODE_COLORS_MODE_SPECIFIC;
-    Refill.speed_min                = CM_ARGB_SPEED_SLOWEST;
-    Refill.speed_max                = CM_ARGB_SPEED_FASTEST;
-    Refill.speed                    = CM_ARGB_SPEED_NORMAL;
-    Refill.brightness_min           = 0;
-    Refill.brightness_max           = CM_ARGB_BRIGHTNESS_MAX;
-    Refill.brightness               = CM_ARGB_BRIGHTNESS_MAX;
-    Refill.colors_min               = 1;
-    Refill.colors_max               = 1;
-    Refill.colors.resize(Refill.colors_max);
-    modes.push_back(Refill);
-
-    for(std::size_t zone_idx = 0; zone_idx < 4; zone_idx++)
-    {
-        zones[zone_idx].modes.push_back(Refill);
-    }
-
-    mode Demo;
-    Demo.name                       = "Demo";
-    Demo.value                      = CM_ARGB_MODE_DEMO;
-    Demo.flags                      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
-    Demo.color_mode                 = MODE_COLORS_NONE;
-    Demo.speed_min                  = CM_ARGB_SPEED_SLOWEST;
-    Demo.speed_max                  = CM_ARGB_SPEED_FASTEST;
-    Demo.speed                      = CM_ARGB_SPEED_NORMAL;
-    Demo.brightness_min             = 0;
-    Demo.brightness_max             = CM_ARGB_BRIGHTNESS_MAX;
-    Demo.brightness                 = CM_ARGB_BRIGHTNESS_MAX;
-    modes.push_back(Demo);
-
-    for(std::size_t zone_idx = 0; zone_idx < 4; zone_idx++)
-    {
-        zones[zone_idx].modes.push_back(Demo);
-    }
-
-    mode Spectrum;
-    Spectrum.name                   = "Rainbow Wave";
-    Spectrum.value                  = CM_ARGB_MODE_SPECTRUM;
-    Spectrum.flags                  = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
-    Spectrum.color_mode             = MODE_COLORS_NONE;
-    Spectrum.speed_min              = CM_ARGB_SPEED_SLOWEST;
-    Spectrum.speed_max              = CM_ARGB_SPEED_FASTEST;
-    Spectrum.speed                  = CM_ARGB_SPEED_NORMAL;
-    Spectrum.brightness_min         = 0;
-    Spectrum.brightness_max         = CM_ARGB_BRIGHTNESS_MAX;
-    Spectrum.brightness             = CM_ARGB_BRIGHTNESS_MAX;
-    modes.push_back(Spectrum);
-
-    for(std::size_t zone_idx = 0; zone_idx < 4; zone_idx++)
-    {
-        zones[zone_idx].modes.push_back(Spectrum);
-    }
-
-    mode FillFlow;
-    FillFlow.name                   = "Fill Flow";
-    FillFlow.value                  = CM_ARGB_MODE_FILLFLOW;
-    FillFlow.flags                  = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
-    FillFlow.color_mode             = MODE_COLORS_NONE;
-    FillFlow.speed_min              = CM_ARGB_SPEED_SLOWEST;
-    FillFlow.speed_max              = CM_ARGB_SPEED_FASTEST;
-    FillFlow.speed                  = CM_ARGB_SPEED_NORMAL;
-    FillFlow.brightness_min         = 0;
-    FillFlow.brightness_max         = CM_ARGB_BRIGHTNESS_MAX;
-    FillFlow.brightness             = CM_ARGB_BRIGHTNESS_MAX;
-    modes.push_back(FillFlow);
-
-    for(std::size_t zone_idx = 0; zone_idx < 4; zone_idx++)
-    {
-        zones[zone_idx].modes.push_back(FillFlow);
-    }
-
-    mode Rainbow;
-    Rainbow.name                    = "Rainbow";
-    Rainbow.value                   = CM_ARGB_MODE_RAINBOW;
-    Rainbow.flags                   = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_BRIGHTNESS;
-    Rainbow.color_mode              = MODE_COLORS_NONE;
-    Rainbow.speed_min               = CM_ARGB_SPEED_SLOWEST;
-    Rainbow.speed_max               = CM_ARGB_SPEED_FASTEST;
-    Rainbow.speed                   = CM_ARGB_SPEED_NORMAL;
-    Rainbow.brightness_min          = 0;
-    Rainbow.brightness_max          = CM_ARGB_BRIGHTNESS_MAX;
-    Rainbow.brightness              = CM_ARGB_BRIGHTNESS_MAX;
-    modes.push_back(Rainbow);
-
-    for(std::size_t zone_idx = 0; zone_idx < 4; zone_idx++)
-    {
-        zones[zone_idx].modes.push_back(Rainbow);
-    }
-
-    mode Static;
-    Static.name                     = "Static";
-    Static.value                    = CM_ARGB_MODE_STATIC;
-    Static.flags                    = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
-    Static.color_mode               = MODE_COLORS_MODE_SPECIFIC;
-    Static.brightness_min           = 0;
-    Static.brightness_max           = CM_ARGB_BRIGHTNESS_MAX;
-    Static.brightness               = CM_ARGB_BRIGHTNESS_MAX;
-    Static.colors_min               = 1;
-    Static.colors_max               = 1;
-    Static.colors.resize(Static.colors_max);
-    modes.push_back(Static);
-
-    for(std::size_t zone_idx = 0; zone_idx < 4; zone_idx++)
-    {
-        zones[zone_idx].modes.push_back(Static);
-    }
-
-    /*-----------------------------------------------------*\
-    | Define zone-specific modes for the RGB port           |
-    \*-----------------------------------------------------*/
-    mode RGBOff;
-    RGBOff.name                     = "Off";
-    RGBOff.value                    = CM_RGB_MODE_OFF;
-    RGBOff.color_mode               = MODE_COLORS_NONE;
-    zones[4].modes.push_back(RGBOff);
-
-    mode RGBMirage;
-    RGBMirage.name                  = "Mirage";
-    RGBMirage.value                 = CM_RGB_MODE_MIRAGE;
-    RGBMirage.flags                 = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
-    RGBMirage.color_mode            = MODE_COLORS_MODE_SPECIFIC;
-    RGBMirage.speed_min             = CM_ARGB_SPEED_SLOWEST;
-    RGBMirage.speed_max             = CM_ARGB_SPEED_FASTEST;
-    RGBMirage.speed                 = CM_ARGB_SPEED_NORMAL;
-    RGBMirage.brightness_min        = 0;
-    RGBMirage.brightness_max        = CM_ARGB_BRIGHTNESS_MAX;
-    RGBMirage.brightness            = CM_ARGB_BRIGHTNESS_MAX;
-    RGBMirage.colors_min            = 1;
-    RGBMirage.colors_max            = 1;
-    RGBMirage.colors.resize(RGBMirage.colors_max);
-    zones[4].modes.push_back(RGBMirage);
-
-    mode RGBFlash;
-    RGBFlash.name                   = "Flash";
-    RGBFlash.value                  = CM_RGB_MODE_FLASH;
-    RGBFlash.flags                  = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
-    RGBFlash.color_mode             = MODE_COLORS_MODE_SPECIFIC;
-    RGBFlash.speed_min              = CM_ARGB_SPEED_SLOWEST;
-    RGBFlash.speed_max              = CM_ARGB_SPEED_FASTEST;
-    RGBFlash.speed                  = CM_ARGB_SPEED_NORMAL;
-    RGBFlash.brightness_min         = 0;
-    RGBFlash.brightness_max         = CM_ARGB_BRIGHTNESS_MAX;
-    RGBFlash.brightness             = CM_ARGB_BRIGHTNESS_MAX;
-    RGBFlash.colors_min             = 1;
-    RGBFlash.colors_max             = 1;
-    RGBFlash.colors.resize(RGBFlash.colors_max);
-    zones[4].modes.push_back(RGBFlash);
-
-    mode RGBBreathing;
-    RGBBreathing.name               = "Breathing";
-    RGBBreathing.value              = CM_RGB_MODE_BREATHING;
-    RGBBreathing.flags              = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
-    RGBBreathing.color_mode         = MODE_COLORS_MODE_SPECIFIC;
-    RGBBreathing.speed_min          = CM_ARGB_SPEED_SLOWEST;
-    RGBBreathing.speed_max          = CM_ARGB_SPEED_FASTEST;
-    RGBBreathing.speed              = CM_ARGB_SPEED_NORMAL;
-    RGBBreathing.brightness_min     = 0;
-    RGBBreathing.brightness_max     = CM_ARGB_BRIGHTNESS_MAX;
-    RGBBreathing.brightness         = CM_ARGB_BRIGHTNESS_MAX;
-    RGBBreathing.colors_min         = 1;
-    RGBBreathing.colors_max         = 1;
-    RGBBreathing.colors.resize(RGBBreathing.colors_max);
-    zones[4].modes.push_back(RGBBreathing);
-
-    mode RGBStatic;
-    RGBStatic.name                  = "Static";
-    RGBStatic.value                 = CM_RGB_MODE_STATIC;
-    RGBStatic.flags                 = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
-    RGBStatic.color_mode            = MODE_COLORS_MODE_SPECIFIC;
-    RGBStatic.brightness_min        = 0;
-    RGBStatic.brightness_max        = CM_ARGB_BRIGHTNESS_MAX;
-    RGBStatic.brightness            = CM_ARGB_BRIGHTNESS_MAX;
-    RGBStatic.colors_min            = 1;
-    RGBStatic.colors_max            = 1;
-    RGBStatic.colors.resize(RGBStatic.colors_max);
-    zones[4].modes.push_back(RGBStatic);
+    zone ARGB_zone;
+    ARGB_zone.name          = std::to_string(zone_idx);
+    ARGB_zone.type          = (boolSingleLED) ? ZONE_TYPE_SINGLE : ZONE_TYPE_LINEAR;
+    ARGB_zone.leds_min      = 4;
+    ARGB_zone.leds_max      = 48;
+    ARGB_zone.leds_count    = zone_led_count;
+    zones.push_back(ARGB_zone);
 }
 
 void RGBController_CMARGBController::SetupZones()
 {
-    /*-----------------------------------------------------*\
-    | Only set LED count on the first run                   |
-    \*-----------------------------------------------------*/
-    bool first_run = false;
-
-    if(zones.size() == 0)
-    {
-        first_run = true;
-    }
-
-    /*-----------------------------------------------------*\
-    | Clear any existing color/LED configuration            |
-    \*-----------------------------------------------------*/
+    /*-------------------------------------------------*\
+    | Clear any existing color/LED configuration        |
+    \*-------------------------------------------------*/
     leds.clear();
     colors.clear();
-    zones.resize(5);
 
-    /*-----------------------------------------------------*\
-    | Set up addressable zones                              |
-    \*-----------------------------------------------------*/
-    for(unsigned int channel_idx = 0; channel_idx < 4; channel_idx++)
+    /*---------------------------------------------------------*\
+    | Set up zones                                              |
+    \*---------------------------------------------------------*/
+    for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
     {
-        zones[channel_idx].leds_min                 = 0;
-        zones[channel_idx].leds_max                 = 48;
+        bool boolSingleLED = (zones[zone_idx].type == ZONE_TYPE_SINGLE);
 
-        if(first_run)
+        if (!boolSingleLED)
         {
-            zones[channel_idx].flags                = ZONE_FLAG_MANUALLY_CONFIGURABLE_SIZE
-                                                    | ZONE_FLAG_MANUALLY_CONFIGURABLE_NAME
-                                                    | ZONE_FLAG_MANUALLY_CONFIGURABLE_TYPE
-                                                    | ZONE_FLAG_MANUALLY_CONFIGURABLE_MATRIX_MAP
-                                                    | ZONE_FLAG_MANUALLY_CONFIGURABLE_SEGMENTS;
+            controller->SetLedCount( std::stoi(zones[zone_idx].name), zones[zone_idx].leds_count);
         }
 
-        if(!(zones[channel_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_NAME))
+        for(unsigned int lp_idx = 0; lp_idx < zones[zone_idx].leds_count; lp_idx++)
         {
-            zones[channel_idx].name                 = "Addressable RGB Header ";
-            zones[channel_idx].name.append(std::to_string(channel_idx + 1));
-        }
+            led     new_led;
+            unsigned int i = std::stoi(zones[zone_idx].name);
 
-        if(!(zones[channel_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_SIZE))
-        {
-            zones[channel_idx].leds_count           = 0;
-        }
-
-        if(!(zones[channel_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_TYPE))
-        {
-            zones[channel_idx].type                 = ZONE_TYPE_LINEAR;
-        }
-
-        if(!(zones[channel_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_MATRIX_MAP))
-        {
-            zones[channel_idx].matrix_map.width     = 0;
-            zones[channel_idx].matrix_map.height    = 0;
-            zones[channel_idx].matrix_map.map.resize(0);
-        }
-
-        for(unsigned int led_ch_idx = 0; led_ch_idx < zones[channel_idx].leds_count; led_ch_idx++)
-        {
-            led new_led;
-            new_led.name            = zones[channel_idx].name;
-            new_led.name.append(", LED ");
-            new_led.name.append(std::to_string(led_ch_idx + 1));
-            new_led.value           = channel_idx;
+            if(boolSingleLED)
+            {
+                new_led.name  = i;
+                new_led.value = argb_header_data[i].header;
+            }
+            else
+            {
+                new_led.name = i;
+                new_led.name.append(" LED " + std::to_string(lp_idx));
+                new_led.value = argb_header_data[i].header;
+            }
 
             leds.push_back(new_led);
         }
     }
 
-    /*-----------------------------------------------------*\
-    | Set up RGB zone                                       |
-    \*-----------------------------------------------------*/
-    zones[4].name                   = "RGB Header";
-    zones[4].type                   = ZONE_TYPE_SINGLE;
-    zones[4].leds_min               = 1;
-    zones[4].leds_max               = 1;
-    zones[4].leds_count             = 1;
-
-    led new_led;
-    new_led.name                    = "RGB Header";
-    new_led.value                   = 4;
-    leds.push_back(new_led);
-
     SetupColors();
 }
 
-void RGBController_CMARGBController::DeviceConfigureZone(int zone_idx)
+void RGBController_CMARGBController::DeviceResizeZone(int zone, int new_size)
 {
-    if((size_t)zone_idx < zones.size())
+    if((size_t) zone >= zones.size())
     {
-        controller->SetPortLEDCount(zone_idx, zones[zone_idx].leds_count);
-
-        SetupZones();
+        return;
     }
+    uint8_t end_zone = last_zone(zone);
+
+    for(std::size_t zone_idx = first_zone(zone); zone_idx < end_zone; zone_idx++)
+    {
+        if(((unsigned int)new_size >= zones[zone_idx].leds_min) && ((unsigned int)new_size <= zones[zone_idx].leds_max))
+        {
+            zones[zone_idx].leds_count = new_size;
+        }
+    }
+
+    SetupZones();
 }
 
 void RGBController_CMARGBController::DeviceUpdateLEDs()
 {
-    for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
+    uint8_t end_zone = last_zone(cmargb->GetZoneIndex());
+
+    for(int zone_idx = first_zone(cmargb->GetZoneIndex()); zone_idx < end_zone; zone_idx++)
     {
-        DeviceUpdateZoneLEDs((int)zone_idx);
+        DeviceUpdateZoneLEDs(zone_idx);
     }
 }
 
 void RGBController_CMARGBController::DeviceUpdateZoneLEDs(int zone)
 {
-    if(modes[active_mode].value != CM_ARGB_MODE_DIRECT)
-    {
-        return;
-    }
-
-    /*-----------------------------------------------------*\
-    | The RGB zone doesn't have a separate Direct mode, so  |
-    | use static mode with the per-LED color for it         |
-    \*-----------------------------------------------------*/
-    if(zone < 4)
-    {
-        controller->SetPortLEDsDirect(zone, zones[zone].colors, zones[zone].leds_count);
-    }
-    else
-    {
-        controller->SetPortMode(zone, CM_RGB_MODE_STATIC, 0, 255, false, RGBGetRValue(zones[zone].colors[0]), RGBGetGValue(zones[zone].colors[0]), RGBGetBValue(zones[zone].colors[0]));
-    }
+    controller->SetLedsDirect( zones[zone].colors, zones[zone].leds_count );
 }
 
 void RGBController_CMARGBController::DeviceUpdateSingleLED(int led)
 {
-    unsigned int zone_idx = leds[led].value;
-
-    UpdateZoneLEDs(zone_idx);
+    DeviceUpdateZoneLEDs(GetLED_Zone(led));
 }
 
 void RGBController_CMARGBController::DeviceUpdateMode()
 {
-    /*-----------------------------------------------------*\
-    | Apply mode to all zones                               |
-    \*-----------------------------------------------------*/
-    for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
-    {
-        DeviceUpdateZoneMode((int)zone_idx);
-    }
+    bool     random_colours = (modes[active_mode].color_mode == MODE_COLORS_RANDOM);
+    RGBColor colour         = (modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC) ? modes[active_mode].colors[0] : 0;
+
+    controller->SetMode( modes[active_mode].value, modes[active_mode].speed, modes[active_mode].brightness, colour, random_colours );
 }
 
-void RGBController_CMARGBController::DeviceUpdateZoneMode(int zone)
+int RGBController_CMARGBController::GetLED_Zone(int led_idx)
 {
-    /*-----------------------------------------------------*\
-    | Determine the active mode for this zone               |
-    \*-----------------------------------------------------*/
-    bool            use_zone_mode       = false;
-    int             zone_active_mode    = active_mode;
-    int             zone_mode_value     = modes[active_mode].value;
-
-    /*-----------------------------------------------------*\
-    | Set up mode parameters                                |
-    \*-----------------------------------------------------*/
-    bool            random              = (modes[active_mode].color_mode == MODE_COLORS_RANDOM);
-    RGBColor        color               = 0;
-    unsigned int    brightness          = modes[active_mode].brightness;
-    unsigned int    speed               = modes[active_mode].speed;
-
-    if(modes[active_mode].colors.size() > 0)
+    /*---------------------------------------------------------*\
+    | This may be more useful in the abstract RGBController.cpp |
+    \*---------------------------------------------------------*/
+    for(int zone_idx = 0; zone_idx < (int)zones.size(); zone_idx++)
     {
-        color                           = modes[active_mode].colors[0];
-    }
+        int zone_start  = zones[zone_idx].start_idx;
+        int zone_end    = zone_start + zones[zone_idx].leds_count - 1;
 
-    if(!(modes[active_mode].flags & MODE_FLAG_REQUIRES_ENTIRE_DEVICE))
-    {
-        if(zones[zone].active_mode >= 0)
+        if(zone_start <= led_idx && zone_end >= led_idx)
         {
-            use_zone_mode               = true;
-            zone_active_mode            = zones[zone].active_mode;
-            zone_mode_value             = zones[zone].modes[zone_active_mode].value;
-
-            random                      = (zones[zone].modes[zone_active_mode].color_mode == MODE_COLORS_RANDOM);
-
-            if(zones[zone].modes[zone_active_mode].colors.size() > 0)
-            {
-                color                   = zones[zone].modes[zone_active_mode].colors[0];
-            }
-
-            brightness                  = zones[zone].modes[zone_active_mode].brightness;
-            speed                       = zones[zone].modes[zone_active_mode].speed;
+            return(zone_idx);
         }
     }
 
-    if((zone == 4) && !use_zone_mode)
-    {
-        /*-------------------------------------------------*\
-        | Map entire-device ARGB modes with the equivalent  |
-        | RGB modes for the RGB zone                        |
-        \*-------------------------------------------------*/
-        switch(modes[active_mode].value)
-        {
-            case CM_ARGB_MODE_SPECTRUM:
-            case CM_ARGB_MODE_FILLFLOW:
-            case CM_ARGB_MODE_RAINBOW:
-                zone_mode_value         = CM_RGB_MODE_MIRAGE;
-                random                  = true;
-                break;
-
-            case CM_ARGB_MODE_RELOAD:
-            case CM_ARGB_MODE_RECOIL:
-                zone_mode_value         = CM_RGB_MODE_FLASH;
-                break;
-
-            case CM_ARGB_MODE_BREATHING:
-                zone_mode_value         = CM_RGB_MODE_BREATHING;
-                break;
-
-            case CM_ARGB_MODE_REFILL:
-            case CM_ARGB_MODE_STATIC:
-                zone_mode_value         = CM_RGB_MODE_STATIC;
-                break;
-
-            case CM_ARGB_MODE_DEMO:
-                zone_mode_value         = CM_RGB_MODE_FLASH;
-                random                  = true;
-                break;
-
-            case CM_ARGB_MODE_OFF:
-            default:
-                zone_mode_value         = CM_RGB_MODE_OFF;
-                break;
-
-            case CM_ARGB_MODE_PASSTHRU:
-                zone_mode_value         = CM_RGB_MODE_PASSTHRU;
-                break;
-        }
-    }
-
-    controller->SetPortMode
-                    (
-                        zone,
-                        zone_mode_value,
-                        speed,
-                        brightness,
-                        random,
-                        RGBGetRValue(color),
-                        RGBGetGValue(color),
-                        RGBGetBValue(color)
-                    );
+    return -1;
 }

Controllers/CoolerMasterController/CMARGBController/RGBController_CMARGBController.h

@@ -12,8 +12,11 @@
 #pragma once
 
 #include <vector>
-#include "CMARGBController.h"
 #include "RGBController.h"
+#include "CMARGBController.h"
+
+#define first_zone(zn)          ((zones.size() > 1) ? 1 : 0)
+#define last_zone(zn)           ((zones.size() > 1) ? 4 : 1)
 
 class RGBController_CMARGBController : public RGBController
 {
@@ -21,19 +24,19 @@ public:
     RGBController_CMARGBController(CMARGBController* controller_ptr);
     ~RGBController_CMARGBController();
 
-    void        SetupModes();
     void        SetupZones();
-
-    void        DeviceConfigureZone(int zone_idx);
+    void        DeviceResizeZone(int zone, int new_size);
 
     void        DeviceUpdateLEDs();
     void        DeviceUpdateZoneLEDs(int zone);
     void        DeviceUpdateSingleLED(int led);
 
     void        DeviceUpdateMode();
-    void        DeviceUpdateZoneMode(int zone);
 
 private:
-    CMARGBController*           controller;
-    std::vector<unsigned int>   leds_channel;
+    void        Init_Controller();
+    int         GetDeviceMode();
+    int         GetLED_Zone(int led_idx);
+
+    CMARGBController*   controller;
 };

Controllers/CoolerMasterController/CMARGBGen2A1Controller/RGBController_CMARGBGen2A1Controller.cpp

@@ -186,8 +186,6 @@ RGBController_CMARGBGen2A1Controller::RGBController_CMARGBGen2A1Controller(CMARG
 
 RGBController_CMARGBGen2A1Controller::~RGBController_CMARGBGen2A1Controller()
 {
-    Shutdown();
-
     delete controller;
 }
 
@@ -220,8 +218,10 @@ void RGBController_CMARGBGen2A1Controller::SetupZones()
     SetupColors();
 }
 
-void RGBController_CMARGBGen2A1Controller::DeviceConfigureZone(int zone_idx)
+void RGBController_CMARGBGen2A1Controller::DeviceResizeZone(int zone, int new_size)
 {
+    zones[zone].leds_count = new_size;
+
     unsigned int total_leds = 0;
 
     for(unsigned int channel = 0; channel < CM_ARGB_GEN2_A1_CHANNEL_COUNT; channel++)
@@ -236,7 +236,7 @@ void RGBController_CMARGBGen2A1Controller::DeviceConfigureZone(int zone_idx)
         leds[i].name = "LED " + std::to_string(i + 1);
     }
 
-    controller->SetupZoneSize(zone_idx, zones[zone_idx].leds_count);
+    controller->SetupZoneSize(zone, new_size);
 
     SetupColors();
 }

Controllers/CoolerMasterController/CMARGBGen2A1Controller/RGBController_CMARGBGen2A1Controller.h

@@ -23,7 +23,7 @@ public:
     ~RGBController_CMARGBGen2A1Controller();
 
     void SetupZones();
-    void DeviceConfigureZone(int zone_idx);
+    void DeviceResizeZone(int zone, int new_size);
     void DeviceUpdateLEDs();
     void DeviceUpdateZoneLEDs(int zone);
     void UpdateSegmentLEDs(int zone, int subchannel);

Controllers/CoolerMasterController/CMGD160Controller/RGBController_CMGD160Controller.cpp

@@ -140,8 +140,6 @@ RGBController_CMGD160Controller::RGBController_CMGD160Controller(CMGD160Controll
 
 RGBController_CMGD160Controller::~RGBController_CMGD160Controller()
 {
-    Shutdown();
-
     delete controller;
 }
 

Controllers/CoolerMasterController/CMKeyboardController/RGBController_CMKeyboardController.cpp

@@ -49,8 +49,6 @@ RGBController_CMKeyboardController::RGBController_CMKeyboardController(CMKeyboar
 
 RGBController_CMKeyboardController::~RGBController_CMKeyboardController()
 {
-    Shutdown();
-
     if(m_pController)
     {
         delete m_pController;

Controllers/CoolerMasterController/CMMM711Controller/RGBController_CMMM711Controller.cpp

@@ -129,8 +129,6 @@ RGBController_CMMM711Controller::RGBController_CMMM711Controller(CMMM711Controll
 
 RGBController_CMMM711Controller::~RGBController_CMMM711Controller()
 {
-    Shutdown();
-
     delete controller;
 }
 

Controllers/CoolerMasterController/CMMM712Controller/RGBController_CMMM712Controller.cpp

@@ -122,8 +122,6 @@ RGBController_CMMM712Controller::RGBController_CMMM712Controller(CMMM712Controll
 
 RGBController_CMMM712Controller::~RGBController_CMMM712Controller()
 {
-    Shutdown();
-
     delete controller;
 }
 

Controllers/CoolerMasterController/CMMMController/RGBController_CMMMController.cpp

@@ -168,8 +168,6 @@ RGBController_CMMMController::RGBController_CMMMController(CMMMController* contr
 
 RGBController_CMMMController::~RGBController_CMMMController()
 {
-    Shutdown();
-
     delete controller;
 }
 

Controllers/CoolerMasterController/CMMP750Controller/RGBController_CMMP750Controller.cpp

@@ -93,8 +93,6 @@ RGBController_CMMP750Controller::RGBController_CMMP750Controller(CMMP750Controll
 
 RGBController_CMMP750Controller::~RGBController_CMMP750Controller()
 {
-    Shutdown();
-
     delete controller;
 }
 

Controllers/CoolerMasterController/CMMonitorController/RGBController_CMMonitorController.cpp

@@ -141,8 +141,6 @@ RGBController_CMMonitorController::RGBController_CMMonitorController(CMMonitorCo
 
 RGBController_CMMonitorController::~RGBController_CMMonitorController()
 {
-    Shutdown();
-
     delete controller;
 }
 

Controllers/CoolerMasterController/CMR6000Controller/RGBController_CMR6000Controller.cpp

@@ -152,8 +152,6 @@ RGBController_CMR6000Controller::RGBController_CMR6000Controller(CMR6000Controll
 
 RGBController_CMR6000Controller::~RGBController_CMR6000Controller()
 {
-    Shutdown();
-
     delete controller;
 }
 

Controllers/CoolerMasterController/CMRGBController/RGBController_CMRGBController.cpp

@@ -153,8 +153,6 @@ RGBController_CMRGBController::RGBController_CMRGBController(CMRGBController* co
 
 RGBController_CMRGBController::~RGBController_CMRGBController()
 {
-    Shutdown();
-
     delete controller;
 }
 

Controllers/CoolerMasterController/CMSmallARGBController/CMSmallARGBController.cpp

@@ -18,10 +18,11 @@ cm_small_argb_headers cm_small_argb_header_data[1] =
     { "CM Small ARGB",  0x01, true,  12 }
 };
 
-CMSmallARGBController::CMSmallARGBController(hid_device* dev_handle, char *_path)
+CMSmallARGBController::CMSmallARGBController(hid_device* dev_handle, char *_path, unsigned char _zone_idx)
 {
     dev                     = dev_handle;
     location                = _path;
+    zone_index              = _zone_idx;
     current_speed           = CM_SMALL_ARGB_SPEED_NORMAL;
 
     /*---------------------------------------------------------*\
@@ -50,7 +51,7 @@ void CMSmallARGBController::GetStatus()
 {
     unsigned char buffer[CM_SMALL_ARGB_PACKET_SIZE]     = { 0x00, 0x80, 0x01, 0x01 };
     int buffer_size                                     = (sizeof(buffer) / sizeof(buffer[0]));
-    int header                                          = 0 - 1;
+    int header                                          = zone_index - 1;
 
     buffer[CM_SMALL_ARGB_ZONE_BYTE]                     = header;
     buffer[CM_SMALL_ARGB_MODE_BYTE]                     = 0x01;
@@ -97,6 +98,11 @@ std::string CMSmallARGBController::GetLocation()
     return("HID: " + location);
 }
 
+unsigned char CMSmallARGBController::GetZoneIndex()
+{
+    return(zone_index);
+}
+
 unsigned char CMSmallARGBController::GetMode()
 {
     return(current_mode);
@@ -171,7 +177,7 @@ void CMSmallARGBController::SetLedsDirect(RGBColor* led_colours, unsigned int le
         colours.push_back( RGBGetBValue(colour) );
     }
 
-    buffer[CM_SMALL_ARGB_ZONE_BYTE]     = 0 - 1; //argb_header_data[zone_index].header;
+    buffer[CM_SMALL_ARGB_ZONE_BYTE]     = zone_index - 1; //argb_header_data[zone_index].header;
     buffer[CM_SMALL_ARGB_MODE_BYTE]     = led_count;
     unsigned char buffer_idx            = CM_SMALL_ARGB_MODE_BYTE + 1;
 
@@ -219,7 +225,7 @@ void CMSmallARGBController::SendUpdate()
 
     buffer[CM_SMALL_ARGB_COMMAND_BYTE]                  = 0x0b;
     buffer[CM_SMALL_ARGB_FUNCTION_BYTE]                 = (false) ? 0x01 : 0x02; //This controls custom mode TODO
-    buffer[CM_SMALL_ARGB_ZONE_BYTE]                     = cm_small_argb_header_data[0].header;
+    buffer[CM_SMALL_ARGB_ZONE_BYTE]                     = cm_small_argb_header_data[zone_index].header;
     buffer[CM_SMALL_ARGB_MODE_BYTE]                     = current_mode;
     buffer[CM_SMALL_ARGB_SPEED_BYTE]                    = current_speed;
     buffer[CM_SMALL_ARGB_COLOUR_INDEX_BYTE]             = (bool_random) ? 0x00 : 0x10; //This looks to still be the colour index and controls random colours

Controllers/CoolerMasterController/CMSmallARGBController/CMSmallARGBController.h

@@ -74,13 +74,14 @@ enum
 class CMSmallARGBController
 {
 public:
-    CMSmallARGBController(hid_device* dev_handle, char *_path);
+    CMSmallARGBController(hid_device* dev_handle, char *_path, unsigned char _zone_idx);
     ~CMSmallARGBController();
 
     std::string         GetDeviceName();
     std::string         GetSerial();
     std::string         GetLocation();
 
+    unsigned char       GetZoneIndex();
     unsigned char       GetMode();
     unsigned char       GetLedRed();
     unsigned char       GetLedGreen();
@@ -96,6 +97,7 @@ private:
     std::string         location;
     hid_device*         dev;
 
+    unsigned char       zone_index;
     unsigned char       current_mode;
     unsigned char       current_speed;
 

Controllers/CoolerMasterController/CMSmallARGBController/RGBController_CMSmallARGBController.cpp

@@ -29,7 +29,7 @@ RGBController_CMSmallARGBController::RGBController_CMSmallARGBController(CMSmall
     controller                  = controller_ptr;
     unsigned char speed         = controller->GetLedSpeed();
 
-    name                        = cm_small_argb_header_data[0].name;
+    name                        = cm_small_argb_header_data[controller->GetZoneIndex()].name;
     vendor                      = "Cooler Master";
     type                        = DEVICE_TYPE_LEDSTRIP;
     description                 = controller->GetDeviceName();
@@ -152,6 +152,7 @@ RGBController_CMSmallARGBController::RGBController_CMSmallARGBController(CMSmall
     PassThru.color_mode         = MODE_COLORS_NONE;
     modes.push_back(PassThru);
 
+    Init_Controller();         //Only processed on first run
     SetupZones();
 
     int temp_mode               = controller->GetMode();
@@ -180,75 +181,60 @@ RGBController_CMSmallARGBController::RGBController_CMSmallARGBController(CMSmall
 
 RGBController_CMSmallARGBController::~RGBController_CMSmallARGBController()
 {
-    Shutdown();
-
     delete controller;
 }
 
+void RGBController_CMSmallARGBController::Init_Controller()
+{
+    int zone_idx            = controller->GetZoneIndex();
+    int zone_led_count      = cm_small_argb_header_data[zone_idx].count;
+    bool boolSingleLED      = ( zone_led_count == 1 );          //If argb_header_data[zone_idx].count == 1 then the zone is ZONE_TYPE_SINGLE
+
+    zone ARGB_zone;
+    ARGB_zone.name          = std::to_string(zone_idx);
+    ARGB_zone.type          = (boolSingleLED) ? ZONE_TYPE_SINGLE : ZONE_TYPE_LINEAR;
+    ARGB_zone.leds_min      = CM_SMALL_ARGB_MIN_LEDS;
+    ARGB_zone.leds_max      = CM_SMALL_ARGB_MAX_LEDS;
+    ARGB_zone.leds_count    = zone_led_count;
+    zones.push_back(ARGB_zone);
+}
+
 void RGBController_CMSmallARGBController::SetupZones()
 {
-    /*-----------------------------------------------------*\
-    | Only set LED count on the first run                   |
-    \*-----------------------------------------------------*/
-    bool first_run = false;
-
-    if(zones.size() == 0)
-    {
-        first_run = true;
-    }
-
-    /*-----------------------------------------------------*\
-    | Clear any existing color/LED configuration            |
-    \*-----------------------------------------------------*/
+    /*-------------------------------------------------*\
+    | Clear any existing color/LED configuration        |
+    \*-------------------------------------------------*/
     leds.clear();
     colors.clear();
-    zones.resize(1);
 
-    /*-----------------------------------------------------*\
-    | Set up zones and LEDs                                 |
-    \*-----------------------------------------------------*/
+    /*---------------------------------------------------------*\
+    | Set up zones                                              |
+    \*---------------------------------------------------------*/
     for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
     {
-        zones[zone_idx].leds_min                    = 0;
-        zones[zone_idx].leds_max                    = CM_SMALL_ARGB_MAX_LEDS;
+        bool boolSingleLED = (zones[zone_idx].type == ZONE_TYPE_SINGLE);    //Calculated for later use
 
-        if(first_run)
+        if (!boolSingleLED)
         {
-            zones[zone_idx].flags                   = ZONE_FLAG_MANUALLY_CONFIGURABLE_SIZE
-                                                    | ZONE_FLAG_MANUALLY_CONFIGURABLE_NAME
-                                                    | ZONE_FLAG_MANUALLY_CONFIGURABLE_TYPE
-                                                    | ZONE_FLAG_MANUALLY_CONFIGURABLE_MATRIX_MAP
-                                                    | ZONE_FLAG_MANUALLY_CONFIGURABLE_SEGMENTS;
-        }
-
-        if(!(zones[zone_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_NAME))
-        {
-            zones[zone_idx].name                    = "Addressable RGB Header";
-            zones[zone_idx].name.append(std::to_string(zone_idx + 1));
-        }
-
-        if(!(zones[zone_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_SIZE))
-        {
-            zones[zone_idx].leds_count              = 0;
-        }
-
-        if(!(zones[zone_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_TYPE))
-        {
-            zones[zone_idx].type                    = ZONE_TYPE_LINEAR;
-        }
-
-        if(!(zones[zone_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_MATRIX_MAP))
-        {
-            zones[zone_idx].matrix_map.width        = 0;
-            zones[zone_idx].matrix_map.height       = 0;
-            zones[zone_idx].matrix_map.map.resize(0);
+            controller->SetLedCount(cm_small_argb_header_data[zone_idx].header, zones[zone_idx].leds_count);
         }
 
         for(unsigned int lp_idx = 0; lp_idx < zones[zone_idx].leds_count; lp_idx++)
         {
-            led new_led;
-            new_led.name                            = zones[zone_idx].name;
-            new_led.name.append(", LED " + std::to_string(lp_idx));
+            led     new_led;
+            unsigned int i = std::stoi(zones[zone_idx].name);
+
+            if(boolSingleLED)
+            {
+                new_led.name  = i;
+                new_led.value = cm_small_argb_header_data[i].header;
+            }
+            else
+            {
+                new_led.name = i;
+                new_led.name.append(" LED " + std::to_string(lp_idx));
+                new_led.value = cm_small_argb_header_data[i].header;
+            }
 
             leds.push_back(new_led);
         }
@@ -257,11 +243,16 @@ void RGBController_CMSmallARGBController::SetupZones()
     SetupColors();
 }
 
-void RGBController_CMSmallARGBController::DeviceConfigureZone(int zone_idx)
+void RGBController_CMSmallARGBController::DeviceResizeZone(int zone, int new_size)
 {
-    if((size_t)zone_idx < zones.size())
+    if((size_t) zone >= zones.size())
     {
-        controller->SetLedCount(cm_small_argb_header_data[zone_idx].header, zones[zone_idx].leds_count);
+        return;
+    }
+
+    if(((unsigned int)new_size >= zones[zone].leds_min) && ((unsigned int)new_size <= zones[zone].leds_max))
+    {
+        zones[zone].leds_count = new_size;
 
         SetupZones();
     }

Controllers/CoolerMasterController/CMSmallARGBController/RGBController_CMSmallARGBController.h

@@ -27,7 +27,7 @@ public:
     ~RGBController_CMSmallARGBController();
 
     void        SetupZones();
-    void        DeviceConfigureZone(int zone_idx);
+    void        DeviceResizeZone(int zone, int new_size);
 
     void        DeviceUpdateLEDs();
     void        DeviceUpdateZoneLEDs(int zone);

Controllers/CoolerMasterController/CoolerMasterControllerDetect.cpp

@@ -91,19 +91,19 @@ DetectedControllers DetectCoolerMasterARGB(hid_device_info* info, const std::str
 
     if(dev)
     {
-        CMARGBController*                   controller     = new CMARGBController(dev, info->path);
+        /*-------------------------------------------------*\
+        | Create mutex to prevent the controllers sharing a |
+        |   receiver from interfering with each other       |
+        \*-------------------------------------------------*/
+        std::shared_ptr<std::mutex>       cm_mutex = std::make_shared<std::mutex>();
 
-        if(controller->GetVersion() != "Unsupported")
+        for(unsigned char i = 0; i < CM_ARGB_HEADER_DATA_SIZE; i++)
         {
+            CMARGBController*               controller     = new CMARGBController(dev, info->path, i, cm_mutex);
             RGBController_CMARGBController* rgb_controller = new RGBController_CMARGBController(controller);
 
             detected_controllers.push_back(rgb_controller);
         }
-        else
-        {
-            LOG_ERROR("[CMARGBController] Unsupported firmware version");
-            delete controller;
-        }
     }
 
     return(detected_controllers);
@@ -326,7 +326,7 @@ DetectedControllers DetectCoolerMasterSmallARGB(hid_device_info* info, const std
 
     if(dev)
     {
-        CMSmallARGBController*               controller     = new CMSmallARGBController(dev, info->path);
+        CMSmallARGBController*               controller     = new CMSmallARGBController(dev, info->path, 0);
         RGBController_CMSmallARGBController* rgb_controller = new RGBController_CMSmallARGBController(controller);
 
         detected_controllers.push_back(rgb_controller);

Controllers/CorsairCommanderCoreController/RGBController_CorsairCommanderCore.cpp

@@ -51,99 +51,56 @@ static unsigned int matrix_map24[11][11] =
 
 RGBController_CorsairCommanderCore::RGBController_CorsairCommanderCore(CorsairCommanderCoreController* controller_ptr)
 {
-    controller          = controller_ptr;
+    controller  = controller_ptr;
 
-    name                = controller->GetNameString();
-    vendor              = "Corsair";
-    description         = "Corsair Commander Core Device";
-    version             = controller->GetFirmwareString();
-    type                = DEVICE_TYPE_COOLER;
-    location            = controller->GetLocationString();
+    name        = controller->GetNameString();
+    vendor      = "Corsair";
+    description = "Corsair Commander Core Device";
+    version     = controller->GetFirmwareString();
+    type        = DEVICE_TYPE_COOLER;
+    location    = controller->GetLocationString();
+    SetupZones();
 
     mode Direct;
-    Direct.name         = "Direct";
-    Direct.value        = 0;
-    Direct.flags        = MODE_FLAG_HAS_PER_LED_COLOR;
-    Direct.color_mode   = MODE_COLORS_PER_LED;
+    Direct.name       = "Direct";
+    Direct.value      = 0;
+    Direct.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    Direct.color_mode = MODE_COLORS_PER_LED;
     modes.push_back(Direct);
-
-    SetupZones();
 }
 
 RGBController_CorsairCommanderCore::~RGBController_CorsairCommanderCore()
 {
-    Shutdown();
-
     delete controller;
 }
 
 void RGBController_CorsairCommanderCore::SetupZones()
 {
-    /*-----------------------------------------------------*\
-    | Only set LED count on the first run                   |
-    \*-----------------------------------------------------*/
-    bool first_run = false;
+    std::atomic<bool> first_run;
+    first_run = 0;
 
     if(zones.size() == 0)
     {
-        first_run = true;
+        first_run = 1;
     }
 
-    /*-----------------------------------------------------*\
-    | Clear any existing color/LED configuration            |
-    \*-----------------------------------------------------*/
-    leds.clear();
-    colors.clear();
-    zones.resize(7);
-
-    /*-----------------------------------------------------*\
-    | Set up zones                                          |
-    \*-----------------------------------------------------*/
     std::vector<unsigned short int> led_count = controller->GetLedCounts();
-
+    zones.resize(7);
     if(controller->GetPidInt() == CORSAIR_COMMANDER_CORE_XT_PID)
     {
-        zones[0].leds_min                           = 0;
-        zones[0].leds_max                           = 204;
-
-        if(first_run)
-        {
-            zones[0].flags                          = ZONE_FLAG_MANUALLY_CONFIGURABLE_SIZE
-                                                    | ZONE_FLAG_MANUALLY_CONFIGURABLE_NAME
-                                                    | ZONE_FLAG_MANUALLY_CONFIGURABLE_TYPE
-                                                    | ZONE_FLAG_MANUALLY_CONFIGURABLE_MATRIX_MAP
-                                                    | ZONE_FLAG_MANUALLY_CONFIGURABLE_SEGMENTS;
-        }
-
-        if(!(zones[0].flags & ZONE_FLAG_MANUALLY_CONFIGURED_NAME))
-        {
-            zones[0].name                           = "Corsair RGB Header";
-        }
-
-        if(!(zones[0].flags & ZONE_FLAG_MANUALLY_CONFIGURED_SIZE))
-        {
-            zones[0].leds_count                     = 0;
-        }
-
-        if(!(zones[0].flags & ZONE_FLAG_MANUALLY_CONFIGURED_TYPE))
-        {
-            zones[0].type                           = ZONE_TYPE_LINEAR;
-        }
-
-        if(!(zones[0].flags & ZONE_FLAG_MANUALLY_CONFIGURED_MATRIX_MAP))
-        {
-            zones[0].matrix_map.width               = 0;
-            zones[0].matrix_map.height              = 0;
-            zones[0].matrix_map.map.resize(0);
-        }
+        zones[0].name                   = "External RGB Port";
+        zones[0].type                   = ZONE_TYPE_LINEAR;
+        zones[0].leds_min               = zones[0].leds_min;
+        zones[0].leds_max               = 204;
+        zones[0].leds_count             = zones[0].leds_count;
     }
     else
     {
-        zones[0].name                               = "Pump";
-        zones[0].type                               = ZONE_TYPE_MATRIX;
-        zones[0].leds_min                           = led_count.at(0);
-        zones[0].leds_max                           = led_count.at(0);
-        zones[0].leds_count                         = led_count.at(0);
+        zones[0].name                   = "Pump";
+        zones[0].type                   = ZONE_TYPE_MATRIX;
+        zones[0].leds_min               = led_count.at(0);
+        zones[0].leds_max               = led_count.at(0);
+        zones[0].leds_count             = led_count.at(0);
 
         if(led_count.at(0) == 24)
         {
@@ -155,52 +112,28 @@ void RGBController_CorsairCommanderCore::SetupZones()
         }
     }
 
-    for(unsigned int zone_idx = 1; zone_idx < (CORSAIR_COMMANDER_CORE_NUM_CHANNELS + 1); zone_idx++)
+    for(unsigned int i = 1; i < (CORSAIR_COMMANDER_CORE_NUM_CHANNELS + 1); i++)
     {
-        zones[zone_idx].leds_min                    = 0;
-        zones[zone_idx].leds_max                    = 34;
+        zones[i].name               = "RGB Port " + std::to_string(i);
+        zones[i].type               = ZONE_TYPE_LINEAR;
+        zones[i].leds_min           = 0;
+        zones[i].leds_max           = 34;
 
         if(first_run)
         {
-            zones[zone_idx].flags                   = ZONE_FLAG_MANUALLY_CONFIGURABLE_SIZE
-                                                    | ZONE_FLAG_MANUALLY_CONFIGURABLE_NAME
-                                                    | ZONE_FLAG_MANUALLY_CONFIGURABLE_TYPE
-                                                    | ZONE_FLAG_MANUALLY_CONFIGURABLE_MATRIX_MAP
-                                                    | ZONE_FLAG_MANUALLY_CONFIGURABLE_SEGMENTS;
-        }
-
-        if(!(zones[zone_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_NAME))
-        {
-            zones[zone_idx].name                    = "Corsair Fan Header " + std::to_string(zone_idx);
-        }
-
-        if(!(zones[zone_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_SIZE))
-        {
-            zones[zone_idx].leds_count              = 0;
-        }
-
-        if(!(zones[zone_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_TYPE))
-        {
-            zones[zone_idx].type                    = ZONE_TYPE_LINEAR;
-        }
-
-        if(!(zones[zone_idx].flags & ZONE_FLAG_MANUALLY_CONFIGURED_MATRIX_MAP))
-        {
-            zones[zone_idx].matrix_map.width        = 0;
-            zones[zone_idx].matrix_map.height       = 0;
-            zones[zone_idx].matrix_map.map.resize(0);
+            zones[i].leds_count     = (led_count.size() > i) ? led_count.at(i) : 0;
         }
     }
 
-    /*-----------------------------------------------------*\
-    | Set up LEDs                                           |
-    \*-----------------------------------------------------*/
+    leds.clear();
+    colors.clear();
+
     for(unsigned int zone_idx = 0; zone_idx < zones.size(); zone_idx++)
     {
         for(unsigned int led_idx = 0; led_idx < zones[zone_idx].leds_count; led_idx++)
         {
             led new_led;
-            new_led.name            = zones[zone_idx].name + ", LED " + std::to_string(led_idx+1);
+            new_led.name            = zones[zone_idx].name + " LED " + std::to_string(led_idx+1);
 
             leds.push_back(new_led);
         }
@@ -209,23 +142,28 @@ void RGBController_CorsairCommanderCore::SetupZones()
     SetupColors();
 }
 
-void RGBController_CorsairCommanderCore::DeviceConfigureZone(int zone_idx)
+void RGBController_CorsairCommanderCore::DeviceResizeZone(int zone, int new_size)
 {
-    if((size_t)zone_idx < zones.size())
+    if((size_t) zone >= zones.size())
     {
-        if(zone_idx == 0 && controller->GetPidInt() == CORSAIR_COMMANDER_CORE_XT_PID)
+        return;
+    }
+
+    if(((unsigned int)new_size >= zones[zone].leds_min) && ((unsigned int)new_size <= zones[zone].leds_max))
+    {
+        zones[zone].leds_count = new_size;
+        if(zone == 0 && controller->GetPidInt() == CORSAIR_COMMANDER_CORE_XT_PID)
         {
-            if(zones[zone_idx].leds_count > 0)
+            if(new_size > 0)
             {
                 controller->SetFanMode(true);
-                controller->SetLedAmount(zones[zone_idx].leds_count);
+                controller->SetLedAmount(new_size);
             }
             else
             {
                 controller->SetFanMode(false);
             }
         }
-
         SetupZones();
     }
 }

Controllers/CorsairCommanderCoreController/RGBController_CorsairCommanderCore.h

@@ -22,7 +22,7 @@ public:
 
     void        SetupZones();
 
-    void        DeviceConfigureZone(int zone_idx);
+    void        DeviceResizeZone(int zone, int new_size);
     void        DeviceUpdateLEDs();
     void        DeviceUpdateZoneLEDs(int zone);
     void        DeviceUpdateSingleLED(int led);

Controllers/CorsairDRAMController/CorsairDRAMController.cpp

@@ -1,422 +0,0 @@
-/*---------------------------------------------------------*\
-| CorsairDRAMController.cpp                                 |
-|                                                           |
-|   Driver for Corsair DRAM RGB controllers                 |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                30 Jun 2019 |
-|   Erik Gilling (konkers)                      25 Sep 2020 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
-
-#include "CRC.h"
-#include "CorsairDRAMController.h"
-#include "LogManager.h"
-
-#define CORSAIR_DRAM_NAME "Corsair DRAM"
-
-using namespace std::chrono_literals;
-
-CorsairDRAMController::CorsairDRAMController(i2c_smbus_interface *bus, corsair_dev_id dev)
-{
-    /*-----------------------------------------------------*\
-    | Initialize class variables                            |
-    \*-----------------------------------------------------*/
-    this->bus           = bus;
-    this->dev           = dev;
-    device_index        = 0;
-    pid                 = 0;
-    vid                 = 0;
-    protocol_version    = 0;
-
-    /*-----------------------------------------------------*\
-    | Read device information                               |
-    \*-----------------------------------------------------*/
-    ReadDeviceInfo();
-}
-
-CorsairDRAMController::~CorsairDRAMController()
-{
-}
-
-unsigned int CorsairDRAMController::GetLEDCount()
-{
-    return(corsair_dram_device_list[device_index]->led_count);
-}
-
-unsigned char CorsairDRAMController::GetProtocolVersion()
-{
-    return(protocol_version);
-}
-
-std::string CorsairDRAMController::GetDeviceLocation()
-{
-    std::string return_string(bus->device_name);
-    char addr[5];
-    snprintf(addr, 5, "0x%02X", dev);
-    return_string.append(", address ");
-    return_string.append(addr);
-    return("I2C: " + return_string);
-}
-
-std::string CorsairDRAMController::GetDeviceName()
-{
-    return(corsair_dram_device_list[device_index]->name);
-}
-
-std::string CorsairDRAMController::GetDeviceVersion()
-{
-    return(firmware_version);
-}
-
-void CorsairDRAMController::SetColorsPerLED(RGBColor* colors)
-{
-    /*-----------------------------------------------------*\
-    | Get LED count from device list                        |
-    \*-----------------------------------------------------*/
-    unsigned int        led_count           = corsair_dram_device_list[device_index]->led_count;
-
-    if(direct_mode)
-    {
-        /*-------------------------------------------------*\
-        | Sanity check - Direct mode can only be used on    |
-        | protocol 4+                                       |
-        \*-------------------------------------------------*/
-        if(protocol_version < 4)
-        {
-            LOG_ERROR("[%s] Protocol version %d tried to use direct mode, ignoring", CORSAIR_DRAM_NAME, protocol_version);
-            return;
-        }
-
-        /*-------------------------------------------------*\
-        | Packet format:                                    |
-        |   Size n is (LED count * 3) + 2                   |
-        |   0:          Command byte (0x0A or 0x0C)         |
-        |   1 to (n-2): LED color data in R/G/B order       |
-        |   (n-1):      CRC8 of bytes 0 to (n-2)            |
-        \*-------------------------------------------------*/
-        unsigned int    direct_packet_size  = (led_count * 3) + 2;
-        unsigned char*  direct_packet       = new unsigned char[direct_packet_size];
-
-        /*-------------------------------------------------*\
-        | First byte in packet is LED count                 |
-        \*-------------------------------------------------*/
-        direct_packet[0]                    = led_count;
-
-        /*-------------------------------------------------*\
-        | Fill in LED data                                  |
-        \*-------------------------------------------------*/
-        for(unsigned int led_idx = 0; led_idx < led_count; led_idx++)
-        {
-            unsigned int color_index        = led_idx;
-            unsigned int offset             = (led_idx * 3) + 1;
-
-            if(corsair_dram_device_list[device_index]->reverse)
-            {
-                color_index                 = (led_count -1) - led_idx;
-            }
-
-            direct_packet[offset + 0]       = RGBGetRValue(colors[color_index]);
-            direct_packet[offset + 1]       = RGBGetGValue(colors[color_index]);
-            direct_packet[offset + 2]       = RGBGetBValue(colors[color_index]);
-        }
-
-        /*-------------------------------------------------*\
-        | Last byte in packet is CRC of all data up to it   |
-        \*-------------------------------------------------*/
-        direct_packet[direct_packet_size - 1] = CRCPP::CRC::Calculate(direct_packet, (direct_packet_size - 1), CRCPP::CRC::CRC_8());
-
-        /*-------------------------------------------------*\
-        | Write using block writes, if packet exceeds 32    |
-        | bytes, use a second block write to the second     |
-        | block write address for the remaining data        |
-        \*-------------------------------------------------*/
-        bus->i2c_smbus_write_block_data(dev, CORSAIR_DRAM_REG_COLOR_BUFFER_BLOCK_1, 32, direct_packet);
-
-        if(direct_packet_size > 32)
-        {
-            bus->i2c_smbus_write_block_data(dev, CORSAIR_DRAM_REG_COLOR_BUFFER_BLOCK_2, direct_packet_size - 32, direct_packet + 32);
-        }
-
-        /*-------------------------------------------------*\
-        | Remember to delete the data buffer                |
-        \*-------------------------------------------------*/
-        delete[] direct_packet;
-    }
-    else
-    {
-        /*-------------------------------------------------*\
-        | Local variables                                   |
-        \*-------------------------------------------------*/
-        unsigned char   device_crc;
-        unsigned char   calc_crc;
-
-        /*-------------------------------------------------*\
-        | Packet format:                                    |
-        |   Size n is (LED count * 4)                       |
-        |   Format is 0xRR, 0xGG, 0xBB, 0xFF for each LED   |
-        \*-------------------------------------------------*/
-        unsigned int    color_data_size     = (led_count * 4);
-        unsigned char*  color_data_packet   = new unsigned char[color_data_size];
-
-        for(unsigned int led_idx = 0; led_idx < led_count; led_idx++)
-        {
-            unsigned int color_index        = led_idx;
-
-            if(corsair_dram_device_list[device_index]->reverse)
-            {
-                color_index                 = (led_count -1) - led_idx;
-            }
-
-            color_data_packet[(led_idx * 4) + 0]  = RGBGetRValue(colors[color_index]);
-            color_data_packet[(led_idx * 4) + 1]  = RGBGetGValue(colors[color_index]);
-            color_data_packet[(led_idx * 4) + 2]  = RGBGetBValue(colors[color_index]);
-            color_data_packet[(led_idx * 4) + 3]  = 0xFF;
-        }
-
-        /*-------------------------------------------------*\
-        | Write LED color data packet                       |
-        \*-------------------------------------------------*/
-        bus->i2c_smbus_write_byte_data(dev, CORSAIR_DRAM_REG_RESET_BUFFER, 0x00);
-        bus->i2c_smbus_write_byte_data(dev, CORSAIR_DRAM_REG_BINARY_START, 0x00);
-
-        for(unsigned int i = 0; i < color_data_size; i++)
-        {
-            bus->i2c_smbus_write_byte_data(dev, CORSAIR_DRAM_REG_SET_BINARY_DATA, color_data_packet[i]);
-        }
-
-        /*-------------------------------------------------*\
-        | Calculate CRC and read CRC reported by device     |
-        \*-------------------------------------------------*/
-        calc_crc    = CRCPP::CRC::Calculate(color_data_packet, color_data_size, CRCPP::CRC::CRC_8());
-        device_crc  = bus->i2c_smbus_read_byte_data(dev, CORSAIR_DRAM_REG_GET_CHECKSUM);
-
-        /*-------------------------------------------------*\
-        | Write effect configuration only if CRCs match     |
-        \*-------------------------------------------------*/
-        if(calc_crc == device_crc)
-        {
-            bus->i2c_smbus_write_byte_data(dev, CORSAIR_DRAM_REG_WRITE_CONFIGURATION, CORSAIR_DRAM_ID_COLOR_DATA);
-            WaitReady();
-        }
-
-        /*-------------------------------------------------*\
-        | Remember to delete the data buffer                |
-        \*-------------------------------------------------*/
-        delete[] color_data_packet;
-    }
-}
-
-void CorsairDRAMController::SetDirect(bool direct)
-{
-    direct_mode = direct;
-}
-
-void CorsairDRAMController::SetEffect
-    (
-    unsigned char mode,
-    unsigned char speed,
-    unsigned char direction,
-    bool          random,
-    unsigned char brightness,
-    unsigned char red1,
-    unsigned char grn1,
-    unsigned char blu1,
-    unsigned char red2,
-    unsigned char grn2,
-    unsigned char blu2
-    )
-{
-    /*-----------------------------------------------------*\
-    | Local variables                                       |
-    \*-----------------------------------------------------*/
-    unsigned char   effect_data[20];
-    unsigned char   device_crc;
-    unsigned char   calc_crc;
-    unsigned char   random_byte;
-
-    /*-----------------------------------------------------*\
-    | If mode is direct (which is a dummy value not         |
-    | understood by the hardware), return.  Direct mode is  |
-    | not set in the effect configuration.                  |
-    \*-----------------------------------------------------*/
-    direct_mode = (mode == CORSAIR_DRAM_MODE_DIRECT);
-
-    if(direct_mode)
-    {
-        return;
-    }
-
-    /*-----------------------------------------------------*\
-    | Determine random byte                                 |
-    \*-----------------------------------------------------*/
-    if(random)
-    {
-        random_byte = CORSAIR_DRAM_EFFECT_RANDOM_COLORS;
-    }
-    else
-    {
-        random_byte = CORSAIR_DRAM_EFFECT_CUSTOM_COLORS;
-    }
-
-    /*-----------------------------------------------------*\
-    | Fill in effect packet                                 |
-    \*-----------------------------------------------------*/
-    effect_data[0]  = mode;         // Mode
-    effect_data[1]  = speed;        // Speed
-    effect_data[2]  = random_byte;  // Custom color
-    effect_data[3]  = direction;    // Direction
-    effect_data[4]  = red1;         // Custom color 1 red
-    effect_data[5]  = grn1;         // Custom color 1 green
-    effect_data[6]  = blu1;         // Custom color 1 blue
-    effect_data[7]  = brightness;
-    effect_data[8]  = red2;         // Custom color 2 red
-    effect_data[9]  = grn2;         // Custom color 2 green
-    effect_data[10] = blu2;         // Custom color 2 blue
-    effect_data[11] = brightness;
-    effect_data[12] = 0x00;
-    effect_data[13] = 0x00;
-    effect_data[14] = 0x00;
-    effect_data[15] = 0x00;
-    effect_data[16] = 0x00;
-    effect_data[17] = 0x00;
-    effect_data[18] = 0x00;
-    effect_data[19] = 0x00;
-
-    /*-----------------------------------------------------*\
-    | Write effect packet                                   |
-    \*-----------------------------------------------------*/
-    bus->i2c_smbus_write_byte_data(dev, CORSAIR_DRAM_REG_RESET_BUFFER, 0x00);
-    bus->i2c_smbus_write_byte_data(dev, CORSAIR_DRAM_REG_BINARY_START, 0x00);
-
-    for(unsigned int i = 0; i < 20; i++)
-    {
-        bus->i2c_smbus_write_byte_data(dev, CORSAIR_DRAM_REG_SET_BINARY_DATA, effect_data[i]);
-    }
-
-    /*-----------------------------------------------------*\
-    | Calculate CRC and read CRC reported by device         |
-    \*-----------------------------------------------------*/
-    calc_crc    = CRCPP::CRC::Calculate(effect_data, sizeof(effect_data), CRCPP::CRC::CRC_8());
-    device_crc  = bus->i2c_smbus_read_byte_data(dev, CORSAIR_DRAM_REG_GET_CHECKSUM);
-
-    /*-----------------------------------------------------*\
-    | Write effect configuration only if CRCs match         |
-    \*-----------------------------------------------------*/
-    if(calc_crc == device_crc)
-    {
-        bus->i2c_smbus_write_byte_data(dev, CORSAIR_DRAM_REG_WRITE_CONFIGURATION, CORSAIR_DRAM_ID_EFFECT_CONFIGURATION);
-        WaitReady();
-    }
-}
-
-bool CorsairDRAMController::WaitReady()
-{
-    /*-----------------------------------------------------*\
-    | Poll status register 0x30; bit 3 (0x08) = busy.       |
-    | Device is ready when bit 3 is clear.                  |
-    \*-----------------------------------------------------*/
-    for(int retry = 0; retry < 5; retry++)
-    {
-        int status = bus->i2c_smbus_read_byte_data(dev, CORSAIR_DRAM_REG_STATUS);
-
-        if(status >= 0 && (status & 0x08) == 0)
-        {
-            return true;
-        }
-
-        std::this_thread::sleep_for(10ms);
-    }
-
-    return false;
-}
-
-void CorsairDRAMController::ReadDeviceInfo()
-{
-    unsigned char   device_information_data[32];
-    unsigned char   device_crc;
-    unsigned char   calc_crc;
-
-    /*-----------------------------------------------------*\
-    | Request Device Information Data                       |
-    \*-----------------------------------------------------*/
-    bus->i2c_smbus_write_byte_data(dev, CORSAIR_DRAM_REG_GET_DEVICE_INFO, 0x00);
-    bus->i2c_smbus_write_byte_data(dev, CORSAIR_DRAM_REG_BINARY_START,    0x00);
-
-    /*-----------------------------------------------------*\
-    | Read Device Information Data                          |
-    \*-----------------------------------------------------*/
-    for(unsigned int i = 0; i < 32; i++)
-    {
-        device_information_data[i] = bus->i2c_smbus_read_byte_data(dev, CORSAIR_DRAM_REG_GET_BINARY_DATA);
-    }
-
-    /*-----------------------------------------------------*\
-    | Compare CRC                                           |
-    \*-----------------------------------------------------*/
-    calc_crc    = CRCPP::CRC::Calculate(device_information_data, sizeof(device_information_data), CRCPP::CRC::CRC_8());
-    device_crc  = bus->i2c_smbus_read_byte_data(dev, CORSAIR_DRAM_REG_GET_CHECKSUM);
-
-    if(calc_crc != device_crc)
-    {
-        LOG_ERROR("[%s] ReadDeviceInfo CRC Mismatch", CORSAIR_DRAM_NAME);
-    }
-
-    /*-----------------------------------------------------*\
-    | Log Device Information Data                           |
-    \*-----------------------------------------------------*/
-    if(LogManager::get()->getLoglevel() >= LL_TRACE)
-    {
-        char            device_info_buf[256];
-        unsigned int    pos;
-
-        pos = snprintf(device_info_buf, sizeof(device_info_buf), "%02X: ", dev);
-
-        for(unsigned int i = 0; i < 32; i++)
-        {
-            pos += snprintf(&device_info_buf[pos], sizeof(device_info_buf) - pos, "%02X ", device_information_data[i]);
-        }
-
-        LOG_TRACE("[%s] Device Info: %s", CORSAIR_DRAM_NAME, device_info_buf);
-    }
-
-    /*-----------------------------------------------------*\
-    | Read VID                                              |
-    \*-----------------------------------------------------*/
-    vid = (device_information_data[1] << 8) | device_information_data[0];
-
-    /*-----------------------------------------------------*\
-    | Read PID                                              |
-    \*-----------------------------------------------------*/
-    pid = (device_information_data[3] << 8) | device_information_data[2];
-
-    /*-----------------------------------------------------*\
-    | Format Firwmare Version                               |
-    \*-----------------------------------------------------*/
-    firmware_version = std::to_string(device_information_data[9]) + "." + std::to_string(device_information_data[8]) + "." + std::to_string((device_information_data[11] << 8) | device_information_data[10]);
-
-    /*-----------------------------------------------------*\
-    | Read Protocol Version                                 |
-    \*-----------------------------------------------------*/
-    protocol_version = device_information_data[28];
-
-    /*-----------------------------------------------------*\
-    | Loop through all known devices to look for a PID      |
-    | match                                                 |
-    \*-----------------------------------------------------*/
-    for(unsigned int i = 0; i < CORSAIR_DRAM_NUM_DEVICES; i++)
-    {
-        for(unsigned int j = 0; j < CORSAIR_DRAM_MAX_PIDS; j++)
-        {
-            if(corsair_dram_device_list[i]->pids[j] == pid)
-            {
-                /*-----------------------------------------*\
-                | Set device ID                             |
-                \*-----------------------------------------*/
-                device_index = i;
-                break;
-            }
-        }
-    }
-}

Controllers/CorsairDRAMController/CorsairDRAMController.h

@@ -1,149 +0,0 @@
-/*---------------------------------------------------------*\
-| CorsairDRAMController.h                                   |
-|                                                           |
-|   Driver for Corsair DRAM RGB controllers                 |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                30 Jun 2019 |
-|   Erik Gilling (konkers)                      25 Sep 2020 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
-
-#pragma once
-
-#include <string>
-#include "i2c_smbus.h"
-#include "CorsairDRAMDevices.h"
-#include "RGBController.h"
-
-typedef unsigned char corsair_dev_id;
-
-enum
-{   /* (*) indicates deprecated registers no longer used by iCue                                            */
-    CORSAIR_DRAM_REG_RESET_BUFFER           = 0x0B,     /* Reset buffer by writing 0x00                     */
-    CORSAIR_DRAM_REG_SET_BINARY_DATA        = 0x20,     /* Write byte to active binary data buffer          */
-    CORSAIR_DRAM_REG_BINARY_START           = 0x21,     /* Start binary data transfer by writing 0x00       */
-    CORSAIR_DRAM_REG_SWITCH_MODE            = 0x23,     /* Switch between Bootloader(0x00) and Normal(0x01) */
-    CORSAIR_DRAM_REG_SET_BUFFER             = 0x26,     /* Select configuration buffer to write by ID (*)   */
-    CORSAIR_DRAM_REG_STATUS                 = 0x30,     /* Status register                                  */
-    CORSAIR_DRAM_REG_COLOR_BUFFER_BLOCK_1   = 0x31,     /* Direct color buffer block register 1             */
-    CORSAIR_DRAM_REG_COLOR_BUFFER_BLOCK_2   = 0x32,     /* Direct color buffer block register 2             */
-    CORSAIR_DRAM_REG_GET_BINARY_DATA        = 0x40,     /* Read byte from active binary data buffer         */
-    CORSAIR_DRAM_REG_BUSY_STATUS            = 0x41,     /* Reads nonzero while busy, zero when ready(*)     */
-    CORSAIR_DRAM_REG_GET_CHECKSUM           = 0x42,     /* Get checksum (CRC8) of active binary data buffer */
-    CORSAIR_DRAM_REG_GET_DEVICE_INFO        = 0x61,     /* Select device info buffer                        */
-    CORSAIR_DRAM_REG_GET_CONFIGURATION      = 0x63,     /* Select configuration buffer to read by ID        */
-    CORSAIR_DRAM_REG_WRITE_CONFIGURATION    = 0x82,     /* Write/Apply configuration by writing buffer ID   */
-};
-
-enum
-{
-    CORSAIR_DRAM_ID_COMMAND_LIST            = 0,        /* Command list                                     */
-    CORSAIR_DRAM_ID_EFFECT_CONFIGURATION    = 1,        /* Effect configuration                             */
-    CORSAIR_DRAM_ID_COLOR_DATA              = 2,        /* Color data                                       */
-};
-
-enum
-{
-    CORSAIR_DRAM_MODE_DIRECT                = 0xDD,     /* Arbitrary value to compare against later. Not the actual packet  */
-    CORSAIR_DRAM_MODE_COLOR_SHIFT           = 0x00,     /* Color Shift mode                                                 */
-    CORSAIR_DRAM_MODE_COLOR_PULSE           = 0x01,     /* Color Pulse mode                                                 */
-    CORSAIR_DRAM_MODE_RAINBOW_WAVE          = 0x03,     /* Rainbow Wave mode                                                */
-    CORSAIR_DRAM_MODE_COLOR_WAVE            = 0x04,     /* Color Wave mode                                                  */
-    CORSAIR_DRAM_MODE_VISOR                 = 0x05,     /* Visor mode                                                       */
-    CORSAIR_DRAM_MODE_RAIN                  = 0x06,     /* Rain mode                                                        */
-    CORSAIR_DRAM_MODE_MARQUEE               = 0x07,     /* Marquee mode                                                     */
-    CORSAIR_DRAM_MODE_RAINBOW               = 0x08,     /* Rainbow mode                                                     */
-    CORSAIR_DRAM_MODE_SEQUENTIAL            = 0x09,     /* Sequential mode                                                  */
-    CORSAIR_DRAM_MODE_STATIC                = 0x10,     /* Static mode                                                      */
-
-    CORSAIR_DRAM_NUMBER_MODES               = 10,       /* Number of Corsair Pro modes          */
-};
-
-enum
-{
-    CORSAIR_DRAM_SPEED_SLOW                 = 0x00,     /* Slow speed                           */
-    CORSAIR_DRAM_SPEED_MEDIUM               = 0x01,     /* Medium speed                         */
-    CORSAIR_DRAM_SPEED_FAST                 = 0x02,     /* Fast speed                           */
-};
-
-enum
-{
-    CORSAIR_DRAM_EFFECT_RANDOM_COLORS       = 0x00,     /* Random colors                        */
-    CORSAIR_DRAM_EFFECT_CUSTOM_COLORS       = 0x01,     /* Custom colors                        */
-};
-
-enum
-{
-    CORSAIR_DRAM_DIRECTION_UP               = 0x00,     /* Up direction                         */
-    CORSAIR_DRAM_DIRECTION_DOWN             = 0x01,     /* Down direction                       */
-    CORSAIR_DRAM_DIRECTION_LEFT             = 0x02,     /* Left direction                       */
-    CORSAIR_DRAM_DIRECTION_RIGHT            = 0x03,     /* Right direction                      */
-    CORSAIR_DRAM_DIRECTION_VERTICAL         = 0x01,     /* Vertical direction                   */
-    CORSAIR_DRAM_DIRECTION_HORIZONTAL       = 0x03,     /* Horizontal direction                 */
-};
-
-enum
-{
-    CORSAIR_DRAM_BRIGHTNESS_MIN             = 0,        /* Minimum brightness                   */
-    CORSAIR_DRAM_BRIGHTNESS_MAX             = 255,      /* Maximum brightness                   */
-    CORSAIR_DRAM_BRIGHTNESS_DEFAULT         = 255,      /* Default brightness                   */
-};
-
-class CorsairDRAMController
-{
-public:
-    CorsairDRAMController(i2c_smbus_interface *bus, corsair_dev_id dev);
-    ~CorsairDRAMController();
-
-    std::string             GetDeviceLocation();
-    std::string             GetDeviceName();
-    std::string             GetDeviceVersion();
-
-    unsigned int            GetLEDCount();
-    unsigned char           GetProtocolVersion();
-
-    void                    SetColorsPerLED(RGBColor* colors);
-    void                    SetDirect(bool direct);
-    void                    SetEffect(unsigned char mode,
-                                      unsigned char speed,
-                                      unsigned char direction,
-                                      bool          random,
-                                      unsigned char brightness,
-                                      unsigned char red1,
-                                      unsigned char grn1,
-                                      unsigned char blu1,
-                                      unsigned char red2,
-                                      unsigned char grn2,
-                                      unsigned char blu2);
-
-    bool                    WaitReady();
-
-private:
-    /*-----------------------------------------------------*\
-    | I2C                                                   |
-    \*-----------------------------------------------------*/
-    i2c_smbus_interface*    bus;
-    corsair_dev_id          dev;
-
-    /*-----------------------------------------------------*\
-    | State tracking                                        |
-    \*-----------------------------------------------------*/
-    bool                    direct_mode;
-
-    /*-----------------------------------------------------*\
-    | Corsair DRAM information                              |
-    \*-----------------------------------------------------*/
-    unsigned short          vid;
-    unsigned short          pid;
-    std::string             firmware_version;
-    unsigned char           protocol_version;
-
-    unsigned int            device_index;
-
-    /*-----------------------------------------------------*\
-    | Private functions                                     |
-    \*-----------------------------------------------------*/
-    void                    ReadDeviceInfo();
-};

Controllers/CorsairDRAMController/CorsairDRAMControllerDetect.cpp

@@ -1,96 +0,0 @@
-/*---------------------------------------------------------*\
-| CorsairDRAMControllerDetect.cpp                           |
-|                                                           |
-|   Detector for Corsair DRAM RGB controllers               |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                30 Jun 2019 |
-|   Erik Gilling (konkers)                      25 Sep 2020 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
-
-#include <vector>
-#include "CorsairDRAMController.h"
-#include "DetectionManager.h"
-#include "i2c_smbus.h"
-#include "LogManager.h"
-#include "pci_ids.h"
-#include "RGBController_CorsairDRAM.h"
-
-using namespace std::chrono_literals;
-
-#define CORSAIR_DRAM_NAME "Corsair DRAM"
-
-bool TestForCorsairDRAMController(i2c_smbus_interface *bus, unsigned char address)
-{
-    int res = bus->i2c_smbus_write_quick(address, I2C_SMBUS_WRITE);
-
-    LOG_DEBUG("[%s] Trying address %02X", CORSAIR_DRAM_NAME, address);
-
-    if(res < 0)
-    {
-        LOG_DEBUG("[%s] Failed: res was %04X", CORSAIR_DRAM_NAME, res);
-        return false;
-    }
-
-    res = bus->i2c_smbus_read_byte_data(address, 0x43);
-
-    if(!(res == 0x1A || res == 0x1B || res == 0x1C))
-    {
-        LOG_DEBUG("[%s] Failed: expected 0x1A, 0x1B, or 0x1C, got %04X", CORSAIR_DRAM_NAME, res);
-        return false;
-    }
-
-    res = bus->i2c_smbus_read_byte_data(address, 0x44);
-
-    if(!(res == 0x03 || res == 0x04))
-    {
-        LOG_DEBUG("[%s] Failed: expected 0x03 or 0x04, got %04X", CORSAIR_DRAM_NAME, res);
-        return false;
-    }
-
-    return true;
-}
-
-DetectedControllers DetectCorsairDRAMControllers(std::vector<i2c_smbus_interface *> &buses)
-{
-    DetectedControllers detected_controllers;
-
-    for(unsigned int bus = 0; bus < buses.size(); bus++)
-    {
-        IF_DRAM_SMBUS(buses[bus]->pci_vendor, buses[bus]->pci_device)
-        {
-            LOG_DEBUG("[%s] Testing bus %d", CORSAIR_DRAM_NAME, bus);
-
-            std::vector<unsigned char> addresses;
-
-            for(unsigned char addr = 0x58; addr <= 0x5F; addr++)
-            {
-                addresses.push_back(addr);
-            }
-
-            for(unsigned char addr = 0x18; addr <= 0x1F; addr++)
-            {
-                addresses.push_back(addr);
-            }
-
-            for(unsigned char addr : addresses)
-            {
-                if(TestForCorsairDRAMController(buses[bus], addr))
-                {
-                    CorsairDRAMController*     controller     = new CorsairDRAMController(buses[bus], addr);
-                    RGBController_CorsairDRAM* rgb_controller = new RGBController_CorsairDRAM(controller);
-
-                    detected_controllers.push_back(rgb_controller);
-                }
-
-                std::this_thread::sleep_for(10ms);
-            }
-        }
-    }
-
-    return(detected_controllers);
-}
-
-REGISTER_I2C_DETECTOR(CORSAIR_DRAM_NAME, DetectCorsairDRAMControllers);

Controllers/CorsairDRAMController/CorsairDRAMDevices.cpp

@@ -1,163 +0,0 @@
-/*---------------------------------------------------------*\
-| CorsairDRAMDevices.cpp                                    |
-|                                                           |
-|   Device list for Corsair DRAM RGB controllers            |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                07 Apr 2026 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
-
-#include "CorsairDRAMDevices.h"
-
-static const corsair_dram_device corsair_vengeance_pro_ddr4_device =
-{
-    "Corsair Vengeance RGB Pro DDR4",
-    {
-        CORSAIR_VENGEANCE_PRO_DDR4_PID_1,
-        CORSAIR_VENGEANCE_PRO_DDR4_PID_2,
-        0,
-        0,
-        0,
-        0,
-    },
-    10,
-    false
-};
-
-static const corsair_dram_device corsair_dominator_platinum_ddr4_device =
-{
-    "Corsair Dominator Platinum RGB DDR4",
-    {
-        CORSAIR_DOMINATOR_PLATINUM_DDR4_PID_1,
-        CORSAIR_DOMINATOR_PLATINUM_DDR4_PID_2,
-        0,
-        0,
-        0,
-        0,
-    },
-    12,
-    true
-};
-
-static const corsair_dram_device corsair_vengeance_pro_sl_ddr4_device =
-{
-    "Corsair Vengeance RGB Pro SL DDR4",
-    {
-        CORSAIR_VENGEANCE_PRO_SL_DDR4_PID_1,
-        CORSAIR_VENGEANCE_PRO_SL_DDR4_PID_2,
-        0,
-        0,
-        0,
-        0,
-    },
-    10,
-    false
-};
-
-static const corsair_dram_device corsair_vengeance_rs_ddr4_device =
-{
-    "Corsair Vengeance RGB RS DDR4",
-    {
-        CORSAIR_VENGEANCE_RS_DDR4_PID_1,
-        CORSAIR_VENGEANCE_RS_DDR4_PID_2,
-        0,
-        0,
-        0,
-        0,
-    },
-    6,
-    false
-};
-
-static const corsair_dram_device corsair_dominator_platinum_ddr5_device =
-{
-    "Corsair Dominator Platinum RGB DDR5",
-    {
-        CORSAIR_DOMINATOR_PLATINUM_DDR5_PID_1,
-        CORSAIR_DOMINATOR_PLATINUM_DDR5_PID_2,
-        0,
-        0,
-        0,
-        0,
-    },
-    12,
-    true
-};
-
-static const corsair_dram_device corsair_dominator_titanium_ddr5_device =
-{
-    "Corsair Dominator Titanium RGB DDR5",
-    {
-        CORSAIR_DOMINATOR_TITANIUM_DDR5_PID_1,
-        CORSAIR_DOMINATOR_TITANIUM_DDR5_PID_2,
-        CORSAIR_DOMINATOR_TITANIUM_DDR5_PID_3,
-        CORSAIR_DOMINATOR_TITANIUM_DDR5_PID_4,
-        0,
-        0,
-    },
-    12,
-    true
-};
-
-static const corsair_dram_device corsair_vengeance_ddr5_device =
-{
-    "Corsair Vengeance RGB DDR5",
-    {
-        CORSAIR_VENGEANCE_DDR5_PID_1,
-        CORSAIR_VENGEANCE_DDR5_PID_2,
-        CORSAIR_VENGEANCE_DDR5_PID_3,
-        CORSAIR_VENGEANCE_DDR5_PID_4,
-        CORSAIR_VENGEANCE_DDR5_PID_5,
-        CORSAIR_VENGEANCE_DDR5_PID_6,
-    },
-    10,
-    false
-};
-
-static const corsair_dram_device corsair_vengeance_shugo_series_ddr5_device =
-{
-    "Corsair Vengeance Shugo Series DDR5",
-    {
-        CORSAIR_VENGEANCE_SHUGO_SERIES_DDR5_PID_1,
-        CORSAIR_VENGEANCE_SHUGO_SERIES_DDR5_PID_2,
-        CORSAIR_VENGEANCE_SHUGO_SERIES_DDR5_PID_3,
-        CORSAIR_VENGEANCE_SHUGO_SERIES_DDR5_PID_4,
-        0,
-        0,
-    },
-    10,
-    false
-};
-
-static const corsair_dram_device corsair_vengeance_rs_ddr5_device =
-{
-    "Corsair Vengeance RGB RS DDR5",
-    {
-        CORSAIR_VENGEANCE_RS_DDR5_PID_1,
-        CORSAIR_VENGEANCE_RS_DDR5_PID_2,
-        0,
-        0,
-        0,
-        0,
-    },
-    6,
-    false
-};
-
-static const corsair_dram_device* device_list[] =
-{
-    &corsair_vengeance_pro_ddr4_device,
-    &corsair_dominator_platinum_ddr4_device,
-    &corsair_vengeance_pro_sl_ddr4_device,
-    &corsair_vengeance_rs_ddr4_device,
-    &corsair_dominator_platinum_ddr5_device,
-    &corsair_dominator_titanium_ddr5_device,
-    &corsair_vengeance_ddr5_device,
-    &corsair_vengeance_shugo_series_ddr5_device,
-    &corsair_vengeance_rs_ddr5_device,
-};
-
-const unsigned int CORSAIR_DRAM_NUM_DEVICES = (sizeof(device_list) / sizeof(device_list[ 0 ]));
-const corsair_dram_device** corsair_dram_device_list = device_list;

Controllers/CorsairDRAMController/CorsairDRAMDevices.h

@@ -1,68 +0,0 @@
-/*---------------------------------------------------------*\
-| CorsairDRAMDevices.h                                      |
-|                                                           |
-|   Device list for Corsair DRAM RGB controllers            |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                07 Apr 2026 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
-
-#pragma once
-
-#include <string>
-
-/*---------------------------------------------------------*\
-| Maximum number of PIDs for a given DRAM model             |
-\*---------------------------------------------------------*/
-#define CORSAIR_DRAM_MAX_PIDS                       6
-
-/*---------------------------------------------------------*\
-| Corsair DRAM vendor ID                                    |
-\*---------------------------------------------------------*/
-#define CORSAIR_DRAM_VID                            0x1B1C
-
-/*---------------------------------------------------------*\
-| Corsair DRAM product IDs                                  |
-\*---------------------------------------------------------*/
-#define CORSAIR_VENGEANCE_PRO_DDR4_PID_1            0x0100
-#define CORSAIR_VENGEANCE_PRO_DDR4_PID_2            0x0101
-#define CORSAIR_DOMINATOR_PLATINUM_DDR4_PID_1       0x0200
-#define CORSAIR_DOMINATOR_PLATINUM_DDR4_PID_2       0x0201
-#define CORSAIR_VENGEANCE_PRO_SL_DDR4_PID_1         0x0300
-#define CORSAIR_VENGEANCE_PRO_SL_DDR4_PID_2         0x0301
-#define CORSAIR_VENGEANCE_RS_DDR4_PID_1             0x0400
-#define CORSAIR_VENGEANCE_RS_DDR4_PID_2             0x0401
-#define CORSAIR_DOMINATOR_PLATINUM_DDR5_PID_1       0x0600
-#define CORSAIR_DOMINATOR_PLATINUM_DDR5_PID_2       0x0601
-#define CORSAIR_DOMINATOR_TITANIUM_DDR5_PID_1       0x0800
-#define CORSAIR_DOMINATOR_TITANIUM_DDR5_PID_2       0x0801
-#define CORSAIR_DOMINATOR_TITANIUM_DDR5_PID_3       0x0810
-#define CORSAIR_DOMINATOR_TITANIUM_DDR5_PID_4       0x0811
-#define CORSAIR_VENGEANCE_DDR5_PID_1                0x0700
-#define CORSAIR_VENGEANCE_DDR5_PID_2                0x0701
-#define CORSAIR_VENGEANCE_DDR5_PID_3                0x0900
-#define CORSAIR_VENGEANCE_DDR5_PID_4                0x0901
-#define CORSAIR_VENGEANCE_DDR5_PID_5                0x0910
-#define CORSAIR_VENGEANCE_DDR5_PID_6                0x0911
-#define CORSAIR_VENGEANCE_SHUGO_SERIES_DDR5_PID_1   0x0A00
-#define CORSAIR_VENGEANCE_SHUGO_SERIES_DDR5_PID_2   0x0A01
-#define CORSAIR_VENGEANCE_SHUGO_SERIES_DDR5_PID_3   0x0A10
-#define CORSAIR_VENGEANCE_SHUGO_SERIES_DDR5_PID_4   0x0A11
-#define CORSAIR_VENGEANCE_RS_DDR5_PID_1             0x0B00
-#define CORSAIR_VENGEANCE_RS_DDR5_PID_2             0x0B01
-
-typedef struct
-{
-    std::string                         name;
-    unsigned short                      pids[CORSAIR_DRAM_MAX_PIDS];
-    unsigned int                        led_count;
-    bool                                reverse;
-} corsair_dram_device;
-
-/*-----------------------------------------------------*\
-| These constant values are defined in RazerDevices.cpp |
-\*-----------------------------------------------------*/
-extern const unsigned int CORSAIR_DRAM_NUM_DEVICES;
-extern const corsair_dram_device** corsair_dram_device_list;

Controllers/CorsairDRAMController/RGBController_CorsairDRAM.cpp

@@ -1,324 +0,0 @@
-/*---------------------------------------------------------*\
-| RGBController_CorsairDRAM.cpp                             |
-|                                                           |
-|   RGBController for Corsair DRAM RGB controllers          |
-|                                                           |
-|   Adam Honse (CalcProgrammer1)                30 Jun 2019 |
-|   Erik Gilling (konkers)                      25 Sep 2020 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-or-later               |
-\*---------------------------------------------------------*/
-
-#include "RGBController_CorsairDRAM.h"
-
-/**------------------------------------------------------------------*\
-    @name Corsair DRAM
-    @category RAM
-    @type SMBus
-    @save :x:
-    @direct :white_check_mark:
-    @effects :x:
-    @detectors DetectCorsairDRAMControllers
-    @comment
-        The Corsair DRAM RGB controller chip can be found on several
-        Corsair memory sticks which have different LED counts. This can be controlled
-        by editing the Part Number in OpenRGB.json with values in the below table.
-
-        | Part Number | LED Count |
-        | :---------: | --------: |
-        | CMG         |  6        |
-        | CMH         | 10        |
-        | CMN         | 10        |
-        | CMT         | 12        |
-\*-------------------------------------------------------------------*/
-
-RGBController_CorsairDRAM::RGBController_CorsairDRAM(CorsairDRAMController* controller_ptr)
-{
-    controller                  = controller_ptr;
-
-    name                        = controller->GetDeviceName();
-    vendor                      = "Corsair";
-    type                        = DEVICE_TYPE_DRAM;
-    description                 = "Corsair DRAM RGB Device";
-    location                    = controller->GetDeviceLocation();
-    version                     = controller->GetDeviceVersion();
-
-    if(controller->GetProtocolVersion() >= 4)
-    {
-        mode Direct;
-        Direct.name             = "Direct";
-        Direct.value            = CORSAIR_DRAM_MODE_DIRECT;
-        Direct.flags            = MODE_FLAG_HAS_PER_LED_COLOR;
-        Direct.color_mode       = MODE_COLORS_PER_LED;
-        modes.push_back(Direct);
-    }
-
-    mode Custom;
-    Custom.name                 = "Custom";
-    Custom.value                = CORSAIR_DRAM_MODE_STATIC;
-    Custom.flags                = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_AUTOMATIC_SAVE;
-    Custom.color_mode           = MODE_COLORS_PER_LED;
-    modes.push_back(Custom);
-
-    mode ColorShift;
-    ColorShift.name             = "Color Shift";
-    ColorShift.value            = CORSAIR_DRAM_MODE_COLOR_SHIFT;
-    ColorShift.flags            = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
-    ColorShift.color_mode       = MODE_COLORS_MODE_SPECIFIC;
-    ColorShift.speed_min        = CORSAIR_DRAM_SPEED_SLOW;
-    ColorShift.speed_max        = CORSAIR_DRAM_SPEED_FAST;
-    ColorShift.speed            = CORSAIR_DRAM_SPEED_SLOW;
-    ColorShift.brightness_min   = CORSAIR_DRAM_BRIGHTNESS_MIN;
-    ColorShift.brightness_max   = CORSAIR_DRAM_BRIGHTNESS_MAX;
-    ColorShift.brightness       = CORSAIR_DRAM_BRIGHTNESS_DEFAULT;
-    ColorShift.colors_min       = 2;
-    ColorShift.colors_max       = 2;
-    ColorShift.colors.resize(2);
-    modes.push_back(ColorShift);
-
-    mode ColorPulse;
-    ColorPulse.name             = "Color Pulse";
-    ColorPulse.value            = CORSAIR_DRAM_MODE_COLOR_PULSE;
-    ColorPulse.flags            = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
-    ColorPulse.color_mode       = MODE_COLORS_MODE_SPECIFIC;
-    ColorPulse.speed_min        = CORSAIR_DRAM_SPEED_SLOW;
-    ColorPulse.speed_max        = CORSAIR_DRAM_SPEED_FAST;
-    ColorPulse.speed            = CORSAIR_DRAM_SPEED_SLOW;
-    ColorPulse.brightness_min   = CORSAIR_DRAM_BRIGHTNESS_MIN;
-    ColorPulse.brightness_max   = CORSAIR_DRAM_BRIGHTNESS_MAX;
-    ColorPulse.brightness       = CORSAIR_DRAM_BRIGHTNESS_DEFAULT;
-    ColorPulse.colors_min       = 2;
-    ColorPulse.colors_max       = 2;
-    ColorPulse.colors.resize(2);
-    modes.push_back(ColorPulse);
-
-    mode RainbowWave;
-    RainbowWave.name            = "Rainbow Wave";
-    RainbowWave.value           = CORSAIR_DRAM_MODE_RAINBOW_WAVE;
-    RainbowWave.flags           = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_DIRECTION_UD | MODE_FLAG_AUTOMATIC_SAVE;
-    RainbowWave.color_mode      = MODE_COLORS_NONE;
-    RainbowWave.speed_min       = CORSAIR_DRAM_SPEED_SLOW;
-    RainbowWave.speed_max       = CORSAIR_DRAM_SPEED_FAST;
-    RainbowWave.speed           = CORSAIR_DRAM_SPEED_SLOW;
-    RainbowWave.direction       = MODE_DIRECTION_DOWN;
-    modes.push_back(RainbowWave);
-
-    mode ColorWave;
-    ColorWave.name              = "Color Wave";
-    ColorWave.value             = CORSAIR_DRAM_MODE_COLOR_WAVE;
-    ColorWave.flags             = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_DIRECTION_UD | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
-    ColorWave.color_mode        = MODE_COLORS_MODE_SPECIFIC;
-    ColorWave.speed_min         = CORSAIR_DRAM_SPEED_SLOW;
-    ColorWave.speed_max         = CORSAIR_DRAM_SPEED_FAST;
-    ColorWave.speed             = CORSAIR_DRAM_SPEED_SLOW;
-    ColorWave.direction         = MODE_DIRECTION_DOWN;
-    ColorWave.brightness_min    = CORSAIR_DRAM_BRIGHTNESS_MIN;
-    ColorWave.brightness_max    = CORSAIR_DRAM_BRIGHTNESS_MAX;
-    ColorWave.brightness        = CORSAIR_DRAM_BRIGHTNESS_DEFAULT;
-    ColorWave.colors_min        = 2;
-    ColorWave.colors_max        = 2;
-    ColorWave.colors.resize(2);
-    modes.push_back(ColorWave);
-
-    mode Visor;
-    Visor.name                  = "Visor";
-    Visor.value                 = CORSAIR_DRAM_MODE_VISOR;
-    Visor.flags                 = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_HV | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
-    Visor.color_mode            = MODE_COLORS_MODE_SPECIFIC;
-    Visor.speed_min             = CORSAIR_DRAM_SPEED_SLOW;
-    Visor.speed_max             = CORSAIR_DRAM_SPEED_FAST;
-    Visor.speed                 = CORSAIR_DRAM_SPEED_SLOW;
-    Visor.direction             = MODE_DIRECTION_VERTICAL;
-    Visor.brightness_min        = CORSAIR_DRAM_BRIGHTNESS_MIN;
-    Visor.brightness_max        = CORSAIR_DRAM_BRIGHTNESS_MAX;
-    Visor.brightness            = CORSAIR_DRAM_BRIGHTNESS_DEFAULT;
-    Visor.colors_min            = 2;
-    Visor.colors_max            = 2;
-    Visor.colors.resize(2);
-    modes.push_back(Visor);
-
-    mode Rain;
-    Rain.name                   = "Rain";
-    Rain.value                  = CORSAIR_DRAM_MODE_RAIN;
-    Rain.flags                  = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_UD | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
-    Rain.color_mode             = MODE_COLORS_MODE_SPECIFIC;
-    Rain.speed_min              = CORSAIR_DRAM_SPEED_SLOW;
-    Rain.speed_max              = CORSAIR_DRAM_SPEED_FAST;
-    Rain.speed                  = CORSAIR_DRAM_SPEED_SLOW;
-    Rain.direction              = MODE_DIRECTION_DOWN;
-    Rain.brightness_min         = CORSAIR_DRAM_BRIGHTNESS_MIN;
-    Rain.brightness_max         = CORSAIR_DRAM_BRIGHTNESS_MAX;
-    Rain.brightness             = CORSAIR_DRAM_BRIGHTNESS_DEFAULT;
-    Rain.colors_min             = 2;
-    Rain.colors_max             = 2;
-    Rain.colors.resize(2);
-    modes.push_back(Rain);
-
-    mode Marquee;
-    Marquee.name                = "Marquee";
-    Marquee.value               = CORSAIR_DRAM_MODE_MARQUEE;
-    Marquee.flags               = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
-    Marquee.color_mode          = MODE_COLORS_MODE_SPECIFIC;
-    Marquee.speed_min           = CORSAIR_DRAM_SPEED_SLOW;
-    Marquee.speed_max           = CORSAIR_DRAM_SPEED_FAST;
-    Marquee.speed               = CORSAIR_DRAM_SPEED_SLOW;
-    Marquee.brightness_min      = CORSAIR_DRAM_BRIGHTNESS_MIN;
-    Marquee.brightness_max      = CORSAIR_DRAM_BRIGHTNESS_MAX;
-    Marquee.brightness          = CORSAIR_DRAM_BRIGHTNESS_DEFAULT;
-    Marquee.colors_min          = 1;
-    Marquee.colors_max          = 1;
-    Marquee.colors.resize(1);
-    modes.push_back(Marquee);
-
-    mode Rainbow;
-    Rainbow.name                = "Rainbow";
-    Rainbow.value               = CORSAIR_DRAM_MODE_RAINBOW;
-    Rainbow.flags               = MODE_FLAG_HAS_SPEED | MODE_FLAG_AUTOMATIC_SAVE;
-    Rainbow.color_mode          = MODE_COLORS_NONE;
-    Rainbow.speed_min           = CORSAIR_DRAM_SPEED_SLOW;
-    Rainbow.speed_max           = CORSAIR_DRAM_SPEED_FAST;
-    Rainbow.speed               = CORSAIR_DRAM_SPEED_SLOW;
-    modes.push_back(Rainbow);
-
-    mode Sequential;
-    Sequential.name             = "Sequential";
-    Sequential.value            = CORSAIR_DRAM_MODE_SEQUENTIAL;
-    Sequential.flags            = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_UD | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_AUTOMATIC_SAVE;
-    Sequential.color_mode       = MODE_COLORS_MODE_SPECIFIC;
-    Sequential.speed_min        = CORSAIR_DRAM_SPEED_SLOW;
-    Sequential.speed_max        = CORSAIR_DRAM_SPEED_FAST;
-    Sequential.speed            = CORSAIR_DRAM_SPEED_SLOW;
-    Sequential.direction        = MODE_DIRECTION_DOWN;
-    Sequential.brightness_min   = CORSAIR_DRAM_BRIGHTNESS_MIN;
-    Sequential.brightness_max   = CORSAIR_DRAM_BRIGHTNESS_MAX;
-    Sequential.brightness       = CORSAIR_DRAM_BRIGHTNESS_DEFAULT;
-    Sequential.colors_min       = 1;
-    Sequential.colors_max       = 1;
-    Sequential.colors.resize(1);
-    modes.push_back(Sequential);
-
-    SetupZones();
-}
-
-RGBController_CorsairDRAM::~RGBController_CorsairDRAM()
-{
-    Shutdown();
-
-    delete controller;
-}
-
-void RGBController_CorsairDRAM::SetupZones()
-{
-    /*-----------------------------------------------------*\
-    | Set up zone                                           |
-    \*-----------------------------------------------------*/
-    zone new_zone;
-    new_zone.name           = "Corsair DRAM";
-    new_zone.type           = ZONE_TYPE_LINEAR;
-    new_zone.leds_min       = controller->GetLEDCount();
-    new_zone.leds_max       = controller->GetLEDCount();
-    new_zone.leds_count     = controller->GetLEDCount();
-    zones.push_back(new_zone);
-
-    /*-----------------------------------------------------*\
-    | Set up LEDs                                           |
-    \*-----------------------------------------------------*/
-    for(std::size_t led_idx = 0; led_idx < zones[0].leds_count; led_idx++)
-    {
-        led new_led;
-        new_led.name        = "Corsair DRAM LED ";
-        new_led.name.append(std::to_string(led_idx));
-        leds.push_back(new_led);
-    }
-
-    SetupColors();
-}
-
-void RGBController_CorsairDRAM::DeviceUpdateLEDs()
-{
-    controller->SetColorsPerLED(colors.data());
-}
-
-void RGBController_CorsairDRAM::DeviceUpdateZoneLEDs(int /*zone*/)
-{
-    DeviceUpdateLEDs();
-}
-
-void RGBController_CorsairDRAM::DeviceUpdateSingleLED(int /*led*/)
-{
-    DeviceUpdateLEDs();
-}
-
-void RGBController_CorsairDRAM::DeviceUpdateMode()
-{
-    unsigned int  corsair_direction = 0;
-    bool          random            = (modes[active_mode].color_mode == MODE_COLORS_RANDOM);
-    unsigned char mode_colors[6];
-
-    switch(modes[active_mode].direction)
-    {
-        case MODE_DIRECTION_LEFT:
-            corsair_direction = CORSAIR_DRAM_DIRECTION_LEFT;
-            break;
-        case MODE_DIRECTION_RIGHT:
-            corsair_direction = CORSAIR_DRAM_DIRECTION_RIGHT;
-            break;
-        case MODE_DIRECTION_UP:
-            corsair_direction = CORSAIR_DRAM_DIRECTION_UP;
-            break;
-        case MODE_DIRECTION_DOWN:
-            corsair_direction = CORSAIR_DRAM_DIRECTION_DOWN;
-            break;
-        case MODE_DIRECTION_HORIZONTAL:
-            corsair_direction = CORSAIR_DRAM_DIRECTION_HORIZONTAL;
-            break;
-        case MODE_DIRECTION_VERTICAL:
-            corsair_direction = CORSAIR_DRAM_DIRECTION_VERTICAL;
-            break;
-    }
-
-    mode_colors[0] = 0;
-    mode_colors[1] = 0;
-    mode_colors[2] = 0;
-    mode_colors[3] = 0;
-    mode_colors[4] = 0;
-    mode_colors[5] = 0;
-
-    if(modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC)
-    {
-        mode_colors[0] = RGBGetRValue(modes[active_mode].colors[0]);
-        mode_colors[1] = RGBGetGValue(modes[active_mode].colors[0]);
-        mode_colors[2] = RGBGetBValue(modes[active_mode].colors[0]);
-
-        if(modes[active_mode].colors.size() == 2)
-        {
-            mode_colors[3] = RGBGetRValue(modes[active_mode].colors[1]);
-            mode_colors[4] = RGBGetGValue(modes[active_mode].colors[1]);
-            mode_colors[5] = RGBGetBValue(modes[active_mode].colors[1]);
-        }
-    }
-
-    if(modes[active_mode].name == "Direct")
-    {
-        controller->SetDirect(true);
-    }
-    else
-    {
-        controller->SetDirect(false);
-    }
-
-    controller->SetEffect(modes[active_mode].value,
-                          modes[active_mode].speed,
-                          corsair_direction,
-                          random,
-                          (unsigned char)modes[active_mode].brightness,
-                          mode_colors[0],
-                          mode_colors[1],
-                          mode_colors[2],
-                          mode_colors[3],
-                          mode_colors[4],
-                          mode_colors[5]);
-
-    std::this_thread::sleep_for(std::chrono::milliseconds(15));
-}

Controllers/CorsairDominatorPlatinumController/CorsairDominatorPlatinumController.cpp

@@ -0,0 +1,134 @@
+/*---------------------------------------------------------*\
+| CorsairDominatorPlatinumController.cpp                    |
+|                                                           |
+|   Driver for Corsair Dominator Platinum RAM               |
+|                                                           |
+|   Erik Gilling (konkers)                      25 Sep 2020 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-or-later               |
+\*---------------------------------------------------------*/
+
+#include <cstring>
+#include <chrono>
+#include "CorsairDominatorPlatinumController.h"
+
+using namespace std::chrono_literals;
+
+CorsairDominatorPlatinumController::CorsairDominatorPlatinumController(i2c_smbus_interface *bus, corsair_dev_id dev, unsigned int leds_count, std::string dev_name)
+{
+    this->bus           = bus;
+    this->dev           = dev;
+    this->leds_count    = leds_count;
+    this->name          = dev_name;
+
+    led_data[0] = 0xc;
+}
+
+CorsairDominatorPlatinumController::~CorsairDominatorPlatinumController()
+{
+}
+
+unsigned int CorsairDominatorPlatinumController::GetLEDCount()
+{
+    return leds_count;
+}
+
+std::string CorsairDominatorPlatinumController::GetDeviceLocation()
+{
+    std::string return_string(bus->device_name);
+    char addr[5];
+    snprintf(addr, 5, "0x%02X", dev);
+    return_string.append(", address ");
+    return_string.append(addr);
+    return("I2C: " + return_string);
+}
+
+std::string CorsairDominatorPlatinumController::GetDeviceName()
+{
+    return(name);
+}
+
+void CorsairDominatorPlatinumController::SetAllColors
+    (
+    unsigned char   red,
+    unsigned char   green,
+    unsigned char   blue
+    )
+{
+    for(unsigned int led = 0; led < leds_count; led++)
+    {
+        SetLEDColor(led, red, green, blue);
+    }
+}
+
+void CorsairDominatorPlatinumController::SetLEDColor
+    (
+    unsigned int    led,
+    unsigned char   red,
+    unsigned char   green,
+    unsigned char   blue
+    )
+{
+    if(led >= leds_count)
+    {
+        return;
+    }
+
+    unsigned int offset     = (led * 3) + 1;
+    led_data[offset]        = red;
+    led_data[offset + 1]    = green;
+    led_data[offset + 2]    = blue;
+}
+
+unsigned char CorsairDominatorPlatinumController::crc8
+    (
+    unsigned char   init,
+    unsigned char   poly,
+    unsigned char*  data,
+    unsigned char   len
+    )
+{
+    unsigned char crc = init;
+
+    for(unsigned int i = 0; i < len; i++)
+    {
+        unsigned char val = data[i];
+        for(unsigned char mask = 0x80; mask != 0; mask >>= 1)
+        {
+            unsigned char bit;
+            if ((val & mask) != 0)
+            {
+                bit = (crc & 0x80) ^ 0x80;
+            }
+            else
+            {
+                bit = crc & 0x80;
+            }
+
+            if (bit == 0)
+            {
+                crc <<= 1;
+            }
+            else
+            {
+                crc = (crc << 1) ^ poly;
+            }
+        }
+    }
+
+    return crc;
+}
+
+void CorsairDominatorPlatinumController::ApplyColors()
+{
+    unsigned char data[sizeof(led_data)];
+    memcpy(data, led_data, sizeof(led_data));
+    unsigned char crc = crc8(0x0, 0x7, data, sizeof(data) - 1);
+    data[sizeof(data) - 1] = crc;
+
+    bus->i2c_smbus_write_block_data(dev, 0x31, 0x20, data);
+    std::this_thread::sleep_for(800us);
+    bus->i2c_smbus_write_block_data(dev, 0x32, sizeof(data) - 0x20, data + 0x20);
+    std::this_thread::sleep_for(200us);
+}

Controllers/CorsairDominatorPlatinumController/CorsairDominatorPlatinumController.h

@@ -0,0 +1,44 @@
+/*---------------------------------------------------------*\
+| CorsairDominatorPlatinumController.h                      |
+|                                                           |
+|   Driver for Corsair Dominator Platinum RAM               |
+|                                                           |
+|   Erik Gilling (konkers)                      25 Sep 2020 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-or-later               |
+\*---------------------------------------------------------*/
+
+#pragma once
+
+#include <string>
+#include "i2c_smbus.h"
+
+#define CORSAIR_DOMINATOR_PLATINUM_DATA_SIZE 38
+
+typedef unsigned char corsair_dev_id;
+
+class CorsairDominatorPlatinumController
+{
+public:
+    CorsairDominatorPlatinumController(i2c_smbus_interface *bus, corsair_dev_id dev, unsigned int leds_count, std::string dev_name);
+    ~CorsairDominatorPlatinumController();
+
+    std::string GetDeviceLocation();
+    std::string GetDeviceName();
+    unsigned int GetLEDCount();
+
+    void SetAllColors(unsigned char red, unsigned char green, unsigned char blue);
+    void SetLEDColor(unsigned int led, unsigned char red, unsigned char green, unsigned char blue);
+    void ApplyColors();
+    bool WaitReady();
+
+private:
+    unsigned char           led_data[CORSAIR_DOMINATOR_PLATINUM_DATA_SIZE];
+    i2c_smbus_interface*    bus;
+    corsair_dev_id          dev;
+    unsigned int            leds_count;
+    std::string             name;
+
+    static unsigned char crc8(unsigned char init, unsigned char poly, unsigned char *data, unsigned char len);
+};

Controllers/CorsairDominatorPlatinumController/CorsairDominatorPlatinumControllerDetect.cpp

@@ -0,0 +1,168 @@
+/*---------------------------------------------------------*\
+| CorsairDominatorPlatinumControllerDetect.cpp              |
+|                                                           |
+|   Detector for Corsair Dominator Platinum RAM             |
+|                                                           |
+|   Erik Gilling (konkers)                      25 Sep 2020 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-or-later               |
+\*---------------------------------------------------------*/
+
+#include <vector>
+#include "CorsairDominatorPlatinumController.h"
+#include "DetectionManager.h"
+#include "i2c_smbus.h"
+#include "LogManager.h"
+#include "pci_ids.h"
+#include "ResourceManager.h"
+#include "RGBController_CorsairDominatorPlatinum.h"
+#include "SettingsManager.h"
+
+using namespace std::chrono_literals;
+
+json corsair_dominator_models =
+{
+    {
+        "CMT",
+        {
+            {"name",  "Corsair Dominator Platinum"},
+            {"leds",  12}
+        }
+    },
+    {
+        "CMH",
+        {
+            {"name",  "Corsair Vengeance Pro SL"},
+            {"leds",  10}
+        }
+    },
+    {
+        "CMN",
+        {
+            {"name",  "Corsair Vengeance RGB RT"},
+            {"leds",  10}
+        }
+    },
+    {
+        "CMG",
+        {
+            {"name",  "Corsair Vengeance RGB RS"},
+            {"leds",  6}
+        }
+    },
+    {
+        "CMP",
+        {
+            {"name",  "Corsair Dominator Titanium"},
+            {"leds",  11}
+        }
+    }
+};
+
+#define CORSAIR_DOMINATOR_PLATINUM_NAME "Corsair Dominator Platinum"
+
+bool TestForCorsairDominatorPlatinumController(i2c_smbus_interface *bus, unsigned char address)
+{
+    int res = bus->i2c_smbus_write_quick(address, I2C_SMBUS_WRITE);
+
+    LOG_DEBUG("[%s] Trying address %02X", CORSAIR_DOMINATOR_PLATINUM_NAME, address);
+
+    if(res < 0)
+    {
+        LOG_DEBUG("[%s] Failed: res was %04X", CORSAIR_DOMINATOR_PLATINUM_NAME, res);
+        return false;
+    }
+
+    res = bus->i2c_smbus_read_byte_data(address, 0x43);
+
+    if(!(res == 0x1A || res == 0x1B))
+    {
+        LOG_DEBUG("[%s] Failed: expected 0x1a or 0x1b, got %04X", CORSAIR_DOMINATOR_PLATINUM_NAME, res);
+        return false;
+    }
+
+    res = bus->i2c_smbus_read_byte_data(address, 0x44);
+
+    if(res != 0x04)
+    {
+        LOG_DEBUG("[%s] Failed: expected 0x04, got %04X", CORSAIR_DOMINATOR_PLATINUM_NAME, res);
+        return false;
+    }
+
+    return true;
+}
+
+DetectedControllers DetectCorsairDominatorPlatinumControllers(std::vector<i2c_smbus_interface *> &busses)
+{
+    DetectedControllers detected_controllers;
+    SettingsManager*    settings_manager            = ResourceManager::get()->GetSettingsManager();
+    json                corsair_dominator_settings  = settings_manager->GetSettings("CorsairDominatorSettings");
+
+    if(!corsair_dominator_settings.contains("model"))
+    {
+        // Set default value
+        corsair_dominator_settings["model"] = "CMT";
+        settings_manager->SetSettings("CorsairDominatorSettings", corsair_dominator_settings);
+        settings_manager->SaveSettings();
+    }
+
+    std::string model = corsair_dominator_settings["model"];
+
+    for(unsigned int bus = 0; bus < busses.size(); bus++)
+    {
+        IF_DRAM_SMBUS(busses[bus]->pci_vendor, busses[bus]->pci_device)
+        {
+            LOG_DEBUG("[%s] Testing bus %d", CORSAIR_DOMINATOR_PLATINUM_NAME, bus);
+
+            std::vector<unsigned char> addresses;
+
+            for(unsigned char addr = 0x58; addr <= 0x5F; addr++)
+            {
+                addresses.push_back(addr);
+            }
+
+            for(unsigned char addr = 0x18; addr <= 0x1F; addr++)
+            {
+                addresses.push_back(addr);
+            }
+
+            for(unsigned char addr : addresses)
+            {
+                if(TestForCorsairDominatorPlatinumController(busses[bus], addr))
+                {
+                    unsigned int leds;
+                    std::string name;
+
+                    if(corsair_dominator_models.contains(model))
+                    {
+                        leds = corsair_dominator_models[model]["leds"];
+                        name = corsair_dominator_models[model]["name"];
+                    }
+                    else
+                    {
+                        leds = corsair_dominator_models["CMT"]["leds"];
+                        name = corsair_dominator_models["CMT"]["name"];
+                    }
+
+                    LOG_DEBUG("[%s] Model: %s, Leds: %d", CORSAIR_DOMINATOR_PLATINUM_NAME, name.c_str(), leds);
+
+                    CorsairDominatorPlatinumController*     controller     = new CorsairDominatorPlatinumController(busses[bus], addr, leds, name);
+                    RGBController_CorsairDominatorPlatinum* rgb_controller = new RGBController_CorsairDominatorPlatinum(controller);
+
+                    detected_controllers.push_back(rgb_controller);
+                }
+
+                std::this_thread::sleep_for(10ms);
+            }
+        }
+        else
+        {
+            LOG_DEBUG("[%s] Bus %d is not a DRAM bus", CORSAIR_DOMINATOR_PLATINUM_NAME, bus);
+        }
+    }
+
+    return(detected_controllers);
+}
+
+REGISTER_I2C_DETECTOR(CORSAIR_DOMINATOR_PLATINUM_NAME, DetectCorsairDominatorPlatinumControllers);

Controllers/CorsairDominatorPlatinumController/RGBController_CorsairDominatorPlatinum.cpp

@@ -0,0 +1,126 @@
+/*---------------------------------------------------------*\
+| RGBController_CorsairDominatorPlatinum.cpp                |
+|                                                           |
+|   RGBController for Corsair Dominator Platinum RAM        |
+|                                                           |
+|   Erik Gilling (konkers)                      25 Sep 2020 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-or-later               |
+\*---------------------------------------------------------*/
+
+#include "RGBController_CorsairDominatorPlatinum.h"
+
+/**------------------------------------------------------------------*\
+    @name Corsair Dominator Platinum
+    @category RAM
+    @type SMBus
+    @save :x:
+    @direct :white_check_mark:
+    @effects :x:
+    @detectors DetectCorsairDominatorPlatinumControllers
+    @comment
+        The Corsair Dominator controller chip can be found on several
+        Corsair memory sticks which have different LED counts. This can be controlled
+        by editing the Part Number in OpenRGB.json with values in the below table.
+
+        | Part Number | LED Count |
+        | :---------: | --------: |
+        | CMG         |  6        |
+        | CMH         | 10        |
+        | CMN         | 10        |
+        | CMT         | 12        |
+\*-------------------------------------------------------------------*/
+
+RGBController_CorsairDominatorPlatinum::RGBController_CorsairDominatorPlatinum(CorsairDominatorPlatinumController* controller_ptr)
+{
+    controller  = controller_ptr;
+
+    name        = controller->GetDeviceName();
+    vendor      = "Corsair";
+    type        = DEVICE_TYPE_DRAM;
+    description = "Corsair RAM RGB Device";
+    location    = controller->GetDeviceLocation();
+
+    mode Direct;
+    Direct.name       = "Direct";
+    Direct.value      = 0;
+    Direct.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    Direct.speed_min  = 0;
+    Direct.speed_max  = 0;
+    Direct.speed      = 0;
+    Direct.color_mode = MODE_COLORS_PER_LED;
+    modes.push_back(Direct);
+
+    SetupZones();
+
+    active_mode = 0;
+}
+
+RGBController_CorsairDominatorPlatinum::~RGBController_CorsairDominatorPlatinum()
+{
+    delete controller;
+}
+
+void RGBController_CorsairDominatorPlatinum::SetupZones()
+{
+    /*---------------------------------------------------------*\
+    | Set up zone                                               |
+    \*---------------------------------------------------------*/
+    zone new_zone;
+    new_zone.name       = "Corsair RAM Zone";
+    new_zone.type       = ZONE_TYPE_LINEAR;
+    new_zone.leds_min   = controller->GetLEDCount();
+    new_zone.leds_max   = controller->GetLEDCount();
+    new_zone.leds_count = controller->GetLEDCount();
+    zones.push_back(new_zone);
+
+    /*---------------------------------------------------------*\
+    | Set up LEDs                                               |
+    \*---------------------------------------------------------*/
+    for(std::size_t led_idx = 0; led_idx < zones[0].leds_count; led_idx++)
+    {
+        led new_led;
+        new_led.name   = "Corsair RAM LED ";
+        new_led.name.append(std::to_string(led_idx));
+        leds.push_back(new_led);
+    }
+
+    SetupColors();
+}
+
+void RGBController_CorsairDominatorPlatinum::DeviceUpdateLEDs()
+{
+    for(unsigned int led = 0; led < (unsigned int)colors.size(); led++)
+    {
+        RGBColor color    = colors[led];
+        unsigned char red = RGBGetRValue(color);
+        unsigned char grn = RGBGetGValue(color);
+        unsigned char blu = RGBGetBValue(color);
+
+        controller->SetLEDColor(led, red, grn, blu);
+    }
+
+    controller->ApplyColors();
+}
+
+void RGBController_CorsairDominatorPlatinum::DeviceUpdateZoneLEDs(int /*zone*/)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_CorsairDominatorPlatinum::DeviceUpdateSingleLED(int led)
+{
+    RGBColor color    = colors[led];
+    unsigned char red = RGBGetRValue(color);
+    unsigned char grn = RGBGetGValue(color);
+    unsigned char blu = RGBGetBValue(color);
+
+    controller->SetLEDColor(led, red, grn, blu);
+    controller->ApplyColors();
+}
+
+void RGBController_CorsairDominatorPlatinum::DeviceUpdateMode()
+{
+
+}

Controllers/CorsairDominatorPlatinumController/RGBController_CorsairDominatorPlatinum.h

@@ -1,9 +1,8 @@
 /*---------------------------------------------------------*\
-| RGBController_CorsairDRAM.h                               |
+| RGBController_CorsairDominatorPlatinum.h                  |
 |                                                           |
-|   RGBController for Corsair DRAM RGB controllers          |
+|   RGBController for Corsair Dominator Platinum RAM        |
 |                                                           |
-|   Adam Honse (CalcProgrammer1)                30 Jun 2019 |
 |   Erik Gilling (konkers)                      25 Sep 2020 |
 |                                                           |
 |   This file is part of the OpenRGB project                |
@@ -13,13 +12,13 @@
 #pragma once
 
 #include "RGBController.h"
-#include "CorsairDRAMController.h"
+#include "CorsairDominatorPlatinumController.h"
 
-class RGBController_CorsairDRAM : public RGBController
+class RGBController_CorsairDominatorPlatinum : public RGBController
 {
 public:
-    RGBController_CorsairDRAM(CorsairDRAMController* controller_ptr);
-    ~RGBController_CorsairDRAM();
+    RGBController_CorsairDominatorPlatinum(CorsairDominatorPlatinumController* controller_ptr);
+    ~RGBController_CorsairDominatorPlatinum();
 
     void SetupZones();
 
@@ -30,5 +29,5 @@ public:
     void DeviceUpdateMode();
 
 private:
-    CorsairDRAMController* controller;
+    CorsairDominatorPlatinumController* controller;
 };

Controllers/CorsairHydro2Controller/RGBController_CorsairHydro2.cpp

@@ -44,8 +44,6 @@ RGBController_CorsairHydro2::RGBController_CorsairHydro2(CorsairHydro2Controller
 
 RGBController_CorsairHydro2::~RGBController_CorsairHydro2()
 {
-    Shutdown();
-
     delete controller;
 }
 

Controllers/CorsairHydroController/RGBController_CorsairHydro.cpp

@@ -84,8 +84,6 @@ RGBController_CorsairHydro::RGBController_CorsairHydro(CorsairHydroController* c
 
 RGBController_CorsairHydro::~RGBController_CorsairHydro()
 {
-    Shutdown();
-
     delete controller;
 }
 

Controllers/CorsairHydroPlatinumController/RGBController_CorsairHydroPlatinum.cpp

@@ -51,101 +51,55 @@ RGBController_CorsairHydroPlatinum::RGBController_CorsairHydroPlatinum(CorsairHy
     Direct.color_mode = MODE_COLORS_PER_LED;
     modes.push_back(Direct);
 
+    Init_Controller();
     SetupZones();
 }
 
 RGBController_CorsairHydroPlatinum::~RGBController_CorsairHydroPlatinum()
 {
-    Shutdown();
-
     delete controller;
 }
 
+void RGBController_CorsairHydroPlatinum::Init_Controller()
+{
+    zone cpu_block_zone;
+    cpu_block_zone.name               = "CPU Block";
+    cpu_block_zone.type               = ZONE_TYPE_MATRIX;
+    cpu_block_zone.leds_min           = 16;
+    cpu_block_zone.leds_max           = 16;
+    cpu_block_zone.leds_count         = 16;
+    cpu_block_zone.matrix_map.Set(5, 5, (unsigned int *)&matrix_map);
+    zones.push_back(cpu_block_zone);
+
+    /*-----------------------------------------------------*\
+    | If the device is RGB fan-capable, set up fan zones.   |
+    \*-----------------------------------------------------*/
+    if(controller->HaveRgbFan())
+    {
+        zone fans_zone;
+        fans_zone.name       = "Fans";
+        fans_zone.type       = ZONE_TYPE_LINEAR;
+        fans_zone.leds_min   = 0;
+        fans_zone.leds_max   = 32;
+        fans_zone.leds_count = 0;
+        zones.push_back(fans_zone);
+    }
+}
+
 void RGBController_CorsairHydroPlatinum::SetupZones()
 {
-    /*-----------------------------------------------------*\
-    | Only set LED count on the first run                   |
-    \*-----------------------------------------------------*/
-    bool first_run = false;
-
-    if(zones.size() == 0)
-    {
-        first_run = true;
-    }
-
-    /*-----------------------------------------------------*\
-    | Clear any existing color/LED configuration            |
-    \*-----------------------------------------------------*/
+    /*-------------------------------------------------*\
+    | Clear any existing color/LED configuration        |
+    \*-------------------------------------------------*/
     leds.clear();
     colors.clear();
-    if(controller->HaveRgbFan())
-    {
-        zones.resize(2);
-    }
-    else
-    {
-        zones.resize(1);
-    }
 
-    /*-----------------------------------------------------*\
-    | Set up zones                                          |
-    \*-----------------------------------------------------*/
-    zones[0].name                           = "CPU Block";
-    zones[0].type                           = ZONE_TYPE_MATRIX;
-    zones[0].leds_min                       = 16;
-    zones[0].leds_max                       = 16;
-    zones[0].leds_count                     = 16;
-    zones[0].matrix_map.Set(5, 5, (unsigned int *)&matrix_map);
-
-    /*-----------------------------------------------------*\
-    | If the device is RGB fan-capable, set up fan zone.    |
-    \*-----------------------------------------------------*/
-    if(controller->HaveRgbFan())
-    {
-        zones[1].leds_min                   = 0;
-        zones[1].leds_max                   = 32;
-
-        if(first_run)
-        {
-            zones[1].flags                  = ZONE_FLAG_MANUALLY_CONFIGURABLE_SIZE
-                                            | ZONE_FLAG_MANUALLY_CONFIGURABLE_NAME
-                                            | ZONE_FLAG_MANUALLY_CONFIGURABLE_TYPE
-                                            | ZONE_FLAG_MANUALLY_CONFIGURABLE_MATRIX_MAP
-                                            | ZONE_FLAG_MANUALLY_CONFIGURABLE_SEGMENTS;
-        }
-
-        if(!(zones[1].flags & ZONE_FLAG_MANUALLY_CONFIGURED_NAME))
-        {
-            zones[1].name                   = "Corsair Fan Header";
-        }
-
-        if(!(zones[1].flags & ZONE_FLAG_MANUALLY_CONFIGURED_SIZE))
-        {
-            zones[1].leds_count             = 0;
-        }
-
-        if(!(zones[1].flags & ZONE_FLAG_MANUALLY_CONFIGURED_TYPE))
-        {
-            zones[1].type                   = ZONE_TYPE_LINEAR;
-        }
-
-        if(!(zones[1].flags & ZONE_FLAG_MANUALLY_CONFIGURED_MATRIX_MAP))
-        {
-            zones[1].matrix_map.width       = 0;
-            zones[1].matrix_map.height      = 0;
-            zones[1].matrix_map.map.resize(0);
-        }
-    }
-
-    /*-----------------------------------------------------*\
-    | Set up LEDs                                           |
-    \*-----------------------------------------------------*/
     for(unsigned int zone_idx = 0; zone_idx < zones.size(); zone_idx++)
     {
         for(unsigned int led_idx = 0; led_idx < zones[zone_idx].leds_count; led_idx++)
         {
             led new_led;
-            new_led.name = zones[zone_idx].name + ", LED " + std::to_string(led_idx);;
+            new_led.name = zones[zone_idx].name + " " + std::to_string(led_idx);;
             leds.push_back(new_led);
         }
     }
@@ -153,10 +107,17 @@ void RGBController_CorsairHydroPlatinum::SetupZones()
     SetupColors();
 }
 
-void RGBController_CorsairHydroPlatinum::DeviceConfigureZone(int zone_idx)
+void RGBController_CorsairHydroPlatinum::DeviceResizeZone(int zone, int new_size)
 {
-    if((size_t)zone_idx < zones.size())
+    if((size_t) zone >= zones.size())
     {
+        return;
+    }
+
+    if(((unsigned int)new_size >= zones[zone].leds_min) && ((unsigned int)new_size <= zones[zone].leds_max))
+    {
+        zones[zone].leds_count = new_size;
+
         SetupZones();
     }
 }

Controllers/CorsairHydroPlatinumController/RGBController_CorsairHydroPlatinum.h

@@ -23,7 +23,7 @@ public:
 
     void        SetupZones();
 
-    void        DeviceConfigureZone(int zone_idx);
+    void        DeviceResizeZone(int zone, int new_size);
 
     void        DeviceUpdateLEDs();
     void        DeviceUpdateZoneLEDs(int zone);