inditelescope.h

Go to the documentation of this file.

/*******************************************************************************
  Copyright(c) 2011 Gerry Rozema, 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 "defaultdevice.h"
#include "libastro.h"
#include "indipropertyswitch.h"
#include <libnova/julian_day.h>
 
#include <string>
 
namespace INDI
{
 
class Telescope : public DefaultDevice
{
    public:
        enum TelescopeStatus
        {
            SCOPE_IDLE,
            SCOPE_SLEWING,
            SCOPE_TRACKING,
            SCOPE_PARKING,
            SCOPE_PARKED
        };
        enum TelescopeMotionCommand
        {
            MOTION_START = 0,
            MOTION_STOP
        };
        enum TelescopeSlewRate
        {
            SLEW_GUIDE,
            SLEW_CENTERING,
            SLEW_FIND,
            SLEW_MAX
        };
        enum TelescopeTrackMode
        {
            TRACK_SIDEREAL,
            TRACK_SOLAR,
            TRACK_LUNAR,
            TRACK_CUSTOM
        };
        enum TelescopeTrackState
        {
            TRACK_ON,
            TRACK_OFF,
            TRACK_UNKNOWN
        };
        enum TelescopeParkData
        {
            PARK_NONE,              
            PARK_RA_DEC,            
            PARK_HA_DEC,            
            PARK_AZ_ALT,            
            PARK_RA_DEC_ENCODER,    
            PARK_AZ_ALT_ENCODER,    
            PARK_SIMPLE             
        };
        enum TelescopeLocation
        {
            LOCATION_LATITUDE,
            LOCATION_LONGITUDE,
            LOCATION_ELEVATION
        };
        enum TelescopePierSide
        {
            PIER_UNKNOWN = -1,
            PIER_WEST    = 0,
            PIER_EAST    = 1
        };
 
        enum TelescopeHomeAction
        {
            HOME_FIND,              
            HOME_SET,               
            HOME_GO,                
        };
 
        enum TelescopePECState
        {
            PEC_UNKNOWN = -1,
            PEC_OFF     = 0,
            PEC_ON      = 1
        };
 
        enum DomeLockingPolicy
        {
            DOME_IGNORED,       
            DOME_LOCKS,         
        };
 
        enum
        {
            CONNECTION_NONE   = 1 << 0, 
            CONNECTION_SERIAL = 1 << 1, 
            CONNECTION_TCP    = 1 << 2  
        } TelescopeConnection;
 
        enum
        {
            TELESCOPE_CAN_GOTO                    = 1 << 0,  
            TELESCOPE_CAN_SYNC                    = 1 << 1,  
            TELESCOPE_CAN_PARK                    = 1 << 2,  
            TELESCOPE_CAN_ABORT                   = 1 << 3,  
            TELESCOPE_HAS_TIME                    = 1 << 4,  
            TELESCOPE_HAS_LOCATION                = 1 << 5,  
            TELESCOPE_HAS_PIER_SIDE               = 1 << 6,  
            TELESCOPE_HAS_PEC                     = 1 << 7,  
            TELESCOPE_HAS_TRACK_MODE              = 1 << 8,  
            TELESCOPE_CAN_CONTROL_TRACK           = 1 << 9,  
            TELESCOPE_HAS_TRACK_RATE              = 1 << 10, 
            TELESCOPE_HAS_PIER_SIDE_SIMULATION    = 1 << 11, 
            TELESCOPE_CAN_TRACK_SATELLITE         = 1 << 12, 
            TELESCOPE_CAN_FLIP                    = 1 << 13, 
            TELESCOPE_CAN_HOME_FIND               = 1 << 14, 
            TELESCOPE_CAN_HOME_SET                = 1 << 15, 
            TELESCOPE_CAN_HOME_GO                 = 1 << 16, 
        } TelescopeCapability;
 
        Telescope();
        virtual ~Telescope();
 
        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 bool ISNewSwitch(const char *dev, const char *name, ISState *states, char *names[], int n) override;
        virtual void ISGetProperties(const char *dev) override;
        virtual bool ISSnoopDevice(XMLEle *root) override;
 
        uint32_t GetTelescopeCapability() const
        {
            return capability;
        }
 
        void SetTelescopeCapability(uint32_t cap, uint8_t slewRateCount);
 
        bool CanGOTO()
        {
            return capability & TELESCOPE_CAN_GOTO;
        }
 
        bool CanSync()
        {
            return capability & TELESCOPE_CAN_SYNC;
        }
 
        bool CanFlip()
        {
            return capability & TELESCOPE_CAN_FLIP;
        }
 
        bool CanAbort()
        {
            return capability & TELESCOPE_CAN_ABORT;
        }
 
        bool CanPark()
        {
            return capability & TELESCOPE_CAN_PARK;
        }
 
        bool CanControlTrack()
        {
            return capability & TELESCOPE_CAN_CONTROL_TRACK;
        }
 
        bool HasTime()
        {
            return capability & TELESCOPE_HAS_TIME;
        }
 
        bool HasLocation()
        {
            return capability & TELESCOPE_HAS_LOCATION;
        }
 
        bool HasPierSide()
        {
            return capability & TELESCOPE_HAS_PIER_SIDE;
        }
 
        bool HasPierSideSimulation()
        {
            return capability & TELESCOPE_HAS_PIER_SIDE_SIMULATION;
        }
        bool CanTrackSatellite()
        {
            return capability & TELESCOPE_CAN_TRACK_SATELLITE;
        }
        bool HasPECState()
        {
            return capability & TELESCOPE_HAS_PEC;
        }
 
        bool HasTrackMode()
        {
            return capability & TELESCOPE_HAS_TRACK_MODE;
        }
 
        bool HasTrackRate()
        {
            return capability & TELESCOPE_HAS_TRACK_RATE;
        }
 
        bool CanHomeFind()
        {
            return capability & TELESCOPE_CAN_HOME_FIND;
        }
 
        bool CanHomeSet()
        {
            return capability & TELESCOPE_CAN_HOME_SET;
        }
 
        bool CanHomeGo()
        {
            return capability & TELESCOPE_CAN_HOME_GO;
        }
 
        virtual bool initProperties() override;
        virtual bool updateProperties() override;
 
        virtual bool Handshake();
 
        virtual void TimerHit() override;
 
        void SetParkDataType(TelescopeParkData type);
 
        bool InitPark();
 
        bool isParked();
 
        virtual void SetParked(bool isparked);
 
        double GetAxis1Park() const;
 
        double GetAxis1ParkDefault() const;
 
        double GetAxis2Park() const;
 
        double GetAxis2ParkDefault() const;
 
        void SetAxis1Park(double value);
 
        void SetAxis1ParkDefault(double steps);
 
        void SetAxis2Park(double steps);
 
        void SetAxis2ParkDefault(double steps);
 
        bool isLocked() const;
 
        // Joystick helpers
        static void joystickHelper(const char *joystick_n, double mag, double angle, void *context);
        static void axisHelper(const char *axis_n, double value, void *context);
        static void buttonHelper(const char *button_n, ISState state, void *context);
 
        void setTelescopeConnection(const uint8_t &value);
 
        uint8_t getTelescopeConnection() const;
 
        void setPierSide(TelescopePierSide side);
        TelescopePierSide getPierSide()
        {
            return currentPierSide;
        }
 
        void setPECState(TelescopePECState state);
        TelescopePECState getPECState()
        {
            return currentPECState;
        }
 
    protected:
        virtual bool saveConfigItems(FILE *fp) override;
 
        void NewRaDec(double ra, double dec);
 
        virtual bool ReadScopeStatus() = 0;
 
        virtual bool Flip(double ra, double dec);
 
        virtual bool Goto(double ra, double dec);
 
        virtual bool Sync(double ra, double dec);
 
        virtual bool MoveNS(INDI_DIR_NS dir, TelescopeMotionCommand command);
 
        virtual bool MoveWE(INDI_DIR_WE dir, TelescopeMotionCommand command);
 
        virtual bool Park();
 
        virtual bool UnPark();
 
        virtual bool Abort();
 
        virtual bool SetTrackMode(uint8_t mode);
 
        virtual bool SetTrackRate(double raRate, double deRate);
 
        virtual int AddTrackMode(const char *name, const char *label, bool isDefault = false);
 
        virtual bool SetTrackEnabled(bool enabled);
 
        virtual bool updateTime(ln_date *utc, double utc_offset);
 
        virtual bool updateLocation(double latitude, double longitude, double elevation);
 
        void updateObserverLocation(double latitude, double longitude, double elevation);
 
        virtual bool SetParkPosition(double Axis1Value, double Axis2Value);
 
        virtual IPState ExecuteHomeAction(TelescopeHomeAction action);
 
        virtual bool SetCurrentPark();
 
        virtual bool SetDefaultPark();
 
 
        virtual void SyncParkStatus(bool isparked);
 
        virtual bool SetSlewRate(int index);
 
        bool callHandshake();
 
        // Joystick
        void processNSWE(double mag, double angle);
        void processJoystick(const char *joystick_n, double mag, double angle);
        void processAxis(const char *axis_n, double value);
        void processSlewPresets(double mag, double angle);
        void processButton(const char *button_n, ISState state);
 
        TelescopePierSide expectedPierSide(double ra);
 
        // Geographic Location
        IGeographicCoordinates m_Location { 0, 0, 0 };
 
        std::string GetHomeDirectory() const;
 
        int GetScopeConfigIndex() const;
 
        bool CheckFile(const std::string &file_name, bool writable) const;
 
        TelescopeStatus TrackState {SCOPE_IDLE};
 
        TelescopeStatus RememberTrackState {SCOPE_IDLE};
 
        // All telescopes should produce equatorial co-ordinates
        INDI::PropertyNumber EqNP {2};
 
        // When a goto is issued, domes will snoop the target property
        // to start moving the dome when a telescope moves
        INDI::PropertyNumber TargetNP {2};
 
        // Abort motion
        INDI::PropertySwitch AbortSP {1};
 
        // On a coord_set message, sync, or slew
        INDI::PropertySwitch CoordSP {4};
 
        // A number vector that stores latitude and longitude
        INDI::PropertyNumber LocationNP {3};
 
        // A Switch in the client interface to park the scope
        INDI::PropertySwitch ParkSP {2};
        enum
        {
            PARK,
            UNPARK
        };
 
        // Custom parking position
        INDI::PropertyNumber ParkPositionNP {2};
 
        INDI::PropertySwitch ParkOptionSP {4};
        enum
        {
            PARK_CURRENT,
            PARK_DEFAULT,
            PARK_WRITE_DATA,
            PARK_PURGE_DATA,
        };
 
        // A switch for North/South motion
        INDI::PropertySwitch MovementNSSP {2};
 
        // A switch for West/East motion
        INDI::PropertySwitch MovementWESP {2};
 
        // Reverse NS or WE
        INDI::PropertySwitch ReverseMovementSP {2};
        enum
        {
            REVERSE_NS,
            REVERSE_WE
        };
 
        // Slew Rate
        INDI::PropertySwitch SlewRateSP {0};
 
        // UTC and UTC Offset
        INDI::PropertyText TimeTP {2};
        enum
        {
            UTC,
            OFFSET
        };
        void sendTimeFromSystem();
 
        // Active GPS/Dome device to snoop
        INDI::PropertyText ActiveDeviceTP {2};
        enum
        {
            ACTIVE_GPS,
            ACTIVE_DOME
        };
 
        // Switch to lock if dome is closed.
        INDI::PropertySwitch DomePolicySP {2};
 
        // Switch for choosing between motion control by 4-way joystick or two separate axes
        INDI::PropertySwitch MotionControlModeTP {2};
        enum
        {
            MOTION_CONTROL_MODE_JOYSTICK,
            MOTION_CONTROL_MODE_AXES,
        };
 
        // Lock Joystick Axis to one direction only
        INDI::PropertySwitch LockAxisSP {2};
        enum
        {
            LOCK_AXIS_1,
            LOCK_AXIS_2
        };
 
        // Joystick reverse motion and swapping (joystick only, does not affect MoveNS/MoveWE)
        INDI::PropertySwitch JoystickReverseSP {3};
        enum
        {
            JOYSTICK_REVERSE_NS,
            JOYSTICK_REVERSE_WE,
            JOYSTICK_REVERSE_SWAP
        };
 
        // Pier Side
        INDI::PropertySwitch PierSideSP {2};
 
        // Pier Side Simulation
        INDI::PropertySwitch SimulatePierSideSP {2};
        enum
        {
            SIMULATE_YES,
            SIMULATE_NO
        };
        bool getSimulatePierSide() const;
        void setSimulatePierSide(bool value);
 
        // Pier Side
        TelescopePierSide lastPierSide, currentPierSide;
 
        const char * getPierSideStr(TelescopePierSide ps);
 
        // Satellite tracking
        INDI::PropertyText TLEtoTrackTP{1};
        INDI::PropertyText SatPassWindowTP {2};
 
        enum
        {
            SAT_PASS_WINDOW_START, 
            SAT_PASS_WINDOW_END, 
        } SatelliteWindow;
 
        INDI::PropertySwitch TrackSatSP {2};
        enum
        {
            SAT_TRACK, 
            SAT_HALT, 
        } SatelliteTracking;
 
        // PEC State
        INDI::PropertySwitch PECStateSP {2};
 
        // Mount Type
        INDI::PropertySwitch MountTypeSP {3};
        enum
        {
            MOUNT_ALTAZ,
            MOUNT_EQ_FORK,
            MOUNT_EQ_GEM
        };
 
        // Track Mode
        INDI::PropertySwitch TrackModeSP {0};
 
        // Track State
        INDI::PropertySwitch TrackStateSP {2};
        // ISwitch TrackStateS[2];
 
        // Track Rate
        INDI::PropertyNumber TrackRateNP {2};
 
        // Home Position
        INDI::PropertySwitch HomeSP {0};
 
        // PEC State
        TelescopePECState lastPECState {PEC_UNKNOWN}, currentPECState {PEC_UNKNOWN};
 
        uint32_t capability {0};
        int last_we_motion {-1}, last_ns_motion {-1};
 
        //Park
        const char *LoadParkData();
        bool WriteParkData();
        bool PurgeParkData();
 
        int PortFD                           = -1;
        Connection::Serial *serialConnection = nullptr;
        Connection::TCP *tcpConnection       = nullptr;
 
        bool IsParked {false};
        TelescopeParkData parkDataType {PARK_NONE};
 
    private:
        bool processTimeInfo(const char *utc, const char *offset);
        bool processLocationInfo(double latitude, double longitude, double elevation);
        void triggerSnoop(const char *driverName, const char *propertyName);
        void generateCoordSet();
 
        const char *LoadParkXML();
 
        bool IsLocked {true};
        const char *ParkDeviceName {nullptr};
        const std::string ParkDataFileName;
        XMLEle *ParkdataXmlRoot {nullptr}, *ParkdeviceXml {nullptr}, *ParkstatusXml {nullptr}, *ParkpositionXml {nullptr},
               *ParkpositionAxis1Xml {nullptr}, *ParkpositionAxis2Xml {nullptr};
 
        double Axis1ParkPosition {0};
        double Axis1DefaultParkPosition {0};
        double Axis2ParkPosition {0};
        double Axis2DefaultParkPosition {0};
 
        uint8_t nSlewRate {0};
        IPState lastEqState { IPS_IDLE };
 
        uint8_t telescopeConnection = (CONNECTION_SERIAL | CONNECTION_TCP);
 
        Controller *controller {nullptr};
 
        float motionDirNSValue {0};
        float motionDirWEValue {0};
 
        bool m_slewPresetArmed {true};
 
        bool m_simulatePierSide;    // use setSimulatePierSide and getSimulatePierSide for public access
 
        // 100 millisecond of arc or time.
        static constexpr double EQ_NOTIFY_THRESHOLD {1.0 / (60 * 60 * 10)};
};
 
}