mountdriverinterface.h

#if !defined(_MountDriverInterface_H_)
#define _MountDriverInterface_H_
 
#ifdef THESKYX_FOLDER_TREE
#include "imagingsystem/hardware/interfaces/licensed/driverrootinterface.h"
#include "imagingsystem/hardware/interfaces/licensed/linkinterface.h"
#include "imagingsystem/hardware/interfaces/licensed/deviceinfointerface.h"
#include "imagingsystem/hardware/interfaces/licensed/driverinfointerface.h"
#include "imagingsystem/hardware/interfaces/licensed/mount/needsrefractioninterface.h"
#else//TheSkyX Plug In Build
#include "../../licensedinterfaces/driverrootinterface.h"
#include "../../licensedinterfaces/linkinterface.h"
#include "../../licensedinterfaces/deviceinfointerface.h"
#include "../../licensedinterfaces/driverinfointerface.h"
#include "../../licensedinterfaces/mount/needsrefractioninterface.h"
#endif

class MountDriverInterface : public DriverRootInterface, public LinkInterface, public HardwareInfoInterface, public DriverInfoInterface, public NeedsRefractionInterface 
{
public:
        enum MotorState
        {
                MKS_MOTOR_HOMING                                                                =(0x0100),
                MKS_MOTOR_SERVO                                                                 =(0x0200),
                MKS_MOTOR_INDEXING                                                              =(0x0400),
                MKS_MOTOR_SLEWING                                                               =(0x0800),
                MKS_MOTOR_HOMED                                                                 =(0x1000),
                MKS_MOTOR_JOYSTICKING                                                           =(0x2000),
                MKS_MOTOR_OFF                                                                   =(0x4000),
                MKS_MOTOR_MOVING                                                                        = (MKS_MOTOR_HOMING | MKS_MOTOR_SLEWING | MKS_MOTOR_JOYSTICKING),
 
        };

        enum Axis
        {
                AXIS_RA         = 0,
                AXIS_DEC        = 1,
        };

        enum MoveDir
        {
                MD_NORTH        = 0,
                MD_SOUTH        = 1,
                MD_EAST         = 2,
                MD_WEST         = 3,
        };

        enum MoveRate
        {
                MR_FLASH        =       -2,
                MR_BASE         =       -1,
                MR_0R5X         =        0,
                MR_1X           =        1,
                MR_2X           =        2,
                MR_4X           =        3,
                MR_8X           =        4,
                MR_16X          =        5,
                MR_32X          =        6,
                MR_64X          =        7,
                MR_128X         =        8,
                MR_256X         =        9,
                MR_SLEW         =        10,
        };
 
public:
        virtual ~MountDriverInterface(){} 
 
public:
 
// Operations
public:

        virtual DeviceType                                                      deviceType(void)                                                          {return DriverRootInterface::DT_MOUNT;}
        virtual int                                                                     queryAbstraction(const char* pszName, void** ppVal) = 0;

        virtual int                                                                     establishLink(void)                                             = 0;
        virtual int                                                                     terminateLink(void)                                             = 0;
        virtual bool                                                            isLinked(void) const                                    = 0;
        virtual bool                                                            isEstablishLinkAbortable(void) const    {return false;}

        virtual void                                                            driverInfoDetailedInfo(BasicStringInterface& str) const =0;
        virtual double                                                          driverInfoVersion(void) const                           = 0;
 
        //
        virtual void deviceInfoNameShort(BasicStringInterface& str) const                               = 0;
        virtual void deviceInfoNameLong(BasicStringInterface& str) const                                = 0;
        virtual void deviceInfoDetailedDescription(BasicStringInterface& str) const     = 0;
        virtual void deviceInfoFirmwareVersion(BasicStringInterface& str)                               = 0;
        virtual void deviceInfoModel(BasicStringInterface& str)                                         = 0;
 
        //NeedsRefractionInterface
        //Don't forget, each mount implementation must return type cast in queryAbstraction
        virtual bool                                                    needsRefactionAdjustments(void) {return true;}

        virtual int                                                                     raDec(double& dRawRA, double& dRawDec, const bool& bCached = false)                                     = 0;
        virtual int                                                                     abort(void)                                                                                                                                     = 0;
 
// Implementation
private:        
 
        
        
};
 
#endif