Publish LumaOps source

2026-09-03 01:18:36 +02:00
commit 7f1c0e5f71
2363 changed files with 501543 additions and 0 deletions
@@ -0,0 +1,53 @@
+/*---------------------------------------------------------*\
+| FanBusController.cpp                                      |
+|                                                           |
+|   Driver for FanBus devices                               |
+|                                                           |
+|   Adam Honse (calcprogrammer1@gmail.com)      12 Jan 2021 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-or-later               |
+\*---------------------------------------------------------*/
+
+#include "FanBusController.h"
+
+FanBusController::FanBusController(FanBusInterface* bus_ptr, unsigned char dev_addr)
+{
+    bus = bus_ptr;
+    dev = dev_addr;
+}
+
+FanBusController::~FanBusController()
+{
+    delete bus;
+}
+
+std::string FanBusController::GetLocation()
+{
+    std::string location_string;
+
+    location_string = "FanBus: ";
+    location_string.append(bus->GetPort());
+    location_string.append(":");
+    location_string.append(std::to_string(dev));
+
+    return(location_string);
+}
+
+void FanBusController::SetLEDs(std::vector<RGBColor> colors)
+{
+    for(unsigned int led_idx = 0; led_idx < 4; led_idx++)
+    {
+        unsigned char red = RGBGetRValue(colors[led_idx]);
+        unsigned char grn = RGBGetGValue(colors[led_idx]);
+        unsigned char blu = RGBGetBValue(colors[led_idx]);
+
+        bus->write_queue(dev, 0x10 + (led_idx * 3), red);
+        bus->write_queue(dev, 0x11 + (led_idx * 3), grn);
+        bus->write_queue(dev, 0x12 + (led_idx * 3), blu);
+    }
+
+    bus->write_queue(dev, 0x0C,  0x01);
+
+    bus->process_queue();
+}
@@ -0,0 +1,32 @@
+/*---------------------------------------------------------*\
+| FanBusController.h                                        |
+|                                                           |
+|   Driver for FanBus devices                               |
+|                                                           |
+|   Adam Honse (calcprogrammer1@gmail.com)      12 Jan 2021 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-or-later               |
+\*---------------------------------------------------------*/
+
+#pragma once
+
+#include <vector>
+#include "FanBusInterface.h"
+#include "RGBController.h"
+
+class FanBusController
+{
+public:
+    FanBusController(FanBusInterface* bus_ptr, unsigned char dev_addr);
+    ~FanBusController();
+
+    std::string GetLocation();
+
+    void        SetLEDs(std::vector<RGBColor> colors);
+
+private:
+    std::string         port_name;
+    FanBusInterface*    bus;
+    unsigned char       dev;
+};
@@ -0,0 +1,54 @@
+/*---------------------------------------------------------*\
+| FanBusControllerDetect.cpp                                |
+|                                                           |
+|   Detector for FanBus devices                             |
+|                                                           |
+|   Adam Honse (calcprogrammer1@gmail.com)      12 Jan 2021 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-or-later               |
+\*---------------------------------------------------------*/
+
+#include "Detector.h"
+#include "FanBusController.h"
+#include "RGBController_FanBus.h"
+#include "SettingsManager.h"
+
+void DetectFanBusControllers()
+{
+    FanBusInterface*    new_interface;
+    json                fanbus_settings;
+
+    /*-------------------------------------------------*\
+    | Get LED Strip settings from settings manager      |
+    \*-------------------------------------------------*/
+    fanbus_settings = ResourceManager::get()->GetSettingsManager()->GetSettings("FanBusDevices");
+
+    /*-------------------------------------------------*\
+    | If the LEDStrip settings contains devices, process|
+    \*-------------------------------------------------*/
+    if(fanbus_settings.contains("devices"))
+    {
+        for(unsigned int device_idx = 0; device_idx < fanbus_settings["devices"].size(); device_idx++)
+        {
+            if(fanbus_settings["devices"][device_idx].contains("port"))
+            {
+                std::string port_val = fanbus_settings["devices"][device_idx]["port"];
+
+                new_interface     = new FanBusInterface(port_val.c_str());
+
+                std::vector<unsigned char> detected_controllers = new_interface->DetectControllers();
+
+                for(unsigned int controller_idx = 0; controller_idx < detected_controllers.size(); controller_idx++)
+                {
+                    FanBusController*     controller     = new FanBusController(new_interface, detected_controllers[controller_idx]);
+                    RGBController_FanBus* rgb_controller = new RGBController_FanBus(controller);
+
+                    ResourceManager::get()->RegisterRGBController(rgb_controller);
+                }
+            }
+        }
+    }
+}
+
+REGISTER_DETECTOR("FanBus", DetectFanBusControllers);
@@ -0,0 +1,149 @@
+/*---------------------------------------------------------*\
+| FanBusInterface.cpp                                       |
+|                                                           |
+|   Interface for FanBus devices                            |
+|                                                           |
+|   Adam Honse (calcprogrammer1@gmail.com)      12 Jan 2021 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-or-later               |
+\*---------------------------------------------------------*/
+
+#include <chrono>
+#include <thread>
+#include "FanBusInterface.h"
+
+using namespace std::chrono_literals;
+
+FanBusInterface::FanBusInterface(const char* portname)
+{
+    port_name  = portname;
+    serialport = new serial_port(portname, 38400);
+
+    /*-----------------------------------------------------*\
+    | Flush any data in the receive queue                   |
+    \*-----------------------------------------------------*/
+    unsigned char read_buf[6];
+
+    while(serialport->serial_read((char *)read_buf, 6) > 0)
+    {
+
+    }
+
+    read_buf[0] = 0xFF;
+
+    serialport->serial_write((char *)read_buf, 1);
+
+    std::this_thread::sleep_for(10ms);
+
+    int test = serialport->serial_read((char *)read_buf, 1);
+
+    if(test > 0)
+    {
+        half_duplex = true;
+    }
+    else
+    {
+        half_duplex = false;
+    }
+}
+
+FanBusInterface::~FanBusInterface()
+{
+    serialport->serial_close();
+    delete serialport;
+}
+
+std::string FanBusInterface::GetPort()
+{
+    return(port_name);
+}
+
+int FanBusInterface::read
+    (
+        unsigned char dev_addr,
+        unsigned char int_addr
+    )
+{
+    unsigned char fanbus_msg[] = { 0x01, int_addr, dev_addr, 0x00, 0xFF };
+
+    serialport->serial_write((char *)fanbus_msg, 5);
+
+    std::this_thread::sleep_for(10ms);
+
+    char read_buf[6];
+
+    if(half_duplex)
+    {
+        if(serialport->serial_read(read_buf, 6) == 6)
+        {
+            return(read_buf[5]);
+        }
+        else
+        {
+            return(-1);
+        }
+    }
+    else
+    {
+        if(serialport->serial_read(read_buf, 1) == 1)
+        {
+            return(read_buf[0]);
+        }
+        else
+        {
+            return(-1);
+        }
+    }
+}
+
+int FanBusInterface::write
+    (
+        unsigned char dev_addr,
+        unsigned char int_addr,
+        unsigned char val
+    )
+{
+    unsigned char fanbus_msg[] = { 0x00, int_addr, dev_addr, val, 0xFF };
+
+    return(serialport->serial_write((char *)fanbus_msg, 5));
+}
+
+void FanBusInterface::write_queue
+    (
+        unsigned char dev_addr,
+        unsigned char int_addr,
+        unsigned char val
+    )
+{
+    unsigned char fanbus_msg[] = { 0x00, int_addr, dev_addr, val, 0xFF };
+
+    for(unsigned int i = 0; i < sizeof(fanbus_msg); i++)
+    {
+        fanbus_msg_queued.push_back(fanbus_msg[i]);
+    }
+}
+
+int FanBusInterface::process_queue()
+{
+    int return_val = serialport->serial_write((char *)&fanbus_msg_queued[0], (int)fanbus_msg_queued.size());
+
+    fanbus_msg_queued.clear();
+
+    return(return_val);
+}
+
+std::vector<unsigned char> FanBusInterface::DetectControllers()
+{
+    std::vector<unsigned char> detected_controllers;
+
+    for(unsigned int dev_addr = 0x03; dev_addr < 0xFF; dev_addr++)
+    {
+        if(read(dev_addr, 0x00) >= 0)
+        {
+            detected_controllers.push_back(dev_addr);
+        }
+    }
+
+    return(detected_controllers);
+}
@@ -0,0 +1,54 @@
+/*---------------------------------------------------------*\
+| FanBusInterface.h                                         |
+|                                                           |
+|   Interface for FanBus devices                            |
+|                                                           |
+|   Adam Honse (calcprogrammer1@gmail.com)      12 Jan 2021 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-or-later               |
+\*---------------------------------------------------------*/
+
+#include <string>
+#include <vector>
+#include "serial_port.h"
+
+class FanBusInterface
+{
+public:
+    FanBusInterface(const char* portname);
+    ~FanBusInterface();
+
+    std::vector<unsigned char> DetectControllers();
+
+    std::string GetPort();
+
+    int         read
+                (
+                    unsigned char dev_addr,
+                    unsigned char int_addr
+                );
+
+    int         write
+                (
+                    unsigned char dev_addr,
+                    unsigned char int_addr,
+                    unsigned char val
+                );
+
+    void        write_queue
+                (
+                    unsigned char dev_addr,
+                    unsigned char int_addr,
+                    unsigned char val
+                );
+
+    int         process_queue();
+
+private:
+    serial_port *   serialport;
+    std::string     port_name;
+    bool            half_duplex;
+
+    std::vector<unsigned char>  fanbus_msg_queued;
+};
@@ -0,0 +1,97 @@
+/*---------------------------------------------------------*\
+| RGBController_FanBus.cpp                                  |
+|                                                           |
+|   RGBController for FanBus devices                        |
+|                                                           |
+|   Adam Honse (calcprogrammer1@gmail.com)      12 Jan 2021 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-or-later               |
+\*---------------------------------------------------------*/
+
+#include "RGBController_FanBus.h"
+
+/**------------------------------------------------------------------*\
+    @name FanBus
+    @category Cooler
+    @type Serial
+    @save :x:
+    @direct :white_check_mark:
+    @effects :x:
+    @detectors DetectFanBusControllers
+    @comment
+\*-------------------------------------------------------------------*/
+
+RGBController_FanBus::RGBController_FanBus(FanBusController* controller_ptr)
+{
+    controller  = controller_ptr;
+
+    name        = "FanBus Device";
+    type        = DEVICE_TYPE_COOLER;
+    description = "FanBus Device";
+    location    = controller->GetLocation();
+
+    mode Direct;
+    Direct.name       = "Direct";
+    Direct.value      = 0;
+    Direct.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    Direct.color_mode = MODE_COLORS_PER_LED;
+    modes.push_back(Direct);
+
+    SetupZones();
+}
+
+RGBController_FanBus::~RGBController_FanBus()
+{
+    delete controller;
+}
+
+void RGBController_FanBus::SetupZones()
+{
+    zone led_zone;
+    led_zone.name       = "Fan LEDs";
+    led_zone.type       = ZONE_TYPE_SINGLE;
+    led_zone.leds_min   = 4;
+    led_zone.leds_max   = 4;
+    led_zone.leds_count = 4;
+    led_zone.matrix_map = NULL;
+    zones.push_back(led_zone);
+
+    for(unsigned int led_idx = 0; led_idx < led_zone.leds_count; led_idx++)
+    {
+        led new_led;
+        new_led.name = "LED ";
+        new_led.name.append(std::to_string(led_idx));
+
+        leds.push_back(new_led);
+    }
+
+    SetupColors();
+}
+
+void RGBController_FanBus::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+    /*---------------------------------------------------------*\
+    | This device does not support resizing zones               |
+    \*---------------------------------------------------------*/
+}
+
+void RGBController_FanBus::DeviceUpdateLEDs()
+{
+    controller->SetLEDs(colors);
+}
+
+void RGBController_FanBus::UpdateZoneLEDs(int /*zone*/)
+{
+    controller->SetLEDs(colors);
+}
+
+void RGBController_FanBus::UpdateSingleLED(int /*led*/)
+{
+    controller->SetLEDs(colors);
+}
+
+void RGBController_FanBus::DeviceUpdateMode()
+{
+
+}
@@ -0,0 +1,35 @@
+/*---------------------------------------------------------*\
+| RGBController_FanBus.h                                    |
+|                                                           |
+|   RGBController for FanBus devices                        |
+|                                                           |
+|   Adam Honse (calcprogrammer1@gmail.com)      12 Jan 2021 |
+|                                                           |
+|   This file is part of the OpenRGB project                |
+|   SPDX-License-Identifier: GPL-2.0-or-later               |
+\*---------------------------------------------------------*/
+
+#pragma once
+
+#include "RGBController.h"
+#include "FanBusController.h"
+
+class RGBController_FanBus : public RGBController
+{
+public:
+    RGBController_FanBus(FanBusController* controller_ptr);
+    ~RGBController_FanBus();
+
+    void        SetupZones();
+
+    void        ResizeZone(int zone, int new_size);
+
+    void        DeviceUpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        DeviceUpdateMode();
+
+private:
+    FanBusController*   controller;
+};