File indexing completed on 2024-04-21 03:44:09

 /*
     SPDX-FileCopyrightText: 2012 Jasem Mutlaq <mutlaqja@ikarustech.com>
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #pragma once
 
 #include <QDBusArgument>
 #include <QTimer>
 
 #include "indiconcretedevice.h"
 #include "skypoint.h"
 
 class SkyObject;
 
 namespace ISD
 {
 /**
  * @class Mount
  * device handle controlling Mounts. It can slew and sync to a specific sky point and supports all standard properties with INDI
  * telescope device.
  *
  * @author Jasem Mutlaq
  */
 class Mount : public ConcreteDevice
 {
         Q_OBJECT
 
     public:
         explicit Mount(GenericDevice *parent);
         virtual ~Mount() override = default;
 
         typedef enum { MOTION_NORTH, MOTION_SOUTH } VerticalMotion;
         typedef enum { MOTION_WEST, MOTION_EAST } HorizontalMotion;
         typedef enum { MOTION_START, MOTION_STOP } MotionCommand;
         typedef enum { PIER_UNKNOWN = -1, PIER_WEST = 0, PIER_EAST = 1 } PierSide;
         static QString pierSideStateString(PierSide ps)
         {
             switch (ps)
             {
             case ISD::Mount::PierSide::PIER_EAST:
                 return "Pier Side: East (pointing West)";
             case ISD::Mount::PierSide::PIER_WEST:
                 return "Pier Side: West (pointing East)";
             default:
                 return "Pier Side: Unknown";
             }
         }
 
         typedef enum
         {
             MOUNT_IDLE,
             MOUNT_MOVING,
             MOUNT_SLEWING,
             MOUNT_TRACKING,
             MOUNT_PARKING,
             MOUNT_PARKED,
             MOUNT_ERROR
         } Status;
         typedef enum { PARK_OPTION_CURRENT, PARK_OPTION_DEFAULT, PARK_OPTION_WRITE_DATA } ParkOptionCommand;
         typedef enum { TRACK_SIDEREAL, TRACK_SOLAR, TRACK_LUNAR, TRACK_CUSTOM } TrackModes;
 
 
         static const QList<const char *> mountStates;
 
         void registerProperty(INDI::Property prop) override;
         void processSwitch(INDI::Property prop) override;
         void processText(INDI::Property prop) override;
         void processNumber(INDI::Property prop) override;
 
         // Coordinates
         bool getEqCoords(double *ra, double *dec);
         bool isJ2000()
         {
             return m_isJ2000;
         }
 
         // Slew
         bool Slew(SkyPoint *ScopeTarget, bool flip=false);
         bool Slew(double ra, double dec, bool flip=false);
         bool canGoto()
         {
             return m_canGoto;
         }
         bool canFlip()
         {
             return m_canFlip;
         }
 
         // Sync
         bool Sync(SkyPoint *ScopeTarget);
         bool Sync(double ra, double dec);
         bool canSync()
         {
             return m_canSync;
         }
 
         // Tracking
         bool canControlTrack() const
         {
             return m_canControlTrack;
         }
         bool isTracking();
 
         // Track Mode
         bool hasTrackModes() const
         {
             return m_hasTrackModes;
         }
         bool getTrackMode(uint8_t &index);
 
         // Custom Track Rate
         bool hasCustomTrackRate() const
         {
             return m_hasTrackModes;
         }
         bool getCustomTrackRate(double &raRate, double &deRate);
 
         // Motion
         bool MoveNS(VerticalMotion dir, MotionCommand cmd);
         bool StopNS();
         bool MoveWE(HorizontalMotion dir, MotionCommand cmd);
         bool StopWE();
         bool isReversed(INDI_EQ_AXIS axis);
         bool setReversedEnabled(INDI_EQ_AXIS axis, bool enabled);
         bool isSlewing();
         bool isInMotion();
         bool canAbort()
         {
             return m_canAbort;
         }
         QString getManualMotionString() const;
 
         // Guiding
         bool canGuide();
         bool doPulse(GuideDirection ra_dir, int ra_msecs, GuideDirection dec_dir, int dec_msecs);
         bool doPulse(GuideDirection dir, int msecs);
 
         // Parking
         bool canPark();
         bool isParked()
         {
             return m_ParkStatus == PARK_PARKED;
         }
         bool canCustomPark()
         {
             return m_hasCustomParking;
         }
         bool sendParkingOptionCommand(ParkOptionCommand command);
 
         // Status
         ParkStatus parkStatus()
         {
             return m_ParkStatus;
         }
 
         Status status(INumberVectorProperty *nvp);
         Status status();
         const QString statusString(Status status, bool translated = true) const;
 
         // Altitude Limits
         void setAltLimits(double minAltitude, double maxAltitude);
 
         // Alignment Model
         bool setAlignmentModelEnabled(bool enable);
         bool clearAlignmentModel();
         bool clearParking();
         bool hasAlignmentModel()
         {
             return m_hasAlignmentModel;
         }
 
         // Slew Rates
         bool hasSlewRates()
         {
             return m_hasSlewRates;
         }
         QStringList slewRates()
         {
             return m_slewRates;
         }
         int getSlewRate() const;
 
         // Pier side
         PierSide pierSide() const
         {
             return m_PierSide;
         }
 
         // Satellite tracking
         bool canTrackSatellite()
         {
             return m_canTrackSatellite;
         }
 
         /**
          * @short Tracks satellite on provided TLE, initial epoch for trajectory calculation and window in minutes
          *
          * This function needs a Two-Line-Element and a time window in the form of an initial point and a
          * number of minutes on which the trajectory should start. The function was developed wiht the lx200
          * in mind. If the trajectory has already started, the current time and a window of 1min are sufficient.
          *
          * @param tle Two-line-element.
          * @param satPassStart Start time of the trajectory calculation
          * @param satPassEnd End time of the trajectory calculation
          */
         bool setSatelliteTLEandTrack(QString tle, const KStarsDateTime satPassStart, const KStarsDateTime satPassEnd);
 
         /**
          * @brief Hour angle of the current coordinates
          */
         const dms hourAngle() const;
 
         const SkyPoint &currentCoordinates() const
         {
             return currentCoords;
         }
 
         /**
          * @brief stopTimers Stop timers to prevent timing race condition when device is unavailable
          * and timer is still invoked.
          */
         void stopTimers();
 
         void centerLock();
         void centerUnlock();
         void find();
         void setCustomParking(SkyPoint *coords = nullptr);
 
     protected:
         /**
          * @brief Send the coordinates to the mount's INDI driver. Due to the INDI implementation, this
          * function is shared for syncing, slewing and other (partly scope specific) functions like the
          * setting parking position. The interpretation of the coordinates depends in the setting of other
          * INDI switches for slewing, synching, tracking etc.
          * @param ScopeTarget target coordinates
          * @return true if sending the coordinates succeeded
          */
         bool sendCoords(SkyPoint *ScopeTarget);
 
         /**
          * @brief Check whether sending new coordinates will result into a slew
          */
         bool slewDefined();
 
         /**
          * @brief Helper function to update the J2000 coordinates of a sky point from its JNow coordinates
          * @param coords sky point with correct JNow values in RA and DEC
          */
         void updateJ2000Coordinates(SkyPoint *coords);
 
         /**
          * @brief updateParkStatus Updating parking status by checking the TELESCOPE_PARK property.
          */
         void updateParkStatus();
 
         /**
          * @brief updateTarget update target position from {@see currentPosition} and
          *       (if not pointing into the empty sky) also the target name.
          */
         void updateTarget();
 
     public slots:
         bool abort();
         bool park();
         bool unpark();
         bool setSlewRate(int index);
         bool setTrackEnabled(bool enable);
         bool setCustomTrackRate(double raRate, double deRate);
         bool setTrackMode(uint8_t index);
 
     signals:
         /**
          * @brief The mount has finished the slew to a new target.
          * @param currentCoords exact position where the mount is positioned
          */
         void newTarget(SkyPoint &currentCoords);
 
         /**
          * @brief The mount has finished the slew to a new target.
          * @param Name Name of object, if any, the mount is positioned at.
          */
         void newTargetName(const QString &name);
         /**
          * @brief Change in the mount status.
          */
         void newStatus(ISD::Mount::Status status);
         /**
          * @brief Update event with the current telescope position
          * @param position mount position. Independent from the mount type,
          * the EQ coordinates(both JNow and J2000) as well as the alt/az values are filled.
          * @param pierside for GEMs report the pier side the scope is currently (PierSide::PIER_WEST means
          * the mount is on the western side of the pier pointing east of the meridian).
          * @param ha current hour angle
          */
         void newCoords(const SkyPoint &position, const PierSide pierside, const dms &ha);
         void newParkStatus(ISD::ParkStatus status);
         void slewRateChanged(int rate);
         void pierSideChanged(PierSide side);
         void axisReversed(INDI_EQ_AXIS axis, bool reversed);
 
     private:
         SkyPoint currentCoords;
         double minAlt {0}, maxAlt = 90;
         ParkStatus m_ParkStatus = PARK_UNKNOWN;
         IPState EqCoordPreviousState {IPS_IDLE};
         QTimer centerLockTimer;
         QTimer updateCoordinatesTimer;
         SkyObject *currentObject = nullptr;
         bool inManualMotion      = false;
         bool inCustomParking     = false;
         IPState NSPreviousState  = IPS_IDLE;
         IPState WEPreviousState  = IPS_IDLE;
         PierSide m_PierSide = PIER_UNKNOWN;
 
         KStarsDateTime g_satPassStart;
         KStarsDateTime g_satPassEnd;
 
         QMap<TrackModes, uint8_t> TrackMap;
         TrackModes currentTrackMode { TRACK_SIDEREAL };
 
         bool m_hasAlignmentModel = { false };
         bool m_canControlTrack = { false };
         bool m_canGoto { false};
         bool m_canFlip { false};
         bool m_canSync { false};
         bool m_canAbort { false };
         bool m_canTrackSatellite { false };
         bool m_TLEIsSetForTracking { false };
         bool m_windowIsSetForTracking { false };
         bool m_hasTrackModes { false};
         bool m_hasCustomTrackRate { false};
         bool m_hasCustomParking { false };
         bool m_hasSlewRates { false };
         bool m_isJ2000 { false };
         bool m_hasEquatorialCoordProperty { false };
         QStringList m_slewRates;
 };
 }
 
 Q_DECLARE_METATYPE(ISD::Mount::Status)
 QDBusArgument &operator<<(QDBusArgument &argument, const ISD::Mount::Status &source);
 const QDBusArgument &operator>>(const QDBusArgument &argument, ISD::Mount::Status &dest);
 
 Q_DECLARE_METATYPE(ISD::Mount::PierSide)
 QDBusArgument &operator<<(QDBusArgument &argument, const ISD::Mount::PierSide &source);
 const QDBusArgument &operator>>(const QDBusArgument &argument, ISD::Mount::PierSide &dest);