indidome.h

Go to the documentation of this file.

/*******************************************************************************
 INDI Dome Base Class
 Copyright(c) 2014 Jasem Mutlaq. All rights reserved.
 
 The code used calculate dome target AZ and ZD is written by Ferran Casarramona, and adapted from code from Markus Wildi.
 The transformations are based on the paper Matrix Method for Coordinates Transformation written by Toshimi Taki (http://www.asahi-net.or.jp/~zs3t-tk).
 
 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 "defaultdevice.h"
#include "libastro.h"
#include "inditimer.h"
 
#include <string>
 
// Defines a point in a 3 dimension space
typedef struct
{
    double x, y, z;
} point3D;
 
namespace Connection
{
class Serial;
class TCP;
}
 
namespace INDI
{
 
class Dome : public DefaultDevice
{
    public:
        typedef enum
        {
            DM_DOME_RADIUS,        
            DM_SHUTTER_WIDTH,      
            DM_NORTH_DISPLACEMENT, 
            DM_EAST_DISPLACEMENT,  
            DM_UP_DISPLACEMENT,    
            DM_OTA_OFFSET          
        } DomeMeasurements;
 
        enum DomeDirection
        {
            DOME_CW,
            DOME_CCW
        };
        enum DomeMotionCommand
        {
            MOTION_START,
            MOTION_STOP
        };
 
        enum DomeParkData
        {
            PARK_NONE,       
            PARK_AZ,         
            PARK_AZ_ENCODER, 
        };
 
        typedef enum
        {
            SHUTTER_OPEN, 
            SHUTTER_CLOSE 
        } ShutterOperation;
 
        enum MountLockingPolicy
        {
            MOUNT_IGNORED,      
            MOUNT_LOCKS,        
        };
 
        typedef enum
        {
            DOME_IDLE,      
            DOME_MOVING,    
            DOME_SYNCED,    
            DOME_PARKING,   
            DOME_UNPARKING, 
            DOME_PARKED,    
            DOME_UNPARKED,  
            DOME_UNKNOWN,   
            DOME_ERROR,     
        } DomeState;
 
        typedef enum
        {
            SHUTTER_OPENED,     
            SHUTTER_CLOSED,     
            SHUTTER_MOVING,     
            SHUTTER_UNKNOWN,    
            SHUTTER_ERROR       
        } ShutterState;
 
        enum
        {
            DOME_CAN_ABORT          = 1 << 0, 
            DOME_CAN_ABS_MOVE       = 1 << 1, 
            DOME_CAN_REL_MOVE       = 1 << 2, 
            DOME_CAN_PARK           = 1 << 3, 
            DOME_CAN_SYNC           = 1 << 4, 
            DOME_HAS_SHUTTER        = 1 << 5, 
            DOME_HAS_VARIABLE_SPEED = 1 << 6, 
            DOME_HAS_BACKLASH       = 1 << 7  
        };
 
        enum
        {
            CONNECTION_NONE   = 1 << 0, 
            CONNECTION_SERIAL = 1 << 1, 
            CONNECTION_TCP    = 1 << 2  
        } DomeConnection;
 
        Dome();
        virtual ~Dome();
 
        virtual bool initProperties() override;
        virtual void ISGetProperties(const char * dev) override;
        virtual bool updateProperties() override;
        virtual bool ISNewNumber(const char * dev, const char * name, double values[], char * names[], int n) override;
        virtual bool ISNewSwitch(const char * dev, const char * name, ISState * states, char * names[], int n) override;
        virtual bool ISNewText(const char * dev, const char * name, char * texts[], char * names[], int n) override;
        virtual bool ISSnoopDevice(XMLEle * root) override;
 
        static void buttonHelper(const char * button_n, ISState state, void * context);
 
        void setDomeConnection(const uint8_t &value);
 
        uint8_t getDomeConnection() const;
 
        uint32_t GetDomeCapability() const
        {
            return capability;
        }
 
        void SetDomeCapability(uint32_t cap);
 
        bool CanAbort()
        {
            return capability & DOME_CAN_ABORT;
        }
 
        bool CanAbsMove()
        {
            return capability & DOME_CAN_ABS_MOVE;
        }
 
        bool CanRelMove()
        {
            return capability & DOME_CAN_REL_MOVE;
        }
 
        bool CanPark()
        {
            return capability & DOME_CAN_PARK;
        }
 
        bool CanSync()
        {
            return capability & DOME_CAN_SYNC;
        }
 
        bool HasShutter()
        {
            return capability & DOME_HAS_SHUTTER;
        }
 
        bool HasVariableSpeed()
        {
            return capability & DOME_HAS_VARIABLE_SPEED;
        }
 
        bool HasBacklash()
        {
            return capability & DOME_HAS_BACKLASH;
        }
 
        bool isLocked();
 
        DomeState getDomeState() const
        {
            return m_DomeState;
        }
        void setDomeState(const DomeState &value);
 
        ShutterState getShutterState() const
        {
            return m_ShutterState;
        }
        void setShutterState(const ShutterState &value);
 
        IPState getMountState() const;
 
    protected:
        virtual bool SetSpeed(double rpm);
 
        virtual IPState Move(DomeDirection dir, DomeMotionCommand operation);
 
        virtual IPState MoveAbs(double az);
 
        virtual IPState MoveRel(double azDiff);
 
        virtual bool Sync(double az);
 
        virtual bool Abort();
 
        virtual IPState Park();
 
        virtual IPState UnPark();
 
        virtual bool SetBacklash(int32_t steps);
 
        virtual bool SetBacklashEnabled(bool enabled);
 
        virtual IPState ControlShutter(ShutterOperation operation);
 
        const char * GetShutterStatusString(ShutterState status);
 
        void SetParkDataType(DomeParkData type);
 
        bool InitPark();
 
        bool isParked();
 
        void SetParked(bool isparked);
 
        double GetAxis1Park();
 
        double GetAxis1ParkDefault();
 
        void SetAxis1Park(double value);
 
        void SetAxis1ParkDefault(double steps);
 
        virtual bool SetCurrentPark();
 
        virtual bool SetDefaultPark();
 
        //Park
        const char * LoadParkData();
        bool WriteParkData();
 
        bool GetTargetAz(double &Az, double &Alt, double &minAz, double &maxAz);
 
        bool Intersection(point3D p1, point3D p2, double r, double &mu1, double &mu2);
 
        bool OpticalCenter(point3D MountCenter, double dOpticalAxis, double Lat, double Ah, point3D &OP);
 
        bool OpticalVector(double Az, double Alt, point3D &OV);
 
        bool CheckHorizon(double HA, double dec, double lat);
 
        virtual bool saveConfigItems(FILE * fp) override;
 
        void UpdateMountCoords();
 
        virtual void UpdateAutoSync();
 
        virtual bool Handshake();
 
        virtual void ActiveDevicesUpdated() {};
 
        double Csc(double x);
        double Sec(double x);
 
        INDI::PropertyNumber DomeSpeedNP {1};
 
        INDI::PropertySwitch DomeMotionSP {2};
 
        INDI::PropertyNumber DomeAbsPosNP {1};
 
        INDI::PropertyNumber DomeRelPosNP {1};
 
        INDI::PropertySwitch AbortSP {1};
 
        INDI::PropertyNumber DomeParamNP {1};
 
        INDI::PropertyNumber DomeSyncNP {1};
 
        INDI::PropertySwitch DomeShutterSP {2};
 
        INDI::PropertySwitch ParkSP {2};
 
        INDI::PropertyNumber ParkPositionNP {1};
 
        INDI::PropertySwitch ParkOptionSP {3};
 
        INDI::PropertyText ActiveDeviceTP {3};
        enum
        {
            ACTIVE_MOUNT,
            ACTIVE_INPUT,
            ACTIVE_OUTPUT
        };
 
        // Switch to lock id mount is unparked
        INDI::PropertySwitch MountPolicySP {2};
 
        // Shutter control on Park/Unpark
        INDI::PropertySwitch ShutterParkPolicySP {2};
        enum
        {
            SHUTTER_CLOSE_ON_PARK,
            SHUTTER_OPEN_ON_UNPARK,
        };
 
        INDI::PropertyNumber PresetNP {3};
        INDI::PropertySwitch PresetGotoSP {3};
 
        INDI::PropertyNumber DomeMeasurementsNP {6};
 
        INDI::PropertySwitch OTASideSP {5};
        // 0 is East, 1 is West, 2 is as reported by mout, 3 as deducted by Hour Angle
        // 4 ignore pier side and perform as in a fork mount
        enum
        {
            DM_OTA_SIDE_EAST,
            DM_OTA_SIDE_WEST,
            DM_OTA_SIDE_MOUNT,
            DM_OTA_SIDE_HA,
            DM_OTA_SIDE_IGNORE
        };
 
        int mountOTASide = 0; // Side of the telescope with respect of the mount, 1: west, -1: east, 0 not reported
        INDI::PropertySwitch DomeAutoSyncSP {2};
 
        // Backlash toggle
        INDI::PropertySwitch DomeBacklashSP {2};
 
        // Backlash steps
        INDI::PropertyNumber DomeBacklashNP {1};
 
        uint32_t capability;
        DomeParkData parkDataType;
 
        double prev_az, prev_alt, prev_ra, prev_dec;
 
        // For Serial and TCP connections
        int PortFD = -1;
 
        Connection::Serial * serialConnection = nullptr;
        Connection::TCP * tcpConnection       = nullptr;
 
        // States
        DomeState m_DomeState;
        ShutterState m_ShutterState;
        IPState m_MountState;
 
        // Observer geographic coords. Snooped from mount driver.
        IGeographicCoordinates observer;
        // Do we have valid geographic coords from mount driver?
        bool HaveLatLong = false;
 
        // Mount horizontal and equatorial coords. Snoops from mount driver.
        INDI::IHorizontalCoordinates mountHoriztonalCoords;
        INDI::IEquatorialCoordinates mountEquatorialCoords;
        // Do we have valid coords from mount driver?
        bool HaveRaDec = false;
 
    private:
        void processButton(const char * button_n, ISState state);
        void triggerSnoop(const char * driverName, const char * propertyName);
        void SyncParkStatus(bool isparked);
        const char * LoadParkXML();
 
        std::string GetHomeDirectory() const;
 
        Controller * controller = nullptr;
 
        bool IsParked = false;
        bool IsMountParked = true;
        bool IsLocked = true;
        bool AutoSyncWarning = false;
        bool UseHourAngle = false;
 
        const char * ParkDeviceName;
        const std::string ParkDataFileName;
        INDI::Timer m_MountUpdateTimer;
        //int m_HorizontalUpdateTimerID { -1 };
        XMLEle * ParkdataXmlRoot, *ParkdeviceXml, *ParkstatusXml, *ParkpositionXml, *ParkpositionAxis1Xml;
 
        double Axis1ParkPosition;
        double Axis1DefaultParkPosition;
 
        bool callHandshake();
        uint8_t domeConnection = CONNECTION_SERIAL | CONNECTION_TCP;
 
        // How often we update horizontal coordinates (10 seconds).
        static constexpr uint32_t HORZ_UPDATE_TIMER { 10000 };
};
 
}