skywatcherAPI.h

Go to the documentation of this file.

 
#pragma once
 
#include <string>
#include <map>
 
#define INDI_DEBUG_LOGGING
#ifdef INDI_DEBUG_LOGGING
#include "inditelescope.h"
#define MYDEBUG(priority, msg) \
    INDI::Logger::getInstance().print(pChildTelescope->getDeviceName(), priority, __FILE__, __LINE__, msg)
#define MYDEBUGF(priority, msg, ...) \
    INDI::Logger::getInstance().print(pChildTelescope->getDeviceName(), priority, __FILE__, __LINE__, msg, __VA_ARGS__)
#else
#define MYDEBUG(priority, msg)
#define MYDEBUGF(priority, msg, ...)
#endif
 
struct AXISSTATUS
{
    AXISSTATUS()
        : FullStop(false), Slewing(false), SlewingTo(false), SlewingForward(false), HighSpeed(false),
          NotInitialized(true)
    {
    }
    bool FullStop;
    bool Slewing;
    bool SlewingTo;
    bool SlewingForward;
    bool HighSpeed;
    bool NotInitialized;
 
    void SetFullStop();
    void SetSlewing(bool forward, bool highspeed);
    void SetSlewingTo(bool forward, bool highspeed);
};
 
class SkywatcherAPI
{
    public:
        enum AXISID
        {
            AXIS1 = 0,
            AXIS2 = 1
        };
 
        // Types
        enum SkywatcherCommand
        {
            Initialize                = 'F',
            InquireMotorBoardVersion  = 'e',
            InquireGridPerRevolution  = 'a',
            InquireTimerInterruptFreq = 'b',
            InquireHighSpeedRatio     = 'g',
            InquirePECPeriod          = 's',
            InstantAxisStop           = 'L',
            NotInstantAxisStop        = 'K',
            SetAxisPositionCmd        = 'E',
            GetAxisPosition           = 'j',
            GetAxisStatus             = 'f',
            SetSnapPort               = 'O', // EQ8/AZEQ6/AZEQ5/EQ6-R/AZ-GTi only
            SetMotionMode             = 'G',
            SetGotoTargetIncrement    = 'H',
            SetBreakPointIncrement    = 'M',
            SetGotoTarget             = 'S',
            SetBreakStep              = 'U',
            SetStepPeriod             = 'I',
            StartMotion               = 'J',
            GetStepPeriod             = 'D', // See Merlin protocol http://www.papywizard.org/wiki/DevelopGuide
            ActivateMotor             = 'B', // See eq6direct implementation http://pierre.nerzic.free.fr/INDI/
            SetST4GuideRateCmd        = 'P',
            GetHomePosition           = 'd', // Get Home position encoder count (default at startup)
            SetFeatureCmd             = 'W', // EQ8/AZEQ6/AZEQ5 only
            GetFeatureCmd             = 'q', // EQ8/AZEQ6/AZEQ5 only
            InquireAuxEncoder         = 'd', // EQ8/AZEQ6/AZEQ5 only
            SetPolarScopeLED          = 'V',
        };
 
        enum SkywatcherGetFeatureCmd
        {
            GET_INDEXER_CMD  = 0x00,
            GET_FEATURES_CMD = 0x01
        };
 
        enum SkywatcherSetFeatureCmd
        {
            START_PPEC_TRAINING_CMD            = 0x00,
            STOP_PPEC_TRAINING_CMD             = 0x01,
            TURN_PPEC_ON_CMD                   = 0x02,
            TURN_PPEC_OFF_CMD                  = 0X03,
            ENCODER_ON_CMD                     = 0x04,
            ENCODER_OFF_CMD                    = 0x05,
            DISABLE_FULL_CURRENT_LOW_SPEED_CMD = 0x0006,
            ENABLE_FULL_CURRENT_LOW_SPEED_CMD  = 0x0106,
            RESET_HOME_INDEXER_CMD             = 0x08
        };
 
 
        // These values are in radians per second
        static constexpr double SIDEREALRATE { (2 * M_PI / 86164.09065) };
        static constexpr double MAX_SPEED { 500.0 };
        static constexpr double LOW_SPEED_MARGIN { 128.0 * SIDEREALRATE };
 
        SkywatcherAPI();
        virtual ~SkywatcherAPI() = default;
 
        unsigned long BCDstr2long(std::string &String);
        unsigned long Highstr2long(std::string &String);
        bool CheckIfDCMotor();
 
        //bool IsVirtuosoMount() const;
 
        //bool IsMerlinMount() const;
 
        //bool IsAZGTiMount() const;
 
        long DegreesPerSecondToClocksTicksPerMicrostep(AXISID Axis, double DegreesPerSecond);
 
        long DegreesToMicrosteps(AXISID Axis, double AngleInDegrees);
 
        bool GetEncoder(AXISID Axis);
 
        bool GetHighSpeedRatio(AXISID Axis);
 
        bool GetMicrostepsPerRevolution(AXISID Axis);
 
        bool GetMicrostepsPerWormRevolution(AXISID Axis);
 
        bool GetMotorBoardVersion(AXISID Axis);
 
        typedef enum { CLOCKWISE, ANTICLOCKWISE } PositiveRotationSense_t;
 
        PositiveRotationSense_t GetPositiveRotationDirection(AXISID Axis);
 
        bool GetStatus(AXISID Axis);
 
        bool GetStepperClockFrequency(AXISID Axis);
 
        // Optional: inquire axis features from mount.
        bool InquireFeatures();
 
        bool InitializeMC();
 
        bool InitMount();
 
        bool HasHomeIndexers();
        bool HasAuxEncoders();
        bool HasPPEC();
        bool HasSnapPort1();
        bool HasSnapPort2();
        bool HasPolarLed();
 
        void TurnEncoder(AXISID axis, bool on);
        void TurnRAEncoder(bool on);
        void TurnDEEncoder(bool on);
        void SetFeature(AXISID axis, uint32_t command);
 
        bool InstantStop(AXISID Axis);
 
        void Long2BCDstr(long Number, std::string &String);
 
        double MicrostepsToDegrees(AXISID Axis, long Microsteps);
 
        double MicrostepsToRadians(AXISID Axis, long Microsteps);
 
        void PrepareForSlewing(AXISID Axis, double Speed);
 
        long RadiansPerSecondToClocksTicksPerMicrostep(AXISID Axis, double RadiansPerSecond);
 
        long RadiansToMicrosteps(AXISID Axis, double AngleInRadians);
 
        bool SetEncoder(AXISID Axis, long Microsteps);
 
        bool SetGotoTargetOffset(AXISID Axis, long OffsetInMicrosteps);
 
        bool SetAxisMotionMode(AXISID Axis, char Func, char Direction);
 
        void SetSerialPort(int port)
        {
            MyPortFD = port;
        }
 
        bool SetClockTicksPerMicrostep(AXISID Axis, long ClockTicksPerMicrostep);
 
        bool SetSlewModeDeccelerationRampLength(AXISID Axis, long Microsteps);
 
        bool SetSlewToModeDeccelerationRampLength(AXISID Axis, long Microsteps);
 
        bool toggleSnapPort(bool enabled);
 
        void Slew(AXISID Axis, double SpeedInRadiansPerSecond, bool IgnoreSilentMode = true);
 
        void SlewTo(AXISID Axis, long OffsetInMicrosteps, bool verbose = true);
 
        bool SlowStop(AXISID Axis);
 
        bool StartAxisMotion(AXISID Axis);
 
        bool TalkWithAxis(AXISID Axis, SkywatcherCommand Command, std::string &cmdDataStr, std::string &responseStr);
 
        bool IsInMotion(AXISID Axis);
 
        // Skywatcher mount status variables
        unsigned long MCVersion { 0 }; // Motor control board firmware version
 
        static const char *mountTypeToString(uint8_t type);
 
        enum MountType
        {
            EQ6              = 0x00,
            HEQ5             = 0x01,
            EQ5              = 0x02,
            EQ3              = 0x03,
            EQ8              = 0x04,
            AZEQ6            = 0x05,
            AZEQ5            = 0x06,
            STAR_ADVENTURER  = 0x0A,
            EQ8R_PRO         = 0x20,
            AZEQ6_PRO        = 0x22,
            EQ6_PRO          = 0x23,
            EQ5_PRO          = 0x31,
            WAVE_150I        = 0x45,
            WAVE_100I        = 0x44,
            GT               = 0x80,
            MF               = 0x81,
            _114GT           = 0x82,
            DOB              = 0x90,
            AZGTE            = 0xA2,
            AZGTI            = 0xA5,
        };
 
        typedef struct SkyWatcherFeatures
        {
            bool inPPECTraining = false;
            bool inPPEC = false;
            bool hasEncoder = false;
            bool hasPPEC = false;
            bool hasHomeIndexer = false;
            bool isAZEQ = false;
            bool hasPolarLed = false;
            bool hasCommonSlewStart = false; // supports :J3
            bool hasHalfCurrentTracking = false;
            bool hasWifi = false;
        } SkyWatcherFeatures;
 
 
        unsigned long MountCode { 0 };
        bool IsDCMotor { false };
        bool SilentSlewMode { true };
 
        // Values from mount
        long MicrostepsPerRevolution[2];     // Number of microsteps for 360 degree revolution
        long StepperClockFrequency[2];       // The stepper clock timer interrupt frequency in ticks per second
        long HighSpeedRatio[2];              // The speed multiplier for high speed mode.
        long MicrostepsPerWormRevolution[2]; // Number of microsteps for one revolution of the worm gear.
        SkyWatcherFeatures AxisFeatures[2];
 
        // Calculated values
        double RadiansPerMicrostep[2];
        double MicrostepsPerRadian[2];
        double DegreesPerMicrostep[2];
        double MicrostepsPerDegree[2];
        long LowSpeedGotoMargin[2];
 
        // SlewTo debugging
        long LastSlewToTarget[2];
 
        long CurrentEncoders[2];
        long PolarisPositionEncoders[2];
        long ZeroPositionEncoders[2];
 
        AXISSTATUS AxesStatus[2];
        double SlewingSpeed[2];
 
    protected:
        // Custom debug level
        unsigned int DBG_SCOPE { 0 };
 
    private:
        int MyPortFD { 0 };
        static constexpr uint8_t SKYWATCHER_MAX_RETRTY {5};
        static constexpr uint8_t SKYWATCHER_TIMEOUT_S  {0};
        static constexpr long    SKYWATCHER_TIMEOUT_US {300000};
        static constexpr uint8_t SKYWATCHER_MAX_CMD {16};
 
        static const std::map<int, std::string> errorCodes;
 
#ifdef INDI_DEBUG_LOGGING
    public:
        INDI::Telescope *pChildTelescope { nullptr };
#endif
};