cameradriverinterface.h

#if !defined(_CameraDriverInterFace_H_)
#define _CameraDriverInterFace_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 "enumcameraindex.h"
#else//TheSkyX X2 Plug In Build
#include "../../licensedinterfaces/driverrootinterface.h"
#include "../../licensedinterfaces/linkinterface.h"
#include "../../licensedinterfaces/deviceinfointerface.h"
#include "../../licensedinterfaces/driverinfointerface.h"
typedef enum 
{
CI_NONE, 
CI_PLUGIN=10000,
CI_PLUGIN_LAST=CI_PLUGIN+50000,
} enumCameraIndex;
#endif
 
//TheSkyX's camera driver interface  
#define CAMAPIVERSION 6
 
typedef enum {CCD_IMAGER, CCD_GUIDER} enumWhichCCD;
typedef enum {PT_UNKNOWN, PT_LIGHT, PT_BIAS, PT_DARK, PT_FLAT, PT_AUTODARK} enumPictureType;
 
//This is an exact copy of SBIG's enum
typedef enum { zDEV_NONE, zDEV_LPT1, zDEV_LPT2, zDEV_LPT3, zDEV_USB=0x7F00, zDEV_ETH, zDEV_USB1, zDEV_USB2, zDEV_USB3, zDEV_USB4 } enumLPTPort;

class CameraDriverInterface : public DriverRootInterface, public HardwareInfoInterface, public DriverInfoInterface 
{
//Base class start copy here
 
public: 
        inline CameraDriverInterface()
        {  
                m_bLinked = false;
                m_Camera = CI_NONE;
        }
        virtual ~CameraDriverInterface(){};  

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

        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;
 
//CameraDriverInterface

        enum ReadOutMode 
        {
                rm_Line = 0,            
                rm_Image = 1,           
                rm_FitsOnDisk = 2,      
        };
 
public://Properties

        virtual enumCameraIndex cameraId()                              {return m_Camera;}
        virtual void            setCameraId(enumCameraIndex Cam)        {m_Camera = Cam;}
        virtual bool            isLinked()                                      {return m_bLinked;}
        virtual void            setLinked(const bool bYes)      {m_bLinked = bYes;}

        virtual int                     cameraDriverInterfaceVersion(void)                      {return CAMAPIVERSION;}
        virtual ReadOutMode readoutMode(void)           {return CameraDriverInterface::rm_Line;}
        virtual int                     pathTo_rm_FitsOnDisk(char* lpszPath, const int& nPathMaxSize){(void)lpszPath; (void)nPathMaxSize;return 0;}
 
public://Methods

        virtual int CCSettings(const enumCameraIndex& Camera, const enumWhichCCD& CCD)=0;

        virtual int CCEstablishLink(enumLPTPort portLPT, const enumWhichCCD& CCD, enumCameraIndex DesiredCamera, enumCameraIndex& CameraFound, const int nDesiredCFW, int& nFoundCFW)=0;
        virtual int CCDisconnect(const bool bShutDownTemp)=0;

        virtual int CCGetChipSize(const enumCameraIndex& Camera, const enumWhichCCD& CCD, const int& nXBin, const int& nYBin, const bool& bOffChipBinning, int& nW, int& nH, int& nReadOut)=0;
        virtual int CCGetNumBins(const enumCameraIndex& Camera, const enumWhichCCD& CCD, int& nNumBins)=0;
        virtual int CCGetBinSizeFromIndex(const enumCameraIndex& Camera, const enumWhichCCD& CCD, const int& nIndex, long& nBincx, long& nBincy)=0;

        virtual int CCSetBinnedSubFrame(const enumCameraIndex& Camera, const enumWhichCCD& CCD, const int& nLeft, const int& nTop, const int& nRight, const int& nBottom)=0;

        virtual void CCMakeExposureState(int* pnState, enumCameraIndex Cam, int nXBin, int nYBin, int abg, bool bRapidReadout)=0;

        virtual int CCStartExposure(const enumCameraIndex& Cam, const enumWhichCCD CCD, const double& dTime, enumPictureType Type, const int& nABGState, const bool& bLeaveShutterAlone)=0;
        virtual int CCIsExposureComplete(const enumCameraIndex& Cam, const enumWhichCCD CCD, bool* pbComplete, unsigned int* pStatus)=0;
        virtual int CCEndExposure(const enumCameraIndex& Cam, const enumWhichCCD CCD, const bool& bWasAborted, const bool& bLeaveShutterAlone)=0;

        virtual int CCReadoutLine(const enumCameraIndex& Cam, const enumWhichCCD& CCD, const int& pixelStart, const int& pixelLength, const int& nReadoutMode, unsigned char* pMem)=0;
        virtual int CCDumpLines(const enumCameraIndex& Cam, const enumWhichCCD& CCD, const int& nReadoutMode, const unsigned int& lines)=0;

        virtual int CCReadoutImage(const enumCameraIndex& Cam, const enumWhichCCD& CCD, const int& nWidth, const int& nHeight, const int& nMemWidth, unsigned char* pMem)=0;

        virtual int CCRegulateTemp(const bool& bOn, const double& dTemp)=0;
        virtual int CCQueryTemperature(double& dCurTemp, double& dCurPower, char* lpszPower, const int nMaxLen, bool& bCurEnabled, double& dCurSetPoint)=0;
        virtual int     CCGetRecommendedSetpoint(double& dRecSP)=0;
        virtual int     CCSetFan(const bool& bOn)=0;

        virtual int CCActivateRelays(const int& nXPlus, const int& nXMinus, const int& nYPlus, const int& nYMinus, const bool& bSynchronous, const bool& bAbort, const bool& bEndThread)=0;

        virtual int CCPulseOut(unsigned int nPulse, bool bAdjust, const enumCameraIndex& Cam)=0;

        virtual int CCSetShutter(bool bOpen)=0;
        virtual int CCUpdateClock(void)=0;

        virtual int CCSetImageProps(const enumCameraIndex& Camera, const enumWhichCCD& CCD, const int& nReadOut, void* pImage)=0;       
        virtual int CCGetFullDynamicRange(const enumCameraIndex& Camera, const enumWhichCCD& CCD, unsigned long& dwDynRg)=0;
        
        virtual void CCBeforeDownload(const enumCameraIndex& Cam, const enumWhichCCD& CCD)=0;
        virtual void CCAfterDownload(const enumCameraIndex& Cam, const enumWhichCCD& CCD)=0;
 
        //Implemenation below here
protected:
        bool            m_bLinked;
        enumCameraIndex m_Camera;
 
//Base class End Copy Above here
};
 
 
//Added another export to CamAPI
//Not requried so its backward compatible
//Attempted to add a ptr func to it in CamApi.h, but got bad debug delete error 
//(i.e. the CamAPI object header, was different from what CCDSoft allocated.
//This gives TheSkyX a way to talk to a plug in imp outside the context of the above object
//Mostly its for Photometric camera that has NFrames
#ifdef Q_WS_WIN
typedef __declspec(dllexport) int (*pfCamAPIDoCommand)(const int& nCmd, const int& nWhichCCD, int* pnArg1, char* lpszInOutStrArg, const int& nInArgStrArgSize);
#else
typedef int (*pfCamAPIDoCommand)(const int& nCmd, const int& nWhichCCD, int* pnArg1, char* lpszInOutStrArg, const int& nInArgStrArgSize);
#endif
 
#endif //_CameraDriverInterFace_H_