Address most of original review comments

Cleaned up, squashed, and rebased by Adam Honse <[email protected]>

Controllers/AirgooLustrousCommanderController/AirgooLustrousCommanderController.cpp

@@ -0,0 +1,117 @@
+/*---------------------------------------------------------*\
+| AirgooLustrousCommanderController.cpp                     |
+|                                                           |
+|   Driver for Airgoo Lustrous Commander                    |
+|                                                           |
+|   Zacahry Guinn                               07 Feb 2022 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
+
+#include <cstring>
+#include "AirgooLustrousCommanderController.h"
+
+AirgooLustrousCommanderController::AirgooLustrousCommanderController(hid_device* dev_handle, const char* path)
+{
+    dev                     = dev_handle;
+    location                = path;
+
+    /*-----------------------------------------------------*\
+    | Initialize controller                                 |
+    \*-----------------------------------------------------*/
+    InitController();
+}
+
+AirgooLustrousCommanderController::~AirgooLustrousCommanderController()
+{
+    /*-----------------------------------------------------*\
+    | Close HID device                                      |
+    \*-----------------------------------------------------*/
+    hid_close(dev);
+}
+
+void AirgooLustrousCommanderController::InitController()
+{
+    unsigned char   usb_buf[AIRGOO_LUSTROUS_COMMANDER_PACKET_SIZE];
+
+    /*-----------------------------------------------------*\
+    | Send initialization packet                            |
+    \*-----------------------------------------------------*/
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    usb_buf[0x00]       = 0x00;
+    usb_buf[0x01]       = 0x03;
+    usb_buf[0x02]       = 0x55;
+    usb_buf[0x03]       = 0xAA;
+
+    hid_write(dev, usb_buf, AIRGOO_LUSTROUS_COMMANDER_PACKET_SIZE);
+
+    //expecting the device to return AA 55 01
+    hid_read(dev, usb_buf, AIRGOO_LUSTROUS_COMMANDER_PACKET_SIZE);
+
+    usb_buf[0x00]       = 0x00;
+    usb_buf[0x01]       = 0x03;
+    usb_buf[0x02]       = 0x55;
+    usb_buf[0x03]       = 0xAA;
+    usb_buf[0x04]       = 0x01;
+
+    //looks like the client software awknolleges? it returns a 0x01 in pos 4 of the buffer array
+    hid_write(dev, usb_buf, AIRGOO_LUSTROUS_COMMANDER_PACKET_SIZE);
+
+    //device will send aa 55 00 back and it seems that we should be ready to send commands at this point
+}
+
+std::string AirgooLustrousCommanderController::GetLocationString()
+{
+    return("HID: " + location);
+}
+
+void AirgooLustrousCommanderController::UpdateDevice
+    (
+    unsigned char   mode,
+    unsigned char   red,
+    unsigned char   grn,
+    unsigned char   blu,
+    unsigned char   speed
+    )
+{
+    unsigned char usb_buf[65];
+
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    /*-----------------------------------------------------*\
+    | Set up message packet with leading 00                 |
+    \*-----------------------------------------------------*/
+    usb_buf[0x00]       = 0x00;
+
+    switch(mode)
+    {
+        case 1: //static
+            usb_buf[0x01]       = 0x09; //number of bytes in package
+            usb_buf[0x02]       = 0xFF;
+            usb_buf[0x03]       = 0x00;
+            usb_buf[0x04]       = 0xF0;
+            usb_buf[0x05]       = red; //Red
+            usb_buf[0x06]       = grn; //Green
+            usb_buf[0x07]       = blu; //Blue
+            usb_buf[0x08]       = 0x05;
+            usb_buf[0x09]       = 0x05;
+            usb_buf[0x0A]       = 0xFE;
+        break;
+        case 2://rainbow
+            usb_buf[0x01]       = 0x05; //number of bytes in package
+            usb_buf[0x02]       = 0xFF;
+            usb_buf[0x03]       = 0x06;
+            usb_buf[0x04]       = 0x01; //type like wheel or rolling
+            usb_buf[0x05]       = speed; //speed
+            usb_buf[0x06]       = 0xFE;
+    }
+
+    hid_write(dev, usb_buf, AIRGOO_LUSTROUS_COMMANDER_PACKET_SIZE);
+}
+
+void AirgooLustrousCommanderController::SetFanMode()
+{
+
+}

Controllers/AirgooLustrousCommanderController/AirgooLustrousCommanderController.h

@@ -0,0 +1,45 @@
+/*---------------------------------------------------------*\
+| AirgooLustrousCommanderController.h                       |
+|                                                           |
+|   Driver for Airgoo Lustrous Commander                    |
+|                                                           |
+|   Zacahry Guinn                               07 Feb 2022 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
+
+#pragma once
+
+#include <vector>
+#include <hidapi.h>
+#include "RGBController.h"
+
+#define AIRGOO_LUSTROUS_COMMANDER_PACKET_SIZE       65
+#define AIRGOO_LUSTROUS_COMMANDER_NUM_RGB_CHANNELS  2
+#define AIRGOO_LUSTROUS_COMMANDER_NUM_FAN_CHANNELS  4
+
+class AirgooLustrousCommanderController
+{
+public:
+    AirgooLustrousCommanderController(hid_device* dev_handle, const char* path);
+    ~AirgooLustrousCommanderController();
+
+    std::string GetLocationString();
+
+    void        SetFanMode();
+    void        UpdateDevice
+                (
+                unsigned char   mode,
+                unsigned char   red,
+                unsigned char   grn,
+                unsigned char   blu,
+                unsigned char   speed
+                );
+
+private:
+    hid_device*             dev;
+    std::string             location;
+
+    void        InitController();
+};

Controllers/AirgooLustrousCommanderController/AirgooLustrousCommanderControllerDetect.cpp

@@ -0,0 +1,51 @@
+/*---------------------------------------------------------*\
+| AirgooLustrousCommanderControllerDetect.cpp               |
+|                                                           |
+|   Detector for Airgoo Lustrous Commander                  |
+|                                                           |
+|   Zacahry Guinn                               07 Feb 2022 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
+
+#include <vector>
+#include <hidapi.h>
+#include "Detector.h"
+#include "AirgooLustrousCommanderController.h"
+#include "RGBController.h"
+#include "RGBController_AirgooLustrousCommander.h"
+
+/*---------------------------------------------------------*\
+| Airgoo vendor ID                                          |
+\*---------------------------------------------------------*/
+#define AIRGOO_VID                                  0x1A86
+
+/*---------------------------------------------------------*\
+| Lustrous Commander product IDs                            |
+\*---------------------------------------------------------*/
+#define AIRGOO_LUSTROUS_COMMANDER_PID               0xE6E0
+
+/******************************************************************************************\
+*                                                                                          *
+*   DetectAirgooCommanderControllers                                                       *
+*                                                                                          *
+*       Tests the USB address to see if a Airgoo RGB controller exists there.              *
+*                                                                                          *
+\******************************************************************************************/
+
+void DetectAirgooLustrousCommanderHIDControllers(hid_device_info* info, const std::string& name)
+{
+    hid_device* dev = hid_open_path(info->path);
+
+    if(dev)
+    {
+        AirgooLustrousCommanderController*     controller     = new AirgooLustrousCommanderController(dev, info->path);
+        RGBController_AirgooLustrousCommander* rgb_controller = new RGBController_AirgooLustrousCommander(controller);
+        rgb_controller->name                                  = name;
+
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
+    }
+}
+
+REGISTER_HID_DETECTOR("Airgoo Lustrous Commander",  DetectAirgooLustrousCommanderHIDControllers, AIRGOO_VID, AIRGOO_LUSTROUS_COMMANDER_PID);

Controllers/AirgooLustrousCommanderController/RGBController_AirgooLustrousCommander.cpp

@@ -0,0 +1,192 @@
+/*---------------------------------------------------------*\
+| RGBController_AirgooLustrousCommander.cpp                 |
+|                                                           |
+|   RGBController for Airgoo Lustrous Commander             |
+|                                                           |
+|   Zacahry Guinn                               07 Feb 2022 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
+
+#include "RGBController_AirgooLustrousCommander.h"
+
+RGBController_AirgooLustrousCommander::RGBController_AirgooLustrousCommander(AirgooLustrousCommanderController* controller_ptr)
+{
+    controller  = controller_ptr;
+
+    vendor      = "Airgoo";
+    description = "Lustrous Commander";
+    type        = DEVICE_TYPE_LEDSTRIP;
+    location    = controller->GetLocationString();
+
+    mode Static;
+    Static.name       = "Static";
+    Static.value      = 1;
+    Static.flags      = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    Static.colors_min = 1;
+    Static.colors_max = 1;
+    Static.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Static.colors.resize(1);
+    modes.push_back(Static);
+
+    // mode Shift;
+    // Shift.name       = "Shift";
+    // Shift.value      = 1;
+    // Shift.flags                = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED;
+    // Shift.color_mode           = MODE_COLORS_MODE_SPECIFIC;
+    // Shift.colors_min           = 1;
+    // Shift.colors_max           = 16;
+    // Shift.colors.resize(Shift.colors_max);
+    // Shift.speed_min            = 0;
+    // Shift.speed_max            = 255;
+    // Shift.speed                = 05;
+    // Shift.brightness_min       = 100;
+    // Shift.brightness_max       = 0;
+    // Shift.brightness           = 0;
+    // modes.push_back(Shift);
+
+    // mode Pulse;
+    // Pulse.name       = "Pulse";
+    // Pulse.value      = 2;
+    // Pulse.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    // Pulse.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    // modes.push_back(Pulse);
+
+    // mode Gradual;
+    // Gradual.name       = "Gradual";
+    // Gradual.value      = 3;
+    // Gradual.flags      = MODE_FLAstd::cout << "@@@@@@@Init Contoller@@@@@@@" << std::endl;ORS_MODE_SPECIFIC;
+    // modes.push_back(Gradual);
+
+    // mode StarLight;
+    // StarLight.name       = "StarLight";
+    // StarLight.value      = 4;
+    // StarLight.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    // StarLight.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    // modes.push_back(StarLight);
+
+    mode Rainbow;
+    Rainbow.name       = "Rainbow";
+    Rainbow.value      = 2;
+    Rainbow.flags     = MODE_FLAG_HAS_SPEED;
+    Rainbow.speed_min            = 1;
+    Rainbow.speed_max            = 255;
+    Rainbow.speed                = 50;
+    Rainbow.color_mode = MODE_COLORS_NONE;
+    modes.push_back(Rainbow);
+
+    // mode ColorWave;
+    // ColorWave.name       = "Color Wave";
+    // ColorWave.value      = 6;
+    // ColorWave.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    // ColorWave.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    // modes.push_back(ColorWave);
+
+    // mode ColorPulse;
+    // ColorPulse.name       = "Color Pulse";
+    // ColorPulse.value      = 7;
+    // ColorPulse.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    // ColorPulse.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    // modes.push_back(ColorPulse);
+
+    // mode ColorMeteor;
+    // ColorMeteor.name       = "Color Meteor";
+    // ColorMeteor.value      = 8;
+    // ColorMeteor.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    // ColorMeteor.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    // modes.push_back(ColorMeteor);
+
+    SetupZones();
+}
+
+RGBController_AirgooLustrousCommander::~RGBController_AirgooLustrousCommander()
+{
+    delete controller;
+}
+
+void RGBController_AirgooLustrousCommander::SetupZones()
+{
+    std::atomic<bool> first_run;
+    first_run = 0;
+
+    if(zones.size() == 0)
+    {
+        first_run = 1;
+    }
+
+    zones.resize(3);
+
+    for(unsigned int i = 1; i < (AIRGOO_LUSTROUS_COMMANDER_NUM_RGB_CHANNELS + 1); i++)
+    {
+        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[i].leds_count     = 0;
+        }
+    }
+
+    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);
+
+            leds.push_back(new_led);
+        }
+    }
+
+    SetupColors();
+}
+
+void RGBController_AirgooLustrousCommander::ResizeZone(int zone, int new_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();
+    }
+}
+
+void RGBController_AirgooLustrousCommander::DeviceUpdateLEDs()
+{
+    DeviceUpdateMode();
+}
+
+void RGBController_AirgooLustrousCommander::UpdateZoneLEDs(int /*zone*/)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_AirgooLustrousCommander::UpdateSingleLED(int /*led*/)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_AirgooLustrousCommander::DeviceUpdateMode()
+{
+    unsigned char red = 0;
+    unsigned char grn = 0;
+    unsigned char blu = 0;
+    if(modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC)
+    {
+        red = RGBGetRValue(modes[active_mode].colors[0]);
+        grn = RGBGetGValue(modes[active_mode].colors[0]);
+        blu = RGBGetBValue(modes[active_mode].colors[0]);
+    }
+    controller->UpdateDevice(modes[active_mode].value, red, grn, blu, modes[active_mode].speed);
+}

Controllers/AirgooLustrousCommanderController/RGBController_AirgooLustrousCommander.h

@@ -0,0 +1,35 @@
+/*---------------------------------------------------------*\
+| RGBController_AirgooLustrousCommander.cpp                 |
+|                                                           |
+|   RGBController for Airgoo Lustrous Commander             |
+|                                                           |
+|   Zacahry Guinn                               07 Feb 2022 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
+
+#pragma once
+
+#include "RGBController.h"
+#include "AirgooLustrousCommanderController.h"
+
+class RGBController_AirgooLustrousCommander : public RGBController
+{
+public:
+    RGBController_AirgooLustrousCommander(AirgooLustrousCommanderController* controller_ptr);
+    ~RGBController_AirgooLustrousCommander();
+
+    void        SetupZones();
+    void        ResizeZone(int zone, int new_size);
+
+    void        DeviceUpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        DeviceUpdateMode();
+
+private:
+    AirgooLustrousCommanderController*  controller;
+    std::vector<int>                    fanleds{0};
+};

Controllers/AsusTUFLaptopController/AsusTUFLaptopDetect_Windows.cpp

@@ -9,7 +9,6 @@
 
 #include <string>
 #include "Detector.h"
-#include "FanController_AsusTUFLaptop_Windows.h"
 #include "RGBController_AsusTUFLaptop_Windows.h"
 #include "wmi.h"
 
@@ -45,10 +44,8 @@ static void DetectAsusTUFLaptopWMIControllers()
     if(controller)
     {
         RGBController* new_controller = new RGBController_AsusTUFLaptopWMI(controller);
-        FanController* fan_controller = new FanController_AsusTUFLaptopWMI(controller);
 
         ResourceManager::get()->RegisterRGBController(new_controller);
-        ResourceManager::get()->RegisterFanController(fan_controller);
     }
 }   /* DetectAsusTUFLaptopWMIControllers() */
 

Controllers/AsusTUFLaptopController/FanController_AsusTUFLaptop_Windows.cpp

@@ -1,44 +0,0 @@
-#include "FanController_AsusTUFLaptop_Windows.h"
-
-
-FanController_AsusTUFLaptopWMI::FanController_AsusTUFLaptopWMI(AsusTUFLaptopController* dev)
-{
-    controller = dev;
-    name = "ASUS TUF Laptop";
-    description = "WMI Device";
-    location    = "\\\\.\\ATKACPI";
-
-    // Coolers RPM reading & current mode retrieval is still WIP
-    fans.resize(2);
-    fans[0].name = "CPU Cooler";
-    fans[0].speed_min = 0;
-    fans[0].speed_max = 2;
-    fans[0].speed_cmd = 1;
-    fans[0].prev_speed_cmd = 1;
-    fans[0].rpm_rdg = 0; // We don't have it, but we don't want an unitialized value either
-}
-
-void FanController_AsusTUFLaptopWMI::UpdateControl()
-{
-    int mode = fans[0].speed_cmd;
-    switch(mode)
-    {
-    case 0:
-        mode = ASUS_WMI_FAN_SPEED_SILENT;
-        break;
-    case 1:
-        mode = ASUS_WMI_FAN_SPEED_NORMAL;
-        break;
-    case 2:
-        mode = ASUS_WMI_FAN_SPEED_TURBO;
-        break;
-    }
-
-    controller->setFanMode(mode);
-}
-
-void FanController_AsusTUFLaptopWMI::UpdateReading()
-{
-    ;
-}
-

Controllers/AsusTUFLaptopController/FanController_AsusTUFLaptop_Windows.h

@@ -1,18 +0,0 @@
-#ifndef FANCONTROLLER_ASUSTUFLAPTOPWMI_H
-#define FANCONTROLLER_ASUSTUFLAPTOPWMI_H
-
-#include "FanController.h"
-#include "AsusTUFLaptopController_Windows.h"
-
-class FanController_AsusTUFLaptopWMI : public FanController
-{
-private:
-    AsusTUFLaptopController* controller;
-
-public:
-    FanController_AsusTUFLaptopWMI(AsusTUFLaptopController* dev);
-    void UpdateControl() override;
-    void UpdateReading() override;
-};
-
-#endif // FANCONTROLLER_ASUSTUFLAPTOPWMI_H

Controllers/CorsairLightingNodeController/CorsairLightingNodeController.cpp

@@ -59,72 +59,6 @@ void CorsairLightingNodeController::KeepaliveThread()
     }
 }
 
-unsigned char CorsairLightingNodeController::GetFanPercent(unsigned char fan_channel)
-{
-    int             actual;
-    unsigned char   usb_buf[65];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up Get Fan RPM packet                             |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]   = 0x00;
-    usb_buf[0x01]   = CORSAIR_LIGHTING_NODE_PACKET_ID_GET_FAN_PERCENT;
-    usb_buf[0x02]   = fan_channel;
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 65);
-    actual = hid_read(dev, usb_buf, 17);
-
-    if(actual > 0)
-    {
-        return(usb_buf[0x01]);
-    }
-    else
-    {
-        return(0);
-    }    
-}
-
-unsigned short CorsairLightingNodeController::GetFanRPM(unsigned char fan_channel)
-{
-    int             actual;
-    unsigned char   usb_buf[65];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up Get Fan RPM packet                             |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]   = 0x00;
-    usb_buf[0x01]   = CORSAIR_LIGHTING_NODE_PACKET_ID_GET_FAN_RPM;
-    usb_buf[0x02]   = fan_channel;
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 65);
-    actual = hid_read(dev, usb_buf, 17);
-
-    if(actual > 0)
-    {
-        return((usb_buf[0x01] << 8) + (usb_buf[0x02] & 0xFF));
-    }
-    else
-    {
-        return(0);
-    }
-}
-
 std::string CorsairLightingNodeController::GetFirmwareString()
 {
     return(firmware_version);
@@ -269,92 +203,6 @@ void CorsairLightingNodeController::SetChannelLEDs(unsigned char channel, RGBCol
     SendCommit();
 }
 
-void CorsairLightingNodeController::SetFanConfiguration
-    (
-        unsigned char   fan_channel,
-        unsigned char   fan_configuration
-    )
-{
-    unsigned char   usb_buf[65];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up Fan Configuration packet                       |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]   = 0x00;
-    usb_buf[0x01]   = CORSAIR_LIGHTING_NODE_PACKET_ID_FAN_CONFIG;
-    usb_buf[0x02]   = 0x02;
-    usb_buf[0x03]   = fan_channel;
-    usb_buf[0x04]   = fan_configuration;
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 65);
-    hid_read(dev, usb_buf, 17);
-}
-
-void CorsairLightingNodeController::SetFanPercent
-    (
-        unsigned char   fan_channel,
-        unsigned char   fan_cmd
-    )
-{
-    unsigned char   usb_buf[65];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up Fan Fixed Percent Command packet               |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]   = 0x00;
-    usb_buf[0x01]   = CORSAIR_LIGHTING_NODE_PACKET_ID_FAN_CMD_PERCENT;
-    usb_buf[0x02]   = fan_channel;
-    usb_buf[0x03]   = fan_cmd;
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 65);
-    hid_read(dev, usb_buf, 17);
-}
-
-void CorsairLightingNodeController::SetFanRPM
-    (
-        unsigned char   fan_channel,
-        unsigned short  fan_cmd
-    )
-{
-    unsigned char   usb_buf[65];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up Fan Fixed RPM Command packet                   |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]   = 0x00;
-    usb_buf[0x01]   = CORSAIR_LIGHTING_NODE_PACKET_ID_FAN_CMD_RPM;
-    usb_buf[0x02]   = fan_channel;
-    usb_buf[0x03]   = fan_cmd & 0xFF;
-    usb_buf[0x04]   = fan_cmd >> 8;
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 65);
-    hid_read(dev, usb_buf, 17);
-}
-
 /*-------------------------------------------------------------------------------------------------*\
 | Private packet sending functions.                                                                 |
 \*-------------------------------------------------------------------------------------------------*/

Controllers/CorsairLightingNodeController/CorsairLightingNodeController.h

@@ -23,12 +23,6 @@
 enum
 {
     CORSAIR_LIGHTING_NODE_PACKET_ID_FIRMWARE         = 0x02,     /* Get firmware version                 */
-    CORSAIR_LIGHTING_NODE_PACKET_ID_GET_FAN_CONFIG   = 0x20,     /* Get fan configuration                */
-    CORSAIR_LIGHTING_NODE_PACKET_ID_GET_FAN_RPM      = 0x21,     /* Get fan RPM                          */
-    CORSAIR_LIGHTING_NODE_PACKET_ID_GET_FAN_PERCENT  = 0x22,     /* Get fan fixed percent command        */
-    CORSAIR_LIGHTING_NODE_PACKET_ID_FAN_CMD_PERCENT  = 0x23,     /* Set fan fixed percent command        */
-    CORSAIR_LIGHTING_NODE_PACKET_ID_FAN_CMD_RPM      = 0x24,     /* Set fan fixed RPM command            */
-    CORSAIR_LIGHTING_NODE_PACKET_ID_FAN_CONFIG       = 0x28,     /* Set fan configuration                */
     CORSAIR_LIGHTING_NODE_PACKET_ID_DIRECT           = 0x32,     /* Direct mode LED update packet        */
     CORSAIR_LIGHTING_NODE_PACKET_ID_COMMIT           = 0x33,     /* Commit changes packet                */
     CORSAIR_LIGHTING_NODE_PACKET_ID_BEGIN            = 0x34,     /* Begin effect packet                  */
@@ -69,17 +63,6 @@ enum
     CORSAIR_LIGHTING_NODE_NUM_CHANNELS               = 0x02,     /* Number of channels                   */
 };
 
-enum
-{
-    CORSAIR_LIGHTING_NODE_FAN_CHANNEL_1              = 0x00,     /* Fan channel 1                        */
-    CORSAIR_LIGHTING_NODE_FAN_CHANNEL_2              = 0x01,     /* Fan channel 2                        */
-    CORSAIR_LIGHTING_NODE_FAN_CHANNEL_3              = 0x02,     /* Fan channel 3                        */
-    CORSAIR_LIGHTING_NODE_FAN_CHANNEL_4              = 0x03,     /* Fan channel 4                        */
-    CORSAIR_LIGHTING_NODE_FAN_CHANNEL_5              = 0x04,     /* Fan channel 5                        */
-    CORSAIR_LIGHTING_NODE_FAN_CHANNEL_6              = 0x05,     /* Fan channel 6                        */
-    CORSAIR_LIGHTING_NODE_NUM_FAN_CHANNELS           = 0x06,     /* Number of fan channels               */
-};
-
 enum
 {
     CORSAIR_LIGHTING_NODE_SPEED_FAST                 = 0x00,     /* Fast speed                           */
@@ -102,23 +85,12 @@ enum
     CORSAIR_LIGHTING_NODE_MODE_RAINBOW               = 0x0A,     /* Rainbow mode                         */
 };
 
-enum
-{
-    CORSAIR_LIGHTING_NODE_FAN_CONFIG_AUTO            = 0x00,     /* Auto/Disconnected                    */
-    CORSAIR_LIGHTING_NODE_FAN_CONFIG_3_PIN           = 0x01,     /* 3-Pin Fan                            */
-    CORSAIR_LIGHTING_NODE_FAN_CONFIG_4_PIN           = 0x02,     /* 4-Pin Fan                            */
-};
-
 class CorsairLightingNodeController
 {
 public:
     CorsairLightingNodeController(hid_device* dev_handle, const char* path);
     ~CorsairLightingNodeController();
 
-    unsigned char   GetFanPercent(unsigned char fan_channel);
-
-    unsigned short  GetFanRPM(unsigned char fan_channel);
-
     std::string     GetFirmwareString();
     std::string     GetLocationString();
     std::string     GetSerialString();
@@ -146,24 +118,6 @@ public:
 
     void            SetChannelLEDs(unsigned char channel, RGBColor * colors, unsigned int num_colors);
 
-    void            SetFanConfiguration
-                        (
-                            unsigned char   fan_channel,
-                            unsigned char   fan_configuration
-                        );
-
-    void            SetFanPercent
-                        (
-                            unsigned char   fan_channel,
-                            unsigned char   fan_cmd
-                        );
-
-    void            SetFanRPM
-                        (
-                            unsigned char   fan_channel,
-                            unsigned short  fan_cmd
-                        );
-
     void            KeepaliveThread();
 
 private:

Controllers/CorsairLightingNodeController/CorsairLightingNodeControllerDetect.cpp

@@ -1,64 +1,55 @@
-/*---------------------------------------------------------*\
-| CorsairLightingNodeControllerDetect.cpp                   |
-|                                                           |
-|   Detector for Corsair Lighting Node devices              |
-|                                                           |
-|   Adam Honse ([email protected])      12 Jan 2020 |
-|                                                           |
-|   This file is part of the OpenRGB project                |
-|   SPDX-License-Identifier: GPL-2.0-only                   |
-\*---------------------------------------------------------*/
-
-#include <vector>
-#include <hidapi.h>
-#include "Detector.h"
-#include "CorsairLightingNodeController.h"
-#include "FanController.h"
-#include "FanController_CorsairCommander.h"
-#include "RGBController.h"
-#include "RGBController_CorsairLightingNode.h"
-
-#define CORSAIR_VID                     0x1B1C
-#define CORSAIR_LIGHTING_NODE_CORE_PID  0x0C1A
-#define CORSAIR_LIGHTING_NODE_PRO_PID   0x0C0B
-#define CORSAIR_COMMANDER_PRO_PID       0x0C10
-#define CORSAIR_LS100_PID               0x0C1E
-#define CORSAIR_1000D_OBSIDIAN_PID      0x1D00
-#define CORSAIR_SPEC_OMEGA_RGB_PID      0x1D04
-#define CORSAIR_LT100_PID               0x0C23
-
-/******************************************************************************************\
-*                                                                                          *
-*   DetectCorsairLightingNodeControllers                                                   *
-*                                                                                          *
-*       Detect devices supported by the Corsair Lighting Node Pro driver                   *
-*                                                                                          *
-\******************************************************************************************/
-
-void DetectCorsairLightingNodeControllers(hid_device_info* info, const std::string& name)
-{
-    hid_device* dev = hid_open_path(info->path);
-
-    if(dev)
-    {
-        CorsairLightingNodeController*     controller     = new CorsairLightingNodeController(dev, info->path);
-        RGBController_CorsairLightingNode* rgb_controller = new RGBController_CorsairLightingNode(controller);
-        rgb_controller->name = name;
-        ResourceManager::get()->RegisterRGBController(rgb_controller);
-
-        if(info->product_id == CORSAIR_COMMANDER_PRO_PID)
-        {
-            FanController_CorsairCommander* fan_controller = new FanController_CorsairCommander(controller);
-            fan_controller->name = name;
-            ResourceManager::get()->RegisterFanController(fan_controller);
-        }
-    }
-}   /* DetectCorsairLightingNodeControllers() */
-
-REGISTER_HID_DETECTOR("Corsair Lighting Node Core", DetectCorsairLightingNodeControllers, CORSAIR_VID, CORSAIR_LIGHTING_NODE_CORE_PID); // 1 channel
-REGISTER_HID_DETECTOR("Corsair Lighting Node Pro",  DetectCorsairLightingNodeControllers, CORSAIR_VID, CORSAIR_LIGHTING_NODE_PRO_PID);  // 2 channels
-REGISTER_HID_DETECTOR("Corsair Commander Pro",      DetectCorsairLightingNodeControllers, CORSAIR_VID, CORSAIR_COMMANDER_PRO_PID);      // 2 channels
-REGISTER_HID_DETECTOR("Corsair LS100 Lighting Kit", DetectCorsairLightingNodeControllers, CORSAIR_VID, CORSAIR_LS100_PID);              // 1 channel
-REGISTER_HID_DETECTOR("Corsair 1000D Obsidian",     DetectCorsairLightingNodeControllers, CORSAIR_VID, CORSAIR_1000D_OBSIDIAN_PID);     // 2 channels
-REGISTER_HID_DETECTOR("Corsair SPEC OMEGA RGB",     DetectCorsairLightingNodeControllers, CORSAIR_VID, CORSAIR_SPEC_OMEGA_RGB_PID);     // 2 channels
-REGISTER_HID_DETECTOR("Corsair LT100",              DetectCorsairLightingNodeControllers, CORSAIR_VID, CORSAIR_LT100_PID);              // 2 channels
+/*---------------------------------------------------------*\
+| CorsairLightingNodeControllerDetect.cpp                   |
+|                                                           |
+|   Detector for Corsair Lighting Node devices              |
+|                                                           |
+|   Adam Honse ([email protected])      12 Jan 2020 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-only                   |
+\*---------------------------------------------------------*/
+
+#include <vector>
+#include <hidapi.h>
+#include "Detector.h"
+#include "CorsairLightingNodeController.h"
+#include "RGBController.h"
+#include "RGBController_CorsairLightingNode.h"
+
+#define CORSAIR_VID                     0x1B1C
+#define CORSAIR_LIGHTING_NODE_CORE_PID  0x0C1A
+#define CORSAIR_LIGHTING_NODE_PRO_PID   0x0C0B
+#define CORSAIR_COMMANDER_PRO_PID       0x0C10
+#define CORSAIR_LS100_PID               0x0C1E
+#define CORSAIR_1000D_OBSIDIAN_PID      0x1D00
+#define CORSAIR_SPEC_OMEGA_RGB_PID      0x1D04
+#define CORSAIR_LT100_PID               0x0C23
+
+/******************************************************************************************\
+*                                                                                          *
+*   DetectCorsairLightingNodeControllers                                                   *
+*                                                                                          *
+*       Detect devices supported by the Corsair Lighting Node Pro driver                   *
+*                                                                                          *
+\******************************************************************************************/
+
+void DetectCorsairLightingNodeControllers(hid_device_info* info, const std::string& name)
+{
+    hid_device* dev = hid_open_path(info->path);
+
+    if(dev)
+    {
+        CorsairLightingNodeController*     controller     = new CorsairLightingNodeController(dev, info->path);
+        RGBController_CorsairLightingNode* rgb_controller = new RGBController_CorsairLightingNode(controller);
+        rgb_controller->name = name;
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
+    }
+}   /* DetectCorsairLightingNodeControllers() */
+
+REGISTER_HID_DETECTOR("Corsair Lighting Node Core", DetectCorsairLightingNodeControllers, CORSAIR_VID, CORSAIR_LIGHTING_NODE_CORE_PID); // 1 channel
+REGISTER_HID_DETECTOR("Corsair Lighting Node Pro",  DetectCorsairLightingNodeControllers, CORSAIR_VID, CORSAIR_LIGHTING_NODE_PRO_PID);  // 2 channels
+REGISTER_HID_DETECTOR("Corsair Commander Pro",      DetectCorsairLightingNodeControllers, CORSAIR_VID, CORSAIR_COMMANDER_PRO_PID);      // 2 channels
+REGISTER_HID_DETECTOR("Corsair LS100 Lighting Kit", DetectCorsairLightingNodeControllers, CORSAIR_VID, CORSAIR_LS100_PID);              // 1 channel
+REGISTER_HID_DETECTOR("Corsair 1000D Obsidian",     DetectCorsairLightingNodeControllers, CORSAIR_VID, CORSAIR_1000D_OBSIDIAN_PID);     // 2 channels
+REGISTER_HID_DETECTOR("Corsair SPEC OMEGA RGB",     DetectCorsairLightingNodeControllers, CORSAIR_VID, CORSAIR_SPEC_OMEGA_RGB_PID);     // 2 channels
+REGISTER_HID_DETECTOR("Corsair LT100",              DetectCorsairLightingNodeControllers, CORSAIR_VID, CORSAIR_LT100_PID);              // 2 channels

Controllers/CorsairLightingNodeController/FanController_CorsairCommander.cpp

@@ -1,57 +0,0 @@
-/*-----------------------------------------*\
-|  FanController_CorsairCommander.cpp       |
-|                                           |
-|  Generic Fan Interface for Corsair        |
-|  Commander controller                     |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 6/7/2020    |
-\*-----------------------------------------*/
-
-#include "FanController_CorsairCommander.h"
-
-FanController_CorsairCommander::FanController_CorsairCommander(CorsairLightingNodeController* corsair_ptr)
-{
-    corsair = corsair_ptr;
-
-    name        = "Corsair Commander";
-    description = "Corsair Commander Device";
-    version     = corsair->GetFirmwareString();
-
-    for(std::size_t fan_index = 0; fan_index < CORSAIR_LIGHTING_NODE_NUM_FAN_CHANNELS; fan_index++)
-    {
-        fan new_fan;
-
-        new_fan.name        = "Corsair Commander Fan ";
-        new_fan.name.append(std::to_string(fan_index + 1));
-        new_fan.speed_min   = 0;
-        new_fan.speed_max   = 100;
-        new_fan.speed_cmd   = corsair->GetFanPercent(fan_index);
-        new_fan.rpm_rdg     = corsair->GetFanRPM(fan_index);
-
-        fans.push_back(new_fan);
-
-        corsair->SetFanConfiguration(fan_index, CORSAIR_LIGHTING_NODE_FAN_CONFIG_4_PIN);
-    }
-
-    UpdateControl();
-}
-
-void FanController_CorsairCommander::UpdateControl()
-{
-    for(std::size_t fan_index = 0; fan_index < fans.size(); fan_index++)
-    {
-        corsair->SetFanPercent(fan_index, fans[fan_index].speed_cmd);
-    }
-}
-
-void FanController_CorsairCommander::UpdateReading()
-{
-    for(std::size_t fan_index = 0; fan_index < fans.size(); fan_index++)
-    {
-        unsigned short rpm;
-
-        rpm = corsair->GetFanRPM(fan_index);
-
-        fans[fan_index].rpm_rdg = rpm;
-    }
-}

Controllers/CorsairLightingNodeController/FanController_CorsairCommander.h

@@ -1,24 +0,0 @@
-/*-----------------------------------------*\
-|  FanController_CorsairCommander.h         |
-|                                           |
-|  Generic Fan Interface for Corsair        |
-|  Commander controller                     |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 6/7/2020    |
-\*-----------------------------------------*/
-
-#pragma once
-#include "FanController.h"
-#include "CorsairLightingNodeController.h"
-
-class FanController_CorsairCommander : public FanController
-{
-public:
-    FanController_CorsairCommander(CorsairLightingNodeController* corsair_ptr);
-
-    void        UpdateControl();
-    void        UpdateReading();
-
-private:
-    CorsairLightingNodeController* corsair;
-};

Controllers/FanBusController/FanBusController.cpp

@@ -34,31 +34,6 @@ std::string FanBusController::GetLocation()
     return(location_string);
 }
 
-unsigned char FanBusController::GetFanPWM()
-{
-    unsigned char fan_pwm;
-
-    fan_pwm = bus->read(dev, 0x01);
-
-    return(fan_pwm);
-}
-
-unsigned short FanBusController::GetFanRPM()
-{
-    unsigned char fan_rpm_low;
-    unsigned char fan_rpm_high;
-
-    fan_rpm_low = bus->read(dev, 0x02);
-    fan_rpm_high = bus->read(dev, 0x03);
-
-    return((fan_rpm_high << 8) | fan_rpm_low);
-}
-
-void FanBusController::SetFanPWM(unsigned char fan_pwm)
-{
-    bus->write(dev, 0x01, fan_pwm);
-}
-
 void FanBusController::SetLEDs(std::vector<RGBColor> colors)
 {
     for(unsigned int led_idx = 0; led_idx < 4; led_idx++)

Controllers/FanBusController/FanBusController.h

@@ -21,12 +21,9 @@ public:
     FanBusController(FanBusInterface* bus_ptr, unsigned char dev_addr);
     ~FanBusController();
 
-    std::string     GetLocation();
+    std::string GetLocation();
 
-    unsigned char   GetFanPWM();
-    unsigned short  GetFanRPM();
-    void            SetFanPWM(unsigned char fan_pwm);
-    void            SetLEDs(std::vector<RGBColor> colors);
+    void        SetLEDs(std::vector<RGBColor> colors);
 
 private:
     std::string         port_name;

Controllers/FanBusController/FanBusControllerDetect.cpp

@@ -11,7 +11,6 @@
 
 #include "Detector.h"
 #include "FanBusController.h"
-#include "FanController_FanBus.h"
 #include "RGBController_FanBus.h"
 #include "SettingsManager.h"
 
@@ -46,10 +45,6 @@ void DetectFanBusControllers()
                     RGBController_FanBus* rgb_controller = new RGBController_FanBus(controller);
 
                     ResourceManager::get()->RegisterRGBController(rgb_controller);
-
-                    FanController_FanBus* fan_controller = new FanController_FanBus(controller);
-
-                    ResourceManager::get()->RegisterFanController(fan_controller);
                 }
             }
         }

Controllers/FanBusController/FanController_FanBus.cpp

@@ -1,43 +0,0 @@
-/*-----------------------------------------*\
-|  FanController_FanBus.cpp                 |
-|                                           |
-|  Generic Fan Interface for FanBus         |
-|  controller                               |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 3/1/2020    |
-\*-----------------------------------------*/
-
-#include "FanController_FanBus.h"
-
-FanController_FanBus::FanController_FanBus(FanBusController* controller_ptr)
-{
-    controller  = controller_ptr;
-
-    name        = "FanBus Device";
-    description = "FanBus Device";
-    location    = controller->GetLocation();
-
-    fan new_fan;
-
-    new_fan.name        = "FanBus Fan";
-    new_fan.speed_min   = 0;
-    new_fan.speed_max   = 255;
-    new_fan.speed_cmd   = controller->GetFanPWM();
-    new_fan.rpm_rdg     = controller->GetFanRPM();
-
-    fans.push_back(new_fan);
-}
-
-void FanController_FanBus::UpdateControl()
-{
-    controller->SetFanPWM(fans[0].speed_cmd);
-}
-
-void FanController_FanBus::UpdateReading()
-{
-    unsigned short rpm;
-
-    rpm = controller->GetFanRPM();
-
-    fans[0].rpm_rdg = rpm;
-}

Controllers/FanBusController/FanController_FanBus.h

@@ -1,24 +0,0 @@
-/*-----------------------------------------*\
-|  FanController_FanBus.h                   |
-|                                           |
-|  Generic Fan Interface for FanBus         |
-|  controller                               |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 3/1/2020    |
-\*-----------------------------------------*/
-
-#pragma once
-#include "FanController.h"
-#include "FanBusController.h"
-
-class FanController_FanBus : public FanController
-{
-public:
-    FanController_FanBus(FanBusController* controller_ptr);
-
-    void        UpdateControl();
-    void        UpdateReading();
-
-private:
-    FanBusController* controller;
-};

Controllers/GigabyteRGBFusion2GPUController/GigabyteRGBFusion2GPUControllerDetect.cpp

@@ -155,7 +155,6 @@ REGISTER_I2C_PCI_DETECTOR("Gigabyte RTX 4070 Ti Super Gaming OC 16G",
 REGISTER_I2C_PCI_DETECTOR("Gigabyte RTX 4080 AERO OC 16G",                           DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX4080_DEV,         GIGABYTE_SUB_VEN,   GIGABYTE_RTX4080_AERO_OC_SUB_DEV,               0x71);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte RTX 4080 Eagle OC 16G",                          DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX4080_DEV,         GIGABYTE_SUB_VEN,   GIGABYTE_RTX4080_EAGLE_OC_SUB_DEV,              0x71);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte RTX 4080 SUPER Gaming OC 16G",                   DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX4080S_DEV,        GIGABYTE_SUB_VEN,   GIGABYTE_RTX4080S_GAMING_OC_16GB_SUB_DEV,       0x72);
-REGISTER_I2C_PCI_DETECTOR("Gigabyte RTX 4080 SUPER AERO OC 16G",                     DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX4080S_DEV,        GIGABYTE_SUB_VEN,   GIGABYTE_RTX4080S_AERO_OC_16GB_SUB_DEV,         0x72);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte RTX 4080 Gaming OC 16G",                         DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX4080_DEV,         GIGABYTE_SUB_VEN,   GIGABYTE_RTX4080_GAMING_OC_SUB_DEV,             0x71);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte AORUS RTX 4080 MASTER 16G",                      DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX4080_DEV,         GIGABYTE_SUB_VEN,   GIGABYTE_AORUS_RTX4080_MASTER_16G_SUB_DEV,      0x71);
 REGISTER_I2C_PCI_DETECTOR("Gigabyte RTX 4090 AERO OC 24G",                           DetectGigabyteRGBFusion2GPUControllers, NVIDIA_VEN, NVIDIA_RTX4090_DEV,         GIGABYTE_SUB_VEN,   GIGABYTE_RTX4090_AERO_OC_24G_SUB_DEV,           0x71);

Controllers/HyperXMicrophoneController/RGBController_HyperXMicrophone.cpp

@@ -99,7 +99,7 @@ void RGBController_HyperXMicrophone::SetupZones()
 
     zone Mic;
     Mic.name       = "Microphone";
-    Mic.type       = ZONE_TYPE_SINGLE;
+    Mic.type       = ZONE_TYPE_LINEAR;
     Mic.leds_min   = 2;
     Mic.leds_max   = 2;
     Mic.leds_count = 2;

Controllers/NZXTHue2Controller/FanController_NZXTHue2.cpp

@@ -1,55 +0,0 @@
-/*-----------------------------------------*\
-|  FanController_NZXTHue2.cpp               |
-|                                           |
-|  Generic Fan Interface for NZXT Hue 2     |
-|  (Smart Device V2, Fan & RGB) controller  |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 6/22/2020   |
-\*-----------------------------------------*/
-
-#include "FanController_NZXTHue2.h"
-
-FanController_NZXTHue2::FanController_NZXTHue2(NZXTHue2Controller* hue2_ptr)
-{
-    hue2 = hue2_ptr;
-
-    name        = "NZXT Hue 2 Device";
-    description = "NZXT Hue 2 Device";
-    version     = hue2->GetFirmwareVersion();
-
-    for(std::size_t fan_index = 0; fan_index < hue2->GetNumFanChannels(); fan_index++)
-    {
-        fan new_fan;
-
-        hue2->UpdateStatus();
-
-        new_fan.name        = "NZXT Fan ";
-        new_fan.name.append(std::to_string(fan_index + 1));
-        new_fan.speed_min   = 0;
-        new_fan.speed_max   = 100;
-        new_fan.speed_cmd   = hue2->GetFanCommand(fan_index);
-        new_fan.rpm_rdg     = hue2->GetFanRPM(fan_index);
-
-        fans.push_back(new_fan);
-    }
-
-    UpdateControl();
-}
-
-void FanController_NZXTHue2::UpdateControl()
-{
-    for(std::size_t fan_index = 0; fan_index < fans.size(); fan_index++)
-    {
-        hue2->SendFan(fan_index, 0, fans[fan_index].speed_cmd);
-    }
-}
-
-void FanController_NZXTHue2::UpdateReading()
-{
-    hue2->UpdateStatus();
-
-    for(std::size_t fan_index = 0; fan_index < fans.size(); fan_index++)
-    {
-        fans[fan_index].rpm_rdg = hue2->GetFanRPM(fan_index);
-    }
-}

Controllers/NZXTHue2Controller/FanController_NZXTHue2.h

@@ -1,24 +0,0 @@
-/*-----------------------------------------*\
-|  FanController_NZXTHue2.h                 |
-|                                           |
-|  Generic Fan Interface for NZXT Hue 2     |
-|  (Smart Device V2, Fan & RGB) controller  |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 6/22/2020   |
-\*-----------------------------------------*/
-
-#pragma once
-#include "FanController.h"
-#include "NZXTHue2Controller.h"
-
-class FanController_NZXTHue2 : public FanController
-{
-public:
-    FanController_NZXTHue2(NZXTHue2Controller* hue2_ptr);
-
-    void        UpdateControl();
-    void        UpdateReading();
-
-private:
-    NZXTHue2Controller* hue2;
-};

Controllers/NZXTHue2Controller/NZXTHue2Controller.cpp

@@ -30,48 +30,6 @@ NZXTHue2Controller::NZXTHue2Controller(hid_device* dev_handle, unsigned int rgb_
 
     fan_cmd.resize(num_fan_channels);
     fan_rpm.resize(num_fan_channels);
-
-    unsigned char usb_buf[64];
-    unsigned int  ret_val = 0;
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up Fan Reporting Interval packet                  |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]   = 0x60;
-    usb_buf[0x01]   = 0x02;
-    usb_buf[0x02]   = 0x01;
-    usb_buf[0x03]   = 0xE8;
-    usb_buf[0x04]   = 0x03;
-    usb_buf[0x05]   = 0x01;
-    usb_buf[0x06]   = 0xE8;
-    usb_buf[0x07]   = 0x03;
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 64);
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up Enable Fan Reporting packet                    |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]   = 0x60;
-    usb_buf[0x01]   = 0x03;
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 64);
-
     UpdateStatus();
 }
 
@@ -291,7 +249,7 @@ void NZXTHue2Controller::UpdateStatus()
     unsigned char usb_buf[64];
     unsigned int  ret_val = 0;
 
-    if(num_fan_channels > 0)
+    if(false)//num_fan_channels > 0)
     {
         /*-----------------------------------------------------*\
         | Zero out buffer                                       |

Controllers/NZXTHue2Controller/NZXTHue2ControllerDetect.cpp

@@ -12,8 +12,6 @@
 #include <hidapi.h>
 #include "Detector.h"
 #include "NZXTHue2Controller.h"
-#include "FanController.h"
-#include "FanController_NZXTHue2.h"
 #include "RGBController.h"
 #include "RGBController_NZXTHue2.h"
 
@@ -47,13 +45,6 @@ static void spawn_hue(hid_device_info* info, const std::string& name, int rgb_ch
         rgb_controller->name                   = name;
 
         ResourceManager::get()->RegisterRGBController(rgb_controller);
-
-        if(fan_channels > 0)
-        {
-            FanController_NZXTHue2* fan_controller = new FanController_NZXTHue2(controller);
-            fan_controller->name = name;
-            ResourceManager::get()->RegisterFanController(fan_controller);
-        }
     }
 }
 

Controllers/NZXTKrakenController/FanController_NZXTKraken.cpp

@@ -1,71 +0,0 @@
-/*-----------------------------------------*\
-|  FanController_NZXTKraken.cpp             |
-|                                           |
-|  Generic Fan Interface for NZXT Kraken    |
-|                                           |
-|  swilde 5/2021                            |
-\*-----------------------------------------*/
-
-#include "FanController_NZXTKraken.h"
-
-FanController_NZXTKraken::FanController_NZXTKraken(NZXTKrakenController* kraken_ptr)
-{
-    kraken      = kraken_ptr;
-
-    name        = "NZXT Kraken X2";
-    description = "NZXT Kraken X42/X52/X62/X72";
-    version     = kraken->GetFirmwareVersion();
-    location    = kraken->GetLocation();
-    serial      = kraken->GetSerialString();
-
-    kraken->UpdateStatus();
-
-    fan new_fan;
-
-    /*---------------------------------------------------------*\
-    | Add fan                                                   |
-    | X52 has a max fan RPM of 200, the X42 and X62 max is 1800 |
-    \*---------------------------------------------------------*/
-    new_fan.name        = "NZXT Kraken Fan";
-    new_fan.speed_min   = 25;
-    new_fan.speed_max   = 100;
-    new_fan.speed_cmd   = 100 * kraken->fan_speed / 2000;
-    new_fan.prev_speed_cmd = 0;
-    new_fan.rpm_rdg     = kraken->fan_speed;
-    fans.push_back(new_fan);
-
-    /*---------------------------------------------------------*\
-    | Add pump                                                  |
-    \*---------------------------------------------------------*/
-    new_fan.name        = "NZXT Kraken Pump";
-    new_fan.speed_min   = 50;
-    new_fan.speed_max   = 100;
-    new_fan.speed_cmd   = 100 * kraken->pump_speed / 2800;
-    new_fan.prev_speed_cmd = 0;
-    new_fan.rpm_rdg     = kraken->pump_speed;
-    fans.push_back(new_fan);
-
-    UpdateControl();
-}
-
-void FanController_NZXTKraken::UpdateControl()
-{
-    if(fans[0].speed_cmd != fans[0].prev_speed_cmd)
-    {
-        kraken->SetSpeed(NZXT_KRAKEN_CHANNEL_FAN, fans[0].speed_cmd);
-        fans[0].prev_speed_cmd = fans[0].speed_cmd;
-    }
-    if(fans[1].speed_cmd != fans[1].prev_speed_cmd)
-    {
-        kraken->SetSpeed(NZXT_KRAKEN_CHANNEL_PUMP, fans[1].speed_cmd);
-        fans[1].prev_speed_cmd = fans[1].speed_cmd;
-    }
-}
-
-void FanController_NZXTKraken::UpdateReading()
-{
-    kraken->UpdateStatus();
-
-    fans[0].rpm_rdg = kraken->fan_speed;
-    fans[1].rpm_rdg = kraken->pump_speed;
-}

Controllers/NZXTKrakenController/FanController_NZXTKraken.h

@@ -1,23 +0,0 @@
-/*-----------------------------------------*\
-|  FanController_NZXTKraken.h               |
-|                                           |
-|  Generic Fan Interface for NZXT Kraken    |
-|                                           |
-|  swilde 5/2021                            |
-\*-----------------------------------------*/
-
-#pragma once
-#include "FanController.h"
-#include "NZXTKrakenController.h"
-
-class FanController_NZXTKraken : public FanController
-{
-public:
-    FanController_NZXTKraken(NZXTKrakenController* kraken_ptr);
-
-    void        UpdateControl();
-    void        UpdateReading();
-
-private:
-    NZXTKrakenController* kraken;
-};

Controllers/NZXTKrakenController/NZXTKrakenController.cpp

@@ -41,9 +41,6 @@ NZXTKrakenController::NZXTKrakenController(hid_device* dev_handle, const char* p
     | Get the firmware version                              |
     \*-----------------------------------------------------*/
     UpdateStatus();
-
-    int major_firmware_version = std::stoi(firmware_version.substr(0, firmware_version.find(".")));
-    supports_cooling_profiles = major_firmware_version >= 3;
 }
 
 NZXTKrakenController::~NZXTKrakenController()
@@ -199,135 +196,3 @@ void NZXTKrakenController::SendEffect
     \*-----------------------------------------------------*/
     hid_write(dev, usb_buf, 64);
 }
-
-void NZXTKrakenController::SetSpeed(unsigned char channel, unsigned int speed_cmd)
-{
-    unsigned char duty;
-
-    /*-----------------------------------------------------*\
-    | Verify channel                                        |
-    \*-----------------------------------------------------*/
-    if(channel == NZXT_KRAKEN_CHANNEL_FAN)
-    {
-        duty = std::max((unsigned char) 25, std::min((unsigned char) 100, (unsigned char) speed_cmd));
-    }
-    else if(channel == NZXT_KRAKEN_CHANNEL_PUMP)
-    {
-        duty = std::max((unsigned char) 50, std::min((unsigned char) 100, (unsigned char) speed_cmd));
-    }
-    else
-    {
-        return;
-    }
-
-    /*-----------------------------------------------------*\
-    | Write speed                                           |
-    \*-----------------------------------------------------*/
-    if(supports_cooling_profiles)
-    {
-        SetFixedSpeedProfile(channel, duty);
-    }
-    else
-    {
-        SetInstantaneousSpeed(channel, duty);
-    }
-}
-
-void NZXTKrakenController::SetFixedSpeedProfile(unsigned char channel, unsigned char duty)
-{
-    unsigned char usb_buf[64];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set to fan write                                      |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]   = 0x02;
-    usb_buf[0x01]   = 0x4d;
-
-    usb_buf[0x02]   = channel;
-
-    /*-----------------------------------------------------*\
-    | Generate steps                                        |
-    \*-----------------------------------------------------*/
-    unsigned char temps[36];
-    for(int i = 0; i < 30; i++)
-    {
-        temps[i] = 20 + i;
-    }
-    for(int i = 0; i <= 5; i++)
-    {
-        temps[30 + i] = 50 + 2*i;
-    }
-
-    /*-----------------------------------------------------*\
-    | Write temp speed pairs                                |
-    \*-----------------------------------------------------*/
-    unsigned char curr_duty = duty;
-    for(int i = 0; i < 36; i++)
-    {
-        if(temps[i] == 60)
-        {
-            curr_duty = 100;
-        }
-
-        /*-----------------------------------------------------*\
-        | Set channel and index                                 |
-        \*-----------------------------------------------------*/
-        usb_buf[0x02]   = channel + i;
-
-        /*-----------------------------------------------------*\
-        | Set temp                                              |
-        \*-----------------------------------------------------*/
-        usb_buf[0x03]   = temps[i];
-
-        /*-----------------------------------------------------*\
-        | Set duty                                              |
-        \*-----------------------------------------------------*/
-        usb_buf[0x04]   = curr_duty;
-
-        /*-----------------------------------------------------*\
-        | Write speed                                           |
-        \*-----------------------------------------------------*/
-        hid_write(dev, usb_buf, 64);
-    }
-}
-
-void NZXTKrakenController::SetInstantaneousSpeed(unsigned char channel, unsigned char duty)
-{
-    unsigned char usb_buf[64];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set to fan write                                      |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]   = 0x02;
-    usb_buf[0x01]   = 0x4d;
-
-    /*-----------------------------------------------------*\
-    | Set channel                                           |
-    \*-----------------------------------------------------*/
-    usb_buf[0x02]   = channel;
-
-    /*-----------------------------------------------------*\
-    | Set temp (0 for instantaneous speed)                  |
-    \*-----------------------------------------------------*/
-    usb_buf[0x03]   = 0;
-
-    /*-----------------------------------------------------*\
-    | Set duty                                              |
-    \*-----------------------------------------------------*/
-    usb_buf[0x04]   = duty;
-
-    /*-----------------------------------------------------*\
-    | Write speed                                           |
-    \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 64);
-}

Controllers/NZXTKrakenController/NZXTKrakenController.h

@@ -48,12 +48,6 @@ enum
     NZXT_KRAKEN_SPEED_FASTEST           = 0x04, /* Fastest speed                */
 };
 
-enum
-{
-    NZXT_KRAKEN_CHANNEL_FAN             = 0x80, /* Fan channel                  */
-    NZXT_KRAKEN_CHANNEL_PUMP            = 0xc0, /* Pump channel                 */
-};
-
 class NZXTKrakenController
 {
 public:
@@ -64,12 +58,6 @@ public:
     std::string GetLocation();
     std::string GetSerialString();
 
-    void SetSpeed
-        (
-        unsigned char   channel,
-        unsigned int    speed_cmd
-        );
-
     void UpdateEffect
         (
         NZXTKrakenChannel_t channel,
@@ -80,12 +68,9 @@ public:
         std::vector<RGBColor> colors
         );
 
+private:
     void UpdateStatus();
 
-    unsigned int            fan_speed;
-    unsigned int            pump_speed;
-
-private:
     void SendEffect
         (
         unsigned char   channel,
@@ -98,23 +83,12 @@ private:
         int             size = 0
         );
 
-    void SetFixedSpeedProfile
-        (
-        unsigned char   channel,
-        unsigned char   duty
-        );
-    void SetInstantaneousSpeed
-        (
-        unsigned char   channel,
-        unsigned char   duty
-        );
-
     hid_device*   dev;
 
     // -- status
     std::string             firmware_version;
     double                  liquid_temperature;
     std::string             location;
-
-    bool                    supports_cooling_profiles;
+    unsigned int            fan_speed;
+    unsigned int            pump_speed;
 };

Controllers/NZXTKrakenController/NZXTKrakenControllerDetect.cpp

@@ -13,7 +13,6 @@
 #include <hidapi.h>
 #include "Detector.h"
 #include "NZXTKrakenController.h"
-#include "FanController_NZXTKraken.h"
 #include "RGBController.h"
 #include "RGBController_NZXTKraken.h"
 
@@ -38,17 +37,6 @@ void DetectNZXTKrakenControllers(hid_device_info* info, const std::string& name)
         RGBController_NZXTKraken* rgb_controller = new RGBController_NZXTKraken(controller);
         rgb_controller->name = name;
         ResourceManager::get()->RegisterRGBController(rgb_controller);
-
-        if(info->product_id == NZXT_KRAKEN_X2_PID)
-        {
-            /*---------------------------------------------*\
-            | Kraken M22 doesn't have liquid temp sensor or |
-            | ability to report or set fan or pump speeds   |
-            \*---------------------------------------------*/
-            FanController_NZXTKraken* fan_controller = new FanController_NZXTKraken(controller);
-            fan_controller->name = name;
-            ResourceManager::get()->RegisterFanController(fan_controller);
-        }
     }
 }   /* DetectNZXTKrakenControllers() */
 

Controllers/RazerController/FanController_Razer.cpp

@@ -1,39 +0,0 @@
-/*-----------------------------------------*\
-|  FanController_Razer.cpp                  |
-|                                           |
-|  Generic Fan Interface for Razer Blade    |
-|  laptops that support fan control         |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 6/23/2021   |
-\*-----------------------------------------*/
-
-#include "FanController_Razer.h"
-
-FanController_Razer::FanController_Razer(RazerController* controller_ptr)
-{
-    controller  = controller_ptr;
-
-    name        = controller->GetName();
-    description = "Razer Device";
-    version     = controller->GetFirmwareString();
-
-    fan new_fan;
-
-    new_fan.name        = "Razer Blade Laptop Fan";
-    new_fan.speed_min   = 0;
-    new_fan.speed_max   = 5400;
-    new_fan.speed_cmd   = 0;
-    new_fan.rpm_rdg     = 0;
-
-    fans.push_back(new_fan);
-}
-
-void FanController_Razer::UpdateControl()
-{
-    controller->SetFanRPM(fans[0].speed_cmd);
-}
-
-void FanController_Razer::UpdateReading()
-{
-
-}

Controllers/RazerController/FanController_Razer.h

@@ -1,24 +0,0 @@
-/*-----------------------------------------*\
-|  FanController_Razer.h                    |
-|                                           |
-|  Generic Fan Interface for Razer Blade    |
-|  laptops that support fan control         |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 6/23/2021   |
-\*-----------------------------------------*/
-
-#pragma once
-#include "FanController.h"
-#include "RazerController.h"
-
-class FanController_Razer : public FanController
-{
-public:
-    FanController_Razer(RazerController* controller_ptr);
-
-    void        UpdateControl();
-    void        UpdateReading();
-
-private:
-    RazerController*    controller;
-};

Controllers/RazerController/RazerController/RazerController.cpp

@@ -355,18 +355,6 @@ bool RazerController::SupportsBreathing()
     return(supports_breathing);
 }
 
-void RazerController::SetFanRPM(unsigned int fan_rpm_cmd)
-{
-    if(fan_rpm_cmd == 0)
-    {
-        razer_set_fan_rpm_cmd(true, 0);
-    }
-    else
-    {
-        razer_set_fan_rpm_cmd(false, fan_rpm_cmd);
-    }
-}
-
 bool RazerController::SupportsReactive()
 {
     return(false);
@@ -1808,29 +1796,6 @@ void RazerController::razer_set_mode_wave(unsigned char direction)
     }
 }
 
-void RazerController::razer_set_fan_rpm_cmd(bool auto_fan_rpm, unsigned int fan_rpm_cmd)
-{
-    struct razer_report mode_report         = razer_create_report(0x0D, 0x02, 0x04);
-
-    mode_report.arguments[0]                = 0x00;
-    mode_report.arguments[1]                = 0x01;
-    mode_report.arguments[2]                = 0x00;
-    mode_report.arguments[3]                = auto_fan_rpm ? 0x00 : 0x01;
-
-    razer_usb_send(&mode_report);
-
-    if(!auto_fan_rpm)
-    {
-        struct razer_report fan_rpm_report  = razer_create_report(0x0D, 0x01, 0x03);
-
-        fan_rpm_report.arguments[0]         = 0x00;
-        fan_rpm_report.arguments[1]         = 0x01;
-        fan_rpm_report.arguments[2]         = (fan_rpm_cmd / 100);
-
-        razer_usb_send(&fan_rpm_report);
-    }
-}
-
 /*---------------------------------------------------------------------------------*\
 | USB transfer functions                                                            |
 \*---------------------------------------------------------------------------------*/

Controllers/RazerController/RazerController/RazerController.h

@@ -246,8 +246,6 @@ public:
     void                    SetModeWave(unsigned char direction);
 
     bool                    SupportsBreathing();
-    void                    SetFanRPM(unsigned int fan_rpm_cmd);
-
     bool                    SupportsReactive();
     bool                    SupportsWave();
 
@@ -343,8 +341,6 @@ private:
     void                    razer_set_mode_static(unsigned char red, unsigned char grn, unsigned char blu);
     void                    razer_set_mode_wave(unsigned char direction);
 
-    void                    razer_set_fan_rpm_cmd(bool auto_fan_rpm, unsigned int fan_rpm_cmd);
-
     int                     razer_usb_receive(razer_report* report);
     int                     razer_usb_send(razer_report* report);
     int                     razer_usb_send_argb(razer_argb_report* report);

Controllers/RazerController/RazerControllerDetect.cpp

@@ -17,8 +17,6 @@
 #include "RazerKrakenController.h"
 #include "RazerDevices.h"
 #include "ResourceManager.h"
-#include "FanController.h"
-#include "FanController_Razer.h"
 #include "RGBController.h"
 #include "RGBController_Razer.h"
 #include "RGBController_RazerAddressable.h"
@@ -42,12 +40,6 @@ void DetectRazerControllers(hid_device_info* info, const std::string& name)
 
         RGBController_Razer* rgb_controller = new RGBController_Razer(controller);
         ResourceManager::get()->RegisterRGBController(rgb_controller);
-
-        if(info->product_id == RAZER_BLADE_14_2021_PID)
-        {
-            FanController_Razer* fan_controller = new FanController_Razer(controller);
-            ResourceManager::get()->RegisterFanController(fan_controller);
-        }
     }
 }   /* DetectRazerControllers() */
 

Controllers/ThermaltakeRiingController/FanController_ThermaltakeRiing.cpp

@@ -1,61 +0,0 @@
-/*-----------------------------------------*\
-|  FanController_ThermaltakeRiing.cpp       |
-|                                           |
-|  Generic Fan Interface for Thermaltake    |
-|  Riing controller                         |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 6/5/2020    |
-\*-----------------------------------------*/
-
-#include "FanController_ThermaltakeRiing.h"
-
-FanController_ThermaltakeRiing::FanController_ThermaltakeRiing(ThermaltakeRiingController* riing_ptr)
-{
-    riing = riing_ptr;
-
-    name        = "Thermaltake Riing";
-    description = "Thermaltake Riing Device";
-    version     = riing->GetFirmwareVersion();
-
-    for(std::size_t fan_index = 0; fan_index < THERMALTAKE_NUM_CHANNELS; fan_index++)
-    {
-        fan new_fan;
-        unsigned char  speed;
-        unsigned short rpm;
-
-        riing->GetFanData(fan_index + 1, &speed, &rpm);
-
-        new_fan.name        = "Thermaltake Riing Fan ";
-        new_fan.name.append(std::to_string(fan_index + 1));
-        new_fan.speed_min   = THERMALTAKE_FAN_SPEED_MIN;
-        new_fan.speed_max   = THERMALTAKE_FAN_SPEED_MAX;
-        new_fan.speed_cmd   = speed;
-        new_fan.rpm_rdg     = rpm;
-
-        fans.push_back(new_fan);
-    }
-
-
-    UpdateControl();
-}
-
-void FanController_ThermaltakeRiing::UpdateControl()
-{
-    for(std::size_t fan_index = 0; fan_index < fans.size(); fan_index++)
-    {
-        riing->SendFan(fan_index + 1, THERMALTAKE_FAN_MODE_FIXED, fans[fan_index].speed_cmd);
-    }
-}
-
-void FanController_ThermaltakeRiing::UpdateReading()
-{
-    for(std::size_t fan_index = 0; fan_index < fans.size(); fan_index++)
-    {
-        unsigned char  speed;
-        unsigned short rpm;
-
-        riing->GetFanData(fan_index + 1, &speed, &rpm);
-
-        fans[fan_index].rpm_rdg = rpm;
-    }
-}

Controllers/ThermaltakeRiingController/FanController_ThermaltakeRiing.h

@@ -1,24 +0,0 @@
-/*-----------------------------------------*\
-|  FanController_ThermaltakeRiing.h         |
-|                                           |
-|  Generic Fan Interface for Thermaltake    |
-|  Riing controller                         |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 6/5/2020    |
-\*-----------------------------------------*/
-
-#pragma once
-#include "FanController.h"
-#include "ThermaltakeRiingController.h"
-
-class FanController_ThermaltakeRiing : public FanController
-{
-public:
-    FanController_ThermaltakeRiing(ThermaltakeRiingController* riing_ptr);
-
-    void        UpdateControl();
-    void        UpdateReading();
-
-private:
-    ThermaltakeRiingController* riing;
-};

Controllers/ThermaltakeRiingController/ThermaltakeRiingController/ThermaltakeRiingController.cpp

@@ -44,41 +44,9 @@ std::string ThermaltakeRiingController::GetSerialString()
     return(StringUtils::wstring_to_string(serial_string));
 }
 
-void ThermaltakeRiingController::GetFanData
-    (
-        unsigned char       port,
-        unsigned char *     speed,
-        unsigned short *    rpm
-    )
-{
-    unsigned char usb_buf[65];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up Get Fan Data packet                            |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]   = 0x00;
-    usb_buf[0x01]   = 0x33;
-    usb_buf[0x02]   = 0x51;
-    usb_buf[0x03]   = port;
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 65);
-    hid_read(dev, usb_buf, 65);
-
-    *speed = usb_buf[0x04];
-    *rpm   = (usb_buf[0x06] << 8) + usb_buf[0x05];
-}
-
 std::string ThermaltakeRiingController::GetFirmwareVersion()
 {
-    unsigned char usb_buf[65];
+    unsigned char usb_buf[64];
 
     /*-----------------------------------------------------*\
     | Zero out buffer                                       |
@@ -88,15 +56,14 @@ std::string ThermaltakeRiingController::GetFirmwareVersion()
     /*-----------------------------------------------------*\
     | Set up Get Firmware Version packet                    |
     \*-----------------------------------------------------*/
-    usb_buf[0x00]   = 0x00;
-    usb_buf[0x01]   = 0x33;
-    usb_buf[0x02]   = 0x50;
+    usb_buf[0x00]   = 0x33;
+    usb_buf[0x01]   = 0x50;
 
     /*-----------------------------------------------------*\
     | Send packet                                           |
     \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 65);
-    hid_read(dev, usb_buf, 65);
+    hid_write(dev, usb_buf, 64);
+    hid_read(dev, usb_buf, 64);
 
     std::string ret_str = std::to_string(usb_buf[2]) + "." + std::to_string(usb_buf[3]) + "." + std::to_string(usb_buf[4]);
 
@@ -153,37 +120,6 @@ void ThermaltakeRiingController::SendInit()
     hid_read(dev, usb_buf, 65);
 }
 
-void ThermaltakeRiingController::SendFan
-    (
-        unsigned char       port,
-        unsigned char       mode,
-        unsigned char       speed
-    )
-{
-    unsigned char usb_buf[65];
-
-    /*-----------------------------------------------------*\
-    | Zero out buffer                                       |
-    \*-----------------------------------------------------*/
-    memset(usb_buf, 0x00, sizeof(usb_buf));
-
-    /*-----------------------------------------------------*\
-    | Set up RGB packet                                     |
-    \*-----------------------------------------------------*/
-    usb_buf[0x00]   = 0x00;
-    usb_buf[0x01]   = 0x32;
-    usb_buf[0x02]   = 0x51;
-    usb_buf[0x03]   = port;
-    usb_buf[0x04]   = mode;
-    usb_buf[0x05]   = speed;
-
-    /*-----------------------------------------------------*\
-    | Send packet                                           |
-    \*-----------------------------------------------------*/
-    hid_write(dev, usb_buf, 65);
-    hid_read(dev, usb_buf, 65);
-}
-
 void ThermaltakeRiingController::SendRGB
     (
         unsigned char       port,

Controllers/ThermaltakeRiingController/ThermaltakeRiingController/ThermaltakeRiingController.h

@@ -44,18 +44,6 @@ enum
     THERMALTAKE_SPEED_EXTREME       = 0x00
 };
 
-enum
-{
-    THERMALTAKE_FAN_MODE_FIXED      = 0x01,
-    THERMALTAKE_FAN_MODE_PWM        = 0x02
-};
-
-enum
-{
-    THERMALTAKE_FAN_SPEED_MIN       = 20,
-    THERMALTAKE_FAN_SPEED_MAX       = 100
-};
-
 #define THERMALTAKE_NUM_CHANNELS    5
 
 class ThermaltakeRiingController
@@ -68,23 +56,9 @@ public:
     std::string     GetSerialString();
     std::string     GetFirmwareVersion();
 
-    void            GetFanData
-                        (
-                            unsigned char       port,
-                            unsigned char *     speed,
-                            unsigned short *    rpm
-                        );
-
     void            SetChannelLEDs(unsigned char channel, RGBColor * colors, unsigned int num_colors);
     void            SetMode(unsigned char mode, unsigned char speed);
 
-    void            SendFan
-                        (
-                            unsigned char       port,
-                            unsigned char       mode,
-                            unsigned char       speed
-                        );
-
 private:
     hid_device*     dev;
 
@@ -94,14 +68,15 @@ private:
 
     void    SendInit();
 
-    void    SendRGB
-                (
-                    unsigned char       port,
-                    unsigned char       mode,
-                    unsigned char       speed,
-                    unsigned char       num_colors,
-                    unsigned char*      color_data
-                );
+    void SendRGB
+        (
+            unsigned char       port,
+            unsigned char       mode,
+            unsigned char       speed,
+            unsigned char       num_colors,
+            unsigned char*      color_data
+        );
 
+    void    SendFan();
     void    SendSave();
 };

Controllers/ThermaltakeRiingController/ThermaltakeRiingControllerDetect.cpp

@@ -15,8 +15,6 @@
 #include "Detector.h"
 #include "ThermaltakeRiingController.h"
 #include "ThermaltakeRiingQuadController.h"
-#include "FanController.h"
-#include "FanController_ThermaltakeRiing.h"
 #include "RGBController.h"
 #include "RGBController_ThermaltakeRiing.h"
 #include "RGBController_ThermaltakeRiingQuad.h"
@@ -42,10 +40,6 @@ void DetectThermaltakeRiingControllers(hid_device_info* info, const std::string&
         RGBController_ThermaltakeRiing* rgb_controller = new RGBController_ThermaltakeRiing(controller);
         // Constructor sets the name
         ResourceManager::get()->RegisterRGBController(rgb_controller);
-
-        FanController_ThermaltakeRiing* fan_controller = new FanController_ThermaltakeRiing(controller);
-
-        ResourceManager::get()->RegisterFanController(fan_controller);
     }
 }   /* DetectThermaltakeRiingControllers() */
 

FanController/FanController.h

@@ -1,52 +0,0 @@
-/*-----------------------------------------*\
-|  FanController.h                          |
-|                                           |
-|  Definitions and types for generic fan    |
-|  and pump controller interface            |
-|                                           |
-|  Adam Honse (CalcProgrammer1) 6/5/2020    |
-\*-----------------------------------------*/
-
-#pragma once
-
-#include <vector>
-#include <string>
-
-/*------------------------------------------------------------------*\
-| Fan Type                                                           |
-\*------------------------------------------------------------------*/
-typedef struct
-{
-    /*--------------------------------------------------------------*\
-    | Fan Information                                                |
-    \*--------------------------------------------------------------*/
-    std::string         name;           /* Fan name                 */
-    unsigned int        speed_cmd;      /* Speed command            */
-    unsigned int        prev_speed_cmd; /* Last speed command       */
-    unsigned int        speed_min;      /* Minimum speed command    */
-    unsigned int        speed_max;      /* Maximum speed command    */
-    unsigned int        rpm_rdg;        /* RPM reading              */
-} fan;
-
-class FanController
-{
-public:
-    std::string             name;           /* controller name          */
-    std::string             description;    /* controller description   */
-    std::string             version;        /* controller version       */
-    std::string             serial;         /* controller serial number */
-    std::string             location;       /* controller location      */
-    std::vector<fan>        fans;           /* Fans                     */
-
-    /*---------------------------------------------------------*\
-    | FanController base class constructor                      |
-    \*---------------------------------------------------------*/
-    //FanController();
-    //~FanController();
-
-    /*---------------------------------------------------------*\
-    | Functions to be implemented in device implementation      |
-    \*---------------------------------------------------------*/
-    virtual void UpdateControl()                                        = 0;
-    virtual void UpdateReading()                                        = 0;
-};

NetworkClient.cpp

@@ -196,7 +196,6 @@ void NetworkClient::StopClient()
     \*---------------------------------------------------------*/
     if(ConnectionThread)
     {
-        connection_cv.notify_all();
         ConnectionThread->join();
         delete ConnectionThread;
         ConnectionThread = nullptr;
@@ -212,8 +211,6 @@ void NetworkClient::ConnectionThreadFunction()
 {
     unsigned int requested_controllers;
 
-    std::unique_lock<std::mutex> lock(connection_mutex);
-
     /*---------------------------------------------------------*\
     | This thread manages the connection to the server          |
     \*---------------------------------------------------------*/
@@ -260,10 +257,7 @@ void NetworkClient::ConnectionThreadFunction()
             }
         }
 
-        /*-------------------------------------------------------------*\
-        | Double-check client_active as it could have changed           |
-        \*-------------------------------------------------------------*/
-        if(client_active && server_initialized == false && server_connected == true)
+        if(server_initialized == false && server_connected == true)
         {
             unsigned int timeout_counter     = 0;
             requested_controllers            = 0;
@@ -274,11 +268,7 @@ void NetworkClient::ConnectionThreadFunction()
             /*---------------------------------------------------------*\
             | Wait for server to connect                                |
             \*---------------------------------------------------------*/
-            connection_cv.wait_for(lock, 100ms);
-            if(!client_active)
-            {
-                break;
-            }
+            std::this_thread::sleep_for(100ms);
 
             /*---------------------------------------------------------*\
             | Request protocol version                                  |
@@ -290,11 +280,7 @@ void NetworkClient::ConnectionThreadFunction()
             \*---------------------------------------------------------*/
             while(!server_protocol_version_received)
             {
-                connection_cv.wait_for(lock, 5ms);
-                if(!client_active)
-                {
-                    break;
-                }
+                std::this_thread::sleep_for(5ms);
 
                 timeout_counter++;
 
@@ -325,11 +311,7 @@ void NetworkClient::ConnectionThreadFunction()
             \*---------------------------------------------------------*/
             while(!server_controller_count_received)
             {
-                connection_cv.wait_for(lock, 5ms);
-                if(!client_active)
-                {
-                    break;
-                }
+                std::this_thread::sleep_for(5ms);
             }
 
             printf("Client: Received controller count from server: %d\r\n", server_controller_count);
@@ -349,11 +331,7 @@ void NetworkClient::ConnectionThreadFunction()
                 \*---------------------------------------------------------*/
                 while(controller_data_received == false)
                 {
-                    connection_cv.wait_for(lock, 5ms);
-                    if(!client_active)
-                    {
-                        break;
-                    }
+                    std::this_thread::sleep_for(5ms);
                 }
 
                 requested_controllers++;
@@ -380,10 +358,7 @@ void NetworkClient::ConnectionThreadFunction()
             ClientInfoChanged();
         }
 
-        /*---------------------------------------------------------*\
-        | Wait 1 sec or until the thread is requested to stop       |
-        \*---------------------------------------------------------*/
-        connection_cv.wait_for(lock, 1s);
+        std::this_thread::sleep_for(1s);
     }
 }
 

NetworkClient.h

@@ -13,7 +13,6 @@
 
 #include <mutex>
 #include <thread>
-#include <condition_variable>
 #include "RGBController.h"
 #include "NetworkProtocol.h"
 #include "net_port.h"
@@ -94,7 +93,7 @@ private:
     net_port        port;
     std::string     port_ip;
     unsigned short  port_num;
-    std::atomic<bool> client_active;
+    bool            client_active;
     bool            controller_data_received;
     bool            server_connected;
     bool            server_initialized;
@@ -105,9 +104,6 @@ private:
     bool            change_in_progress;
     std::mutex      send_in_progress;
 
-    std::mutex      connection_mutex;
-    std::condition_variable connection_cv;
-
     std::thread *   ConnectionThread;
     std::thread *   ListenThread;
 

NetworkServer.h

@@ -99,8 +99,8 @@ public:
 protected:
     std::string                         host;
     unsigned short                      port_num;
-    std::atomic<bool>                   server_online;
-    std::atomic<bool>                   server_listening;
+    bool                                server_online;
+    bool                                server_listening;
 
     std::vector<RGBController *>&       controllers;
 

OpenRGB.pro

@@ -122,7 +122,6 @@ INCLUDEPATH +=
     super_io/                                                                                   \
     AutoStart/                                                                                  \
     KeyboardLayoutManager/                                                                      \
-    FanController/                                                                              \
     RGBController/                                                                              \
     qt/
 
@@ -160,7 +159,6 @@ HEADERS +=
     super_io/super_io.h                                                                         \
     AutoStart/AutoStart.h                                                                       \
     KeyboardLayoutManager/KeyboardLayoutManager.h                                               \
-    FanController/FanController.h                                                               \
     RGBController/RGBController.h                                                               \
     RGBController/RGBController_Dummy.h                                                         \
     RGBController/RGBControllerKeyNames.h                                                       \

README.md

@@ -166,4 +166,4 @@ While no code from these projects directly made its way into OpenRGB, these proj
   * k550-macos https://github.com/vookimedlo/ck550-macos/tree/master
   * luxafor-python https://github.com/vmitchell85/luxafor-python
   * dreamcheekyusb https://github.com/gbrayut/dreamcheekyusb
-  * razer-laptop-control: https://github.com/rnd-ash/razer-laptop-control
+  

ResourceManager.cpp

@@ -19,7 +19,6 @@
 #include <stdlib.h>
 #include <string>
 #include <hidapi.h>
-#include "cli.h"
 #include "ResourceManager.h"
 #include "ProfileManager.h"
 #include "LogManager.h"
@@ -83,10 +82,8 @@ ResourceManager::ResourceManager()
     detection_percent           = 100;
     detection_string            = "";
     detection_is_required       = false;
-    InitThread                  = nullptr;
     DetectDevicesThread         = nullptr;
     dynamic_detectors_processed = false;
-    init_finished               = false;
 
     SetupConfigurationDirectory();
 
@@ -171,13 +168,6 @@ ResourceManager::ResourceManager()
 ResourceManager::~ResourceManager()
 {
     Cleanup();
-
-    if(InitThread)
-    {
-        DetectDevicesThread->join();
-        delete DetectDevicesThread;
-        DetectDevicesThread = nullptr;
-    }
 }
 
 void ResourceManager::RegisterI2CBus(i2c_smbus_interface *bus)
@@ -191,11 +181,6 @@ std::vector<i2c_smbus_interface*> & ResourceManager::GetI2CBusses()
     return busses;
 }
 
-void ResourceManager::RegisterFanController(FanController *fan_controller)
-{
-    fan_controllers.push_back(fan_controller);
-}
-
 void ResourceManager::RegisterRGBController(RGBController *rgb_controller)
 {
     LOG_INFO("[%s] Registering RGB controller", rgb_controller->name.c_str());
@@ -259,11 +244,6 @@ void ResourceManager::UnregisterRGBController(RGBController* rgb_controller)
     UpdateDeviceList();
 }
 
-std::vector<FanController*> & ResourceManager::GetFanControllers()
-{
-    return fan_controllers;
-}
-
 std::vector<RGBController*> & ResourceManager::GetRGBControllers()
 {
     return rgb_controllers;
@@ -662,76 +642,6 @@ void ResourceManager::UnregisterNetworkClient(NetworkClient* network_client)
     UpdateDeviceList();
 }
 
-
-/******************************************************************************************\
-*                                                                                          *
-*   AttemptLocalConnection                                                                 *
-*                                                                                          *
-*       Attempts an SDK connection to the local server.  Returns true if success           *
-*                                                                                          *
-\******************************************************************************************/
-
-bool ResourceManager::AttemptLocalConnection()
-{
-    detection_percent = 0;
-    detection_string  = "Attempting local server connection...";
-    DetectionProgressChanged();
-
-    LOG_DEBUG("[ResourceManager] Attempting server connection...");
-
-    bool success = false;
-
-    NetworkClient * client = new NetworkClient(ResourceManager::get()->GetRGBControllers());
-
-    std::string titleString = "OpenRGB ";
-    titleString.append(VERSION_STRING);
-
-    client->SetName(titleString.c_str());
-    client->StartClient();
-
-    for(int timeout = 0; timeout < 10; timeout++)
-    {
-        if(client->GetConnected())
-        {
-            break;
-        }
-        std::this_thread::sleep_for(5ms);
-    }
-
-    if(!client->GetConnected())
-    {
-        LOG_TRACE("[main] Client failed to connect");
-        client->StopClient();
-        LOG_TRACE("[main] Client stopped");
-
-        delete client;
-
-        client = NULL;
-    }
-    else
-    {
-        ResourceManager::get()->RegisterNetworkClient(client);
-        LOG_TRACE("[main] Registered network client");
-
-        success = true;
-
-        /*-----------------------------------------------------*\
-        | Wait up to 5 seconds for the client connection to     |
-        | retrieve all controllers                              |
-        \*-----------------------------------------------------*/
-        for(int timeout = 0; timeout < 1000; timeout++)
-        {
-            if(client->GetOnline())
-            {
-                break;
-            }
-            std::this_thread::sleep_for(5ms);
-        }
-    }
-
-    return success;
-}
-
 std::vector<NetworkClient*>& ResourceManager::GetClients()
 {
     return(clients);
@@ -834,12 +744,7 @@ void ResourceManager::ProcessDynamicDetectors()
     dynamic_detectors_processed = true;
 }
 
-/*-----------------------------------------------------*\
-| Handle ALL pre-detection routines                     |
-| The system should be ready to start a detection thread|
-| (returns false if detection can not proceed)          |
-\*-----------------------------------------------------*/
-bool ResourceManager::ProcessPreDetection()
+void ResourceManager::DetectDevices()
 {
     /*-----------------------------------------------------*\
     | Process pre-detection hooks                           |
@@ -868,6 +773,7 @@ bool ResourceManager::ProcessPreDetection()
     | Update the detector settings                          |
     \*-----------------------------------------------------*/
     UpdateDetectorSettings();
+
     if(detection_enabled)
     {
         /*-------------------------------------------------*\
@@ -875,7 +781,7 @@ bool ResourceManager::ProcessPreDetection()
         \*-------------------------------------------------*/
         if(detection_is_required.load())
         {
-            return false;
+            return;
         }
 
         /*-------------------------------------------------*\
@@ -902,16 +808,6 @@ bool ResourceManager::ProcessPreDetection()
         | Start the device detection thread                 |
         \*-------------------------------------------------*/
         detection_is_required = true;
-
-        return true;
-    }
-    return false;
-}
-
-void ResourceManager::DetectDevices()
-{
-    if(ProcessPreDetection())
-    {
         DetectDevicesThread = new std::thread(&ResourceManager::DetectDevicesThreadFunction, this);
 
         /*-------------------------------------------------*\
@@ -920,37 +816,24 @@ void ResourceManager::DetectDevices()
         \*-------------------------------------------------*/
         std::this_thread::sleep_for(1ms);
     }
-
-    if(!detection_enabled)
+    else
     {
-        ProcessPostDetection();
+        /*-------------------------------------------------*\
+        | Signal that detection is complete                 |
+        \*-------------------------------------------------*/
+        detection_percent     = 100;
+        DetectionProgressChanged();
+
+        /*-----------------------------------------------------*\
+        | Call detection end callbacks                          |
+        \*-----------------------------------------------------*/
+        for(unsigned int callback_idx = 0; callback_idx < DetectionEndCallbacks.size(); callback_idx++)
+        {
+            DetectionEndCallbacks[callback_idx](DetectionEndCallbackArgs[callback_idx]);
+        }
     }
 }
 
-void ResourceManager::ProcessPostDetection()
-{
-    /*-------------------------------------------------*\
-    | Signal that detection is complete                 |
-    \*-------------------------------------------------*/
-    detection_percent     = 100;
-    DetectionProgressChanged();
-
-    LOG_INFO("[ResourceManager] Calling Post-detection callbacks");
-    /*-----------------------------------------------------*\
-    | Call detection end callbacks                          |
-    \*-----------------------------------------------------*/
-    for(unsigned int callback_idx = 0; callback_idx < DetectionEndCallbacks.size(); callback_idx++)
-    {
-        DetectionEndCallbacks[callback_idx](DetectionEndCallbackArgs[callback_idx]);
-    }
-
-    detection_is_required = false;
-
-    LOG_INFO("------------------------------------------------------");
-    LOG_INFO("|                Detection completed                 |");
-    LOG_INFO("------------------------------------------------------");
-}
-
 void ResourceManager::DisableDetection()
 {
     detection_enabled = false;
@@ -1496,10 +1379,26 @@ void ResourceManager::DetectDevicesThreadFunction()
     | Make sure that when the detection is done,        |
     | progress bar is set to 100%                       |
     \*-------------------------------------------------*/
-    ProcessPostDetection();
+    detection_is_required = false;
+    detection_percent = 100;
+    detection_string = "";
+
+    DetectionProgressChanged();
 
     DetectDeviceMutex.unlock();
 
+    /*-----------------------------------------------------*\
+    | Call detection end callbacks                          |
+    \*-----------------------------------------------------*/
+    for(unsigned int callback_idx = 0; callback_idx < DetectionEndCallbacks.size(); callback_idx++)
+    {
+        DetectionEndCallbacks[callback_idx](DetectionEndCallbackArgs[callback_idx]);
+    }
+
+    LOG_INFO("------------------------------------------------------");
+    LOG_INFO("|                Detection completed                 |");
+    LOG_INFO("------------------------------------------------------");
+
 #ifdef __linux__
     /*-------------------------------------------------*\
     | If the udev rules file is not installed, show a   |
@@ -1572,81 +1471,6 @@ void ResourceManager::StopDeviceDetection()
     detection_string = "Stopping";
 }
 
-void ResourceManager::Initialize(bool tryConnect, bool detectDevices, bool startServer, bool applyPostOptions)
-{
-    // Cache the parameters
-    // TODO: Possibly cache them in the CLI file somewhere
-    tryAutoConnect     = tryConnect;
-    detection_enabled  = detectDevices;
-    start_server       = startServer;
-    apply_post_options = applyPostOptions;
-
-    InitThread = new std::thread(&ResourceManager::InitThreadFunction, this);
-}
-
-void ResourceManager::InitThreadFunction()
-{
-    if(tryAutoConnect)
-    {
-        detection_percent = 0;
-        detection_string  = "Attempting server connection...";
-        DetectionProgressChanged();
-
-        // Disable detection if a local server was found
-        if(AttemptLocalConnection())
-        {
-            DisableDetection();
-        }
-        else
-        {
-            LOG_DEBUG("[ResourceManager] Local OpenRGB server connected, running in client mode");
-        }
-        tryAutoConnect = false;
-    }
-
-    /*---------------------------------------------------------*\
-    | Perform actual detection                                  |
-    | Done in the same thread (InitThread), as we need to wait  |
-    | for completion anyway                                     |
-    \*---------------------------------------------------------*/
-    if(detection_enabled)
-    {
-        LOG_DEBUG("[ResourceManager] Running standalone");
-        if(ProcessPreDetection())
-        {
-            DetectDevicesThreadFunction();
-        }
-    }
-    else
-    {
-        ProcessPostDetection();
-    }
-
-    if(start_server)
-    {
-        detection_percent = 100;
-        detection_string = "Starting server";
-        DetectionProgressChanged();
-
-        GetServer()->StartServer();
-        if(!GetServer()->GetOnline())
-        {
-            LOG_DEBUG("[ResourceManager] Server failed to start");
-        }
-    }
-
-    /*---------------------------------------------------------*\
-    | Process command line arguments after detection only if the|
-    | pre-detection parsing indicated it should be run          |
-    \*---------------------------------------------------------*/
-    if(apply_post_options)
-    {
-        cli_post_detection();
-    }
-
-    init_finished = true;
-}
-
 void ResourceManager::UpdateDetectorSettings()
 {
     json                detector_settings;
@@ -1748,19 +1572,6 @@ void ResourceManager::UpdateDetectorSettings()
     }
 }
 
-void ResourceManager::WaitForInitialization()
-{
-    /*-------------------------------------------------*\
-    | A reliable sychronization of this kind is         |
-    | impossible without the use of a `barrier`         |
-    | implementation, which is only introduced in C++20 |
-    \*-------------------------------------------------*/
-    while (!init_finished)
-    {
-        std::this_thread::sleep_for(1ms);
-    };
-}
-
 void ResourceManager::WaitForDeviceDetection()
 {
     DetectDeviceMutex.lock();

ResourceManager.h

@@ -29,7 +29,6 @@
 #define CONTROLLER_LIST_HID 0
 
 struct hid_device_info;
-class FanController;
 class NetworkClient;
 class NetworkServer;
 class ProfileManager;
@@ -137,11 +136,9 @@ public:
     void RegisterI2CBus(i2c_smbus_interface *);
     std::vector<i2c_smbus_interface*> & GetI2CBusses();
 
-    void RegisterFanController(FanController *fan_controller);
     void RegisterRGBController(RGBController *rgb_controller);
     void UnregisterRGBController(RGBController *rgb_controller);
 
-    std::vector<FanController*> & GetFanControllers();
     std::vector<RGBController*> & GetRGBControllers();
 
     void RegisterI2CBusDetector         (I2CBusDetectorFunction     detector);
@@ -194,15 +191,13 @@ public:
 
     void                            SetConfigurationDirectory(const filesystem::path &directory);
 
-    void ProcessPreDetectionHooks(); // Consider making private
-    void ProcessDynamicDetectors();  // Consider making private
+    void ProcessPreDetectionHooks();
+    void ProcessDynamicDetectors();
     void UpdateDeviceList();
     void DeviceListChanged();
     void DetectionProgressChanged();
     void I2CBusListChanged();
 
-    void Initialize(bool tryConnect, bool detectDevices, bool startServer, bool applyPostOptions);
-
     void Cleanup();
 
     void DetectDevices();
@@ -211,47 +206,23 @@ public:
 
     void StopDeviceDetection();
 
-    void WaitForInitialization();
     void WaitForDeviceDetection();
 
 private:
     void DetectDevicesThreadFunction();
     void UpdateDetectorSettings();
     void SetupConfigurationDirectory();
-    bool AttemptLocalConnection();
-    void InitThreadFunction();
-    bool ProcessPreDetection();
-    void ProcessPostDetection();
 
     /*-------------------------------------------------------------------------------------*\
     | Static pointer to shared instance of ResourceManager                                  |
     \*-------------------------------------------------------------------------------------*/
     static ResourceManager*                     instance;
 
-    /*-------------------------------------------------------------------------------------*\
-    | Auto connection permitting flag                                                       |
-    \*-------------------------------------------------------------------------------------*/
-    bool                                        tryAutoConnect;
-
     /*-------------------------------------------------------------------------------------*\
     | Detection enabled flag                                                                |
     \*-------------------------------------------------------------------------------------*/
     bool                                        detection_enabled;
 
-    /*-------------------------------------------------------------------------------------*\
-    | Auto connection permitting flag                                                       |
-    \*-------------------------------------------------------------------------------------*/
-    bool                                        start_server;
-
-    /*-------------------------------------------------------------------------------------*\
-    | Auto connection permitting flag                                                       |
-    \*-------------------------------------------------------------------------------------*/
-    bool                                        apply_post_options;
-    /*-------------------------------------------------------------------------------------*\
-    | Initialization completion flag                                                        |
-    \*-------------------------------------------------------------------------------------*/
-    std::atomic<bool>                           init_finished;
-
     /*-------------------------------------------------------------------------------------*\
     | Profile Manager                                                                       |
     \*-------------------------------------------------------------------------------------*/
@@ -267,11 +238,6 @@ private:
     \*-------------------------------------------------------------------------------------*/
     std::vector<i2c_smbus_interface*>           busses;
 
-    /*-------------------------------------------------------------------------------------*\
-    | FanControllers                                                                        |
-    \*-------------------------------------------------------------------------------------*/
-    std::vector<FanController*>                 fan_controllers;
-
     /*-------------------------------------------------------------------------------------*\
     | RGBControllers                                                                        |
     \*-------------------------------------------------------------------------------------*/
@@ -309,8 +275,7 @@ private:
     /*-------------------------------------------------------------------------------------*\
     | Detection Thread and Detection State                                                  |
     \*-------------------------------------------------------------------------------------*/
-    std::thread *                               DetectDevicesThread; // Used for rescan
-    std::thread *                               InitThread; // Used for initial scan, initial network scan, server startup
+    std::thread *                               DetectDevicesThread;
     std::mutex                                  DetectDeviceMutex;
 
     std::atomic<bool>                           detection_is_required;

cli.cpp

@@ -38,9 +38,6 @@ static std::string                 profile_save_filename = "";
 const unsigned int                 brightness_percentage = 100;
 const unsigned int                 speed_percentage      = 100;
 
-static int preserve_argc = 0;
-static char** preserve_argv = nullptr;
-
 enum
 {
     RET_FLAG_PRINT_HELP         = 1,
@@ -892,7 +889,7 @@ bool OptionSaveProfile(std::string argument)
     return(true);
 }
 
-int ProcessOptions(Options* options, std::vector<RGBController *>& rgb_controllers)
+int ProcessOptions(int argc, char* argv[], Options* options, std::vector<RGBController *>& rgb_controllers)
 {
     unsigned int ret_flags  = 0;
     int arg_index           = 1;
@@ -906,18 +903,18 @@ int ProcessOptions(Options* options, std::vector<RGBController *>& rgb_controlle
     wchar_t** argvw = CommandLineToArgvW(GetCommandLineW(), &fake_argc);
 #endif
 
-    while(arg_index < preserve_argc)
+    while(arg_index < argc)
     {
-        std::string option   = preserve_argv[arg_index];
+        std::string option   = argv[arg_index];
         std::string argument = "";
         filesystem::path arg_path;
 
         /*---------------------------------------------------------*\
         | Handle options that take an argument                      |
         \*---------------------------------------------------------*/
-        if(arg_index + 1 < preserve_argc)
+        if(arg_index + 1 < argc)
         {
-            argument = preserve_argv[arg_index + 1];
+            argument = argv[arg_index + 1];
 #ifdef _WIN32
             arg_path = argvw[arg_index + 1];
 #else
@@ -1269,9 +1266,6 @@ unsigned int cli_pre_detection(int argc, char* argv[])
     bool            server_start = false;
     bool            print_help   = false;
 
-    preserve_argc = argc;
-    preserve_argv = argv;
-
 #ifdef _WIN32
     int fake_argc;
     wchar_t** argvw = CommandLineToArgvW(GetCommandLineW(), &fake_argc);
@@ -1703,7 +1697,7 @@ unsigned int cli_pre_detection(int argc, char* argv[])
     return(ret_flags);
 }
 
-unsigned int cli_post_detection()
+unsigned int cli_post_detection(int argc, char *argv[])
 {
     /*---------------------------------------------------------*\
     | Wait for device detection                                 |
@@ -1719,7 +1713,7 @@ unsigned int cli_post_detection()
     | Process the argument options                              |
     \*---------------------------------------------------------*/
     Options options;
-    unsigned int ret_flags = ProcessOptions(&options, rgb_controllers);
+    unsigned int ret_flags = ProcessOptions(argc, argv, &options, rgb_controllers);
 
     /*---------------------------------------------------------*\
     | If the return flags are set, exit CLI mode without        |

cli.h

@@ -1,19 +0,0 @@
-#ifndef CLI_H
-#define CLI_H
-
-unsigned int cli_pre_detection(int argc, char* argv[]);
-unsigned int cli_post_detection();
-
-enum
-{
-    RET_FLAG_PRINT_HELP         = 1,
-    RET_FLAG_START_GUI          = 2,
-    RET_FLAG_I2C_TOOLS          = 4,
-    RET_FLAG_START_MINIMIZED    = 8,
-    RET_FLAG_NO_DETECT          = 16,
-    RET_FLAG_CLI_POST_DETECTION = 32,
-    RET_FLAG_START_SERVER       = 64,
-    RET_FLAG_NO_AUTO_CONNECT    = 128,
-};
-
-#endif

main.cpp

@@ -11,7 +11,6 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <thread>
-#include "cli.h"
 #include "ResourceManager.h"
 #include "NetworkClient.h"
 #include "NetworkServer.h"
@@ -33,6 +32,24 @@ io_connect_t macUSPCIO_driver_connection;
 
 using namespace std::chrono_literals;
 
+/*-------------------------------------------------------------*\
+| Command line functionality and return flags                   |
+\*-------------------------------------------------------------*/
+extern unsigned int cli_pre_detection(int argc, char *argv[]);
+extern unsigned int cli_post_detection(int argc, char *argv[]);
+
+enum
+{
+    RET_FLAG_PRINT_HELP         = 1,
+    RET_FLAG_START_GUI          = 2,
+    RET_FLAG_I2C_TOOLS          = 4,
+    RET_FLAG_START_MINIMIZED    = 8,
+    RET_FLAG_NO_DETECT          = 16,
+    RET_FLAG_CLI_POST_DETECTION = 32,
+    RET_FLAG_START_SERVER       = 64,
+    RET_FLAG_NO_AUTO_CONNECT    = 128,
+};
+
 /******************************************************************************************\
 *                                                                                          *
 *   InitializeTimerResolution (Win32)                                                      *
@@ -78,6 +95,66 @@ void WaitWhileServerOnline(NetworkServer* srv)
     };
 }
 
+/******************************************************************************************\
+*                                                                                          *
+*   AttemptLocalConnection                                                                 *
+*                                                                                          *
+*       Attempts an SDK connection to the local server.  Returns true if success           *
+*                                                                                          *
+\******************************************************************************************/
+
+bool AttemptLocalConnection()
+{
+    bool success = false;
+
+    NetworkClient * client = new NetworkClient(ResourceManager::get()->GetRGBControllers());
+
+    std::string titleString = "OpenRGB ";
+    titleString.append(VERSION_STRING);
+
+    client->SetName(titleString.c_str());
+    client->StartClient();
+
+    for(int timeout = 0; timeout < 10; timeout++)
+    {
+        if(client->GetConnected())
+        {
+            break;
+        }
+        std::this_thread::sleep_for(5ms);
+    }
+
+    if(!client->GetConnected())
+    {
+        client->StopClient();
+
+        delete client;
+
+        client = NULL;
+    }
+    else
+    {
+        ResourceManager::get()->RegisterNetworkClient(client);
+
+        success = true;
+
+        /*-----------------------------------------------------*\
+        | Wait up to 5 seconds for the client connection to     |
+        | retrieve all controllers                              |
+        \*-----------------------------------------------------*/
+        for(int timeout = 0; timeout < 1000; timeout++)
+        {
+            if(client->GetOnline())
+            {
+                break;
+            }
+            std::this_thread::sleep_for(5ms);
+        }
+    }
+
+    return success;
+}
+
 /******************************************************************************************\
 *                                                                                          *
 *   Install SMBus Driver WinRing0, If not already installed (Win32)                        *
@@ -202,11 +279,61 @@ int main(int argc, char* argv[])
     \*---------------------------------------------------------*/
     unsigned int ret_flags = cli_pre_detection(argc, argv);
 
-    ResourceManager::get()->Initialize(
-        !(ret_flags & RET_FLAG_NO_AUTO_CONNECT),
-        !(ret_flags & RET_FLAG_NO_DETECT),
-        ret_flags & RET_FLAG_START_SERVER,
-        ret_flags & RET_FLAG_CLI_POST_DETECTION);
+    /*---------------------------------------------------------*\
+    | Perform local connection and/or hardware detection if not |
+    | disabled from CLI                                         |
+    \*---------------------------------------------------------*/
+    if(!(ret_flags & RET_FLAG_NO_AUTO_CONNECT))
+    {
+        printf("Attempting to connect to local OpenRGB server.\r\n");
+
+        if(!AttemptLocalConnection())
+        {
+            printf("Local OpenRGB server unavailable.\r\n");
+        }
+        else
+        {
+            printf("Local OpenRGB server connected, running in client mode\r\n");
+
+            ResourceManager::get()->DisableDetection();
+        }
+    }
+
+    /*---------------------------------------------------------*\
+    | Perform hardware detection if not disabled from CLI       |
+    \*---------------------------------------------------------*/
+    if(!(ret_flags & RET_FLAG_NO_DETECT))
+    {
+        if(ResourceManager::get()->GetDetectionEnabled())
+        {
+            printf("Running standalone.\r\n");
+        }
+
+        ResourceManager::get()->DetectDevices();
+    }
+
+    /*---------------------------------------------------------*\
+    | Start the server if requested from CLI (this must be done |
+    | after attempting local connection!)                       |
+    \*---------------------------------------------------------*/
+    if(ret_flags & RET_FLAG_START_SERVER)
+    {
+        ResourceManager::get()->GetServer()->StartServer();
+
+        if(!ResourceManager::get()->GetServer()->GetOnline())
+        {
+            printf("Server failed to start\r\n");
+        }
+    }
+
+    /*---------------------------------------------------------*\
+    | Process command line arguments after detection only if the|
+    | pre-detection parsing indicated it should be run          |
+    \*---------------------------------------------------------*/
+    if(ret_flags & RET_FLAG_CLI_POST_DETECTION)
+    {
+        ret_flags |= cli_post_detection(argc, argv);
+    }
 
     /*---------------------------------------------------------*\
     | If the command line parser indicates that the GUI should  |
@@ -215,17 +342,14 @@ int main(int argc, char* argv[])
     \*---------------------------------------------------------*/
     if(ret_flags & RET_FLAG_START_GUI)
     {
-        LOG_TRACE("[main] initializing GUI");
         QApplication::setAttribute(Qt::AA_EnableHighDpiScaling);
         QApplication a(argc, argv);
         QGuiApplication::setDesktopFileName("org.openrgb.OpenRGB");
-        LOG_TRACE("[main] QApplication created");
 
         /*---------------------------------------------------------*\
         | Main UI widget                                            |
         \*---------------------------------------------------------*/
         Ui::OpenRGBDialog2 dlg;
-        LOG_TRACE("[main] Dialog created");
 
         if(ret_flags & RET_FLAG_I2C_TOOLS)
         {
@@ -246,21 +370,13 @@ int main(int argc, char* argv[])
             dlg.show();
         }
 
-        LOG_TRACE("[main] Ready to exec() the dialog");
         return a.exec();
     }
     else
     {
         if(ret_flags & RET_FLAG_START_SERVER)
         {
-            NetworkServer* server = ResourceManager::get()->GetServer();
-            ResourceManager::get()->WaitForInitialization();
-
-            /*---------------------------------------------------------*\
-            | The server is only started after detection finishes and   |
-            | it takes some time to get the server online - we wait     |
-            \*---------------------------------------------------------*/
-            if(!server->GetOnline())
+            if(!ResourceManager::get()->GetServer()->GetOnline())
             {
 #ifdef _MACOSX_X86_X64
                 CloseMacUSPCIODriver();
@@ -269,7 +385,7 @@ int main(int argc, char* argv[])
             }
             else
             {
-                WaitWhileServerOnline(server);
+                WaitWhileServerOnline(ResourceManager::get()->GetServer());
 #ifdef _MACOSX_X86_X64
                 CloseMacUSPCIODriver();
 #endif

pci_ids/pci_ids.h

@@ -616,7 +616,6 @@
 #define GIGABYTE_RTX4080_EAGLE_OC_SUB_DEV               0x40BE
 #define GIGABYTE_RTX4080_GAMING_OC_SUB_DEV              0x40BC
 #define GIGABYTE_RTX4080S_GAMING_OC_16GB_SUB_DEV        0x4140
-#define GIGABYTE_RTX4080S_AERO_OC_16GB_SUB_DEV          0x4141
 #define GIGABYTE_AORUS_RTX4080_MASTER_16G_SUB_DEV       0x40BD
 #define GIGABYTE_RTX4090_AERO_OC_24G_SUB_DEV            0x40E4
 #define GIGABYTE_RTX4090_GAMING_OC_24G_SUB_DEV          0x40BF

qt/OpenRGBDialog2/OpenRGBDialog2.cpp

@@ -13,7 +13,6 @@
 #include "PluginManager.h"
 #include "OpenRGBDevicePage.h"
 #include "OpenRGBDeviceInfoPage.h"
-#include "OpenRGBFanPage.h"
 #include "OpenRGBServerInfoPage.h"
 #include "OpenRGBConsolePage.h"
 #include "OpenRGBPluginContainer.h"
@@ -434,6 +433,7 @@ OpenRGBDialog2::OpenRGBDialog2(QWidget *parent) : QMainWindow(parent), ui(new Op
     plugin_manager = new PluginManager();
     plugin_manager->RegisterAddPluginCallback(&CreatePluginCallback, this);
     plugin_manager->RegisterRemovePluginCallback(&DeletePluginCallback, this);
+    plugin_manager->ScanAndLoadPlugins();
 
     /*-----------------------------------------------------*\
     | Add the Plugins page                                  |
@@ -1164,17 +1164,10 @@ void OpenRGBDialog2::ClearDevicesList()
             ui->InformationTabBar->removeTab(tab_idx);
         }
     }
-
-    for(int tab_idx = 0; tab_idx < ui->FanTabBar->count(); tab_idx++)
-    {
-        delete ui->FanTabBar->widget(tab_idx);
-    }
-    ui->FanTabBar->clear();
 }
 
 void OpenRGBDialog2::UpdateDevicesList()
 {
-    std::vector<FanController *> fan_controllers = ResourceManager::get()->GetFanControllers();
     std::vector<RGBController *> controllers = ResourceManager::get()->GetRGBControllers();
 
     /*-----------------------------------------------------*\
@@ -1340,45 +1333,6 @@ void OpenRGBDialog2::UpdateDevicesList()
             base_tab += 1;
         }
     }
-
-    /*-----------------------------------------------------*\
-    | Remove all remaining device tabs                      |
-    \*-----------------------------------------------------*/
-    tab_count = ui->FanTabBar->count();
-    for(unsigned int tab_idx = 0; tab_idx < tab_count; tab_idx++)
-    {
-        unsigned int remove_idx = ui->FanTabBar->count() - 1;
-        QWidget*     tab_widget = ui->FanTabBar->widget(remove_idx);
-
-        ui->FanTabBar->removeTab(remove_idx);
-
-        delete tab_widget;
-    }
-
-    /*-----------------------------------------------------*\
-    | Set up list of fan devices                            |
-    \*-----------------------------------------------------*/
-    QTabBar *FanTabBar = ui->FanTabBar->tabBar();
-
-    for(std::size_t fan_idx = 0; fan_idx < fan_controllers.size(); fan_idx++)
-    {
-        OpenRGBFanPage *NewPage = new OpenRGBFanPage(fan_controllers[fan_idx]);
-        ui->FanTabBar->addTab(NewPage, "");
-
-        /*-----------------------------------------------------*\
-        | Use Qt's HTML capabilities to display both icon and   |
-        | text in the tab label.  Choose icon based on device   |
-        | type and append device name string.                   |
-        \*-----------------------------------------------------*/
-        QString NewLabelString = QString::fromStdString(fan_controllers[fan_idx]->name);
-
-        QLabel *NewTabLabel = new QLabel();
-        NewTabLabel->setText(NewLabelString);
-        NewTabLabel->setIndent(20);
-        NewTabLabel->setGeometry(0, 0, 200, 20);
-
-        FanTabBar->setTabButton(fan_idx, QTabBar::LeftSide, NewTabLabel);
-    }
 }
 
 void OpenRGBDialog2::SetDialogMessage(PLogMessage msg)
@@ -1494,19 +1448,10 @@ void OpenRGBDialog2::onDetectionProgressUpdated()
 
 void OpenRGBDialog2::onDetectionEnded()
 {
-    /*-------------------------------------------------------*\
-    | Detect unconfigured zones and prompt for resizing       |
-    \*-------------------------------------------------------*/
+    /*-----------------------------------------------------*\
+    | Detect unconfigured zones and prompt for resizing     |
+    \*-----------------------------------------------------*/
     OpenRGBZonesBulkResizer::RunChecks(this);
-
-    /*-------------------------------------------------------*\
-    | Load plugins after the first detection (ONLY the first) |
-    \*-------------------------------------------------------*/
-    if(!plugins_loaded)
-    {
-        plugin_manager->ScanAndLoadPlugins();
-        plugins_loaded = true;
-    }
 }
 
 void OpenRGBDialog2::on_SetAllDevices(unsigned char red, unsigned char green, unsigned char blue)

qt/OpenRGBDialog2/OpenRGBDialog2.h

@@ -39,7 +39,6 @@
 #include "PluginManager.h"
 
 #include "i2c_smbus.h"
-#include "FanController.h"
 #include "LogManager.h"
 #include "RGBController.h"
 #include "ProfileManager.h"
@@ -109,7 +108,6 @@ private:
     OpenRGBNanoleafSettingsPage *NanoleafSettingsPage;
 
     bool ShowI2CTools = false;
-    bool plugins_loaded = false;
 
     /*-------------------------------------*\
     | System tray icon and menu             |
@@ -190,4 +188,5 @@ private slots:
     void on_InformationTabBar_currentChanged(int);
     void on_DevicesTabBar_currentChanged(int);
     void on_SettingsTabBar_currentChanged(int);
+
 };

qt/OpenRGBDialog2/OpenRGBDialog2.ui

@@ -60,23 +60,6 @@
         </item>
        </layout>
       </widget>
-      <widget class="QWidget" name="TabFans">
-       <attribute name="title">
-        <string>Fans</string>
-       </attribute>
-       <layout class="QGridLayout" name="gridLayout_6">
-        <item row="0" column="0">
-         <widget class="QTabWidget" name="FanTabBar">
-          <property name="tabPosition">
-           <enum>QTabWidget::West</enum>
-          </property>
-          <property name="currentIndex">
-           <number>-1</number>
-          </property>
-         </widget>
-        </item>
-       </layout>
-      </widget>
       <widget class="QWidget" name="TabSettings">
        <attribute name="title">
         <string>Settings</string>

qt/OpenRGBFanPage.cpp

@@ -1,119 +0,0 @@
-#include <QTimer>
-#include "OpenRGBFanPage.h"
-
-using namespace Ui;
-
-#ifdef _WIN32
-#include <Windows.h>
-#endif
-
-#ifdef __APPLE__
-#include <unistd.h>
-
-static void Sleep(unsigned int milliseconds)
-{
-    usleep(1000 * milliseconds);
-}
-#endif
-
-#ifdef __linux__
-#include <unistd.h>
-
-static void Sleep(unsigned int milliseconds)
-{
-    usleep(1000 * milliseconds);
-}
-#endif
-
-OpenRGBFanPage::OpenRGBFanPage(FanController *dev, QWidget *parent) :
-    QFrame(parent),
-    ui(new Ui::OpenRGBFanPageUi)
-{
-    ui->setupUi(this);
-
-    /*-----------------------------------------------------*\
-    | Store device pointer                                  |
-    \*-----------------------------------------------------*/
-    device = dev;
-
-    fan_thread_running = true;
-    FanUpdateThread = new std::thread(&OpenRGBFanPage::FanUpdateThreadFunction, this);
-
-    QTimer *timer = new QTimer(this);
-    connect(timer, &QTimer::timeout, this, QOverload<>::of(&OpenRGBFanPage::UpdateRPM));
-    timer->start(1000);
-
-    /*-----------------------------------------------------*\
-    | Fill in the fan box                                   |
-    \*-----------------------------------------------------*/
-    for (std::size_t i = 0; i < device->fans.size(); i++)
-    {
-        ui->FanBox->addItem(device->fans[i].name.c_str());
-        ui->SpeedSlider->setMinimum(device->fans[i].speed_min);
-        ui->SpeedSlider->setMaximum(device->fans[i].speed_max);
-        ui->SpeedSlider->setValue(device->fans[i].speed_cmd);
-        ui->RPMValue->setText(QString::number(device->fans[i].rpm_rdg));
-    }
-
-    /*-----------------------------------------------------*\
-    | Set to current values                                 |
-    \*-----------------------------------------------------*/
-    on_FanBox_currentIndexChanged(0);
-}
-
-OpenRGBFanPage::~OpenRGBFanPage()
-{
-    fan_thread_running = false;
-    FanUpdateThread->join();
-    delete ui;
-}
-
-void OpenRGBFanPage::FanUpdateThreadFunction()
-{
-    while(fan_thread_running)
-    {
-        device->UpdateControl();
-        device->UpdateReading();
-        Sleep(1000);
-    }
-}
-
-void OpenRGBFanPage::UpdateRPM()
-{
-    /*-----------------------------------------------------*\
-    | Read selected fan                                     |
-    \*-----------------------------------------------------*/
-    unsigned int selected_fan   = (unsigned int)ui->FanBox->currentIndex();
-
-    ui->RPMValue->setText(QString::number(device->fans[selected_fan].rpm_rdg));
-}
-
-void OpenRGBFanPage::on_FanBox_currentIndexChanged(int /*index*/)
-{
-    /*-----------------------------------------------------*\
-    | Read selected fan                                     |
-    \*-----------------------------------------------------*/
-    unsigned int selected_fan   = (unsigned int)ui->FanBox->currentIndex();
-
-    ui->SpeedSlider->setMinimum(device->fans[selected_fan].speed_min);
-    ui->SpeedSlider->setMaximum(device->fans[selected_fan].speed_max);
-    ui->SpeedSlider->setValue(device->fans[selected_fan].speed_cmd);
-
-    UpdateRPM();
-}
-
-void OpenRGBFanPage::on_ModeBox_currentIndexChanged(int /*index*/)
-{
-
-}
-
-void OpenRGBFanPage::on_SpeedSlider_valueChanged(int /* value */)
-{
-    /*-----------------------------------------------------*\
-    | Read selected fan                                     |
-    \*-----------------------------------------------------*/
-    unsigned int selected_fan   = (unsigned int)ui->FanBox->currentIndex();
-    unsigned int speed_cmd      = ui->SpeedSlider->value();
-
-    device->fans[selected_fan].speed_cmd = speed_cmd;
-}

qt/OpenRGBFanPage.h

@@ -1,45 +0,0 @@
-#ifndef OPENRGBFANPAGE_H
-#define OPENRGBFANPAGE_H
-
-#include "ui_OpenRGBFanPage.h"
-#include "FanController.h"
-
-#include <QFrame>
-#include <thread>
-
-namespace Ui {
-class OpenRGBFanPage;
-}
-
-class Ui::OpenRGBFanPage : public QFrame
-{
-    Q_OBJECT
-
-public:
-    explicit OpenRGBFanPage(FanController *dev, QWidget *parent = nullptr);
-    ~OpenRGBFanPage();
-    
-    void FanUpdateThreadFunction();
-    void SetDevice(unsigned char red, unsigned char green, unsigned char blue);
-    void SetCustomMode();
-    void UpdateDevice();
-    void UpdateMode();
-    void UpdateModeUi();
-
-private slots:
-    void UpdateRPM();
-    void on_FanBox_currentIndexChanged(int index);
-    void on_ModeBox_currentIndexChanged(int index);
-    void on_SpeedSlider_valueChanged(int value);
-
-private:
-    Ui::OpenRGBFanPageUi *ui;
-    FanController *device;
-
-    bool fan_thread_running;
-    std::thread* FanUpdateThread;
-
-signals:
-};
-
-#endif // OPENRGBDEVICEPAGE_H

qt/OpenRGBFanPage.ui

@@ -1,75 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<ui version="4.0">
- <class>OpenRGBFanPageUi</class>
- <widget class="QFrame" name="OpenRGBFanPageUi">
-  <property name="geometry">
-   <rect>
-    <x>0</x>
-    <y>0</y>
-    <width>683</width>
-    <height>300</height>
-   </rect>
-  </property>
-  <property name="windowTitle">
-   <string>Frame</string>
-  </property>
-  <layout class="QGridLayout" name="gridLayout">
-   <item row="3" column="1" colspan="3">
-    <widget class="QSlider" name="SpeedSlider">
-     <property name="orientation">
-      <enum>Qt::Horizontal</enum>
-     </property>
-    </widget>
-   </item>
-   <item row="0" column="1" colspan="3">
-    <widget class="QComboBox" name="FanBox"/>
-   </item>
-   <item row="0" column="0">
-    <widget class="QLabel" name="FanLabel">
-     <property name="text">
-      <string>Fan:</string>
-     </property>
-    </widget>
-   </item>
-   <item row="2" column="1" colspan="3">
-    <widget class="QComboBox" name="ModeBox"/>
-   </item>
-   <item row="3" column="0">
-    <widget class="QLabel" name="SpeedLabel">
-     <property name="text">
-      <string>Speed:</string>
-     </property>
-    </widget>
-   </item>
-   <item row="4" column="0">
-    <widget class="QLabel" name="RPMLabel">
-     <property name="text">
-      <string>RPM:</string>
-     </property>
-    </widget>
-   </item>
-   <item row="2" column="0">
-    <widget class="QLabel" name="ModeLabel">
-     <property name="text">
-      <string>Mode:</string>
-     </property>
-    </widget>
-   </item>
-   <item row="4" column="1" colspan="3">
-    <widget class="QLabel" name="RPMValue">
-     <property name="sizePolicy">
-      <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
-       <horstretch>0</horstretch>
-       <verstretch>0</verstretch>
-      </sizepolicy>
-     </property>
-     <property name="text">
-      <string>RPM Value</string>
-     </property>
-    </widget>
-   </item>
-  </layout>
- </widget>
- <resources/>
- <connections/>
-</ui>