defaultdevice.h

Go to the documentation of this file.

/*******************************************************************************
  Copyright(c) 2011 Jasem Mutlaq. All rights reserved.
 
 This library is free software; you can redistribute it and/or
 modify it under the terms of the GNU Library General Public
 License version 2 as published by the Free Software Foundation.
 
 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
 Library General Public License for more details.
 
 You should have received a copy of the GNU Library General Public License
 along with this library; see the file COPYING.LIB.  If not, write to
 the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 Boston, MA 02110-1301, USA.
*******************************************************************************/
 
#pragma once
 
#include "parentdevice.h"
#include "indidriver.h"
#include "indilogger.h"
 
#include <stdint.h>
#include <any>
#include <string>
#include <functional>
 
namespace Connection
{
class Interface;
class Serial;
class TCP;
class I2C;
}
extern const char *COMMUNICATION_TAB;
 
extern const char *MAIN_CONTROL_TAB;
 
extern const char *CONNECTION_TAB;
 
extern const char *MOTION_TAB;
 
extern const char *DATETIME_TAB;
 
extern const char *SITE_TAB;
 
extern const char *OPTIONS_TAB;
 
extern const char *FILTER_TAB;
 
extern const char *FOCUS_TAB;
 
extern const char *GUIDE_TAB;
 
extern const char *ALIGNMENT_TAB;
 
extern const char *SATELLITE_TAB;
 
extern const char *INFO_TAB;
 
namespace INDI
{
 
class DefaultDevicePrivate;
class DefaultDevice : public ParentDevice
{
        DECLARE_PRIVATE(DefaultDevice)
 
    public:
        DefaultDevice();
        virtual ~DefaultDevice() override = default;
 
    public:
        void addAuxControls();
 
        void addDebugControl();
 
        void addSimulationControl();
 
        void addConfigurationControl();
 
        void addPollPeriodControl();
 
        void addNicknameControl();
 
    public:
        void resetProperties();
 
        INDI_DEPRECATED("Use defineProperty(INDI::Property &).")
        void defineNumber(INumberVectorProperty *nvp);
        void defineProperty(INumberVectorProperty *property);
 
        INDI_DEPRECATED("Use defineProperty(INDI::Property &).")
        void defineText(ITextVectorProperty *tvp);
        void defineProperty(ITextVectorProperty *property);
 
        INDI_DEPRECATED("Use defineProperty(INDI::Property &).")
        void defineSwitch(ISwitchVectorProperty *svp);
        void defineProperty(ISwitchVectorProperty *property);
 
        INDI_DEPRECATED("Use defineProperty(INDI::Property &).")
        void defineLight(ILightVectorProperty *lvp);
        void defineProperty(ILightVectorProperty *property);
 
        INDI_DEPRECATED("Use defineProperty(INDI::Property &).")
        void defineBLOB(IBLOBVectorProperty *bvp);
        void defineProperty(IBLOBVectorProperty *property);
 
        void defineProperty(INDI::Property &property);
        virtual bool deleteProperty(const char *propertyName);
 
        bool deleteProperty(INDI::Property &property);
 
    public:
        virtual void setConnected(bool status, IPState state = IPS_OK, const char *msg = nullptr);
 
        int SetTimer(uint32_t ms);
 
        void RemoveTimer(int id);
 
        virtual void TimerHit();
 
        virtual const char *getDriverExec();
 
        virtual const char *getDriverName();
 
        void setVersion(uint16_t vMajor, uint16_t vMinor);
 
        uint16_t getMajorVersion() const;
 
        uint16_t getMinorVersion() const;
 
    public:
        virtual void ISGetProperties(const char *dev);
 
        virtual bool ISNewSwitch(const char *dev, const char *name, ISState *states, char *names[], int n);
 
        virtual bool ISNewNumber(const char *dev, const char *name, double values[], char *names[], int n);
 
        virtual bool ISNewText(const char *dev, const char *name, char *texts[], char *names[], int n);
 
        virtual bool ISNewBLOB(const char *dev, const char *name, int sizes[], int blobsizes[], char *blobs[],
                               char *formats[], char *names[], int n);
 
        virtual bool ISSnoopDevice(XMLEle *root);
 
        bool ISNewProperty(INDI::Property &property, const std::string &elementName, const std::any &value);
 
        template<typename PropertyType, typename ValueType>
        bool updateProperty(PropertyType& property, ValueType* values, char* names[], int n,
                            std::function<bool()> updater, bool saveConfig = false)
        {
            if (property.isUpdated(values, names, n))
            {
                if (updater())
                {
                    property.update(values, names, n);
                    property.setState(IPS_OK);
                    if (saveConfig)
                        this->saveConfig(property);
                    property.apply();
                    return true;
                }
                else
                {
                    property.setState(IPS_ALERT);
                    property.apply();
                    return false;
                }
            }
            else
            {
                // If nothing is updated, just accept as-is
                property.setState(IPS_OK);
                property.apply();
                return false;
            }
        }
 
        uint32_t getDriverInterface() const;
 
        void setDriverInterface(uint32_t value);
 
    public:
        void watchDevice(const char *deviceName, const std::function<void (INDI::BaseDevice)> &callback);
 
    protected:
        void setDynamicPropertiesBehavior(bool defineEnabled, bool deleteEnabled);
 
        // Configuration
 
        virtual bool loadConfig(bool silent = false, const char *property = nullptr);
 
        bool loadConfig(INDI::Property &property);
 
        virtual bool saveConfig(bool silent = false, const char *property = nullptr);
 
        bool saveConfig(INDI::Property &property);
 
        virtual bool purgeConfig();
 
        virtual bool saveConfigItems(FILE *fp);
 
        virtual bool saveAllConfigItems(FILE *fp);
 
        virtual bool loadDefaultConfig();
 
        // Simulatin & Debug
 
        void setDebug(bool enable);
 
        void setSimulation(bool enable);
 
        virtual void debugTriggered(bool enable);
 
        virtual void simulationTriggered(bool enable);
 
        bool isDebug() const;
 
        bool isSimulation() const;
 
        virtual bool initProperties();
 
        virtual bool updateProperties();
 
        virtual bool Connect();
 
        virtual bool Disconnect();
 
        void registerConnection(Connection::Interface *newConnection);
 
        bool unRegisterConnection(Connection::Interface *existingConnection);
 
        Connection::Interface *getActiveConnection();
 
        void setActiveConnection(Connection::Interface *existingConnection);
 
    protected: // polling
        void setDefaultPollingPeriod(uint32_t msec);
 
        void setPollingPeriodRange(uint32_t minimum, uint32_t maximum);
 
        uint32_t getPollingPeriod() const;
 
        void setCurrentPollingPeriod(uint32_t msec);
 
        uint32_t getCurrentPollingPeriod() const;
 
        /* direct access to POLLMS is deprecated, please use setCurrentPollingPeriod/getCurrentPollingPeriod */
        uint32_t &refCurrentPollingPeriod() __attribute__((deprecated));
        uint32_t  refCurrentPollingPeriod() const __attribute__((deprecated));
#define POLLMS refCurrentPollingPeriod()
 
    protected:
        bool isConfigLoading() const;
 
        bool isInitializationComplete() const;
 
        void syncDriverInfo();
 
        virtual const char *getDefaultName() = 0;
 
        void setDeviceNickname(const char *nick);
 
        const char *getDeviceNickname();
 
        const char *lookupDeviceNicknameFromId(const char *identifier, const char *device = nullptr);
 
        bool setDeviceNicknameFromId(const char *identifier);
 
        void saveNicknameId(const char *nickname, const char *identifier);
 
        virtual void nicknameSet(const char *nickname);
 
    private:
        // Connection Plugins
        friend class Connection::Serial;
        friend class Connection::TCP;
        friend class Connection::I2C;
        friend class FilterInterface;
        friend class FocuserInterface;
        friend class WeatherInterface;
        friend class LightBoxInterface;
        friend class OutputInterface;
        friend class InputInterface;
        friend class PowerInterface;
        friend class IMUInterface;
        friend class PACInterface;
 
    protected:
        DefaultDevice(const std::shared_ptr<DefaultDevicePrivate> &dd);
};
 
}