scopedome_dome.h

Go to the documentation of this file.

/*******************************************************************************
 ScopeDome Dome INDI Driver
 
 Copyright(c) 2017-2024 Jarno Paananen. All rights reserved.
 
 based on:
 
 ScopeDome Windows ASCOM driver version 5.1.30
 
 and
 
 Copyright(c) 2014 Jasem Mutlaq. All rights reserved.
 
 Baader Planetarium Dome INDI Driver
 
 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 "indidome.h"
#include "indipropertyswitch.h"
#include "indipropertynumber.h"
#include "indipropertytext.h"
 
#include <string>
#include <vector>
 
class ScopeDomeCard
{
    public:
 
        enum ScopeDomeStatusBits
        {
            STATUS_RESET            = 1,
            STATUS_MOVING           = 2,
            STATUS_HOMING           = 4,
            STATUS_OPEN1            = 8,
            STATUS_OPEN2            = 0x10,
            STATUS_AUTO_CLOSE1      = 0x20,
            STATUS_AUTO_CLOSE2      = 0x40,
            STATUS_CALIBRATING      = 0x80,
            STATUS_FINDING_POWER    = 0x100,
            STATUS_CALIBRATION_STOP = 0x200
        };
 
        enum AbstractInput
        {
            HOME,
            OPEN1,
            CLOSED1,
            OPEN2,
            CLOSED2,
            ROTARY_LINK
        };
 
        enum AbstractOutput
        {
            RESET,
            CCW,
            CW,
        };
 
        enum ShutterOperation
        {
            OPEN_SHUTTER = 0,
            CLOSE_SHUTTER = 1,
            STOP_SHUTTER = 2
        };
 
        struct SensorInfo
        {
            std::string propName;
            std::string label;
            std::string format;
            float minValue;
            float maxValue;
        };
 
        struct RelayInfo
        {
            std::string propName;
            std::string label;
        };
 
        struct InputInfo
        {
            std::string propName;
            std::string label;
        };
 
        enum HomeSensorPolarity
        {
            ACTIVE_HIGH = 0,
            ACTIVE_LOW = 1
        };
 
        virtual ~ScopeDomeCard() = default;
 
        virtual bool detect() = 0;
        const char *getDeviceName()
        {
            return (const char *)"ScopeDome Dome";
        };
        virtual void setPortFD(int fd) = 0;
 
        // State polling
        virtual int updateState()                                             = 0;
        virtual uint32_t getStatus()                                          = 0;
        virtual int getRotationCounter()                                      = 0;
        virtual int getRotationCounterExt()                                   = 0;
 
        // Information
        virtual void getFirmwareVersions(double &main, double &rotary)        = 0;
        virtual uint32_t getStepsPerRevolution()                              = 0;
        virtual bool isCalibrationNeeded()                                    = 0;
 
        // Commands
        virtual void abort()                                                  = 0;
        virtual void calibrate()                                              = 0;
        virtual void findHome()                                               = 0;
        virtual void controlShutter(ShutterOperation operation)   = 0;
 
        virtual void resetCounter()                                           = 0;
 
        // negative means CCW, positive CW steps
        virtual void move(int steps)                                          = 0;
 
        // Input/Output management
        virtual size_t getNumberOfSensors()                                   = 0;
        virtual SensorInfo getSensorInfo(size_t index)                        = 0;
        virtual double getSensorValue(size_t index)                           = 0;
 
        virtual size_t getNumberOfRelays()                                    = 0;
        virtual RelayInfo getRelayInfo(size_t index)                          = 0;
        virtual ISState getRelayState(size_t index)                           = 0;
        virtual void setRelayState(size_t index, ISState state)               = 0;
 
        virtual size_t getNumberOfInputs()                                    = 0;
        virtual InputInfo getInputInfo(size_t index)                          = 0;
        virtual ISState getInputValue(size_t index)                           = 0;
 
        virtual ISState getInputState(AbstractInput input)                    = 0;
        virtual int setOutputState(AbstractOutput output, ISState state)      = 0;
 
        virtual void setHomeSensorPolarity(HomeSensorPolarity polarity)       = 0;
 
    protected:
        ScopeDomeCard() = default;
 
    private:
        ScopeDomeCard(const ScopeDomeCard &rhs) = delete;
        ScopeDomeCard &operator=(const ScopeDomeCard &rhs) = delete;
};
 
class ScopeDome : public INDI::Dome
{
    public:
        typedef enum
        {
            DOME_UNKNOWN,
            DOME_CALIBRATING,
            DOME_READY,
            DOME_HOMING,
            DOME_DEROTATING
        } DomeStatus;
 
        ScopeDome();
        virtual ~ScopeDome() = default;
 
        virtual const char *getDefaultName() override;
        virtual bool initProperties() override;
        virtual bool updateProperties() override;
        virtual bool saveConfigItems(FILE *fp) override;
 
        virtual bool Handshake() override;
 
        virtual void TimerHit() override;
 
        virtual bool ISNewSwitch(const char *dev, const char *name, ISState *states, char *names[], int n) override;
        virtual bool ISNewNumber(const char *dev, const char *name, double values[], char *names[], int n) override;
        virtual bool ISNewText(const char *dev, const char *name, char *texts[], char *names[], int n) override;
 
        virtual IPState Move(DomeDirection dir, DomeMotionCommand operation) override;
        virtual IPState MoveRel(double azDiff) override;
        virtual IPState MoveAbs(double az) override;
        virtual IPState ControlShutter(ShutterOperation operation) override;
        virtual bool Abort() override;
 
        // Parking
        virtual IPState Park() override;
        virtual IPState UnPark() override;
        virtual bool SetCurrentPark() override;
        virtual bool SetDefaultPark() override;
 
    protected:
        // Commands
        bool UpdatePosition();
        bool UpdateShutterStatus();
        bool UpdateSensorStatus();
        bool UpdateRelayStatus();
 
        // Misc
        bool SetupParms();
 
        DomeStatus status{ DOME_UNKNOWN };
        double targetAz{ 0 };
        bool refineMove{ false };
        ShutterOperation targetShutter{ SHUTTER_OPEN };
        bool sim{ false };
        double simShutterTimer{ 0 };
        ShutterState simShutterStatus{ SHUTTER_OPENED };
 
        enum CardType
        {
            SCOPEDOME_USB21 = 0,
            SCOPEDOME_ARDUINO = 1
        };
        INDI::PropertySwitch CardTypeSP{2};
 
        INDI::PropertyNumber DomeHomePositionNP{1};
 
        INDI::PropertySwitch HomeSensorPolaritySP{2};
 
        INDI::PropertySwitch FindHomeSP{1};
 
        INDI::PropertySwitch DerotateSP{1};
 
        INDI::PropertyNumber StepsPerRevolutionNP{1};
 
        INDI::PropertySwitch CalibrationNeededSP{1};
 
        INDI::PropertySwitch StartCalibrationSP{1};
 
        INDI::PropertyNumber FirmwareVersionsNP{2};
 
        INDI::PropertyText CredentialsTP{2};
 
        // Dynamic properties initialized based on card type
        INDI::PropertySwitch RelaysSP{0};
        INDI::PropertyNumber SensorsNP{0};
        INDI::PropertySwitch InputsSP{0};
 
    private:
        uint16_t currentStatus;
        int32_t currentRotation;
        int32_t rotationCounter;
 
        uint32_t stepsPerRevolution;
 
        std::unique_ptr<ScopeDomeCard> interface;
 
        IPState sendMove(double azDiff);
 
        // Dome inertia compensation
        std::vector<uint16_t> inertiaTable;
        int compensateInertia(int steps);
 
        // Needed to access reconnect function
        friend class ScopeDomeUSB21;
        friend class ScopeDomeArduino;
 
        void reconnect();
        bool reconnecting{false};
        bool reconnected{false};
 
        const INDI::PropertyText &getCredentials() const
        {
            return CredentialsTP;
        };
 
        // Dew point calculation
        float getDewPoint(float RH, float T);
 
        ISState rotaryLinkEstablished {ISS_OFF};
};