Документ взят из кэша поисковой машины. Адрес оригинального документа : http://www.astro.louisville.edu/software/sbig/archive/xmccd-4.2.1/xmccd-4.2.1/libapogee/src/apogeeLinux.i Дата изменения: Sun Feb 11 05:37:46 2007 Дата индексирования: Sun Apr 10 06:11:20 2016 Кодировка: Поисковые слова: р р р р р р п п р р р р р р

enum Camera_Status{
Camera_Status_Idle = 0,
Camera_Status_Waiting,
Camera_Status_Exposing,
Camera_Status_Downloading,
Camera_Status_LineReady,
Camera_Status_ImageReady,
Camera_Status_Flushing
};

enum Camera_CoolerStatus{
Camera_CoolerStatus_Off = 0,
Camera_CoolerStatus_RampingToSetPoint,
Camera_CoolerStatus_Correcting,
Camera_CoolerStatus_RampingToAmbient,
Camera_CoolerStatus_AtAmbient,
Camera_CoolerStatus_AtMax,
Camera_CoolerStatus_AtMin,
Camera_CoolerStatus_AtSetPoint
};

enum Camera_CoolerMode{
Camera_CoolerMode_Off = 0,
Camera_CoolerMode_On,
Camera_CoolerMode_Shutdown
};

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

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 );
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
// 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();
};