indipowerinterface.h

Go to the documentation of this file.

/*
    Power Interface
    Copyright (C) 2025 Jasem Mutlaq ([email protected])
 
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2.1 of the License, or (at your option) any later version.
 
    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Lesser General Public License for more details.
 
    You should have received a copy of the GNU Lesser General Public
    License along with this library; if not, write to the Free Software
    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 
*/
 
#pragma once
 
#include "indibase.h"
#include "indipropertyswitch.h"
#include "indipropertynumber.h"
#include "indipropertytext.h"
#include <stdint.h>
 
using PI = INDI::PowerInterface;
 
namespace INDI
{
 
class PowerInterface
{
    public:
        enum
        {
            POWER_HAS_DC_OUT                    = 1 << 0,  
            POWER_HAS_DEW_OUT                   = 1 << 1,  
            POWER_HAS_VARIABLE_OUT              = 1 << 2,  
            POWER_HAS_VOLTAGE_SENSOR            = 1 << 3,  
            POWER_HAS_OVERALL_CURRENT           = 1 << 4,  
            POWER_HAS_PER_PORT_CURRENT          = 1 << 5,  
            POWER_HAS_LED_TOGGLE                = 1 << 6,  
            POWER_HAS_AUTO_DEW                  = 1 << 7,  
            POWER_HAS_POWER_CYCLE               = 1 << 8,  
            POWER_HAS_USB_TOGGLE                = 1 << 9,  
            POWER_HAS_OVER_VOLTAGE_PROTECTION   = 1 << 10, 
            POWER_HAS_OVER_VOTALGE_PROTECTION   = POWER_HAS_OVER_VOLTAGE_PROTECTION, 
            POWER_OFF_ON_DISCONNECT             = 1 << 11, 
        } PowerCapability;
 
        uint32_t GetCapability() const
        {
            return powerCapability;
        }
 
        void SetCapability(uint32_t cap)
        {
            powerCapability = cap;
        }
 
        bool HasDCOutput()
        {
            return powerCapability & POWER_HAS_DC_OUT;
        }
 
        bool HasDewOutput()
        {
            return powerCapability & POWER_HAS_DEW_OUT;
        }
 
        bool HasVariableOutput()
        {
            return powerCapability & POWER_HAS_VARIABLE_OUT;
        }
 
        bool HasVoltageSensor()
        {
            return powerCapability & POWER_HAS_VOLTAGE_SENSOR;
        }
 
        bool HasOverallCurrent()
        {
            return powerCapability & POWER_HAS_OVERALL_CURRENT;
        }
 
        bool HasPerPortCurrent()
        {
            return powerCapability & POWER_HAS_PER_PORT_CURRENT;
        }
 
        bool HasLEDToggle()
        {
            return powerCapability & POWER_HAS_LED_TOGGLE;
        }
 
        bool HasAutoDew()
        {
            return powerCapability & POWER_HAS_AUTO_DEW;
        }
 
        bool HasUSBPort()
        {
            return powerCapability & POWER_HAS_USB_TOGGLE;
        }
 
        bool HasOverVoltageProtection()
        {
            return powerCapability & POWER_HAS_OVER_VOLTAGE_PROTECTION;
        }
 
        bool ShouldPowerOffOnDisconnect()
        {
            return powerCapability & POWER_OFF_ON_DISCONNECT;
        }
 
    protected:
        explicit PowerInterface(DefaultDevice *defaultDevice);
 
        void initProperties(const char *groupName, size_t nPowerPorts = 0, size_t nDewPorts = 0, size_t nVariablePorts = 0,
                            size_t nAutoDewPorts = 0, size_t nUSBPorts = 0);
 
        bool updateProperties();
 
        bool processNumber(const char *dev, const char *name, double values[], char *names[], int n);
 
        bool processSwitch(const char *dev, const char *name, ISState *states, char *names[], int n);
 
        bool processText(const char *dev, const char *name, char *texts[], char *names[], int n);
 
        virtual bool SetPowerPort(size_t port, bool enabled);
 
        virtual bool SetDewPort(size_t port, bool enabled, double dutyCycle);
 
        virtual bool SetVariablePort(size_t port, bool enabled, double voltage);
 
        virtual bool SetLEDEnabled(bool enabled);
 
        virtual bool SetAutoDewEnabled(size_t port, bool enabled);
 
        virtual bool CyclePower();
 
        virtual bool SetUSBPort(size_t port, bool enabled);
 
        bool saveConfigItems(FILE *fp);
 
        // Power Sensors Indices
        enum
        {
            SENSOR_VOLTAGE,     
            SENSOR_CURRENT,     
            SENSOR_POWER,       
            N_POWER_SENSORS     
        };
 
        // Main Control - Overall Power Sensors
        INDI::PropertyNumber PowerSensorsNP {N_POWER_SENSORS};  // Voltage, Total Current, Total Power
 
        // Power Channels (12V DC)
        INDI::PropertySwitch PowerChannelsSP {0};                 // On/Off switches
        INDI::PropertyNumber PowerChannelCurrentNP {0}; // Current sensors (if per-channel current monitoring available)
        INDI::PropertyText PowerChannelLabelsTP {0};    // Custom labels
 
        // DEW/Dew Channels
        INDI::PropertySwitch DewChannelsSP {0};        // On/Off switches
        INDI::PropertyNumber DewChannelDutyCycleNP {0}; // Duty cycle control
        INDI::PropertyNumber DewChannelCurrentNP {0};   // Current sensors (if per-channel current monitoring available)
        INDI::PropertyText DewChannelLabelsTP {0};      // Custom labels
 
        // Variable Voltage Channels
        INDI::PropertySwitch VariableChannelsSP {0};    // On/Off switches
        INDI::PropertyNumber VariableChannelVoltsNP {0}; // Voltage control
        INDI::PropertyText VariableChannelLabelsTP {0};  // Custom labels
 
        // Over Voltage Protection
        INDI::PropertyNumber OverVoltageProtectionNP {1};
 
        // Power Off on Disconnect
        INDI::PropertySwitch PowerOffOnDisconnectSP {2};
 
        // LED Control
        INDI::PropertySwitch LEDControlSP {2};
 
        // Auto Dew Control
        INDI::PropertySwitch AutoDewSP {0};
 
        // USB Ports
        INDI::PropertySwitch USBPortSP {0};
        INDI::PropertyText USBPortLabelsTP {0};
 
        // Power Cycle All
        INDI::PropertySwitch PowerCycleAllSP {1};
 
        uint32_t powerCapability = 0;
        DefaultDevice *m_defaultDevice { nullptr };
 
        const char *POWER_TAB {"Power"};
        const char *DEW_TAB {"Dew"};
        const char *USB_TAB {"USB"};
        const char *VARIABLE_TAB {"Variable"};
};
 
}