• Skip to content
• Skip to link menu

KDE 3.5 API Reference

• KDE API Reference
• API Reference

• Sitemap
• Contact Us

 

kstars

CameraIO_Linux.h

Go to the documentation of this file.

// CameraIO.h: interface for the CCameraIO class.
//
// Copyright (c) 2000 Apogee Instruments Inc.

#if !defined(AFX_CAMERAIO_H__A2882C82_7CFB_11D4_9155_0060676644C1__INCLUDED_)
#define AFX_CAMERAIO_H__A2882C82_7CFB_11D4_9155_0060676644C1__INCLUDED_

#include "Apogee.h"

enum Camera_Interface{
    Camera_Interface_ISA = 0,
    Camera_Interface_PPI,
    Camera_Interface_PCI
};

enum Camera_SensorType{
    Camera_SensorType_CCD = 0,
    Camera_SensorType_CMOS
};

const long MAXCOLUMNS = 16383;
const long MAXROWS = 16383;
const long MAXHBIN = 8;
const long MAXVBIN = 255;

// Number of write only registers
const long NumWriteRegisters = 8;

const long RegISA_Command = 0x000;          // Register 1 in ISA firmware
const long Reg_Command = 0;                 // Register 1 shadow
const unsigned short RegBit_TDIMode = 0x1;          // Bit 0
const unsigned short RegBit_StartTimer = 0x2;       // Bit 1
const unsigned short RegBit_ShutterOverride = 0x4;  // Bit 2
const unsigned short RegBit_ResetSystem = 0x8;      // Bit 3
const unsigned short RegBit_FIFOCache = 0x10;       // Bit 4
const unsigned short RegBit_TriggerEnable = 0x20;   // Bit 5
const unsigned short RegBit_StopFlushing = 0x40;    // Bit 6
const unsigned short RegBit_ShutterEnable = 0x80;   // Bit 7
const unsigned short RegBit_CoolerShutdown = 0x100; // Bit 8
const unsigned short RegBit_DoneReading = 0x200;    // Bit 9
const unsigned short RegBit_TimerLoad = 0x400;      // Bit 10
const unsigned short RegBit_StartNextLine = 0x800;  // Bit 11
const unsigned short RegBit_StartFlushing = 0x1000; // Bit 12
const unsigned short RegBit_Focus = 0x2000;         // Bit 13
const unsigned short RegBit_CableLength = 0x4000;   // Bit 14
const unsigned short RegBit_CoolerEnable = 0x8000;  // Bit 15

const long RegISA_Timer = 0x002;            // Register 2 in ISA firmware
const long Reg_Timer = 1;                   // Register 2 shadow
const unsigned short RegBitShift_Timer = 0;         // Bit 0
const unsigned short RegBitMask_Timer = 0xFFFF;     // 16 bits

const long RegISA_VBinning = 0x004;         // Register 3 in ISA firmware
const long Reg_VBinning = 2;                // Register 3 shadow
const unsigned short RegBitShift_Timer2 = 0;        // Bit 0
const unsigned short RegBitMask_Timer2 = 0xF;       // 4 bits
const unsigned short RegBitShift_VBinning = 0x8;    // Bit 8
const unsigned short RegBitMask_VBinning = 0xFF;    // 8 bits

const long RegISA_AICCounter = 0x006;       // Register 4 in ISA firmware
const long Reg_AICCounter = 3;              // Register 4 shadow
const unsigned short RegBitShift_AICCounter = 0;    // Bit 0
const unsigned short RegBitMask_AICCounter = 0xFFF; // 12 bits
const unsigned short RegBitShift_Test2 = 0xC;       // Bit 12
const unsigned short RegBitMask_Test2 = 0xF;        // 4 bits

const long RegISA_TempSetPoint = 0x008;     // Register 5 in ISA firmware
const long Reg_TempSetPoint = 4;            // Register 5 shadow
const unsigned short RegBitShift_TempSetPoint = 0;  // Bit 0
const unsigned short RegBitMask_TempSetPoint = 0xFF;// 8 bits
const unsigned short RegBitShift_PortControl = 0x8; // Bit 8
const unsigned short RegBitMask_PortControl = 0xFF; // 8 bits

const long RegISA_PixelCounter = 0x00a;     // Register 6 in ISA firmware
const long Reg_PixelCounter = 5;            // Register 6 shadow
const unsigned short RegBitShift_PixelCounter = 0;      // Bit 0
const unsigned short RegBitMask_PixelCounter = 0xFFF;   // 12 bits
const unsigned short RegBitShift_HBinning = 0xC;        // Bit 12
const unsigned short RegBitMask_HBinning = 0x7;         // 3 bits
const unsigned short RegBit_LoopLock = 0x8000;          // Bit 15

const long RegISA_LineCounter = 0x00c;      // Register 7 in ISA firmware
const long Reg_LineCounter = 6;             // Register 7 shadow
const unsigned short RegBitShift_LineCounter = 0;       // Bit 0
const unsigned short RegBitMask_LineCounter = 0xFFF;    // 12 bits
const unsigned short RegBitShift_Mode = 0xC;            // Bit 12
const unsigned short RegBitMask_Mode = 0xF;             // 4 bits

const long RegISA_BICCounter = 0x00e;       // Register 8 in ISA firmware
const long Reg_BICCounter = 7;              // Register 8 shadow
const unsigned short RegBitShift_BICCounter = 0;    // Bit 0
const unsigned short RegBitMask_BICCounter = 0xFFF; // 12 bits
const unsigned short RegBitShift_Test = 0xC;        // Bit 12
const unsigned short RegBitMask_Test = 0xF;         // 4 bits

const long RegISA_ImageData = 0x000;        // Register 9 in ISA firmware
const long Reg_ImageData = 8;               // Register 9
const unsigned short RegBitShift_ImageData = 0;     // Bit 0
const unsigned short RegBitMask_ImageData = 0xFFFF; // 16 bits

const long RegISA_TempData = 0x002;     // Register 10 in ISA firmware
const long Reg_TempData = 9;                // Register 10
const unsigned short RegBitShift_TempData = 0;  // Bit 0
const unsigned short RegBitMask_TempData = 0xFF;    // 8 bits

const long RegISA_Status = 0x006;           // Register 11 in firmware
const long Reg_Status = 10;                 // Register 11
const unsigned short RegBit_Exposing = 0x1;         // Bit 0
const unsigned short RegBit_LineDone = 0x2;         // Bit 1
const unsigned short RegBit_CacheReadOK = 0x4;      // Bit 2
const unsigned short RegBit_TempAtMin = 0x10;       // Bit 4
const unsigned short RegBit_TempAtMax = 0x20;       // Bit 5
const unsigned short RegBit_ShutdownComplete = 0x40;// Bit 6
const unsigned short RegBit_TempAtSetPoint = 0x80;  // Bit 7
const unsigned short RegBit_GotTrigger = 0x400;     // Bit 10
const unsigned short RegBit_FrameDone = 0x800;      // Bit 11
const unsigned short RegBit_LoopbackTest = 0x8000;  // Bit 15

const long RegISA_CommandReadback = 0x008;  // Register 12 in ISA firmware
const long Reg_CommandReadback = 11;        // Register 12
// Use RegBit offsets from Reg_Command

const long RegPCI_Command               = 0x000;        // Register 1 in PCI firmware
const long RegPCI_CommandRead   = 0x020;
const long RegPCI_Timer                 = 0x004;        // Register 2 in PCI firmware
const long RegPCI_TimerRead             = 0x024;
const long RegPCI_VBinning              = 0x008;        // Register 3 in PCI firmware
const long RegPCI_VBinningRead  = 0x028;
const long RegPCI_AICCounter            = 0x00C;        // Register 4 in PCI firmware
const long RegPCI_AICCounterRead        = 0x02C;
const long RegPCI_TempSetPoint          = 0x010;        // Register 5 in PCI firmware
const long RegPCI_TempSetPointRead      = 0x030;
const long RegPCI_PixelCounter          = 0x014;        // Register 6 in PCI firmware
const long RegPCI_PixelCounterRead      = 0x034;
const long RegPCI_LineCounter           = 0x018;        // Register 7 in PCI firmware
const long RegPCI_LineCounterRead       = 0x038;
const long RegPCI_BICCounter            = 0x01C;        // Register 8 in PCI firmware
const long RegPCI_BICCounterRead        = 0x03C;
const long RegPCI_ImageData = 0x000;            // Register 9 in PCI firmware
const long RegPCI_TempData = 0x004;                     // Register 10 in PCI firmware
const long RegPCI_Status = 0x00C;                       // Register 11 in firmware
const long RegPCI_CommandReadback = 0x010;      // Register 12 in PCI firmware



class CCameraIO
{
public:

    CCameraIO();
    virtual ~CCameraIO();

    // Low level read write methods - Overridables
        bool InitDriver(unsigned short camnum);
        long ReadLine( long SkipPixels, long Pixels, unsigned short* pLineBuffer );
        long Write( unsigned short reg, unsigned short val );
        long Read( unsigned short reg, unsigned short& val );
 
    // Camera Settings

    Camera_Status read_Status();        // Current camera state
                                        // <0: error codes
                                        // 0: idle
                                        // 1: flushing
                                        // 2: waiting for trigger
                                        // 3: exposing
                                        // 4: reading
                                        // 5: downloading
                                        // 6: line ready
                                        // 7: image ready

    bool read_Present();                // True if camera is present, false otherwise.
    
    bool read_Shutter();                // Current shutter state, true = open, false = closed.
    void write_Shutter( bool val );
    
    bool read_ForceShutterOpen();               // True: Forces shutter permanently open. False: allows
    void write_ForceShutterOpen( bool val );    // normal shutter operation.

    bool read_LongCable();              // Long cable mode.
    void write_LongCable( bool val );           

    short read_Mode();                  // First four bits map to Mode bits used for
    void write_Mode( short val );       // special functions or camera configurations.

    short read_TestBits();              // First four bits to Test bits used for
    void write_TestBits( short val );       // troubleshooting.
    
    short read_Test2Bits();             // First four bits map to Test2 bits used for
    void write_Test2Bits( short val );  // special functions or camera configurations.

    bool read_FastReadout();                // Fast readout mode (used for focusing).
    void write_FastReadout( bool val ); // True means fast focus is on          

    bool read_UseTrigger();             // Triggered exposure mode.
    void write_UseTrigger( bool val );  // True means triggered exposure is on.

    bool m_HighPriority;        // Bost thread priority level during download

    short m_PPRepeat;           // Delay used on parallel port systems.
    
    short m_DataBits;           // Digitization resolution, 8 - 18.

    bool m_FastShutter;         // Capable of 0.001 sec exposure resolution

    bool m_GuiderRelays;        // Capable of outputing autoguider signals

    short m_MaxBinX, m_MaxBinY; // Maximum binning factors  
    
    double m_MaxExposure;   // Maximum exposure length
    double m_MinExposure;   // Minimum exposure length

    double m_Timeout;       // camera polling timeout value

    // Cooler Settings
    // N.B. DAC units = ( m_TempScale * CoolerSetPoint (deg. C ) ) + m_TempCalibration;
    // N.B. Temperature (deg. C) = (DAC units - m_TempCalibration) / m_TempScale
    
    double read_CoolerSetPoint();               // Returns/sets setpoint temperature in degrees
    void write_CoolerSetPoint( double val );    // Celcius.

    Camera_CoolerStatus read_CoolerStatus();    // Returns current cooler status

    Camera_CoolerMode read_CoolerMode();        // Returns/sets current cooler operation mode.
    void write_CoolerMode( Camera_CoolerMode val );

    double read_Temperature();  // Current temperature in degrees Celcius.
    
    bool m_TempControl;         // Temperature can be externally controlled
    short m_TempCalibration;    // Temperature calibration factor.
    double m_TempScale;         // Temperature scaling factor.

    // Exposure Settings
    // The following variables are latched in Expose method, until next Reset or GetImage

    short m_BinX, m_BinY;       // Horizontal and vertical binning.
    short m_StartX, m_StartY;   // Zero based subframe start position in unbinned pixels.
    short m_NumX, m_NumY;       // Subframe size in binned pixels.

    // Geometry Settings
    // The following variables are latched in Expose method, until next Reset or GetImage
    
    short m_Columns, m_Rows;        // Total columns/rows on CCD (physical).
    short m_ImgColumns, m_ImgRows;  // Unbinned columns/rows in imaging area
    short m_SkipC, m_SkipR;         // Deleted data columns/rows not to be displayed or saved
    short m_HFlush, m_VFlush;       // Horizontal/Vertical flush binning.
    short m_BIC, m_BIR;             // Before Image Column/Row count (dark non-imaging pixels).
    
    // CCD Settings

    char m_Sensor[ 256 ];   // Sensor model installed in camera (i.e. Sensor = SITe 502).
    bool m_Color;           // Sensor has color dyes
    double m_Noise;         // Read out noise in e-.
    double m_Gain;          // Gain in e-/ADU units.
    double m_PixelXSize;    // Size of pixel in X direction in micrometers.
    double m_PixelYSize;    // Size of pixel in Y direction in micrometers.

    // System methods

    // Resets camera to idle state, will terminate current exposure.
    void Reset();

    // Mask user requested set of IRQS
//  void MaskIrqs();

    // Restore default IRQ mask
//  void UnmaskIrqs();

    // Starts flushing the camera (which should be the normal idle state)
    // If Rows is non-negative, only the specified number of rows are flushed,
    // in which case the method will return only when flushing is completed.
    void Flush( short Rows = -1 );

    // Output byte to auxillary output port (e.g. for driving guider relays).
    void AuxOutput( unsigned char val );

    // Write a 16 bit value to register 1 to 8.
    void RegWrite( short reg, unsigned short val );

    // Read a 16 bit value from register 9 to 12.
    void RegRead( short reg, unsigned short& val );

    // Move the filterwheel to the home position - failure indicates no filterwheel
    //attached or broken filterwheel
    bool FilterHome();
    
    // Move filterwheel to the given slot
    void FilterSet( short Slot );

    // Normal exposure methods

    // The Duration parameter is the exposure time in seconds. The Light parameter controls
    // the status of the shutter during the exposure, Light = True opens the shutter, Light
    // = False closes the shutter. Returns immediately after invocation, poll the CameraStatus
    // property to determine the start time of a triggered exposure and the end of an exposure.
    bool Expose( double Duration, bool Light );

    // Returns the pImageData parameter which is a pointer to unsigned short data with NumX*NumY
    // elements.  Can be overridden if necessary
    virtual bool GetImage( unsigned short* pImageData, short& xSize, short& ySize );

    /*virtual bool BufferImage(char *bufferName );*/

    // Drift scan methods

    // Begins clocking and digitization of a single line of data begining with a vertical clock
    // sequence and ending with a buffer full of line data. Poll the CameraStatus property to
    // determine when the data is ready for download.
    bool DigitizeLine();

    // Returns the pLineData parameter which is a pointer to unsigned short data with NumX elements.
    bool GetLine( unsigned short* pLineData, short& xSize );

    /* TODO enable this back after removing some deps */
    /*bool BufferDriftScan(char *bufferName, int delay, int rowCount, int nblock , int npipe);*/

    // Easy to use methods

    // Combination of the Expose and GetImage methods. Blocks calling thread for duration
    // of exposure and readout.
    bool Snap( double Duration, bool Light, unsigned short* pImageData, short& xSize, short& ySize );

// Internal variables to keep track of things that can not be read from the firmware
// directly, or are a combination of firmware setting

    bool m_TDI;                 // Time drift integration mode

    bool m_WaitingforTrigger;   // camera is waiting for external trigger
    bool m_WaitingforImage;     // camera is exposing and wiating for an to available
    bool m_WaitingforLine;      // camera is clocking and digitizing a row of data

    short m_RegisterOffset;     // Offset from base address used in parallel port systems.
    
    short m_FilterPosition;     // Current filter position
    short m_FilterStepPos;      // Current filter position in our internal array

    bool m_Shutter;             // Last known shutter state
    Camera_Status m_Status;     // Last known camera status

    Camera_Interface m_Interface;       // String acronyms may be used in INI file.
                                        // 0 or ISA: Industry Standard Architecture bus
                                        // 1 or PPI: Parallel Port Interface 
                                        // 2 or PCI: Peripheral Component Interface
    
    Camera_SensorType m_SensorType;     // 0 or CCD: Charge Coupled Device
                                        // 1 or CMOS: Complementary Metal-Oxide-Silicon

    Camera_CoolerStatus m_CoolerStatus;     // Last known cooler status.
    unsigned int m_IRQMask;         // Set of IRQs masked on user request                                       // 0: Off
                                            // 1: Ramping to set point
                                            // 2: Correcting
                                            // 3: Ramping to ambient
                                            // 4: At ambient
                                            // 5: Max cooling limit
                                            // 6: Min cooling limit
                                            // 7: At set point

    // Latched public variables used during Exposure..GetImage sequence
    short m_ExposureBinX, m_ExposureBinY;       // Horizontal and vertical binning.
    short m_ExposureStartX, m_ExposureStartY;   // Subframe start position in unbinned pixels.
    short m_ExposureNumX, m_ExposureNumY;       // Subframe size in binned pixels.
    short m_ExposureColumns, m_ExposureRows;    // Total columns/rows on CCD (physical).
    short m_ExposureSkipC, m_ExposureSkipR;     // Deleted data columns/rows not to be displayed or saved to disk.
    short m_ExposureHFlush, m_ExposureVFlush;   // Horizontal/Vertical flush binning.
    short m_ExposureBIC, m_ExposureBIR;         // Before Image Column/Row count (dark non-imaging pixels).
    unsigned short m_ExposureAIC;               // Calculated After Image Column count (dark non-imaging pixels).
    unsigned short m_ExposureRemainingLines;    // Number of lines to be clocked out by GetImage
    unsigned short m_ExposureAIR;               // Number of lines to be flushed after GetImage

    // Write register shadow variables
    unsigned short m_RegShadow[ NumWriteRegisters ];
    
    unsigned short m_FastShutterBits_Mode;      // Mask to enable fast shutter mode
    unsigned short m_FastShutterBits_Test;      // Mask to enable fast shutter mode
    
    // Internal helper routines

    void LoadLineCounter( unsigned short rows );
    void LoadColumnLayout( unsigned short aic, unsigned short bic, unsigned short pixels );
    void LoadTimerAndBinning( double Duration, unsigned short HBin, unsigned short VBin );
    
    void StartFlushing();
    void StopFlushing();

    void InitDefaults();
#ifndef WITHPPI
long ReadImage(short unsigned int *);
long InternalReadLine(bool, long int, long int, unsigned short *);
#endif

private:
        unsigned short m_BaseAddressp2;
        unsigned int   saveIRQS;
        int fileHandle;
#ifdef WITHPPI
        inline void RegisterSelect( unsigned short reg );
        inline unsigned short INPW();
        inline void OUTPW( unsigned short val );                               
#endif

};

#endif // !defined(AFX_CAMERAIO_H__A2882C82_7CFB_11D4_9155_0060676644C1__INCLUDED_)

kstars

Skip menu "kstars"

• Main Page
• Modules
• Class Hierarchy
• Alphabetical List
• Class List
• File List
• Class Members
• Related Pages

API Reference

Skip menu "API Reference"

• keduca
• kstars

Generated for API Reference by doxygen 1.5.9
This website is maintained by Adriaan de Groot and Allen Winter.
KDE^® and the K Desktop Environment^® logo are registered trademarks of KDE e.V. | Legal