libapogee2-2.2/0000755000175000017500000000000011145372200011171 5ustar jrjrlibapogee2-2.2/ApnCamTable.cpp0000644000175000017500000001730611110507150014007 0ustar jrjr////////////////////////////////////////////////////////////////////// // // ApnCamTable.cpp // // Copyright (c) 2003-2005 Apogee Instruments, Inc. // ////////////////////////////////////////////////////////////////////// #include #include "ApnCamTable.h" #define ALTA_MODEL_PREFIX "Alta-" #define ASCENT_MODEL_PREFIX "Ascent-" void ApnCamModelLookup( unsigned short CamId, int FwRev, unsigned short Interface, char *szCamModel ) { char szModelNumber[20]; bool Error; bool IsAltaCamera; bool IsAscentCamera; unsigned short ModelIdentifier; IsAltaCamera = ApnCamModelIsAlta( CamId, FwRev ); IsAscentCamera = ApnCamModelIsAscent( CamId, FwRev ); if ( (IsAltaCamera && IsAscentCamera) || (!IsAltaCamera && !IsAscentCamera) ) { strcpy( szCamModel, "Unknown" ); return; } else { if ( IsAltaCamera ) { strcpy( szCamModel, ALTA_MODEL_PREFIX ); ModelIdentifier = CamId & APN_MASK_CAMERA_ID_ALTA; } else if ( IsAscentCamera ) { strcpy( szCamModel, ASCENT_MODEL_PREFIX ); ModelIdentifier = CamId & APN_MASK_CAMERA_ID_ASCENT; } } Error = false; switch( ModelIdentifier ) { case APN_ALTA_KAF0401E_CAM_ID: strcpy( szModelNumber, APN_ALTA_KAF0401E_CAM_SZ ); break; case APN_ALTA_KAF1602E_CAM_ID: strcpy( szModelNumber, APN_ALTA_KAF1602E_CAM_SZ ); break; case APN_ALTA_KAF0261E_CAM_ID: strcpy( szModelNumber, APN_ALTA_KAF0261E_CAM_SZ ); break; case APN_ALTA_KAF1301E_CAM_ID: strcpy( szModelNumber, APN_ALTA_KAF1301E_CAM_SZ ); break; case APN_ALTA_KAF1001E_CAM_ID: strcpy( szModelNumber, APN_ALTA_KAF1001E_CAM_SZ ); break; case APN_ALTA_KAF1001ENS_CAM_ID: strcpy( szModelNumber, APN_ALTA_KAF1001ENS_CAM_SZ ); break; case APN_ALTA_KAF10011105_CAM_ID: strcpy( szModelNumber, APN_ALTA_KAF10011105_CAM_SZ ); break; case APN_ALTA_KAF3200E_CAM_ID: strcpy( szModelNumber, APN_ALTA_KAF3200E_CAM_SZ ); break; case APN_ALTA_KAF6303E_CAM_ID: strcpy( szModelNumber, APN_ALTA_KAF6303E_CAM_SZ ); break; case APN_ALTA_KAF16801E_CAM_ID: strcpy( szModelNumber, APN_ALTA_KAF16801E_CAM_SZ ); break; case APN_ALTA_KAF09000_CAM_ID: strcpy( szModelNumber, APN_ALTA_KAF09000_CAM_SZ ); break; case APN_ALTA_KAF09000X_CAM_ID: strcpy( szModelNumber, APN_ALTA_KAF09000X_CAM_SZ ); break; case APN_ALTA_KAF0401EB_CAM_ID: strcpy( szModelNumber, APN_ALTA_KAF0401EB_CAM_SZ ); break; case APN_ALTA_KAF1602EB_CAM_ID: strcpy( szModelNumber, APN_ALTA_KAF1602EB_CAM_SZ ); break; case APN_ALTA_KAF0261EB_CAM_ID: strcpy( szModelNumber, APN_ALTA_KAF0261EB_CAM_SZ ); break; case APN_ALTA_KAF1301EB_CAM_ID: strcpy( szModelNumber, APN_ALTA_KAF1301EB_CAM_SZ ); break; case APN_ALTA_KAF1001EB_CAM_ID: strcpy( szModelNumber, APN_ALTA_KAF1001EB_CAM_SZ ); break; case APN_ALTA_KAF6303EB_CAM_ID: strcpy( szModelNumber, APN_ALTA_KAF6303EB_CAM_SZ ); break; case APN_ALTA_KAF3200EB_CAM_ID: strcpy( szModelNumber, APN_ALTA_KAF3200EB_CAM_SZ ); break; case APN_ALTA_KAF16803_CAM_ID: strcpy( szModelNumber, APN_ALTA_KAF16803_CAM_SZ ); break; case APN_ALTA_TH7899_CAM_ID: strcpy( szModelNumber, APN_ALTA_TH7899_CAM_SZ ); break; case APN_ALTA_S101401107_CAM_ID: strcpy( szModelNumber, APN_ALTA_S101401107_CAM_SZ ); break; case APN_ALTA_S101401109_CAM_ID: strcpy( szModelNumber, APN_ALTA_S101401109_CAM_SZ ); break; case APN_ALTA_CCD4710_CAM_ID: strcpy( szModelNumber, APN_ALTA_CCD4710_CAM_SZ ); break; case APN_ALTA_CCD4710ALT_CAM_ID: strcpy( szModelNumber, APN_ALTA_CCD4710ALT_CAM_SZ ); break; case APN_ALTA_CCD4240_CAM_ID: strcpy( szModelNumber, APN_ALTA_CCD4240_CAM_SZ ); break; case APN_ALTA_CCD5710_CAM_ID: strcpy( szModelNumber, APN_ALTA_CCD5710_CAM_SZ ); break; case APN_ALTA_CCD3011_CAM_ID: strcpy( szModelNumber, APN_ALTA_CCD3011_CAM_SZ ); break; case APN_ALTA_CCD5520_CAM_ID: strcpy( szModelNumber, APN_ALTA_CCD5520_CAM_SZ ); break; case APN_ALTA_CCD4720_CAM_ID: strcpy( szModelNumber, APN_ALTA_CCD4720_CAM_SZ ); break; case APN_ALTA_CCD7700_CAM_ID: strcpy( szModelNumber, APN_ALTA_CCD7700_CAM_SZ ); break; case APN_ALTA_CCD4710B_CAM_ID: strcpy( szModelNumber, APN_ALTA_CCD4710B_CAM_SZ ); break; case APN_ALTA_CCD4240B_CAM_ID: strcpy( szModelNumber, APN_ALTA_CCD4240B_CAM_SZ ); break; case APN_ALTA_CCD5710B_CAM_ID: strcpy( szModelNumber, APN_ALTA_CCD5710B_CAM_SZ ); break; case APN_ALTA_CCD3011B_CAM_ID: strcpy( szModelNumber, APN_ALTA_CCD3011B_CAM_SZ ); break; case APN_ALTA_CCD5520B_CAM_ID: strcpy( szModelNumber, APN_ALTA_CCD5520B_CAM_SZ ); break; case APN_ALTA_CCD4720B_CAM_ID: strcpy( szModelNumber, APN_ALTA_CCD4720B_CAM_SZ ); break; case APN_ALTA_CCD7700B_CAM_ID: strcpy( szModelNumber, APN_ALTA_CCD7700B_CAM_SZ ); break; case APN_ALTA_KAI2001ML_CAM_ID: strcpy( szModelNumber, APN_ALTA_KAI2001ML_CAM_SZ ); break; case APN_ALTA_KAI2020ML_CAM_ID: strcpy( szModelNumber, APN_ALTA_KAI2020ML_CAM_SZ ); break; case APN_ALTA_KAI4020ML_CAM_ID: strcpy( szModelNumber, APN_ALTA_KAI4020ML_CAM_SZ ); break; case APN_ALTA_KAI11000ML_CAM_ID: strcpy( szModelNumber, APN_ALTA_KAI11000ML_CAM_SZ ); break; case APN_ALTA_KAI2001CL_CAM_ID: strcpy( szModelNumber, APN_ALTA_KAI2001CL_CAM_SZ ); break; case APN_ALTA_KAI2020CL_CAM_ID: strcpy( szModelNumber, APN_ALTA_KAI2020CL_CAM_SZ ); break; case APN_ALTA_KAI4020CL_CAM_ID: strcpy( szModelNumber, APN_ALTA_KAI4020CL_CAM_SZ ); break; case APN_ALTA_KAI11000CL_CAM_ID: strcpy( szModelNumber, APN_ALTA_KAI11000CL_CAM_SZ ); break; case APN_ALTA_KAI2020MLB_CAM_ID: strcpy( szModelNumber, APN_ALTA_KAI2020MLB_CAM_SZ ); break; case APN_ALTA_KAI4020MLB_CAM_ID: strcpy( szModelNumber, APN_ALTA_KAI4020MLB_CAM_SZ ); break; case APN_ALTA_KAI2020CLB_CAM_ID: strcpy( szModelNumber, APN_ALTA_KAI2020CLB_CAM_SZ ); break; case APN_ALTA_KAI4020CLB_CAM_ID: strcpy( szModelNumber, APN_ALTA_KAI4020CLB_CAM_SZ ); break; // Ascent cameras case APN_ASCENT_KAF0402E_CAM_ID: strcpy( szModelNumber, APN_ASCENT_KAF0402E_CAM_SZ ); break; case APN_ASCENT_KAF0402E2_CAM_ID: strcpy( szModelNumber, APN_ASCENT_KAF0402E2_CAM_SZ ); break; case APN_ASCENT_KAF0402E3_CAM_ID: strcpy( szModelNumber, APN_ASCENT_KAF0402E3_CAM_SZ ); break; case APN_ASCENT_KAF0402E4_CAM_ID: strcpy( szModelNumber, APN_ASCENT_KAF0402E4_CAM_SZ ); break; case APN_ASCENT_KAI340_CAM_ID: strcpy( szModelNumber, APN_ASCENT_KAI340_CAM_SZ ); break; case APN_ASCENT_KAI2000_CAM_ID: strcpy( szModelNumber, APN_ASCENT_KAI2000_CAM_SZ ); break; case APN_ASCENT_KAI4000_CAM_ID: strcpy( szModelNumber, APN_ASCENT_KAI4000_CAM_SZ ); break; case APN_ASCENT_KAI16000_CAM_ID: strcpy( szModelNumber, APN_ASCENT_KAI16000_CAM_SZ ); break; default: Error = true; break; } if ( Error ) { strcpy( szCamModel, "Unknown" ); } else { if ( Interface == 0 ) // Network Interface strcat( szCamModel, "E" ); if ( Interface == 1 ) // USB 2.0 Interface { if ( IsAltaCamera ) strcat( szCamModel, "U" ); else if ( IsAscentCamera ) strcat( szCamModel, "A" ); } strcat( szCamModel, szModelNumber ); } } bool ApnCamModelIsAlta( unsigned short CamId, int FwRev ) { bool IsAltaPlatform; IsAltaPlatform = false; if ( FwRev < 100 ) IsAltaPlatform = true; return ( IsAltaPlatform ); } bool ApnCamModelIsAscent( unsigned short CamId, int FwRev ) { bool IsAscentPlatform; IsAscentPlatform = false; if ( FwRev < 100 ) IsAscentPlatform = false; else if ( (CamId & APN_SIG_CAMERA_ID_ASCENT) == APN_SIG_CAMERA_ID_ASCENT ) IsAscentPlatform = true; return ( IsAscentPlatform ); } libapogee2-2.2/ApnCamera_Linux.cpp0000644000175000017500000000725411110507150014707 0ustar jrjr// ApnCamera.cpp: extras from the CCameraIO class. // ////////////////////////////////////////////////////////////////////// #include "stdafx.h" #include "ApnCamera.h" #include "ApnCamTable.h" #include "ApnCamData.h" #ifndef ALTA_STANDALONE #include "tcl.h" #include "ccd.h" #endif // Determine if camera is present // True if camera is present, false otherwise. bool CApnCamera::read_Present() { // OutputDebugString( "read_Present()" ); USHORT ApStatus; USHORT DatumA; USHORT DatumB; char szMsg[80]; DatumA = 0x0; DatumB = 0x0; ApStatus = 0; Write( FPGA_REG_SCRATCH, 0x8086 ); Read( FPGA_REG_SCRATCH, DatumA ); Write( FPGA_REG_SCRATCH, 0x1F2F ); Read( FPGA_REG_SCRATCH, DatumB ); if ( (DatumA != 0x8086) || (DatumB != 0x1F2F) ) { // OutputDebugString( "read_Present FAILED." ); sprintf( szMsg, "read_Present FAILED. DatumA: 0x%X DatumB: 0x%X", DatumA, DatumB ); // OutputDebugString( szMsg ); return false; } // OutputDebugString( "read_Present SUCCESS" ); return true; } bool CApnCamera::sensorInfo() { strcpy(m_Sensor,m_ApnSensorInfo->m_Sensor); strcpy(m_CameraModel,m_ApnSensorInfo->m_CameraModel); m_CameraId = m_ApnSensorInfo->m_CameraId; m_InterlineCCD = m_ApnSensorInfo->m_InterlineCCD; m_SupportsSerialA = m_ApnSensorInfo->m_SupportsSerialA; m_SupportsSerialB = m_ApnSensorInfo->m_SupportsSerialB; m_SensorTypeCCD =m_ApnSensorInfo->m_SensorTypeCCD; m_TotalColumns =m_ApnSensorInfo->m_TotalColumns; m_ImagingColumns= m_ApnSensorInfo->m_ImagingColumns; m_ClampColumns= m_ApnSensorInfo->m_ClampColumns; m_PreRoiSkipColumns =m_ApnSensorInfo->m_PreRoiSkipColumns; m_PostRoiSkipColumns= m_ApnSensorInfo->m_PostRoiSkipColumns; m_OverscanColumns =m_ApnSensorInfo->m_OverscanColumns; m_TotalRows =m_ApnSensorInfo->m_TotalRows; m_ImagingRows =m_ApnSensorInfo->m_ImagingRows; m_UnderscanRows= m_ApnSensorInfo->m_UnderscanRows; m_OverscanRows =m_ApnSensorInfo->m_OverscanRows; m_VFlushBinning =m_ApnSensorInfo->m_VFlushBinning; m_HFlushDisable =m_ApnSensorInfo->m_HFlushDisable; m_ShutterCloseDelay= m_ApnSensorInfo->m_ShutterCloseDelay; m_PixelSizeX = m_ApnSensorInfo->m_PixelSizeX; m_PixelSizeY = m_ApnSensorInfo->m_PixelSizeY; m_Color = m_ApnSensorInfo->m_Color; // m_ReportedGainTwelveBit = m_ApnSensorInfo->m_ReportedGainTwelveBit; m_ReportedGainSixteenBit= m_ApnSensorInfo->m_ReportedGainSixteenBit; m_MinSuggestedExpTime = m_ApnSensorInfo->m_MinSuggestedExpTime; // m_TempRegRate =m_ApnSensorInfo->m_TempRegRate; m_TempRampRateOne =m_ApnSensorInfo->m_TempRampRateOne; m_TempRampRateTwo =m_ApnSensorInfo->m_TempRampRateTwo; // m_DefaultGainTwelveBit =m_ApnSensorInfo->m_DefaultGainTwelveBit; // m_DefaultOffsetTwelveBit= m_ApnSensorInfo->m_DefaultOffsetTwelveBit; // m_DefaultRVoltage =m_ApnSensorInfo->m_DefaultRVoltage; return true; } #ifndef ALTA_STANDALONE bool CApnCamera::BufferImage(char *bufferName ) { unsigned short *pImageData; bool status; short cols,rows,hbin,vbin; unsigned short xSize, ySize; unsigned long count; cols = m_pvtExposurePixelsH; rows = m_pvtExposurePixelsV; /* ALTA code has already applied binning calculations*/ hbin = 1; vbin = 1; pImageData = (unsigned short *)CCD_locate_buffer(bufferName, 2 , cols, rows, hbin, vbin ); if (pImageData == NULL) { return 0; } status = GetImageData(pImageData, xSize, ySize, count); return status; } bool CApnCamera::BufferDriftScan(char *bufferName, int delay, int rowCount, int nblock , int npipe) { unsigned short *pImageData, *ptr; bool status; int irow; short cols,rows,hbin,vbin; cols = m_pvtExposurePixelsH; rows = rowCount; hbin = m_pvtRoiBinningH; vbin = 1; return 1; } #endif libapogee2-2.2/ApnCamData_ASCENT0402ME4.h0000644000175000017500000000223211110507150015137 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_ASCENT0402ME4.h: Interface file for the CApnCamData_ASCENT0402ME4 class. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #if _MSC_VER > 1000 #pragma once #endif // _MSC_VER> 1000 #include "ApnCamData.h" class CApnCamData_ASCENT0402ME4 : public CApnCamData { public: CApnCamData_ASCENT0402ME4(); virtual ~CApnCamData_ASCENT0402ME4(); void Initialize(); private: void set_vpattern(); void set_hpattern_clamp_sixteen(); void set_hpattern_skip_sixteen(); void set_hpattern_roi_sixteen(); void set_hpattern_clamp_twelve(); void set_hpattern_skip_twelve(); void set_hpattern_roi_twelve(); void set_hpattern( APN_HPATTERN_FILE *Pattern, unsigned short Mask, unsigned short BinningLimit, unsigned short RefNumElements, unsigned short SigNumElements, unsigned short BinNumElements[], unsigned short RefPatternData[], unsigned short SigPatternData[], unsigned short BinPatternData[][APN_MAX_PATTERN_ENTRIES] ); }; libapogee2-2.2/ApnCamData_KAF1001ENS.cpp0000644000175000017500000006141211110507150015157 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_KAF1001ENS.cpp: Implementation file for the CApnCamData_KAF1001ENS class. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #include "ApnCamData_KAF1001ENS.h" #include #include #include ///////////////////////////////////////////////////////////// // Construction/Destruction ///////////////////////////////////////////////////////////// CApnCamData_KAF1001ENS::CApnCamData_KAF1001ENS() { } CApnCamData_KAF1001ENS::~CApnCamData_KAF1001ENS() { } void CApnCamData_KAF1001ENS::Initialize() { strcpy( m_Sensor, "KAF1001ENS" ); strcpy( m_CameraModel, "6" ); m_CameraId = 30; m_InterlineCCD = false; m_SupportsSerialA = true; m_SupportsSerialB = true; m_SensorTypeCCD = true; m_TotalColumns = 1044; m_ImagingColumns = 1024; m_ClampColumns = 8; m_PreRoiSkipColumns = 0; m_PostRoiSkipColumns = 0; m_OverscanColumns = 12; m_TotalRows = 1032; m_ImagingRows = 1024; m_UnderscanRows = 4; m_OverscanRows = 4; m_VFlushBinning = 8; m_EnableSingleRowOffset = false; m_RowOffsetBinning = 1; m_HFlushDisable = false; m_ShutterCloseDelay = 0; m_PixelSizeX = 24; m_PixelSizeY = 24; m_Color = false; m_ReportedGainSixteenBit = 3; m_MinSuggestedExpTime = 20.0; m_CoolingSupported = true; m_RegulatedCoolingSupported = true; m_TempSetPoint = -20.0; m_TempRampRateOne = 700; m_TempRampRateTwo = 4000; m_TempBackoffPoint = 2.0; m_PrimaryADType = ApnAdType_Alta_Sixteen; m_AlternativeADType = ApnAdType_Alta_Twelve; m_DefaultGainLeft = 0; m_DefaultOffsetLeft = 250; m_DefaultGainRight = -1; m_DefaultOffsetRight = -1; m_DefaultRVoltage = 1000; m_DefaultSpeed = 0xffff; m_DefaultDataReduction = false; set_vpattern(); set_hpattern_clamp_sixteen(); set_hpattern_skip_sixteen(); set_hpattern_roi_sixteen(); set_hpattern_clamp_twelve(); set_hpattern_skip_twelve(); set_hpattern_roi_twelve(); } void CApnCamData_KAF1001ENS::set_vpattern() { const unsigned short Mask = 0x0; const unsigned short NumElements = 71; unsigned short Pattern[NumElements] = { 0x0000, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0001, 0x0000 }; m_VerticalPattern.Mask = Mask; m_VerticalPattern.NumElements = NumElements; m_VerticalPattern.PatternData = (unsigned short *)malloc(NumElements * sizeof(unsigned short)); for ( int i=0; iMask = Mask; Pattern->BinningLimit = BinningLimit; Pattern->RefNumElements = RefNumElements; Pattern->SigNumElements = SigNumElements; if ( RefNumElements > 0 ) { Pattern->RefPatternData = (unsigned short *)malloc(RefNumElements * sizeof(unsigned short)); for ( i=0; iRefPatternData[i] = RefPatternData[i]; } } if ( SigNumElements > 0 ) { Pattern->SigPatternData = (unsigned short *)malloc(SigNumElements * sizeof(unsigned short)); for ( i=0; iSigPatternData[i] = SigPatternData[i]; } } if ( BinningLimit > 0 ) { for ( i=0; iBinNumElements[i] = BinNumElements[i]; Pattern->BinPatternData[i] = (unsigned short *)malloc(BinNumElements[i] * sizeof(unsigned short)); for ( j=0; jBinPatternData[i][j] = BinPatternData[i][j]; } } } } libapogee2-2.2/ApnCamData_KAI4020ML.h0000644000175000017500000000220611110507150014512 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_KAI4020ML.h: Interface file for the CApnCamData_KAI4020ML class. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #if _MSC_VER > 1000 #pragma once #endif // _MSC_VER> 1000 #include "ApnCamData.h" class CApnCamData_KAI4020ML : public CApnCamData { public: CApnCamData_KAI4020ML(); virtual ~CApnCamData_KAI4020ML(); void Initialize(); private: void set_vpattern(); void set_hpattern_clamp_sixteen(); void set_hpattern_skip_sixteen(); void set_hpattern_roi_sixteen(); void set_hpattern_clamp_twelve(); void set_hpattern_skip_twelve(); void set_hpattern_roi_twelve(); void set_hpattern( APN_HPATTERN_FILE *Pattern, unsigned short Mask, unsigned short BinningLimit, unsigned short RefNumElements, unsigned short SigNumElements, unsigned short BinNumElements[], unsigned short RefPatternData[], unsigned short SigPatternData[], unsigned short BinPatternData[][APN_MAX_PATTERN_ENTRIES] ); }; libapogee2-2.2/ApnCamData_CCD5520.h0000644000175000017500000000217411110507150014260 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_CCD5520.h: Interface file for the CApnCamData_CCD5520 class. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #if _MSC_VER > 1000 #pragma once #endif // _MSC_VER> 1000 #include "ApnCamData.h" class CApnCamData_CCD5520 : public CApnCamData { public: CApnCamData_CCD5520(); virtual ~CApnCamData_CCD5520(); void Initialize(); private: void set_vpattern(); void set_hpattern_clamp_sixteen(); void set_hpattern_skip_sixteen(); void set_hpattern_roi_sixteen(); void set_hpattern_clamp_twelve(); void set_hpattern_skip_twelve(); void set_hpattern_roi_twelve(); void set_hpattern( APN_HPATTERN_FILE *Pattern, unsigned short Mask, unsigned short BinningLimit, unsigned short RefNumElements, unsigned short SigNumElements, unsigned short BinNumElements[], unsigned short RefPatternData[], unsigned short SigPatternData[], unsigned short BinPatternData[][APN_MAX_PATTERN_ENTRIES] ); }; libapogee2-2.2/ApnCamData_CCD3011.h0000644000175000017500000000217411110507150014251 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_CCD3011.h: Interface file for the CApnCamData_CCD3011 class. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #if _MSC_VER > 1000 #pragma once #endif // _MSC_VER> 1000 #include "ApnCamData.h" class CApnCamData_CCD3011 : public CApnCamData { public: CApnCamData_CCD3011(); virtual ~CApnCamData_CCD3011(); void Initialize(); private: void set_vpattern(); void set_hpattern_clamp_sixteen(); void set_hpattern_skip_sixteen(); void set_hpattern_roi_sixteen(); void set_hpattern_clamp_twelve(); void set_hpattern_skip_twelve(); void set_hpattern_roi_twelve(); void set_hpattern( APN_HPATTERN_FILE *Pattern, unsigned short Mask, unsigned short BinningLimit, unsigned short RefNumElements, unsigned short SigNumElements, unsigned short BinNumElements[], unsigned short RefPatternData[], unsigned short SigPatternData[], unsigned short BinPatternData[][APN_MAX_PATTERN_ENTRIES] ); }; libapogee2-2.2/ApnCamData_KAI2020CLB.h0000644000175000017500000000221311110507150014576 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_KAI2020CLB.h: Interface file for the CApnCamData_KAI2020CLB class. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #if _MSC_VER > 1000 #pragma once #endif // _MSC_VER> 1000 #include "ApnCamData.h" class CApnCamData_KAI2020CLB : public CApnCamData { public: CApnCamData_KAI2020CLB(); virtual ~CApnCamData_KAI2020CLB(); void Initialize(); private: void set_vpattern(); void set_hpattern_clamp_sixteen(); void set_hpattern_skip_sixteen(); void set_hpattern_roi_sixteen(); void set_hpattern_clamp_twelve(); void set_hpattern_skip_twelve(); void set_hpattern_roi_twelve(); void set_hpattern( APN_HPATTERN_FILE *Pattern, unsigned short Mask, unsigned short BinningLimit, unsigned short RefNumElements, unsigned short SigNumElements, unsigned short BinNumElements[], unsigned short RefPatternData[], unsigned short SigPatternData[], unsigned short BinPatternData[][APN_MAX_PATTERN_ENTRIES] ); }; libapogee2-2.2/ChangeLog0000644000175000017500000000005011110507150012732 0ustar jrjrChangeLog: 2008-10-03 Initial Release. libapogee2-2.2/libapogee.h0000644000175000017500000000160711110507150013271 0ustar jrjr/* glue so C can make use of key operations available in CApnCamera. */ #ifndef LIBAPOGEE_H #define LIBAPOGEE_H #define APOGEE_USB_ONLY 0 #define APOGEE_ETH_ONLY 1 #ifdef __cplusplus extern "C" { #endif int ApnGlueOpen(unsigned int id); void ApnGlueGetMaxValues (double *exptime, int *roiw, int *roih, int *osw, int *osh, int *binw, int *binh, int *shutter, double *mintemp); int ApnGlueSetExpGeom (int roiw, int roih, int osw, int osh, int binw, int binh, int roix, int roiy, int *impixw, int *impixh, char whynot[]); void ApnGlueExpAbort(void); int ApnGlueStartExp (double *exptime, int shutter); int ApnGlueExpDone(void); int ApnGlueReadPixels (unsigned short *buf, int nbuf, char whynot[]); void ApnGlueSetTemp (double C); int ApnGlueGetTemp (double *Cp); void ApnGlueSetFan (int speed); void ApnGlueGetName(char **sensor, char **camera); #ifdef __cplusplus } #endif #endif libapogee2-2.2/ApnCamData_CCD5710.cpp0000644000175000017500000004232011110507150014611 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_CCD5710.cpp: Implementation file for the CApnCamData_CCD5710 class. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #include "ApnCamData_CCD5710.h" #include #include #include ///////////////////////////////////////////////////////////// // Construction/Destruction ///////////////////////////////////////////////////////////// CApnCamData_CCD5710::CApnCamData_CCD5710() { } CApnCamData_CCD5710::~CApnCamData_CCD5710() { } void CApnCamData_CCD5710::Initialize() { strcpy( m_Sensor, "CCD5710" ); strcpy( m_CameraModel, "57" ); m_CameraId = 18; m_InterlineCCD = false; m_SupportsSerialA = true; m_SupportsSerialB = true; m_SensorTypeCCD = true; m_TotalColumns = 536; m_ImagingColumns = 512; m_ClampColumns = 24; m_PreRoiSkipColumns = 0; m_PostRoiSkipColumns = 0; m_OverscanColumns = 12; m_TotalRows = 1056; m_ImagingRows = 512; m_UnderscanRows = 540; m_OverscanRows = 4; m_VFlushBinning = 1; m_EnableSingleRowOffset = true; m_RowOffsetBinning = 540; m_HFlushDisable = false; m_ShutterCloseDelay = 0; m_PixelSizeX = 13; m_PixelSizeY = 13; m_Color = false; m_ReportedGainSixteenBit = 2; m_MinSuggestedExpTime = 1.0; m_CoolingSupported = true; m_RegulatedCoolingSupported = true; m_TempSetPoint = -20.0; m_TempRampRateOne = 700; m_TempRampRateTwo = 4000; m_TempBackoffPoint = 2.0; m_PrimaryADType = ApnAdType_Alta_Sixteen; m_AlternativeADType = ApnAdType_Alta_Twelve; m_DefaultGainLeft = 400; m_DefaultOffsetLeft = 250; m_DefaultGainRight = -1; m_DefaultOffsetRight = -1; m_DefaultRVoltage = 1000; m_DefaultSpeed = 0xffff; m_DefaultDataReduction = false; set_vpattern(); set_hpattern_clamp_sixteen(); set_hpattern_skip_sixteen(); set_hpattern_roi_sixteen(); set_hpattern_clamp_twelve(); set_hpattern_skip_twelve(); set_hpattern_roi_twelve(); } void CApnCamData_CCD5710::set_vpattern() { const unsigned short Mask = 0x0; const unsigned short NumElements = 129; unsigned short Pattern[NumElements] = { 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0001, 0x0000 }; m_VerticalPattern.Mask = Mask; m_VerticalPattern.NumElements = NumElements; m_VerticalPattern.PatternData = (unsigned short *)malloc(NumElements * sizeof(unsigned short)); for ( int i=0; iMask = Mask; Pattern->BinningLimit = BinningLimit; Pattern->RefNumElements = RefNumElements; Pattern->SigNumElements = SigNumElements; if ( RefNumElements > 0 ) { Pattern->RefPatternData = (unsigned short *)malloc(RefNumElements * sizeof(unsigned short)); for ( i=0; iRefPatternData[i] = RefPatternData[i]; } } if ( SigNumElements > 0 ) { Pattern->SigPatternData = (unsigned short *)malloc(SigNumElements * sizeof(unsigned short)); for ( i=0; iSigPatternData[i] = SigPatternData[i]; } } if ( BinningLimit > 0 ) { for ( i=0; iBinNumElements[i] = BinNumElements[i]; Pattern->BinPatternData[i] = (unsigned short *)malloc(BinNumElements[i] * sizeof(unsigned short)); for ( j=0; jBinPatternData[i][j] = BinPatternData[i][j]; } } } } libapogee2-2.2/ApnCamData_CCD4720.h0000644000175000017500000000217411110507150014261 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_CCD4720.h: Interface file for the CApnCamData_CCD4720 class. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #if _MSC_VER > 1000 #pragma once #endif // _MSC_VER> 1000 #include "ApnCamData.h" class CApnCamData_CCD4720 : public CApnCamData { public: CApnCamData_CCD4720(); virtual ~CApnCamData_CCD4720(); void Initialize(); private: void set_vpattern(); void set_hpattern_clamp_sixteen(); void set_hpattern_skip_sixteen(); void set_hpattern_roi_sixteen(); void set_hpattern_clamp_twelve(); void set_hpattern_skip_twelve(); void set_hpattern_roi_twelve(); void set_hpattern( APN_HPATTERN_FILE *Pattern, unsigned short Mask, unsigned short BinningLimit, unsigned short RefNumElements, unsigned short SigNumElements, unsigned short BinNumElements[], unsigned short RefPatternData[], unsigned short SigPatternData[], unsigned short BinPatternData[][APN_MAX_PATTERN_ENTRIES] ); }; libapogee2-2.2/ApnCamData_ASCENT0402ME.cpp0000644000175000017500000002222511110507150015412 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_ASCENT0402ME.cpp: Implementation file for the CApnCamData_ASCENT0402ME class. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #include "ApnCamData_ASCENT0402ME.h" #include #include #include ///////////////////////////////////////////////////////////// // Construction/Destruction ///////////////////////////////////////////////////////////// CApnCamData_ASCENT0402ME::CApnCamData_ASCENT0402ME() { } CApnCamData_ASCENT0402ME::~CApnCamData_ASCENT0402ME() { } void CApnCamData_ASCENT0402ME::Initialize() { strcpy( m_Sensor, "ASCENT0402ME" ); strcpy( m_CameraModel, "1" ); m_CameraId = 256; m_InterlineCCD = false; m_SupportsSerialA = false; m_SupportsSerialB = false; m_SensorTypeCCD = true; m_TotalColumns = 796; m_ImagingColumns = 768; m_ClampColumns = 14; m_PreRoiSkipColumns = 0; m_PostRoiSkipColumns = 0; m_OverscanColumns = 14; m_TotalRows = 520; m_ImagingRows = 512; m_UnderscanRows = 4; m_OverscanRows = 4; m_VFlushBinning = 3; m_EnableSingleRowOffset = false; m_RowOffsetBinning = 1; m_HFlushDisable = false; m_ShutterCloseDelay = 100; m_PixelSizeX = 9; m_PixelSizeY = 9; m_Color = false; m_ReportedGainSixteenBit = 1.5; m_MinSuggestedExpTime = 50.0; m_CoolingSupported = true; m_RegulatedCoolingSupported = true; m_TempSetPoint = -20.0; m_TempRampRateOne = 1200; m_TempRampRateTwo = 4000; m_TempBackoffPoint = 2.0; m_PrimaryADType = ApnAdType_Ascent_Sixteen; m_AlternativeADType = ApnAdType_None; m_DefaultGainLeft = 0; m_DefaultOffsetLeft = 100; m_DefaultGainRight = 0; m_DefaultOffsetRight = 100; m_DefaultRVoltage = 1000; m_DefaultSpeed = 0x2; m_DefaultDataReduction = true; set_vpattern(); set_hpattern_clamp_sixteen(); set_hpattern_skip_sixteen(); set_hpattern_roi_sixteen(); set_hpattern_clamp_twelve(); set_hpattern_skip_twelve(); set_hpattern_roi_twelve(); } void CApnCamData_ASCENT0402ME::set_vpattern() { const unsigned short Mask = 0x6; const unsigned short NumElements = 71; unsigned short Pattern[NumElements] = { 0x0000, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0001, 0x0000 }; m_VerticalPattern.Mask = Mask; m_VerticalPattern.NumElements = NumElements; m_VerticalPattern.PatternData = (unsigned short *)malloc(NumElements * sizeof(unsigned short)); for ( int i=0; iMask = Mask; Pattern->BinningLimit = BinningLimit; Pattern->RefNumElements = RefNumElements; Pattern->SigNumElements = SigNumElements; if ( RefNumElements > 0 ) { Pattern->RefPatternData = (unsigned short *)malloc(RefNumElements * sizeof(unsigned short)); for ( i=0; iRefPatternData[i] = RefPatternData[i]; } } if ( SigNumElements > 0 ) { Pattern->SigPatternData = (unsigned short *)malloc(SigNumElements * sizeof(unsigned short)); for ( i=0; iSigPatternData[i] = SigPatternData[i]; } } if ( BinningLimit > 0 ) { for ( i=0; iBinNumElements[i] = BinNumElements[i]; Pattern->BinPatternData[i] = (unsigned short *)malloc(BinNumElements[i] * sizeof(unsigned short)); for ( j=0; jBinPatternData[i][j] = BinPatternData[i][j]; } } } } libapogee2-2.2/ApnCamData_CCD4240.cpp0000644000175000017500000004435311110507150014616 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_CCD4240.cpp: Implementation file for the CApnCamData_CCD4240 class. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #include "ApnCamData_CCD4240.h" #include #include #include ///////////////////////////////////////////////////////////// // Construction/Destruction ///////////////////////////////////////////////////////////// CApnCamData_CCD4240::CApnCamData_CCD4240() { } CApnCamData_CCD4240::~CApnCamData_CCD4240() { } void CApnCamData_CCD4240::Initialize() { strcpy( m_Sensor, "CCD4240" ); strcpy( m_CameraModel, "42" ); m_CameraId = 16; m_InterlineCCD = false; m_SupportsSerialA = true; m_SupportsSerialB = true; m_SensorTypeCCD = true; m_TotalColumns = 2148; m_ImagingColumns = 2048; m_ClampColumns = 50; m_PreRoiSkipColumns = 0; m_PostRoiSkipColumns = 0; m_OverscanColumns = 50; m_TotalRows = 2052; m_ImagingRows = 2048; m_UnderscanRows = 2; m_OverscanRows = 2; m_VFlushBinning = 1; m_EnableSingleRowOffset = false; m_RowOffsetBinning = 1; m_HFlushDisable = false; m_ShutterCloseDelay = 500; m_PixelSizeX = 13.5; m_PixelSizeY = 13.5; m_Color = false; m_ReportedGainSixteenBit = 2; m_MinSuggestedExpTime = 20.0; m_CoolingSupported = true; m_RegulatedCoolingSupported = true; m_TempSetPoint = -20.0; m_TempRampRateOne = 700; m_TempRampRateTwo = 4000; m_TempBackoffPoint = 2.0; m_PrimaryADType = ApnAdType_Alta_Sixteen; m_AlternativeADType = ApnAdType_Alta_Twelve; m_DefaultGainLeft = 400; m_DefaultOffsetLeft = 200; m_DefaultGainRight = -1; m_DefaultOffsetRight = -1; m_DefaultRVoltage = 1000; m_DefaultSpeed = 0xffff; m_DefaultDataReduction = false; set_vpattern(); set_hpattern_clamp_sixteen(); set_hpattern_skip_sixteen(); set_hpattern_roi_sixteen(); set_hpattern_clamp_twelve(); set_hpattern_skip_twelve(); set_hpattern_roi_twelve(); } void CApnCamData_CCD4240::set_vpattern() { const unsigned short Mask = 0x0; const unsigned short NumElements = 253; unsigned short Pattern[NumElements] = { 0x0000, 0x0000, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x000A, 0x000A, 0x000A, 0x000A, 0x000A, 0x000A, 0x000A, 0x000A, 0x000A, 0x000A, 0x000A, 0x000A, 0x000A, 0x000A, 0x000A, 0x000A, 0x000A, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0000, 0x0000, 0x0000, 0x0001, 0x0000 }; m_VerticalPattern.Mask = Mask; m_VerticalPattern.NumElements = NumElements; m_VerticalPattern.PatternData = (unsigned short *)malloc(NumElements * sizeof(unsigned short)); for ( int i=0; iMask = Mask; Pattern->BinningLimit = BinningLimit; Pattern->RefNumElements = RefNumElements; Pattern->SigNumElements = SigNumElements; if ( RefNumElements > 0 ) { Pattern->RefPatternData = (unsigned short *)malloc(RefNumElements * sizeof(unsigned short)); for ( i=0; iRefPatternData[i] = RefPatternData[i]; } } if ( SigNumElements > 0 ) { Pattern->SigPatternData = (unsigned short *)malloc(SigNumElements * sizeof(unsigned short)); for ( i=0; iSigPatternData[i] = SigPatternData[i]; } } if ( BinningLimit > 0 ) { for ( i=0; iBinNumElements[i] = BinNumElements[i]; Pattern->BinPatternData[i] = (unsigned short *)malloc(BinNumElements[i] * sizeof(unsigned short)); for ( j=0; jBinPatternData[i][j] = BinPatternData[i][j]; } } } } libapogee2-2.2/ApnCamData_CCD4710.cpp0000644000175000017500000004320111110507150014607 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_CCD4710.cpp: Implementation file for the CApnCamData_CCD4710 class. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #include "ApnCamData_CCD4710.h" #include #include #include ///////////////////////////////////////////////////////////// // Construction/Destruction ///////////////////////////////////////////////////////////// CApnCamData_CCD4710::CApnCamData_CCD4710() { } CApnCamData_CCD4710::~CApnCamData_CCD4710() { } void CApnCamData_CCD4710::Initialize() { strcpy( m_Sensor, "CCD4710" ); strcpy( m_CameraModel, "47" ); m_CameraId = 10; m_InterlineCCD = false; m_SupportsSerialA = true; m_SupportsSerialB = true; m_SensorTypeCCD = true; m_TotalColumns = 1072; m_ImagingColumns = 1024; m_ClampColumns = 24; m_PreRoiSkipColumns = 0; m_PostRoiSkipColumns = 0; m_OverscanColumns = 24; m_TotalRows = 1027; m_ImagingRows = 1024; m_UnderscanRows = 3; m_OverscanRows = 0; m_VFlushBinning = 1; m_EnableSingleRowOffset = false; m_RowOffsetBinning = 1; m_HFlushDisable = false; m_ShutterCloseDelay = 300; m_PixelSizeX = 13; m_PixelSizeY = 13; m_Color = false; m_ReportedGainSixteenBit = 2; m_MinSuggestedExpTime = 20.0; m_CoolingSupported = true; m_RegulatedCoolingSupported = true; m_TempSetPoint = -20.0; m_TempRampRateOne = 700; m_TempRampRateTwo = 4000; m_TempBackoffPoint = 2.0; m_PrimaryADType = ApnAdType_Alta_Sixteen; m_AlternativeADType = ApnAdType_Alta_Twelve; m_DefaultGainLeft = 400; m_DefaultOffsetLeft = 200; m_DefaultGainRight = -1; m_DefaultOffsetRight = -1; m_DefaultRVoltage = 1000; m_DefaultSpeed = 0xffff; m_DefaultDataReduction = false; set_vpattern(); set_hpattern_clamp_sixteen(); set_hpattern_skip_sixteen(); set_hpattern_roi_sixteen(); set_hpattern_clamp_twelve(); set_hpattern_skip_twelve(); set_hpattern_roi_twelve(); } void CApnCamData_CCD4710::set_vpattern() { const unsigned short Mask = 0x0; const unsigned short NumElements = 180; unsigned short Pattern[NumElements] = { 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0001, 0x0000, }; m_VerticalPattern.Mask = Mask; m_VerticalPattern.NumElements = NumElements; m_VerticalPattern.PatternData = (unsigned short *)malloc(NumElements * sizeof(unsigned short)); for ( int i=0; iMask = Mask; Pattern->BinningLimit = BinningLimit; Pattern->RefNumElements = RefNumElements; Pattern->SigNumElements = SigNumElements; if ( RefNumElements > 0 ) { Pattern->RefPatternData = (unsigned short *)malloc(RefNumElements * sizeof(unsigned short)); for ( i=0; iRefPatternData[i] = RefPatternData[i]; } } if ( SigNumElements > 0 ) { Pattern->SigPatternData = (unsigned short *)malloc(SigNumElements * sizeof(unsigned short)); for ( i=0; iSigPatternData[i] = SigPatternData[i]; } } if ( BinningLimit > 0 ) { for ( i=0; iBinNumElements[i] = BinNumElements[i]; Pattern->BinPatternData[i] = (unsigned short *)malloc(BinNumElements[i] * sizeof(unsigned short)); for ( j=0; jBinPatternData[i][j] = BinPatternData[i][j]; } } } } libapogee2-2.2/.cproject0000644000175000017500000013132111110507150013000 0ustar jrjr libapogee2-2.2/ApnGlue.cpp0000644000175000017500000001225411110507150013230 0ustar jrjr#include #include #include #include #include #include #include "ApnCamera.h" #include "ApnGlue.h" /* master object */ static CApnCamera *alta; static void checkalta(); /* connect to the camera and perform any one-time setup. * return 0 if ok else -1 */ int ApnGlueOpen() { alta = (CApnCamera *)new CApnCamera(); if (!alta->InitDriver(1,0,0) || !alta->ResetSystem()) return (-1); alta->write_LedState (0, Apn_LedState_Expose); alta->write_LedState (1, Apn_LedState_AtTemp); return (0); } /* return the max values for the camera. */ void ApnGlueGetMaxValues (double * /*exptime*/, int *roiw, int *roih, int *osw, int *osh, int *binw, int *binh, int *shutter, double *mintemp) { checkalta(); *roiw = alta->m_ApnSensorInfo->m_ImagingColumns; *roih = alta->m_ApnSensorInfo->m_ImagingRows; *osw = alta->m_ApnSensorInfo->m_OverscanColumns; *osh = alta->m_ApnSensorInfo->m_OverscanRows; *binw = alta->read_MaxBinningH(); *binh = alta->read_MaxBinningV(); *shutter = 1; /* TODO */ *mintemp = alta->m_ApnSensorInfo->m_CoolingSupported ? -30 : 0; /*TODO*/ } /* set parameters for subsequent exposures. * if anything can't be done return -1 with explanation in whynot[], else 0. * also return final image size in net binned pixels, allowing for overscan, * binning etc. */ int ApnGlueSetExpGeom (int roiw, int roih, int osw, int osh, int binw, int binh, int roix, int roiy, int *impixw, int *impixh, char whynot[]) { int maxw, maxh; checkalta(); maxw = alta->m_ApnSensorInfo->m_ImagingColumns; maxh = alta->m_ApnSensorInfo->m_ImagingRows; /* be kind */ if (!binw) binw = 1; if (!binh) binh = 1; if (!roiw) roiw = maxw; if (!roih) roih = maxh; /* check maxes */ if (roiw > maxw) { sprintf (whynot, "Max width is %d", maxw); return (-1); } if (roih > maxh) { sprintf (whynot, "Max height is %d", maxh); return (-1); } /* check overscan */ if (osw > 0 || osh > 0) { int maxosw = alta->read_OverscanColumns(); int maxosh = alta->m_ApnSensorInfo->m_OverscanRows; if (osw > maxosw) { sprintf (whynot, "Max overscan columns is %d", maxosw); return (-1); } if (osh > maxosh) { sprintf (whynot, "Max overscan rows is %d", maxosh); return (-1); } if (roix > 0 || roiw < maxw || roiy > 0 || roih < maxh) { sprintf (whynot, "Can not overscan with windowing"); return (-1); } roiw += osw; roih += osh; alta->write_DigitizeOverscan(1); } else alta->write_DigitizeOverscan(0); /* ok */ alta->write_RoiStartX (roix); alta->write_RoiStartY (roiy); alta->write_RoiPixelsH (roiw/binw); alta->write_RoiPixelsV (roih/binh); alta->write_RoiBinningH (binw); alta->write_RoiBinningV (binh); *impixw = roiw/binw; *impixh = roih/binh; return (0); } /* start an exposure with the given duration (secs) and whether to open shutter. * update *exptime with the actual exposure time (may have been bumped to min). * return 0 if ok, else -1 */ int ApnGlueStartExp (double *exptime, int shutter) { double minsecs; checkalta(); minsecs = alta->m_ApnSensorInfo->m_MinSuggestedExpTime/1000.0; if (*exptime < minsecs) *exptime = minsecs; alta->write_ImageCount(1); return (alta->Expose(*exptime, shutter) ? 0 : -1); } /* abort an exposure */ void ApnGlueExpAbort(void) { checkalta(); alta->StopExposure(0); } /* return 1 if the current exposure is complete, else 0 */ int ApnGlueExpDone(void) { checkalta(); return (alta->read_ImagingStatus() == Apn_Status_ImageReady); } /* read pixels from the camera into the given buffer of length nbuf. * return 0 if ok else -1 with reason in whynot[]. */ int ApnGlueReadPixels (unsigned short *buf, int nbuf, char whynot[]) { unsigned short w, h; unsigned long c, r; checkalta(); r = alta->GetImageData (buf, w, h, c); if (r != CAPNCAMERA_SUCCESS) { sprintf (whynot, "GetImageData returned %ld\n", r); return (-1); } if (w*h != nbuf) { sprintf (whynot, "Expecting %d pixels but found %d", nbuf, w*h); return (-1); } return (0); } /* set cooler target to given value, C * turn cooler off it target is 0. */ void ApnGlueSetTemp (double C) { checkalta(); if (C == 0) { alta->write_CoolerEnable(0); } else { alta->write_CoolerEnable(1); alta->write_CoolerSetPoint(C); } } /* fetch current cooler temp, C, and return status: * 0 = off * 1 = ramping to set point * 2 = at set point */ int ApnGlueGetTemp (double *Cp) { int status; checkalta(); *Cp = alta->read_TempCCD(); status = alta->read_CoolerStatus(); if (status > 2) status = 2; return (status); } /* set fan speed: 0..3 */ void ApnGlueSetFan (int speed) { alta->write_FanMode(0); /* helps to do this first */ alta->write_FanMode(speed&3); } /* return pointers to sensor and camera names. * N.B. caller should neither modify nor free these strings. */ void ApnGlueGetName(char **sensor, char **camera) { *sensor = alta->m_ApnSensorInfo->m_Sensor; *camera = alta->m_ApnSensorInfo->m_CameraModel; } /* check that the alta object has been created, else complain and exit. */ static void checkalta() { if (!alta) { fprintf (stderr, "Bug! Alta used before open\n"); exit(1); } } libapogee2-2.2/ApnCamera.cpp0000644000175000017500000035175311110507150013536 0ustar jrjr////////////////////////////////////////////////////////////////////// // // ApnCamera.cpp: implementation of the CApnCamera class. // // Copyright (c) 2003-2006 Apogee Instruments, Inc. // ////////////////////////////////////////////////////////////////////// #include "stdafx.h" #include "ApnCamera.h" #include "ApnCamTable.h" typedef struct _ColorPixel { unsigned short Red; unsigned short Green; unsigned short Blue; } ColorPixel; ////////////////////////////////////////////////////////////////////// // Construction/Destruction ////////////////////////////////////////////////////////////////////// CApnCamera::CApnCamera() { AltaDebugOutputString( "APOGEE.DLL - CApnCamera::CApnCamera()" ); m_pvtPlatformType = Apn_Platform_Unknown; m_ApnSensorInfo = NULL; } CApnCamera::~CApnCamera() { AltaDebugOutputString( "APOGEE.DLL - CApnCamera::~CApnCamera()" ); if ( m_ApnSensorInfo != NULL ) { delete m_ApnSensorInfo; m_ApnSensorInfo = NULL; CloseDriver(); } } bool CApnCamera::ConvertBayerImageToRGB( unsigned short *pBayer, unsigned short *pRgb, unsigned short ImageWidth, unsigned short ImageHeight ) { unsigned long i, j; unsigned long Index; unsigned long NextCol, PrevCol; unsigned long NextRow, PrevRow; unsigned long LastRow, LastCol; bool DoRedPixel, DoBluePixel; bool DoGreenRedRow; ColorPixel* Pixel; bool RowShift, ColumnShift; if ( (pBayer == NULL) || (pRgb == NULL) ) return false; if ( (ImageWidth == 0) || (ImageHeight == 0) ) return false; RowShift = false; ColumnShift = false; Index = 0; Pixel = (ColorPixel*)pRgb; switch ( m_pvtBayerShift ) { case Apn_BayerShift_Automatic: if ( (m_pvtRoiStartX % 2) == 1 ) ColumnShift = true; if ( (m_pvtRoiStartY % 2) == 1 ) RowShift = true; break; case Apn_BayerShift_None: // RowShift and ColumnShift were initialized to "false" // We don't need to do anything here break; case Apn_BayerShift_Column: ColumnShift = true; break; case Apn_BayerShift_Row: RowShift = true; break; case Apn_BayerShift_Both: ColumnShift = true; RowShift = true; break; } if ( RowShift == false ) DoGreenRedRow = true; else DoGreenRedRow = false; LastRow = ImageHeight - 1; LastCol = ImageWidth - 1; for ( j=0; jRed = pBayer[Index]; Pixel->Green = (unsigned long)(pBayer[NextCol] + pBayer[PrevRow] + pBayer[NextRow]) / 3; Pixel->Blue = (unsigned long)(pBayer[PrevRow+1] + pBayer[NextRow+1]) >> 1; } if ( i==LastCol ) { Pixel->Red = pBayer[Index]; Pixel->Green = (unsigned long)(pBayer[PrevCol] + pBayer[PrevRow] + pBayer[NextRow]) / 3; Pixel->Blue = (unsigned long)(pBayer[PrevRow-1] + pBayer[NextRow-1]) >> 1; } else { Pixel->Red = pBayer[Index]; Pixel->Green = (unsigned long)(pBayer[PrevCol] + pBayer[NextCol] + pBayer[PrevRow] + pBayer[NextRow]) >> 2; Pixel->Blue = (unsigned long)(pBayer[PrevRow-1] + pBayer[PrevRow+1] + pBayer[NextRow-1] + pBayer[NextRow+1]) >> 2; } } else { if ( i==0 ) { Pixel->Red = pBayer[Index+1]; Pixel->Green = pBayer[Index]; Pixel->Blue = (unsigned long)(pBayer[NextRow] + pBayer[PrevRow]) >> 1; } if ( i==LastCol ) { Pixel->Red = pBayer[PrevCol]; Pixel->Green = pBayer[Index]; Pixel->Blue = (unsigned long)(pBayer[PrevRow] + pBayer[NextRow]) >> 1; } else { Pixel->Red = (unsigned long)(pBayer[PrevCol] + pBayer[NextCol]) >> 1; Pixel->Green = pBayer[Index]; Pixel->Blue = (unsigned long)(pBayer[PrevRow] + pBayer[NextRow]) >> 1; } } // Increment to next pixel Pixel++; Index++; // Alternate DoRedPixel = !DoRedPixel; } } else { ///////////////////// // Blue/Green Row ///////////////////// // DoBluePixel = true; if ( ColumnShift ) DoBluePixel = false; else DoBluePixel = true; for ( i=0; iRed = (unsigned long)(pBayer[PrevRow+1] + pBayer[NextRow+1]) >> 1; Pixel->Green = (unsigned long)(pBayer[NextCol] + pBayer[PrevRow] + pBayer[NextRow]) / 3; Pixel->Blue = pBayer[Index]; } else if ( i==LastCol ) { Pixel->Red = (unsigned long)(pBayer[PrevRow-1] + pBayer[NextRow-1]) >> 1; Pixel->Green = (unsigned long)(pBayer[PrevCol] + pBayer[PrevRow] + pBayer[NextRow]) / 3; Pixel->Blue = pBayer[Index]; } else { Pixel->Red = (unsigned long)(pBayer[PrevRow-1] + pBayer[PrevRow+1] + pBayer[NextRow-1] + pBayer[NextRow+1]) >> 2; Pixel->Green = (unsigned long)(pBayer[PrevCol] + pBayer[NextCol] + pBayer[PrevRow] + pBayer[NextRow]) >> 2; Pixel->Blue = pBayer[Index]; } } else { if ( i==0 ) { Pixel->Red = (unsigned long)(pBayer[PrevRow] + pBayer[NextRow]) >> 1; Pixel->Green = pBayer[Index]; Pixel->Blue = pBayer[NextCol]; } else if ( i==LastCol ) { Pixel->Red = (unsigned long)(pBayer[PrevRow] + pBayer[NextRow]) >> 1; Pixel->Green = pBayer[Index]; Pixel->Blue = pBayer[PrevCol]; } else { Pixel->Red = (unsigned long)(pBayer[PrevRow] + pBayer[NextRow]) >> 1; Pixel->Green = pBayer[Index]; Pixel->Blue = (unsigned long)(pBayer[PrevCol] + pBayer[NextCol]) >> 1; } } // Increment to next pixel Pixel++; Index++; // Alternate DoBluePixel = !DoBluePixel; } } // Increment to next pixel // Pixel++; // Index++; DoGreenRedRow = !DoGreenRedRow; } return true; } bool CApnCamera::Expose( double Duration, bool Light ) { unsigned long ExpTime; unsigned short BitsPerPixel; unsigned short UnbinnedRoiX; unsigned short UnbinnedRoiY; unsigned short PreRoiSkip, PostRoiSkip; unsigned short PreRoiRows, PostRoiRows; unsigned short PreRoiVBinning, PostRoiVBinning; unsigned short RegStartCmd; unsigned short RoiRegBuffer[15]; unsigned short RoiRegData[15]; unsigned short TotalHPixels; unsigned short TotalVPixels; unsigned long TestImageSize; unsigned long WaitCounter; char szOutputText[128]; sprintf( szOutputText, "APOGEE.DLL - CApnCamera::Expose( Duration = %f, Light = %d ) -> BEGIN", Duration, Light ); AltaDebugOutputString( szOutputText ); WaitCounter = 0; while ( read_ImagingStatus() != Apn_Status_Flushing ) { Sleep( 20 ); WaitCounter++; if ( WaitCounter > 150 ) { // we've waited longer than 3s to start flushing in the camera head // something is amiss...abort the expose command to avoid an infinite loop AltaDebugOutputString( "APOGEE.DLL - CApnCamera::Expose() -> ERROR: Timed out waiting for flushing!!" ); return false; } } // Validate the "Duration" parameter if ( Duration < m_PlatformExposureTimeMin ) Duration = m_PlatformExposureTimeMin; // Validate the ROI params UnbinnedRoiX = m_pvtRoiPixelsH * m_pvtRoiBinningH; PreRoiSkip = m_pvtRoiStartX; PostRoiSkip = m_ApnSensorInfo->m_TotalColumns - m_ApnSensorInfo->m_ClampColumns - PreRoiSkip - UnbinnedRoiX; TotalHPixels = UnbinnedRoiX + PreRoiSkip + PostRoiSkip + m_ApnSensorInfo->m_ClampColumns; if ( TotalHPixels != m_ApnSensorInfo->m_TotalColumns ) { AltaDebugOutputString( "APOGEE.DLL - CApnCamera::Expose() -> ERROR: Horizontal geometry incorrect" ); return false; } UnbinnedRoiY = m_pvtRoiPixelsV * m_pvtRoiBinningV; PreRoiRows = m_ApnSensorInfo->m_UnderscanRows + m_pvtRoiStartY; PostRoiRows = m_ApnSensorInfo->m_TotalRows - PreRoiRows - UnbinnedRoiY; TotalVPixels = UnbinnedRoiY + PreRoiRows + PostRoiRows; if ( TotalVPixels != m_ApnSensorInfo->m_TotalRows ) { AltaDebugOutputString( "APOGEE.DLL - CApnCamera::Expose() -> ERROR: Vertical geometry incorrect" ); return false; } m_pvtExposurePixelsV = m_pvtRoiPixelsV; m_pvtExposurePixelsH = m_pvtRoiPixelsH; if ( read_CameraMode() == Apn_CameraMode_Test ) { TestImageSize = m_pvtExposurePixelsV * m_pvtExposurePixelsH; Write( FPGA_REG_TEST_COUNT_UPPER, (USHORT)(TestImageSize>>16) ); Write( FPGA_REG_TEST_COUNT_LOWER, (USHORT)(TestImageSize & 0xFFFF) ); } if ( m_pvtDataBits == Apn_Resolution_SixteenBit ) { BitsPerPixel = 16; } else if ( m_pvtDataBits == Apn_Resolution_TwelveBit ) { BitsPerPixel = 12; } if ( PreStartExpose( BitsPerPixel ) != 0 ) { AltaDebugOutputString( "APOGEE.DLL - CApnCamera::Expose() -> ERROR: Failed PreStartExpose()!!" ); return false; } // Calculate the vertical parameters PreRoiVBinning = m_ApnSensorInfo->m_RowOffsetBinning; PostRoiVBinning = 1; // For interline CCDs, set "Fast Dump" mode if the particular array is NOT digitized /* if ( m_ApnSensorInfo->m_InterlineCCD ) { // use the fast dump feature to get rid of the data quickly. // one row, binning to the original row count // note that we only are not digitized in arrays 1 and 3 PreRoiVBinning = PreRoiRows; PostRoiVBinning = PostRoiRows; PreRoiVBinning |= FPGA_BIT_ARRAY_FASTDUMP; PostRoiVBinning |= FPGA_BIT_ARRAY_FASTDUMP; PreRoiRows = 1; PostRoiRows = 1; } */ // Set up the geometry for a full frame device if ( m_ApnSensorInfo->m_EnableSingleRowOffset ) { // PreRoiVBinning += PreRoiRows; PreRoiVBinning = PreRoiRows; PostRoiVBinning = PostRoiRows; PreRoiVBinning |= FPGA_BIT_ARRAY_FASTDUMP; PostRoiVBinning |= FPGA_BIT_ARRAY_FASTDUMP; PreRoiRows = 1; PostRoiRows = 1; } // Calculate the exposure time to program to the camera ExpTime = ((unsigned long)(Duration / m_PlatformTimerResolution)) + m_PlatformTimerOffsetCount; Write( FPGA_REG_TIMER_LOWER, (unsigned short)(ExpTime & 0xFFFF)); ExpTime = ExpTime >> 16; Write( FPGA_REG_TIMER_UPPER, (unsigned short)(ExpTime & 0xFFFF)); // Set up the registers for the exposure ResetSystemNoFlush(); // Issue the reset // RoiRegBuffer[0] = FPGA_REG_COMMAND_B; RoiRegBuffer[0] = FPGA_REG_SCRATCH; RoiRegData[0] = FPGA_BIT_CMD_RESET; // Program the horizontal settings RoiRegBuffer[1] = FPGA_REG_PREROI_SKIP_COUNT; RoiRegData[1] = PreRoiSkip; RoiRegBuffer[2] = FPGA_REG_ROI_COUNT; // Number of ROI pixels. Adjust the 12bit operation here to account for an extra // 10 pixel shift as a result of the A/D conversion. if ( m_pvtDataBits == Apn_Resolution_SixteenBit ) { RoiRegData[2] = m_pvtExposurePixelsH + 1; } else if ( m_pvtDataBits == Apn_Resolution_TwelveBit ) { RoiRegData[2] = m_pvtExposurePixelsH + 10; } RoiRegBuffer[3] = FPGA_REG_POSTROI_SKIP_COUNT; RoiRegData[3] = PostRoiSkip; // Program the vertical settings if ( m_pvtFirmwareVersion < 11 ) { RoiRegBuffer[4] = FPGA_REG_A1_ROW_COUNT; RoiRegData[4] = PreRoiRows; RoiRegBuffer[5] = FPGA_REG_A1_VBINNING; RoiRegData[5] = PreRoiVBinning; RoiRegBuffer[6] = FPGA_REG_A2_ROW_COUNT; RoiRegData[6] = m_pvtRoiPixelsV; RoiRegBuffer[7] = FPGA_REG_A2_VBINNING; RoiRegData[7] = (m_pvtRoiBinningV | FPGA_BIT_ARRAY_DIGITIZE); RoiRegBuffer[8] = FPGA_REG_A3_ROW_COUNT; RoiRegData[8] = PostRoiRows; RoiRegBuffer[9] = FPGA_REG_A3_VBINNING; RoiRegData[9] = PostRoiVBinning; RoiRegBuffer[10] = FPGA_REG_SCRATCH; RoiRegData[10] = 0; RoiRegBuffer[11] = FPGA_REG_SCRATCH; RoiRegData[11] = 0; RoiRegBuffer[12] = FPGA_REG_SCRATCH; RoiRegData[12] = 0; RoiRegBuffer[13] = FPGA_REG_SCRATCH; RoiRegData[13] = 0; } else { if ( m_ApnSensorInfo->m_EnableSingleRowOffset ) { RoiRegBuffer[4] = FPGA_REG_A1_ROW_COUNT; RoiRegData[4] = 0; RoiRegBuffer[5] = FPGA_REG_A1_VBINNING; RoiRegData[5] = 0; RoiRegBuffer[6] = FPGA_REG_A2_ROW_COUNT; RoiRegData[6] = PreRoiRows; RoiRegBuffer[7] = FPGA_REG_A2_VBINNING; RoiRegData[7] = PreRoiVBinning; RoiRegBuffer[8] = FPGA_REG_A3_ROW_COUNT; RoiRegData[8] = m_pvtRoiPixelsV; RoiRegBuffer[9] = FPGA_REG_A3_VBINNING; RoiRegData[9] = (m_pvtRoiBinningV | FPGA_BIT_ARRAY_DIGITIZE); RoiRegBuffer[10] = FPGA_REG_A4_ROW_COUNT; RoiRegData[10] = 0; RoiRegBuffer[11] = FPGA_REG_A4_VBINNING; RoiRegData[11] = 0; RoiRegBuffer[12] = FPGA_REG_A5_ROW_COUNT; RoiRegData[12] = PostRoiRows; RoiRegBuffer[13] = FPGA_REG_A5_VBINNING; RoiRegData[13] = PostRoiVBinning; } else { if ( PreRoiRows > 70 ) { RoiRegBuffer[4] = FPGA_REG_A1_ROW_COUNT; RoiRegData[4] = 1; RoiRegBuffer[5] = FPGA_REG_A1_VBINNING; RoiRegData[5] = (PreRoiRows-70); RoiRegBuffer[6] = FPGA_REG_A2_ROW_COUNT; RoiRegData[6] = 70; RoiRegBuffer[7] = FPGA_REG_A2_VBINNING; RoiRegData[7] = 1; } else { RoiRegBuffer[4] = FPGA_REG_A1_ROW_COUNT; RoiRegData[4] = 0; RoiRegBuffer[5] = FPGA_REG_A1_VBINNING; RoiRegData[5] = 0; RoiRegBuffer[6] = FPGA_REG_A2_ROW_COUNT; RoiRegData[6] = PreRoiRows; RoiRegBuffer[7] = FPGA_REG_A2_VBINNING; RoiRegData[7] = PreRoiVBinning; } RoiRegBuffer[8] = FPGA_REG_A3_ROW_COUNT; RoiRegData[8] = m_pvtRoiPixelsV; RoiRegBuffer[9] = FPGA_REG_A3_VBINNING; RoiRegData[9] = (m_pvtRoiBinningV | FPGA_BIT_ARRAY_DIGITIZE); if ( PostRoiRows > 70 ) { RoiRegBuffer[10] = FPGA_REG_A4_ROW_COUNT; RoiRegData[10] = 1; RoiRegBuffer[11] = FPGA_REG_A4_VBINNING; RoiRegData[11] = (PostRoiRows-70); RoiRegBuffer[12] = FPGA_REG_A5_ROW_COUNT; RoiRegData[12] = 70; RoiRegBuffer[13] = FPGA_REG_A5_VBINNING; RoiRegData[13] = 1; } else { RoiRegBuffer[10] = FPGA_REG_A4_ROW_COUNT; RoiRegData[10] = 0; RoiRegBuffer[11] = FPGA_REG_A4_VBINNING; RoiRegData[11] = 0; RoiRegBuffer[12] = FPGA_REG_A5_ROW_COUNT; RoiRegData[12] = PostRoiRows; RoiRegBuffer[13] = FPGA_REG_A5_VBINNING; RoiRegData[13] = PostRoiVBinning; } } } // Issue the reset RoiRegBuffer[14] = FPGA_REG_COMMAND_B; RoiRegData[14] = FPGA_BIT_CMD_RESET; // Send the instruction sequence to the camera AltaDebugOutputString( "APOGEE.DLL - CApnCamera::Expose() -> Issue WriteMultiMRMD() for Exposure setup" ); WriteMultiMRMD( RoiRegBuffer, RoiRegData, 15 ); // Issue the flush for interlines, or if using the external shutter if ( (m_ApnSensorInfo->m_InterlineCCD && m_pvtFastSequence) || (m_pvtExternalShutter) ) { // Make absolutely certain that flushing starts first // in order to use Progressive Scan/Ratio Mode Write( FPGA_REG_COMMAND_A, FPGA_BIT_CMD_FLUSH ); for ( int i=0; i<2; i++ ) { Write( FPGA_REG_SCRATCH, 0x8086 ); Write( FPGA_REG_SCRATCH, 0x8088 ); } } m_pvtExposureExternalShutter = m_pvtExternalShutter; switch ( m_pvtCameraMode ) { case Apn_CameraMode_Normal: if ( Light ) RegStartCmd = FPGA_BIT_CMD_EXPOSE; else RegStartCmd = FPGA_BIT_CMD_DARK; if ( m_pvtTriggerNormalGroup ) m_pvtExposureTriggerGroup = true; else m_pvtExposureTriggerGroup = false; if ( m_pvtTriggerNormalEach ) m_pvtExposureTriggerEach = true; else m_pvtExposureTriggerEach = false; break; case Apn_CameraMode_TDI: RegStartCmd = FPGA_BIT_CMD_TDI; if ( m_pvtTriggerTdiKineticsGroup ) m_pvtExposureTriggerGroup = false; else m_pvtExposureTriggerGroup = false; if ( m_pvtTriggerTdiKineticsEach ) m_pvtExposureTriggerEach = false; else m_pvtExposureTriggerEach = false; break; case Apn_CameraMode_Test: if ( Light ) RegStartCmd = FPGA_BIT_CMD_TEST; else RegStartCmd = FPGA_BIT_CMD_TEST; break; case Apn_CameraMode_ExternalTrigger: RegStartCmd = FPGA_BIT_CMD_TRIGGER_EXPOSE; break; case Apn_CameraMode_Kinetics: RegStartCmd = FPGA_BIT_CMD_KINETICS; if ( m_pvtTriggerTdiKineticsGroup ) m_pvtExposureTriggerGroup = true; else m_pvtExposureTriggerGroup = false; if ( m_pvtTriggerTdiKineticsEach ) m_pvtExposureTriggerEach = true; else m_pvtExposureTriggerEach = false; break; } // Send the instruction sequence to the camera AltaDebugOutputString( "APOGEE.DLL - CApnCamera::Expose() -> Issue start command to FPGA_REG_COMMAND_A" ); Write( FPGA_REG_COMMAND_A, RegStartCmd ); // Set our flags to mark the start of a new exposure m_pvtImageInProgress = true; m_pvtImageReady = false; // Debug output for leaving this function sprintf( szOutputText, "APOGEE.DLL - CApnCamera::Expose( Duration = %f, Light = %d ) -> END", Duration, Light ); AltaDebugOutputString( szOutputText ); return true; } bool CApnCamera::ResetSystem() { AltaDebugOutputString( "APOGEE.DLL - CApnCamera::ResetSystem()" ); // Reset the camera engine Write( FPGA_REG_COMMAND_B, FPGA_BIT_CMD_RESET ); // A little delay before we start flushing Write( FPGA_REG_SCRATCH, 0x8086 ); Write( FPGA_REG_SCRATCH, 0x8088 ); Write( FPGA_REG_SCRATCH, 0x8086 ); Write( FPGA_REG_SCRATCH, 0x8088 ); Write( FPGA_REG_SCRATCH, 0x8086 ); Write( FPGA_REG_SCRATCH, 0x8088 ); // Start flushing Write( FPGA_REG_COMMAND_A, FPGA_BIT_CMD_FLUSH ); // A little delay once we've started flushing Write( FPGA_REG_SCRATCH, 0x8086 ); Write( FPGA_REG_SCRATCH, 0x8088 ); return true; } bool CApnCamera::ResetSystemNoFlush() { AltaDebugOutputString( "APOGEE.DLL - CApnCamera::ResetSystemNoFlush()" ); // Reset the camera engine Write( FPGA_REG_COMMAND_B, FPGA_BIT_CMD_RESET ); // A little delay before we start flushing Write( FPGA_REG_SCRATCH, 0x8086 ); Write( FPGA_REG_SCRATCH, 0x8088 ); Write( FPGA_REG_SCRATCH, 0x8086 ); Write( FPGA_REG_SCRATCH, 0x8088 ); Write( FPGA_REG_SCRATCH, 0x8086 ); Write( FPGA_REG_SCRATCH, 0x8088 ); return true; } bool CApnCamera::PauseTimer( bool PauseState ) { unsigned short RegVal; bool CurrentState; char szOutputText[128]; sprintf( szOutputText, "APOGEE.DLL - CApnCamera::PauseTimer( PauseState = %d)", PauseState ); AltaDebugOutputString( szOutputText ); Read( FPGA_REG_OP_A, RegVal ); CurrentState = ( RegVal & FPGA_BIT_PAUSE_TIMER ) == FPGA_BIT_PAUSE_TIMER; if ( CurrentState != PauseState ) { if ( PauseState ) { RegVal |= FPGA_BIT_PAUSE_TIMER; } else { RegVal &= ~FPGA_BIT_PAUSE_TIMER; } Write ( FPGA_REG_OP_A, RegVal ); } return true; } bool CApnCamera::GetImage( unsigned short *pBuffer ) { AltaDebugOutputString( "APOGEE.DLL - CApnCamera::GetImage() -> BEGIN" ); unsigned short Width, Height; unsigned long Count; if ( m_pvtImageInProgress ) { if ( GetImageData( pBuffer, Width, Height, Count ) != CAPNCAMERA_SUCCESS ) { return false; } } AltaDebugOutputString( "APOGEE.DLL - CApnCamera::GetImage() -> END" ); return true; } bool CApnCamera::StopExposure( bool DigitizeData ) { char szOutputText[128]; sprintf( szOutputText, "APOGEE.DLL - CApnCamera::StopExposure( DigitizeData = %d) -> BEGIN", DigitizeData ); AltaDebugOutputString( szOutputText ); if ( m_pvtImageInProgress ) { Write( FPGA_REG_COMMAND_B, FPGA_BIT_CMD_END_EXPOSURE ); if ( PostStopExposure( DigitizeData ) != 0 ) { return false; } } sprintf( szOutputText, "APOGEE.DLL - CApnCamera::StopExposure( DigitizeData = %d) -> END", DigitizeData ); AltaDebugOutputString( szOutputText ); return true; } bool CApnCamera::GuideAbort() { AltaDebugOutputString( "APOGEE.DLL - CApnCamera::GuideAbort()" ); if ( m_pvtPlatformType == Apn_Platform_Ascent ) Write( FPGA_REG_COMMAND_A, FPGA_BIT_CMD_GUIDE_ABORT ); return true; } bool CApnCamera::GuideRAPlus() { AltaDebugOutputString( "APOGEE.DLL - CApnCamera::GuideRAPlus()" ); if ( m_pvtPlatformType == Apn_Platform_Ascent ) Write( FPGA_REG_COMMAND_A, FPGA_BIT_CMD_GUIDE_RA_PLUS ); return true; } bool CApnCamera::GuideRAMinus() { AltaDebugOutputString( "APOGEE.DLL - CApnCamera::GuideRAMinus()" ); if ( m_pvtPlatformType == Apn_Platform_Ascent ) Write( FPGA_REG_COMMAND_A, FPGA_BIT_CMD_GUIDE_RA_MINUS ); return true; } bool CApnCamera::GuideDecPlus() { AltaDebugOutputString( "APOGEE.DLL - CApnCamera::GuideDecPlus()" ); if ( m_pvtPlatformType == Apn_Platform_Ascent ) Write( FPGA_REG_COMMAND_A, FPGA_BIT_CMD_GUIDE_DEC_PLUS ); return true; } bool CApnCamera::GuideDecMinus() { AltaDebugOutputString( "APOGEE.DLL - CApnCamera::GuideDecMinus()" ); if ( m_pvtPlatformType == Apn_Platform_Ascent ) Write( FPGA_REG_COMMAND_A, FPGA_BIT_CMD_GUIDE_DEC_MINUS ); return true; } #ifndef LINUX void CApnCamera::SetNetworkTransferMode( Apn_NetworkMode TransferMode ) { char szOutputText[128]; sprintf( szOutputText, "APOGEE.DLL - CApnCamera::SetNetworkTransferMode( TransferMode = %d)", TransferMode ); AltaDebugOutputString( szOutputText ); if ( GetCameraInterface() == Apn_Interface_USB ) return; } #endif unsigned short CApnCamera::GetExposurePixelsH() { return m_pvtExposurePixelsH; } unsigned short CApnCamera::GetExposurePixelsV() { return m_pvtExposurePixelsV; } double CApnCamera::read_InputVoltage() { UpdateGeneralStatus(); return m_pvtInputVoltage; } long CApnCamera::read_AvailableMemory() { AltaDebugOutputString( "APOGEE.DLL - CApnCamera::read_AvailableMemory()" ); long AvailableMemory; switch( GetCameraInterface() ) { case Apn_Interface_NET: AvailableMemory = 28 * 1024; break; case Apn_Interface_USB: AvailableMemory = 32 * 1024; break; default: break; } return AvailableMemory; } unsigned short CApnCamera::read_FirmwareVersion() { AltaDebugOutputString( "APOGEE.DLL - CApnCamera::read_FirmwareVersion()" ); return m_pvtFirmwareVersion; } void CApnCamera::read_CameraModel( ) { char szModel[256]; ApnCamModelLookup( m_pvtCameraID, m_pvtFirmwareVersion, GetCameraInterface(), szModel ); // *BufferLength = strlen( szModel ); // strncpy( CameraModel, szModel, *BufferLength + 1); } bool CApnCamera::read_ShutterState() { AltaDebugOutputString( "APOGEE.DLL - CApnCamera::read_ShutterState()" ); UpdateGeneralStatus(); return m_pvtShutterState; } bool CApnCamera::read_DisableShutter() { AltaDebugOutputString( "APOGEE.DLL - CApnCamera::read_DisableShutter()" ); unsigned short RegVal; Read( FPGA_REG_OP_A, RegVal ); return ( (RegVal & FPGA_BIT_DISABLE_SHUTTER) != 0 ); } void CApnCamera::write_DisableShutter( bool DisableShutter ) { char szOutputText[128]; sprintf( szOutputText, "APOGEE.DLL - CApnCamera::write_DisableShutter( DisableShutter = %d)", DisableShutter ); AltaDebugOutputString( szOutputText ); unsigned short RegVal; Read( FPGA_REG_OP_A, RegVal ); if ( DisableShutter ) RegVal |= FPGA_BIT_DISABLE_SHUTTER; else RegVal &= ~FPGA_BIT_DISABLE_SHUTTER; Write( FPGA_REG_OP_A, RegVal ); } bool CApnCamera::read_ForceShutterOpen() { AltaDebugOutputString( "APOGEE.DLL - CApnCamera::read_ForceShutterOpen()" ); unsigned short RegVal; Read( FPGA_REG_OP_A, RegVal ); return ( (RegVal & FPGA_BIT_FORCE_SHUTTER) != 0 ); } void CApnCamera::write_ForceShutterOpen( bool ForceShutterOpen ) { char szOutputText[128]; sprintf( szOutputText, "APOGEE.DLL - CApnCamera::write_ForceShutterOpen( ForceShutterOpen = %d)", ForceShutterOpen ); AltaDebugOutputString( szOutputText ); unsigned short RegVal; Read( FPGA_REG_OP_A, RegVal ); if ( ForceShutterOpen ) RegVal |= FPGA_BIT_FORCE_SHUTTER; else RegVal &= ~FPGA_BIT_FORCE_SHUTTER; Write( FPGA_REG_OP_A, RegVal ); } bool CApnCamera::read_ShutterAmpControl() { AltaDebugOutputString( "APOGEE.DLL - CApnCamera::read_ShutterAmpControl()" ); unsigned short RegVal; Read( FPGA_REG_OP_A, RegVal ); return ( (RegVal & FPGA_BIT_SHUTTER_AMP_CONTROL ) != 0 ); } void CApnCamera::write_ShutterAmpControl( bool ShutterAmpControl ) { char szOutputText[128]; sprintf( szOutputText, "APOGEE.DLL - CApnCamera::write_ShutterAmpControl( ShutterAmpControl = %d)", ShutterAmpControl ); AltaDebugOutputString( szOutputText ); unsigned short RegVal; Read( FPGA_REG_OP_A, RegVal ); if ( ShutterAmpControl ) RegVal |= FPGA_BIT_SHUTTER_AMP_CONTROL; else RegVal &= ~FPGA_BIT_SHUTTER_AMP_CONTROL; Write( FPGA_REG_OP_A, RegVal ); } bool CApnCamera::read_DisableFlushCommands() { AltaDebugOutputString( "APOGEE.DLL - CApnCamera::read_DisableFlushCommands()" ); unsigned short RegVal; Read( FPGA_REG_OP_B, RegVal ); return ( (RegVal & FPGA_BIT_DISABLE_FLUSH_COMMANDS ) != 0 ); } void CApnCamera::write_DisableFlushCommands( bool DisableFlushCommands ) { char szOutputText[128]; sprintf( szOutputText, "APOGEE.DLL - CApnCamera::write_DisableFlushCommands( DisableFlushCommands = %d)", DisableFlushCommands ); AltaDebugOutputString( szOutputText ); unsigned short RegVal; Read( FPGA_REG_OP_B, RegVal ); if ( DisableFlushCommands ) RegVal |= FPGA_BIT_DISABLE_FLUSH_COMMANDS; else RegVal &= ~FPGA_BIT_DISABLE_FLUSH_COMMANDS; Write( FPGA_REG_OP_B, RegVal ); } bool CApnCamera::read_DisablePostExposeFlushing() { AltaDebugOutputString( "APOGEE.DLL - CApnCamera::read_DisablePostExposeFlushing()" ); unsigned short RegVal; Read( FPGA_REG_OP_B, RegVal ); return ( (RegVal & FPGA_BIT_DISABLE_POST_EXP_FLUSH ) != 0 ); } void CApnCamera::write_DisablePostExposeFlushing( bool DisablePostExposeFlushing ) { char szOutputText[128]; sprintf( szOutputText, "APOGEE.DLL - CApnCamera::write_DisablePostExposeFlushing( DisablePostExposeFlushing = %d)", DisablePostExposeFlushing ); AltaDebugOutputString( szOutputText ); unsigned short RegVal; Read( FPGA_REG_OP_B, RegVal ); if ( DisablePostExposeFlushing ) RegVal |= FPGA_BIT_DISABLE_POST_EXP_FLUSH; else RegVal &= ~FPGA_BIT_DISABLE_POST_EXP_FLUSH; Write( FPGA_REG_OP_B, RegVal ); } bool CApnCamera::read_ExternalIoReadout() { AltaDebugOutputString( "APOGEE.DLL - CApnCamera::read_ExternalIoReadout()" ); unsigned short RegVal; bool RetVal; RetVal = false; if ( m_pvtPlatformType == Apn_Platform_Alta ) { Read( FPGA_REG_OP_A, RegVal ); RetVal = (RegVal & FPGA_BIT_SHUTTER_MODE) != 0; } else if ( m_pvtPlatformType == Apn_Platform_Ascent ) { RetVal = false; } return RetVal; } void CApnCamera::write_ExternalIoReadout( bool ExternalIoReadout ) { char szOutputText[128]; sprintf( szOutputText, "APOGEE.DLL - CApnCamera::write_ExternalIoReadout( ExternalIoReadout = %d)", ExternalIoReadout ); AltaDebugOutputString( szOutputText ); unsigned short RegVal; if ( m_pvtPlatformType == Apn_Platform_Alta ) { Read( FPGA_REG_OP_A, RegVal ); if ( ExternalIoReadout ) RegVal |= FPGA_BIT_SHUTTER_MODE; else RegVal &= ~FPGA_BIT_SHUTTER_MODE; Write( FPGA_REG_OP_A, RegVal ); } } bool CApnCamera::read_ExternalShutter() { AltaDebugOutputString( "APOGEE.DLL - CApnCamera::read_ExternalShutter()" ); unsigned short RegVal; Read( FPGA_REG_OP_A, RegVal ); return ( (RegVal & FPGA_BIT_SHUTTER_SOURCE) != 0 ); } void CApnCamera::write_ExternalShutter( bool ExternalShutter ) { char szOutputText[128]; sprintf( szOutputText, "APOGEE.DLL - CApnCamera::write_ExternalShutter( ExternalShutter = %d)", ExternalShutter ); AltaDebugOutputString( szOutputText ); unsigned short RegVal; Read( FPGA_REG_OP_A, RegVal ); if ( ExternalShutter ) RegVal |= FPGA_BIT_SHUTTER_SOURCE; else RegVal &= ~FPGA_BIT_SHUTTER_SOURCE; Write( FPGA_REG_OP_A, RegVal ); m_pvtExternalShutter = ExternalShutter; } bool CApnCamera::read_FastSequence() { AltaDebugOutputString( "APOGEE.DLL - CApnCamera::read_FastSequence()" ); if ( m_ApnSensorInfo->m_InterlineCCD == false ) return false; unsigned short RegVal; Read( FPGA_REG_OP_A, RegVal ); return ( (RegVal & FPGA_BIT_RATIO) != 0 ); } void CApnCamera::write_FastSequence( bool FastSequence ) { char szOutputText[128]; sprintf( szOutputText, "APOGEE.DLL - CApnCamera::write_FastSequence( FastSequence = %d)", FastSequence ); AltaDebugOutputString( szOutputText ); // fast sequence/progressive scan is for interline only if ( m_ApnSensorInfo->m_InterlineCCD == false ) return; // do not allow triggers on each progressive scanned image if ( m_pvtTriggerNormalEach ) return; unsigned short RegVal; Read( FPGA_REG_OP_A, RegVal ); if ( FastSequence ) { RegVal |= FPGA_BIT_RATIO; Write( FPGA_REG_SHUTTER_CLOSE_DELAY, 0x0 ); } else { RegVal &= ~FPGA_BIT_RATIO; } Write( FPGA_REG_OP_A, RegVal ); m_pvtFastSequence = FastSequence; } Apn_NetworkMode CApnCamera::read_NetworkTransferMode() { AltaDebugOutputString( "APOGEE.DLL - CApnCamera::read_NetworkTransferMode()" ); return m_pvtNetworkTransferMode; } void CApnCamera::write_NetworkTransferMode( Apn_NetworkMode TransferMode ) { char szOutputText[128]; sprintf( szOutputText, "APOGEE.DLL - CApnCamera::write_NetworkTransferMode( TransferMode = %d)", TransferMode ); AltaDebugOutputString( szOutputText ); SetNetworkTransferMode( TransferMode ); m_pvtNetworkTransferMode = TransferMode; } Apn_CameraMode CApnCamera::read_CameraMode() { AltaDebugOutputString( "APOGEE.DLL - CApnCamera::read_CameraMode()" ); return m_pvtCameraMode; } void CApnCamera::write_CameraMode( Apn_CameraMode CameraMode ) { char szOutputText[128]; sprintf( szOutputText, "APOGEE.DLL - CApnCamera::write_CameraMode( CameraMode = %d)", CameraMode ); AltaDebugOutputString( szOutputText ); unsigned short RegVal; // The Apn_CameraMode_ExternalShutter mode was deprecated as of // version 3.0.15. If an application sends this mode, it is now // converted to Apn_CameraMode_Normal. Applications should use the // ExternalShutter property to enable an external shutter if ( CameraMode == Apn_CameraMode_ExternalShutter ) CameraMode = Apn_CameraMode_Normal; // Only allow Apn_CameraMode_Kinetics if our firmware is v17 or higher. // If the firmware doesn't support the mode, switch to Apn_CameraMode_Normal if ( (m_pvtFirmwareVersion < 17 ) && (CameraMode == Apn_CameraMode_Kinetics) ) CameraMode = Apn_CameraMode_Normal; // If we are an interline CCD, do not allow the mode to be set to // Apn_CameraMode_TDI or Apn_CameraMode_Kinetics if ( m_ApnSensorInfo->m_InterlineCCD == true ) { if ( (CameraMode == Apn_CameraMode_TDI) || (CameraMode == Apn_CameraMode_Kinetics) ) CameraMode = Apn_CameraMode_Normal; } // If our state isn't going to change, do nothing if ( m_pvtCameraMode == CameraMode ) return; // If we didn't return already, then if we know our state is going to // change. If we're in test mode, clear the appropriate FPGA bit(s). switch( m_pvtCameraMode ) { case Apn_CameraMode_Normal: break; case Apn_CameraMode_TDI: break; case Apn_CameraMode_Test: Read( FPGA_REG_OP_B, RegVal ); RegVal &= ~FPGA_BIT_AD_SIMULATION; Write( FPGA_REG_OP_B, RegVal ); break; case Apn_CameraMode_ExternalTrigger: RegVal = read_IoPortAssignment(); if ( m_pvtPlatformType == Apn_Platform_Alta ) { RegVal &= 0x3E; // External trigger is pin one (bit zero) write_IoPortAssignment( RegVal ); } break; case Apn_CameraMode_Kinetics: break; } switch ( CameraMode ) { case Apn_CameraMode_Normal: break; case Apn_CameraMode_TDI: break; case Apn_CameraMode_Test: Read( FPGA_REG_OP_B, RegVal ); RegVal |= FPGA_BIT_AD_SIMULATION; Write( FPGA_REG_OP_B, RegVal ); break; case Apn_CameraMode_ExternalTrigger: RegVal = read_IoPortAssignment(); if ( m_pvtPlatformType == Apn_Platform_Alta ) { RegVal |= 0x01; // External trigger is pin one (bit zero) write_IoPortAssignment( RegVal ); } else if ( m_pvtPlatformType == Apn_Platform_Ascent ) { RegVal |= 0x02; // External trigger is pin one (bit zero) write_IoPortAssignment( RegVal ); } break; case Apn_CameraMode_Kinetics: break; } m_pvtCameraMode = CameraMode; } Apn_Resolution CApnCamera::read_DataBits() { AltaDebugOutputString( "APOGEE.DLL - CApnCamera::read_DataBits()" ); return m_pvtDataBits; } void CApnCamera::write_DataBits( Apn_Resolution BitResolution ) { char szOutputText[128]; sprintf( szOutputText, "APOGEE.DLL - CApnCamera::write_DataBits( BitResolution = %d)", BitResolution ); AltaDebugOutputString( szOutputText ); unsigned short RegVal; bool UseOppositePatterns; if ( GetCameraInterface() == Apn_Interface_NET ) { // The network interface is 16bpp only. Changing the resolution // for network cameras has no effect. return; } if ( m_ApnSensorInfo->m_AlternativeADType == ApnAdType_None ) { // No 12bit A/D converter is supported. Changing the resolution // for these systems has no effect return; } if ( m_pvtDataBits != BitResolution ) { // Reset the camera Write( FPGA_REG_COMMAND_B, FPGA_BIT_CMD_RESET ); // Change bit setting after the reset Read( FPGA_REG_OP_A, RegVal ); if ( BitResolution == Apn_Resolution_TwelveBit ) RegVal |= FPGA_BIT_DIGITIZATION_RES; if ( BitResolution == Apn_Resolution_SixteenBit ) RegVal &= ~FPGA_BIT_DIGITIZATION_RES; Write( FPGA_REG_OP_A, RegVal ); m_pvtDataBits = BitResolution; if ( BitResolution == Apn_Resolution_TwelveBit ) Write( FPGA_REG_HRAM_INV_MASK, m_ApnSensorInfo->m_RoiPatternTwelve.Mask ); if ( BitResolution == Apn_Resolution_SixteenBit ) Write( FPGA_REG_HRAM_INV_MASK, m_ApnSensorInfo->m_RoiPatternSixteen.Mask ); UseOppositePatterns = false; if ( (m_ApnSensorInfo->m_CameraId >= 256) && (m_ApnSensorInfo->m_DefaultSpeed == 0x0) ) { UseOppositePatterns = true; } LoadClampPattern( UseOppositePatterns ); LoadSkipPattern( UseOppositePatterns ); LoadRoiPattern( UseOppositePatterns, m_pvtRoiBinningH ); // Reset the camera and start flushing ResetSystem(); } } Apn_Status CApnCamera::read_ImagingStatus() { bool Exposing, Active, Done, Flushing, WaitOnTrigger; bool DataHalted, RamError; AltaDebugOutputString( "APOGEE.DLL - CApnCamera::read_ImagingStatus()" ); UpdateGeneralStatus(); // Update the ImagingStatus Exposing = false; Active = false; Done = false; Flushing = false; WaitOnTrigger = false; DataHalted = false; RamError = false; if ( (GetCameraInterface() == Apn_Interface_USB) && (m_pvtQueryStatusRetVal == CAPNCAMERA_ERR_CONNECT) ) { m_pvtImagingStatus = Apn_Status_ConnectionError; return m_pvtImagingStatus; } if ( (m_pvtStatusReg & FPGA_BIT_STATUS_IMAGING_ACTIVE) != 0 ) Active = true; if ( (m_pvtStatusReg & FPGA_BIT_STATUS_IMAGE_EXPOSING) != 0 ) Exposing = true; if ( (m_pvtStatusReg & FPGA_BIT_STATUS_IMAGE_DONE) != 0 ) Done = true; if ( (m_pvtStatusReg & FPGA_BIT_STATUS_FLUSHING) != 0 ) Flushing = true; if ( (m_pvtStatusReg & FPGA_BIT_STATUS_WAITING_TRIGGER) != 0 ) WaitOnTrigger = true; if ( (m_pvtStatusReg & FPGA_BIT_STATUS_DATA_HALTED) != 0 ) DataHalted = true; if ( (m_pvtStatusReg & FPGA_BIT_STATUS_PATTERN_ERROR) != 0 ) RamError = true; // set the previous imaging status to whatever the current status is // this previous status will only be used for stopping a triggered // exposure, in the case where the hw trigger was not yet received. m_pvtPrevImagingStatus = m_pvtImagingStatus; if ( RamError ) { m_pvtImagingStatus = Apn_Status_PatternError; } else { if ( DataHalted ) { m_pvtImagingStatus = Apn_Status_DataError; } else { if ( WaitOnTrigger ) { m_pvtImagingStatus = Apn_Status_WaitingOnTrigger; if ( m_pvtExposureExternalShutter && Active && Exposing ) { m_pvtImagingStatus = Apn_Status_Exposing; } } else { if ( Done && m_pvtImageInProgress && ( (m_pvtCameraMode != Apn_CameraMode_TDI) || ((m_pvtCameraMode == Apn_CameraMode_TDI) && (m_pvtSequenceBulkDownload)) ) ) { m_pvtImageReady = true; m_pvtImagingStatus = Apn_Status_ImageReady; } else { if ( Active ) { if ( Exposing ) m_pvtImagingStatus = Apn_Status_Exposing; else m_pvtImagingStatus = Apn_Status_ImagingActive; } else { if ( Flushing ) m_pvtImagingStatus = Apn_Status_Flushing; else { if ( m_pvtImageInProgress && (m_pvtCameraMode == Apn_CameraMode_TDI) ) { // Driver defined status...not all rows have been returned to the application m_pvtImagingStatus = Apn_Status_ImagingActive; } else { m_pvtImagingStatus = Apn_Status_Idle; } if ( m_pvtPrevImagingStatus == Apn_Status_WaitingOnTrigger ) { // we've transitioned from waiting on the trigger // to an idle state. this means the trigger was // never received by the hardware. reset the hardware // and start flushing the sensor. } } } } } } } #ifdef APOGEE_DLL_IMAGING_STATUS_OUTPUT char szMsg[512]; sprintf( szMsg, "APOGEE.DLL - CApnCamera::read_ImagingStatus() - Flags: Active=%d; Exposing=%d; Done=%d; Flushing=%d; WaitOnTrigger=%d", Active, Exposing, Done, Flushing, WaitOnTrigger ); AltaDebugOutputString( szMsg ); switch( m_pvtImagingStatus ) { case Apn_Status_DataError: AltaDebugOutputString( "APOGEE.DLL - CApnCamera::read_ImagingStatus() returning Apn_Status_DataError" ); break; case Apn_Status_PatternError: AltaDebugOutputString( "APOGEE.DLL - CApnCamera::read_ImagingStatus() returning Apn_Status_PatternError" ); break; case Apn_Status_Idle: AltaDebugOutputString( "APOGEE.DLL - CApnCamera::read_ImagingStatus() returning Apn_Status_Idle" ); break; case Apn_Status_Exposing: AltaDebugOutputString( "APOGEE.DLL - CApnCamera::read_ImagingStatus() returning Apn_Status_Exposing" ); break; case Apn_Status_ImagingActive: AltaDebugOutputString( "APOGEE.DLL - CApnCamera::read_ImagingStatus() returning Apn_Status_ImagingActive" ); break; case Apn_Status_ImageReady: AltaDebugOutputString( "APOGEE.DLL - CApnCamera::read_ImagingStatus() returning Apn_Status_ImageReady" ); break; case Apn_Status_Flushing: AltaDebugOutputString( "APOGEE.DLL - CApnCamera::read_ImagingStatus() returning Apn_Status_Flushing" ); break; case Apn_Status_WaitingOnTrigger: AltaDebugOutputString( "APOGEE.DLL - CApnCamera::read_ImagingStatus() returning Apn_Status_WaitingOnTrigger" ); break; default: AltaDebugOutputString( "APOGEE.DLL - CApnCamera::read_ImagingStatus() returning UNDEFINED!!" ); break; } #endif return m_pvtImagingStatus; } Apn_LedMode CApnCamera::read_LedMode() { AltaDebugOutputString( "APOGEE.DLL - CApnCamera::read_LedMode()" ); return m_pvtLedMode; } void CApnCamera::write_LedMode( Apn_LedMode LedMode ) { unsigned short RegVal; char szOutputText[128]; sprintf( szOutputText, "APOGEE.DLL - CApnCamera::write_LedMode( LedMode = %d)", LedMode ); AltaDebugOutputString( szOutputText ); Read( FPGA_REG_OP_A, RegVal ); switch ( LedMode ) { case Apn_LedMode_DisableAll: RegVal |= FPGA_BIT_LED_DISABLE; break; case Apn_LedMode_DisableWhileExpose: RegVal &= ~FPGA_BIT_LED_DISABLE; RegVal |= FPGA_BIT_LED_EXPOSE_DISABLE; break; case Apn_LedMode_EnableAll: RegVal &= ~FPGA_BIT_LED_DISABLE; RegVal &= ~FPGA_BIT_LED_EXPOSE_DISABLE; break; } m_pvtLedMode = LedMode; Write( FPGA_REG_OP_A, RegVal ); } Apn_LedState CApnCamera::read_LedState( unsigned short LedId ) { AltaDebugOutputString( "APOGEE.DLL - CApnCamera::read_LedState()" ); Apn_LedState RetVal; if ( LedId == 0 ) // LED A RetVal = m_pvtLedStateA; if ( LedId == 1 ) // LED B RetVal = m_pvtLedStateB; return RetVal; } void CApnCamera::write_LedState( unsigned short LedId, Apn_LedState LedState ) { unsigned short RegVal; char szOutputText[128]; sprintf( szOutputText, "APOGEE.DLL - CApnCamera::write_LedState( LedId = %d, LedState = %d)", LedId, LedState ); AltaDebugOutputString( szOutputText ); RegVal = 0x0; if ( LedId == 0 ) // LED A { RegVal = (m_pvtLedStateB << 4); // keep the current settings for LED B RegVal |= LedState; // program new settings m_pvtLedStateA = LedState; } else if ( LedId == 1 ) // LED B { RegVal = m_pvtLedStateA; // keep the current settings for LED A RegVal |= (LedState << 4); // program new settings m_pvtLedStateB = LedState; } Write( FPGA_REG_LED_SELECT, RegVal ); } bool CApnCamera::read_CoolerEnable() { AltaDebugOutputString( "APOGEE.DLL - CApnCamera::read_CoolerEnable()" ); return m_pvtCoolerEnable; } void CApnCamera::write_CoolerEnable( bool CoolerEnable ) { char szOutputText[128]; sprintf( szOutputText, "APOGEE.DLL - CApnCamera::write_CoolerEnable( CoolerEnable = %d)", CoolerEnable ); AltaDebugOutputString( szOutputText ); if ( CoolerEnable ) { Write( FPGA_REG_COMMAND_B, FPGA_BIT_CMD_RAMP_TO_SETPOINT ); } else { Write( FPGA_REG_COMMAND_B, FPGA_BIT_CMD_RAMP_TO_AMBIENT ); } m_pvtCoolerEnable = CoolerEnable; } Apn_CoolerStatus CApnCamera::read_CoolerStatus() { bool CoolerAtTemp; bool CoolerActive; bool CoolerTempRevised; AltaDebugOutputString( "APOGEE.DLL - CApnCamera::read_CoolerStatus()" ); UpdateGeneralStatus(); // Update CoolerStatus CoolerActive = false; CoolerAtTemp = false; CoolerTempRevised = false; if ( (m_pvtStatusReg & FPGA_BIT_STATUS_TEMP_AT_TEMP) != 0 ) CoolerAtTemp = true; if ( (m_pvtStatusReg & FPGA_BIT_STATUS_TEMP_ACTIVE) != 0 ) CoolerActive = true; if ( (m_pvtStatusReg & FPGA_BIT_STATUS_TEMP_REVISION) != 0 ) CoolerTempRevised = true; // Now derive our cooler state if ( !CoolerActive ) { m_pvtCoolerStatus = Apn_CoolerStatus_Off; } else { if ( CoolerTempRevised ) { m_pvtCoolerStatus = Apn_CoolerStatus_Revision; } else { if ( CoolerAtTemp ) m_pvtCoolerStatus = Apn_CoolerStatus_AtSetPoint; else m_pvtCoolerStatus = Apn_CoolerStatus_RampingToSetPoint; } } return m_pvtCoolerStatus; } double CApnCamera::read_CoolerSetPoint() { unsigned short RegVal; double TempVal; AltaDebugOutputString( "APOGEE.DLL - CApnCamera::read_CoolerSetPoint()" ); Read( FPGA_REG_TEMP_DESIRED, RegVal ); RegVal &= 0x0FFF; TempVal = ( RegVal - m_PlatformTempSetpointZeroPoint ) * m_PlatformTempDegreesPerBit; return TempVal; } void CApnCamera::write_CoolerSetPoint( double SetPoint ) { char szOutputText[128]; sprintf( szOutputText, "APOGEE.DLL - CApnCamera::write_CoolerSetPoint( SetPoint = %f)", SetPoint ); AltaDebugOutputString( szOutputText ); unsigned short RegVal; double TempVal; TempVal = SetPoint; if ( SetPoint < (m_PlatformTempSetpointMin - m_PlatformTempKelvinScaleOffset) ) TempVal = m_PlatformTempSetpointMin; if ( SetPoint > (m_PlatformTempSetpointMax - m_PlatformTempKelvinScaleOffset) ) TempVal = m_PlatformTempSetpointMax; RegVal = (unsigned short)( (TempVal / m_PlatformTempDegreesPerBit) + m_PlatformTempSetpointZeroPoint ); Write( FPGA_REG_TEMP_DESIRED, RegVal ); } double CApnCamera::read_CoolerBackoffPoint() { AltaDebugOutputString( "APOGEE.DLL - CApnCamera::read_CoolerBackoffPoint()" ); return ( m_pvtCoolerBackoffPoint ); } void CApnCamera::write_CoolerBackoffPoint( double BackoffPoint ) { char szOutputText[128]; sprintf( szOutputText, "APOGEE.DLL - CApnCamera::write_CoolerBackoffPoint( BackoffPoint = %f)", BackoffPoint ); AltaDebugOutputString( szOutputText ); unsigned short RegVal; double TempVal; TempVal = BackoffPoint; // BackoffPoint must be a positive number! if ( BackoffPoint < 0.0 ) TempVal = 0.0; if ( BackoffPoint < (m_PlatformTempSetpointMin - m_PlatformTempKelvinScaleOffset) ) TempVal = m_PlatformTempSetpointMin; if ( BackoffPoint > (m_PlatformTempSetpointMax - m_PlatformTempKelvinScaleOffset) ) TempVal = m_PlatformTempSetpointMax; m_pvtCoolerBackoffPoint = TempVal; RegVal = (unsigned short)( TempVal / m_PlatformTempDegreesPerBit ); Write( FPGA_REG_TEMP_BACKOFF, RegVal ); } double CApnCamera::read_CoolerDrive() { AltaDebugOutputString( "APOGEE.DLL - CApnCamera::read_CoolerDrive()" ); UpdateGeneralStatus(); return m_pvtCoolerDrive; } double CApnCamera::read_TempCCD() { double TempAvg; double TempTotal; AltaDebugOutputString( "APOGEE.DLL - CApnCamera::read_TempCCD()" ); TempTotal = 0; for ( int i=0; i<8; i++ ) { UpdateGeneralStatus(); TempTotal += m_pvtCurrentCcdTemp; } TempAvg = TempTotal / 8; return TempAvg; } double CApnCamera::read_TempHeatsink() { double TempAvg; double TempTotal; if ( m_pvtPlatformType == Apn_Platform_Alta ) { TempTotal = 0; for ( int i=0; i<8; i++ ) { UpdateGeneralStatus(); TempTotal += m_pvtCurrentHeatsinkTemp; } TempAvg = TempTotal / 8; } else if ( m_pvtPlatformType == Apn_Platform_Ascent ) { // Hinksink temperature recording not supported // Return an obviously incorrect value TempAvg = -255; } return TempAvg; } Apn_FanMode CApnCamera::read_FanMode() { Apn_FanMode RetVal; if ( m_pvtPlatformType == Apn_Platform_Alta ) RetVal = m_pvtFanMode; else if ( m_pvtPlatformType == Apn_Platform_Ascent ) RetVal = Apn_FanMode_Off; return RetVal; } void CApnCamera::write_FanMode( Apn_FanMode FanMode ) { char szOutputText[128]; sprintf( szOutputText, "APOGEE.DLL - CApnCamera::write_FanMode( FanMode = %d)", FanMode ); AltaDebugOutputString( szOutputText ); unsigned short RegVal; unsigned short OpRegA; if ( m_pvtPlatformType == Apn_Platform_Alta ) { if ( m_pvtFanMode == FanMode ) return; if ( m_pvtCoolerEnable ) { Read( FPGA_REG_OP_A, OpRegA ); OpRegA |= FPGA_BIT_TEMP_SUSPEND; Write( FPGA_REG_OP_A, OpRegA ); do { Read( FPGA_REG_GENERAL_STATUS, RegVal ); } while ( (RegVal & FPGA_BIT_STATUS_TEMP_SUSPEND_ACK) == 0 ); } switch ( FanMode ) { case Apn_FanMode_Off: RegVal = m_PlatformFanSpeedOff; break; case Apn_FanMode_Low: RegVal = m_PlatformFanSpeedLow; break; case Apn_FanMode_Medium: RegVal = m_PlatformFanSpeedMedium; break; case Apn_FanMode_High: RegVal = m_PlatformFanSpeedHigh; break; } Write( FPGA_REG_FAN_SPEED_CONTROL, RegVal ); Read( FPGA_REG_OP_B, RegVal ); RegVal |= FPGA_BIT_DAC_SELECT_ZERO; RegVal &= ~FPGA_BIT_DAC_SELECT_ONE; Write( FPGA_REG_OP_B, RegVal ); Write( FPGA_REG_COMMAND_B, FPGA_BIT_CMD_DAC_LOAD ); m_pvtFanMode = FanMode; if ( m_pvtCoolerEnable ) { OpRegA &= ~FPGA_BIT_TEMP_SUSPEND; Write( FPGA_REG_OP_A, OpRegA ); } } } double CApnCamera::read_ShutterStrobePosition() { AltaDebugOutputString( "APOGEE.DLL - CApnCamera::read_ShutterStrobePosition" ); return m_pvtShutterStrobePosition; } void CApnCamera::write_ShutterStrobePosition( double Position ) { char szOutputText[128]; sprintf( szOutputText, "APOGEE.DLL - CApnCamera::write_ShutterStrobePosition( Position = %f)", Position ); AltaDebugOutputString( szOutputText ); unsigned short RegVal; if ( Position < m_PlatformStrobePositionMin ) Position = m_PlatformStrobePositionMin; RegVal = (unsigned short)((Position - m_PlatformStrobePositionMin) / m_PlatformTimerResolution); Write( FPGA_REG_SHUTTER_STROBE_POSITION, RegVal ); m_pvtShutterStrobePosition = Position; } double CApnCamera::read_ShutterStrobePeriod() { AltaDebugOutputString( "APOGEE.DLL - CApnCamera::read_ShutterStrobePosition" ); return m_pvtShutterStrobePeriod; } void CApnCamera::write_ShutterStrobePeriod( double Period ) { char szOutputText[128]; sprintf( szOutputText, "APOGEE.DLL - CApnCamera::write_ShutterStrobePeriod( Period = %f)", Period ); AltaDebugOutputString( szOutputText ); unsigned short RegVal; if ( Period < m_PlatformStrobePeriodMin ) Period = m_PlatformStrobePeriodMin; RegVal = (unsigned short)((Period - m_PlatformStrobePeriodMin) / m_PlatformPeriodTimerResolution); Write( FPGA_REG_SHUTTER_STROBE_PERIOD, RegVal ); m_pvtShutterStrobePeriod = Period; } double CApnCamera::read_ShutterCloseDelay() { AltaDebugOutputString( "APOGEE.DLL - CApnCamera::read_ShutterCloseDelay" ); return m_pvtShutterCloseDelay; } void CApnCamera::write_ShutterCloseDelay( double ShutterCloseDelay ) { char szOutputText[128]; sprintf( szOutputText, "APOGEE.DLL - CApnCamera::write_ShutterCloseDelay( ShutterCloseDelay = %f)", ShutterCloseDelay ); AltaDebugOutputString( szOutputText ); unsigned short RegVal; if ( ShutterCloseDelay < m_PlatformShutterCloseDiff ) ShutterCloseDelay = m_PlatformShutterCloseDiff; RegVal = (unsigned short)( (ShutterCloseDelay - m_PlatformShutterCloseDiff) / m_PlatformTimerResolution ); Write( FPGA_REG_SHUTTER_CLOSE_DELAY, RegVal ); m_pvtShutterCloseDelay = ShutterCloseDelay; } bool CApnCamera::read_SequenceBulkDownload() { AltaDebugOutputString( "APOGEE.DLL - CApnCamera::read_SequenceBulkDownload" ); return m_pvtSequenceBulkDownload; } void CApnCamera::write_SequenceBulkDownload( bool SequenceBulkDownload ) { char szOutputText[128]; AltaDebugPrint( szOutputText, "APOGEE.DLL - CApnCamera::write_SequenceBulkDownload( SequenceBulkDownload = %d)", SequenceBulkDownload ); AltaDebugOutputString( szOutputText ); if ( GetCameraInterface() == Apn_Interface_NET ) { m_pvtSequenceBulkDownload = true; return; } m_pvtSequenceBulkDownload = SequenceBulkDownload; } double CApnCamera::read_SequenceDelay() { AltaDebugOutputString( "APOGEE.DLL - CApnCamera::read_SequenceDelay" ); return m_pvtSequenceDelay; } void CApnCamera::write_SequenceDelay( double Delay ) { char szOutputText[128]; sprintf( szOutputText, "APOGEE.DLL - CApnCamera::write_SequenceDelay( Delay = %f)", Delay ); AltaDebugOutputString( szOutputText ); unsigned short RegVal; if ( Delay > m_PlatformSequenceDelayMaximum ) Delay = m_PlatformSequenceDelayMaximum; if ( Delay < m_PlatformSequenceDelayMinimum ) Delay = m_PlatformSequenceDelayMinimum; m_pvtSequenceDelay = Delay; RegVal = (unsigned short)(Delay / m_PlatformSequenceDelayResolution); Write( FPGA_REG_SEQUENCE_DELAY, RegVal ); } bool CApnCamera::read_VariableSequenceDelay() { AltaDebugOutputString( "APOGEE.DLL - CApnCamera::read_VariableSequenceDelay" ); unsigned short RegVal; Read( FPGA_REG_OP_A, RegVal ); // variable delay occurs when the bit is 0 return ( (RegVal & FPGA_BIT_DELAY_MODE) == 0 ); } void CApnCamera::write_VariableSequenceDelay( bool VariableSequenceDelay ) { char szOutputText[128]; sprintf( szOutputText, "APOGEE.DLL - CApnCamera::write_VariableSequenceDelay( VariableSequenceDelay = %d)", VariableSequenceDelay ); AltaDebugOutputString( szOutputText ); unsigned short RegVal; Read( FPGA_REG_OP_A, RegVal ); if ( VariableSequenceDelay ) RegVal &= ~FPGA_BIT_DELAY_MODE; // variable when zero else RegVal |= FPGA_BIT_DELAY_MODE; // constant when one Write( FPGA_REG_OP_A, RegVal ); } unsigned short CApnCamera::read_ImageCount() { AltaDebugOutputString( "APOGEE.DLL - CApnCamera::read_ImageCount" ); return m_pvtImageCount; } void CApnCamera::write_ImageCount( unsigned short Count ) { char szOutputText[128]; sprintf( szOutputText, "APOGEE.DLL - CApnCamera::write_ImageCount( Count = %d)", Count ); AltaDebugOutputString( szOutputText ); if ( Count == 0 ) Count = 1; Write( FPGA_REG_IMAGE_COUNT, Count ); m_pvtImageCount = Count; } unsigned short CApnCamera::read_FlushBinningV() { return m_pvtFlushBinningV; } void CApnCamera::write_FlushBinningV( unsigned short FlushBinningV ) { unsigned short NewFlushBinningV; // Do some bounds checking on our input parameter if ( FlushBinningV == 0 ) NewFlushBinningV = 1; else if ( FlushBinningV > read_MaxBinningV() ) NewFlushBinningV = read_MaxBinningV(); else NewFlushBinningV = FlushBinningV; // First check to see if we actually need to update the binning if ( NewFlushBinningV != m_pvtFlushBinningV ) { ResetSystemNoFlush(); Write( FPGA_REG_VFLUSH_BINNING, NewFlushBinningV ); m_pvtFlushBinningV = NewFlushBinningV; ResetSystem(); } } unsigned short CApnCamera::read_RoiBinningH() { return m_pvtRoiBinningH; } void CApnCamera::write_RoiBinningH( unsigned short RoiBinningH ) { unsigned short NewRoiBinningH; bool UseOppositePatterns; // Do some bounds checking on our input parameter if ( RoiBinningH == 0 ) NewRoiBinningH = 1; else if ( RoiBinningH > read_MaxBinningH() ) NewRoiBinningH = read_MaxBinningH(); else NewRoiBinningH = RoiBinningH; // Check to see if we actually need to update the binning if ( NewRoiBinningH != m_pvtRoiBinningH ) { // Reset the camera ResetSystemNoFlush(); UseOppositePatterns = false; if ( (m_ApnSensorInfo->m_CameraId >= 256) && (m_ApnSensorInfo->m_DefaultSpeed == 0x0) ) { UseOppositePatterns = true; } LoadRoiPattern( UseOppositePatterns, NewRoiBinningH ); m_pvtRoiBinningH = NewRoiBinningH; // Reset the camera and start flushing ResetSystem(); } } unsigned short CApnCamera::read_RoiBinningV() { return m_pvtRoiBinningV; } void CApnCamera::write_RoiBinningV( unsigned short RoiBinningV ) { unsigned short NewRoiBinningV; // Do some bounds checking on our input parameter if ( RoiBinningV == 0 ) NewRoiBinningV = 1; if ( RoiBinningV > read_MaxBinningV() ) NewRoiBinningV = read_MaxBinningV(); else NewRoiBinningV = RoiBinningV; // Check to see if we actually need to update the binning if ( NewRoiBinningV != m_pvtRoiBinningV ) { m_pvtRoiBinningV = NewRoiBinningV; } } unsigned short CApnCamera::read_RoiPixelsH() { return m_pvtRoiPixelsH; } void CApnCamera::write_RoiPixelsH( unsigned short RoiPixelsH ) { unsigned short NewRoiPixelsH; if ( RoiPixelsH == 0 ) NewRoiPixelsH = 1; else NewRoiPixelsH = RoiPixelsH; m_pvtRoiPixelsH = NewRoiPixelsH; } unsigned short CApnCamera::read_RoiPixelsV() { return m_pvtRoiPixelsV; } void CApnCamera::write_RoiPixelsV( unsigned short RoiPixelsV ) { unsigned short NewRoiPixelsV; if ( RoiPixelsV == 0 ) NewRoiPixelsV = 1; else NewRoiPixelsV = RoiPixelsV; m_pvtRoiPixelsV = NewRoiPixelsV; } unsigned short CApnCamera::read_RoiStartX() { return m_pvtRoiStartX; } void CApnCamera::write_RoiStartX( unsigned short RoiStartX ) { m_pvtRoiStartX = RoiStartX; } unsigned short CApnCamera::read_RoiStartY() { return m_pvtRoiStartY; } void CApnCamera::write_RoiStartY( unsigned short RoiStartY ) { m_pvtRoiStartY = RoiStartY; } bool CApnCamera::read_DigitizeOverscan() { return m_pvtDigitizeOverscan; } void CApnCamera::write_DigitizeOverscan( bool DigitizeOverscan ) { m_pvtDigitizeOverscan = DigitizeOverscan; } unsigned short CApnCamera::read_OverscanColumns() { return m_ApnSensorInfo->m_OverscanColumns; } unsigned short CApnCamera::read_MaxBinningH() { return m_PlatformHBinningMax; } unsigned short CApnCamera::read_MaxBinningV() { if ( m_ApnSensorInfo->m_ImagingRows < m_PlatformVBinningMax ) return m_ApnSensorInfo->m_ImagingRows; else return m_PlatformVBinningMax; } unsigned short CApnCamera::read_SequenceCounter() { UpdateGeneralStatus(); if ( m_pvtSequenceBulkDownload ) return m_pvtSequenceCounter; else return m_pvtReadyFrame; } bool CApnCamera::read_ContinuousImaging() { // CI requires v17 or higher firmware support if ( m_pvtFirmwareVersion < 17 ) return false; unsigned short RegVal; Read( FPGA_REG_OP_B, RegVal ); return ( (RegVal & FPGA_BIT_CONT_IMAGE_ENABLE) == 1 ); } void CApnCamera::write_ContinuousImaging( bool ContinuousImaging ) { // CI requires v17 or higher firmware support if ( m_pvtFirmwareVersion < 17 ) return; unsigned short RegVal; Read( FPGA_REG_OP_B, RegVal ); if ( ContinuousImaging ) RegVal |= FPGA_BIT_CONT_IMAGE_ENABLE; // enable else RegVal &= ~FPGA_BIT_CONT_IMAGE_ENABLE; // disable Write( FPGA_REG_OP_B, RegVal ); } unsigned short CApnCamera::read_TDICounter() { unsigned short Counter; char szOutputText[128]; AltaDebugOutputString( "APOGEE.DLL - CApnCamera::read_TDICounter()" ); UpdateGeneralStatus(); if ( m_pvtSequenceBulkDownload ) Counter = m_pvtTDICounter; else Counter = m_pvtReadyFrame; AltaDebugPrint( szOutputText, "APOGEE.DLL - CApnCamera::read_TDICounter() returning %d", Counter ); AltaDebugOutputString( szOutputText ); return Counter; } unsigned short CApnCamera::read_TDIRows() { char szOutputText[128]; AltaDebugOutputString( "APOGEE.DLL - CApnCamera::read_TDIRows()" ); return m_pvtTDIRows; AltaDebugPrint( szOutputText, "APOGEE.DLL - CApnCamera::read_TDIRows() returning %d", m_pvtTDIRows ); AltaDebugOutputString( szOutputText ); } void CApnCamera::write_TDIRows( unsigned short TdiRows ) { if ( TdiRows == 0 ) // Make sure the TDI row count is at least 1 TdiRows = 1; Write( FPGA_REG_TDI_COUNT, TdiRows ); m_pvtTDIRows = TdiRows; } double CApnCamera::read_TDIRate() { return m_pvtTDIRate; } void CApnCamera::write_TDIRate( double TdiRate ) { unsigned short RegVal; if ( TdiRate < m_PlatformTdiRateMin ) TdiRate = m_PlatformTdiRateMin; if ( TdiRate > m_PlatformTdiRateMax ) TdiRate = m_PlatformTdiRateMax; RegVal = (unsigned short)( TdiRate / m_PlatformTdiRateResolution ); Write( FPGA_REG_TDI_RATE, RegVal ); m_pvtTDIRate = TdiRate; } unsigned short CApnCamera::read_TDIBinningV() { return m_pvtTDIBinningV; } void CApnCamera::write_TDIBinningV( unsigned short TdiBinningV ) { if ( TdiBinningV == 0 ) // Make sure the TDI binning is at least 1 TdiBinningV = 1; Write( FPGA_REG_TDI_BINNING, TdiBinningV ); m_pvtTDIBinningV = TdiBinningV; } unsigned short CApnCamera::read_KineticsSections() { return read_TDIRows(); } void CApnCamera::write_KineticsSections( unsigned short KineticsSections ) { write_TDIRows( KineticsSections ); } double CApnCamera::read_KineticsShiftInterval() { return read_TDIRate(); } void CApnCamera::write_KineticsShiftInterval( double KineticsShiftInterval ) { write_TDIRate( KineticsShiftInterval ); } unsigned short CApnCamera::read_KineticsSectionHeight() { return read_TDIBinningV(); } void CApnCamera::write_KineticsSectionHeight( unsigned short KineticsSectionHeight ) { write_TDIBinningV( KineticsSectionHeight ); } bool CApnCamera::read_TriggerNormalEach() { // This trigger option requires v17 or higher firmware on Alta if ( (m_pvtPlatformType == Apn_Platform_Alta) && (m_pvtFirmwareVersion < 17) ) return false; unsigned short RegVal; Read( FPGA_REG_OP_C, RegVal ); return ( (RegVal & FPGA_BIT_IMAGE_TRIGGER_EACH) == 1 ); } void CApnCamera::write_TriggerNormalEach( bool TriggerNormalEach ) { // This trigger option requires v17 or higher firmware on Alta if ( (m_pvtPlatformType == Apn_Platform_Alta) && (m_pvtFirmwareVersion < 17) ) return; // do not allow triggers on each progressive scanned image if ( m_pvtFastSequence ) return; // If our current state var is equal to the new state, no need to do anything if ( m_pvtTriggerNormalEach == TriggerNormalEach ) return; unsigned short RegVal, IoRegVal; Read( FPGA_REG_OP_C, RegVal ); if ( TriggerNormalEach ) { RegVal |= FPGA_BIT_IMAGE_TRIGGER_EACH; // Enable // We only need to set the I/O port bit if it hasn't been set already if ( (!m_pvtTriggerNormalGroup) && (!m_pvtTriggerTdiKineticsEach) && (!m_pvtTriggerTdiKineticsGroup) ) { IoRegVal = read_IoPortAssignment(); if ( m_pvtPlatformType == Apn_Platform_Alta ) IoRegVal |= 0x01; // External trigger is pin one (bit zero) else if ( m_pvtPlatformType == Apn_Platform_Ascent ) IoRegVal &= 0x02; write_IoPortAssignment( IoRegVal ); } } else { RegVal &= ~FPGA_BIT_IMAGE_TRIGGER_EACH; // Disable // We only disable the I/O port bit if it is unused if ( (!m_pvtTriggerNormalGroup) && (!m_pvtTriggerTdiKineticsEach) && (!m_pvtTriggerTdiKineticsGroup) ) { IoRegVal = read_IoPortAssignment(); IoRegVal &= 0x3E; // External trigger is pin one (bit zero) write_IoPortAssignment( IoRegVal ); } } Write( FPGA_REG_OP_C, RegVal ); m_pvtTriggerNormalEach = TriggerNormalEach; } bool CApnCamera::read_TriggerNormalGroup() { // This trigger option requires v17 or higher firmware on Alta if ( (m_pvtPlatformType == Apn_Platform_Alta) && (m_pvtFirmwareVersion < 17) ) return false; unsigned short RegVal; Read( FPGA_REG_OP_C, RegVal ); return ( (RegVal & FPGA_BIT_IMAGE_TRIGGER_GROUP) == 1 ); } void CApnCamera::write_TriggerNormalGroup( bool TriggerNormalGroup ) { // This trigger option requires v17 or higher firmware on Alta if ( (m_pvtPlatformType == Apn_Platform_Alta) && (m_pvtFirmwareVersion < 17) ) return; // If our current state var is equal to the new state, no need to do anything if ( m_pvtTriggerNormalGroup == TriggerNormalGroup ) return; unsigned short RegVal, IoRegVal; Read( FPGA_REG_OP_C, RegVal ); if ( TriggerNormalGroup ) { RegVal |= FPGA_BIT_IMAGE_TRIGGER_GROUP; // enable // We only need to set the I/O port bit if it hasn't been set already if ( (!m_pvtTriggerNormalEach) && (!m_pvtTriggerTdiKineticsEach) && (!m_pvtTriggerTdiKineticsGroup) ) { IoRegVal = read_IoPortAssignment(); if ( m_pvtPlatformType == Apn_Platform_Alta ) IoRegVal |= 0x01; // External trigger is pin one (bit zero) else if ( m_pvtPlatformType == Apn_Platform_Ascent ) IoRegVal &= 0x02; write_IoPortAssignment( IoRegVal ); } } else { RegVal &= ~FPGA_BIT_IMAGE_TRIGGER_GROUP; // disable // We only disable the I/O port bit if it is unused if ( (!m_pvtTriggerNormalEach) && (!m_pvtTriggerTdiKineticsEach) && (!m_pvtTriggerTdiKineticsGroup) ) { IoRegVal = read_IoPortAssignment(); IoRegVal &= 0x3E; // External trigger is pin one (bit zero) write_IoPortAssignment( IoRegVal ); } } Write( FPGA_REG_OP_C, RegVal ); m_pvtTriggerNormalGroup = TriggerNormalGroup; } bool CApnCamera::read_TriggerTdiKineticsEach() { // This trigger option requires v17 or higher firmware on Alta if ( (m_pvtPlatformType == Apn_Platform_Alta) && (m_pvtFirmwareVersion < 17) ) return false; unsigned short RegVal; Read( FPGA_REG_OP_C, RegVal ); return ( (RegVal & FPGA_BIT_TDI_TRIGGER_EACH) == 1 ); } void CApnCamera::write_TriggerTdiKineticsEach( bool TriggerTdiKineticsEach ) { // This trigger option requires v17 or higher firmware on Alta if ( (m_pvtPlatformType == Apn_Platform_Alta) && (m_pvtFirmwareVersion < 17) ) return; // If our current state var is equal to the new state, no need to do anything if ( m_pvtTriggerTdiKineticsEach == TriggerTdiKineticsEach ) return; unsigned short RegVal, IoRegVal; Read( FPGA_REG_OP_C, RegVal ); if ( TriggerTdiKineticsEach ) { RegVal |= FPGA_BIT_TDI_TRIGGER_EACH; // enable // We only need to set the I/O port bit if it hasn't been set already if ( (!m_pvtTriggerNormalEach) && (!m_pvtTriggerNormalGroup) && (!m_pvtTriggerTdiKineticsGroup) ) { IoRegVal = read_IoPortAssignment(); if ( m_pvtPlatformType == Apn_Platform_Alta ) IoRegVal |= 0x01; // External trigger is pin one (bit zero) else if ( m_pvtPlatformType == Apn_Platform_Ascent ) IoRegVal &= 0x02; write_IoPortAssignment( IoRegVal ); } } else { RegVal &= ~FPGA_BIT_TDI_TRIGGER_EACH; // disable // We only disable the I/O port bit if it is unused if ( (!m_pvtTriggerNormalEach) && (!m_pvtTriggerNormalGroup) && (!m_pvtTriggerTdiKineticsGroup) ) { IoRegVal = read_IoPortAssignment(); IoRegVal &= 0x3E; // External trigger is pin one (bit zero) write_IoPortAssignment( IoRegVal ); } } Write( FPGA_REG_OP_C, RegVal ); m_pvtTriggerTdiKineticsEach = TriggerTdiKineticsEach; } bool CApnCamera::read_TriggerTdiKineticsGroup() { // This trigger option requires v17 or higher firmware on Alta if ( (m_pvtPlatformType == Apn_Platform_Alta) && (m_pvtFirmwareVersion < 17) ) return false; unsigned short RegVal; Read( FPGA_REG_OP_C, RegVal ); return ( (RegVal & FPGA_BIT_TDI_TRIGGER_GROUP) == 1 ); } void CApnCamera::write_TriggerTdiKineticsGroup( bool TriggerTdiKineticsGroup ) { // This trigger option requires v17 or higher firmware on Alta if ( (m_pvtPlatformType == Apn_Platform_Alta) && (m_pvtFirmwareVersion < 17) ) return; // If our current state var is equal to the new state, no need to do anything if ( m_pvtTriggerTdiKineticsGroup == TriggerTdiKineticsGroup ) return; unsigned short RegVal, IoRegVal; Read( FPGA_REG_OP_C, RegVal ); if ( TriggerTdiKineticsGroup ) { RegVal |= FPGA_BIT_TDI_TRIGGER_GROUP; // enable // We only need to set the I/O port bit if it hasn't been set already if ( (!m_pvtTriggerNormalEach) && (!m_pvtTriggerNormalGroup) && (!m_pvtTriggerTdiKineticsEach) ) { IoRegVal = read_IoPortAssignment(); if ( m_pvtPlatformType == Apn_Platform_Alta ) IoRegVal |= 0x01; // External trigger is pin one (bit zero) else if ( m_pvtPlatformType == Apn_Platform_Ascent ) IoRegVal &= 0x02; write_IoPortAssignment( IoRegVal ); } } else { RegVal &= ~FPGA_BIT_TDI_TRIGGER_GROUP; // disable // We only disable the I/O port bit if it is unused if ( (!m_pvtTriggerNormalEach) && (!m_pvtTriggerNormalGroup) && (!m_pvtTriggerTdiKineticsEach) ) { IoRegVal = read_IoPortAssignment(); IoRegVal &= 0x3E; // External trigger is pin one (bit zero) write_IoPortAssignment( IoRegVal ); } } Write( FPGA_REG_OP_C, RegVal ); m_pvtTriggerTdiKineticsGroup = TriggerTdiKineticsGroup; } bool CApnCamera::read_ExposureTriggerEach() { return m_pvtExposureTriggerEach; } bool CApnCamera::read_ExposureTriggerGroup() { return m_pvtExposureTriggerGroup; } bool CApnCamera::read_ExposureExternalShutter() { return m_pvtExposureExternalShutter; } unsigned short CApnCamera::read_IoPortAssignment() { return m_pvtIoPortAssignment; } void CApnCamera::write_IoPortAssignment( unsigned short IoPortAssignment ) { if ( m_pvtPlatformType == Apn_Platform_Alta ) { IoPortAssignment &= FPGA_MASK_IO_PORT_ASSIGNMENT_ALTA; Write( FPGA_REG_IO_PORT_ASSIGNMENT_ALTA, IoPortAssignment ); } else if ( m_pvtPlatformType == Apn_Platform_Ascent ) { IoPortAssignment &= FPGA_MASK_IO_PORT_ASSIGNMENT_ASCENT; Write( FPGA_REG_IO_PORT_ASSIGNMENT_ASCENT, IoPortAssignment ); } m_pvtIoPortAssignment = IoPortAssignment; } unsigned short CApnCamera::read_IoPortDirection() { unsigned short RetVal; RetVal = 0x0; if ( m_pvtPlatformType == Apn_Platform_Alta ) RetVal = m_pvtIoPortDirection; else if ( m_pvtPlatformType == Apn_Platform_Ascent ) RetVal = 0x0; return RetVal; } void CApnCamera::write_IoPortDirection( unsigned short IoPortDirection ) { if ( m_pvtPlatformType == Apn_Platform_Alta ) { IoPortDirection &= FPGA_MASK_IO_PORT_DIRECTION; Write( FPGA_REG_IO_PORT_DIRECTION, IoPortDirection ); m_pvtIoPortDirection = IoPortDirection; } } unsigned short CApnCamera::read_IoPortData() { unsigned short RegVal; if ( m_pvtPlatformType == Apn_Platform_Alta ) { Read( FPGA_REG_IO_PORT_READ, RegVal ); RegVal &= FPGA_MASK_IO_PORT_DATA; } else if ( m_pvtPlatformType == Apn_Platform_Ascent ) { RegVal = 0x0; } return RegVal; } void CApnCamera::write_IoPortData( unsigned short IoPortData ) { if ( m_pvtPlatformType == Apn_Platform_Alta ) { IoPortData &= FPGA_MASK_IO_PORT_DATA; Write( FPGA_REG_IO_PORT_WRITE, IoPortData ); } } unsigned short CApnCamera::read_TwelveBitGain() { unsigned short RetVal; if ( m_pvtPlatformType == Apn_Platform_Alta ) RetVal = m_pvtTwelveBitGain; else if ( m_pvtPlatformType == Apn_Platform_Ascent ) RetVal = 0x0; return RetVal; } void CApnCamera::write_TwelveBitGain( unsigned short TwelveBitGain ) { unsigned short NewVal; unsigned short StartVal; unsigned short FirstBit; if ( m_pvtPlatformType == Apn_Platform_Alta ) { NewVal = 0x0; StartVal = TwelveBitGain & 0x3FF; for ( int i=0; i<10; i++ ) { FirstBit = ( StartVal & 0x0001 ); NewVal |= ( FirstBit << (10-i) ); StartVal = StartVal >> 1; } NewVal |= 0x4000; Write( FPGA_REG_AD_CONFIG_DATA, NewVal ); Write( FPGA_REG_COMMAND_B, 0x8000 ); m_pvtTwelveBitGain = TwelveBitGain & 0x3FF; } } unsigned short CApnCamera::read_TwelveBitOffset() { unsigned short RetVal; if ( m_pvtPlatformType == Apn_Platform_Alta ) RetVal = m_pvtTwelveBitOffset; else if ( m_pvtPlatformType == Apn_Platform_Ascent ) RetVal = 0x0; return RetVal; } void CApnCamera::write_TwelveBitOffset( unsigned short TwelveBitOffset ) { unsigned short NewVal; unsigned short StartVal; unsigned short FirstBit; if ( m_pvtPlatformType == Apn_Platform_Alta ) { NewVal = 0x0; StartVal = TwelveBitOffset & 0xFF; for ( int i=0; i<8; i++ ) { FirstBit = ( StartVal & 0x0001 ); NewVal |= ( FirstBit << (10-i) ); StartVal = StartVal >> 1; } NewVal |= 0x2000; Write( FPGA_REG_AD_CONFIG_DATA, NewVal ); Write( FPGA_REG_COMMAND_B, FPGA_BIT_CMD_AD_CONFIG ); m_pvtTwelveBitOffset = TwelveBitOffset; } } double CApnCamera::read_MaxExposureTime() { return m_PlatformExposureTimeMax; } double CApnCamera::read_TestLedBrightness() { return m_pvtTestLedBrightness; } void CApnCamera::write_TestLedBrightness( double TestLedBrightness ) { unsigned short RegVal; unsigned short OpRegA; if ( TestLedBrightness == m_pvtTestLedBrightness ) return; if ( m_pvtCoolerEnable ) { Read( FPGA_REG_OP_A, OpRegA ); OpRegA |= FPGA_BIT_TEMP_SUSPEND; Write( FPGA_REG_OP_A, OpRegA ); do { Read( FPGA_REG_GENERAL_STATUS, RegVal ); } while ( (RegVal & FPGA_BIT_STATUS_TEMP_SUSPEND_ACK) == 0 ); } if ( m_pvtPlatformType == Apn_Platform_Alta ) { RegVal = (unsigned short)( (double)FPGA_MASK_LED_ILLUMINATION_ALTA * (TestLedBrightness/100.0) ); } else if ( m_pvtPlatformType == Apn_Platform_Ascent ) { RegVal = (unsigned short)( (double)FPGA_MASK_LED_ILLUMINATION_ASCENT * (TestLedBrightness/100.0) ); } Write( FPGA_REG_LED_DRIVE, RegVal ); Read( FPGA_REG_OP_B, RegVal ); RegVal &= ~FPGA_BIT_DAC_SELECT_ZERO; RegVal |= FPGA_BIT_DAC_SELECT_ONE; Write( FPGA_REG_OP_B, RegVal ); Write( FPGA_REG_COMMAND_B, FPGA_BIT_CMD_DAC_LOAD ); m_pvtTestLedBrightness = TestLedBrightness; if ( m_pvtCoolerEnable ) { OpRegA &= ~FPGA_BIT_TEMP_SUSPEND; Write( FPGA_REG_OP_A, OpRegA ); } } Apn_Platform CApnCamera::read_PlatformType() { return m_pvtPlatformType; } unsigned short CApnCamera::read_AscentADGainSixteenLeft() { if ( m_pvtPlatformType == Apn_Platform_Alta ) return 0; return m_pvtAscentSixteenBitGainLeft; } unsigned short CApnCamera::read_AscentADGainSixteenRight() { if ( m_pvtPlatformType == Apn_Platform_Alta ) return 0; return m_pvtAscentSixteenBitGainRight; } void CApnCamera::write_AscentADGainSixteen( unsigned short GainValue ) { if ( m_pvtPlatformType == Apn_Platform_Alta ) return; unsigned short NewVal; NewVal = GainValue & 0x003F; NewVal |= 0x2000; Write( FPGA_REG_AD_CONFIG_DATA, NewVal ); Write( FPGA_REG_COMMAND_B, FPGA_BIT_CMD_AD_CONFIG ); } unsigned short CApnCamera::read_AscentADOffsetSixteenLeft() { if ( m_pvtPlatformType == Apn_Platform_Alta ) return 0; return m_pvtAscentSixteenBitOffsetLeft; } unsigned short CApnCamera::read_AscentADOffsetSixteenRight() { if ( m_pvtPlatformType == Apn_Platform_Alta ) return 0; return m_pvtAscentSixteenBitOffsetRight; } void CApnCamera::write_AscentADOffsetSixteen( unsigned short OffsetValue ) { if ( m_pvtPlatformType == Apn_Platform_Alta ) return; unsigned short NewVal; NewVal = OffsetValue & 0x01FF; NewVal |= 0x5000; Write( FPGA_REG_AD_CONFIG_DATA, NewVal ); Write( FPGA_REG_COMMAND_B, FPGA_BIT_CMD_AD_CONFIG ); } unsigned short CApnCamera::read_DigitizationSpeed() { if ( m_pvtPlatformType == Apn_Platform_Alta ) return 0; unsigned short RegVal; Read( FPGA_REG_OP_C, RegVal ); return ( (RegVal & FPGA_MASK_HCLK) >> 4 ); } void CApnCamera::write_DigitizationSpeed( unsigned short DigitizationSpeed ) { if ( m_pvtPlatformType == Apn_Platform_Alta ) return; unsigned short RegVal; unsigned short TempHclkValue; TempHclkValue = DigitizationSpeed & 0x7; TempHclkValue = TempHclkValue << 4; Read( FPGA_REG_OP_C, RegVal ); RegVal &= ~FPGA_MASK_HCLK; RegVal |= TempHclkValue; Write( FPGA_REG_OP_C, RegVal ); } /* bool CApnCamera::FilterInit( Apn_Filter FilterType ) { char szOutputText[128]; sprintf( szOutputText, "APOGEE.DLL - CApnCamera::FilterInit( FilterType = %d)", FilterType ); AltaDebugOutputString( szOutputText ); if ( m_pvtPlatformType == Apn_Platform_Alta ) return true; if ( (FilterType != Apn_Filter_AFW30_7R) && (FilterType != Apn_Filter_AFW50_5R) && (FilterType != Apn_Filter_AFW25_4R) ) { return false; } switch ( FilterType ) { case Apn_Filter_AFW30_7R: m_pvtFilterWheelType = Apn_Filter_AFW30_7R; m_pvtFilterMaxPositions = APN_FILTER_AFW30_7R_MAX_POSITIONS; break; case Apn_Filter_AFW50_5R: m_pvtFilterWheelType = Apn_Filter_AFW50_5R; m_pvtFilterMaxPositions = APN_FILTER_AFW50_5R_MAX_POSITIONS; break; case Apn_Filter_AFW25_4R: m_pvtFilterWheelType = Apn_Filter_AFW25_4R; m_pvtFilterMaxPositions = APN_FILTER_AFW25_4R_MAX_POSITIONS; break; default: m_pvtFilterWheelType = Apn_Filter_Unknown; m_pvtFilterMaxPositions = APN_FILTER_UNKNOWN_MAX_POSITIONS; return false; break; } return true; } bool CApnCamera::FilterClose() { AltaDebugOutputString( "APOGEE.DLL - CApnCamera::FilterClose()" ); if ( m_pvtPlatformType == Apn_Platform_Alta ) return true; m_pvtFilterWheelType = Apn_Filter_Unknown; m_pvtFilterMaxPositions = APN_FILTER_UNKNOWN_MAX_POSITIONS; return true; } unsigned short CApnCamera::read_FilterPosition() { if ( m_pvtPlatformType == Apn_Platform_Alta ) return 0; if ( m_pvtFilterWheelType == Apn_Filter_Unknown ) return 0; unsigned short RegVal; Read( FPGA_REG_OP_C, RegVal ); return ( (RegVal & FPGA_MASK_FILTER_POSITION) >> 8 ); } void CApnCamera::write_FilterPosition( unsigned short FilterPosition ) { if ( m_pvtPlatformType == Apn_Platform_Alta ) return; if ( m_pvtFilterWheelType == Apn_Filter_Unknown ) return; if ( FilterPosition >= m_pvtFilterMaxPositions ) return; unsigned short RegVal; unsigned short TempFilterPosition; TempFilterPosition = FilterPosition & 0x7; TempFilterPosition = FilterPosition << 8; Read( FPGA_REG_OP_C, RegVal ); RegVal &= ~FPGA_MASK_FILTER_POSITION; RegVal |= TempFilterPosition; Write( FPGA_REG_OP_C, RegVal ); } bool CApnCamera::read_FilterReady() { if ( m_pvtPlatformType == Apn_Platform_Alta ) return false; if ( m_pvtFilterWheelType == Apn_Filter_Unknown ) return false; UpdateGeneralStatus(); return ( (m_pvtStatusReg & FPGA_BIT_STATUS_FILTER_SENSE) != 0 ); } unsigned short CApnCamera::read_FilterMaxPositions() { if ( m_pvtPlatformType == Apn_Platform_Alta ) return 0; return m_pvtFilterMaxPositions; } Apn_Filter CApnCamera::read_FilterWheelType() { return m_pvtFilterWheelType; } void CApnCamera::read_FilterModel( char *FilterModel, long *BufferLength ) { // we don't check platform type or anything for this property because // we want to return something, no matter what. we key off the private // variable m_pvtFilterWheelType, and we'll just return "Unknown" // for anything other than what we support char szModel[256]; switch ( m_pvtFilterWheelType ) { case Apn_Filter_AFW30_7R: strcpy( szModel, APN_FILTER_AFW30_7R_DESCR ); break; case Apn_Filter_AFW50_5R: strcpy( szModel, APN_FILTER_AFW50_5R_DESCR ); break; case Apn_Filter_AFW25_4R: strcpy( szModel, APN_FILTER_AFW25_4R_DESCR ); break; default: strcpy( szModel, "Unknown" ); break; } *BufferLength = strlen( szModel ); strncpy( FilterModel, szModel, *BufferLength + 1); } */ bool CApnCamera::read_DataAveraging() { if ( m_pvtPlatformType == Apn_Platform_Alta ) return false; unsigned short RegVal; Read( FPGA_REG_OP_B, RegVal ); return ( (RegVal & FPGA_BIT_AD_AVERAGING) != 0 ); } void CApnCamera::write_DataAveraging( bool DataAveraging ) { if ( m_pvtPlatformType == Apn_Platform_Alta ) return; unsigned short RegVal; Read( FPGA_REG_OP_B, RegVal ); if ( DataAveraging ) RegVal |= FPGA_BIT_AD_AVERAGING; // enable else RegVal &= ~FPGA_BIT_AD_AVERAGING; // disable Write( FPGA_REG_OP_B, RegVal ); } bool CApnCamera::read_DualReadout() { if ( m_pvtPlatformType == Apn_Platform_Alta ) return false; return m_pvtDualReadout; } void CApnCamera::write_DualReadout( bool DualReadout ) { if ( m_pvtPlatformType == Apn_Platform_Alta ) { m_pvtDualReadout = false; return; } unsigned short RegVal; Read( FPGA_REG_OP_A, RegVal ); if ( DualReadout ) RegVal |= FPGA_BIT_DUAL_AD_READOUT; // enable else RegVal &= ~FPGA_BIT_DUAL_AD_READOUT; // disable Write( FPGA_REG_OP_A, RegVal ); m_pvtDualReadout = DualReadout; } bool CApnCamera::read_ConnectionTest() { unsigned short RegData; unsigned short NewRegData; RegData = 0x5AA5; Write( FPGA_REG_SCRATCH, RegData ); Read( FPGA_REG_SCRATCH, NewRegData ); if ( RegData != NewRegData ) return false; RegData = 0xA55A; Write( FPGA_REG_SCRATCH, RegData ); Read( FPGA_REG_SCRATCH, NewRegData ); if ( RegData != NewRegData ) return false; return true; } bool CApnCamera::read_GuideActive() { if ( m_pvtPlatformType == Apn_Platform_Alta ) return false; UpdateGeneralStatus(); return ( (m_pvtStatusReg & FPGA_BIT_STATUS_GUIDE_ACTIVE) != 0 ); } double CApnCamera::read_GuideRAPlusDuration() { double RetVal; RetVal = 0; if ( m_pvtPlatformType == Apn_Platform_Alta ) RetVal = 0; else if ( m_pvtPlatformType == Apn_Platform_Ascent ) RetVal = m_pvtGuideRAPlusDuration; return RetVal; } void CApnCamera::write_GuideRAPlusDuration( double GuideRAPlusDuration ) { unsigned short RegVal; double RelayDuration; if ( m_pvtPlatformType == Apn_Platform_Alta ) { return; } else if ( m_pvtPlatformType == Apn_Platform_Ascent ) { RelayDuration = CheckGuiderRelayDuration( GuideRAPlusDuration ); RegVal = CalculateGuiderRelayTimeCounts( RelayDuration ); Write( FPGA_REG_GUIDE_RA_PLUS, RegVal ); m_pvtGuideRAPlusDuration = RelayDuration; } } double CApnCamera::read_GuideRAMinusDuration() { double RetVal; RetVal = 0; if ( m_pvtPlatformType == Apn_Platform_Alta ) RetVal = 0; else if ( m_pvtPlatformType == Apn_Platform_Ascent ) RetVal = m_pvtGuideRAMinusDuration; return RetVal; } void CApnCamera::write_GuideRAMinusDuration( double GuideRAMinusDuration ) { unsigned short RegVal; double RelayDuration; if ( m_pvtPlatformType == Apn_Platform_Alta ) { return; } else if ( m_pvtPlatformType == Apn_Platform_Ascent ) { RelayDuration = CheckGuiderRelayDuration( GuideRAMinusDuration ); RegVal = CalculateGuiderRelayTimeCounts( RelayDuration ); Write( FPGA_REG_GUIDE_RA_MINUS, RegVal ); m_pvtGuideRAMinusDuration = RelayDuration; } } double CApnCamera::read_GuideDecPlusDuration() { double RetVal; RetVal = 0; if ( m_pvtPlatformType == Apn_Platform_Alta ) RetVal = 0; else if ( m_pvtPlatformType == Apn_Platform_Ascent ) RetVal = m_pvtGuideDecPlusDuration; return RetVal; } void CApnCamera::write_GuideDecPlusDuration( double GuideDecPlusDuration ) { unsigned short RegVal; double RelayDuration; if ( m_pvtPlatformType == Apn_Platform_Alta ) { return; } else if ( m_pvtPlatformType == Apn_Platform_Ascent ) { RelayDuration = CheckGuiderRelayDuration( GuideDecPlusDuration ); RegVal = CalculateGuiderRelayTimeCounts( RelayDuration ); Write( FPGA_REG_GUIDE_DEC_PLUS, RegVal ); m_pvtGuideDecPlusDuration = RelayDuration; } } double CApnCamera::read_GuideDecMinusDuration() { double RetVal; RetVal = 0; if ( m_pvtPlatformType == Apn_Platform_Alta ) RetVal = 0; else if ( m_pvtPlatformType == Apn_Platform_Ascent ) RetVal = m_pvtGuideDecMinusDuration; return RetVal; } void CApnCamera::write_GuideDecMinusDuration( double GuideDecMinusDuration ) { unsigned short RegVal; double RelayDuration; if ( m_pvtPlatformType == Apn_Platform_Alta ) { return; } else if ( m_pvtPlatformType == Apn_Platform_Ascent ) { RelayDuration = CheckGuiderRelayDuration( GuideDecMinusDuration ); RegVal = CalculateGuiderRelayTimeCounts( RelayDuration ); Write( FPGA_REG_GUIDE_DEC_MINUS, RegVal ); m_pvtGuideDecMinusDuration = RelayDuration; } } Apn_BayerShift CApnCamera::read_BayerStartPosition() { return m_pvtBayerShift; } void CApnCamera::write_BayerStartPosition( Apn_BayerShift BayerStartPosition ) { m_pvtBayerShift = BayerStartPosition; } long CApnCamera::LoadVerticalPattern() { unsigned short RegData; // Prime the RAM (Enable) Read( FPGA_REG_OP_B, RegData ); RegData |= FPGA_BIT_VRAM_ENABLE; Write( FPGA_REG_OP_B, RegData ); WriteMultiSRMD( FPGA_REG_VRAM_INPUT, m_ApnSensorInfo->m_VerticalPattern.PatternData, m_ApnSensorInfo->m_VerticalPattern.NumElements ); // RAM is now loaded (Disable) Read( FPGA_REG_OP_B, RegData ); RegData &= ~FPGA_BIT_VRAM_ENABLE; Write( FPGA_REG_OP_B, RegData ); return 0; } long CApnCamera::LoadClampPattern( bool UseOppositePatterns ) { unsigned short RegData; // Prime the RAM (Enable) Read( FPGA_REG_OP_B, RegData ); RegData |= FPGA_BIT_HCLAMP_ENABLE; Write( FPGA_REG_OP_B, RegData ); if ( m_pvtDataBits == Apn_Resolution_SixteenBit ) { if ( UseOppositePatterns ) { WriteHorizontalPattern( &m_ApnSensorInfo->m_ClampPatternTwelve, FPGA_REG_HCLAMP_INPUT, 1 ); } else { WriteHorizontalPattern( &m_ApnSensorInfo->m_ClampPatternSixteen, FPGA_REG_HCLAMP_INPUT, 1 ); } } else if ( m_pvtDataBits == Apn_Resolution_TwelveBit ) { WriteHorizontalPattern( &m_ApnSensorInfo->m_ClampPatternTwelve, FPGA_REG_HCLAMP_INPUT, 1 ); } // RAM is now loaded (Disable) Read( FPGA_REG_OP_B, RegData ); RegData &= ~FPGA_BIT_HCLAMP_ENABLE; Write( FPGA_REG_OP_B, RegData ); return 0; } long CApnCamera::LoadSkipPattern( bool UseOppositePatterns ) { unsigned short RegData; // Prime the RAM (Enable) Read( FPGA_REG_OP_B, RegData ); RegData |= FPGA_BIT_HSKIP_ENABLE; Write( FPGA_REG_OP_B, RegData ); if ( m_pvtDataBits == Apn_Resolution_SixteenBit ) { if ( UseOppositePatterns ) { WriteHorizontalPattern( &m_ApnSensorInfo->m_SkipPatternTwelve, FPGA_REG_HSKIP_INPUT, 1 ); } else { WriteHorizontalPattern( &m_ApnSensorInfo->m_SkipPatternSixteen, FPGA_REG_HSKIP_INPUT, 1 ); } } else if ( m_pvtDataBits == Apn_Resolution_TwelveBit ) { WriteHorizontalPattern( &m_ApnSensorInfo->m_SkipPatternTwelve, FPGA_REG_HSKIP_INPUT, 1 ); } // RAM is now loaded (Disable) Read( FPGA_REG_OP_B, RegData ); RegData &= ~FPGA_BIT_HSKIP_ENABLE; Write( FPGA_REG_OP_B, RegData ); return 0; } long CApnCamera::LoadRoiPattern( bool UseOppositePatterns, unsigned short binning ) { unsigned short RegData; // Prime the RAM (Enable) Read( FPGA_REG_OP_B, RegData ); RegData |= FPGA_BIT_HRAM_ENABLE; Write( FPGA_REG_OP_B, RegData ); if ( m_pvtDataBits == Apn_Resolution_SixteenBit ) { if ( UseOppositePatterns ) { WriteHorizontalPattern( &m_ApnSensorInfo->m_RoiPatternTwelve, FPGA_REG_HRAM_INPUT, binning ); } else { WriteHorizontalPattern( &m_ApnSensorInfo->m_RoiPatternSixteen, FPGA_REG_HRAM_INPUT, binning ); } } else if ( m_pvtDataBits == Apn_Resolution_TwelveBit ) { WriteHorizontalPattern( &m_ApnSensorInfo->m_RoiPatternTwelve, FPGA_REG_HRAM_INPUT, binning ); } // RAM is now loaded (Disable) Read( FPGA_REG_OP_B, RegData ); RegData &= ~FPGA_BIT_HRAM_ENABLE; Write( FPGA_REG_OP_B, RegData ); return 0; } long CApnCamera::WriteHorizontalPattern( APN_HPATTERN_FILE *Pattern, unsigned short RamReg, unsigned short Binning ) { unsigned short i; unsigned short DataCount; unsigned short *DataArray; unsigned short Index; unsigned short BinNumber; Index = 0; BinNumber = Binning - 1; // arrays are zero-based DataCount = Pattern->RefNumElements + Pattern->BinNumElements[BinNumber] + Pattern->SigNumElements; DataArray = (unsigned short *)malloc(DataCount * sizeof(unsigned short)); for ( i=0; iRefNumElements; i++ ) { DataArray[Index] = Pattern->RefPatternData[i]; Index++; } for ( i=0; iBinNumElements[BinNumber]; i++ ) { DataArray[Index] = Pattern->BinPatternData[BinNumber][i]; Index++; } for ( i=0; iSigNumElements; i++ ) { DataArray[Index] = Pattern->SigPatternData[i]; Index++; } WriteMultiSRMD( RamReg, DataArray, DataCount ); // cleanup free( DataArray ); return 0; } double CApnCamera::CheckGuiderRelayDuration( double GuideDuration ) { double RetVal; RetVal = GuideDuration; if ( RetVal < m_PlatformGuiderRelayMin ) RetVal = m_PlatformGuiderRelayMin; else if ( RetVal > m_PlatformGuiderRelayMax ) RetVal = m_PlatformGuiderRelayMax; return RetVal; } unsigned short CApnCamera::CalculateGuiderRelayTimeCounts( double GuideDuration ) { unsigned short RetVal; RetVal = (unsigned short)( (GuideDuration + m_PlatformGuiderRelayOpenTime + m_PlatformGuiderRelayCloseTime) / m_PlatformGuiderRelayResolution ); return RetVal; } long CApnCamera::LookupAltaCameraId( unsigned short CameraId ) { switch ( CameraId & FPGA_MASK_CAMERA_ID_ALTA ) { case APN_ALTA_KAF0401E_CAM_ID: m_ApnSensorInfo = new CApnCamData_KAF0401E; break; case APN_ALTA_KAF1602E_CAM_ID: m_ApnSensorInfo = new CApnCamData_KAF1602E; break; case APN_ALTA_KAF0261E_CAM_ID: m_ApnSensorInfo = new CApnCamData_KAF0261E; break; case APN_ALTA_KAF1301E_CAM_ID: m_ApnSensorInfo = new CApnCamData_KAF1301E; break; case APN_ALTA_KAF1001E_CAM_ID: m_ApnSensorInfo = new CApnCamData_KAF1001E; break; case APN_ALTA_KAF1001ENS_CAM_ID: m_ApnSensorInfo = new CApnCamData_KAF1001ENS; break; case APN_ALTA_KAF10011105_CAM_ID: m_ApnSensorInfo = new CApnCamData_KAF10011105; break; case APN_ALTA_KAF3200E_CAM_ID: m_ApnSensorInfo = new CApnCamData_KAF3200E; break; case APN_ALTA_KAF6303E_CAM_ID: m_ApnSensorInfo = new CApnCamData_KAF6303E; break; case APN_ALTA_KAF16801E_CAM_ID: m_ApnSensorInfo = new CApnCamData_KAF16801E; break; case APN_ALTA_KAF16803_CAM_ID: m_ApnSensorInfo = new CApnCamData_KAF16803; break; case APN_ALTA_KAF09000_CAM_ID: m_ApnSensorInfo = new CApnCamData_KAF09000; break; case APN_ALTA_KAF09000X_CAM_ID: m_ApnSensorInfo = new CApnCamData_KAF09000X; break; case APN_ALTA_KAF0401EB_CAM_ID: m_ApnSensorInfo = new CApnCamData_KAF0401EB; break; case APN_ALTA_KAF1602EB_CAM_ID: m_ApnSensorInfo = new CApnCamData_KAF1602EB; break; case APN_ALTA_KAF0261EB_CAM_ID: m_ApnSensorInfo = new CApnCamData_KAF0261EB; break; case APN_ALTA_KAF1301EB_CAM_ID: m_ApnSensorInfo = new CApnCamData_KAF1301EB; break; case APN_ALTA_KAF1001EB_CAM_ID: m_ApnSensorInfo = new CApnCamData_KAF1001EB; break; case APN_ALTA_KAF6303EB_CAM_ID: m_ApnSensorInfo = new CApnCamData_KAF6303EB; break; case APN_ALTA_KAF3200EB_CAM_ID: m_ApnSensorInfo = new CApnCamData_KAF3200EB; break; case APN_ALTA_TH7899_CAM_ID: m_ApnSensorInfo = new CApnCamData_TH7899; break; case APN_ALTA_S101401107_CAM_ID: m_ApnSensorInfo = new CApnCamData_S101401107; break; case APN_ALTA_S101401109_CAM_ID: m_ApnSensorInfo = new CApnCamData_S101401109; break; case APN_ALTA_CCD4710_CAM_ID: m_ApnSensorInfo = new CApnCamData_CCD4710; break; case APN_ALTA_CCD4710ALT_CAM_ID: m_ApnSensorInfo = new CApnCamData_CCD4710ALT; break; case APN_ALTA_CCD4240_CAM_ID: m_ApnSensorInfo = new CApnCamData_CCD4240; break; case APN_ALTA_CCD5710_CAM_ID: m_ApnSensorInfo = new CApnCamData_CCD5710; break; case APN_ALTA_CCD3011_CAM_ID: m_ApnSensorInfo = new CApnCamData_CCD3011; break; case APN_ALTA_CCD5520_CAM_ID: m_ApnSensorInfo = new CApnCamData_CCD5520; break; case APN_ALTA_CCD4720_CAM_ID: m_ApnSensorInfo = new CApnCamData_CCD4720; break; case APN_ALTA_CCD7700_CAM_ID: m_ApnSensorInfo = new CApnCamData_CCD7700; break; case APN_ALTA_CCD4710B_CAM_ID: m_ApnSensorInfo = new CApnCamData_CCD4710B; break; case APN_ALTA_CCD4240B_CAM_ID: m_ApnSensorInfo = new CApnCamData_CCD4240B; break; case APN_ALTA_CCD5710B_CAM_ID: m_ApnSensorInfo = new CApnCamData_CCD5710B; break; case APN_ALTA_CCD3011B_CAM_ID: m_ApnSensorInfo = new CApnCamData_CCD3011B; break; case APN_ALTA_CCD5520B_CAM_ID: m_ApnSensorInfo = new CApnCamData_CCD5520B; break; case APN_ALTA_CCD4720B_CAM_ID: m_ApnSensorInfo = new CApnCamData_CCD4720B; break; case APN_ALTA_CCD7700B_CAM_ID: m_ApnSensorInfo = new CApnCamData_CCD7700B; break; case APN_ALTA_KAI2001ML_CAM_ID: m_ApnSensorInfo = new CApnCamData_KAI2001ML; break; case APN_ALTA_KAI2020ML_CAM_ID: m_ApnSensorInfo = new CApnCamData_KAI2020ML; break; case APN_ALTA_KAI4020ML_CAM_ID: m_ApnSensorInfo = new CApnCamData_KAI4020ML; break; case APN_ALTA_KAI11000ML_CAM_ID: m_ApnSensorInfo = new CApnCamData_KAI11000ML; break; case APN_ALTA_KAI2001CL_CAM_ID: m_ApnSensorInfo = new CApnCamData_KAI2001CL; break; case APN_ALTA_KAI2020CL_CAM_ID: m_ApnSensorInfo = new CApnCamData_KAI2020CL; break; case APN_ALTA_KAI4020CL_CAM_ID: m_ApnSensorInfo = new CApnCamData_KAI4020CL; break; case APN_ALTA_KAI11000CL_CAM_ID: m_ApnSensorInfo = new CApnCamData_KAI11000CL; break; case APN_ALTA_KAI2020MLB_CAM_ID: m_ApnSensorInfo = new CApnCamData_KAI2020MLB; break; case APN_ALTA_KAI4020MLB_CAM_ID: m_ApnSensorInfo = new CApnCamData_KAI4020MLB; break; case APN_ALTA_KAI2020CLB_CAM_ID: m_ApnSensorInfo = new CApnCamData_KAI2020CLB; break; case APN_ALTA_KAI4020CLB_CAM_ID: m_ApnSensorInfo = new CApnCamData_KAI4020CLB; break; default: return 1; break; } return 0; } long CApnCamera::LookupAscentCameraId( unsigned short CameraId ) { switch ( CameraId & FPGA_MASK_CAMERA_ID_ASCENT ) { case APN_ASCENT_KAF0402E_CAM_ID: m_ApnSensorInfo = new CApnCamData_ASCENT0402ME; break; case APN_ASCENT_KAF0402E2_CAM_ID: m_ApnSensorInfo = new CApnCamData_ASCENT0402ME2; break; case APN_ASCENT_KAF0402E3_CAM_ID: m_ApnSensorInfo = new CApnCamData_ASCENT0402ME3; break; case APN_ASCENT_KAF0402E4_CAM_ID: m_ApnSensorInfo = new CApnCamData_ASCENT0402ME4; break; case APN_ASCENT_KAI340_CAM_ID: m_ApnSensorInfo = new CApnCamData_ASCENT340; break; case APN_ASCENT_KAI2000_CAM_ID: m_ApnSensorInfo = new CApnCamData_ASCENT2000; break; case APN_ASCENT_KAI4000_CAM_ID: m_ApnSensorInfo = new CApnCamData_ASCENT4000; break; case APN_ASCENT_KAI16000_CAM_ID: m_ApnSensorInfo = new CApnCamData_ASCENT16000; break; default: return 1; // No known camera located, return break; } return 0; } long CApnCamera::InitDefaults() { unsigned short RegVal; unsigned short ShutterDelay; unsigned short PreRoiRows, PostRoiRows; unsigned short PreRoiVBinning, PostRoiVBinning; unsigned short UnbinnedRoiY; // Vertical ROI pixels unsigned short CameraId; double CloseDelay; bool UseOppositePatterns; bool AltaPlatform; bool AscentPlatform; AltaPlatform = false; AscentPlatform = false; // Init the camera data structure if ( m_ApnSensorInfo ) delete m_ApnSensorInfo; m_ApnSensorInfo = NULL; // Read and store the firmware version for reference Read( FPGA_REG_FIRMWARE_REV, m_pvtFirmwareVersion ); // Read the Camera ID register Read( FPGA_REG_CAMERA_ID, CameraId ); // Deterministically check if we are an Ascent camera AscentPlatform = ApnCamModelIsAscent( CameraId, m_pvtFirmwareVersion ); // Deterministically check if we are an Alta camera AltaPlatform = ApnCamModelIsAlta( CameraId, m_pvtFirmwareVersion ); // We cannot be both and Alta and an Ascent, and we must be one or the other if ( (AscentPlatform && AltaPlatform) || (!AscentPlatform && !AltaPlatform) ) { m_pvtPlatformType = Apn_Platform_Unknown; return 1; // failure to determine camera line } // Look up the ID and dynamically create the m_ApnSensorInfo object if ( AltaPlatform ) { if ( LookupAltaCameraId( CameraId ) != 0 ) return 1; m_pvtPlatformType = Apn_Platform_Alta; m_pvtCameraID = CameraId & FPGA_MASK_CAMERA_ID_ALTA; } if ( AscentPlatform ) { if ( LookupAscentCameraId( CameraId ) != 0 ) return 1; m_pvtPlatformType = Apn_Platform_Ascent; m_pvtCameraID = CameraId & FPGA_MASK_CAMERA_ID_ASCENT; } // First set all of our constants SetPlatformConstants(); // New Reset command ResetSystemNoFlush(); // we created the object, now set everything m_ApnSensorInfo->Initialize(); // Initialize private variables write_CameraMode( Apn_CameraMode_Normal ); write_DigitizeOverscan( false ); write_DisableFlushCommands( false ); write_DisablePostExposeFlushing( false ); m_pvtDataBits = Apn_Resolution_SixteenBit; m_pvtExternalShutter = false; m_pvtNetworkTransferMode = Apn_NetworkMode_Tcp; // Initialize variables used for imaging m_pvtRoiStartX = 0; m_pvtRoiStartY = 0; m_pvtRoiPixelsH = m_ApnSensorInfo->m_ImagingColumns; m_pvtRoiPixelsV = m_ApnSensorInfo->m_ImagingRows; m_pvtRoiBinningH = 1; m_pvtRoiBinningV = 1; printf ("Camera ID is %u\n",m_pvtCameraID); printf("sensor = %s\n", m_ApnSensorInfo->m_Sensor); printf("model = %s\n",m_ApnSensorInfo->m_CameraModel); printf("interline = %u\n",m_ApnSensorInfo->m_InterlineCCD); printf("serialA = %u\n",m_ApnSensorInfo->m_SupportsSerialA); printf("serialB = %u\n",m_ApnSensorInfo->m_SupportsSerialB); printf("ccdtype = %u\n",m_ApnSensorInfo->m_SensorTypeCCD); printf("Tcolumns = %u\n",m_ApnSensorInfo->m_TotalColumns); printf("ImgColumns = %u\n",m_ApnSensorInfo->m_ImagingColumns); printf("ClampColumns = %u\n",m_ApnSensorInfo->m_ClampColumns); printf("PreRoiSColumns = %u\n",m_ApnSensorInfo->m_PreRoiSkipColumns); printf("PostRoiSColumns = %u\n",m_ApnSensorInfo->m_PostRoiSkipColumns); printf("OverscanColumns = %u\n",m_ApnSensorInfo->m_OverscanColumns); printf("TRows = %u\n",m_ApnSensorInfo->m_TotalRows); printf("ImgRows = %u\n",m_ApnSensorInfo->m_ImagingRows); printf("UnderscanRows = %u\n",m_ApnSensorInfo->m_UnderscanRows); printf("OverscanRows = %u\n",m_ApnSensorInfo->m_OverscanRows); printf("VFlushBinning = %u\n",m_ApnSensorInfo->m_VFlushBinning); printf("HFlushDisable = %u\n",m_ApnSensorInfo->m_HFlushDisable); printf("ShutterCloseDelay = %u\n",m_ApnSensorInfo->m_ShutterCloseDelay); printf("PixelSizeX = %lf\n",m_ApnSensorInfo->m_PixelSizeX); printf("PixelSizeY = %lf\n",m_ApnSensorInfo->m_PixelSizeY); printf("Color = %u\n",m_ApnSensorInfo->m_Color); // printf("ReportedGainTwelveBit = %lf\n",m_ApnSensorInfo->m_ReportedGainTwelveBit); printf("ReportedGainSixteenBit = %lf\n",m_ApnSensorInfo->m_ReportedGainSixteenBit); printf("MinSuggestedExpTime = %lf\n",m_ApnSensorInfo->m_MinSuggestedExpTime); printf("CoolingSupported = %u\n",m_ApnSensorInfo->m_CoolingSupported); printf("RegulatedCoolingSupported = %u\n",m_ApnSensorInfo->m_RegulatedCoolingSupported); printf("TempSetPoint = %lf\n",m_ApnSensorInfo->m_TempSetPoint); // printf("TempRegRate = %u\n",m_ApnSensorInfo->m_TempRegRate); printf("TempRampRateOne = %u\n",m_ApnSensorInfo->m_TempRampRateOne); printf("TempRampRateTwo = %u\n",m_ApnSensorInfo->m_TempRampRateTwo); printf("TempBackoffPoint = %lf\n",m_ApnSensorInfo->m_TempBackoffPoint); // printf("DefaultGainTwelveBit = %u\n",m_ApnSensorInfo->m_DefaultGainTwelveBit); // printf("DefaultOffsetTwelveBit = %u\n",m_ApnSensorInfo->m_DefaultOffsetTwelveBit); printf("DefaultRVoltage = %u\n",m_ApnSensorInfo->m_DefaultRVoltage); printf ("RoiPixelsH is %u\n",m_pvtRoiPixelsH); printf ("RoiPixelsV is %u\n",m_pvtRoiPixelsV); // Issue a clear command, so the registers are zeroed out // This will put the camera in a known state for us. Write( FPGA_REG_COMMAND_B, FPGA_BIT_CMD_CLEAR_ALL ); // Reset the camera ResetSystemNoFlush(); // Load Inversion Masks Write( FPGA_REG_VRAM_INV_MASK, m_ApnSensorInfo->m_VerticalPattern.Mask ); Write( FPGA_REG_HRAM_INV_MASK, m_ApnSensorInfo->m_RoiPatternSixteen.Mask ); // Load Pattern Files LoadVerticalPattern(); UseOppositePatterns = false; if ( (m_ApnSensorInfo->m_CameraId >= 256) && (m_ApnSensorInfo->m_DefaultSpeed == 0x0) ) { UseOppositePatterns = true; } LoadClampPattern( UseOppositePatterns ); LoadSkipPattern( UseOppositePatterns ); LoadRoiPattern( UseOppositePatterns, m_pvtRoiBinningH ); // Set the HCLK speed for Ascent if ( (m_pvtPlatformType == Apn_Platform_Ascent) && (m_ApnSensorInfo->m_DefaultSpeed != 0xFFFF) ) { write_DigitizationSpeed( m_ApnSensorInfo->m_DefaultSpeed ); } // Program default camera settings Write( FPGA_REG_CLAMP_COUNT, m_ApnSensorInfo->m_ClampColumns ); Write( FPGA_REG_PREROI_SKIP_COUNT, m_ApnSensorInfo->m_PreRoiSkipColumns ); Write( FPGA_REG_ROI_COUNT, m_ApnSensorInfo->m_ImagingColumns ); Write( FPGA_REG_POSTROI_SKIP_COUNT, m_ApnSensorInfo->m_PostRoiSkipColumns + m_ApnSensorInfo->m_OverscanColumns ); // Since the default state of m_DigitizeOverscan is false, set the count to zero. Write( FPGA_REG_OVERSCAN_COUNT, 0x0 ); // Now calculate the vertical settings UnbinnedRoiY = m_pvtRoiPixelsV * m_pvtRoiBinningV; PreRoiRows = m_ApnSensorInfo->m_UnderscanRows + m_pvtRoiStartY; PostRoiRows = m_ApnSensorInfo->m_TotalRows - PreRoiRows - UnbinnedRoiY; PreRoiVBinning = 1; PostRoiVBinning = 1; // For interline CCDs, set "Fast Dump" mode if the particular array is NOT digitized if ( m_ApnSensorInfo->m_InterlineCCD ) { // use the fast dump feature to get rid of the data quickly. // one row, binning to the original row count // note that we only are not digitized in arrays 1 and 3 PreRoiVBinning = PreRoiRows; PostRoiVBinning = PostRoiRows; PreRoiVBinning |= FPGA_BIT_ARRAY_FASTDUMP; PostRoiVBinning |= FPGA_BIT_ARRAY_FASTDUMP; PreRoiRows = 1; PostRoiRows = 1; } // Program the vertical settings if ( m_pvtFirmwareVersion < 11 ) { Write( FPGA_REG_A1_ROW_COUNT, PreRoiRows ); Write( FPGA_REG_A1_VBINNING, PreRoiVBinning ); Write( FPGA_REG_A2_ROW_COUNT, m_pvtRoiPixelsV ); Write( FPGA_REG_A2_VBINNING, (m_pvtRoiBinningV | FPGA_BIT_ARRAY_DIGITIZE) ); Write( FPGA_REG_A3_ROW_COUNT, PostRoiRows ); Write( FPGA_REG_A3_VBINNING, PostRoiVBinning ); } else { Write( FPGA_REG_A1_ROW_COUNT, 0 ); Write( FPGA_REG_A1_VBINNING, 0 ); Write( FPGA_REG_A2_ROW_COUNT, PreRoiRows ); Write( FPGA_REG_A2_VBINNING, PreRoiVBinning ); Write( FPGA_REG_A3_ROW_COUNT, m_pvtRoiPixelsV ); Write( FPGA_REG_A3_VBINNING, (m_pvtRoiBinningV | FPGA_BIT_ARRAY_DIGITIZE) ); Write( FPGA_REG_A4_ROW_COUNT, 0 ); Write( FPGA_REG_A4_VBINNING, 0 ); Write( FPGA_REG_A5_ROW_COUNT, PostRoiRows ); Write( FPGA_REG_A5_VBINNING, PostRoiVBinning ); } // we don't use write_FlushBinningV() here because that would include additional RESETs m_pvtFlushBinningV = m_ApnSensorInfo->m_VFlushBinning; Write( FPGA_REG_VFLUSH_BINNING, m_pvtFlushBinningV ); if ( m_ApnSensorInfo->m_ShutterCloseDelay == 0 ) { // This is the case for interline cameras ShutterDelay = 0; m_pvtShutterCloseDelay = ShutterDelay; } else { CloseDelay = (double)m_ApnSensorInfo->m_ShutterCloseDelay / 1000; m_pvtShutterCloseDelay = CloseDelay; ShutterDelay = (unsigned short) ( (CloseDelay - m_PlatformShutterCloseDiff) / m_PlatformTimerResolution ); } if ( m_ApnSensorInfo->m_HFlushDisable ) { Read( FPGA_REG_OP_A, RegVal ); RegVal |= FPGA_BIT_DISABLE_H_CLK; Write( FPGA_REG_OP_A, RegVal ); } // If we are a USB2 camera, set all the 12bit variables for the 12bit // A/D processor if ( GetCameraInterface() == Apn_Interface_USB ) { if ( m_ApnSensorInfo->m_PrimaryADType == ApnAdType_Ascent_Sixteen ) { // left side Read( FPGA_REG_OP_B, RegVal ); RegVal &= ~FPGA_BIT_AD_LOAD_SELECT; Write( FPGA_REG_OP_B, RegVal ); InitAscentSixteenBitAD(); write_AscentADGainSixteen( m_ApnSensorInfo->m_DefaultGainLeft ); write_AscentADOffsetSixteen( m_ApnSensorInfo->m_DefaultOffsetLeft ); // right side Read( FPGA_REG_OP_B, RegVal ); RegVal |= FPGA_BIT_AD_LOAD_SELECT; Write( FPGA_REG_OP_B, RegVal ); InitAscentSixteenBitAD(); write_AscentADGainSixteen( m_ApnSensorInfo->m_DefaultGainRight ); write_AscentADOffsetSixteen( m_ApnSensorInfo->m_DefaultOffsetRight ); // when the right side is done, we need to set the // FPGA_BIT_AD_LOAD_SELECT bit back to zero Read( FPGA_REG_OP_B, RegVal ); RegVal &= ~FPGA_BIT_AD_LOAD_SELECT; Write( FPGA_REG_OP_B, RegVal ); // assign private vars m_pvtAscentSixteenBitGainLeft = m_ApnSensorInfo->m_DefaultGainLeft; m_pvtAscentSixteenBitGainRight = m_ApnSensorInfo->m_DefaultGainRight; m_pvtAscentSixteenBitOffsetLeft = m_ApnSensorInfo->m_DefaultOffsetLeft; m_pvtAscentSixteenBitOffsetRight = m_ApnSensorInfo->m_DefaultOffsetRight; } if ( m_ApnSensorInfo->m_AlternativeADType == ApnAdType_Alta_Twelve ) { InitTwelveBitAD(); write_TwelveBitGain( m_ApnSensorInfo->m_DefaultGainLeft ); write_TwelveBitOffset( m_ApnSensorInfo->m_DefaultOffsetLeft ); } } // Reset the camera and start flushing ResetSystem(); write_SequenceBulkDownload( true ); write_ImageCount( 1 ); write_SequenceDelay( 0.000327 ); write_VariableSequenceDelay( true ); Write( FPGA_REG_SHUTTER_CLOSE_DELAY, ShutterDelay ); // Set the Fan State. Setting the private var first to make sure the write_FanMode // call thinks we're doing a state transition. // On write_FanMode return, our state will be Apn_FanMode_Medium m_pvtFanMode = Apn_FanMode_Off; // we're going to set this write_FanMode( Apn_FanMode_Low ); // Initialize the LED states and the LED mode. There is nothing to output // to the device since we issued our CLEAR early in the init() process, and // we are now in a known state. m_pvtLedStateA = Apn_LedState_Expose; m_pvtLedStateB = Apn_LedState_Expose; m_pvtLedMode = Apn_LedMode_EnableAll; // The CLEAR puts many vars into their default state m_pvtTriggerNormalEach = false; m_pvtTriggerNormalGroup = false; m_pvtTriggerTdiKineticsEach = false; m_pvtTriggerTdiKineticsGroup = false; m_pvtFastSequence = false; // Default value for test LED is 0% m_pvtTestLedBrightness = 0.0; // Default values for I/O Port - the CLEAR op doesn't clear these values // This will also init our private vars to 0x0 write_IoPortAssignment( 0x0 ); write_IoPortDirection( 0x0 ); // Set the default TDI variables. These also will automatically initialize // the "virtual" kinetics mode variables. write_TDIRate( m_PlatformTdiRateDefault ); write_TDIRows( 1 ); write_TDIBinningV( 1 ); // Set the shutter strobe values to their defaults write_ShutterStrobePeriod( m_PlatformStrobePeriodDefault ); write_ShutterStrobePosition( m_PlatformStrobePositionDefault ); // Set default averaging state if ( m_ApnSensorInfo->m_DefaultDataReduction ) { Read( FPGA_REG_OP_B, RegVal ); RegVal |= FPGA_BIT_AD_AVERAGING; Write( FPGA_REG_OP_B, RegVal ); } // Program our initial cooler values. The only cooler value that we reset // at init time is the backoff point. Everything else is left untouched, and // state information is determined from the camera controller. m_pvtCoolerBackoffPoint = m_ApnSensorInfo->m_TempBackoffPoint; write_CoolerBackoffPoint( m_pvtCoolerBackoffPoint ); Write( FPGA_REG_TEMP_RAMP_DOWN_A, m_ApnSensorInfo->m_TempRampRateOne ); Write( FPGA_REG_TEMP_RAMP_DOWN_B, m_ApnSensorInfo->m_TempRampRateTwo ); // the cooler code not only determines the m_pvtCoolerEnable state, but // also implicitly calls UpdateGeneralStatus() as part of read_CoolerStatus() if ( read_CoolerStatus() == Apn_CoolerStatus_Off ) m_pvtCoolerEnable = false; else m_pvtCoolerEnable = true; // Perform any platform-specific initialization if ( m_pvtPlatformType == Apn_Platform_Alta ) { } else if ( m_pvtPlatformType == Apn_Platform_Ascent ) { write_DataAveraging( false ); write_DualReadout( false ); write_GuideRAPlusDuration( 0.005 ); write_GuideRAMinusDuration( 0.005 ); write_GuideDecPlusDuration( 0.005 ); write_GuideDecMinusDuration( 0.005 ); } m_pvtImageInProgress = false; m_pvtImageReady = false; m_pvtMostRecentFrame = 0; m_pvtReadyFrame = 0; m_pvtCurrentFrame = 0; m_pvtBayerShift = Apn_BayerShift_Automatic; m_pvtFilterWheelType = Apn_Filter_Unknown; m_pvtFilterMaxPositions = APN_FILTER_UNKNOWN_MAX_POSITIONS; return 0; } long CApnCamera::InitTwelveBitAD() { // Write( FPGA_REG_AD_CONFIG_DATA, 0x0028 ); Write( FPGA_REG_AD_CONFIG_DATA, 0x0008 ); Write( FPGA_REG_COMMAND_B, FPGA_BIT_CMD_AD_CONFIG ); return 0; } long CApnCamera::InitAscentSixteenBitAD() { Write( FPGA_REG_AD_CONFIG_DATA, 0x0058 ); Write( FPGA_REG_COMMAND_B, FPGA_BIT_CMD_AD_CONFIG ); Write( FPGA_REG_AD_CONFIG_DATA, 0x10C0 ); Write( FPGA_REG_COMMAND_B, FPGA_BIT_CMD_AD_CONFIG ); return 0; } void CApnCamera::UpdateGeneralStatus() { unsigned short StatusReg; unsigned short HeatsinkTempReg; unsigned short CcdTempReg; unsigned short CoolerDriveReg; unsigned short VoltageReg; unsigned short TdiCounterReg; unsigned short SequenceCounterReg; unsigned short MostRecentFrame; unsigned short ReadyFrame; unsigned short CurrentFrame; char szOutputText[256]; // AltaDebugOutputString( "APOGEE.DLL - CApnCamera::UpdateGeneralStatus()" ); // Read the general status register of the device m_pvtQueryStatusRetVal = QueryStatusRegs( StatusReg, HeatsinkTempReg, CcdTempReg, CoolerDriveReg, VoltageReg, TdiCounterReg, SequenceCounterReg, MostRecentFrame, ReadyFrame, CurrentFrame ); /* AltaDebugPrint( szOutputText, "APOGEE.DLL - CApnCamera::UpdateGeneralStatus() -> StatusReg = 0x%04X", StatusReg ); AltaDebugOutputString( szOutputText ); AltaDebugPrint( szOutputText, "APOGEE.DLL - CApnCamera::UpdateGeneralStatus() -> HeatsinkTempReg = 0x%04X", HeatsinkTempReg ); AltaDebugOutputString( szOutputText ); AltaDebugPrint( szOutputText, "APOGEE.DLL - CApnCamera::UpdateGeneralStatus() -> CcdTempReg = 0x%04X", CcdTempReg ); AltaDebugOutputString( szOutputText ); AltaDebugPrint( szOutputText, "APOGEE.DLL - CApnCamera::UpdateGeneralStatus() -> CoolerDriveReg = 0x%04X", CoolerDriveReg ); AltaDebugOutputString( szOutputText ); AltaDebugPrint( szOutputText, "APOGEE.DLL - CApnCamera::UpdateGeneralStatus() -> VoltageReg = 0x%04X", VoltageReg ); AltaDebugOutputString( szOutputText ); AltaDebugPrint( szOutputText, "APOGEE.DLL - CApnCamera::UpdateGeneralStatus() -> TdiCounterReg = 0x%04X", TdiCounterReg ); AltaDebugOutputString( szOutputText ); AltaDebugPrint( szOutputText, "APOGEE.DLL - CApnCamera::UpdateGeneralStatus() -> SequenceCounterReg = 0x%04X", SequenceCounterReg ); AltaDebugOutputString( szOutputText ); AltaDebugPrint( szOutputText, "APOGEE.DLL - CApnCamera::UpdateGeneralStatus() -> MostRecentFrame = %d", MostRecentFrame ); AltaDebugOutputString( szOutputText ); AltaDebugPrint( szOutputText, "APOGEE.DLL - CApnCamera::UpdateGeneralStatus() -> ReadyFrame = %d", ReadyFrame ); AltaDebugOutputString( szOutputText ); AltaDebugPrint( szOutputText, "APOGEE.DLL - CApnCamera::UpdateGeneralStatus() -> CurrentFrame = %d", CurrentFrame ); AltaDebugOutputString( szOutputText ); */ m_pvtStatusReg = StatusReg; HeatsinkTempReg &= FPGA_MASK_TEMP_PARAMS; CcdTempReg &= FPGA_MASK_TEMP_PARAMS; VoltageReg &= FPGA_MASK_INPUT_VOLTAGE; if ( m_pvtPlatformType == Apn_Platform_Alta ) { CoolerDriveReg &= FPGA_MASK_TEMP_PARAMS; if ( CoolerDriveReg > 3200 ) m_pvtCoolerDrive = 100.0; else m_pvtCoolerDrive = ( (double)(CoolerDriveReg - 600) / 2600.0 ) * 100.0; } else if ( m_pvtPlatformType == Apn_Platform_Ascent ) { if ( CoolerDriveReg > 60000 ) m_pvtCoolerDrive = 100.0; else m_pvtCoolerDrive = ( (double)(CoolerDriveReg - 15000) / 45000.0 ) * 100.0; } // Don't return a negative value if ( m_pvtCoolerDrive < 0.0 ) m_pvtCoolerDrive = 0.0; m_pvtCurrentCcdTemp = ( (CcdTempReg - m_PlatformTempSetpointZeroPoint) * m_PlatformTempDegreesPerBit ); m_pvtCurrentHeatsinkTemp = ( (HeatsinkTempReg - m_PlatformTempHeatsinkZeroPoint) * m_PlatformTempDegreesPerBit ); m_pvtInputVoltage = VoltageReg * m_PlatformVoltageResolution; // Update ShutterState m_pvtShutterState = ( (m_pvtStatusReg & FPGA_BIT_STATUS_SHUTTER_OPEN) != 0 ); // Update counters m_pvtSequenceCounter = SequenceCounterReg; m_pvtTDICounter = TdiCounterReg; // Update USB frame info (for images in a sequence) // Network systems will just set these vars to zero (they are not used) m_pvtMostRecentFrame = MostRecentFrame; m_pvtReadyFrame = ReadyFrame; m_pvtCurrentFrame = CurrentFrame; } bool CApnCamera::ImageReady() { return m_pvtImageReady; } bool CApnCamera::ImageInProgress() { return m_pvtImageInProgress; } void CApnCamera::SignalImagingDone() { m_pvtImageInProgress = false; } void CApnCamera::SetPlatformConstants() { if ( read_PlatformType() == Apn_Platform_Alta ) { m_PlatformHBinningMax = APN_HBINNING_MAX_ALTA; m_PlatformVBinningMax = APN_HBINNING_MAX_ALTA; m_PlatformTimerResolution = APN_TIMER_RESOLUTION_ALTA; m_PlatformPeriodTimerResolution = APN_PERIOD_TIMER_RESOLUTION_ALTA; m_PlatformTimerOffsetCount = APN_TIMER_OFFSET_COUNT_ALTA; m_PlatformSequenceDelayResolution = APN_SEQUENCE_DELAY_RESOLUTION_ALTA; m_PlatformSequenceDelayMaximum = APN_SEQUENCE_DELAY_MAXIMUM_ALTA; m_PlatformSequenceDelayMinimum = APN_SEQUENCE_DELAY_MINIMUM_ALTA; m_PlatformExposureTimeMin = APN_EXPOSURE_TIME_MIN_ALTA; m_PlatformExposureTimeMax = APN_EXPOSURE_TIME_MAX_ALTA; m_PlatformTdiRateResolution = APN_TDI_RATE_RESOLUTION_ALTA; m_PlatformTdiRateMin = APN_TDI_RATE_MIN_ALTA; m_PlatformTdiRateMax = APN_TDI_RATE_MAX_ALTA; m_PlatformTdiRateDefault = APN_TDI_RATE_DEFAULT_ALTA; m_PlatformVoltageResolution = APN_VOLTAGE_RESOLUTION_ALTA; m_PlatformShutterCloseDiff = APN_SHUTTER_CLOSE_DIFF_ALTA; m_PlatformStrobePositionMin = APN_STROBE_POSITION_MIN_ALTA; m_PlatformStrobePositionMax = APN_STROBE_POSITION_MAX_ALTA; m_PlatformStrobePositionDefault = APN_STROBE_POSITION_DEFAULT_ALTA; m_PlatformStrobePeriodMin = APN_STROBE_PERIOD_MIN_ALTA; m_PlatformStrobePeriodMax = APN_STROBE_PERIOD_MAX_ALTA; m_PlatformStrobePeriodDefault = APN_STROBE_PERIOD_DEFAULT_ALTA; m_PlatformTempCounts = APN_TEMP_COUNTS_ALTA; m_PlatformTempKelvinScaleOffset = APN_TEMP_KELVIN_SCALE_OFFSET_ALTA; m_PlatformTempSetpointMin = APN_TEMP_SETPOINT_MIN_ALTA; m_PlatformTempSetpointMax = APN_TEMP_SETPOINT_MAX_ALTA; m_PlatformTempHeatsinkMin = APN_TEMP_HEATSINK_MIN_ALTA; m_PlatformTempHeatsinkMax = APN_TEMP_HEATSINK_MAX_ALTA; m_PlatformTempSetpointZeroPoint = APN_TEMP_SETPOINT_ZERO_POINT_ALTA; m_PlatformTempHeatsinkZeroPoint = APN_TEMP_HEATSINK_ZERO_POINT_ALTA; m_PlatformTempDegreesPerBit = APN_TEMP_DEGREES_PER_BIT_ALTA; m_PlatformFanSpeedOff = APN_FAN_SPEED_OFF_ALTA; m_PlatformFanSpeedLow = APN_FAN_SPEED_LOW_ALTA; m_PlatformFanSpeedMedium = APN_FAN_SPEED_MEDIUM_ALTA; m_PlatformFanSpeedHigh = APN_FAN_SPEED_HIGH_ALTA; m_PlatformGuiderRelayResolution = APN_GUIDER_RELAY_RESOLUTION_ALTA; m_PlatformGuiderRelayMin = APN_GUIDER_RELAY_MIN_ALTA; m_PlatformGuiderRelayMax = APN_GUIDER_RELAY_MAX_ALTA; m_PlatformGuiderRelayOpenTime = APN_GUIDER_RELAY_OPEN_TIME_ALTA; m_PlatformGuiderRelayCloseTime = APN_GUIDER_RELAY_CLOSE_TIME_ALTA; } else if ( read_PlatformType() == Apn_Platform_Ascent ) { m_PlatformHBinningMax = APN_HBINNING_MAX_ASCENT; m_PlatformVBinningMax = APN_HBINNING_MAX_ASCENT; m_PlatformTimerResolution = APN_TIMER_RESOLUTION_ASCENT; m_PlatformPeriodTimerResolution = APN_PERIOD_TIMER_RESOLUTION_ASCENT; m_PlatformTimerOffsetCount = APN_TIMER_OFFSET_COUNT_ASCENT; m_PlatformSequenceDelayResolution = APN_SEQUENCE_DELAY_RESOLUTION_ASCENT; m_PlatformSequenceDelayMaximum = APN_SEQUENCE_DELAY_MAXIMUM_ASCENT; m_PlatformSequenceDelayMinimum = APN_SEQUENCE_DELAY_MINIMUM_ASCENT; m_PlatformExposureTimeMin = APN_EXPOSURE_TIME_MIN_ASCENT; m_PlatformExposureTimeMax = APN_EXPOSURE_TIME_MAX_ASCENT; m_PlatformTdiRateResolution = APN_TDI_RATE_RESOLUTION_ASCENT; m_PlatformTdiRateMin = APN_TDI_RATE_MIN_ASCENT; m_PlatformTdiRateMax = APN_TDI_RATE_MAX_ASCENT; m_PlatformTdiRateDefault = APN_TDI_RATE_DEFAULT_ASCENT; m_PlatformVoltageResolution = APN_VOLTAGE_RESOLUTION_ASCENT; m_PlatformShutterCloseDiff = APN_SHUTTER_CLOSE_DIFF_ASCENT; m_PlatformStrobePositionMin = APN_STROBE_POSITION_MIN_ASCENT; m_PlatformStrobePositionMax = APN_STROBE_POSITION_MAX_ASCENT; m_PlatformStrobePositionDefault = APN_STROBE_POSITION_DEFAULT_ASCENT; m_PlatformStrobePeriodMin = APN_STROBE_PERIOD_MIN_ASCENT; m_PlatformStrobePeriodMax = APN_STROBE_PERIOD_MAX_ASCENT; m_PlatformStrobePeriodDefault = APN_STROBE_PERIOD_DEFAULT_ASCENT; m_PlatformTempCounts = APN_TEMP_COUNTS_ASCENT; m_PlatformTempKelvinScaleOffset = APN_TEMP_KELVIN_SCALE_OFFSET_ASCENT; m_PlatformTempSetpointMin = APN_TEMP_SETPOINT_MIN_ASCENT; m_PlatformTempSetpointMax = APN_TEMP_SETPOINT_MAX_ASCENT; m_PlatformTempHeatsinkMin = APN_TEMP_HEATSINK_MIN_ASCENT; m_PlatformTempHeatsinkMax = APN_TEMP_HEATSINK_MAX_ASCENT; m_PlatformTempSetpointZeroPoint = APN_TEMP_SETPOINT_ZERO_POINT_ASCENT; m_PlatformTempHeatsinkZeroPoint = APN_TEMP_HEATSINK_ZERO_POINT_ASCENT; m_PlatformTempDegreesPerBit = APN_TEMP_DEGREES_PER_BIT_ASCENT; m_PlatformFanSpeedOff = APN_FAN_SPEED_OFF_ASCENT; m_PlatformFanSpeedLow = APN_FAN_SPEED_LOW_ASCENT; m_PlatformFanSpeedMedium = APN_FAN_SPEED_MEDIUM_ASCENT; m_PlatformFanSpeedHigh = APN_FAN_SPEED_HIGH_ASCENT; m_PlatformGuiderRelayResolution = APN_GUIDER_RELAY_RESOLUTION_ASCENT; m_PlatformGuiderRelayMin = APN_GUIDER_RELAY_MIN_ASCENT; m_PlatformGuiderRelayMax = APN_GUIDER_RELAY_MAX_ASCENT; m_PlatformGuiderRelayOpenTime = APN_GUIDER_RELAY_OPEN_TIME_ASCENT; m_PlatformGuiderRelayCloseTime = APN_GUIDER_RELAY_CLOSE_TIME_ASCENT; } } libapogee2-2.2/ApnCamData_KAI2020CLB.cpp0000644000175000017500000005456111110507150015146 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_KAI2020CLB.cpp: Implementation file for the CApnCamData_KAI2020CLB class. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #include "ApnCamData_KAI2020CLB.h" #include #include #include ///////////////////////////////////////////////////////////// // Construction/Destruction ///////////////////////////////////////////////////////////// CApnCamData_KAI2020CLB::CApnCamData_KAI2020CLB() { } CApnCamData_KAI2020CLB::~CApnCamData_KAI2020CLB() { } void CApnCamData_KAI2020CLB::Initialize() { strcpy( m_Sensor, "KAI2020CLB" ); strcpy( m_CameraModel, "2020cl" ); m_CameraId = 74; m_InterlineCCD = true; m_SupportsSerialA = true; m_SupportsSerialB = true; m_SensorTypeCCD = true; m_TotalColumns = 1648; m_ImagingColumns = 1600; m_ClampColumns = 24; m_PreRoiSkipColumns = 0; m_PostRoiSkipColumns = 0; m_OverscanColumns = 24; m_TotalRows = 1214; m_ImagingRows = 1200; m_UnderscanRows = 6; m_OverscanRows = 8; m_VFlushBinning = 1; m_EnableSingleRowOffset = false; m_RowOffsetBinning = 1; m_HFlushDisable = false; m_ShutterCloseDelay = 0; m_PixelSizeX = 7.4; m_PixelSizeY = 7.4; m_Color = true; m_ReportedGainSixteenBit = 1; m_MinSuggestedExpTime = 0.05; m_CoolingSupported = true; m_RegulatedCoolingSupported = true; m_TempSetPoint = -20.0; m_TempRampRateOne = 700; m_TempRampRateTwo = 4000; m_TempBackoffPoint = 2.0; m_PrimaryADType = ApnAdType_Alta_Sixteen; m_AlternativeADType = ApnAdType_Alta_Twelve; m_DefaultGainLeft = 0; m_DefaultOffsetLeft = 100; m_DefaultGainRight = -1; m_DefaultOffsetRight = -1; m_DefaultRVoltage = 1000; m_DefaultSpeed = 0xffff; m_DefaultDataReduction = false; set_vpattern(); set_hpattern_clamp_sixteen(); set_hpattern_skip_sixteen(); set_hpattern_roi_sixteen(); set_hpattern_clamp_twelve(); set_hpattern_skip_twelve(); set_hpattern_roi_twelve(); } void CApnCamData_KAI2020CLB::set_vpattern() { const unsigned short Mask = 0x16; const unsigned short NumElements = 38; unsigned short Pattern[NumElements] = { 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0302, 0x0302, 0x0302, 0x0302, 0x0302, 0x0302, 0x0302, 0x0302, 0x0302, 0x0302, 0x0002, 0x0002, 0x0002, 0x0003, 0x0002 }; m_VerticalPattern.Mask = Mask; m_VerticalPattern.NumElements = NumElements; m_VerticalPattern.PatternData = (unsigned short *)malloc(NumElements * sizeof(unsigned short)); for ( int i=0; iMask = Mask; Pattern->BinningLimit = BinningLimit; Pattern->RefNumElements = RefNumElements; Pattern->SigNumElements = SigNumElements; if ( RefNumElements > 0 ) { Pattern->RefPatternData = (unsigned short *)malloc(RefNumElements * sizeof(unsigned short)); for ( i=0; iRefPatternData[i] = RefPatternData[i]; } } if ( SigNumElements > 0 ) { Pattern->SigPatternData = (unsigned short *)malloc(SigNumElements * sizeof(unsigned short)); for ( i=0; iSigPatternData[i] = SigPatternData[i]; } } if ( BinningLimit > 0 ) { for ( i=0; iBinNumElements[i] = BinNumElements[i]; Pattern->BinPatternData[i] = (unsigned short *)malloc(BinNumElements[i] * sizeof(unsigned short)); for ( j=0; jBinPatternData[i][j] = BinPatternData[i][j]; } } } } libapogee2-2.2/AUTHORS0000644000175000017500000000015611110507150012237 0ustar jrjrDave Mills The Random Factory P.O. Box 44070 Tucson AZ 85733-4070 rfactory@theriver.com www.randomfactory.com libapogee2-2.2/apogee-test.h0000644000175000017500000000012611110507150013552 0ustar jrjr#include "ApnCamera_USB.h" int main (int argc, char **argv); CApnCamera *alta; libapogee2-2.2/ApnCamData_CCD7700B.cpp0000644000175000017500000004321511110507150014720 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_CCD7700B.cpp: Implementation file for the CApnCamData_CCD7700B class. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #include "ApnCamData_CCD7700B.h" #include #include #include ///////////////////////////////////////////////////////////// // Construction/Destruction ///////////////////////////////////////////////////////////// CApnCamData_CCD7700B::CApnCamData_CCD7700B() { } CApnCamData_CCD7700B::~CApnCamData_CCD7700B() { } void CApnCamData_CCD7700B::Initialize() { strcpy( m_Sensor, "CCD7700B" ); strcpy( m_CameraModel, "77" ); m_CameraId = 23; m_InterlineCCD = false; m_SupportsSerialA = true; m_SupportsSerialB = true; m_SensorTypeCCD = true; m_TotalColumns = 527; m_ImagingColumns = 512; m_ClampColumns = 15; m_PreRoiSkipColumns = 0; m_PostRoiSkipColumns = 0; m_OverscanColumns = 0; m_TotalRows = 512; m_ImagingRows = 512; m_UnderscanRows = 0; m_OverscanRows = 0; m_VFlushBinning = 1; m_EnableSingleRowOffset = false; m_RowOffsetBinning = 1; m_HFlushDisable = false; m_ShutterCloseDelay = 300; m_PixelSizeX = 24; m_PixelSizeY = 24; m_Color = false; m_ReportedGainSixteenBit = 2; m_MinSuggestedExpTime = 20.0; m_CoolingSupported = true; m_RegulatedCoolingSupported = true; m_TempSetPoint = -20.0; m_TempRampRateOne = 700; m_TempRampRateTwo = 4000; m_TempBackoffPoint = 2.0; m_PrimaryADType = ApnAdType_Alta_Sixteen; m_AlternativeADType = ApnAdType_Alta_Twelve; m_DefaultGainLeft = 400; m_DefaultOffsetLeft = 200; m_DefaultGainRight = -1; m_DefaultOffsetRight = -1; m_DefaultRVoltage = 1000; m_DefaultSpeed = 0xffff; m_DefaultDataReduction = false; set_vpattern(); set_hpattern_clamp_sixteen(); set_hpattern_skip_sixteen(); set_hpattern_roi_sixteen(); set_hpattern_clamp_twelve(); set_hpattern_skip_twelve(); set_hpattern_roi_twelve(); } void CApnCamData_CCD7700B::set_vpattern() { const unsigned short Mask = 0xE; const unsigned short NumElements = 180; unsigned short Pattern[NumElements] = { 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0001, 0x0000, }; m_VerticalPattern.Mask = Mask; m_VerticalPattern.NumElements = NumElements; m_VerticalPattern.PatternData = (unsigned short *)malloc(NumElements * sizeof(unsigned short)); for ( int i=0; iMask = Mask; Pattern->BinningLimit = BinningLimit; Pattern->RefNumElements = RefNumElements; Pattern->SigNumElements = SigNumElements; if ( RefNumElements > 0 ) { Pattern->RefPatternData = (unsigned short *)malloc(RefNumElements * sizeof(unsigned short)); for ( i=0; iRefPatternData[i] = RefPatternData[i]; } } if ( SigNumElements > 0 ) { Pattern->SigPatternData = (unsigned short *)malloc(SigNumElements * sizeof(unsigned short)); for ( i=0; iSigPatternData[i] = SigPatternData[i]; } } if ( BinningLimit > 0 ) { for ( i=0; iBinNumElements[i] = BinNumElements[i]; Pattern->BinPatternData[i] = (unsigned short *)malloc(BinNumElements[i] * sizeof(unsigned short)); for ( j=0; jBinPatternData[i][j] = BinPatternData[i][j]; } } } } libapogee2-2.2/.project0000644000175000017500000000460711110507150012643 0ustar jrjr libapogee org.eclipse.cdt.managedbuilder.core.genmakebuilder clean,full,incremental, org.eclipse.cdt.make.core.cleanBuildTarget clean org.eclipse.cdt.make.core.enableCleanBuild true ?name? org.eclipse.cdt.make.core.append_environment true org.eclipse.cdt.make.core.stopOnError true org.eclipse.cdt.make.core.buildCommand make org.eclipse.cdt.make.core.contents org.eclipse.cdt.make.core.activeConfigSettings org.eclipse.cdt.make.core.buildLocation ${workspace_loc:/libapogee/Debug} org.eclipse.cdt.make.core.useDefaultBuildCmd true org.eclipse.cdt.make.core.enableAutoBuild false org.eclipse.cdt.make.core.enableFullBuild true org.eclipse.cdt.make.core.buildArguments org.eclipse.cdt.make.core.fullBuildTarget all org.eclipse.cdt.make.core.autoBuildTarget all org.eclipse.cdt.managedbuilder.core.ScannerConfigBuilder org.eclipse.cdt.core.ccnature org.eclipse.cdt.managedbuilder.core.ScannerConfigNature org.eclipse.cdt.managedbuilder.core.managedBuildNature org.eclipse.cdt.core.cnature libapogee2-2.2/ApnCamData_KAI2020CL.h0000644000175000017500000000220611110507150014476 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_KAI2020CL.h: Interface file for the CApnCamData_KAI2020CL class. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #if _MSC_VER > 1000 #pragma once #endif // _MSC_VER> 1000 #include "ApnCamData.h" class CApnCamData_KAI2020CL : public CApnCamData { public: CApnCamData_KAI2020CL(); virtual ~CApnCamData_KAI2020CL(); void Initialize(); private: void set_vpattern(); void set_hpattern_clamp_sixteen(); void set_hpattern_skip_sixteen(); void set_hpattern_roi_sixteen(); void set_hpattern_clamp_twelve(); void set_hpattern_skip_twelve(); void set_hpattern_roi_twelve(); void set_hpattern( APN_HPATTERN_FILE *Pattern, unsigned short Mask, unsigned short BinningLimit, unsigned short RefNumElements, unsigned short SigNumElements, unsigned short BinNumElements[], unsigned short RefPatternData[], unsigned short SigPatternData[], unsigned short BinPatternData[][APN_MAX_PATTERN_ENTRIES] ); }; libapogee2-2.2/ApnCamData_KAI2001CL.h0000644000175000017500000000220611110507150014475 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_KAI2001CL.h: Interface file for the CApnCamData_KAI2001CL class. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #if _MSC_VER > 1000 #pragma once #endif // _MSC_VER> 1000 #include "ApnCamData.h" class CApnCamData_KAI2001CL : public CApnCamData { public: CApnCamData_KAI2001CL(); virtual ~CApnCamData_KAI2001CL(); void Initialize(); private: void set_vpattern(); void set_hpattern_clamp_sixteen(); void set_hpattern_skip_sixteen(); void set_hpattern_roi_sixteen(); void set_hpattern_clamp_twelve(); void set_hpattern_skip_twelve(); void set_hpattern_roi_twelve(); void set_hpattern( APN_HPATTERN_FILE *Pattern, unsigned short Mask, unsigned short BinningLimit, unsigned short RefNumElements, unsigned short SigNumElements, unsigned short BinNumElements[], unsigned short RefPatternData[], unsigned short SigPatternData[], unsigned short BinPatternData[][APN_MAX_PATTERN_ENTRIES] ); }; libapogee2-2.2/ApnCamData_KAF1602E.h0000644000175000017500000000220111110507150014361 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_KAF1602E.h: Interface file for the CApnCamData_KAF1602E class. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #if _MSC_VER > 1000 #pragma once #endif // _MSC_VER> 1000 #include "ApnCamData.h" class CApnCamData_KAF1602E : public CApnCamData { public: CApnCamData_KAF1602E(); virtual ~CApnCamData_KAF1602E(); void Initialize(); private: void set_vpattern(); void set_hpattern_clamp_sixteen(); void set_hpattern_skip_sixteen(); void set_hpattern_roi_sixteen(); void set_hpattern_clamp_twelve(); void set_hpattern_skip_twelve(); void set_hpattern_roi_twelve(); void set_hpattern( APN_HPATTERN_FILE *Pattern, unsigned short Mask, unsigned short BinningLimit, unsigned short RefNumElements, unsigned short SigNumElements, unsigned short BinNumElements[], unsigned short RefPatternData[], unsigned short SigPatternData[], unsigned short BinPatternData[][APN_MAX_PATTERN_ENTRIES] ); }; libapogee2-2.2/ApnCamData_KAF0401EB.h0000644000175000017500000000220611110507150014464 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_KAF0401EB.h: Interface file for the CApnCamData_KAF0401EB class. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #if _MSC_VER > 1000 #pragma once #endif // _MSC_VER> 1000 #include "ApnCamData.h" class CApnCamData_KAF0401EB : public CApnCamData { public: CApnCamData_KAF0401EB(); virtual ~CApnCamData_KAF0401EB(); void Initialize(); private: void set_vpattern(); void set_hpattern_clamp_sixteen(); void set_hpattern_skip_sixteen(); void set_hpattern_roi_sixteen(); void set_hpattern_clamp_twelve(); void set_hpattern_skip_twelve(); void set_hpattern_roi_twelve(); void set_hpattern( APN_HPATTERN_FILE *Pattern, unsigned short Mask, unsigned short BinningLimit, unsigned short RefNumElements, unsigned short SigNumElements, unsigned short BinNumElements[], unsigned short RefPatternData[], unsigned short SigPatternData[], unsigned short BinPatternData[][APN_MAX_PATTERN_ENTRIES] ); }; libapogee2-2.2/ApnCamData_KAF09000.h0000644000175000017500000000220111110507150014334 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_KAF09000.h: Interface file for the CApnCamData_KAF09000 class. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #if _MSC_VER > 1000 #pragma once #endif // _MSC_VER> 1000 #include "ApnCamData.h" class CApnCamData_KAF09000 : public CApnCamData { public: CApnCamData_KAF09000(); virtual ~CApnCamData_KAF09000(); void Initialize(); private: void set_vpattern(); void set_hpattern_clamp_sixteen(); void set_hpattern_skip_sixteen(); void set_hpattern_roi_sixteen(); void set_hpattern_clamp_twelve(); void set_hpattern_skip_twelve(); void set_hpattern_roi_twelve(); void set_hpattern( APN_HPATTERN_FILE *Pattern, unsigned short Mask, unsigned short BinningLimit, unsigned short RefNumElements, unsigned short SigNumElements, unsigned short BinNumElements[], unsigned short RefPatternData[], unsigned short SigPatternData[], unsigned short BinPatternData[][APN_MAX_PATTERN_ENTRIES] ); }; libapogee2-2.2/ApnCamData_KAI4020CLB.h0000644000175000017500000000221311110507150014600 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_KAI4020CLB.h: Interface file for the CApnCamData_KAI4020CLB class. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #if _MSC_VER > 1000 #pragma once #endif // _MSC_VER> 1000 #include "ApnCamData.h" class CApnCamData_KAI4020CLB : public CApnCamData { public: CApnCamData_KAI4020CLB(); virtual ~CApnCamData_KAI4020CLB(); void Initialize(); private: void set_vpattern(); void set_hpattern_clamp_sixteen(); void set_hpattern_skip_sixteen(); void set_hpattern_roi_sixteen(); void set_hpattern_clamp_twelve(); void set_hpattern_skip_twelve(); void set_hpattern_roi_twelve(); void set_hpattern( APN_HPATTERN_FILE *Pattern, unsigned short Mask, unsigned short BinningLimit, unsigned short RefNumElements, unsigned short SigNumElements, unsigned short BinNumElements[], unsigned short RefPatternData[], unsigned short SigPatternData[], unsigned short BinPatternData[][APN_MAX_PATTERN_ENTRIES] ); }; libapogee2-2.2/ApnCamData_CCD4240.h0000644000175000017500000000217411110507150014256 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_CCD4240.h: Interface file for the CApnCamData_CCD4240 class. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #if _MSC_VER > 1000 #pragma once #endif // _MSC_VER> 1000 #include "ApnCamData.h" class CApnCamData_CCD4240 : public CApnCamData { public: CApnCamData_CCD4240(); virtual ~CApnCamData_CCD4240(); void Initialize(); private: void set_vpattern(); void set_hpattern_clamp_sixteen(); void set_hpattern_skip_sixteen(); void set_hpattern_roi_sixteen(); void set_hpattern_clamp_twelve(); void set_hpattern_skip_twelve(); void set_hpattern_roi_twelve(); void set_hpattern( APN_HPATTERN_FILE *Pattern, unsigned short Mask, unsigned short BinningLimit, unsigned short RefNumElements, unsigned short SigNumElements, unsigned short BinNumElements[], unsigned short RefPatternData[], unsigned short SigPatternData[], unsigned short BinPatternData[][APN_MAX_PATTERN_ENTRIES] ); }; libapogee2-2.2/ApnCamData_CCD5710B.h0000644000175000017500000000220111110507150014352 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_CCD5710B.h: Interface file for the CApnCamData_CCD5710B class. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #if _MSC_VER > 1000 #pragma once #endif // _MSC_VER> 1000 #include "ApnCamData.h" class CApnCamData_CCD5710B : public CApnCamData { public: CApnCamData_CCD5710B(); virtual ~CApnCamData_CCD5710B(); void Initialize(); private: void set_vpattern(); void set_hpattern_clamp_sixteen(); void set_hpattern_skip_sixteen(); void set_hpattern_roi_sixteen(); void set_hpattern_clamp_twelve(); void set_hpattern_skip_twelve(); void set_hpattern_roi_twelve(); void set_hpattern( APN_HPATTERN_FILE *Pattern, unsigned short Mask, unsigned short BinningLimit, unsigned short RefNumElements, unsigned short SigNumElements, unsigned short BinNumElements[], unsigned short RefPatternData[], unsigned short SigPatternData[], unsigned short BinPatternData[][APN_MAX_PATTERN_ENTRIES] ); }; libapogee2-2.2/Apn.h0000644000175000017500000001540111110507150012055 0ustar jrjr///////////////////////////////////////////////////////////// // // Apn.h: Common constants for the Alta (and derivative) camera systems // // Copyright (c) 2003-2006 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #define APOGEE_DLL_OUTPUT 1 #ifdef APOGEE_DLL_OUTPUT #ifdef LINUX #define AltaDebugOutputString(__X__) fprintf(stderr,__X__) #else #define AltaDebugString(__X__) OutputDebugString(__X__) #endif #define AltaDebugPrint( __A__, __B__, __C__ ) sprintf( __A__, __B__, __C__ ) #else #define AltaDebugString(__X__) #define AltaDebugPrint( __A__, __B__, __C__ ) #endif #define APN_DRIVER_VERSION "3.1.8" /////////////////////////////////// // Alta Plaform Constants /////////////////////////////////// #define APN_HBINNING_MAX_ALTA 10 #define APN_VBINNING_MAX_ALTA 2048 #define APN_TIMER_RESOLUTION_ALTA 0.00000256 #define APN_PERIOD_TIMER_RESOLUTION_ALTA 0.000000040 #define APN_TIMER_OFFSET_COUNT_ALTA 3 #define APN_SEQUENCE_DELAY_RESOLUTION_ALTA 0.000327 #define APN_SEQUENCE_DELAY_MAXIMUM_ALTA 21.429945 #define APN_SEQUENCE_DELAY_MINIMUM_ALTA 0.000327 #define APN_EXPOSURE_TIME_MIN_ALTA 0.00001 // 10us is the defined min. #define APN_EXPOSURE_TIME_MAX_ALTA 10990.0 // seconds #define APN_TDI_RATE_RESOLUTION_ALTA 0.00000512 #define APN_TDI_RATE_MIN_ALTA 0.00000512 #define APN_TDI_RATE_MAX_ALTA 0.336 #define APN_TDI_RATE_DEFAULT_ALTA 0.100 #define APN_VOLTAGE_RESOLUTION_ALTA 0.00439453 #define APN_SHUTTER_CLOSE_DIFF_ALTA 0.00001024 #define APN_STROBE_POSITION_MIN_ALTA 0.00000331 #define APN_STROBE_POSITION_MAX_ALTA 0.1677 #define APN_STROBE_POSITION_DEFAULT_ALTA 0.001 #define APN_STROBE_PERIOD_MIN_ALTA 0.000000045 #define APN_STROBE_PERIOD_MAX_ALTA 0.0026 #define APN_STROBE_PERIOD_DEFAULT_ALTA 0.001 #define APN_TEMP_COUNTS_ALTA 4096 #define APN_TEMP_KELVIN_SCALE_OFFSET_ALTA 273.16 #define APN_TEMP_SETPOINT_MIN_ALTA 213 #define APN_TEMP_SETPOINT_MAX_ALTA 313 #define APN_TEMP_HEATSINK_MIN_ALTA 240 #define APN_TEMP_HEATSINK_MAX_ALTA 340 #define APN_TEMP_SETPOINT_ZERO_POINT_ALTA 2458 #define APN_TEMP_HEATSINK_ZERO_POINT_ALTA 1351 #define APN_TEMP_DEGREES_PER_BIT_ALTA 0.024414 #define APN_FAN_SPEED_OFF_ALTA 0 #define APN_FAN_SPEED_LOW_ALTA 3100 #define APN_FAN_SPEED_MEDIUM_ALTA 3660 #define APN_FAN_SPEED_HIGH_ALTA 4095 #define APN_GUIDER_RELAY_RESOLUTION_ALTA 0.0007509 #define APN_GUIDER_RELAY_MIN_ALTA 0.005 #define APN_GUIDER_RELAY_MAX_ALTA 40.0 #define APN_GUIDER_RELAY_OPEN_TIME_ALTA 0.0004 #define APN_GUIDER_RELAY_CLOSE_TIME_ALTA 0.0011 /////////////////////////////////// // Ascent Platform Constants /////////////////////////////////// #define APN_HBINNING_MAX_ASCENT 8 #define APN_VBINNING_MAX_ASCENT 4095 #define APN_TIMER_RESOLUTION_ASCENT 0.00000133 #define APN_PERIOD_TIMER_RESOLUTION_ASCENT 0.00000002078 #define APN_TIMER_OFFSET_COUNT_ASCENT 3 #define APN_SEQUENCE_DELAY_RESOLUTION_ASCENT 0.00037547 #define APN_SEQUENCE_DELAY_MAXIMUM_ASCENT 24.606426 #define APN_SEQUENCE_DELAY_MINIMUM_ASCENT 0.00037547 #define APN_EXPOSURE_TIME_MIN_ASCENT 0.00001 #define APN_EXPOSURE_TIME_MAX_ASCENT 5712.3 #define APN_TDI_RATE_RESOLUTION_ASCENT 0.00000533 #define APN_TDI_RATE_MIN_ASCENT 0.00000533 #define APN_TDI_RATE_MAX_ASCENT 0.349 #define APN_TDI_RATE_DEFAULT_ASCENT 0.100 #define APN_VOLTAGE_RESOLUTION_ASCENT 0.00439453 #define APN_SHUTTER_CLOSE_DIFF_ASCENT 0.00000533 #define APN_STROBE_POSITION_MIN_ASCENT 0.00000533 #define APN_STROBE_POSITION_MAX_ASCENT 0.3493 #define APN_STROBE_POSITION_DEFAULT_ASCENT 0.001 #define APN_STROBE_PERIOD_MIN_ASCENT 0.000000026 #define APN_STROBE_PERIOD_MAX_ASCENT 0.00136 #define APN_STROBE_PERIOD_DEFAULT_ASCENT 0.001 #define APN_TEMP_COUNTS_ASCENT 4096 #define APN_TEMP_KELVIN_SCALE_OFFSET_ASCENT 273.16 #define APN_TEMP_SETPOINT_MIN_ASCENT 213 #define APN_TEMP_SETPOINT_MAX_ASCENT 313 #define APN_TEMP_HEATSINK_MIN_ASCENT 240 #define APN_TEMP_HEATSINK_MAX_ASCENT 240 #define APN_TEMP_SETPOINT_ZERO_POINT_ASCENT 2458 #define APN_TEMP_HEATSINK_ZERO_POINT_ASCENT 1351 #define APN_TEMP_DEGREES_PER_BIT_ASCENT 0.024414 #define APN_FAN_SPEED_OFF_ASCENT 0 #define APN_FAN_SPEED_LOW_ASCENT 49611 #define APN_FAN_SPEED_MEDIUM_ASCENT 58573 #define APN_FAN_SPEED_HIGH_ASCENT 65535 #define APN_GUIDER_RELAY_RESOLUTION_ASCENT 0.0007509 #define APN_GUIDER_RELAY_MIN_ASCENT 0.005 #define APN_GUIDER_RELAY_MAX_ASCENT 40.0 #define APN_GUIDER_RELAY_OPEN_TIME_ASCENT 0.0004 #define APN_GUIDER_RELAY_CLOSE_TIME_ASCENT 0.0011 /////////////////////////////////// // Filter Wheel Constants /////////////////////////////////// #define APN_FILTER_UNKNOWN_DESCR "Unknown" #define APN_FILTER_UNKNOWN_MAX_POSITIONS 0 #define APN_FILTER_FW50_9R_DESCR "AI FW50 9R" #define APN_FILTER_FW50_9R_MAX_POSITIONS 9 #define APN_FILTER_FW50_7S_DESCR "AI FW50 7S" #define APN_FILTER_FW50_7S_MAX_POSITIONS 7 #define APN_FILTER_AFW30_7R_DESCR "AI AFW30 7R" #define APN_FILTER_AFW30_7R_MAX_POSITIONS 7 #define APN_FILTER_AFW50_5R_DESCR "AI AFW50 5R" #define APN_FILTER_AFW50_5R_MAX_POSITIONS 5 #define APN_FILTER_AFW25_4R_DESCR "AI AFW25 4R" #define APN_FILTER_AFW25_4R_MAX_POSITIONS 4 libapogee2-2.2/ApnCamera_USB.cpp0000644000175000017500000005713211110507150014241 0ustar jrjr////////////////////////////////////////////////////////////////////// // // ApnCamera_USB.cpp: implementation of the CApnCamera_USB class. // // Copyright (c) 2003-2006 Apogee Instruments, Inc. // ////////////////////////////////////////////////////////////////////// #include "stdafx.h" #include "ApnCamera_USB.h" #include "ApogeeUsb.h" #include "ApogeeUsbErr.h" ////////////////////////////////////////////////////////////////////// // Construction/Destruction ////////////////////////////////////////////////////////////////////// bool CApnCamera::GetDeviceHandle( void *hCamera, char *CameraInfo ) { strcpy( CameraInfo, m_SysDeviceName ); return true; } bool CApnCamera::SimpleInitDriver( unsigned long CamIdA, unsigned short CamIdB, unsigned long Option ) { m_CamIdA = CamIdA; m_CamIdB = CamIdB; m_Option = Option; m_pvtConnectionOpen = false; if ( ApnUsbOpen( (unsigned short)CamIdA, m_SysDeviceName ) != APN_USB_SUCCESS ) { m_CamIdA = 0x0; m_CamIdB = 0x0; m_Option = 0x0; return false; } m_pvtConnectionOpen = true; ApnUsbReadVendorInfo( &m_pvtVendorId, &m_pvtProductId, &m_pvtDeviceId ); if ( (m_pvtProductId != 0x0010) && (m_pvtProductId != 0x0020) ) { return false; } return true; } bool CApnCamera::InitDriver( unsigned long CamIdA, unsigned short CamIdB, unsigned long Option ) { AltaDebugOutputString( "APOGEE.DLL - CApnCamera::InitDriver() -> BEGIN" ); m_CamIdA = CamIdA; m_CamIdB = CamIdB; m_Option = Option; m_pvtConnectionOpen = false; if ( ApnUsbOpen( (unsigned short)CamIdA, m_SysDeviceName ) != APN_USB_SUCCESS ) { m_CamIdA = 0x0; m_CamIdB = 0x0; m_Option = 0x0; return false; } m_pvtConnectionOpen = true; ApnUsbReadVendorInfo( &m_pvtVendorId, &m_pvtProductId, &m_pvtDeviceId ); if ( (m_pvtProductId != 0x0010) && (m_pvtProductId != 0x0020) ) { return false; } // Before trying to initialize, perform a simple loopback test unsigned short RegData; unsigned short NewRegData; RegData = 0x5AA5; if ( Write( FPGA_REG_SCRATCH, RegData ) != APN_USB_SUCCESS ) return false; if ( Read( FPGA_REG_SCRATCH, NewRegData ) != APN_USB_SUCCESS ) return false; if ( RegData != NewRegData ) return false; RegData = 0xA55A; if ( Write( FPGA_REG_SCRATCH, RegData ) != APN_USB_SUCCESS ) return false; if ( Read( FPGA_REG_SCRATCH, NewRegData ) != APN_USB_SUCCESS ) return false; if ( RegData != NewRegData ) return false; m_SysImgSizeBytes = 0; ApnUsbReadVendorInfo( &m_pvtVendorId, &m_pvtProductId, &m_pvtDeviceId ); ApnUsbSysDriverVersion( &m_SysDriverVersion ); // Update the feature set structure if ( m_pvtDeviceId >= 16 ) { m_pvtUseAdvancedStatus = true; } else { m_pvtUseAdvancedStatus = false; } m_pvtSequenceImagesDownloaded = 0; m_pvtExposeSequenceBulkDownload = true; m_pvtExposeCI = false; m_pvtExposeDualReadout = read_DualReadout(); m_pvtMostRecentFrame = 0; m_pvtReadyFrame = 0; m_pvtCurrentFrame = 0; // The loopback test was successful. Proceed with initialization. if ( InitDefaults() != 0 ) return false; // Done AltaDebugOutputString( "APOGEE.DLL - CApnCamera::InitDriver() -> END" ); return true; } Apn_Interface CApnCamera::GetCameraInterface() { // AltaDebugOutputString( "APOGEE.DLL - CApnCamera::GetCameraInterface()" ); return Apn_Interface_USB; } long CApnCamera::GetCameraSerialNumber( char *CameraSerialNumber, long *BufferLength ) { AltaDebugOutputString( "APOGEE.DLL - CApnCamera::GetCameraSerialNumber()" ); char pBuffer[256]; unsigned short Length; if ( *BufferLength < (APN_USB_SN_BYTE_COUNT + 1) ) { if ( *BufferLength > 7 ) { strcpy( CameraSerialNumber, "Unknown" ); *BufferLength = strlen( CameraSerialNumber ); } return CAPNCAMERA_ERR_SN; } if ( m_pvtDeviceId < 0x0011 ) { strcpy( CameraSerialNumber, "Unknown" ); *BufferLength = strlen( CameraSerialNumber ); } else { if ( ApnUsbReadCustomSerialNumber( pBuffer, &Length ) != APN_USB_SUCCESS ) { strcpy( CameraSerialNumber, "Unknown" ); *BufferLength = strlen( CameraSerialNumber ); } else { strcpy( CameraSerialNumber, pBuffer ); *BufferLength = Length; } } return CAPNCAMERA_SUCCESS; } long CApnCamera::GetSystemDriverVersion( char *SystemDriverVersion, long *BufferLength ) { AltaDebugOutputString( "APOGEE.DLL - CApnCamera::GetSystemDriverVersion()" ); if ( m_SysDriverVersion == 0.0 ) sprintf( SystemDriverVersion, "Unknown" ); else sprintf( SystemDriverVersion, "%.2f", m_SysDriverVersion ); *BufferLength = strlen( SystemDriverVersion ); return CAPNCAMERA_SUCCESS; } long CApnCamera::GetUsb8051FirmwareRev( char *FirmwareRev, long *BufferLength ) { AltaDebugOutputString( "APOGEE.DLL - CApnCamera::GetUsb8051FirmwareRev()" ); ApnUsbRead8051FirmwareRevision( FirmwareRev ); *BufferLength = strlen( FirmwareRev ); return CAPNCAMERA_SUCCESS; } long CApnCamera::GetUsbProductId( unsigned short *pProductId ) { AltaDebugOutputString( "APOGEE.DLL - CApnCamera::GetUsbProductId()" ); *pProductId = m_pvtProductId; return CAPNCAMERA_SUCCESS; } long CApnCamera::GetUsbDeviceId( unsigned short *pDeviceId ) { AltaDebugOutputString( "APOGEE.DLL - CApnCamera::GetUsbDeviceId()" ); *pDeviceId = m_pvtDeviceId; return CAPNCAMERA_SUCCESS; } bool CApnCamera::CloseDriver() { AltaDebugOutputString( "APOGEE.DLL - CApnCamera::CloseDriver()" ); ApnUsbClose( ); return true; } void CApnCamera::SetNetworkTransferMode( int TransferMode ) { return; } long CApnCamera::GetImageData( unsigned short *pImageBuffer, unsigned short &Width, unsigned short &Height, unsigned long &Count ) { AltaDebugOutputString( "APOGEE.DLL - CApnCamera::GetImageData()" ); unsigned short Offset; unsigned short *pTempBuffer; unsigned long DownloadHeight; unsigned long i, j; char szOutputText[128]; if ( m_pvtConnectionOpen == false ) return CAPNCAMERA_ERR_CONNECT; if ( !ImageInProgress() ) return CAPNCAMERA_ERR_IMAGE; // Make sure it is okay to get the image data // The app *should* have done this on its own, but we have to make sure if ( (m_pvtNumImages == 1) || (m_pvtExposeSequenceBulkDownload) ) { while ( !ImageReady() ) { Sleep( 50 ); read_ImagingStatus(); } } Width = m_pvtExposeWidth; Height = m_pvtExposeHeight; if ( m_pvtExposeCameraMode != Apn_CameraMode_Test ) { if ( m_pvtExposeBitsPerPixel == 16 ) Offset = 1; if ( m_pvtExposeBitsPerPixel == 12 ) Offset = 10; Width -= Offset; // Calculate the true image width } if ( m_pvtExposeSequenceBulkDownload ) DownloadHeight = Height * m_pvtNumImages; else DownloadHeight = Height; pTempBuffer = new unsigned short[(Width+Offset) * DownloadHeight]; if ( ApnUsbGetImage( m_SysImgSizeBytes, pTempBuffer ) != APN_USB_SUCCESS ) { AltaDebugOutputString( "APOGEE.DLL - CApnCamera::GetImageData() -> ERROR: Failed ApnUsbGetImage()!!" ); ApnUsbClose( ); delete [] pTempBuffer; SignalImagingDone(); m_pvtConnectionOpen = false; return CAPNCAMERA_ERR_IMAGE; } unsigned long TermOne; unsigned long TermTwo; for ( i=0; i TdiLinesDownloaded = %d", m_pvtTdiLinesDownloaded ); AltaDebugOutputString( szOutputText ); if ( m_pvtTdiLinesDownloaded == read_TDIRows() ) { SignalImagingDone(); ResetSystem(); } } else { if ( (m_pvtNumImages == 1) || (m_pvtExposeSequenceBulkDownload) ) { AltaDebugOutputString( "APOGEE.DLL - CApnCamera::GetImage() -> Single Image Done" ); SignalImagingDone(); } if ( (m_pvtNumImages > 1) && (!m_pvtExposeSequenceBulkDownload) ) { m_pvtSequenceImagesDownloaded++; AltaDebugPrint( szOutputText, "APOGEE.DLL - CApnCamera::GetImage() -> SequenceImagesDownloaded = %d", m_pvtSequenceImagesDownloaded ); AltaDebugOutputString( szOutputText ); if ( m_pvtSequenceImagesDownloaded == m_pvtNumImages ) SignalImagingDone(); } } return CAPNCAMERA_SUCCESS; } long CApnCamera::GetLineData( unsigned short *pLineBuffer, unsigned short &Size ) { unsigned short Offset; unsigned short *pTempBuffer; unsigned short Width; unsigned long BytesPerLine; unsigned long i; if ( m_pvtConnectionOpen == false ) return CAPNCAMERA_ERR_CONNECT; // image must already be in progress if ( !ImageInProgress() ) return CAPNCAMERA_ERR_IMAGE; // the SequenceBulkDownload var *must* be set to FALSE if ( m_pvtExposeSequenceBulkDownload ) return CAPNCAMERA_ERR_IMAGE; Width = m_pvtExposeWidth; BytesPerLine = Width * 2; if ( m_pvtExposeBitsPerPixel == 16 ) Offset = 1; if ( m_pvtExposeBitsPerPixel == 12 ) Offset = 10; Width -= Offset; // Calculate the true image width pTempBuffer = new unsigned short[Width+Offset]; if ( ApnUsbGetImage( BytesPerLine, pTempBuffer ) != APN_USB_SUCCESS ) { ApnUsbClose( ); delete [] pTempBuffer; SignalImagingDone(); m_pvtConnectionOpen = false; return CAPNCAMERA_ERR_IMAGE; } for ( i=0; i BEGIN" ); if ( m_pvtConnectionOpen == false ) { return CAPNCAMERA_ERR_CONNECT; } if ( (BitsPerPixel != 16) && (BitsPerPixel != 12) ) { // Invalid bit depth request return CAPNCAMERA_ERR_START_EXP; } m_pvtExposeWidth = GetExposurePixelsH(); m_pvtExposeBitsPerPixel = BitsPerPixel; m_pvtExposeHBinning = read_RoiBinningH(); m_pvtExposeSequenceBulkDownload = read_SequenceBulkDownload(); m_pvtExposeExternalShutter = read_ExternalShutter(); m_pvtExposeCameraMode = read_CameraMode(); m_pvtExposeCI = read_ContinuousImaging(); if ( m_pvtExposeCameraMode != Apn_CameraMode_Test ) { if ( m_pvtExposeBitsPerPixel == 16 ) m_pvtExposeWidth += 1; if ( m_pvtExposeBitsPerPixel == 12 ) m_pvtExposeWidth += 10; } if ( m_pvtExposeCameraMode == Apn_CameraMode_TDI ) { m_pvtTdiLinesDownloaded = 0; m_pvtExposeHeight = 1; m_pvtNumImages = read_TDIRows(); } else { m_pvtExposeHeight = GetExposurePixelsV(); m_pvtNumImages = read_ImageCount(); } if ( (m_pvtExposeCI) && (m_pvtExposeCameraMode == Apn_CameraMode_Normal) ) { if ( ApnUsbStartCI( m_pvtExposeWidth, m_pvtExposeHeight ) != APN_USB_SUCCESS ) { ApnUsbClose( ); if ( ApnUsbOpen( (unsigned short)m_CamIdA, m_SysDeviceName ) != APN_USB_SUCCESS ) { m_pvtConnectionOpen = false; m_SysImgSizeBytes = 0; return CAPNCAMERA_ERR_CONNECT; // Failure } else { if ( ApnUsbStartCI( m_pvtExposeWidth, m_pvtExposeHeight ) != APN_USB_SUCCESS ) return CAPNCAMERA_ERR_START_EXP; } } m_SysImgSizeBytes = m_pvtExposeWidth * m_pvtExposeHeight * 2; } else { if ( m_pvtExposeSequenceBulkDownload == true ) { if ( ApnUsbStartExp( 1, m_pvtExposeWidth, (m_pvtExposeHeight*m_pvtNumImages) ) != APN_USB_SUCCESS ) { ApnUsbClose( ); if ( ApnUsbOpen( (unsigned short)m_CamIdA, m_SysDeviceName ) != APN_USB_SUCCESS ) { m_pvtConnectionOpen = false; m_SysImgSizeBytes = 0; return CAPNCAMERA_ERR_CONNECT; // Failure } else { if ( ApnUsbStartExp( 1, m_pvtExposeWidth, (m_pvtExposeHeight*m_pvtNumImages) ) != APN_USB_SUCCESS ) return CAPNCAMERA_ERR_START_EXP; } } m_SysImgSizeBytes = m_pvtExposeWidth * m_pvtExposeHeight * m_pvtNumImages * 2; } else { // first check DID and .sys driver version // reset our vars that will be updated during future status calls m_pvtMostRecentFrame = 0; m_pvtReadyFrame = 0; m_pvtCurrentFrame = 0; m_pvtSequenceImagesDownloaded = 0; if ( ApnUsbStartExp( m_pvtNumImages, m_pvtExposeWidth, m_pvtExposeHeight ) != APN_USB_SUCCESS ) { ApnUsbClose( ); if ( ApnUsbOpen( (unsigned short)m_CamIdA, m_SysDeviceName ) != APN_USB_SUCCESS ) { m_pvtConnectionOpen = false; m_SysImgSizeBytes = 0; return CAPNCAMERA_ERR_CONNECT; // Failure } else { if ( ApnUsbStartExp( m_pvtNumImages, m_pvtExposeWidth, m_pvtExposeHeight ) != APN_USB_SUCCESS ) return CAPNCAMERA_ERR_START_EXP; } } m_SysImgSizeBytes = m_pvtExposeWidth * m_pvtExposeHeight * 2; } } AltaDebugOutputString( "APOGEE.DLL - CApnCamera::PreStartExpose() -> END" ); return CAPNCAMERA_SUCCESS; } long CApnCamera::PostStopExposure( bool DigitizeData ) { AltaDebugOutputString( "APOGEE.DLL - CApnCamera::PostStopExposure() -> BEGIN" ); PUSHORT pRequestData; if ( m_pvtConnectionOpen == false ) return CAPNCAMERA_ERR_CONNECT; switch( m_pvtExposeCameraMode ) { case Apn_CameraMode_Normal: // If in continuous imaging mode, issue the stop if ( m_pvtExposeCI ) { ApnUsbStopCI( 1 ); } // First, if we are not triggered in some manner, do a normal stop exposure routine // We check the condition "read_ImagingStatus() == Apn_Status_WaitingOnTrigger" // after this because we don't usually want to read ImagingStatus in the driver if ( !read_ExposureTriggerGroup() && !read_ExposureTriggerEach() && !read_ExposureExternalShutter() ) { AltaDebugOutputString( "APOGEE.DLL - CApnCamera::PostStopExposure() -> Not using H/W trigger" ); if ( !DigitizeData ) { while ( !ImageReady() ) { Sleep( 50 ); read_ImagingStatus(); } pRequestData = new USHORT[m_pvtExposeWidth*m_pvtExposeHeight]; if ( ApnUsbGetImage( m_SysImgSizeBytes, pRequestData ) != APN_USB_SUCCESS ) { ApnUsbClose( ); delete [] pRequestData; SignalImagingDone(); m_pvtConnectionOpen = false; return CAPNCAMERA_ERR_STOP_EXP; } delete [] pRequestData; SignalImagingDone(); } } else { AltaDebugOutputString( "APOGEE.DLL - CApnCamera::PostStopExposure() -> Using H/W trigger" ); if ( read_ImagingStatus() == Apn_Status_WaitingOnTrigger ) { AltaDebugOutputString( "APOGEE.DLL - CApnCamera::PostStopExposure() -> Detected Apn_Status_WaitingOnTrigger" ); ApnUsbStopExp( false ); SignalImagingDone(); ResetSystem(); } else { AltaDebugOutputString( "APOGEE.DLL - CApnCamera::PostStopExposure() -> Did NOT detect Apn_Status_WaitingOnTrigger" ); if ( !DigitizeData ) { while ( !ImageReady() ) { Sleep( 50 ); read_ImagingStatus(); } pRequestData = new USHORT[m_pvtExposeWidth*m_pvtExposeHeight]; if ( ApnUsbGetImage( m_SysImgSizeBytes, pRequestData ) != APN_USB_SUCCESS ) { AltaDebugOutputString( "APOGEE.DLL - CApnCamera::PostStopExposure() -> ERROR: Failed ApnUsbGetImage()!!" ); ApnUsbClose( ); delete [] pRequestData; SignalImagingDone(); m_pvtConnectionOpen = false; return CAPNCAMERA_ERR_STOP_EXP; } delete [] pRequestData; SignalImagingDone(); if ( m_pvtExposeExternalShutter ) { ResetSystem(); } } } } break; case Apn_CameraMode_TDI: // Issue the Stop command ApnUsbStopExp( DigitizeData ); // Clean up after the stop // Restart the system to flush normally SignalImagingDone(); ResetSystem(); break; case Apn_CameraMode_ExternalTrigger: // Included for stopping "legacy" externally triggered exposures if ( !DigitizeData ) { while ( !ImageReady() ) { Sleep( 50 ); read_ImagingStatus(); } pRequestData = new USHORT[m_pvtExposeWidth*m_pvtExposeHeight]; if ( ApnUsbGetImage( m_SysImgSizeBytes, pRequestData ) != APN_USB_SUCCESS ) { ApnUsbClose( ); delete [] pRequestData; SignalImagingDone(); m_pvtConnectionOpen = false; return CAPNCAMERA_ERR_STOP_EXP; } delete [] pRequestData; SignalImagingDone(); } break; case Apn_CameraMode_Kinetics: // Issue the Stop command ApnUsbStopExp( DigitizeData ); // Clean up after the stop // Restart the system to flush normally SignalImagingDone(); ResetSystem(); break; default: break; } AltaDebugOutputString( "APOGEE.DLL - CApnCamera::PostStopExposure() -> END" ); return CAPNCAMERA_SUCCESS; } long CApnCamera::Read( unsigned short reg, unsigned short& val ) { if ( m_pvtConnectionOpen == false ) return CAPNCAMERA_ERR_CONNECT; if ( ApnUsbReadReg( reg, &val ) != APN_USB_SUCCESS ) { ApnUsbClose( ); if ( ApnUsbOpen( (unsigned short)m_CamIdA, m_SysDeviceName ) != APN_USB_SUCCESS ) { m_pvtConnectionOpen = false; return CAPNCAMERA_ERR_CONNECT; // Failure } else { if ( ApnUsbReadReg( reg, &val ) != APN_USB_SUCCESS ) return CAPNCAMERA_ERR_READ; } } return CAPNCAMERA_SUCCESS; } long CApnCamera::Write( unsigned short reg, unsigned short val ) { if ( m_pvtConnectionOpen == false ) return CAPNCAMERA_ERR_CONNECT; if ( ApnUsbWriteReg( reg, val ) != APN_USB_SUCCESS ) { ApnUsbClose( ); if ( ApnUsbOpen( (unsigned short)m_CamIdA, m_SysDeviceName ) != APN_USB_SUCCESS ) { m_pvtConnectionOpen = false; return CAPNCAMERA_ERR_CONNECT; // Failure } else { if ( ApnUsbWriteReg( reg, val ) != APN_USB_SUCCESS ) return CAPNCAMERA_ERR_WRITE; } } return CAPNCAMERA_SUCCESS; } long CApnCamera::WriteMultiSRMD( unsigned short reg, unsigned short val[], unsigned short count ) { if ( m_pvtConnectionOpen == false ) return CAPNCAMERA_ERR_CONNECT; if ( ApnUsbWriteRegMulti( reg, val, count ) != APN_USB_SUCCESS ) { ApnUsbClose( ); if ( ApnUsbOpen( (unsigned short)m_CamIdA, m_SysDeviceName ) != APN_USB_SUCCESS ) { m_pvtConnectionOpen = false; return CAPNCAMERA_ERR_CONNECT; // Failure } else { if ( ApnUsbWriteRegMulti( reg, val, count ) != APN_USB_SUCCESS ) return CAPNCAMERA_ERR_WRITE; } } return CAPNCAMERA_SUCCESS; } long CApnCamera::WriteMultiMRMD( unsigned short reg[], unsigned short val[], unsigned short count ) { if ( m_pvtConnectionOpen == false ) return CAPNCAMERA_ERR_CONNECT; if ( ApnUsbWriteRegMultiMRMD( reg, val, count ) != APN_USB_SUCCESS ) { ApnUsbClose( ); if ( ApnUsbOpen( (unsigned short)m_CamIdA, m_SysDeviceName ) != APN_USB_SUCCESS ) { m_pvtConnectionOpen = false; return CAPNCAMERA_ERR_CONNECT; // Failure } else { if ( ApnUsbWriteRegMultiMRMD( reg, val, count ) != APN_USB_SUCCESS ) return CAPNCAMERA_ERR_WRITE; } } return CAPNCAMERA_SUCCESS; } long CApnCamera::QueryStatusRegs( unsigned short& StatusReg, unsigned short& HeatsinkTempReg, unsigned short& CcdTempReg, unsigned short& CoolerDriveReg, unsigned short& VoltageReg, unsigned short& TdiCounter, unsigned short& SequenceCounter, unsigned short& MostRecentFrame, unsigned short& ReadyFrame, unsigned short& CurrentFrame ) { // AltaDebugOutputString( "APOGEE.DLL - CApnCamera::QueryStatusRegs()" ); bool DoneFlag; if ( m_pvtConnectionOpen == false ) return CAPNCAMERA_ERR_CONNECT; if ( ApnUsbReadStatusRegs( m_pvtUseAdvancedStatus, &DoneFlag, &StatusReg, &HeatsinkTempReg, &CcdTempReg, &CoolerDriveReg, &VoltageReg, &TdiCounter, &SequenceCounter, &MostRecentFrame, &ReadyFrame, &CurrentFrame ) != APN_USB_SUCCESS ) { ApnUsbClose( ); if ( ApnUsbOpen( (unsigned short)m_CamIdA, m_SysDeviceName ) != APN_USB_SUCCESS ) { m_pvtConnectionOpen = false; return CAPNCAMERA_ERR_CONNECT; // Failure } else { if ( ApnUsbReadStatusRegs( m_pvtUseAdvancedStatus, &DoneFlag, &StatusReg, &HeatsinkTempReg, &CcdTempReg, &CoolerDriveReg, &VoltageReg, &TdiCounter, &SequenceCounter, &MostRecentFrame, &ReadyFrame, &CurrentFrame ) != APN_USB_SUCCESS ) { return CAPNCAMERA_ERR_QUERY; } } } #ifdef APOGEE_DLL_GENERAL_STATUS_OUTPUT char szOutputText[256]; AltaDebugPrint( szOutputText, "APOGEE.DLL - CApnCamera::QueryStatusRegs() -> UseAdvancedStatus (Driver Flag) = %d", m_pvtUseAdvancedStatus ); AltaDebugOutputString( szOutputText ); AltaDebugPrint( szOutputText, "APOGEE.DLL - CApnCamera::QueryStatusRegs() -> DoneFlag (USB FW Flag) = %d", DoneFlag ); AltaDebugOutputString( szOutputText ); AltaDebugPrint( szOutputText, "APOGEE.DLL - CApnCamera::QueryStatusRegs() -> StatusReg (R91) = 0x%04X", StatusReg ); AltaDebugOutputString( szOutputText ); AltaDebugPrint( szOutputText, "APOGEE.DLL - CApnCamera::QueryStatusRegs() -> HeatsinkTempReg (R93) = 0x%04X", HeatsinkTempReg ); AltaDebugOutputString( szOutputText ); AltaDebugPrint( szOutputText, "APOGEE.DLL - CApnCamera::QueryStatusRegs() -> CcdTempReg (R94) = 0x%04X", CcdTempReg ); AltaDebugOutputString( szOutputText ); AltaDebugPrint( szOutputText, "APOGEE.DLL - CApnCamera::QueryStatusRegs() -> CoolerDriveReg (R95) = 0x%04X", CoolerDriveReg ); AltaDebugOutputString( szOutputText ); AltaDebugPrint( szOutputText, "APOGEE.DLL - CApnCamera::QueryStatusRegs() -> VoltageReg (R96) = 0x%04X", VoltageReg ); AltaDebugOutputString( szOutputText ); AltaDebugPrint( szOutputText, "APOGEE.DLL - CApnCamera::QueryStatusRegs() -> TdiCounter (R104) = %d", TdiCounter ); AltaDebugOutputString( szOutputText ); AltaDebugPrint( szOutputText, "APOGEE.DLL - CApnCamera::QueryStatusRegs() -> SequenceCounter (R105) = %d", SequenceCounter ); AltaDebugOutputString( szOutputText ); AltaDebugPrint( szOutputText, "APOGEE.DLL - CApnCamera::QueryStatusRegs() -> MostRecentFrame (USB FW Counter) = %d", MostRecentFrame ); AltaDebugOutputString( szOutputText ); AltaDebugPrint( szOutputText, "APOGEE.DLL - CApnCamera::QueryStatusRegs() -> ReadyFrame (USB FW Counter) = %d", ReadyFrame ); AltaDebugOutputString( szOutputText ); AltaDebugPrint( szOutputText, "APOGEE.DLL - CApnCamera::QueryStatusRegs() -> CurrentFrame (USB FW Counter) = %d", CurrentFrame ); AltaDebugOutputString( szOutputText ); #endif if ( DoneFlag ) { StatusReg |= FPGA_BIT_STATUS_IMAGE_DONE; } m_pvtMostRecentFrame = MostRecentFrame; m_pvtReadyFrame = ReadyFrame; m_pvtCurrentFrame = CurrentFrame; return CAPNCAMERA_SUCCESS; } libapogee2-2.2/ApnCamData_CCD4240B.cpp0000644000175000017500000004431011110507150014711 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_CCD4240B.cpp: Implementation file for the CApnCamData_CCD4240B class. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #include "ApnCamData_CCD4240B.h" #include #include #include ///////////////////////////////////////////////////////////// // Construction/Destruction ///////////////////////////////////////////////////////////// CApnCamData_CCD4240B::CApnCamData_CCD4240B() { } CApnCamData_CCD4240B::~CApnCamData_CCD4240B() { } void CApnCamData_CCD4240B::Initialize() { strcpy( m_Sensor, "CCD4240B" ); strcpy( m_CameraModel, "42" ); m_CameraId = 13; m_InterlineCCD = false; m_SupportsSerialA = true; m_SupportsSerialB = true; m_SensorTypeCCD = true; m_TotalColumns = 2148; m_ImagingColumns = 2048; m_ClampColumns = 50; m_PreRoiSkipColumns = 0; m_PostRoiSkipColumns = 0; m_OverscanColumns = 50; m_TotalRows = 2052; m_ImagingRows = 2048; m_UnderscanRows = 2; m_OverscanRows = 2; m_VFlushBinning = 1; m_EnableSingleRowOffset = false; m_RowOffsetBinning = 1; m_HFlushDisable = false; m_ShutterCloseDelay = 500; m_PixelSizeX = 13.5; m_PixelSizeY = 13.5; m_Color = false; m_ReportedGainSixteenBit = 2; m_MinSuggestedExpTime = 20.0; m_CoolingSupported = true; m_RegulatedCoolingSupported = true; m_TempSetPoint = -20.0; m_TempRampRateOne = 700; m_TempRampRateTwo = 4000; m_TempBackoffPoint = 2.0; m_PrimaryADType = ApnAdType_Alta_Sixteen; m_AlternativeADType = ApnAdType_Alta_Twelve; m_DefaultGainLeft = 400; m_DefaultOffsetLeft = 200; m_DefaultGainRight = -1; m_DefaultOffsetRight = -1; m_DefaultRVoltage = 1000; m_DefaultSpeed = 0xffff; m_DefaultDataReduction = false; set_vpattern(); set_hpattern_clamp_sixteen(); set_hpattern_skip_sixteen(); set_hpattern_roi_sixteen(); set_hpattern_clamp_twelve(); set_hpattern_skip_twelve(); set_hpattern_roi_twelve(); } void CApnCamData_CCD4240B::set_vpattern() { const unsigned short Mask = 0xE; const unsigned short NumElements = 247; unsigned short Pattern[NumElements] = { 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x000A, 0x000A, 0x000A, 0x000A, 0x000A, 0x000A, 0x000A, 0x000A, 0x000A, 0x000A, 0x000A, 0x000A, 0x000A, 0x000A, 0x000A, 0x000A, 0x000A, 0x000A, 0x000A, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0001, 0x0000 }; m_VerticalPattern.Mask = Mask; m_VerticalPattern.NumElements = NumElements; m_VerticalPattern.PatternData = (unsigned short *)malloc(NumElements * sizeof(unsigned short)); for ( int i=0; iMask = Mask; Pattern->BinningLimit = BinningLimit; Pattern->RefNumElements = RefNumElements; Pattern->SigNumElements = SigNumElements; if ( RefNumElements > 0 ) { Pattern->RefPatternData = (unsigned short *)malloc(RefNumElements * sizeof(unsigned short)); for ( i=0; iRefPatternData[i] = RefPatternData[i]; } } if ( SigNumElements > 0 ) { Pattern->SigPatternData = (unsigned short *)malloc(SigNumElements * sizeof(unsigned short)); for ( i=0; iSigPatternData[i] = SigPatternData[i]; } } if ( BinningLimit > 0 ) { for ( i=0; iBinNumElements[i] = BinNumElements[i]; Pattern->BinPatternData[i] = (unsigned short *)malloc(BinNumElements[i] * sizeof(unsigned short)); for ( j=0; jBinPatternData[i][j] = BinPatternData[i][j]; } } } } libapogee2-2.2/ApnSerial_NET.h0000644000175000017500000000233411110507150013724 0ustar jrjr// ApnSerial_NET.h: interface for the CApnSerial_NET class. // ////////////////////////////////////////////////////////////////////// #if !defined(AFX_APNSERIAL_NET_H__F31A372D_2B82_4998_B74C_FFAD8E3EEE86__INCLUDED_) #define AFX_APNSERIAL_NET_H__F31A372D_2B82_4998_B74C_FFAD8E3EEE86__INCLUDED_ #if _MSC_VER > 1000 #pragma once #endif // _MSC_VER > 1000 #include "ApnSerial.h" class CApnSerial_NET : public CApnSerial { public: CApnSerial_NET(); virtual ~CApnSerial_NET(); bool InitPort( unsigned long CamIdA, unsigned short CamIdB, unsigned short SerialId ); bool ClosePort(); bool GetBaudRate( unsigned long *BaudRate ); bool SetBaudRate( unsigned long BaudRate ); bool GetFlowControl( Apn_SerialFlowControl *FlowControl ); bool SetFlowControl( Apn_SerialFlowControl FlowControl ); bool GetParity( Apn_SerialParity *Parity ); bool SetParity( Apn_SerialParity Parity ); bool Read( int SerialSock, char *ReadBuffer, unsigned short *ReadCount ); bool Write( int SerialSock, char *WriteBuffer, unsigned short WriteCount ); char *ReadBuffer(void); }; #endif // !defined(AFX_APNSERIAL_NET_H__F31A372D_2B82_4998_B74C_FFAD8E3EEE86__INCLUDED_) libapogee2-2.2/ApnCamData.h0000644000175000017500000000624411110507150013275 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData.h: Interface file for the CApnCamData class. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #if !defined(AFX_APNCAMDATA_H__32231556_A1FD_421B_94F8_295D4148E195__INCLUDED_) #define AFX_APNCAMDATA_H__32231556_A1FD_421B_94F8_295D4148E195__INCLUDED_ #if _MSC_VER > 1000 #pragma once #endif // _MSC_VER > 1000 #define APN_MAX_HBINNING 10 #define APN_MAX_PATTERN_ENTRIES 256 typedef struct _APN_VPATTERN_FILE { unsigned short Mask; unsigned short NumElements; unsigned short *PatternData; } APN_VPATTERN_FILE; typedef struct _APN_HPATTERN_FILE { unsigned short Mask; unsigned short BinningLimit; unsigned short RefNumElements; unsigned short BinNumElements[APN_MAX_HBINNING]; unsigned short SigNumElements; unsigned short *RefPatternData; unsigned short *BinPatternData[APN_MAX_HBINNING]; unsigned short *SigPatternData; } APN_HPATTERN_FILE; typedef enum ApnAdType { ApnAdType_None, ApnAdType_Alta_Sixteen, ApnAdType_Alta_Twelve, ApnAdType_Ascent_Sixteen }; class CApnCamData { public: CApnCamData(); virtual ~CApnCamData(); virtual void Initialize() = 0; char m_Sensor[20]; char m_CameraModel[20]; unsigned short m_CameraId; bool m_InterlineCCD; bool m_SupportsSerialA; bool m_SupportsSerialB; bool m_SensorTypeCCD; unsigned short m_TotalColumns; unsigned short m_ImagingColumns; unsigned short m_ClampColumns; unsigned short m_PreRoiSkipColumns; unsigned short m_PostRoiSkipColumns; unsigned short m_OverscanColumns; unsigned short m_TotalRows; unsigned short m_ImagingRows; unsigned short m_UnderscanRows; unsigned short m_OverscanRows; unsigned short m_VFlushBinning; bool m_EnableSingleRowOffset; unsigned short m_RowOffsetBinning; bool m_HFlushDisable; unsigned short m_ShutterCloseDelay; double m_PixelSizeX; double m_PixelSizeY; bool m_Color; double m_ReportedGainSixteenBit; double m_MinSuggestedExpTime; bool m_CoolingSupported; bool m_RegulatedCoolingSupported; double m_TempSetPoint; unsigned short m_TempRampRateOne; unsigned short m_TempRampRateTwo; double m_TempBackoffPoint; ApnAdType m_PrimaryADType; ApnAdType m_AlternativeADType; int m_DefaultGainLeft; int m_DefaultOffsetLeft; int m_DefaultGainRight; int m_DefaultOffsetRight; unsigned short m_DefaultRVoltage; unsigned short m_DefaultSpeed; bool m_DefaultDataReduction; // Pattern Files APN_VPATTERN_FILE m_VerticalPattern; APN_HPATTERN_FILE m_ClampPatternSixteen; APN_HPATTERN_FILE m_SkipPatternSixteen; APN_HPATTERN_FILE m_RoiPatternSixteen; APN_HPATTERN_FILE m_ClampPatternTwelve; APN_HPATTERN_FILE m_SkipPatternTwelve; APN_HPATTERN_FILE m_RoiPatternTwelve; private: void init_vpattern( ); void clear_vpattern( ); void init_hpattern( APN_HPATTERN_FILE *Pattern ); void clear_hpattern( APN_HPATTERN_FILE *Pattern ); }; #endif // !defined(AFX_APNCAMDATA_H__32231556_A1FD_421B_94F8_295D4148E195__INCLUDED_) libapogee2-2.2/ApnCamData_CCD7700.h0000644000175000017500000000217411110507150014262 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_CCD7700.h: Interface file for the CApnCamData_CCD7700 class. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #if _MSC_VER > 1000 #pragma once #endif // _MSC_VER> 1000 #include "ApnCamData.h" class CApnCamData_CCD7700 : public CApnCamData { public: CApnCamData_CCD7700(); virtual ~CApnCamData_CCD7700(); void Initialize(); private: void set_vpattern(); void set_hpattern_clamp_sixteen(); void set_hpattern_skip_sixteen(); void set_hpattern_roi_sixteen(); void set_hpattern_clamp_twelve(); void set_hpattern_skip_twelve(); void set_hpattern_roi_twelve(); void set_hpattern( APN_HPATTERN_FILE *Pattern, unsigned short Mask, unsigned short BinningLimit, unsigned short RefNumElements, unsigned short SigNumElements, unsigned short BinNumElements[], unsigned short RefPatternData[], unsigned short SigPatternData[], unsigned short BinPatternData[][APN_MAX_PATTERN_ENTRIES] ); }; libapogee2-2.2/ApnUsbSys.h0000644000175000017500000000277611110507150013241 0ustar jrjr// ApnUsbSys.h // // Copyright (c) 2003, 2004 Apogee Instruments, Inc. // // Defines common data structure(s) for sharing between application // layer and the ApUSB.sys device driver. // #if !defined(_APNUSBSYS_H__INCLUDED_) #define _APNUSBSYS_H__INCLUDED_ #if _MSC_VER > 1000 #pragma once #endif // _MSC_VER > 1000 #define VND_ANCHOR_LOAD_INTERNAL 0xA0 #define VND_APOGEE_CMD_BASE 0xC0 #define VND_APOGEE_STATUS ( VND_APOGEE_CMD_BASE + 0x0 ) #define VND_APOGEE_CAMCON_REG ( VND_APOGEE_CMD_BASE + 0x2 ) #define VND_APOGEE_BUFCON_REG ( VND_APOGEE_CMD_BASE + 0x3 ) #define VND_APOGEE_SET_SERIAL ( VND_APOGEE_CMD_BASE + 0x4 ) #define VND_APOGEE_SERIAL ( VND_APOGEE_CMD_BASE + 0x5 ) #define VND_APOGEE_EEPROM ( VND_APOGEE_CMD_BASE + 0x6 ) #define VND_APOGEE_SOFT_RESET ( VND_APOGEE_CMD_BASE + 0x8 ) #define VND_APOGEE_GET_IMAGE ( VND_APOGEE_CMD_BASE + 0x9 ) #define VND_APOGEE_STOP_IMAGE ( VND_APOGEE_CMD_BASE + 0xA ) #define VND_APOGEE_VERSION ( VND_APOGEE_CMD_BASE + 0xB ) #define VND_APOGEE_VENDOR ( VND_APOGEE_CMD_BASE + 0xC ) #define VND_APOGEE_DATA_PORT ( VND_APOGEE_CMD_BASE + 0xD ) #define VND_APOGEE_CONTROL_PORT ( VND_APOGEE_CMD_BASE + 0xE ) #define REQUEST_IN 0x1 #define REQUEST_OUT 0x0 typedef struct _APN_USB_REQUEST { unsigned char Request; unsigned char Direction; unsigned short Value; unsigned short Index; } APN_USB_REQUEST, *PAPN_USB_REQUEST; #endif // !defined(_APNUSBSYS_H__INCLUDED_) libapogee2-2.2/ApnCamData_ASCENT340.cpp0000644000175000017500000002215211110507150015110 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_ASCENT340.cpp: Implementation file for the CApnCamData_ASCENT340 class. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #include "ApnCamData_ASCENT340.h" #include #include #include ///////////////////////////////////////////////////////////// // Construction/Destruction ///////////////////////////////////////////////////////////// CApnCamData_ASCENT340::CApnCamData_ASCENT340() { } CApnCamData_ASCENT340::~CApnCamData_ASCENT340() { } void CApnCamData_ASCENT340::Initialize() { strcpy( m_Sensor, "ASCENT340" ); strcpy( m_CameraModel, "340" ); m_CameraId = 323; m_InterlineCCD = true; m_SupportsSerialA = false; m_SupportsSerialB = false; m_SensorTypeCCD = true; m_TotalColumns = 4942; m_ImagingColumns = 4872; m_ClampColumns = 35; m_PreRoiSkipColumns = 0; m_PostRoiSkipColumns = 0; m_OverscanColumns = 35; m_TotalRows = 3324; m_ImagingRows = 3248; m_UnderscanRows = 56; m_OverscanRows = 20; m_VFlushBinning = 4; m_EnableSingleRowOffset = false; m_RowOffsetBinning = 1; m_HFlushDisable = false; m_ShutterCloseDelay = 0; m_PixelSizeX = 7.4; m_PixelSizeY = 7.4; m_Color = false; m_ReportedGainSixteenBit = 0.8; m_MinSuggestedExpTime = 0.1; m_CoolingSupported = true; m_RegulatedCoolingSupported = true; m_TempSetPoint = -20.0; m_TempRampRateOne = 1200; m_TempRampRateTwo = 4000; m_TempBackoffPoint = 2.0; m_PrimaryADType = ApnAdType_Ascent_Sixteen; m_AlternativeADType = ApnAdType_None; m_DefaultGainLeft = 0; m_DefaultOffsetLeft = 100; m_DefaultGainRight = 0; m_DefaultOffsetRight = 100; m_DefaultRVoltage = 1000; m_DefaultSpeed = 0x0; m_DefaultDataReduction = true; set_vpattern(); set_hpattern_clamp_sixteen(); set_hpattern_skip_sixteen(); set_hpattern_roi_sixteen(); set_hpattern_clamp_twelve(); set_hpattern_skip_twelve(); set_hpattern_roi_twelve(); } void CApnCamData_ASCENT340::set_vpattern() { const unsigned short Mask = 0x6; const unsigned short NumElements = 71; unsigned short Pattern[NumElements] = { 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0202, 0x0202, 0x0202, 0x0202, 0x0202, 0x0202, 0x0202, 0x0202, 0x0202, 0x0202, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0003, 0x0002 }; m_VerticalPattern.Mask = Mask; m_VerticalPattern.NumElements = NumElements; m_VerticalPattern.PatternData = (unsigned short *)malloc(NumElements * sizeof(unsigned short)); for ( int i=0; iMask = Mask; Pattern->BinningLimit = BinningLimit; Pattern->RefNumElements = RefNumElements; Pattern->SigNumElements = SigNumElements; if ( RefNumElements > 0 ) { Pattern->RefPatternData = (unsigned short *)malloc(RefNumElements * sizeof(unsigned short)); for ( i=0; iRefPatternData[i] = RefPatternData[i]; } } if ( SigNumElements > 0 ) { Pattern->SigPatternData = (unsigned short *)malloc(SigNumElements * sizeof(unsigned short)); for ( i=0; iSigPatternData[i] = SigPatternData[i]; } } if ( BinningLimit > 0 ) { for ( i=0; iBinNumElements[i] = BinNumElements[i]; Pattern->BinPatternData[i] = (unsigned short *)malloc(BinNumElements[i] * sizeof(unsigned short)); for ( j=0; jBinPatternData[i][j] = BinPatternData[i][j]; } } } } libapogee2-2.2/ApnCamData_KAI11000ML.cpp0000644000175000017500000005347011110507150015132 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_KAI11000ML.cpp: Implementation file for the CApnCamData_KAI11000ML class. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #include "ApnCamData_KAI11000ML.h" #include #include #include ///////////////////////////////////////////////////////////// // Construction/Destruction ///////////////////////////////////////////////////////////// CApnCamData_KAI11000ML::CApnCamData_KAI11000ML() { } CApnCamData_KAI11000ML::~CApnCamData_KAI11000ML() { } void CApnCamData_KAI11000ML::Initialize() { strcpy( m_Sensor, "KAI11000ML" ); strcpy( m_CameraModel, "11002ml" ); m_CameraId = 67; m_InterlineCCD = true; m_SupportsSerialA = true; m_SupportsSerialB = true; m_SensorTypeCCD = true; m_TotalColumns = 4080; m_ImagingColumns = 4008; m_ClampColumns = 36; m_PreRoiSkipColumns = 0; m_PostRoiSkipColumns = 0; m_OverscanColumns = 36; m_TotalRows = 2720; m_ImagingRows = 2672; m_UnderscanRows = 24; m_OverscanRows = 24; m_VFlushBinning = 1; m_EnableSingleRowOffset = false; m_RowOffsetBinning = 1; m_HFlushDisable = false; m_ShutterCloseDelay = 0; m_PixelSizeX = 9; m_PixelSizeY = 9; m_Color = false; m_ReportedGainSixteenBit = 1; m_MinSuggestedExpTime = 0.05; m_CoolingSupported = true; m_RegulatedCoolingSupported = true; m_TempSetPoint = -20.0; m_TempRampRateOne = 700; m_TempRampRateTwo = 4000; m_TempBackoffPoint = 2.0; m_PrimaryADType = ApnAdType_Alta_Sixteen; m_AlternativeADType = ApnAdType_Alta_Twelve; m_DefaultGainLeft = 150; m_DefaultOffsetLeft = 100; m_DefaultGainRight = -1; m_DefaultOffsetRight = -1; m_DefaultRVoltage = 1000; m_DefaultSpeed = 0xffff; m_DefaultDataReduction = false; set_vpattern(); set_hpattern_clamp_sixteen(); set_hpattern_skip_sixteen(); set_hpattern_roi_sixteen(); set_hpattern_clamp_twelve(); set_hpattern_skip_twelve(); set_hpattern_roi_twelve(); } void CApnCamData_KAI11000ML::set_vpattern() { const unsigned short Mask = 0x106; const unsigned short NumElements = 59; unsigned short Pattern[NumElements] = { 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0302, 0x0302, 0x0302, 0x0302, 0x0302, 0x0302, 0x0302, 0x0302, 0x0302, 0x0302, 0x0002, 0x0002, 0x0002, 0x0003, 0x0002 }; m_VerticalPattern.Mask = Mask; m_VerticalPattern.NumElements = NumElements; m_VerticalPattern.PatternData = (unsigned short *)malloc(NumElements * sizeof(unsigned short)); for ( int i=0; iMask = Mask; Pattern->BinningLimit = BinningLimit; Pattern->RefNumElements = RefNumElements; Pattern->SigNumElements = SigNumElements; if ( RefNumElements > 0 ) { Pattern->RefPatternData = (unsigned short *)malloc(RefNumElements * sizeof(unsigned short)); for ( i=0; iRefPatternData[i] = RefPatternData[i]; } } if ( SigNumElements > 0 ) { Pattern->SigPatternData = (unsigned short *)malloc(SigNumElements * sizeof(unsigned short)); for ( i=0; iSigPatternData[i] = SigPatternData[i]; } } if ( BinningLimit > 0 ) { for ( i=0; iBinNumElements[i] = BinNumElements[i]; Pattern->BinPatternData[i] = (unsigned short *)malloc(BinNumElements[i] * sizeof(unsigned short)); for ( j=0; jBinPatternData[i][j] = BinPatternData[i][j]; } } } } libapogee2-2.2/test_apogee.cpp0000644000175000017500000007516411110507150014205 0ustar jrjr/* Program : test_apogee.cpp * Version : 1.2 * Author : Dave Mills * Copyright : The Random Factory 2004 * License : GPL * * * This program provides a limited test environment for Apogee PCI/ISA/PPort * series cameras. It utilises the same low-level API provided by the * apogee_PCI.so , apogee_ISA.so, and apogee_PPI.so shared object libraries. * * To build for ISA interface models * g++ -I/opt/apogee/include test_apogee.cpp \ CameraIO_Linux.o CameraIO_LinuxISA.o \ -o test_apogeeisa -DAPOGEE_ISA \ -L/opt/apogee/lib -ltcl8.3 -lccd -lfitsTcl * To build for PCI interface models * g++ -I/opt/apogee/include test_apogee.cpp \ CameraIO_Linux.o CameraIO_LinuxPCI.o \ -o test_apogeepci -DAPOGEE_PCI \ -L/opt/apogee/lib -ltcl8.3 -lccd -lfitsTcl * To build for Parallel Port interface models * g++ -I/opt/apogee/include test_apogee.cpp \ CameraIO_Linux.o CameraIO_LinuxPPI.o \ -o test_apogeeppi -DAPOGEE_PPI \ -L/opt/apogee/lib -ltcl8.3 -lccd -lfitsTcl * * The program is controlled by a set of command line options * Usage information is obtained by invoking the program with -h * * eg ./alta_testppi -h * * Functions provided include full frame, subregion, binning, image sequences, * and cooling control. * * Caveats : There is limited error checking on the input options, if you * hang the camera onboard software, simply power cycle the * camera. */ #include #include #include #include "fitsio.h" #include #include #include #include #include #include "tcl.h" #include "CameraIO_Linux.h" #include "ccd.h" int parse_options (int argc, char **argv); int saveimage(unsigned short *src_buffer, char *filename, short nx, short ny); int dobiassubtract(unsigned short *src,unsigned short *dest, int nx, int ny); /* Declare the camera object. All camera functions and parameters are * accessed using the methods and instance variables of this object * * Their declarations can be found in CameraIO_Linux.h */ CCameraIO *cam; /* Declare globals to store the input command line options */ char imagename[256]; char cfgname[256]; double exposure=1.0; int shutter=1; int ip[4]={0,0,0,0}; int xbin=1; int ybin=1; int xstart=0; int xend=0; int ystart=0; int yend=0; int biascols=0; int bcols=0; int fanmode=0; double cooling=99.0; int numexp=1; int ipause=0; int verbose=0; /* Error codes returned from config_load */ const long CCD_OPEN_NOERR = 0; // No error detected const long CCD_OPEN_CFGNAME = 1; // No config file specified const long CCD_OPEN_CFGDATA = 2; // Config missing or missing required data const long CCD_OPEN_LOOPTST = 3; // Loopback test failed, no camera found const long CCD_OPEN_ALLOC = 4; // Memory alloc failed - system error long config_load( char* cfgname, short BaseAddress, short RegOffset ); bool CfgGet ( FILE* inifp, char* inisect, char* iniparm, char* retbuff, short bufflen, short* parmlen); unsigned short hextoi(char* instr); void trimstr(char* s); #define MAXCOLUMNS 16383 #define MAXROWS 16383 #define MAXTOTALCOLUMNS 16383 #define MAXTOTALROWS 16383 #define MAXHBIN 8 #define MAXVBIN 64 /* Bias definitions used in the libccd functions */ extern int bias_start, bias_end, bcols; /* Functions from libccd, provide simple named image buffer management */ typedef void *PDATA; #define MAX_CCD_BUFFERS 1000 PDATA CCD_locate_buffer(char *name, int idepth, short imgcols, short imgrows, short hbin, short vbin); int CCD_free_buffer(); int CCD_locate_buffernum(char *name); typedef struct { unsigned short *pixels; int size; short xdim; short ydim; short zdim; short xbin; short ybin; short type; char name[64]; int shmid; size_t shmsize; char *shmem; } CCD_FRAME; CCD_FRAME CCD_Frame[MAX_CCD_BUFFERS]; extern int CCD_free_buffer(char *name); /* Main executable starts here -----------------------------------------------*/ int main (int argc, char **argv) { int status; unsigned short *image; int bnum,i; int nx,ny; int iexposure; unsigned int ipaddr; double t; char seqname[256]; /* Default the bias to no-bias-subtraction */ bias_start = 0; bias_end = 0; bcols = 0; /* Obtain user provided options */ status = parse_options(argc,argv); /* Parse camera configuration file */ long ret = config_load( cfgname, -1, -1 ); if ( ret != 0 ) { switch ( ret ) { case CCD_OPEN_CFGNAME: printf("No config file specified.\n"); break; case CCD_OPEN_CFGDATA: printf("Config file missing or missing required data.\n"); break; case CCD_OPEN_LOOPTST: printf("Loopback test failed, no camera found\n"); break; case CCD_OPEN_ALLOC: printf("Memory allocation failed - system error\n"); break; } exit(1); } /* Assume only 1 camera, and it is number 0 */ cam->InitDriver(0); /* Do a system reset to ensure known state, flushing enabled etc */ cam->Reset(); /* Parse config file for camera parameters */ cam->Flush(); /* If bias subtraction requested, set it up */ if (biascols != 0) { bcols = biascols; bias_start = 1; bias_end = biascols; cam->m_BIC = cam->m_BIC-biascols; } /* Setup binning, defaults to full frame */ i = 0; cam->m_BinX = xbin; cam->m_BinY = ybin; /* Set up a region of interest, defaults to full frame */ if (xstart > 0) { cam->m_StartX = xstart; cam->m_StartY = ystart; cam->m_NumX = (xend-xstart+1); cam->m_NumY = (yend-ystart+1); } /* If a particular CCD temperature was requested, then enable cooling and set the correct setpoint value */ if (cooling < 99.0) { printf("Waiting for requested temperature of %6.1lf \r",cooling); fflush(NULL); cam->write_CoolerMode(0); cam->write_CoolerMode(1); cam->write_CoolerSetPoint(cooling); t = cam->read_Temperature(); /* Then loop until we get within 0.2 degrees, about the best we can hope for */ while (fabs(t-cooling) > 0.2) { printf("Waiting for requested temperature of %6.1lf, current value is %6.1lf \r",cooling,t); fflush(NULL); sleep(1); t = cam->read_CoolerStatus(); t = cam->read_Temperature(); } printf("\nTemperature is now %6.1lf, starting exposure(s)\n",t); } /* Add a second to ensure readout will be complete when we try to read */ iexposure = (int)exposure+1; /* Loop until all exposures completed */ while ( i < numexp ) { /* Start an exposure */ status = cam->Expose(exposure,shutter); /* Wait until done, we could continously poll the camera here instead */ sleep(iexposure); /* Readout the image and save in a named buffer (tempobs) */ status = cam->BufferImage("tempobs"); /* Use the libccd routine to find the corresponding buffer index */ bnum = CCD_locate_buffernum("tempobs"); /* Print details about the buffer for debug purposes */ printf("Buffer %4d %s = %d bytes cols=%d rows=%d depth=%d\n",bnum,CCD_Frame[bnum].name, CCD_Frame[bnum].size,CCD_Frame[bnum].xdim,CCD_Frame[bnum].ydim,CCD_Frame[bnum].zdim); /* Obtain the memory address of the actual image data, and x,y dimensions */ image = CCD_Frame[bnum].pixels; nx = CCD_Frame[bnum].xdim; ny = CCD_Frame[bnum].ydim; /* If this is part of a sequence, prefix image name with the number */ if (numexp > 1) { sprintf(seqname,"%d_%s",i,imagename); printf("Saving image as %s\n",seqname); saveimage(image, seqname, nx, ny); } else { printf("Saving image as %s\n",imagename); saveimage(image, imagename, nx, ny); } /* Wait requested interval between exposures (default is 0) */ sleep(ipause); i++; } /* All done, tidy up */ } /* Helper routines start here-------------------------------------------------*/ /* This routine provides a very simple command line parser * Unknown options should be ignored, but strict type * checking is NOT done. */ int parse_options (int argc, char **argv) { int i; int goti,gott,gots; char *hdir; /* Zero out counters for required options */ goti=0; gott=0; gots=0; i=1; /* Default fanmode to medium */ fanmode = 2; /* Default location of config file is users home directory */ hdir = getenv("HOME"); sprintf(cfgname,"%s/.apccd.ini",hdir); /* Loop thru all provided options */ while (i 0) { printf("Apogee CCD image test - V1.2\n"); printf(" Image name is %s\n",imagename); printf(" Exposure time is %lf\n",exposure); if (numexp > 1) printf(" Sequence of %d exposures requested\n",numexp); if (ipause > 0.0) printf(" Pause of %d seconds between exposures\n",ipause); printf(" Shutter state during exposure will be %d\n",shutter); if (xbin > 1) printf(" X binning selected xbin=%d\n",xbin); if (ybin > 1) printf(" Y binning selected ybin=%d\n",ybin); if (xstart != 0) printf(" Subregion readout %d,%d,%d,%d\n",xstart,xend,ystart,yend); if (biascols != 0) printf(" Bias subtraction using %d columns\n",biascols); if (cooling < 99.0) printf(" Requested ccd temperature for exposure is %lf\n",cooling); } return(0); } /* This routine provides simple FITS writer. It uses the routines * provided by the fitsTcl/cfitsio libraries * * NOTE : It will fail if the image already exists */ int saveimage(unsigned short *src_buffer, char *filename, short nx, short ny) { fitsfile *fptr; /* pointer to the FITS file, defined in fitsio.h */ long fpixel, nelements; unsigned short *array; unsigned short *simg; int status; /* initialize FITS image parameters */ int bitpix = USHORT_IMG; /* 16-bit unsigned short pixel values */ long naxis = 2; /* 2-dimensional image */ long naxes[2]; naxes[0] = nx-bcols; naxes[1] = ny; array = src_buffer; status = 0; /* initialize status before calling fitsio routines */ simg = (unsigned short *)CCD_locate_buffer("stemp",2,nx-bcols,ny,1,1); if (fits_create_file(&fptr, filename, &status)) /* create new FITS file */ printerror( status ); /* call printerror if error occurs */ /* write the required keywords for the primary array image. */ /* Since bitpix = USHORT_IMG, this will cause cfitsio to create */ /* a FITS image with BITPIX = 16 (signed short integers) with */ /* BSCALE = 1.0 and BZERO = 32768. This is the convention that */ /* FITS uses to store unsigned integers. Note that the BSCALE */ /* and BZERO keywords will be automatically written by cfitsio */ /* in this case. */ if ( fits_create_img(fptr, bitpix, naxis, naxes, &status) ) printerror( status ); fpixel = 1; /* first pixel to write */ nelements = naxes[0] * naxes[1]; /* number of pixels to write */ dobiassubtract(src_buffer,simg,naxes[0],naxes[1]); /* write the array of unsigned integers to the FITS file */ if ( fits_write_img(fptr, TUSHORT, fpixel, nelements, simg, &status) ) printerror( status ); if ( fits_close_file(fptr, &status) ) /* close the file */ printerror( status ); return(status); } /* This routine should do bias subtraction. * src is the input image with bias columns * dest is a smaller output image with the bias columns trimmed off * and the "bias" subtracted from the image pixels. */ int dobiassubtract(unsigned short *src,unsigned short *dest, int nx, int ny) { double biases[8192]; double abiases; int ix,iy, oix; int ipix, opix; unsigned short minbias; minbias = 65535; if (bcols == 0) { for (iy=0;iy bias_end) { ipix = (nx+bcols)*iy + ix; opix = nx*iy + oix; if (src[ipix] < minbias) { dest[opix] = 0; } else { dest[opix] = src[ipix] - (int)biases[iy]; } oix++; } } } return(0); } // Convert a string to a decimal or hexadecimal integer unsigned short hextoi(char *instr) { unsigned short val, tot = 0; bool IsHEX = false; long n = strlen( instr ); if ( n > 1 ) { // Look for hex format e.g. 8Fh, A3H or 0x5D if ( instr[ n - 1 ] == 'h' || instr[ n - 1 ] == 'H' ) IsHEX = true; else if ( *instr == '0' && *(instr+1) == 'x' ) { IsHEX = true; instr += 2; } } if ( IsHEX ) { while (instr && *instr && isxdigit(*instr)) { val = *instr++ - '0'; if (9 < val) val -= 7; tot <<= 4; tot |= (val & 0x0f); } } else tot = atoi( instr ); return tot; } // Trim trailing spaces from a string void trimstr(char *s) { char *p; p = s + (strlen(s) - 1); while (isspace(*p)) p--; *(++p) = '\0'; } //------------------------------------------------------------- // CfgGet // // Retrieve a parameter from an INI file. Returns a status code // and the paramter string in retbuff. //------------------------------------------------------------- bool CfgGet ( FILE* inifp, char *inisect, char *iniparm, char *retbuff, short bufflen, short *parmlen) { short gotsect; char tbuf[256]; char *ss, *eq, *ps, *vs, *ptr; rewind( inifp ); // find the target section gotsect = 0; while (fgets(tbuf,256,inifp) != NULL) { if ((ss = strchr(tbuf,'[')) != NULL) { if (strncasecmp(ss+1,inisect,strlen(inisect)) == 0) { gotsect = 1; break; } } } if (!gotsect) { // section not found return false; } while (fgets(tbuf,256,inifp) != NULL) { // find parameter in sect if ((ptr = strrchr(tbuf,'\n')) != NULL) // remove newline if there *ptr = '\0'; ps = tbuf+strspn(tbuf," \t"); // find the first non-blank if (*ps == ';') // Skip line if comment continue; if (*ps == '[') { // Start of next section return false; } eq = strchr(ps,'='); // Find '=' sign in string if (eq) vs = eq + 1 + strspn(eq+1," \t"); // Find start of value str else continue; // found the target parameter if (strncasecmp(ps,iniparm,strlen(iniparm)) == 0) { if ((ptr = strchr(vs,';')) != NULL) // cut off an EOL comment *ptr = '\0'; if (short(strlen(vs)) > bufflen - 1) {// not enough buffer space strncpy(retbuff,vs,bufflen - 1); retbuff[bufflen - 1] = '\0'; // put EOL in string *parmlen = bufflen; if (verbose) printf("Configuration %s.%s = %s\n",inisect,iniparm,retbuff); return true; } else { strcpy(retbuff,vs); // got it trimstr(retbuff); // trim any trailing blanks *parmlen = strlen(retbuff); if (verbose) printf("Configuration %s.%s = %s\n",inisect,iniparm,retbuff); return true; } } } return false; // parameter not found } // Initializes internal variables to their default value and reads the parameters in the // specified INI file. Then initializes the camera using current settings. If BaseAddress // or RegOffset parameters are specified (not equal to -1) then one or both of these // values are used for the m_BaseAddress and m_RegisterOffset properties overriding those // settings in the INI file. long config_load( char* cfgname, short BaseAddress, short RegOffset ) { short plen; char retbuf[256]; int m_BaseAddress; if ((strlen(cfgname) == 0) || (cfgname[0] == '\0')) return CCD_OPEN_CFGNAME; // attempt to open INI file FILE* inifp = NULL; if ((inifp = fopen(cfgname,"r")) == NULL) return CCD_OPEN_CFGDATA; // System if (CfgGet (inifp, "system", "interface", retbuf, sizeof(retbuf), &plen)) { cam = new CCameraIO(); if ( cam == NULL ) { fclose( inifp ); return CCD_OPEN_ALLOC; } } else { fclose( inifp ); return CCD_OPEN_CFGDATA; } ///////////////////////////////////////////////////////////////////////////////// // Settings which are stored in a class member (not in firmware) are already set // to a default value in the constructor. Settings accessed by get/put functions // must be set to a default value in this routine, after the base address and // communication protocal is setup. ///////////////////////////////////////////////////////////////////////////////// // These settings must done first since they affect communication with the camera // In the Linux drivers this is taken care of by the /dev/apppi0 device file // so we just set a dummy m_BaseAddress instead if ( BaseAddress == -1 ) { if (CfgGet (inifp, "system", "base", retbuf, sizeof(retbuf), &plen)) m_BaseAddress = hextoi(retbuf) & 0xFFF; else { fclose( inifp ); delete cam; cam = NULL; return CCD_OPEN_CFGDATA; // base address MUST be defined } } else m_BaseAddress = BaseAddress & 0xFFF; if ( RegOffset == -1 ) { if (CfgGet (inifp, "system", "reg_offset", retbuf, sizeof(retbuf), &plen)) { unsigned short val = hextoi(retbuf); cam->m_RegisterOffset = val & 0xF0; } } else { if ( RegOffset >= 0x0 && RegOffset <= 0xF0 ) cam->m_RegisterOffset = RegOffset & 0xF0; } ///////////////////////////////////////////////////////////////////////////////// // Necessary geometry settings if (CfgGet (inifp, "geometry", "rows", retbuf, sizeof(retbuf), &plen)) { short val = hextoi(retbuf); if ( val >= 1 && val <= MAXTOTALROWS ) cam->m_Rows = val; } else { fclose( inifp ); delete cam; cam = NULL; return CCD_OPEN_CFGDATA; // rows MUST be defined } if (CfgGet (inifp, "geometry", "columns", retbuf, sizeof(retbuf), &plen)) { short val = hextoi(retbuf); if ( val >= 1 && val <= MAXTOTALCOLUMNS ) cam->m_Columns = val; } else { fclose( inifp ); delete cam; cam = NULL; return CCD_OPEN_CFGDATA; // columns MUST be defined } ///////////////////////////////////////////////////////////////////////////////// if (CfgGet (inifp, "system", "pp_repeat", retbuf, sizeof(retbuf), &plen)) { short val = hextoi( retbuf ); if ( val > 0 && val <= 1000 ) cam->m_PPRepeat = val; } ///////////////////////////////////////////////////////////////////////////////// // First actual communication with camera if in PPI mode if ( !cam->InitDriver(0) ) { delete cam; cam = NULL; fclose( inifp ); return CCD_OPEN_LOOPTST; } ///////////////////////////////////////////////////////////////////////////////// // First actual communication with camera if in ISA mode cam->Reset(); // Read in command register to set shadow register known state ///////////////////////////////////////////////////////////////////////////////// if (CfgGet (inifp, "system", "cable", retbuf, sizeof(retbuf), &plen)) { if (!strcmp("LONG",retbuf)) cam->write_LongCable( true ); else if ( !strcmp("SHORT",retbuf) ) cam->write_LongCable( false ); } else cam->write_LongCable( false ); // default if ( !cam->read_Present() ) { delete cam; cam = NULL; fclose( inifp ); return CCD_OPEN_LOOPTST; } ///////////////////////////////////////////////////////////////////////////////// // Set default setting and read other settings from ini file cam->write_UseTrigger( false ); cam->write_ForceShutterOpen( false ); if (CfgGet (inifp, "system", "high_priority", retbuf, sizeof(retbuf), &plen)) { if (!strcmp("ON",retbuf) || !strcmp("TRUE",retbuf) || !strcmp("1",retbuf)) { cam->m_HighPriority = true; } else if (!strcmp("OFF",retbuf) || !strcmp("FALSE",retbuf) || !strcmp("0",retbuf)) { cam->m_HighPriority = false; } } if (CfgGet (inifp, "system", "data_bits", retbuf, sizeof(retbuf), &plen)) { short val = hextoi( retbuf ); if ( val >= 8 && val <= 18 ) cam->m_DataBits = val; } if (CfgGet (inifp, "system", "sensor", retbuf, sizeof(retbuf), &plen)) { if ( strcmp( "ccd", retbuf ) == 0 ) { cam->m_SensorType = Camera_SensorType_CCD; } else if ( strcmp( "cmos", retbuf ) == 0 ) { cam->m_SensorType = Camera_SensorType_CMOS; } } if (CfgGet (inifp, "system", "mode", retbuf, sizeof(retbuf), &plen)) { unsigned short val = hextoi(retbuf) & 0xF; cam->write_Mode( val ); } else cam->write_Mode( 0 ); // default if (CfgGet (inifp, "system", "test", retbuf, sizeof(retbuf), &plen)) { unsigned short val = hextoi(retbuf) & 0xF; cam->write_TestBits( val ); } else cam->write_TestBits( 0 ); //default if (CfgGet (inifp, "system", "test2", retbuf, sizeof(retbuf), &plen)) { unsigned short val = hextoi(retbuf) & 0xF; cam->write_Test2Bits( val ); } else cam->write_Test2Bits( 0 ); // default cam->write_FastReadout( false ); //default if (CfgGet (inifp, "system", "shutter_speed", retbuf, sizeof(retbuf), &plen)) { if (!strcmp("normal",retbuf)) { cam->m_FastShutter = false; cam->m_MaxExposure = 10485.75; cam->m_MinExposure = 0.01; } else if (!strcmp("fast",retbuf)) { cam->m_FastShutter = true; cam->m_MaxExposure = 1048.575; cam->m_MinExposure = 0.001; } else if ( !strcmp("dual",retbuf)) { cam->m_FastShutter = true; cam->m_MaxExposure = 10485.75; cam->m_MinExposure = 0.001; } } if (CfgGet (inifp, "system", "shutter_bits", retbuf, sizeof(retbuf), &plen)) { unsigned short val = hextoi(retbuf); cam->m_FastShutterBits_Mode = val & 0x0F; cam->m_FastShutterBits_Test = ( val & 0xF0 ) >> 4; } if (CfgGet (inifp, "system", "maxbinx", retbuf, sizeof(retbuf), &plen)) { short val = hextoi(retbuf); if ( val >= 1 && val <= MAXHBIN ) cam->m_MaxBinX = val; } if (CfgGet (inifp, "system", "maxbiny", retbuf, sizeof(retbuf), &plen)) { short val = hextoi(retbuf); if ( val >= 1 && val <= MAXVBIN ) cam->m_MaxBinY = val; } if (CfgGet (inifp, "system", "guider_relays", retbuf, sizeof(retbuf), &plen)) { if (!strcmp("ON",retbuf) || !strcmp("TRUE",retbuf) || !strcmp("1",retbuf)) { cam->m_GuiderRelays = true; } else if (!strcmp("OFF",retbuf) || !strcmp("FALSE",retbuf) || !strcmp("0",retbuf)) { cam->m_GuiderRelays = false; } } if (CfgGet (inifp, "system", "timeout", retbuf, sizeof(retbuf), &plen)) { double val = atof(retbuf); if ( val >= 0.0 && val <= 10000.0 ) cam->m_Timeout = val; } ///////////////////////////////////////////////////////////////////////////////// // Geometry if (CfgGet (inifp, "geometry", "bic", retbuf, sizeof(retbuf), &plen)) { short val = hextoi(retbuf); if ( val >= 1 && val <= MAXCOLUMNS ) cam->m_BIC = val; } if (CfgGet (inifp, "geometry", "bir", retbuf, sizeof(retbuf), &plen)) { short val = hextoi(retbuf); if ( val >= 1 && val <= MAXROWS ) cam->m_BIR = val; } if (CfgGet (inifp, "geometry", "skipc", retbuf, sizeof(retbuf), &plen)) { short val = hextoi(retbuf); if ( val >= 0 && val <= MAXCOLUMNS ) cam->m_SkipC = val; } if (CfgGet (inifp, "geometry", "skipr", retbuf, sizeof(retbuf), &plen)) { short val = hextoi(retbuf); if ( val >= 0 && val <= MAXROWS ) cam->m_SkipR = val; } if (CfgGet (inifp, "geometry", "imgcols", retbuf, sizeof(retbuf), &plen)) { short val = hextoi(retbuf); if ( val >= 1 && val <= MAXTOTALCOLUMNS ) cam->m_ImgColumns = val; } else cam->m_ImgColumns = cam->m_Columns - cam->m_BIC - cam->m_SkipC; if (CfgGet (inifp, "geometry", "imgrows", retbuf, sizeof(retbuf), &plen)) { short val = hextoi(retbuf); if ( val >= 1 && val <= MAXTOTALROWS ) cam->m_ImgRows = val; } else cam->m_ImgRows = cam->m_Rows - cam->m_BIR - cam->m_SkipR; if (CfgGet (inifp, "geometry", "hflush", retbuf, sizeof(retbuf), &plen)) { short val = hextoi(retbuf); if ( val >= 1 && val <= MAXHBIN ) cam->m_HFlush = val; } if (CfgGet (inifp, "geometry", "vflush", retbuf, sizeof(retbuf), &plen)) { short val = hextoi(retbuf); if ( val >= 1 && val <= MAXVBIN ) cam->m_VFlush = val; } // Default to full frame cam->m_NumX = cam->m_ImgColumns; cam->m_NumY = cam->m_ImgRows; ///////////////////////////////////////////////////////////////////////////////// // Temperature if (CfgGet (inifp, "temp", "control", retbuf, sizeof(retbuf), &plen)) { if (!strcmp("ON",retbuf) || !strcmp("TRUE",retbuf) || !strcmp("1",retbuf)) { cam->m_TempControl = true; } else if (!strcmp("OFF",retbuf) || !strcmp("FALSE",retbuf) || !strcmp("0",retbuf)) { cam->m_TempControl = false; } } if (CfgGet (inifp, "temp", "cal", retbuf, sizeof(retbuf), &plen)) { short val = hextoi(retbuf); if ( val >= 1 && val <= 255 ) cam->m_TempCalibration = val; } if (CfgGet (inifp, "temp", "scale", retbuf, sizeof(retbuf), &plen)) { double val = atof(retbuf); if ( val >= 1.0 && val <= 10.0 ) cam->m_TempScale = val; } if (CfgGet (inifp, "temp", "target", retbuf, sizeof(retbuf), &plen)) { double val = atof(retbuf); if ( val >= -60.0 && val <= 40.0 ) cam->write_CoolerSetPoint( val ); else cam->write_CoolerSetPoint( -10.0 ); } else cam->write_CoolerSetPoint( -10.0 ); //default ///////////////////////////////////////////////////////////////////////////////// // CCD if (CfgGet (inifp, "ccd", "sensor", retbuf, sizeof(retbuf), &plen)) { if ( plen > 256 ) plen = 256; memcpy( cam->m_Sensor, retbuf, plen ); } if (CfgGet (inifp, "ccd", "color", retbuf, sizeof(retbuf), &plen)) { if (!strcmp("ON",retbuf) || !strcmp("TRUE",retbuf) || !strcmp("1",retbuf)) { cam->m_Color = true; } else if (!strcmp("OFF",retbuf) || !strcmp("FALSE",retbuf) || !strcmp("0",retbuf)) { cam->m_Color = false; } } if (CfgGet (inifp, "ccd", "noise", retbuf, sizeof(retbuf), &plen)) { cam->m_Noise = atof( retbuf ); } if (CfgGet (inifp, "ccd", "gain", retbuf, sizeof(retbuf), &plen)) { cam->m_Gain = atof( retbuf ); } if (CfgGet (inifp, "ccd", "pixelxsize", retbuf, sizeof(retbuf), &plen)) { cam->m_PixelXSize = atof( retbuf ); } if (CfgGet (inifp, "ccd", "pixelysize", retbuf, sizeof(retbuf), &plen)) { cam->m_PixelYSize = atof( retbuf ); } fclose( inifp ); return CCD_OPEN_NOERR; } libapogee2-2.2/ApnCamData_KAF0401EB.cpp0000644000175000017500000004414211110507150015024 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_KAF0401EB.cpp: Implementation file for the CApnCamData_KAF0401EB class. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #include "ApnCamData_KAF0401EB.h" #include #include #include ///////////////////////////////////////////////////////////// // Construction/Destruction ///////////////////////////////////////////////////////////// CApnCamData_KAF0401EB::CApnCamData_KAF0401EB() { } CApnCamData_KAF0401EB::~CApnCamData_KAF0401EB() { } void CApnCamData_KAF0401EB::Initialize() { strcpy( m_Sensor, "KAF0401EB" ); strcpy( m_CameraModel, "1" ); m_CameraId = 32; m_InterlineCCD = false; m_SupportsSerialA = true; m_SupportsSerialB = true; m_SensorTypeCCD = true; m_TotalColumns = 796; m_ImagingColumns = 768; m_ClampColumns = 14; m_PreRoiSkipColumns = 0; m_PostRoiSkipColumns = 0; m_OverscanColumns = 14; m_TotalRows = 520; m_ImagingRows = 512; m_UnderscanRows = 4; m_OverscanRows = 4; m_VFlushBinning = 1; m_EnableSingleRowOffset = false; m_RowOffsetBinning = 1; m_HFlushDisable = false; m_ShutterCloseDelay = 100; m_PixelSizeX = 9; m_PixelSizeY = 9; m_Color = false; m_ReportedGainSixteenBit = 1.5; m_MinSuggestedExpTime = 10.0; m_CoolingSupported = true; m_RegulatedCoolingSupported = true; m_TempSetPoint = -20.0; m_TempRampRateOne = 700; m_TempRampRateTwo = 4000; m_TempBackoffPoint = 2.0; m_PrimaryADType = ApnAdType_Alta_Sixteen; m_AlternativeADType = ApnAdType_Alta_Twelve; m_DefaultGainLeft = 0; m_DefaultOffsetLeft = 100; m_DefaultGainRight = -1; m_DefaultOffsetRight = -1; m_DefaultRVoltage = 1000; m_DefaultSpeed = 0xffff; m_DefaultDataReduction = false; set_vpattern(); set_hpattern_clamp_sixteen(); set_hpattern_skip_sixteen(); set_hpattern_roi_sixteen(); set_hpattern_clamp_twelve(); set_hpattern_skip_twelve(); set_hpattern_roi_twelve(); } void CApnCamData_KAF0401EB::set_vpattern() { const unsigned short Mask = 0x6; const unsigned short NumElements = 71; unsigned short Pattern[NumElements] = { 0x0000, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0001, 0x0000 }; m_VerticalPattern.Mask = Mask; m_VerticalPattern.NumElements = NumElements; m_VerticalPattern.PatternData = (unsigned short *)malloc(NumElements * sizeof(unsigned short)); for ( int i=0; iMask = Mask; Pattern->BinningLimit = BinningLimit; Pattern->RefNumElements = RefNumElements; Pattern->SigNumElements = SigNumElements; if ( RefNumElements > 0 ) { Pattern->RefPatternData = (unsigned short *)malloc(RefNumElements * sizeof(unsigned short)); for ( i=0; iRefPatternData[i] = RefPatternData[i]; } } if ( SigNumElements > 0 ) { Pattern->SigPatternData = (unsigned short *)malloc(SigNumElements * sizeof(unsigned short)); for ( i=0; iSigPatternData[i] = SigPatternData[i]; } } if ( BinningLimit > 0 ) { for ( i=0; iBinNumElements[i] = BinNumElements[i]; Pattern->BinPatternData[i] = (unsigned short *)malloc(BinNumElements[i] * sizeof(unsigned short)); for ( j=0; jBinPatternData[i][j] = BinPatternData[i][j]; } } } } libapogee2-2.2/ApnCamData_S101401107.h0000644000175000017500000000221311110507150014446 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_S101401107.h: Interface file for the CApnCamData_S101401107 class. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #if _MSC_VER > 1000 #pragma once #endif // _MSC_VER> 1000 #include "ApnCamData.h" class CApnCamData_S101401107 : public CApnCamData { public: CApnCamData_S101401107(); virtual ~CApnCamData_S101401107(); void Initialize(); private: void set_vpattern(); void set_hpattern_clamp_sixteen(); void set_hpattern_skip_sixteen(); void set_hpattern_roi_sixteen(); void set_hpattern_clamp_twelve(); void set_hpattern_skip_twelve(); void set_hpattern_roi_twelve(); void set_hpattern( APN_HPATTERN_FILE *Pattern, unsigned short Mask, unsigned short BinningLimit, unsigned short RefNumElements, unsigned short SigNumElements, unsigned short BinNumElements[], unsigned short RefPatternData[], unsigned short SigPatternData[], unsigned short BinPatternData[][APN_MAX_PATTERN_ENTRIES] ); }; libapogee2-2.2/ApnCamData_KAF6303E.h0000644000175000017500000000220111110507150014364 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_KAF6303E.h: Interface file for the CApnCamData_KAF6303E class. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #if _MSC_VER > 1000 #pragma once #endif // _MSC_VER> 1000 #include "ApnCamData.h" class CApnCamData_KAF6303E : public CApnCamData { public: CApnCamData_KAF6303E(); virtual ~CApnCamData_KAF6303E(); void Initialize(); private: void set_vpattern(); void set_hpattern_clamp_sixteen(); void set_hpattern_skip_sixteen(); void set_hpattern_roi_sixteen(); void set_hpattern_clamp_twelve(); void set_hpattern_skip_twelve(); void set_hpattern_roi_twelve(); void set_hpattern( APN_HPATTERN_FILE *Pattern, unsigned short Mask, unsigned short BinningLimit, unsigned short RefNumElements, unsigned short SigNumElements, unsigned short BinNumElements[], unsigned short RefPatternData[], unsigned short SigPatternData[], unsigned short BinPatternData[][APN_MAX_PATTERN_ENTRIES] ); }; libapogee2-2.2/ApnCamData_KAI2020C.cpp0000644000175000017500000005277511110507150014735 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_KAI2020C.cpp: Implementation file for the CApnCamData_KAI2020C class. // // Copyright (c) 2003, 2004 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #include "ApnCamData_KAI2020C.h" #include #include #include ///////////////////////////////////////////////////////////// // Construction/Destruction ///////////////////////////////////////////////////////////// CApnCamData_KAI2020C::CApnCamData_KAI2020C() { } CApnCamData_KAI2020C::~CApnCamData_KAI2020C() { } void CApnCamData_KAI2020C::Initialize() { strcpy( m_Sensor, "KAI2020C" ); strcpy( m_CameraModel, "2020c" ); m_CameraId = 84; m_InterlineCCD = true; m_SupportsSerialA = true; m_SupportsSerialB = true; m_SensorTypeCCD = true; m_TotalColumns = 1648; m_ImagingColumns = 1600; m_ClampColumns = 24; m_PreRoiSkipColumns = 0; m_PostRoiSkipColumns = 0; m_OverscanColumns = 24; m_TotalRows = 1214; m_ImagingRows = 1200; m_UnderscanRows = 6; m_OverscanRows = 8; m_VFlushBinning = 1; m_EnableSingleRowOffset = false; m_RowOffsetBinning = 1; m_HFlushDisable = false; m_ShutterCloseDelay = 0; m_PixelSizeX = 7.4; m_PixelSizeY = 7.4; m_Color = true; m_ReportedGainSixteenBit = 1; m_MinSuggestedExpTime = 0.05; m_CoolingSupported = true; m_RegulatedCoolingSupported = true; m_TempSetPoint = -20.0; m_TempRampRateOne = 700; m_TempRampRateTwo = 4000; m_TempBackoffPoint = 2.0; m_PrimaryADType = ApnAdType_Alta_Sixteen; m_AlternativeADType = ApnAdType_Alta_Twelve; //m_DefaultGainTwelveBit = 0; //m_DefaultOffsetTwelveBit = 100; m_DefaultRVoltage = 1000; set_vpattern(); set_hpattern_clamp_sixteen(); set_hpattern_skip_sixteen(); set_hpattern_roi_sixteen(); set_hpattern_clamp_twelve(); set_hpattern_skip_twelve(); set_hpattern_roi_twelve(); } void CApnCamData_KAI2020C::set_vpattern() { const unsigned short Mask = 0x106; const unsigned short NumElements = 38; unsigned short Pattern[NumElements] = { 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0302, 0x0302, 0x0302, 0x0302, 0x0302, 0x0302, 0x0302, 0x0302, 0x0302, 0x0302, 0x0002, 0x0002, 0x0002, 0x0003, 0x0002 }; m_VerticalPattern.Mask = Mask; m_VerticalPattern.NumElements = NumElements; m_VerticalPattern.PatternData = (unsigned short *)malloc(NumElements * sizeof(unsigned short)); for ( int i=0; iMask = Mask; Pattern->BinningLimit = BinningLimit; Pattern->RefNumElements = RefNumElements; Pattern->SigNumElements = SigNumElements; if ( RefNumElements > 0 ) { Pattern->RefPatternData = (unsigned short *)malloc(RefNumElements * sizeof(unsigned short)); for ( i=0; iRefPatternData[i] = RefPatternData[i]; } } if ( SigNumElements > 0 ) { Pattern->SigPatternData = (unsigned short *)malloc(SigNumElements * sizeof(unsigned short)); for ( i=0; iSigPatternData[i] = SigPatternData[i]; } } if ( BinningLimit > 0 ) { for ( i=0; iBinNumElements[i] = BinNumElements[i]; Pattern->BinPatternData[i] = (unsigned short *)malloc(BinNumElements[i] * sizeof(unsigned short)); for ( j=0; jBinPatternData[i][j] = BinPatternData[i][j]; } } } } libapogee2-2.2/README0000644000175000017500000000155211110507150012050 0ustar jrjrApogee CCD Library ================== This archive contains the standalone version of the Apogee ALTA device drivers for Linux. In order to use this library you will need to provide code to allocate memory for the image data, and routines to save the images to disk, and/or display them. A more fully featured driver package is available from http://www.randomfactory.com/downloads. This package is primarily intended for developers wishing to add ALTA camera control options to other packages (e.g. Kstars/INDI), the library includes a set of INDI compatible. entry points, the ApnGlue??? routines. Dependencies ============ The code requires the standard GNU gcc build tools. Both C and C++ compilers are needed. External dependencies include the libcurl package (ALTA-E model cameras), and libusb (ALTA-U model cameras). Installation ============ See INSTALL libapogee2-2.2/ApnCamData_CCD4710.h0000644000175000017500000000217411110507150014260 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_CCD4710.h: Interface file for the CApnCamData_CCD4710 class. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #if _MSC_VER > 1000 #pragma once #endif // _MSC_VER> 1000 #include "ApnCamData.h" class CApnCamData_CCD4710 : public CApnCamData { public: CApnCamData_CCD4710(); virtual ~CApnCamData_CCD4710(); void Initialize(); private: void set_vpattern(); void set_hpattern_clamp_sixteen(); void set_hpattern_skip_sixteen(); void set_hpattern_roi_sixteen(); void set_hpattern_clamp_twelve(); void set_hpattern_skip_twelve(); void set_hpattern_roi_twelve(); void set_hpattern( APN_HPATTERN_FILE *Pattern, unsigned short Mask, unsigned short BinningLimit, unsigned short RefNumElements, unsigned short SigNumElements, unsigned short BinNumElements[], unsigned short RefPatternData[], unsigned short SigPatternData[], unsigned short BinPatternData[][APN_MAX_PATTERN_ENTRIES] ); }; libapogee2-2.2/ApnCamData_KAI4020CL.cpp0000644000175000017500000005316611110507150015046 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_KAI4020CL.cpp: Implementation file for the CApnCamData_KAI4020CL class. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #include "ApnCamData_KAI4020CL.h" #include #include #include ///////////////////////////////////////////////////////////// // Construction/Destruction ///////////////////////////////////////////////////////////// CApnCamData_KAI4020CL::CApnCamData_KAI4020CL() { } CApnCamData_KAI4020CL::~CApnCamData_KAI4020CL() { } void CApnCamData_KAI4020CL::Initialize() { strcpy( m_Sensor, "KAI4020CL" ); strcpy( m_CameraModel, "4020cl" ); m_CameraId = 69; m_InterlineCCD = true; m_SupportsSerialA = true; m_SupportsSerialB = true; m_SensorTypeCCD = true; m_TotalColumns = 2136; m_ImagingColumns = 2048; m_ClampColumns = 44; m_PreRoiSkipColumns = 0; m_PostRoiSkipColumns = 0; m_OverscanColumns = 44; m_TotalRows = 2072; m_ImagingRows = 2048; m_UnderscanRows = 16; m_OverscanRows = 8; m_VFlushBinning = 1; m_EnableSingleRowOffset = false; m_RowOffsetBinning = 1; m_HFlushDisable = false; m_ShutterCloseDelay = 0; m_PixelSizeX = 7.4; m_PixelSizeY = 7.4; m_Color = true; m_ReportedGainSixteenBit = 1; m_MinSuggestedExpTime = 0.05; m_CoolingSupported = true; m_RegulatedCoolingSupported = true; m_TempSetPoint = -20.0; m_TempRampRateOne = 700; m_TempRampRateTwo = 4000; m_TempBackoffPoint = 2.0; m_PrimaryADType = ApnAdType_Alta_Sixteen; m_AlternativeADType = ApnAdType_Alta_Twelve; m_DefaultGainLeft = 0; m_DefaultOffsetLeft = 100; m_DefaultGainRight = -1; m_DefaultOffsetRight = -1; m_DefaultRVoltage = 1000; m_DefaultSpeed = 0xffff; m_DefaultDataReduction = false; set_vpattern(); set_hpattern_clamp_sixteen(); set_hpattern_skip_sixteen(); set_hpattern_roi_sixteen(); set_hpattern_clamp_twelve(); set_hpattern_skip_twelve(); set_hpattern_roi_twelve(); } void CApnCamData_KAI4020CL::set_vpattern() { const unsigned short Mask = 0x106; const unsigned short NumElements = 38; unsigned short Pattern[NumElements] = { 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0302, 0x0302, 0x0302, 0x0302, 0x0302, 0x0302, 0x0302, 0x0302, 0x0302, 0x0302, 0x0002, 0x0002, 0x0002, 0x0003, 0x0002 }; m_VerticalPattern.Mask = Mask; m_VerticalPattern.NumElements = NumElements; m_VerticalPattern.PatternData = (unsigned short *)malloc(NumElements * sizeof(unsigned short)); for ( int i=0; iMask = Mask; Pattern->BinningLimit = BinningLimit; Pattern->RefNumElements = RefNumElements; Pattern->SigNumElements = SigNumElements; if ( RefNumElements > 0 ) { Pattern->RefPatternData = (unsigned short *)malloc(RefNumElements * sizeof(unsigned short)); for ( i=0; iRefPatternData[i] = RefPatternData[i]; } } if ( SigNumElements > 0 ) { Pattern->SigPatternData = (unsigned short *)malloc(SigNumElements * sizeof(unsigned short)); for ( i=0; iSigPatternData[i] = SigPatternData[i]; } } if ( BinningLimit > 0 ) { for ( i=0; iBinNumElements[i] = BinNumElements[i]; Pattern->BinPatternData[i] = (unsigned short *)malloc(BinNumElements[i] * sizeof(unsigned short)); for ( j=0; jBinPatternData[i][j] = BinPatternData[i][j]; } } } } libapogee2-2.2/ApnCamData_KAF16801E.h0000644000175000017500000000220611110507150014455 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_KAF16801E.h: Interface file for the CApnCamData_KAF16801E class. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #if _MSC_VER > 1000 #pragma once #endif // _MSC_VER> 1000 #include "ApnCamData.h" class CApnCamData_KAF16801E : public CApnCamData { public: CApnCamData_KAF16801E(); virtual ~CApnCamData_KAF16801E(); void Initialize(); private: void set_vpattern(); void set_hpattern_clamp_sixteen(); void set_hpattern_skip_sixteen(); void set_hpattern_roi_sixteen(); void set_hpattern_clamp_twelve(); void set_hpattern_skip_twelve(); void set_hpattern_roi_twelve(); void set_hpattern( APN_HPATTERN_FILE *Pattern, unsigned short Mask, unsigned short BinningLimit, unsigned short RefNumElements, unsigned short SigNumElements, unsigned short BinNumElements[], unsigned short RefPatternData[], unsigned short SigPatternData[], unsigned short BinPatternData[][APN_MAX_PATTERN_ENTRIES] ); }; libapogee2-2.2/ApnCamData_KAI2020M.h0000644000175000017500000000221211110507150014371 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_KAI2020M.h: Interface file for the CApnCamData_KAI2020M class. // // Copyright (c) 2003, 2004 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #if _MSC_VER > 1000 #pragma once #endif // _MSC_VER> 1000 #include "ApnCamData.h" class CApnCamData_KAI2020M : public CApnCamData { public: CApnCamData_KAI2020M(); virtual ~CApnCamData_KAI2020M(); void Initialize(); private: void set_vpattern(); void set_hpattern_clamp_sixteen(); void set_hpattern_skip_sixteen(); void set_hpattern_roi_sixteen(); void set_hpattern_clamp_twelve(); void set_hpattern_skip_twelve(); void set_hpattern_roi_twelve(); void set_hpattern( APN_HPATTERN_FILE *Pattern, unsigned short Mask, unsigned short BinningLimit, unsigned short RefNumElements, unsigned short SigNumElements, unsigned short BinNumElements[], unsigned short RefPatternData[], unsigned short SigPatternData[], unsigned short BinPatternData[][APN_MAX_PATTERN_ENTRIES] ); }; libapogee2-2.2/ApnCamData_KAF1001E.h0000644000175000017500000000220111110507150014352 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_KAF1001E.h: Interface file for the CApnCamData_KAF1001E class. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #if _MSC_VER > 1000 #pragma once #endif // _MSC_VER> 1000 #include "ApnCamData.h" class CApnCamData_KAF1001E : public CApnCamData { public: CApnCamData_KAF1001E(); virtual ~CApnCamData_KAF1001E(); void Initialize(); private: void set_vpattern(); void set_hpattern_clamp_sixteen(); void set_hpattern_skip_sixteen(); void set_hpattern_roi_sixteen(); void set_hpattern_clamp_twelve(); void set_hpattern_skip_twelve(); void set_hpattern_roi_twelve(); void set_hpattern( APN_HPATTERN_FILE *Pattern, unsigned short Mask, unsigned short BinningLimit, unsigned short RefNumElements, unsigned short SigNumElements, unsigned short BinNumElements[], unsigned short RefPatternData[], unsigned short SigPatternData[], unsigned short BinPatternData[][APN_MAX_PATTERN_ENTRIES] ); }; libapogee2-2.2/ApnCamera.h0000644000175000017500000005355311110507150013200 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamera.h: Interface file for the CApnCamera class. // // Copyright (c) 2003-2006 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #if !defined(AFX_APNCAMERA_H__CF513996_359F_4103_BBA6_2C730AE2C301__INCLUDED_) #define AFX_APNCAMERA_H__CF513996_359F_4103_BBA6_2C730AE2C301__INCLUDED_ #if _MSC_VER > 1000 #pragma once #endif // _MSC_VER > 1000 #include "Apogee.h" #include "Apn.h" #include "FpgaRegs/FpgaRegs.h" #include "ApnCamData.h" #include "ApnCamData_KAF0261E.h" #include "ApnCamData_KAF0401E.h" #include "ApnCamData_KAF1001E.h" #include "ApnCamData_KAF1001ENS.h" #include "ApnCamData_KAF10011105.h" #include "ApnCamData_KAF1301E.h" #include "ApnCamData_KAF1602E.h" #include "ApnCamData_KAF16801E.h" #include "ApnCamData_KAF16803.h" #include "ApnCamData_KAF3200E.h" #include "ApnCamData_KAF6303E.h" #include "ApnCamData_KAF09000.h" #include "ApnCamData_KAF09000X.h" #include "ApnCamData_KAF0261EB.h" #include "ApnCamData_KAF0401EB.h" #include "ApnCamData_KAF1001EB.h" #include "ApnCamData_KAF1301EB.h" #include "ApnCamData_KAF1602EB.h" #include "ApnCamData_KAF3200EB.h" #include "ApnCamData_KAF6303EB.h" #include "ApnCamData_TH7899.h" #include "ApnCamData_S101401107.h" #include "ApnCamData_S101401109.h" #include "ApnCamData_CCD3011.h" #include "ApnCamData_CCD4240.h" #include "ApnCamData_CCD4710.h" #include "ApnCamData_CCD4710ALT.h" #include "ApnCamData_CCD4720.h" #include "ApnCamData_CCD5520.h" #include "ApnCamData_CCD5710.h" #include "ApnCamData_CCD7700.h" #include "ApnCamData_CCD3011B.h" #include "ApnCamData_CCD4240B.h" #include "ApnCamData_CCD4710B.h" #include "ApnCamData_CCD4720B.h" #include "ApnCamData_CCD5520B.h" #include "ApnCamData_CCD5710B.h" #include "ApnCamData_CCD7700B.h" #include "ApnCamData_KAI2001ML.h" #include "ApnCamData_KAI2020ML.h" #include "ApnCamData_KAI4020ML.h" #include "ApnCamData_KAI11000ML.h" #include "ApnCamData_KAI2001CL.h" #include "ApnCamData_KAI2020CL.h" #include "ApnCamData_KAI4020CL.h" #include "ApnCamData_KAI11000CL.h" #include "ApnCamData_KAI2020MLB.h" #include "ApnCamData_KAI4020MLB.h" #include "ApnCamData_KAI2020CLB.h" #include "ApnCamData_KAI4020CLB.h" #include "ApnCamData_ASCENT0402ME.h" #include "ApnCamData_ASCENT0402ME2.h" #include "ApnCamData_ASCENT0402ME3.h" #include "ApnCamData_ASCENT0402ME4.h" #include "ApnCamData_ASCENT340.h" #include "ApnCamData_ASCENT2000.h" #include "ApnCamData_ASCENT4000.h" #include "ApnCamData_ASCENT16000.h" #define CAPNCAMERA_SUCCESS 0 #define CAPNCAMERA_ERR_CONNECT 1 #define CAPNCAMERA_ERR_READ 2 #define CAPNCAMERA_ERR_WRITE 3 #define CAPNCAMERA_ERR_IMAGE 4 #define CAPNCAMERA_ERR_LINE 5 #define CAPNCAMERA_ERR_START_EXP 6 #define CAPNCAMERA_ERR_STOP_EXP 7 #define CAPNCAMERA_ERR_QUERY 8 #define CAPNCAMERA_ERR_SN 9 typedef struct _FEATURE_SUPPORT_LIST { bool bSequenceBulkDownload; } FEATURE_SUPPORT_LIST; class CApnCamera { public: CApnCamera(); ~CApnCamera(); bool GetDeviceHandle( void *hCamera, char *CameraInfo ); bool InitDriver( unsigned long CamIdA, unsigned short CamIdB, unsigned long Option ); bool SimpleInitDriver( unsigned long CamIdA, unsigned short CamIdB, unsigned long Option ); Apn_Interface GetCameraInterface(); long GetCameraSerialNumber( char *CameraSerialNumber, long *BufferLength ); long GetSystemDriverVersion( char *SystemDriverVersion, long *BufferLength ); long GetUsb8051FirmwareRev( char *FirmwareRev, long *BufferLength ); long GetUsbProductId( unsigned short *pProductId ); long GetUsbDeviceId( unsigned short *pDeviceId ); bool CloseDriver(); long PreStartExpose( unsigned short BitsPerPixel ); long PostStopExposure( bool DigitizeData ); long GetImageData( unsigned short *pImageData, unsigned short &Width, unsigned short &Height, unsigned long &Count ); long GetLineData( unsigned short *pLineBuffer, unsigned short &Size ); long Read( unsigned short reg, unsigned short& val ); long Write( unsigned short reg, unsigned short val ); long WriteMultiSRMD( unsigned short reg, unsigned short val[], unsigned short count ); long WriteMultiMRMD( unsigned short reg[], unsigned short val[], unsigned short count ); long QueryStatusRegs( unsigned short& StatusReg, unsigned short& HeatsinkTempReg, unsigned short& CcdTempReg, unsigned short& CoolerDriveReg, unsigned short& VoltageReg, unsigned short& TdiCounter, unsigned short& SequenceCounter, unsigned short& MostRecentFrame, unsigned short& ReadyFrame, unsigned short& CurrentFrame ); void SetNetworkTransferMode( Apn_NetworkMode TransferMode ); /////////////////////////////////////////////////////////////////////// // Generic Public calls for handling key camera activities /////////////////////////////////////////////////////////////////////// long InitDefaults(); bool Expose( double Duration, bool Light ); bool GetImage( unsigned short *pBuffer ); #ifndef ALTA_STANDALONE bool BufferImage(char *bufferName ); bool BufferDriftScan(char *bufferName, int delay, int rowCount, int nblock , int npipe); #endif bool StopExposure( bool DigitizeData ); bool ResetSystem(); bool ResetSystemNoFlush(); bool PauseTimer( bool PauseState ); bool GuideAbort(); bool GuideRAPlus(); bool GuideRAMinus(); bool GuideDecPlus(); bool GuideDecMinus(); bool ConvertBayerImageToRGB( unsigned short *pBayerBuffer, unsigned short *pRgbBuffer, unsigned short ImageWidth, unsigned short ImageHeight ); /////////////////////////////////////////////////////////////////////// // Public helper functions /////////////////////////////////////////////////////////////////////// bool ImageReady(); bool ImageInProgress(); void SignalImagingDone(); unsigned short GetExposurePixelsH(); unsigned short GetExposurePixelsV(); /////////////////////////////////////////////////////////////////////// // Public calls for internal state control /////////////////////////////////////////////////////////////////////// bool read_Present(); unsigned short read_FirmwareVersion(); void read_CameraModel( ); bool read_ShutterState(); bool read_DisableShutter(); void write_DisableShutter( bool DisableShutter ); bool read_ForceShutterOpen(); void write_ForceShutterOpen( bool ForceShutterOpen ); bool read_ShutterAmpControl(); void write_ShutterAmpControl( bool ShutterAmpControl ); bool read_DisableFlushCommands(); void write_DisableFlushCommands( bool DisableFlushCommands ); bool read_DisablePostExposeFlushing(); void write_DisablePostExposeFlushing( bool DisablePostExposeFlushing ); bool read_ExternalIoReadout(); void write_ExternalIoReadout( bool ExternalIoReadout ); bool read_ExternalShutter(); void write_ExternalShutter( bool ExternalShutter ); bool read_FastSequence(); void write_FastSequence( bool FastSequence ); Apn_CameraMode read_CameraMode(); void write_CameraMode( Apn_CameraMode CameraMode ); Apn_Resolution read_DataBits(); void write_DataBits( Apn_Resolution BitResolution ); Apn_Status read_ImagingStatus(); Apn_LedMode read_LedMode(); void write_LedMode( Apn_LedMode LedMode ); Apn_LedState read_LedState( unsigned short LedId ); void write_LedState( unsigned short LedId, Apn_LedState LedState ); bool read_CoolerEnable(); void write_CoolerEnable( bool CoolerEnable ); Apn_CoolerStatus read_CoolerStatus(); double read_CoolerSetPoint(); void write_CoolerSetPoint( double SetPoint ); double read_CoolerBackoffPoint(); void write_CoolerBackoffPoint( double BackoffPoint ); double read_CoolerDrive(); double read_TempCCD(); double read_TempHeatsink(); Apn_FanMode read_FanMode(); void write_FanMode( Apn_FanMode FanMode ); void write_FlushBinningV( unsigned short FlushBinningV ); unsigned short read_FlushBinningV(); unsigned short read_MaxBinningH(); unsigned short read_MaxBinningV(); void write_RoiBinningH( unsigned short RoiBinningH ); unsigned short read_RoiBinningH(); void write_RoiBinningV( unsigned short RoiBinningV ); unsigned short read_RoiBinningV(); unsigned short read_RoiPixelsH(); void write_RoiPixelsH( unsigned short RoiPixelsH ); unsigned short read_RoiPixelsV(); void write_RoiPixelsV( unsigned short RoiPixelsV ); unsigned short read_RoiStartX(); void write_RoiStartX( unsigned short RoiStartX ); unsigned short read_RoiStartY(); void write_RoiStartY( unsigned short RoiStartY ); bool read_DigitizeOverscan(); void write_DigitizeOverscan( bool DigitizeOverscan ); unsigned short read_OverscanColumns(); double read_ShutterStrobePosition(); void write_ShutterStrobePosition( double Position ); double read_ShutterStrobePeriod(); void write_ShutterStrobePeriod( double Period ); double read_ShutterCloseDelay(); void write_ShutterCloseDelay( double ShutterCloseDelay ); bool read_SequenceBulkDownload(); void write_SequenceBulkDownload( bool SequenceBulkDownload ); double read_SequenceDelay(); void write_SequenceDelay( double Delay ); bool read_VariableSequenceDelay(); void write_VariableSequenceDelay( bool VariableSequenceDelay ); unsigned short read_ImageCount(); void write_ImageCount( unsigned short Count ); unsigned short read_SequenceCounter(); bool read_ContinuousImaging(); void write_ContinuousImaging( bool ContinuousImaging ); unsigned short read_TDICounter(); unsigned short read_TDIRows(); void write_TDIRows( unsigned short TdiRows ); double read_TDIRate(); void write_TDIRate( double TdiRate ); unsigned short read_TDIBinningV(); void write_TDIBinningV( unsigned short TdiBinningV ); unsigned short read_KineticsSections(); void write_KineticsSections( unsigned short KineticsSections ); double read_KineticsShiftInterval(); void write_KineticsShiftInterval( double KineticsShiftInterval ); unsigned short read_KineticsSectionHeight(); void write_KineticsSectionHeight( unsigned short KineticsSectionHeight ); bool read_TriggerNormalEach(); void write_TriggerNormalEach( bool TriggerNormalEach ); bool read_TriggerNormalGroup(); void write_TriggerNormalGroup( bool TriggerNormalGroup ); bool read_TriggerTdiKineticsEach(); void write_TriggerTdiKineticsEach( bool TriggerTdiKineticsEach ); bool read_TriggerTdiKineticsGroup(); void write_TriggerTdiKineticsGroup( bool TriggerTdiKineticsGroup ); bool read_ExposureTriggerEach(); bool read_ExposureTriggerGroup(); bool read_ExposureExternalShutter(); unsigned short read_IoPortAssignment(); void write_IoPortAssignment( unsigned short IoPortAssignment ); unsigned short read_IoPortDirection(); void write_IoPortDirection( unsigned short IoPortDirection ); unsigned short read_IoPortData(); void write_IoPortData( unsigned short IoPortData ); unsigned short read_TwelveBitGain(); void write_TwelveBitGain( unsigned short TwelveBitGain ); unsigned short read_TwelveBitOffset(); void write_TwelveBitOffset( unsigned short TwelveBitOffset ); double read_InputVoltage(); long read_AvailableMemory(); double read_MaxExposureTime(); Apn_NetworkMode read_NetworkTransferMode(); void write_NetworkTransferMode( Apn_NetworkMode TransferMode ); double read_TestLedBrightness(); void write_TestLedBrightness( double TestLedBrightness ); Apn_Platform read_PlatformType(); unsigned short read_AscentADGainSixteenLeft(); unsigned short read_AscentADGainSixteenRight(); void write_AscentADGainSixteen( unsigned short GainValue ); unsigned short read_AscentADOffsetSixteenLeft(); unsigned short read_AscentADOffsetSixteenRight(); void write_AscentADOffsetSixteen( unsigned short OffsetValue ); unsigned short read_DigitizationSpeed(); void write_DigitizationSpeed( unsigned short DigitizationSpeed ); /* bool FilterInit( Apn_Filter FilterType ); bool FilterClose(); unsigned short read_FilterPosition(); void write_FilterPosition( unsigned short FilterPosition ); bool read_FilterReady(); unsigned short read_FilterMaxPositions(); Apn_Filter read_FilterWheelType(); void read_FilterModel( char *FilterModel, long *BufferLength ); */ bool read_DataAveraging(); void write_DataAveraging( bool DataAveraging ); bool read_DualReadout(); void write_DualReadout( bool DualReadout ); bool read_ConnectionTest(); bool read_GuideActive(); // void write_GuideActive( bool GuideActive ); double read_GuideRAPlusDuration(); void write_GuideRAPlusDuration( double GuideRAPlusDuration ); double read_GuideRAMinusDuration(); void write_GuideRAMinusDuration( double GuideRAMinusDuration ); double read_GuideDecPlusDuration(); void write_GuideDecPlusDuration( double GuideDecPlusDuration ); double read_GuideDecMinusDuration(); void write_GuideDecMinusDuration( double GuideDecMinusDuration ); Apn_BayerShift read_BayerStartPosition(); void write_BayerStartPosition( Apn_BayerShift BayerStartPosition ); /////////////////////////////////////////////////////////////////////// // Public Variable /////////////////////////////////////////////////////////////////////// CApnCamData *m_ApnSensorInfo; /* was private: */ // General helper functions long LoadVerticalPattern(); long LoadClampPattern( bool UseOppositePatterns ); long LoadSkipPattern( bool UseOppositePatterns ); long LoadRoiPattern( bool UseOppositePatterns, unsigned short Binning ); long WriteHorizontalPattern( APN_HPATTERN_FILE *Pattern, unsigned short reg, unsigned short binning ); long InitTwelveBitAD(); long InitAscentSixteenBitAD(); void UpdateGeneralStatus(); long LookupAltaCameraId( unsigned short CameraId ); long LookupAscentCameraId( unsigned short CameraId ); double CheckGuiderRelayDuration( double GuideDuration ); unsigned short CalculateGuiderRelayTimeCounts( double GuideDuration ); // Internal private variables Apn_Platform m_pvtPlatformType; bool m_pvtResetVerticalArrays; FEATURE_SUPPORT_LIST m_pvtNewFeatureSupport; // Camera imaging params unsigned short m_pvtRoiBinningH; unsigned short m_pvtRoiBinningV; unsigned short m_pvtRoiPixelsH; unsigned short m_pvtRoiPixelsV; unsigned short m_pvtRoiStartX; unsigned short m_pvtRoiStartY; // Camera state variables Apn_CameraMode m_pvtCameraMode; bool m_pvtExternalShutter; Apn_Resolution m_pvtDataBits; Apn_NetworkMode m_pvtNetworkTransferMode; Apn_BayerShift m_pvtBayerShift; bool m_pvtUseAdvancedStatus; unsigned short m_pvtCameraID; unsigned short m_pvtFirmwareVersion; unsigned short m_pvtImageCount; unsigned short m_pvtTDIRows; unsigned short m_pvtTDIBinningV; double m_pvtTDIRate; unsigned short m_pvtTDICounter; unsigned short m_pvtFlushBinningV; bool m_pvtDigitizeOverscan; bool m_pvtSequenceBulkDownload; double m_pvtSequenceDelay; unsigned short m_pvtSequenceCounter; bool m_pvtFastSequence; double m_pvtShutterStrobePosition; double m_pvtShutterStrobePeriod; double m_pvtShutterCloseDelay; unsigned short m_pvtExposurePixelsH; unsigned short m_pvtExposurePixelsV; bool m_pvtExposureTriggerGroup; bool m_pvtExposureTriggerEach; bool m_pvtExposureExternalShutter; unsigned short m_pvtTwelveBitGain; unsigned short m_pvtTwelveBitOffset; unsigned short m_pvtAscentSixteenBitGainLeft; unsigned short m_pvtAscentSixteenBitOffsetLeft; unsigned short m_pvtAscentSixteenBitGainRight; unsigned short m_pvtAscentSixteenBitOffsetRight; bool m_pvtDualReadout; Apn_LedMode m_pvtLedMode; Apn_LedState m_pvtLedStateA; Apn_LedState m_pvtLedStateB; double m_pvtTestLedBrightness; bool m_pvtCoolerEnable; Apn_FanMode m_pvtFanMode; double m_pvtCoolerBackoffPoint; Apn_CoolerStatus m_pvtCoolerStatus; Apn_Status m_pvtImagingStatus; Apn_Status m_pvtPrevImagingStatus; bool m_pvtShutterState; bool m_pvtImageInProgress; bool m_pvtImageReady; bool m_pvtTriggerNormalEach; bool m_pvtTriggerNormalGroup; bool m_pvtTriggerTdiKineticsEach; bool m_pvtTriggerTdiKineticsGroup; unsigned short m_pvtStatusReg; double m_pvtCoolerDrive; double m_pvtCurrentHeatsinkTemp; double m_pvtCurrentCcdTemp; double m_pvtInputVoltage; unsigned short m_pvtIoPortDirection; unsigned short m_pvtIoPortAssignment; long m_pvtQueryStatusRetVal; unsigned short m_pvtMostRecentFrame; unsigned short m_pvtReadyFrame; unsigned short m_pvtCurrentFrame; double m_pvtGuideRAPlusDuration; double m_pvtGuideRAMinusDuration; double m_pvtGuideDecPlusDuration; double m_pvtGuideDecMinusDuration; Apn_Filter m_pvtFilterWheelType; unsigned short m_pvtFilterMaxPositions; ////////////////////////////////////////////////// // Platform Constants ////////////////////////////////////////////////// void SetPlatformConstants(); unsigned short m_PlatformHBinningMax; unsigned short m_PlatformVBinningMax; double m_PlatformTimerResolution; double m_PlatformPeriodTimerResolution; long m_PlatformTimerOffsetCount; double m_PlatformSequenceDelayResolution; double m_PlatformSequenceDelayMaximum; double m_PlatformSequenceDelayMinimum; double m_PlatformExposureTimeMin; double m_PlatformExposureTimeMax; double m_PlatformTdiRateResolution; double m_PlatformTdiRateMin; double m_PlatformTdiRateMax; double m_PlatformTdiRateDefault; double m_PlatformVoltageResolution; double m_PlatformShutterCloseDiff; double m_PlatformStrobePositionMin; double m_PlatformStrobePositionMax; double m_PlatformStrobePositionDefault; double m_PlatformStrobePeriodMin; double m_PlatformStrobePeriodMax; double m_PlatformStrobePeriodDefault; long m_PlatformTempCounts; double m_PlatformTempKelvinScaleOffset; double m_PlatformTempSetpointMin; double m_PlatformTempSetpointMax; double m_PlatformTempHeatsinkMin; double m_PlatformTempHeatsinkMax; long m_PlatformTempSetpointZeroPoint; long m_PlatformTempHeatsinkZeroPoint; double m_PlatformTempDegreesPerBit; unsigned short m_PlatformFanSpeedOff; unsigned short m_PlatformFanSpeedLow; unsigned short m_PlatformFanSpeedMedium; unsigned short m_PlatformFanSpeedHigh; double m_PlatformGuiderRelayResolution; double m_PlatformGuiderRelayMin; double m_PlatformGuiderRelayMax; double m_PlatformGuiderRelayOpenTime; double m_PlatformGuiderRelayCloseTime; //////////////////////////////////////////////////////////////////////// // Cached variables for the Expose() method // double m_pvtCacheDuration; // unsigned short m_pvtCacheDataBits; // unsigned short m_pvtCacheRoiPixelsH, m_pvtCacheRoiPixelsV; // unsigned short m_pvtCacheRoiStartX, m_pvtCacheRoiStartY; // unsigned short m_pvtCacheRoiBinningH, m_pvtCacheRoiBinningV; /* added USB/NET specifics */ int m_pvtConnectionOpen; char m_SysDeviceName[80]; int m_CamIdA; int m_CamIdB; int m_Option; int m_SysImgSizeBytes; unsigned short m_pvtVendorId; unsigned short m_pvtProductId; unsigned short m_pvtDeviceId; double m_SysDriverVersion; unsigned short m_pvtSequenceImagesDownloaded ; unsigned short m_pvtNumImages; unsigned short m_pvtTdiLinesDownloaded; char m_HostAddr[80]; unsigned int m_ImageSizeBytes; bool m_ImageInProgress; bool m_FastDownload; unsigned short m_pvtExposeWidth; unsigned short m_pvtExposeHeight; bool m_pvtExposeExternalShutter; unsigned short m_pvtExposeCameraMode; bool m_pvtExposeSequenceBulkDownload; bool m_pvtExposeCI; int m_pvtExposeHBinning; unsigned short m_pvtExposeBitsPerPixel; unsigned short m_pvtBitsPerPixel; bool m_pvtExposeDualReadout; /* added sensor data mirrors */ bool sensorInfo(); char m_Sensor[20]; char m_CameraModel[20]; unsigned short m_CameraId; bool m_InterlineCCD; bool m_SupportsSerialA; bool m_SupportsSerialB; bool m_SensorTypeCCD; unsigned short m_TotalColumns; unsigned short m_ImagingColumns; unsigned short m_ClampColumns; unsigned short m_PreRoiSkipColumns; unsigned short m_PostRoiSkipColumns; unsigned short m_OverscanColumns; unsigned short m_TotalRows; unsigned short m_ImagingRows; unsigned short m_UnderscanRows; unsigned short m_OverscanRows; unsigned short m_VFlushBinning; bool m_HFlushDisable; unsigned short m_ShutterCloseDelay; double m_PixelSizeX; double m_PixelSizeY; bool m_Color; // double m_ReportedGainTwelveBit; double m_ReportedGainSixteenBit; double m_MinSuggestedExpTime; // unsigned short m_TempRegRate; unsigned short m_TempRampRateOne; unsigned short m_TempRampRateTwo; // unsigned short m_DefaultGainTwelveBit; // unsigned short m_DefaultOffsetTwelveBit; // unsigned short m_DefaultRVoltage; }; #endif // !defined(AFX_APNCAMERA_H__CF513996_359F_4103_BBA6_2C730AE2C301__INCLUDED_) libapogee2-2.2/ApnCamData_CCD3011B.cpp0000644000175000017500000004404011110507150014704 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_CCD3011B.cpp: Implementation file for the CApnCamData_CCD3011B class. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #include "ApnCamData_CCD3011B.h" #include #include #include ///////////////////////////////////////////////////////////// // Construction/Destruction ///////////////////////////////////////////////////////////// CApnCamData_CCD3011B::CApnCamData_CCD3011B() { } CApnCamData_CCD3011B::~CApnCamData_CCD3011B() { } void CApnCamData_CCD3011B::Initialize() { strcpy( m_Sensor, "CCD3011B" ); strcpy( m_CameraModel, "30" ); m_CameraId = 17; m_InterlineCCD = false; m_SupportsSerialA = true; m_SupportsSerialB = true; m_SensorTypeCCD = true; m_TotalColumns = 1040; m_ImagingColumns = 1024; m_ClampColumns = 8; m_PreRoiSkipColumns = 0; m_PostRoiSkipColumns = 0; m_OverscanColumns = 8; m_TotalRows = 256; m_ImagingRows = 256; m_UnderscanRows = 0; m_OverscanRows = 0; m_VFlushBinning = 1; m_EnableSingleRowOffset = false; m_RowOffsetBinning = 1; m_HFlushDisable = false; m_ShutterCloseDelay = 300; m_PixelSizeX = 26; m_PixelSizeY = 26; m_Color = false; m_ReportedGainSixteenBit = 2; m_MinSuggestedExpTime = 20.0; m_CoolingSupported = true; m_RegulatedCoolingSupported = true; m_TempSetPoint = -20.0; m_TempRampRateOne = 700; m_TempRampRateTwo = 4000; m_TempBackoffPoint = 2.0; m_PrimaryADType = ApnAdType_Alta_Sixteen; m_AlternativeADType = ApnAdType_Alta_Twelve; m_DefaultGainLeft = 400; m_DefaultOffsetLeft = 200; m_DefaultGainRight = -1; m_DefaultOffsetRight = -1; m_DefaultRVoltage = 1000; m_DefaultSpeed = 0xffff; m_DefaultDataReduction = false; set_vpattern(); set_hpattern_clamp_sixteen(); set_hpattern_skip_sixteen(); set_hpattern_roi_sixteen(); set_hpattern_clamp_twelve(); set_hpattern_skip_twelve(); set_hpattern_roi_twelve(); } void CApnCamData_CCD3011B::set_vpattern() { const unsigned short Mask = 0xE; const unsigned short NumElements = 247; unsigned short Pattern[NumElements] = { 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x000A, 0x000A, 0x000A, 0x000A, 0x000A, 0x000A, 0x000A, 0x000A, 0x000A, 0x000A, 0x000A, 0x000A, 0x000A, 0x000A, 0x000A, 0x000A, 0x000A, 0x000A, 0x000A, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0001, 0x0000 }; m_VerticalPattern.Mask = Mask; m_VerticalPattern.NumElements = NumElements; m_VerticalPattern.PatternData = (unsigned short *)malloc(NumElements * sizeof(unsigned short)); for ( int i=0; iMask = Mask; Pattern->BinningLimit = BinningLimit; Pattern->RefNumElements = RefNumElements; Pattern->SigNumElements = SigNumElements; if ( RefNumElements > 0 ) { Pattern->RefPatternData = (unsigned short *)malloc(RefNumElements * sizeof(unsigned short)); for ( i=0; iRefPatternData[i] = RefPatternData[i]; } } if ( SigNumElements > 0 ) { Pattern->SigPatternData = (unsigned short *)malloc(SigNumElements * sizeof(unsigned short)); for ( i=0; iSigPatternData[i] = SigPatternData[i]; } } if ( BinningLimit > 0 ) { for ( i=0; iBinNumElements[i] = BinNumElements[i]; Pattern->BinPatternData[i] = (unsigned short *)malloc(BinNumElements[i] * sizeof(unsigned short)); for ( j=0; jBinPatternData[i][j] = BinPatternData[i][j]; } } } } libapogee2-2.2/ApnCamData_KAI4020MLB.h0000644000175000017500000000221311110507150014612 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_KAI4020MLB.h: Interface file for the CApnCamData_KAI4020MLB class. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #if _MSC_VER > 1000 #pragma once #endif // _MSC_VER> 1000 #include "ApnCamData.h" class CApnCamData_KAI4020MLB : public CApnCamData { public: CApnCamData_KAI4020MLB(); virtual ~CApnCamData_KAI4020MLB(); void Initialize(); private: void set_vpattern(); void set_hpattern_clamp_sixteen(); void set_hpattern_skip_sixteen(); void set_hpattern_roi_sixteen(); void set_hpattern_clamp_twelve(); void set_hpattern_skip_twelve(); void set_hpattern_roi_twelve(); void set_hpattern( APN_HPATTERN_FILE *Pattern, unsigned short Mask, unsigned short BinningLimit, unsigned short RefNumElements, unsigned short SigNumElements, unsigned short BinNumElements[], unsigned short RefPatternData[], unsigned short SigPatternData[], unsigned short BinPatternData[][APN_MAX_PATTERN_ENTRIES] ); }; libapogee2-2.2/test_alta.cpp0000644000175000017500000004411611110507150013657 0ustar jrjr/* Program : test_alta.cpp * Version : 2.0 * Author : Dave Mills * Copyright : The Random Factory 2004-2008 * License : GPL * * * This program provides a limited test environment for Apogee ALTA * series cameras. It utilises the same low-level API provided by the * apogee_USB.so and apogee_NET.so shared object libraries. * * To build for ALTA-E * g++ -I/opt/apogee/include -DALTA_NET -c test_alta.cpp -IFpgaRegs -o test_altae \ ApnCamera.o ApnCamera_Linux.o ApnCamera_NET.o \ ApogeeNetLinux.o ApnCamData*.o ApnCamTable.o \ -L/opt/apogee/lib -ltcl8.3 -lccd -lfitsTcl * * To build for ALTA-U * g++ -I/opt/apogee/include -c test_alta.cpp -IFpgaRegs -o test_altau \ ApnCamera.o ApnCamera_Linux.o ApnCamera_USB.o \ ApogeeUsbLinux.o ApnCamData*.o ApnCamTable.o \ -L/opt/apogee/lib -ltcl8.3 -lccd -lfitsTcl /opt/apogee/lib/libusb.so * * The program is controlled by a set of command line options * Usage information is obtained by invoking the program with -h * * eg ./alta_teste -h * * Functions provided include full frame, subregion, binning, image sequences, * fan and cooling control. * * Caveats : There is limited error checking on the input options, if you * hang the camera onboard software, simply power cycle the * camera. */ #include #include #include #include "fitsio.h" #include #include #include #include "tcl.h" #include "ApnCamera.h" #include "ccd.h" int parse_options (int argc, char **argv); int saveimage(unsigned short *src_buffer, char *filename, short nx, short ny); int dobiassubtract(unsigned short *src,unsigned short *dest, int nx, int ny); /* Declare the camera object. All camera functions and parameters are * accessed using the methods and instance variables of this object * * Their declarations can be found in ApnCamera.h */ CApnCamera *alta; /* Declare globals to store the input command line options */ char imagename[256]; double texposure=1.0; int shutter=1; int ip[4]={0,0,0,0}; int xbin=1; int ybin=1; int xstart=0; int xend=0; int ystart=0; int yend=0; int biascols=0; int fanmode=0; double cooling=99.0; int numexp=1; int ipause=0; int verbose=0; int camnum=1; int highspeed=0; int tdimode=0; int tdirows=0; /* Bias definitions used in the libccd functions */ extern int bias_start, bias_end, bcols; /* Functions from libccd, provide simple named image buffer management */ typedef struct { unsigned short *pixels; int size; short xdim; short ydim; short zdim; short xbin; short ybin; short type; char name[64]; int shmid; size_t shmsize; char *shmem; } CCD_FRAME; typedef void *PDATA; #define MAX_CCD_BUFFERS 1000 PDATA CCD_locate_buffer(char *name, int idepth, short imgcols, short imgrows, short hbin, short vbin); int CCD_free_buffer(); int CCD_locate_buffernum(char *name); extern CCD_FRAME CCD_Frame[MAX_CCD_BUFFERS]; extern int CCD_free_buffer(char *name); /* Main executable starts here -----------------------------------------------*/ int main (int argc, char **argv) { int status; unsigned short *image; int bnum,i; int nx,ny; int iexposure; unsigned int ipaddr; double t; char seqname[256]; unsigned short ir, Reg; /* Default the bias to no-bias-subtraction */ bias_start = 0; bias_end = 0; bcols = 0; /* Obtain user provided options */ status = parse_options(argc,argv); /* Create the camera object , this will reserve memory */ alta = (CApnCamera *)new CApnCamera(); /* If this is an ALTA-E model, then add the ip address to the driver initialization. The second argument is the default port used (80 is the http default). If you have altered this on your camera, then change the source here too! */ #ifdef ALTA_NET ipaddr = ip[0]*256*256*256 + ip[1]*256*256 + ip[2]*256 + ip[3]; alta->InitDriver(ipaddr,80,0); #else alta->InitDriver(camnum,0,0); #endif /* Do a system reset to ensure known state, flushing enabled etc */ alta->ResetSystem(); /* Special verbosity to dump regs and exit */ if (verbose == 99) { for(ir=0;ir<106;ir++) { alta->Read(ir,Reg); printf ("Register %d = %d (%x)\n",ir,Reg,Reg); } exit(0); } /* If bias subtraction requested, set it up */ if (biascols != 0) { bcols = biascols; bias_start = alta->m_ApnSensorInfo->m_ImagingColumns+1; bias_end = alta->m_ApnSensorInfo->m_ImagingColumns+bcols; alta->m_pvtRoiPixelsH = alta->m_ApnSensorInfo->m_ImagingColumns + bcols; alta->m_ApnSensorInfo->m_PostRoiSkipColumns = bcols; } /* Setup binning, defaults to full frame */ i = 0; /* Set up a region of interest, defaults to full frame */ if (xstart > 0) { alta->m_pvtRoiStartX = xstart; alta->m_pvtRoiStartY = ystart; alta->m_pvtRoiPixelsH = (xend-xstart+1); alta->m_pvtRoiPixelsV = (yend-ystart+1); } /* Set up binning */ alta->m_pvtRoiPixelsH = alta->m_pvtRoiPixelsH / xbin; alta->m_pvtRoiPixelsV = alta->m_pvtRoiPixelsV / ybin; alta->write_RoiBinningH(xbin); alta->write_RoiBinningV(ybin); /* Set the required fan mode */ alta->write_FanMode(fanmode); #ifndef ALTA_NET /* Set the highspeed mode if required */ if (highspeed > 0) { alta->write_DataBits(highspeed); } #endif /* If a particular CCD temperature was requested, then enable cooling and set the correct setpoint value */ if (cooling < 99.0) { printf("Waiting for requested temperature of %6.1lf \r",cooling); alta->write_CoolerEnable(1); alta->write_CoolerSetPoint(cooling); t = alta->read_TempCCD(); /* Then loop until we get within 0.2 degrees, about the best we can hope for */ while (fabs(t-cooling) > 0.2) { printf("Waiting for requested temperature of %6.1lf, current value is %6.1lf \r",cooling,t); sleep(1); t = alta->read_CoolerStatus(); t = alta->read_TempCCD(); } printf("\n Temperature is now %6.1lf\n",t); } /* Add a second to ensure readout will be complete when we try to read */ iexposure = (int)texposure+1; /* Single image per download */ alta->write_ImageCount(1); /* Loop until all exposures completed */ while ( i < numexp ) { /* Setup kinetics if requested */ if (tdimode > 0) { alta->m_pvtRoiPixelsV = tdirows; // Set the TDI row count alta->write_TDIRows (tdirows); // Set the TDI rate alta->write_TDIRate (texposure); // Toggle the camera mode for TDI alta->write_CameraMode (Apn_CameraMode_TDI); // Toggle the sequence download variable alta->write_SequenceBulkDownload (true); /* iexposure = (int)(tdirows*texposure+2.0); */ } /* Start an exposure */ status = alta->Expose(texposure,shutter); /* Wait until done, we could continously poll the camera here instead */ /* if (tdimode > 0) { iexposure = (int)(tdirows*texposure+2.0); sleep(iexposure); } */ /* Readout the image and save in a named buffer (tempobs) */ status = alta->BufferImage("tempobs"); /* Use the libccd routine to find the corresponding buffer index */ bnum = CCD_locate_buffernum("tempobs"); /* Print details about the buffer for debug purposes */ printf("Buffer %4d %s = %d bytes cols=%d rows=%d depth=%d\n",bnum,CCD_Frame[bnum].name, CCD_Frame[bnum].size,CCD_Frame[bnum].xdim,CCD_Frame[bnum].ydim,CCD_Frame[bnum].zdim); /* Obtain the memory address of the actual image data, and x,y dimensions */ image = CCD_Frame[bnum].pixels; nx = CCD_Frame[bnum].xdim; ny = CCD_Frame[bnum].ydim; /* If this is part of a sequence, prefix image name with the number */ if (numexp > 1) { sprintf(seqname,"%d_%s",i,imagename); saveimage(image, seqname, nx, ny); } else { saveimage(image, imagename, nx, ny); } /* Wait requested interval between exposures (default is 0) */ sleep(ipause); i++; } /* All done, tidy up */ alta->CloseDriver(); } /* Helper routines start here-------------------------------------------------*/ /* This routine provides a very simple command line parser * Unknown options should be ignored, but strict type * checking is NOT done. */ int parse_options (int argc, char **argv) { int i; int goti,gott,gots,gota; /* Zero out counters for required options */ goti=0; gott=0; gots=0; gota=0; i=1; /* Default fanmode to medium */ fanmode = 2; /* Loop thru all provided options */ while (i 0) { printf("Apogee ALTA image test - V2.0\n"); printf(" Image name is %s\n",imagename); printf(" Exposure time is %lf\n",texposure); if (numexp > 1) printf(" Sequence of %d exposures requested\n",numexp); if (ipause > 0.0) printf(" Pause of %d seconds between exposures\n",ipause); printf(" Shutter state during exposure will be %d\n",shutter); #ifdef ALTA_NET if (ip[0] != 0) printf(" ALTA-E ip address is %d.%d.%d.%d\n",ip[0],ip[1],ip[2],ip[3]); #endif if (xbin > 1) printf(" X binning selected xbin=%d\n",xbin); if (ybin > 1) printf(" Y binning selected ybin=%d\n",ybin); if (xstart != 0) printf(" Subregion readout %d,%d,%d,%d\n",xstart,xend,ystart,yend); if (biascols != 0) printf(" Bias subtraction using %d columns\n",biascols); if (fanmode > 0) printf(" Fan set to mode = %d\n",fanmode); if (cooling < 99.0) printf(" Requested ccd temperature for exposure is %lf\n",cooling); if (tdimode == 1) printf(" TDI mode , number of rows = %d, %d secs per row\n",tdirows,texposure); } return(0); } /* This routine provides simple FITS writer. It uses the routines * provided by the fitsTcl/cfitsio libraries * * NOTE : It will fail if the image already exists */ int saveimage(unsigned short *src_buffer, char *filename, short nx, short ny) { fitsfile *fptr; /* pointer to the FITS file, defined in fitsio.h */ long fpixel, nelements; unsigned short *array; unsigned short *simg; int status; /* initialize FITS image parameters */ int bitpix = USHORT_IMG; /* 16-bit unsigned short pixel values */ long naxis = 2; /* 2-dimensional image */ long naxes[2]; naxes[0] = nx-bcols; naxes[1] = ny; array = src_buffer; status = 0; /* initialize status before calling fitsio routines */ simg = (unsigned short *)CCD_locate_buffer("stemp",2,nx-bcols,ny,1,1); if (fits_create_file(&fptr, filename, &status)) /* create new FITS file */ printerror( status ); /* call printerror if error occurs */ /* write the required keywords for the primary array image. */ /* Since bitpix = USHORT_IMG, this will cause cfitsio to create */ /* a FITS image with BITPIX = 16 (signed short integers) with */ /* BSCALE = 1.0 and BZERO = 32768. This is the convention that */ /* FITS uses to store unsigned integers. Note that the BSCALE */ /* and BZERO keywords will be automatically written by cfitsio */ /* in this case. */ if ( fits_create_img(fptr, bitpix, naxis, naxes, &status) ) printerror( status ); fpixel = 1; /* first pixel to write */ nelements = naxes[0] * naxes[1]; /* number of pixels to write */ dobiassubtract(src_buffer,simg,naxes[0],naxes[1]); /* write the array of unsigned integers to the FITS file */ if ( fits_write_img(fptr, TUSHORT, fpixel, nelements, simg, &status) ) printerror( status ); if ( fits_close_file(fptr, &status) ) /* close the file */ printerror( status ); return(status); } /* This routine should do bias subtraction. At present it * uses the minium pixel DN as the bias value, instead of * averaging the bias columns. This is because on the * test unit I have, averaging these columns does not seem * to give values consistently lower than those in the * exposed region. * * src is the input image with bias columns * dest is a smaller output image with the bias columns trimmed off * and the "bias" subtracted from the image pixels. */ int dobiassubtract(unsigned short *src,unsigned short *dest, int nx, int ny) { double biases[128000]; double abiases; int ix,iy, oix; int ipix, opix; unsigned short minbias; minbias = 65535; if (bcols == 0) { for (iy=0;iy bias_end) { ipix = (nx+bcols)*iy + ix; opix = nx*iy + oix; if (src[ipix] < minbias) { dest[opix] = 0; } else { dest[opix] = src[ipix] - (int)minbias; } oix++; } } } return(0); } libapogee2-2.2/INSTALL0000644000175000017500000000053211110507150012216 0ustar jrjrApogee INSTALL ============== You must have CMake >= 2.4.7 in order to build this package. 1) $ tar -xzf libapogee.tar.gz 2) $ mkdir libapogee_build 3) $ cd libapogee_build 4) $ cmake -DCMAKE_INSTALL_PREFIX=/usr . ../libapogee 5) $ su -c 'make install' or sudo make install Refer to README for instructions on using the driver. That's it! libapogee2-2.2/ApnCamData_CCD7700.cpp0000644000175000017500000004317411110507150014622 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_CCD7700.cpp: Implementation file for the CApnCamData_CCD7700 class. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #include "ApnCamData_CCD7700.h" #include #include #include ///////////////////////////////////////////////////////////// // Construction/Destruction ///////////////////////////////////////////////////////////// CApnCamData_CCD7700::CApnCamData_CCD7700() { } CApnCamData_CCD7700::~CApnCamData_CCD7700() { } void CApnCamData_CCD7700::Initialize() { strcpy( m_Sensor, "CCD7700" ); strcpy( m_CameraModel, "77" ); m_CameraId = 26; m_InterlineCCD = false; m_SupportsSerialA = true; m_SupportsSerialB = true; m_SensorTypeCCD = true; m_TotalColumns = 527; m_ImagingColumns = 512; m_ClampColumns = 15; m_PreRoiSkipColumns = 0; m_PostRoiSkipColumns = 0; m_OverscanColumns = 0; m_TotalRows = 512; m_ImagingRows = 512; m_UnderscanRows = 0; m_OverscanRows = 0; m_VFlushBinning = 1; m_EnableSingleRowOffset = false; m_RowOffsetBinning = 1; m_HFlushDisable = false; m_ShutterCloseDelay = 300; m_PixelSizeX = 24; m_PixelSizeY = 24; m_Color = false; m_ReportedGainSixteenBit = 2; m_MinSuggestedExpTime = 20.0; m_CoolingSupported = true; m_RegulatedCoolingSupported = true; m_TempSetPoint = -20.0; m_TempRampRateOne = 700; m_TempRampRateTwo = 4000; m_TempBackoffPoint = 2.0; m_PrimaryADType = ApnAdType_Alta_Sixteen; m_AlternativeADType = ApnAdType_Alta_Twelve; m_DefaultGainLeft = 400; m_DefaultOffsetLeft = 200; m_DefaultGainRight = -1; m_DefaultOffsetRight = -1; m_DefaultRVoltage = 1000; m_DefaultSpeed = 0xffff; m_DefaultDataReduction = false; set_vpattern(); set_hpattern_clamp_sixteen(); set_hpattern_skip_sixteen(); set_hpattern_roi_sixteen(); set_hpattern_clamp_twelve(); set_hpattern_skip_twelve(); set_hpattern_roi_twelve(); } void CApnCamData_CCD7700::set_vpattern() { const unsigned short Mask = 0x0; const unsigned short NumElements = 180; unsigned short Pattern[NumElements] = { 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x000A, 0x000A, 0x000A, 0x000A, 0x000A, 0x000A, 0x000A, 0x000A, 0x000A, 0x000A, 0x000A, 0x000A, 0x000A, 0x000A, 0x000A, 0x000A, 0x000A, 0x000A, 0x000A, 0x000A, 0x000A, 0x000A, 0x000A, 0x000A, 0x000A, 0x000A, 0x000A, 0x000A, 0x000A, 0x000A, 0x000A, 0x000A, 0x000A, 0x000A, 0x000A, 0x000A, 0x000A, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0001, 0x0000, }; m_VerticalPattern.Mask = Mask; m_VerticalPattern.NumElements = NumElements; m_VerticalPattern.PatternData = (unsigned short *)malloc(NumElements * sizeof(unsigned short)); for ( int i=0; iMask = Mask; Pattern->BinningLimit = BinningLimit; Pattern->RefNumElements = RefNumElements; Pattern->SigNumElements = SigNumElements; if ( RefNumElements > 0 ) { Pattern->RefPatternData = (unsigned short *)malloc(RefNumElements * sizeof(unsigned short)); for ( i=0; iRefPatternData[i] = RefPatternData[i]; } } if ( SigNumElements > 0 ) { Pattern->SigPatternData = (unsigned short *)malloc(SigNumElements * sizeof(unsigned short)); for ( i=0; iSigPatternData[i] = SigPatternData[i]; } } if ( BinningLimit > 0 ) { for ( i=0; iBinNumElements[i] = BinNumElements[i]; Pattern->BinPatternData[i] = (unsigned short *)malloc(BinNumElements[i] * sizeof(unsigned short)); for ( j=0; jBinPatternData[i][j] = BinPatternData[i][j]; } } } } libapogee2-2.2/ApnFilterWheel.cpp0000644000175000017500000001343211110507150014545 0ustar jrjr////////////////////////////////////////////////////////////////////// // // ApnFilterWheel.cpp: implementation of the CApnFilterWheel class. // // Copyright (c) 2007 Apogee Instruments, Inc. // ////////////////////////////////////////////////////////////////////// #include "stdafx.h" #include "dbt.h" #include "ApnFilterWheel.h" #include "ApogeeUsb.h" #include "ApogeeUsbErr.h" #include "Apn.h" #ifdef _DEBUG #undef THIS_FILE static char THIS_FILE[]=__FILE__; #define new DEBUG_NEW #endif ////////////////////////////////////////////////////////////////////// // Construction/Destruction ////////////////////////////////////////////////////////////////////// CApnFilterWheel::CApnFilterWheel() { InitMemberVars(); } CApnFilterWheel::~CApnFilterWheel() { } ///////////////////////////////////////////////////////////////////////////// // CApnSerial_USB message handlers void CApnFilterWheel::InitMemberVars() { m_VendorId = 0; m_ProductId = 0; m_DeviceId = 0; m_MaxPositions = 0; m_WheelType = Apn_Filter_Unknown; m_ConnectionOpen = false; m_DeviceNum = 0; } bool CApnFilterWheel::Init( Apn_Filter FilterType, unsigned long DeviceNum ) { unsigned short IoAssignment; m_ConnectionOpen = false; if ( (FilterType != Apn_Filter_FW50_9R) && (FilterType != Apn_Filter_FW50_7S) ) { return false; } if ( ApnUsbOpen( (unsigned short)DeviceNum, m_SysDeviceName ) != APN_USB_SUCCESS ) { return false; } ApnUsbReadVendorInfo( &m_VendorId, &m_ProductId, &m_DeviceId ); if ( m_ProductId != 0x0100 ) { return false; } m_ConnectionOpen = true; m_WheelType = FilterType; GetMaxPositions( &m_MaxPositions ); SetPosition( 1 ); return true; } bool CApnFilterWheel::Close() { ApnUsbClose( ); InitMemberVars(); return true; } bool CApnFilterWheel::GetVendorId( unsigned short *VendorId ) { bool RetVal; RetVal = true; if ( !m_ConnectionOpen ) return false; if ( m_WheelType != Apn_Filter_Unknown ) { *VendorId = m_VendorId; } else { *VendorId = 0x0; RetVal = false; } return RetVal; } bool CApnFilterWheel::GetProductId( unsigned short *ProductId ) { bool RetVal; RetVal = true; if ( !m_ConnectionOpen ) return false; if ( m_WheelType != Apn_Filter_Unknown ) { *ProductId = m_ProductId; } else { *ProductId = 0x0; RetVal = false; } return RetVal; } bool CApnFilterWheel::GetDeviceId( unsigned short *DeviceId ) { bool RetVal; RetVal = true; if ( !m_ConnectionOpen ) return false; if ( m_WheelType != Apn_Filter_Unknown ) { *DeviceId = m_DeviceId; } else { *DeviceId = 0x0; RetVal = false; } return RetVal; } bool CApnFilterWheel::GetUsbFirmwareRev( char *FirmwareRev, long *BufferLength ) { bool RetVal; RetVal = true; if ( !m_ConnectionOpen ) return false; if ( ApnUsbRead8051FirmwareRevision( FirmwareRev ) == APN_USB_SUCCESS ) { *BufferLength = strlen( FirmwareRev ); } else { RetVal = false; } return RetVal; } bool CApnFilterWheel::GetWheelType( Apn_Filter *WheelType ) { bool RetVal; RetVal = true; if ( m_WheelType == Apn_Filter_Unknown ) RetVal = false; *WheelType = m_WheelType; return RetVal; } bool CApnFilterWheel::GetWheelModel( char *WheelDescr, long *BufferLength ) { bool RetVal; RetVal = true; char szModel[256]; switch ( m_WheelType ) { case Apn_Filter_FW50_9R: strcpy( szModel, APN_FILTER_AFW30_7R_DESCR ); break; case Apn_Filter_FW50_7S: strcpy( szModel, APN_FILTER_AFW50_5R_DESCR ); break; case Apn_Filter_Unknown: strcpy( szModel, APN_FILTER_UNKNOWN_DESCR ); break; default: strcpy( szModel, APN_FILTER_UNKNOWN_DESCR ); break; } *BufferLength = strlen( szModel ); strncpy( WheelDescr, szModel, *BufferLength + 1); return RetVal; } bool CApnFilterWheel::GetStatus( Apn_FilterStatus *FilterStatus ) { bool RetVal; unsigned char Data; unsigned char Pins; Apn_FilterStatus TempStatus; RetVal = true; if ( !m_ConnectionOpen ) { *FilterStatus = Apn_FilterStatus_NotConnected; } else { ApnUsbReadControlPort( &Data, &Pins ); if ( Pins & 0x01 ) { *FilterStatus = Apn_FilterStatus_Active; } else { *FilterStatus = Apn_FilterStatus_Ready; } } return RetVal; } bool CApnFilterWheel::GetMaxPositions( unsigned long *MaxPositions ) { bool RetVal; RetVal = true; if ( !m_ConnectionOpen ) { *MaxPositions = 0; return false; } switch ( m_WheelType ) { case Apn_Filter_FW50_9R: *MaxPositions = APN_FILTER_FW50_9R_MAX_POSITIONS; break; case Apn_Filter_FW50_7S: *MaxPositions = APN_FILTER_FW50_7S_MAX_POSITIONS; break; case Apn_Filter_Unknown: *MaxPositions = 0; RetVal = false; break; default: *MaxPositions = 0; RetVal = false; break; } return RetVal; } bool CApnFilterWheel::SetPosition( unsigned long Position ) { bool RetVal; unsigned char Data; unsigned char Pins; RetVal = true; if ( !m_ConnectionOpen ) { return false; } if ( (Position < 1) || (Position > m_MaxPositions) ) { return false; } // ApnUsbConfigureControlPort( 0x0F ); Data = Position - 1; // hardware is zero-based Pins = 0x0; ApnUsbWriteControlPort( Data, Pins ); return RetVal; } bool CApnFilterWheel::GetPosition( unsigned long *Position ) { bool RetVal; unsigned char Data; unsigned char Pins; RetVal = true; if ( !m_ConnectionOpen ) { *Position = 0; return false; } // ApnUsbConfigureControlPort( 0x00 ); ApnUsbReadControlPort( &Data, &Pins ); *Position = (Data & 0x0F) + 1; // hardware is zero-based return RetVal; } libapogee2-2.2/ApnCamData_CCD4710ALT.h0000644000175000017500000000221311110507150014613 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_CCD4710ALT.h: Interface file for the CApnCamData_CCD4710ALT class. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #if _MSC_VER > 1000 #pragma once #endif // _MSC_VER> 1000 #include "ApnCamData.h" class CApnCamData_CCD4710ALT : public CApnCamData { public: CApnCamData_CCD4710ALT(); virtual ~CApnCamData_CCD4710ALT(); void Initialize(); private: void set_vpattern(); void set_hpattern_clamp_sixteen(); void set_hpattern_skip_sixteen(); void set_hpattern_roi_sixteen(); void set_hpattern_clamp_twelve(); void set_hpattern_skip_twelve(); void set_hpattern_roi_twelve(); void set_hpattern( APN_HPATTERN_FILE *Pattern, unsigned short Mask, unsigned short BinningLimit, unsigned short RefNumElements, unsigned short SigNumElements, unsigned short BinNumElements[], unsigned short RefPatternData[], unsigned short SigPatternData[], unsigned short BinPatternData[][APN_MAX_PATTERN_ENTRIES] ); }; libapogee2-2.2/ApnCamera_NET.h0000644000175000017500000000623311110507150013677 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamera_NET.h: Interface file for the CApnCamera_NET class. // // Copyright (c) 2003, 2004 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #if !defined(AFX_APNCAMERA_NET_H__D6F0E3AB_536C_4937_9E2B_DCF682D0DD31__INCLUDED_) #define AFX_APNCAMERA_NET_H__D6F0E3AB_536C_4937_9E2B_DCF682D0DD31__INCLUDED_ #if _MSC_VER > 1000 #pragma once #endif // _MSC_VER > 1000 #include "ApnCamera.h" #include "ApogeeNet.h" #include "ApogeeNetErr.h" class CApnCamera_NET : public CApnCamera { private: HINTERNET m_hSession; ULONG m_ImageSizeBytes; BOOLEAN m_ImageInProgress; bool m_FastDownload; char m_HostAddr[80]; unsigned short m_pvtBitsPerPixel; unsigned short m_pvtExposeBitsPerPixel; unsigned short m_pvtExposeCameraMode; unsigned short m_pvtExposeWidth; unsigned short m_pvtExposeHeight; bool m_pvtExposeExternalShutter; unsigned short m_pvtNumImages; public: CApnCamera_NET(); virtual ~CApnCamera_NET(); bool GetDeviceHandle( void *hCamera, char *CameraInfo ); bool InitDriver( unsigned long CamIdA, unsigned short CamIdB, unsigned long Option ); bool SimpleInitDriver( unsigned long CamIdA, unsigned short CamIdB, unsigned long Option ); Apn_Interface GetCameraInterface(); long GetCameraSerialNumber( char *CameraSerialNumber, long *BufferLength ); long GetSystemDriverVersion( char *SystemDriverVersion, long *BufferLength ); long GetUsb8051FirmwareRev( char *FirmwareRev, long *BufferLength ); long GetUsbProductId( unsigned short *pProductId ); long GetUsbDeviceId( unsigned short *pDeviceId ); bool CloseDriver(); long PreStartExpose( unsigned short BitsPerPixel ); long PostStopExposure( bool DigitizeData ); void SetNetworkTransferMode( Apn_NetworkMode TransferMode ); long GetImageData( unsigned short *pImageData, unsigned short &Width, unsigned short &Height, unsigned long &Count ); long GetLineData( unsigned short *pLineBuffer, unsigned short &Size ); long Read( unsigned short reg, unsigned short& val ); long Write( unsigned short reg, unsigned short val ); long WriteMultiSRMD( unsigned short reg, unsigned short val[], unsigned short count ); long WriteMultiMRMD( unsigned short reg[], unsigned short val[], unsigned short count ); long QueryStatusRegs( unsigned short& StatusReg, unsigned short& HeatsinkTempReg, unsigned short& CcdTempReg, unsigned short& CoolerDriveReg, unsigned short& VoltageReg, unsigned short& TdiCounter, unsigned short& SequenceCounter, unsigned short& MostRecentFrame, unsigned short& ReadyFrame, unsigned short& CurrentFrame ); }; #endif // !defined(AFX_APNCAMERA_NET_H__D6F0E3AB_536C_4937_9E2B_DCF682D0DD31__INCLUDED_) libapogee2-2.2/ApnCamData_KAF0261EB.h0000644000175000017500000000220611110507150014470 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_KAF0261EB.h: Interface file for the CApnCamData_KAF0261EB class. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #if _MSC_VER > 1000 #pragma once #endif // _MSC_VER> 1000 #include "ApnCamData.h" class CApnCamData_KAF0261EB : public CApnCamData { public: CApnCamData_KAF0261EB(); virtual ~CApnCamData_KAF0261EB(); void Initialize(); private: void set_vpattern(); void set_hpattern_clamp_sixteen(); void set_hpattern_skip_sixteen(); void set_hpattern_roi_sixteen(); void set_hpattern_clamp_twelve(); void set_hpattern_skip_twelve(); void set_hpattern_roi_twelve(); void set_hpattern( APN_HPATTERN_FILE *Pattern, unsigned short Mask, unsigned short BinningLimit, unsigned short RefNumElements, unsigned short SigNumElements, unsigned short BinNumElements[], unsigned short RefPatternData[], unsigned short SigPatternData[], unsigned short BinPatternData[][APN_MAX_PATTERN_ENTRIES] ); }; libapogee2-2.2/ApnCamData_ASCENT2000.cpp0000644000175000017500000002217411110507150015167 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_ASCENT2000.cpp: Implementation file for the CApnCamData_ASCENT2000 class. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #include "ApnCamData_ASCENT2000.h" #include #include #include ///////////////////////////////////////////////////////////// // Construction/Destruction ///////////////////////////////////////////////////////////// CApnCamData_ASCENT2000::CApnCamData_ASCENT2000() { } CApnCamData_ASCENT2000::~CApnCamData_ASCENT2000() { } void CApnCamData_ASCENT2000::Initialize() { strcpy( m_Sensor, "ASCENT2000" ); strcpy( m_CameraModel, "2000" ); m_CameraId = 322; m_InterlineCCD = true; m_SupportsSerialA = false; m_SupportsSerialB = false; m_SensorTypeCCD = true; m_TotalColumns = 4942; m_ImagingColumns = 4872; m_ClampColumns = 35; m_PreRoiSkipColumns = 0; m_PostRoiSkipColumns = 0; m_OverscanColumns = 35; m_TotalRows = 3324; m_ImagingRows = 3248; m_UnderscanRows = 56; m_OverscanRows = 20; m_VFlushBinning = 4; m_EnableSingleRowOffset = false; m_RowOffsetBinning = 1; m_HFlushDisable = false; m_ShutterCloseDelay = 0; m_PixelSizeX = 7.4; m_PixelSizeY = 7.4; m_Color = false; m_ReportedGainSixteenBit = 0.8; m_MinSuggestedExpTime = 0.1; m_CoolingSupported = true; m_RegulatedCoolingSupported = true; m_TempSetPoint = -20.0; m_TempRampRateOne = 1200; m_TempRampRateTwo = 4000; m_TempBackoffPoint = 2.0; m_PrimaryADType = ApnAdType_Ascent_Sixteen; m_AlternativeADType = ApnAdType_None; m_DefaultGainLeft = 0; m_DefaultOffsetLeft = 100; m_DefaultGainRight = 0; m_DefaultOffsetRight = 100; m_DefaultRVoltage = 1000; m_DefaultSpeed = 0x0; m_DefaultDataReduction = true; set_vpattern(); set_hpattern_clamp_sixteen(); set_hpattern_skip_sixteen(); set_hpattern_roi_sixteen(); set_hpattern_clamp_twelve(); set_hpattern_skip_twelve(); set_hpattern_roi_twelve(); } void CApnCamData_ASCENT2000::set_vpattern() { const unsigned short Mask = 0x6; const unsigned short NumElements = 71; unsigned short Pattern[NumElements] = { 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0202, 0x0202, 0x0202, 0x0202, 0x0202, 0x0202, 0x0202, 0x0202, 0x0202, 0x0202, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0003, 0x0002 }; m_VerticalPattern.Mask = Mask; m_VerticalPattern.NumElements = NumElements; m_VerticalPattern.PatternData = (unsigned short *)malloc(NumElements * sizeof(unsigned short)); for ( int i=0; iMask = Mask; Pattern->BinningLimit = BinningLimit; Pattern->RefNumElements = RefNumElements; Pattern->SigNumElements = SigNumElements; if ( RefNumElements > 0 ) { Pattern->RefPatternData = (unsigned short *)malloc(RefNumElements * sizeof(unsigned short)); for ( i=0; iRefPatternData[i] = RefPatternData[i]; } } if ( SigNumElements > 0 ) { Pattern->SigPatternData = (unsigned short *)malloc(SigNumElements * sizeof(unsigned short)); for ( i=0; iSigPatternData[i] = SigPatternData[i]; } } if ( BinningLimit > 0 ) { for ( i=0; iBinNumElements[i] = BinNumElements[i]; Pattern->BinPatternData[i] = (unsigned short *)malloc(BinNumElements[i] * sizeof(unsigned short)); for ( j=0; jBinPatternData[i][j] = BinPatternData[i][j]; } } } } libapogee2-2.2/CameraIO_PCI.cpp0000644000175000017500000002350011110507150014004 0ustar jrjr// CameraIO_PCI.cpp: implementation of the CCameraIO_PCI class. // // Copyright (c) 2000 Apogee Instruments Inc. ////////////////////////////////////////////////////////////////////// #include "stdafx.h" #include #include "ApogeeLinux.h" // This defines the IOCTL constants. #include "CameraIO_PCI.h" #include "time.h" ////////////////////////////////////////////////////////////////////// // Construction/Destruction ////////////////////////////////////////////////////////////////////// CCameraIO_PCI::CCameraIO_PCI() { m_IsWDM = false; m_hDriver = NULL; } CCameraIO_PCI::~CCameraIO_PCI() { CloseDriver(); } long CCameraIO_PCI::Read(unsigned short reg, unsigned short& val) { BOOLEAN IoctlResult; ULONG ReturnedLength; USHORT RegNumber; USHORT ReadBuffer; switch ( reg ) { case Reg_Command: RegNumber = RegPCI_CommandRead; break; case Reg_Timer: RegNumber = RegPCI_TimerRead; break; case Reg_VBinning: RegNumber = RegPCI_VBinningRead; break; case Reg_AICCounter: RegNumber = RegPCI_AICCounterRead; break; case Reg_TempSetPoint: RegNumber = RegPCI_TempSetPointRead; break; case Reg_PixelCounter: RegNumber = RegPCI_PixelCounterRead; break; case Reg_LineCounter: RegNumber = RegPCI_LineCounterRead; break; case Reg_BICCounter: RegNumber = RegPCI_BICCounterRead; break; case Reg_ImageData: RegNumber = RegPCI_ImageData; break; case Reg_TempData: RegNumber = RegPCI_TempData; break; case Reg_Status: RegNumber = RegPCI_Status; break; case Reg_CommandReadback: RegNumber = RegPCI_CommandReadback; break; default: _ASSERT( FALSE ); // Application program bug val = 0; return 0; } if ( m_IsWDM ) { IoctlResult = DeviceIoControl( m_hDriver, // Handle to device IOCTL_WDM_READ_PCI_USHORT, // IO Control code for Read &RegNumber, // Buffer to driver. sizeof(RegNumber), // Length of buffer in bytes. &ReadBuffer, // Buffer from driver. sizeof(ReadBuffer), // Length of buffer in bytes. &ReturnedLength, // Bytes placed in DataBuffer. NULL // NULL means wait till op. completes. ); } else { IoctlResult = DeviceIoControl( m_hDriver, // Handle to device IOCTL_GPD_READ_PCI_USHORT, // IO Control code for Read &RegNumber, // Buffer to driver. sizeof(RegNumber), // Length of buffer in bytes. &ReadBuffer, // Buffer from driver. sizeof(ReadBuffer), // Length of buffer in bytes. &ReturnedLength, // Bytes placed in DataBuffer. NULL // NULL means wait till op. completes. ); } if ( (ReturnedLength != 2) || (IoctlResult == FALSE) ) { return 1; } val = ReadBuffer; return 0; } long CCameraIO_PCI::Write(unsigned short reg, unsigned short val) { BOOLEAN IoctlResult; ULONG InBuffer[2]; ULONG ReturnedLength; USHORT RegNumber; switch ( reg ) { case Reg_Command: RegNumber = RegPCI_Command; break; case Reg_Timer: RegNumber = RegPCI_Timer; break; case Reg_VBinning: RegNumber = RegPCI_VBinning; break; case Reg_AICCounter: RegNumber = RegPCI_AICCounter; break; case Reg_TempSetPoint: RegNumber = RegPCI_TempSetPoint; break; case Reg_PixelCounter: RegNumber = RegPCI_PixelCounter; break; case Reg_LineCounter: RegNumber = RegPCI_LineCounter; break; case Reg_BICCounter: RegNumber = RegPCI_BICCounter; break; default: _ASSERT ( false ); return 0; } InBuffer[0] = RegNumber; InBuffer[1] = val; // Do an I/O write if ( m_IsWDM ) { IoctlResult = DeviceIoControl( m_hDriver, // Handle to device IOCTL_WDM_WRITE_PCI_USHORT, // IO Control code for Write &InBuffer, // Buffer to driver. Holds register/data. sizeof ( InBuffer ), // Length of buffer in bytes. NULL, // Buffer from driver. Not used. 0, // Length of buffer in bytes. &ReturnedLength, // Bytes placed in outbuf. Should be 0. NULL // NULL means wait till I/O completes. ); } else { IoctlResult = DeviceIoControl( m_hDriver, // Handle to device IOCTL_GPD_WRITE_PCI_USHORT, // IO Control code for Write &InBuffer, // Buffer to driver. Holds register/data. sizeof ( InBuffer ), // Length of buffer in bytes. NULL, // Buffer from driver. Not used. 0, // Length of buffer in bytes. &ReturnedLength, // Bytes placed in outbuf. Should be 0. NULL // NULL means wait till I/O completes. ); } if ( (IoctlResult == FALSE) || (ReturnedLength != 0) ) { return 1; } return 0; } long CCameraIO_PCI::ReadLine( long SkipPixels, long Pixels, unsigned short* pLineBuffer ) { BOOLEAN IoctlResult; ULONG InBuffer[3]; ULONG ReturnedLength; // Number of bytes returned in output buffer ULONG NumBytes; USHORT* DataBuffer; InBuffer[0] = RegPCI_ImageData; InBuffer[1] = SkipPixels; // Data points to skip InBuffer[2] = Pixels; // Data points to keep NumBytes = Pixels * sizeof( unsigned short ); DataBuffer = pLineBuffer; if ( !m_TDI ) { ///////////////////////////////////// // Clock out the line m_RegShadow[ Reg_Command ] |= RegBit_StartNextLine; // set bit to 1 Write( Reg_Command, m_RegShadow[ Reg_Command ] ); m_RegShadow[ Reg_Command ] &= ~RegBit_StartNextLine; // set bit to 0 Write( Reg_Command, m_RegShadow[ Reg_Command ] ); ///////////////////////////////////// } if ( m_IsWDM ) { IoctlResult = DeviceIoControl( m_hDriver, // Handle to device IOCTL_WDM_READ_PCI_LINE, // IO Control code for Read line &InBuffer, // Buffer to driver. sizeof(InBuffer), // Length of buffer in bytes. DataBuffer, // Buffer from driver. NumBytes, // Length of buffer in bytes. &ReturnedLength, // Bytes placed in DataBuffer. NULL // NULL means wait till op. completes. ); } else { IoctlResult = DeviceIoControl( m_hDriver, // Handle to device IOCTL_GPD_READ_PCI_LINE, // IO Control code for Read line &InBuffer, // Buffer to driver. sizeof(InBuffer), // Length of buffer in bytes. DataBuffer, // Buffer from driver. NumBytes, // Length of buffer in bytes. &ReturnedLength, // Bytes placed in DataBuffer. NULL // NULL means wait till op. completes. ); } if ( (ReturnedLength != NumBytes) || (!IoctlResult) ) { return 1; // Failed to get line info } ///////////////////////////////////// // Assert done reading line m_RegShadow[ Reg_Command ] |= RegBit_DoneReading; // set bit to 1 Write( Reg_Command, m_RegShadow[ Reg_Command ] ); m_RegShadow[ Reg_Command ] &= ~RegBit_DoneReading; // set bit to 0 Write( Reg_Command, m_RegShadow[ Reg_Command ] ); ///////////////////////////////////// if ( !m_TDI ) { ///////////////////////////////////// // Wait until camera is done clock_t StopTime = clock() + CLOCKS_PER_SEC; // wait at most one second while ( true ) { unsigned short val = 0; Read( Reg_Status, val ); if ( ( val & RegBit_LineDone ) != 0 ) break;// Line done if ( clock() > StopTime ) return 1; // Timed out } } return 0; } bool CCameraIO_PCI::InitDriver() { OSVERSIONINFO OSVerInfo; BOOLEAN IsPostWin98OS; BOOLEAN IsNT4OS; BOOLEAN IsPostNT4OS; IsPostWin98OS = false; IsNT4OS = false; IsPostNT4OS = false; CloseDriver(); OSVerInfo.dwOSVersionInfoSize = sizeof ( OSVERSIONINFO ); GetVersionEx( &OSVerInfo ); // Check for Win9x versions. Pre-Win98 is unsupported. if ( OSVerInfo.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS ) { // Check for pre-Win98 if (( OSVerInfo.dwMajorVersion < 4 ) || (( OSVerInfo.dwMajorVersion == 4 ) && ( OSVerInfo.dwMinorVersion == 0 ))) { return false; // Pre-Win98 not supported } else { IsPostWin98OS = true; } } else if ( OSVerInfo.dwPlatformId == VER_PLATFORM_WIN32_NT ) { // Check if NT4 if ( OSVerInfo.dwMajorVersion < 4 ) { // NT3.51 is not supported. Right?? return false; } else if (OSVerInfo.dwMajorVersion == 4 ) { IsNT4OS = true; } else if (OSVerInfo.dwMajorVersion > 4 ) { IsPostNT4OS = true; } } if ( IsNT4OS ) { ULONG ReturnedLength; ULONG DataBuffer[2]; // Open the driver m_hDriver = CreateFile( "\\\\.\\ApogeeIO", GENERIC_WRITE | GENERIC_READ, FILE_SHARE_WRITE | FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL); if ( m_hDriver == INVALID_HANDLE_VALUE ) { m_hDriver = NULL; return false; } BOOL IoctlResult = DeviceIoControl( m_hDriver, // Handle to device IOCTL_PCI_BUS_SCAN, // IO Control code for PCI Bus Scan NULL, // Buffer to driver. 0, // Length of buffer in bytes. DataBuffer, // Buffer from driver. sizeof( DataBuffer ), // Length of buffer in bytes. &ReturnedLength, // Bytes placed in DataBuffer. NULL // NULL means wait till op. completes. ); if ( (!IoctlResult) || (ReturnedLength != sizeof(DataBuffer)) ) { return false; } } else if ( IsPostWin98OS || IsPostNT4OS ) { // Should be okay to use the WDM driver. Note that the kernel // driver will actually check to see if WDM services are available // Open the driver m_hDriver = CreateFile( "\\\\.\\ApPCI", GENERIC_WRITE | GENERIC_READ, FILE_SHARE_WRITE | FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL ); if ( m_hDriver == INVALID_HANDLE_VALUE ) { m_hDriver = NULL; return false; } // Safe to assume we're using the WDM driver at this point. m_IsWDM = true; } return true; } void CCameraIO_PCI::CloseDriver() { // Close the driver if it already exists if ( m_hDriver != NULL ) { CloseHandle ( m_hDriver ); } m_hDriver = NULL; } libapogee2-2.2/ApnCamData_KAF0401E.cpp0000644000175000017500000006134611110507150014727 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_KAF0401E.cpp: Implementation file for the CApnCamData_KAF0401E class. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #include "ApnCamData_KAF0401E.h" #include #include #include ///////////////////////////////////////////////////////////// // Construction/Destruction ///////////////////////////////////////////////////////////// CApnCamData_KAF0401E::CApnCamData_KAF0401E() { } CApnCamData_KAF0401E::~CApnCamData_KAF0401E() { } void CApnCamData_KAF0401E::Initialize() { strcpy( m_Sensor, "KAF0401E" ); strcpy( m_CameraModel, "1" ); m_CameraId = 0; m_InterlineCCD = false; m_SupportsSerialA = true; m_SupportsSerialB = true; m_SensorTypeCCD = true; m_TotalColumns = 796; m_ImagingColumns = 768; m_ClampColumns = 14; m_PreRoiSkipColumns = 0; m_PostRoiSkipColumns = 0; m_OverscanColumns = 14; m_TotalRows = 520; m_ImagingRows = 512; m_UnderscanRows = 4; m_OverscanRows = 4; m_VFlushBinning = 1; m_EnableSingleRowOffset = false; m_RowOffsetBinning = 1; m_HFlushDisable = false; m_ShutterCloseDelay = 100; m_PixelSizeX = 9; m_PixelSizeY = 9; m_Color = false; m_ReportedGainSixteenBit = 1.5; m_MinSuggestedExpTime = 10.0; m_CoolingSupported = true; m_RegulatedCoolingSupported = true; m_TempSetPoint = -20.0; m_TempRampRateOne = 700; m_TempRampRateTwo = 4000; m_TempBackoffPoint = 2.0; m_PrimaryADType = ApnAdType_Alta_Sixteen; m_AlternativeADType = ApnAdType_Alta_Twelve; m_DefaultGainLeft = 0; m_DefaultOffsetLeft = 100; m_DefaultGainRight = -1; m_DefaultOffsetRight = -1; m_DefaultRVoltage = 1000; m_DefaultSpeed = 0xffff; m_DefaultDataReduction = false; set_vpattern(); set_hpattern_clamp_sixteen(); set_hpattern_skip_sixteen(); set_hpattern_roi_sixteen(); set_hpattern_clamp_twelve(); set_hpattern_skip_twelve(); set_hpattern_roi_twelve(); } void CApnCamData_KAF0401E::set_vpattern() { const unsigned short Mask = 0x0; const unsigned short NumElements = 71; unsigned short Pattern[NumElements] = { 0x0000, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0001, 0x0000 }; m_VerticalPattern.Mask = Mask; m_VerticalPattern.NumElements = NumElements; m_VerticalPattern.PatternData = (unsigned short *)malloc(NumElements * sizeof(unsigned short)); for ( int i=0; iMask = Mask; Pattern->BinningLimit = BinningLimit; Pattern->RefNumElements = RefNumElements; Pattern->SigNumElements = SigNumElements; if ( RefNumElements > 0 ) { Pattern->RefPatternData = (unsigned short *)malloc(RefNumElements * sizeof(unsigned short)); for ( i=0; iRefPatternData[i] = RefPatternData[i]; } } if ( SigNumElements > 0 ) { Pattern->SigPatternData = (unsigned short *)malloc(SigNumElements * sizeof(unsigned short)); for ( i=0; iSigPatternData[i] = SigPatternData[i]; } } if ( BinningLimit > 0 ) { for ( i=0; iBinNumElements[i] = BinNumElements[i]; Pattern->BinPatternData[i] = (unsigned short *)malloc(BinNumElements[i] * sizeof(unsigned short)); for ( j=0; jBinPatternData[i][j] = BinPatternData[i][j]; } } } } libapogee2-2.2/ApnCamData_CCD4720B.h0000644000175000017500000000220111110507150014352 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_CCD4720B.h: Interface file for the CApnCamData_CCD4720B class. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #if _MSC_VER > 1000 #pragma once #endif // _MSC_VER> 1000 #include "ApnCamData.h" class CApnCamData_CCD4720B : public CApnCamData { public: CApnCamData_CCD4720B(); virtual ~CApnCamData_CCD4720B(); void Initialize(); private: void set_vpattern(); void set_hpattern_clamp_sixteen(); void set_hpattern_skip_sixteen(); void set_hpattern_roi_sixteen(); void set_hpattern_clamp_twelve(); void set_hpattern_skip_twelve(); void set_hpattern_roi_twelve(); void set_hpattern( APN_HPATTERN_FILE *Pattern, unsigned short Mask, unsigned short BinningLimit, unsigned short RefNumElements, unsigned short SigNumElements, unsigned short BinNumElements[], unsigned short RefPatternData[], unsigned short SigPatternData[], unsigned short BinPatternData[][APN_MAX_PATTERN_ENTRIES] ); }; libapogee2-2.2/ApnCamData_ASCENT2000.h0000644000175000017500000000221311110507150014624 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_ASCENT2000.h: Interface file for the CApnCamData_ASCENT2000 class. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #if _MSC_VER > 1000 #pragma once #endif // _MSC_VER> 1000 #include "ApnCamData.h" class CApnCamData_ASCENT2000 : public CApnCamData { public: CApnCamData_ASCENT2000(); virtual ~CApnCamData_ASCENT2000(); void Initialize(); private: void set_vpattern(); void set_hpattern_clamp_sixteen(); void set_hpattern_skip_sixteen(); void set_hpattern_roi_sixteen(); void set_hpattern_clamp_twelve(); void set_hpattern_skip_twelve(); void set_hpattern_roi_twelve(); void set_hpattern( APN_HPATTERN_FILE *Pattern, unsigned short Mask, unsigned short BinningLimit, unsigned short RefNumElements, unsigned short SigNumElements, unsigned short BinNumElements[], unsigned short RefPatternData[], unsigned short SigPatternData[], unsigned short BinPatternData[][APN_MAX_PATTERN_ENTRIES] ); }; libapogee2-2.2/ApnCamData_KAI2001CL.cpp0000644000175000017500000005316511110507150015042 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_KAI2001CL.cpp: Implementation file for the CApnCamData_KAI2001CL class. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #include "ApnCamData_KAI2001CL.h" #include #include #include ///////////////////////////////////////////////////////////// // Construction/Destruction ///////////////////////////////////////////////////////////// CApnCamData_KAI2001CL::CApnCamData_KAI2001CL() { } CApnCamData_KAI2001CL::~CApnCamData_KAI2001CL() { } void CApnCamData_KAI2001CL::Initialize() { strcpy( m_Sensor, "KAI2001CL" ); strcpy( m_CameraModel, "2001cl" ); m_CameraId = 71; m_InterlineCCD = true; m_SupportsSerialA = true; m_SupportsSerialB = true; m_SensorTypeCCD = true; m_TotalColumns = 1648; m_ImagingColumns = 1600; m_ClampColumns = 24; m_PreRoiSkipColumns = 0; m_PostRoiSkipColumns = 0; m_OverscanColumns = 24; m_TotalRows = 1214; m_ImagingRows = 1200; m_UnderscanRows = 6; m_OverscanRows = 8; m_VFlushBinning = 1; m_EnableSingleRowOffset = false; m_RowOffsetBinning = 1; m_HFlushDisable = false; m_ShutterCloseDelay = 0; m_PixelSizeX = 7.4; m_PixelSizeY = 7.4; m_Color = true; m_ReportedGainSixteenBit = 1; m_MinSuggestedExpTime = 0.05; m_CoolingSupported = true; m_RegulatedCoolingSupported = true; m_TempSetPoint = -20.0; m_TempRampRateOne = 700; m_TempRampRateTwo = 4000; m_TempBackoffPoint = 2.0; m_PrimaryADType = ApnAdType_Alta_Sixteen; m_AlternativeADType = ApnAdType_Alta_Twelve; m_DefaultGainLeft = 0; m_DefaultOffsetLeft = 100; m_DefaultGainRight = -1; m_DefaultOffsetRight = -1; m_DefaultRVoltage = 1000; m_DefaultSpeed = 0xffff; m_DefaultDataReduction = false; set_vpattern(); set_hpattern_clamp_sixteen(); set_hpattern_skip_sixteen(); set_hpattern_roi_sixteen(); set_hpattern_clamp_twelve(); set_hpattern_skip_twelve(); set_hpattern_roi_twelve(); } void CApnCamData_KAI2001CL::set_vpattern() { const unsigned short Mask = 0x106; const unsigned short NumElements = 38; unsigned short Pattern[NumElements] = { 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0302, 0x0302, 0x0302, 0x0302, 0x0302, 0x0302, 0x0302, 0x0302, 0x0302, 0x0302, 0x0002, 0x0002, 0x0002, 0x0003, 0x0002 }; m_VerticalPattern.Mask = Mask; m_VerticalPattern.NumElements = NumElements; m_VerticalPattern.PatternData = (unsigned short *)malloc(NumElements * sizeof(unsigned short)); for ( int i=0; iMask = Mask; Pattern->BinningLimit = BinningLimit; Pattern->RefNumElements = RefNumElements; Pattern->SigNumElements = SigNumElements; if ( RefNumElements > 0 ) { Pattern->RefPatternData = (unsigned short *)malloc(RefNumElements * sizeof(unsigned short)); for ( i=0; iRefPatternData[i] = RefPatternData[i]; } } if ( SigNumElements > 0 ) { Pattern->SigPatternData = (unsigned short *)malloc(SigNumElements * sizeof(unsigned short)); for ( i=0; iSigPatternData[i] = SigPatternData[i]; } } if ( BinningLimit > 0 ) { for ( i=0; iBinNumElements[i] = BinNumElements[i]; Pattern->BinPatternData[i] = (unsigned short *)malloc(BinNumElements[i] * sizeof(unsigned short)); for ( j=0; jBinPatternData[i][j] = BinPatternData[i][j]; } } } } libapogee2-2.2/ApnCamData_ASCENT4000.h0000644000175000017500000000221311110507150014626 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_ASCENT4000.h: Interface file for the CApnCamData_ASCENT4000 class. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #if _MSC_VER > 1000 #pragma once #endif // _MSC_VER> 1000 #include "ApnCamData.h" class CApnCamData_ASCENT4000 : public CApnCamData { public: CApnCamData_ASCENT4000(); virtual ~CApnCamData_ASCENT4000(); void Initialize(); private: void set_vpattern(); void set_hpattern_clamp_sixteen(); void set_hpattern_skip_sixteen(); void set_hpattern_roi_sixteen(); void set_hpattern_clamp_twelve(); void set_hpattern_skip_twelve(); void set_hpattern_roi_twelve(); void set_hpattern( APN_HPATTERN_FILE *Pattern, unsigned short Mask, unsigned short BinningLimit, unsigned short RefNumElements, unsigned short SigNumElements, unsigned short BinNumElements[], unsigned short RefPatternData[], unsigned short SigPatternData[], unsigned short BinPatternData[][APN_MAX_PATTERN_ENTRIES] ); }; libapogee2-2.2/ApnCamData_KAF1301EB.cpp0000644000175000017500000004414611110507150015030 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_KAF1301EB.cpp: Implementation file for the CApnCamData_KAF1301EB class. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #include "ApnCamData_KAF1301EB.h" #include #include #include ///////////////////////////////////////////////////////////// // Construction/Destruction ///////////////////////////////////////////////////////////// CApnCamData_KAF1301EB::CApnCamData_KAF1301EB() { } CApnCamData_KAF1301EB::~CApnCamData_KAF1301EB() { } void CApnCamData_KAF1301EB::Initialize() { strcpy( m_Sensor, "KAF1301EB" ); strcpy( m_CameraModel, "13" ); m_CameraId = 35; m_InterlineCCD = false; m_SupportsSerialA = true; m_SupportsSerialB = true; m_SensorTypeCCD = true; m_TotalColumns = 1305; m_ImagingColumns = 1280; m_ClampColumns = 4; m_PreRoiSkipColumns = 0; m_PostRoiSkipColumns = 0; m_OverscanColumns = 21; m_TotalRows = 1028; m_ImagingRows = 1024; m_UnderscanRows = 2; m_OverscanRows = 2; m_VFlushBinning = 1; m_EnableSingleRowOffset = false; m_RowOffsetBinning = 1; m_HFlushDisable = false; m_ShutterCloseDelay = 300; m_PixelSizeX = 16; m_PixelSizeY = 16; m_Color = false; m_ReportedGainSixteenBit = 3; m_MinSuggestedExpTime = 20.0; m_CoolingSupported = true; m_RegulatedCoolingSupported = true; m_TempSetPoint = -20.0; m_TempRampRateOne = 700; m_TempRampRateTwo = 4000; m_TempBackoffPoint = 2.0; m_PrimaryADType = ApnAdType_Alta_Sixteen; m_AlternativeADType = ApnAdType_Alta_Twelve; m_DefaultGainLeft = 0; m_DefaultOffsetLeft = 200; m_DefaultGainRight = -1; m_DefaultOffsetRight = -1; m_DefaultRVoltage = 1000; m_DefaultSpeed = 0xffff; m_DefaultDataReduction = false; set_vpattern(); set_hpattern_clamp_sixteen(); set_hpattern_skip_sixteen(); set_hpattern_roi_sixteen(); set_hpattern_clamp_twelve(); set_hpattern_skip_twelve(); set_hpattern_roi_twelve(); } void CApnCamData_KAF1301EB::set_vpattern() { const unsigned short Mask = 0x6; const unsigned short NumElements = 71; unsigned short Pattern[NumElements] = { 0x0000, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0001, 0x0000 }; m_VerticalPattern.Mask = Mask; m_VerticalPattern.NumElements = NumElements; m_VerticalPattern.PatternData = (unsigned short *)malloc(NumElements * sizeof(unsigned short)); for ( int i=0; iMask = Mask; Pattern->BinningLimit = BinningLimit; Pattern->RefNumElements = RefNumElements; Pattern->SigNumElements = SigNumElements; if ( RefNumElements > 0 ) { Pattern->RefPatternData = (unsigned short *)malloc(RefNumElements * sizeof(unsigned short)); for ( i=0; iRefPatternData[i] = RefPatternData[i]; } } if ( SigNumElements > 0 ) { Pattern->SigPatternData = (unsigned short *)malloc(SigNumElements * sizeof(unsigned short)); for ( i=0; iSigPatternData[i] = SigPatternData[i]; } } if ( BinningLimit > 0 ) { for ( i=0; iBinNumElements[i] = BinNumElements[i]; Pattern->BinPatternData[i] = (unsigned short *)malloc(BinNumElements[i] * sizeof(unsigned short)); for ( j=0; jBinPatternData[i][j] = BinPatternData[i][j]; } } } } libapogee2-2.2/ApnCamData_KAF4202.cpp0000644000175000017500000006116211110507150014621 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_KAF4202.cpp: Implementation file for the CApnCamData_KAF4202 class. // // Copyright (c) 2003, 2004 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #include "ApnCamData_KAF4202.h" #include #include #include ///////////////////////////////////////////////////////////// // Construction/Destruction ///////////////////////////////////////////////////////////// CApnCamData_KAF4202::CApnCamData_KAF4202() { } CApnCamData_KAF4202::~CApnCamData_KAF4202() { } void CApnCamData_KAF4202::Initialize() { strcpy( m_Sensor, "KAF4202" ); strcpy( m_CameraModel, "4" ); m_CameraId = 7; m_InterlineCCD = false; m_SupportsSerialA = true; m_SupportsSerialB = true; m_SensorTypeCCD = true; m_TotalColumns = 2060; m_ImagingColumns = 2032; m_ClampColumns = 25; m_PreRoiSkipColumns = 0; m_PostRoiSkipColumns = 0; m_OverscanColumns = 3; m_TotalRows = 2048; m_ImagingRows = 2044; m_UnderscanRows = 2; m_OverscanRows = 2; m_VFlushBinning = 1; m_EnableSingleRowOffset = false; m_RowOffsetBinning = 1; m_HFlushDisable = false; m_ShutterCloseDelay = 300; m_PixelSizeX = 9; m_PixelSizeY = 9; m_Color = false; m_ReportedGainSixteenBit = 1.5; m_MinSuggestedExpTime = 20.0; m_CoolingSupported = true; m_RegulatedCoolingSupported = true; m_TempSetPoint = -20.0; m_TempRampRateOne = 700; m_TempRampRateTwo = 4000; m_TempBackoffPoint = 2.0; m_PrimaryADType = ApnAdType_Alta_Sixteen; m_AlternativeADType = ApnAdType_Alta_Twelve; //m_DefaultGainTwelveBit = 0; //m_DefaultOffsetTwelveBit = 100; m_DefaultRVoltage = 1000; set_vpattern(); set_hpattern_clamp_sixteen(); set_hpattern_skip_sixteen(); set_hpattern_roi_sixteen(); set_hpattern_clamp_twelve(); set_hpattern_skip_twelve(); set_hpattern_roi_twelve(); } void CApnCamData_KAF4202::set_vpattern() { const unsigned short Mask = 0x0; const unsigned short NumElements = 71; unsigned short Pattern[NumElements] = { 0x0000, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0001, 0x0000 }; m_VerticalPattern.Mask = Mask; m_VerticalPattern.NumElements = NumElements; m_VerticalPattern.PatternData = (unsigned short *)malloc(NumElements * sizeof(unsigned short)); for ( int i=0; iMask = Mask; Pattern->BinningLimit = BinningLimit; Pattern->RefNumElements = RefNumElements; Pattern->SigNumElements = SigNumElements; if ( RefNumElements > 0 ) { Pattern->RefPatternData = (unsigned short *)malloc(RefNumElements * sizeof(unsigned short)); for ( i=0; iRefPatternData[i] = RefPatternData[i]; } } if ( SigNumElements > 0 ) { Pattern->SigPatternData = (unsigned short *)malloc(SigNumElements * sizeof(unsigned short)); for ( i=0; iSigPatternData[i] = SigPatternData[i]; } } if ( BinningLimit > 0 ) { for ( i=0; iBinNumElements[i] = BinNumElements[i]; Pattern->BinPatternData[i] = (unsigned short *)malloc(BinNumElements[i] * sizeof(unsigned short)); for ( j=0; jBinPatternData[i][j] = BinPatternData[i][j]; } } } } libapogee2-2.2/CameraIO_Linux.cpp0000644000175000017500000011505711110507150014501 0ustar jrjr// CameraIO.cpp: implementation of the CCameraIO class. // // Copyright (c) 2000 Apogee Instruments Inc. ////////////////////////////////////////////////////////////////////// #ifndef LINUX #include "stdafx.h" #else #include #include #include #include #include #include #include #include #include #define HANDLE int #define FALSE 0 #define DWORD long #define _ASSERT assert #define REALTIME_PRIORITY_CLASS 1 #define GetCurrentProcess getpid #define LOBYTE(x) ((x) & 0xff) #define HIBYTE(x) ((x >> 8) & 0xff) #endif #define MIRQ1 0x21 #define MIRQ2 0xA1 #include "time.h" #include "tcl.h" #include "ccd.h" #include "CameraIO_Linux.h" #include "ApogeeLinux.h" const int NUM_POSITIONS = 6; const int NUM_STEPS_PER_FILTER = 48; const int STEP_DELAY = 10; const unsigned char Steps[] = { 0x10, 0x30, 0x20, 0x60, 0x40, 0xc0, 0x80, 0x90 }; const int NUM_STEPS = sizeof ( Steps ); ////////////////////////////////////////////////////////////////////// // Construction/Destruction ////////////////////////////////////////////////////////////////////// CCameraIO::CCameraIO() { InitDefaults(); m_TDI = false; m_Shutter = false; m_FilterPosition = 0; m_FilterStepPos = 0; m_WaitingforImage = false; m_WaitingforLine = false; m_WaitingforTrigger = false; m_Status = Camera_Status_Idle; m_CoolerStatus = Camera_CoolerStatus_Off; m_ExposureBinX = 0; m_ExposureBinY = 0; m_ExposureStartX = 0; m_ExposureStartY = 0; m_ExposureNumX = 0; m_ExposureNumY = 0; m_ExposureColumns = 0; m_ExposureRows = 0; m_ExposureSkipC = 0; m_ExposureSkipR = 0; m_ExposureHFlush = 0; m_ExposureVFlush = 0; m_ExposureBIC = 0; m_ExposureBIR = 0; m_ExposureAIC = 0; m_ExposureRemainingLines = 0; m_ExposureAIR = 0; m_RegShadow[ Reg_Command ] = 0; m_RegShadow[ Reg_Timer ] = 0; m_RegShadow[ Reg_VBinning ] = 0; m_RegShadow[ Reg_AICCounter ] = 0; m_RegShadow[ Reg_TempSetPoint ] = 0; m_RegShadow[ Reg_PixelCounter ] = 0; m_RegShadow[ Reg_LineCounter ] = 0; m_RegShadow[ Reg_BICCounter ] = 0; m_FastShutterBits_Mode = 0; m_FastShutterBits_Test = 0; m_IRQMask = 0; saveIRQS = 0; } CCameraIO::~CCameraIO() { ::close(fileHandle); } //////////////////////////////////////////////////////////// // System methods int GetPriorityClass ( HANDLE hProcess ) { int i; i = sched_getscheduler(0); return(i); } int SetPriorityClass ( HANDLE hProcess, int hPriority) { int i; sched_param p; if (hPriority) { i = sched_setscheduler(0,SCHED_RR,&p); } else { i = sched_setscheduler(0,SCHED_OTHER,&p); } return(i); } void Sleep (int hTime) { timespec t; t.tv_sec= 0; t.tv_nsec = hTime*1000000; // nanosleep(&t); } void ATLTRACE (char *msg) { } void CCameraIO::Reset() { unsigned short val = 0; Read( Reg_CommandReadback, val ); // Take snapshot of currrent status m_RegShadow[ Reg_Command ] = val; // remember it in our write shadow // In case these were left on, turn them off m_RegShadow[ Reg_Command ] &= ~RegBit_FIFOCache; // set bit to 0 m_RegShadow[ Reg_Command ] &= ~RegBit_TDIMode; // set bit to 0 m_RegShadow[ Reg_Command ] |= RegBit_ResetSystem; // set bit to 1 Write( Reg_Command, m_RegShadow[ Reg_Command ] ); m_RegShadow[ Reg_Command ] &= ~RegBit_ResetSystem; // set bit to 0 Write( Reg_Command, m_RegShadow[ Reg_Command ] ); m_WaitingforImage = false; m_WaitingforLine = false; m_WaitingforTrigger = false; } void CCameraIO::AuxOutput( unsigned char val ) { // clear bits to 0 m_RegShadow[ Reg_TempSetPoint ] &= ~( RegBitMask_PortControl << RegBitShift_PortControl ); // set our new bits m_RegShadow[ Reg_TempSetPoint ] |= val << RegBitShift_PortControl; Write( Reg_TempSetPoint, m_RegShadow[ Reg_TempSetPoint ] ); } // Input reg is from 0 to 7, val is any 16 bit number void CCameraIO::RegWrite( short reg, unsigned short val ) { Write( reg, val ); // Update our shadow register switch ( reg ) { case Reg_Command: m_RegShadow[ Reg_Command ] = val; break; case Reg_Timer: m_RegShadow[ Reg_Timer ] = val; break; case Reg_VBinning: m_RegShadow[ Reg_VBinning ] = val; break; case Reg_AICCounter: m_RegShadow[ Reg_AICCounter ] = val; break; case Reg_TempSetPoint: m_RegShadow[ Reg_TempSetPoint ] = val; break; case Reg_PixelCounter: m_RegShadow[ Reg_PixelCounter ] = val; break; case Reg_LineCounter: m_RegShadow[ Reg_LineCounter ] = val; break; case Reg_BICCounter: m_RegShadow[ Reg_BICCounter ] = val; break; default: _ASSERT( FALSE ); // application program bug } } // Input reg is from 8 to 12, returned val is any 16 bit number void CCameraIO::RegRead( short reg, unsigned short& val ) { Read( reg, val ); } bool CCameraIO::FilterHome() { HANDLE hProcess; DWORD Class; if ( m_HighPriority ) { // Store current process class and priority hProcess = GetCurrentProcess(); Class = GetPriorityClass ( hProcess ); SetPriorityClass ( hProcess, REALTIME_PRIORITY_CLASS ); } // Find the home position m_FilterPosition = 0; int Safety = 0; for (int I = 0; I < NUM_POSITIONS * NUM_STEPS_PER_FILTER * 2; I++) { // Advance the filter one step m_FilterStepPos += 1; if (m_FilterStepPos >= NUM_STEPS) m_FilterStepPos = 0; unsigned char Step = Steps[ m_FilterStepPos ]; AuxOutput( Step ); Sleep ( STEP_DELAY ); // Check for strobe unsigned short val = 0; Read( Reg_Status, val ); if ( val & RegBit_GotTrigger ) { // Cycle all the way around if it's on the first time if (I < NUM_STEPS_PER_FILTER) { if (++Safety > NUM_STEPS_PER_FILTER * 2) { // Restore normal priority if ( m_HighPriority ) SetPriorityClass ( hProcess, Class ); return false; } I = 0; continue; } // Continue cycling until we get clear of the opto mirror for (int J = 0; J < NUM_STEPS_PER_FILTER; J++) { // Advance the filter one step m_FilterStepPos += 1; if (m_FilterStepPos >= NUM_STEPS) m_FilterStepPos = 0; unsigned char Step = Steps[ m_FilterStepPos ]; AuxOutput( Step ); Sleep ( STEP_DELAY ); val = 0; Read( Reg_Status, val ); if ( val & RegBit_GotTrigger ) { Sleep ( 10 ); val = 0; Read( Reg_Status, val ); if ( val & RegBit_GotTrigger ) { // Restore normal priority if ( m_HighPriority ) SetPriorityClass ( hProcess, Class ); return true; } } } // Restore normal priority if ( m_HighPriority ) SetPriorityClass ( hProcess, Class ); return true; } } // Restore normal priority if ( m_HighPriority ) SetPriorityClass ( hProcess, Class ); return false; } void CCameraIO::FilterSet( short Slot ) { // Determine how far we have to move int Pos = Slot - m_FilterPosition; if (Pos < 0) Pos += NUM_POSITIONS; HANDLE hProcess; DWORD Class; if ( m_HighPriority ) { // Store current process class and priority hProcess = GetCurrentProcess(); Class = GetPriorityClass ( hProcess ); SetPriorityClass ( hProcess, REALTIME_PRIORITY_CLASS ); } for (int I = 0; I < Pos; I++) { // Advance one position for (int J = 0; J < NUM_STEPS_PER_FILTER; J++) { m_FilterStepPos += 1; if (m_FilterStepPos >= NUM_STEPS) m_FilterStepPos = 0; unsigned char Step = Steps[ m_FilterStepPos ]; AuxOutput( Step ); Sleep ( STEP_DELAY ); } } if ( m_HighPriority ) SetPriorityClass ( hProcess, Class ); m_FilterPosition = Slot; } //////////////////////////////////////////////////////////// // Normal exposure methods bool CCameraIO::Expose( double Duration, bool Light ) { if ( !m_TDI && ( Duration < m_MinExposure || Duration > m_MaxExposure ) ) return false; // Validate all input variables if ( m_Columns < 1 || m_Columns > MAXCOLUMNS ) return false; m_ExposureColumns = m_Columns; if ( m_Rows < 1 || m_Rows > MAXROWS ) return false; m_ExposureRows = m_Rows; if ( m_SkipC < 0 ) return false; m_ExposureSkipC = m_SkipC; if ( m_SkipR < 0 ) return false; m_ExposureSkipR = m_SkipR; if ( m_HFlush < 1 || m_HFlush > MAXHBIN ) return false; m_ExposureHFlush = m_HFlush; if ( m_VFlush < 1 || m_VFlush > MAXVBIN ) return false; m_ExposureVFlush = m_VFlush; if ( m_BIC < 1 || m_BIC > MAXCOLUMNS ) return false; m_ExposureBIC = m_BIC; if ( m_BIR < 1 || m_BIR > MAXROWS ) return false; m_ExposureBIR = m_BIR; // Validate all input variables if ( m_BinX < 1 || m_BinX > MAXHBIN ) return false; m_ExposureBinX = m_BinX; if ( m_StartX < 0 || m_StartX >= MAXCOLUMNS ) return false; m_ExposureStartX = m_StartX; if ( m_NumX < 1 || m_NumX * m_BinX > m_ImgColumns ) return false; m_ExposureNumX = m_NumX; // Calculate BIC, RawPixelCount, AIC unsigned short BIC = m_ExposureBIC + m_ExposureStartX; // unbinned columns unsigned short RawPixelCount = m_ExposureNumX * m_ExposureBinX; m_ExposureAIC = m_ExposureColumns - BIC - RawPixelCount; // unbinned columns if ( m_BinY < 1 || m_BinY > MAXVBIN ) return false; m_ExposureBinY = m_BinY; unsigned short VBin, row_offset; if ( m_TDI ) { // row_offset is the drift time in milliseconds when in TDI mode row_offset = (unsigned short) (Duration * 1000 + 0.5); Duration = 0.0; } else { if ( m_StartY < 0 || m_StartX >= MAXROWS ) return false; m_ExposureStartY = m_StartY; if ( m_NumY < 1 || m_NumY * m_BinY > m_ImgRows ) return false; m_ExposureNumY = m_NumY; unsigned short BIR = m_ExposureBIR + m_ExposureStartY; // unbinned rows if ( BIR >= MAXROWS ) return false; m_ExposureAIR = m_ExposureRows - BIR - m_ExposureNumY * m_ExposureBinY; // unbinned rows if ( m_VFlush > BIR ) { VBin = BIR; m_ExposureRemainingLines = 0; } else { VBin = m_VFlush; m_ExposureRemainingLines = BIR % VBin; // unbinned rows } row_offset = BIR - m_ExposureRemainingLines; // unbinned rows } StopFlushing(); Reset(); LoadColumnLayout( m_ExposureAIC, BIC, (unsigned short) m_ExposureNumX + m_ExposureSkipC ); LoadTimerAndBinning( Duration, (unsigned short) m_ExposureHFlush, VBin ); LoadLineCounter( row_offset ); if ( m_TDI ) { // Turn on TDI m_RegShadow[ Reg_Command ] |= RegBit_TDIMode; // set bit to 1 // Disable FIFO cache m_RegShadow[ Reg_Command ] &= ~RegBit_FIFOCache; // set bit to 0 // Set shutter override if ( Light ) m_RegShadow[ Reg_Command ] |= RegBit_ShutterOverride; // set bit to 1 else m_RegShadow[ Reg_Command ] &= ~RegBit_ShutterOverride; // set bit to 0 Write( Reg_Command, m_RegShadow[ Reg_Command ] ); // Update our status m_Shutter = Light; m_WaitingforTrigger = false; m_WaitingforLine = false; } else { // Set shutter if ( Light ) m_RegShadow[ Reg_Command ] |= RegBit_ShutterEnable; // set bit to 1 else m_RegShadow[ Reg_Command ] &= ~RegBit_ShutterEnable; // set bit to 0 Write( Reg_Command, m_RegShadow[ Reg_Command ] ); // Update our status unsigned short val = 0; Read( Reg_CommandReadback, val ); if ( val & RegBit_ShutterOverride ) m_Shutter = true; else m_Shutter = Light; if ( ( val & RegBit_TriggerEnable ) ) m_WaitingforTrigger = true; else m_WaitingforTrigger = false; // Start the exposure m_RegShadow[ Reg_Command ] |= RegBit_StartTimer; // set bit to 1 Write( Reg_Command, m_RegShadow[ Reg_Command ] ); m_RegShadow[ Reg_Command ] &= ~RegBit_StartTimer; // set bit to 0 Write( Reg_Command, m_RegShadow[ Reg_Command ] ); m_WaitingforImage = true; } return true; } bool CCameraIO::BufferImage(char *bufferName ) { unsigned short *pImageData; bool status; short cols,rows,hbin,vbin; short xSize, ySize; cols = m_NumX*m_BinX; rows = m_NumY*m_BinY; hbin = m_BinX; vbin = m_BinY; pImageData = (unsigned short *)CCD_locate_buffer(bufferName, 2 , cols, rows, hbin, vbin ); if (pImageData == NULL) { return 0; } status = GetImage(pImageData, xSize, ySize); return status; } bool CCameraIO::GetImage( unsigned short* pImageData, short& xSize, short& ySize ) { int i; unsigned short BIC = m_ExposureBIC + m_ExposureStartX; // Update internal variables in case application did not poll read_Status m_WaitingforTrigger = false; m_WaitingforLine = false; if ( m_WaitingforImage ) { // In case application did not poll read_Status m_WaitingforImage = false; ///////////////////////////////////// // Wait until camera is done flushing clock_t StopTime = clock() + long( m_Timeout * CLOCKS_PER_SEC ); // wait at most m_Timeout seconds while ( true ) { unsigned short val = 0; Read( Reg_Status, val ); if ( ( val & RegBit_FrameDone ) != 0 ) break; if ( clock() > StopTime ) return false; // Timed out } } // MaskIrqs(); ///////////////////////////////////// // Update our internal status unsigned short val = 0; Read( Reg_CommandReadback, val ); if ( !( val & RegBit_ShutterOverride ) ) m_Shutter = false; StopFlushing(); LoadColumnLayout( m_ExposureAIC, BIC, (unsigned short) m_ExposureNumX + m_ExposureSkipC ); if ( m_ExposureRemainingLines > 0 ) { LoadTimerAndBinning( 0.0, m_ExposureHFlush, m_ExposureRemainingLines ); ///////////////////////////////////// // Clock out the remaining lines m_RegShadow[ Reg_Command ] |= RegBit_StartNextLine; // set bit to 1 Write( Reg_Command, m_RegShadow[ Reg_Command ] ); m_RegShadow[ Reg_Command ] &= ~RegBit_StartNextLine; // set bit to 0 Write( Reg_Command, m_RegShadow[ Reg_Command ] ); ///////////////////////////////////// ///////////////////////////////////// // Wait until camera is done clocking clock_t StopTime = clock() + CLOCKS_PER_SEC; // wait at most one second while ( true ) { unsigned short val = 0; Read( Reg_Status, val ); if ( ( val & RegBit_LineDone ) != 0 ) break; // Line done if ( clock() > StopTime ) { Flush(); return false; // Timed out, no image available } } } LoadTimerAndBinning( 0.0, m_ExposureBinX, m_ExposureBinY ); bool ret = false; // assume failure // NB Application must have allocated enough memory or else !!! if ( pImageData != NULL ) { HANDLE hProcess; DWORD Class; if ( m_HighPriority ) { // Store current process class and priority hProcess = GetCurrentProcess(); Class = GetPriorityClass ( hProcess ); SetPriorityClass ( hProcess, REALTIME_PRIORITY_CLASS ); } m_RegShadow[ Reg_Command ] |= RegBit_FIFOCache; // set bit to 1 Write( Reg_Command, m_RegShadow[ Reg_Command ] ); long XPixels = long( m_ExposureNumX ); long SkipPixels = long( m_ExposureSkipC ); for (i = 0; i < m_ExposureSkipR; i++) { if ( ReadLine( SkipPixels, XPixels, pImageData ) ) break; } if ( i == m_ExposureSkipR ) { // We have skipped all the lines long YPixels = long( m_ExposureNumY ); unsigned short* pLineBuffer = pImageData; for (i = 0; i < YPixels; i++) { if ( ReadLine( SkipPixels, XPixels, pLineBuffer ) ) break; pLineBuffer += XPixels; } if ( i == YPixels ) ret = true; // We have read all the lines } m_RegShadow[ Reg_Command ] &= ~RegBit_FIFOCache; // set bit to 0 Write( Reg_Command, m_RegShadow[ Reg_Command ] ); //Restore priority if ( m_HighPriority ) SetPriorityClass ( hProcess, Class ); } // UnmaskIrqs(); if ( ret ) { // We were successfull Flush( m_ExposureAIR ); // flush after imaging rows xSize = m_ExposureNumX; ySize = m_ExposureNumY; if ( m_DataBits == 16 ) { // Take care of two's complement converters unsigned short *Ptr = pImageData; short *Ptr2 = (short *) pImageData; long Size = m_ExposureNumX * m_ExposureNumY; for (i = 0; i < Size; i++) { *Ptr++ = (unsigned short) *Ptr2++ + 32768 ; } } } else { // Something went wrong xSize = 0; ySize = 0; } Flush(); // start normal flushing return ret; } //////////////////////////////////////////////////////////// // Drift scan methods bool CCameraIO::DigitizeLine() { ///////////////////////////////////// // All of these are done just in case // since they are called in Expose() StopFlushing(); unsigned short BIC = m_ExposureBIC + m_ExposureStartX; LoadColumnLayout( m_ExposureAIC, BIC, (unsigned short) m_ExposureNumX + m_ExposureSkipC ); LoadTimerAndBinning( 0.0, m_ExposureBinX, m_ExposureBinY ); // Disable FIFO cache m_RegShadow[ Reg_Command ] &= ~RegBit_FIFOCache; // set bit to 0 ///////////////////////////////////// ///////////////////////////////////// // Clock out the line m_RegShadow[ Reg_Command ] |= RegBit_StartNextLine; // set bit to 1 Write( Reg_Command, m_RegShadow[ Reg_Command ] ); m_RegShadow[ Reg_Command ] &= ~RegBit_StartNextLine; // set bit to 0 Write( Reg_Command, m_RegShadow[ Reg_Command ] ); ///////////////////////////////////// m_WaitingforLine = true; return true; } bool CCameraIO::GetLine( unsigned short* pLineData, short& xSize ) { int i; if ( m_WaitingforLine ) { // In case application did not poll read_Status m_WaitingforLine = false; ///////////////////////////////////// // Wait until camera is done clocking clock_t StopTime = clock() + CLOCKS_PER_SEC; // wait at most one second while ( true ) { unsigned short val = 0; Read( Reg_Status, val ); if ( ( val & RegBit_LineDone ) != 0 ) break; // Line done if ( clock() > StopTime ) { Flush(); return false; // Timed out, no line available } } } bool ret = false; // assume failure // MaskIrqs(); // NB Application must have allocated enough memory or else !!! if ( pLineData != NULL ) { HANDLE hProcess; DWORD Class; if ( m_HighPriority ) { // Store current process class and priority hProcess = GetCurrentProcess(); Class = GetPriorityClass ( hProcess ); SetPriorityClass ( hProcess, REALTIME_PRIORITY_CLASS ); } long XPixels = long( m_ExposureNumX ); long SkipPixels = long( m_ExposureSkipC ); if ( ReadLine( SkipPixels, XPixels, pLineData ) ) { // Something went wrong xSize = 0; ret = false; } else { xSize = m_ExposureNumX; if ( m_DataBits == 16 ) { // Take care of two's complement converters unsigned short *Ptr = pLineData; short *Ptr2 = (short *) pLineData; long Size = m_ExposureNumX; for (i = 0; i < Size; i++) { *Ptr++ = (unsigned short) *Ptr2++ + 32768 ; } } ret = true; } //Restore priority if ( m_HighPriority ) SetPriorityClass ( hProcess, Class ); } // UnmaskIrqs(); return ret; } bool CCameraIO::BufferDriftScan(char *bufferName, int delay, int rowCount, int nblock , int npipe) { unsigned short *pImageData, *ptr; bool status; int irow; short cols,rows,hbin,vbin; short xSize, ySize; struct timespec tdrift; struct timeval now1, now2, orig; struct timezone zone; struct sched_param s; long waitfor, diff; int iblock, iskip, ipipe; FILE *fpipe; size_t numcols; size_t bpr; cols = m_NumX*m_BinX; rows = rowCount; hbin = m_BinX; vbin = 1; if (npipe) { fpipe = fopen("/tmp/apgpipe", "w"); numcols = (size_t)m_NumX; bpr = sizeof(unsigned short); } pImageData = (unsigned short *)CCD_locate_buffer(bufferName, 2 , cols, rows, hbin, vbin ); if (pImageData == NULL) { return 0; } ptr = pImageData; irow = 0; for (iskip=0;iskip 20000000) { tdrift.tv_nsec = waitfor-20000000; nanosleep(&tdrift,NULL); } gettimeofday(&now2, &zone); diff = ((now2.tv_sec-now1.tv_sec)*1000000 + now2.tv_usec - now1.tv_usec)/1000; tdrift.tv_sec = 0; tdrift.tv_nsec = 100000; while (diff < waitfor/1000000) { nanosleep(&tdrift,NULL); gettimeofday(&now2, &zone); diff = ((now2.tv_sec-now1.tv_sec)*1000000 + now2.tv_usec - now1.tv_usec)/1000; } ipipe++; } /* printf("."); fflush(stdout); */ } sched_setscheduler(0, SCHED_OTHER, &s); if (npipe) { fclose(fpipe); } return 1; } //////////////////////////////////////////////////////////// // Easy to use methods bool CCameraIO::Snap( double Duration, bool Light, unsigned short* pImageData, short& xSize, short& ySize ) { // NB This also demonstrates how an application might use the // Expose and GetImage routines. bool ret = Expose( Duration, Light ); if ( !ret ) return false; if ( m_WaitingforTrigger ) { Camera_Status stat; while ( true ) { // This will wait forever if no trigger happens stat = read_Status(); if ( stat == Camera_Status_Exposing ) break; Sleep( 220 ); // dont bog down the CPU while polling } m_WaitingforTrigger = false; } // Only wait a time slightly greater than the duration of the exposure // but enough for the BIR to flush out clock_t StopTime = clock() + long( ( 1.2 * Duration + m_Timeout ) * CLOCKS_PER_SEC ); while ( true ) { Camera_Status stat = read_Status(); if ( stat == Camera_Status_ImageReady ) break; if ( clock() > StopTime ) return false; // Timed out, no image available Sleep( 220 ); // dont bog down the CPU while polling } return GetImage( pImageData, xSize, ySize ); } //////////////////////////////////////////////////////////// // Camera Settings Camera_Status CCameraIO::read_Status() { unsigned short val = 0; Read( Reg_Status, val ); if ( val & RegBit_Exposing ) //11.0 { ATLTRACE( "Exposing\r\n" ); m_WaitingforTrigger = false; m_Status = Camera_Status_Exposing; } else if ( m_WaitingforTrigger ) m_Status = Camera_Status_Waiting; else if ( m_WaitingforImage && ( val & RegBit_FrameDone ) ) //11.11 { ATLTRACE( "ImageReady\r\n" ); m_WaitingforImage = false; m_Status = Camera_Status_ImageReady; } else if ( m_WaitingforLine && ( val & RegBit_LineDone ) ) //11.1 { ATLTRACE( "LineReady\r\n" ); m_WaitingforLine = false; m_Status = Camera_Status_LineReady; } else if ( m_WaitingforImage || m_WaitingforLine ) { ATLTRACE( "Flushing\r\n" ); m_Status = Camera_Status_Flushing; } else m_Status = Camera_Status_Idle; return m_Status; } bool CCameraIO::read_Present() { // This does not work on all cameras /* m_RegShadow[ Reg_BICCounter ] |= RegBit_LoopbackTest; // set bit to 1 Write( Reg_BICCounter, m_RegShadow[ Reg_BICCounter ] ); bool FailedLoopback = false; unsigned short val = 0; Read( Reg_Status, val ); if ( !( val & RegBit_LoopbackTest ) ) FailedLoopback = true; m_RegShadow[ Reg_BICCounter ] &= ~RegBit_LoopbackTest; // clear bit to 0 Write( Reg_BICCounter, m_RegShadow[ Reg_BICCounter ] ); Read( Reg_Status, val ); if ( val & RegBit_LoopbackTest ) FailedLoopback = true; */ unsigned short val = 0; Read( Reg_CommandReadback, val ); // Take snapshot of currrent status m_RegShadow[ Reg_Command ] = val; // remember it in our write shadow bool TriggerEnabled = ( val & RegBit_TriggerEnable ) != 0; m_RegShadow[ Reg_Command ] &= ~RegBit_TriggerEnable;// clear bit to 0 Write( Reg_Command, m_RegShadow[ Reg_Command ] ); Read( Reg_CommandReadback, val ); // get currrent status if ( val & RegBit_TriggerEnable ) return false; m_RegShadow[ Reg_Command ] |= RegBit_TriggerEnable; // set bit to 1 Write( Reg_Command, m_RegShadow[ Reg_Command ] ); Read( Reg_CommandReadback, val ); // get currrent status if ( !(val & RegBit_TriggerEnable) ) return false; m_RegShadow[ Reg_Command ] &= ~RegBit_TriggerEnable;// clear bit to 0 Write( Reg_Command, m_RegShadow[ Reg_Command ] ); Read( Reg_CommandReadback, val ); // get currrent status if ( val & RegBit_TriggerEnable ) return false; if ( TriggerEnabled ) { // Set it back the way it was m_RegShadow[ Reg_Command ] |= RegBit_TriggerEnable; // set bit to 1 Write( Reg_Command, m_RegShadow[ Reg_Command ] ); } return true; } bool CCameraIO::read_Shutter() { unsigned short regval = 0; Read( Reg_Status, regval ); if ( !( regval & RegBit_Exposing ) ) { // We are not exposing, but might have finnshed an exposure // and have not called GetImage yet, so update our internal variable regval = 0; Read( Reg_CommandReadback, regval ); if ( !( regval & RegBit_ShutterOverride ) ) // The shutter override is not on, so the shutter must be closed m_Shutter = false; } return m_Shutter; } bool CCameraIO::read_ForceShutterOpen() { unsigned short val = 0; Read( Reg_CommandReadback, val ); return ( ( val & RegBit_ShutterOverride ) != 0 ); } void CCameraIO::write_ForceShutterOpen( bool val ) { if ( val ) { m_RegShadow[ Reg_Command ] |= RegBit_ShutterOverride; // set bit to 1 m_Shutter = true; // shutter will open immediately now matter what is going on } else { m_RegShadow[ Reg_Command ] &= ~RegBit_ShutterOverride; // clear bit to 0 unsigned short regval = 0; Read( Reg_Status, regval ); if ( ( regval & RegBit_Exposing ) ) { // Shutter will remain open if a Light frame is being taken // however if a dark frame was being exposed while the // override was on or the override is turned on during the exposure // and now is turned off (dumb idea but some app might do it!) // we must update our variable since the shutter will close // when override gets turned off below regval = 0; Read( Reg_CommandReadback, regval ); if ( !( regval & RegBit_ShutterEnable ) ) m_Shutter = false; } else { // Not currently exposing so shutter will close // once override is turned off, update our variable m_Shutter = false; } } Write( Reg_Command, m_RegShadow[ Reg_Command ] ); } bool CCameraIO::read_LongCable() { unsigned short val = 0; Read( Reg_CommandReadback, val ); return ( ( val & RegBit_CableLength ) != 0 ); } void CCameraIO::write_Shutter( bool val ) { if ( val ) m_RegShadow[ Reg_Command ] |= RegBit_ShutterEnable; // set bit to 1 else m_RegShadow[ Reg_Command ] &= ~RegBit_ShutterEnable; // clear bit to 0 Write( Reg_Command, m_RegShadow[ Reg_Command ] ); } void CCameraIO::write_LongCable( bool val ) { if ( val ) m_RegShadow[ Reg_Command ] |= RegBit_CableLength; // set bit to 1 else m_RegShadow[ Reg_Command ] &= ~RegBit_CableLength; // clear bit to 0 Write( Reg_Command, m_RegShadow[ Reg_Command ] ); } short CCameraIO::read_Mode() { return ( ( m_RegShadow[ Reg_LineCounter ] >> RegBitShift_Mode ) & RegBitMask_Mode ); } void CCameraIO::write_Mode( short val ) { // clear bits to 0 m_RegShadow[ Reg_LineCounter ] &= ~( RegBitMask_Mode << RegBitShift_Mode ); // set our new bits m_RegShadow[ Reg_LineCounter ] |= ( (unsigned short) val & RegBitMask_Mode ) << RegBitShift_Mode; Write( Reg_LineCounter, m_RegShadow[ Reg_LineCounter ] ); } short CCameraIO::read_TestBits() { return ( ( m_RegShadow[ Reg_BICCounter ] >> RegBitShift_Test ) & RegBitMask_Test ); } void CCameraIO::write_TestBits( short val ) { // clear bits to 0 m_RegShadow[ Reg_BICCounter ] &= ~( RegBitMask_Test << RegBitShift_Test ); // set our new bits m_RegShadow[ Reg_BICCounter ] |= ( (unsigned short) val & RegBitMask_Test ) << RegBitShift_Test; Write( Reg_BICCounter, m_RegShadow[ Reg_BICCounter ] ); } short CCameraIO::read_Test2Bits() { return ( ( m_RegShadow[ Reg_AICCounter ] >> RegBitShift_Test2 ) & RegBitMask_Test2 ); } void CCameraIO::write_Test2Bits( short val ) { // clear bits to 0 m_RegShadow[ Reg_AICCounter ] &= ~( RegBitMask_Test2 << RegBitShift_Test2 ); // set our new bits m_RegShadow[ Reg_AICCounter ] |= ( (unsigned short) val & RegBitMask_Test2 ) << RegBitShift_Test2; Write( Reg_AICCounter, m_RegShadow[ Reg_AICCounter ] ); } bool CCameraIO::read_FastReadout() { unsigned short val = 0; Read( Reg_CommandReadback , val ); return ( ( val & RegBit_Focus ) != 0 ); } void CCameraIO::write_FastReadout( bool val ) { if ( val ) m_RegShadow[ Reg_Command ] |= RegBit_Focus; // set bit to 1 else m_RegShadow[ Reg_Command ] &= ~RegBit_Focus; // clear bit to 0 Write( Reg_Command, m_RegShadow[ Reg_Command ] ); } bool CCameraIO::read_UseTrigger() { unsigned short val = 0; Read( Reg_CommandReadback , val ); return ( ( val & RegBit_TriggerEnable ) != 0 ); } void CCameraIO::write_UseTrigger( bool val ) { if ( val ) m_RegShadow[ Reg_Command ] |= RegBit_TriggerEnable; // set bit to 1 else m_RegShadow[ Reg_Command ] &= ~RegBit_TriggerEnable; // clear bit to 0 Write( Reg_Command, m_RegShadow[ Reg_Command ] ); } //////////////////////////////////////////////////////////// // Cooler Settings double CCameraIO::read_CoolerSetPoint() { // Get the setting from the shadow registers short DACunits = short( ( m_RegShadow[ Reg_TempSetPoint ] >> RegBitShift_TempSetPoint ) & RegBitMask_TempSetPoint ); return ( DACunits - m_TempCalibration ) / m_TempScale; } void CCameraIO::write_CoolerSetPoint( double val ) { // clear bits to 0 m_RegShadow[ Reg_TempSetPoint ] &= ~( RegBitMask_TempSetPoint << RegBitShift_TempSetPoint ); // Calculate DAC units from degrees Celcius unsigned short DACunits = (unsigned )( m_TempScale * val ) + m_TempCalibration ; // set our new bits m_RegShadow[ Reg_TempSetPoint ] |= ( DACunits & RegBitMask_TempSetPoint ) << RegBitShift_TempSetPoint; Write( Reg_TempSetPoint, m_RegShadow[ Reg_TempSetPoint ] ); } Camera_CoolerStatus CCameraIO::read_CoolerStatus() { unsigned short val = 0; Read( Reg_CommandReadback, val ); if ( val & RegBit_CoolerEnable ) //12.15 { unsigned short val2 = 0; Read( Reg_Status, val2 ); if ( val & RegBit_CoolerShutdown ) //12.8 { if ( val2 & RegBit_ShutdownComplete ) //11.6 m_CoolerStatus = Camera_CoolerStatus_AtAmbient; else m_CoolerStatus = Camera_CoolerStatus_RampingToAmbient; } else { if ( val2 & RegBit_TempAtMax ) //11.5 m_CoolerStatus = Camera_CoolerStatus_AtMax; else if ( val2 & RegBit_TempAtMin ) //11.4 m_CoolerStatus = Camera_CoolerStatus_AtMin; else if ( val2 & RegBit_TempAtSetPoint ) //11.7 m_CoolerStatus = Camera_CoolerStatus_AtSetPoint; // Check against last known cooler status else if ( m_CoolerStatus == Camera_CoolerStatus_AtSetPoint ) m_CoolerStatus = Camera_CoolerStatus_Correcting; else m_CoolerStatus = Camera_CoolerStatus_RampingToSetPoint; } } else m_CoolerStatus = Camera_CoolerStatus_Off; return m_CoolerStatus; } Camera_CoolerMode CCameraIO::read_CoolerMode() { unsigned short val = 0; Read( Reg_CommandReadback, val ); if ( val & RegBit_CoolerShutdown ) return Camera_CoolerMode_Shutdown; else if ( val & RegBit_CoolerEnable ) return Camera_CoolerMode_On; else return Camera_CoolerMode_Off; } void CCameraIO::write_CoolerMode( Camera_CoolerMode val ) { switch ( val ) { case Camera_CoolerMode_Off: m_RegShadow[ Reg_Command ] &= ~( RegBit_CoolerEnable ); // clear bit to 0 m_RegShadow[ Reg_Command ] &= ~( RegBit_CoolerShutdown ); // clear bit to 0 break; case Camera_CoolerMode_On: m_RegShadow[ Reg_Command ] |= RegBit_CoolerEnable; // set bit to 1 break; case Camera_CoolerMode_Shutdown: m_RegShadow[ Reg_Command ] |= RegBit_CoolerShutdown; // set bit to 1 break; default: return; } Write( Reg_Command, m_RegShadow[ Reg_Command ] ); } double CCameraIO::read_Temperature() { if ( m_TempScale == 0.0 ) return 0.0; else { unsigned short val = 0; Read( Reg_TempData, val ); short DACunits = short( ( val >> RegBitShift_TempData ) & RegBitMask_TempData ); return ( DACunits - m_TempCalibration ) / m_TempScale; } } // Load line counter void CCameraIO::LoadLineCounter( unsigned short rows ) { ///////////////////////////////////// // Write out Line_Count - in unbinned rows // clear bits to 0 m_RegShadow[ Reg_LineCounter ] &= ~( RegBitMask_LineCounter << RegBitShift_LineCounter ); // set our new bits m_RegShadow[ Reg_LineCounter ] |= ( rows & RegBitMask_LineCounter ) << RegBitShift_LineCounter; Write( Reg_LineCounter, m_RegShadow[ Reg_LineCounter ] ); ///////////////////////////////////// } // Load AIC, BIC and pixel count into registers void CCameraIO::LoadColumnLayout( unsigned short aic, unsigned short bic, unsigned short pixels ) { ///////////////////////////////////// // Write out AIC - in unbinned columns // clear bits to 0 m_RegShadow[ Reg_AICCounter ] &= ~( RegBitMask_AICCounter << RegBitShift_AICCounter ); // set our new bits m_RegShadow[ Reg_AICCounter ] |= ( aic & RegBitMask_AICCounter ) << RegBitShift_AICCounter; Write( Reg_AICCounter, m_RegShadow[ Reg_AICCounter ] ); ///////////////////////////////////// ///////////////////////////////////// // Write out BIC - in unbinned columns // clear bits to 0 m_RegShadow[ Reg_BICCounter ] &= ~( RegBitMask_BICCounter << RegBitShift_BICCounter ); // set our new bits m_RegShadow[ Reg_BICCounter ] |= ( bic & RegBitMask_BICCounter ) << RegBitShift_BICCounter; Write( Reg_BICCounter, m_RegShadow[ Reg_BICCounter ] ); ///////////////////////////////////// ///////////////////////////////////// // Write out pixel count - in binned columns // clear bits to 0 m_RegShadow[ Reg_PixelCounter ] &= ~( RegBitMask_PixelCounter << RegBitShift_PixelCounter ); // set our new bits m_RegShadow[ Reg_PixelCounter ] |= ( pixels & RegBitMask_PixelCounter ) << RegBitShift_PixelCounter; Write( Reg_PixelCounter, m_RegShadow[ Reg_PixelCounter ] ); ///////////////////////////////////// } // Load timer, vertical binning and horizontal binning in to registers // If Duration parameter is 0 the current timer value will be retained. // The VBin and HBin parameters are one based, the HBin value // is converted to zero base inside this routine. void CCameraIO::LoadTimerAndBinning( double Duration, unsigned short HBin, unsigned short VBin ) { ///////////////////////////////////// // Write out HBin for flushing // clear bits to 0 m_RegShadow[ Reg_PixelCounter ] &= ~( RegBitMask_HBinning << RegBitShift_HBinning ); // set our new bits m_RegShadow[ Reg_PixelCounter ] |= ( ( HBin - 1 ) & RegBitMask_HBinning ) << RegBitShift_HBinning; Write( Reg_PixelCounter, m_RegShadow[ Reg_PixelCounter ] ); ///////////////////////////////////// ///////////////////////////////////// // Write out VBin for flushing and Timer if ( Duration > 0.0 ) { if ( Duration > m_MaxExposure ) Duration = m_MaxExposure; long valTimer; if ( m_FastShutter && Duration <= 1048.575 ) { // Automatically switch to high precision mode valTimer = long( ( Duration * 1000 ) + 0.5 ); m_RegShadow[ Reg_LineCounter ] |= ( m_FastShutterBits_Mode & RegBitMask_Mode ) << RegBitShift_Mode; m_RegShadow[ Reg_BICCounter ] |= ( m_FastShutterBits_Test & RegBitMask_Test ) << RegBitShift_Test; } else { valTimer = long( ( Duration * 100 ) + 0.5 ); if ( m_FastShutter ) { // Disable high precision mode m_RegShadow[ Reg_LineCounter ] &= ~( m_FastShutterBits_Mode & RegBitMask_Mode ) << RegBitShift_Mode; m_RegShadow[ Reg_BICCounter ] &= ~( m_FastShutterBits_Test & RegBitMask_Test ) << RegBitShift_Test; } } if ( m_FastShutter ) { Write( Reg_LineCounter, m_RegShadow[ Reg_LineCounter ] ); Write( Reg_BICCounter, m_RegShadow[ Reg_BICCounter ] ); } if ( valTimer <= 0 ) valTimer = 1; // Safety since firmware doesnt like zero unsigned short valTimerLow = (unsigned short) (valTimer & 0x0000FFFF); unsigned short valTimerHigh = (unsigned short) (valTimer >> 16); // Enable loading of timer values m_RegShadow[ Reg_Command ] |= RegBit_TimerLoad; // set bit to 1 Write( Reg_Command, m_RegShadow[ Reg_Command ] ); // clear bits to 0 m_RegShadow[ Reg_Timer ] = 0; // set our new bits m_RegShadow[ Reg_Timer ] |= ( valTimerLow & RegBitMask_Timer )<< RegBitShift_Timer; Write( Reg_Timer, m_RegShadow[ Reg_Timer ] ); // clear bits to 0 m_RegShadow[ Reg_VBinning ] = 0; // set our new bits m_RegShadow[ Reg_VBinning ] |= ( VBin & RegBitMask_VBinning ) << RegBitShift_VBinning; m_RegShadow[ Reg_VBinning ] |= ( valTimerHigh & RegBitMask_Timer2 ) << RegBitShift_Timer2; Write( Reg_VBinning, m_RegShadow[ Reg_VBinning ] ); // Disable loading of timer values m_RegShadow[ Reg_Command ] &= ~RegBit_TimerLoad; // set bit to 0 Write( Reg_Command, m_RegShadow[ Reg_Command ] ); ///////////////////////////////////// } else { // clear bits to 0 m_RegShadow[ Reg_VBinning ] &= ~( RegBitMask_VBinning << RegBitShift_VBinning ); // set our new bits m_RegShadow[ Reg_VBinning ] |= ( VBin & RegBitMask_VBinning ) << RegBitShift_VBinning; Write( Reg_VBinning, m_RegShadow[ Reg_VBinning ] ); } } // Start flushing the entire CCD (rows = -1) or a specific number or rows void CCameraIO::Flush( short Rows ) { if ( Rows == 0 ) return; unsigned short AIC = (unsigned short) ( m_Columns - m_BIC - m_ImgColumns ); unsigned short Pixels = (unsigned short) ( m_ImgColumns / m_HFlush ); if ( m_ImgColumns % m_HFlush > 0 ) Pixels++; // round up if necessary LoadColumnLayout( AIC, (unsigned short) m_BIC, Pixels ); LoadTimerAndBinning( 0.0, m_HFlush, m_VFlush ); if ( Rows > 0 ) { LoadLineCounter( (unsigned short) Rows ); StartFlushing(); ///////////////////////////////////// // Wait until camera is done flushing clock_t StopTime = clock() + long( m_Timeout * CLOCKS_PER_SEC ); // wait at most m_Timeout seconds while ( true ) { unsigned short val = 0; Read( Reg_Status, val ); if ( ( val & RegBit_FrameDone ) != 0 ) break; if ( clock() > StopTime ) break; // Timed out } } else { LoadLineCounter( (unsigned short) m_ImgRows ); StartFlushing(); } } void CCameraIO::StartFlushing() { ///////////////////////////////////// // Start flushing m_RegShadow[ Reg_Command ] |= RegBit_StartFlushing; // set bit to 1 Write( Reg_Command, m_RegShadow[ Reg_Command ] ); m_RegShadow[ Reg_Command ] &= ~RegBit_StartFlushing;// set bit to 0 Write( Reg_Command, m_RegShadow[ Reg_Command ] ); ///////////////////////////////////// } void CCameraIO::StopFlushing() { ///////////////////////////////////// // Stop flushing m_RegShadow[ Reg_Command ] |= RegBit_StopFlushing; // set bit to 1 Write( Reg_Command, m_RegShadow[ Reg_Command ] ); m_RegShadow[ Reg_Command ] &= ~RegBit_StopFlushing; // set bit to 0 Write( Reg_Command, m_RegShadow[ Reg_Command ] ); ///////////////////////////////////// } libapogee2-2.2/ApnCamData_KAI4020CL.h0000644000175000017500000000220611110507150014500 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_KAI4020CL.h: Interface file for the CApnCamData_KAI4020CL class. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #if _MSC_VER > 1000 #pragma once #endif // _MSC_VER> 1000 #include "ApnCamData.h" class CApnCamData_KAI4020CL : public CApnCamData { public: CApnCamData_KAI4020CL(); virtual ~CApnCamData_KAI4020CL(); void Initialize(); private: void set_vpattern(); void set_hpattern_clamp_sixteen(); void set_hpattern_skip_sixteen(); void set_hpattern_roi_sixteen(); void set_hpattern_clamp_twelve(); void set_hpattern_skip_twelve(); void set_hpattern_roi_twelve(); void set_hpattern( APN_HPATTERN_FILE *Pattern, unsigned short Mask, unsigned short BinningLimit, unsigned short RefNumElements, unsigned short SigNumElements, unsigned short BinNumElements[], unsigned short RefPatternData[], unsigned short SigPatternData[], unsigned short BinPatternData[][APN_MAX_PATTERN_ENTRIES] ); }; libapogee2-2.2/ApnCamData_CCD4240B.h0000644000175000017500000000220111110507150014347 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_CCD4240B.h: Interface file for the CApnCamData_CCD4240B class. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #if _MSC_VER > 1000 #pragma once #endif // _MSC_VER> 1000 #include "ApnCamData.h" class CApnCamData_CCD4240B : public CApnCamData { public: CApnCamData_CCD4240B(); virtual ~CApnCamData_CCD4240B(); void Initialize(); private: void set_vpattern(); void set_hpattern_clamp_sixteen(); void set_hpattern_skip_sixteen(); void set_hpattern_roi_sixteen(); void set_hpattern_clamp_twelve(); void set_hpattern_skip_twelve(); void set_hpattern_roi_twelve(); void set_hpattern( APN_HPATTERN_FILE *Pattern, unsigned short Mask, unsigned short BinningLimit, unsigned short RefNumElements, unsigned short SigNumElements, unsigned short BinNumElements[], unsigned short RefPatternData[], unsigned short SigPatternData[], unsigned short BinPatternData[][APN_MAX_PATTERN_ENTRIES] ); }; libapogee2-2.2/ApnCamData_KAF1301EB.h0000644000175000017500000000220611110507150014464 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_KAF1301EB.h: Interface file for the CApnCamData_KAF1301EB class. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #if _MSC_VER > 1000 #pragma once #endif // _MSC_VER> 1000 #include "ApnCamData.h" class CApnCamData_KAF1301EB : public CApnCamData { public: CApnCamData_KAF1301EB(); virtual ~CApnCamData_KAF1301EB(); void Initialize(); private: void set_vpattern(); void set_hpattern_clamp_sixteen(); void set_hpattern_skip_sixteen(); void set_hpattern_roi_sixteen(); void set_hpattern_clamp_twelve(); void set_hpattern_skip_twelve(); void set_hpattern_roi_twelve(); void set_hpattern( APN_HPATTERN_FILE *Pattern, unsigned short Mask, unsigned short BinningLimit, unsigned short RefNumElements, unsigned short SigNumElements, unsigned short BinNumElements[], unsigned short RefPatternData[], unsigned short SigPatternData[], unsigned short BinPatternData[][APN_MAX_PATTERN_ENTRIES] ); }; libapogee2-2.2/ApnCamData_KAI4020ML.cpp0000644000175000017500000005316711110507150015061 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_KAI4020ML.cpp: Implementation file for the CApnCamData_KAI4020ML class. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #include "ApnCamData_KAI4020ML.h" #include #include #include ///////////////////////////////////////////////////////////// // Construction/Destruction ///////////////////////////////////////////////////////////// CApnCamData_KAI4020ML::CApnCamData_KAI4020ML() { } CApnCamData_KAI4020ML::~CApnCamData_KAI4020ML() { } void CApnCamData_KAI4020ML::Initialize() { strcpy( m_Sensor, "KAI4020ML" ); strcpy( m_CameraModel, "4020ml" ); m_CameraId = 66; m_InterlineCCD = true; m_SupportsSerialA = true; m_SupportsSerialB = true; m_SensorTypeCCD = true; m_TotalColumns = 2136; m_ImagingColumns = 2048; m_ClampColumns = 44; m_PreRoiSkipColumns = 0; m_PostRoiSkipColumns = 0; m_OverscanColumns = 44; m_TotalRows = 2072; m_ImagingRows = 2048; m_UnderscanRows = 16; m_OverscanRows = 8; m_VFlushBinning = 1; m_EnableSingleRowOffset = false; m_RowOffsetBinning = 1; m_HFlushDisable = false; m_ShutterCloseDelay = 0; m_PixelSizeX = 7.4; m_PixelSizeY = 7.4; m_Color = false; m_ReportedGainSixteenBit = 1; m_MinSuggestedExpTime = 0.05; m_CoolingSupported = true; m_RegulatedCoolingSupported = true; m_TempSetPoint = -20.0; m_TempRampRateOne = 700; m_TempRampRateTwo = 4000; m_TempBackoffPoint = 2.0; m_PrimaryADType = ApnAdType_Alta_Sixteen; m_AlternativeADType = ApnAdType_Alta_Twelve; m_DefaultGainLeft = 0; m_DefaultOffsetLeft = 100; m_DefaultGainRight = -1; m_DefaultOffsetRight = -1; m_DefaultRVoltage = 1000; m_DefaultSpeed = 0xffff; m_DefaultDataReduction = false; set_vpattern(); set_hpattern_clamp_sixteen(); set_hpattern_skip_sixteen(); set_hpattern_roi_sixteen(); set_hpattern_clamp_twelve(); set_hpattern_skip_twelve(); set_hpattern_roi_twelve(); } void CApnCamData_KAI4020ML::set_vpattern() { const unsigned short Mask = 0x106; const unsigned short NumElements = 38; unsigned short Pattern[NumElements] = { 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0302, 0x0302, 0x0302, 0x0302, 0x0302, 0x0302, 0x0302, 0x0302, 0x0302, 0x0302, 0x0002, 0x0002, 0x0002, 0x0003, 0x0002 }; m_VerticalPattern.Mask = Mask; m_VerticalPattern.NumElements = NumElements; m_VerticalPattern.PatternData = (unsigned short *)malloc(NumElements * sizeof(unsigned short)); for ( int i=0; iMask = Mask; Pattern->BinningLimit = BinningLimit; Pattern->RefNumElements = RefNumElements; Pattern->SigNumElements = SigNumElements; if ( RefNumElements > 0 ) { Pattern->RefPatternData = (unsigned short *)malloc(RefNumElements * sizeof(unsigned short)); for ( i=0; iRefPatternData[i] = RefPatternData[i]; } } if ( SigNumElements > 0 ) { Pattern->SigPatternData = (unsigned short *)malloc(SigNumElements * sizeof(unsigned short)); for ( i=0; iSigPatternData[i] = SigPatternData[i]; } } if ( BinningLimit > 0 ) { for ( i=0; iBinNumElements[i] = BinNumElements[i]; Pattern->BinPatternData[i] = (unsigned short *)malloc(BinNumElements[i] * sizeof(unsigned short)); for ( j=0; jBinPatternData[i][j] = BinPatternData[i][j]; } } } } libapogee2-2.2/CameraIO_LinuxPCI.cpp0000644000175000017500000002547111110507150015035 0ustar jrjr// CameraIO.cpp: implementation of the CCameraIO class. // // Copyright (c) 2000 Apogee Instruments Inc. ////////////////////////////////////////////////////////////////////// #ifndef LINUX #include "stdafx.h" #else #include #include #include #include #include #include #include #include #include #define HANDLE int #define FALSE 0 #define DWORD long #define _ASSERT assert #define REALTIME_PRIORITY_CLASS 1 #define GetCurrentProcess getpid #define LOBYTE(x) ((x) & 0xff) #define HIBYTE(x) ((x >> 8) & 0xff) #endif #define MIRQ1 0x21 #define MIRQ2 0xA1 #include "time.h" #include "tcl.h" #include "ccd.h" #include "CameraIO_Linux.h" #include "ApogeeLinux.h" const int NUM_POSITIONS = 6; const int NUM_STEPS_PER_FILTER = 48; const int STEP_DELAY = 10; const unsigned char Steps[] = { 0x10, 0x30, 0x20, 0x60, 0x40, 0xc0, 0x80, 0x90 }; const int NUM_STEPS = sizeof ( Steps ); ////////////////////////////////////////////////////////////////////// // Construction/Destruction ////////////////////////////////////////////////////////////////////// void CCameraIO::InitDefaults() { //////////////////////////////////////////////////////////// // Camera Settings m_HighPriority = true; m_PPRepeat = 1; m_DataBits = 16; m_FastShutter = false; m_MaxBinX = 8; m_MaxBinY = 63; m_MaxExposure = 10485.75; m_MinExposure = 0.01; m_GuiderRelays = false; m_Timeout = 2.0; //////////////////////////////////////////////////////////// // Cooler Settings m_TempControl = true; m_TempCalibration = 160; m_TempScale = 2.1; //////////////////////////////////////////////////////////// // Exposure Settings m_BinX = 1; m_BinY = 1; m_StartX = 0; m_StartY = 0; m_NumX = 1; m_NumY = 1; //////////////////////////////////////////////////////////// // Geometry Settings m_Columns = 0; m_Rows = 0; m_SkipC = 0; m_SkipR = 0; m_HFlush = 1; m_VFlush = 1; m_BIC = 4; m_BIR = 4; m_ImgColumns = 0; m_ImgRows = 0; //////////////////////////////////////////////////////////// // CCD Settings memset( m_Sensor, 0, 256 ); m_Color = false; m_Noise = 0.0; m_Gain = 0.0; m_PixelXSize = 0.0; m_PixelYSize = 0.0; //////////////////////////////////////////////////////////// // Internal variables fileHandle = 0; m_RegisterOffset = 0; m_Interface = Camera_Interface_PCI; m_SensorType = Camera_SensorType_CCD; } bool CCameraIO::InitDriver(unsigned short camnum) { char deviceName[64]; sprintf(deviceName,"%s%d",APOGEE_PCI_DEVICE,camnum); fileHandle = ::open(deviceName,O_RDONLY); if (fileHandle == -1) return false; return true; } long CCameraIO::Write( unsigned short reg, unsigned short val ) { int status; unsigned short RegNumber; struct apIOparam request; switch ( reg ) { case Reg_Command: RegNumber = RegPCI_Command; break; case Reg_Timer: RegNumber = RegPCI_Timer; break; case Reg_VBinning: RegNumber = RegPCI_VBinning; break; case Reg_AICCounter: RegNumber = RegPCI_AICCounter; break; case Reg_TempSetPoint: RegNumber = RegPCI_TempSetPoint; break; case Reg_PixelCounter: RegNumber = RegPCI_PixelCounter; break; case Reg_LineCounter: RegNumber = RegPCI_LineCounter; break; case Reg_BICCounter: RegNumber = RegPCI_BICCounter; break; default: _ASSERT ( false ); return 0; } request.reg = RegNumber; request.param1=(int)val; status=ioctl(fileHandle,APPCI_WRITE_USHORT,(unsigned long)&request); return 0; } long CCameraIO::Read( unsigned short reg, unsigned short& val ) { int retval, status; struct apIOparam request; unsigned short RegNumber; switch ( reg ) { case Reg_Command: RegNumber = RegPCI_CommandRead; break; case Reg_Timer: RegNumber = RegPCI_TimerRead; break; case Reg_VBinning: RegNumber = RegPCI_VBinningRead; break; case Reg_AICCounter: RegNumber = RegPCI_AICCounterRead; break; case Reg_TempSetPoint: RegNumber = RegPCI_TempSetPointRead; break; case Reg_PixelCounter: RegNumber = RegPCI_PixelCounterRead; break; case Reg_LineCounter: RegNumber = RegPCI_LineCounterRead; break; case Reg_BICCounter: RegNumber = RegPCI_BICCounterRead; break; case Reg_ImageData: RegNumber = RegPCI_ImageData; break; case Reg_TempData: RegNumber = RegPCI_TempData; break; case Reg_Status: RegNumber = RegPCI_Status; break; case Reg_CommandReadback: RegNumber = RegPCI_CommandReadback; break; default: assert( 1 ); // application program bug val = 0; return 0; } request.reg = RegNumber; request.param1=(unsigned long)&retval; status=ioctl(fileHandle,APPCI_READ_USHORT,(unsigned long)&request); val = (unsigned short)retval; return 0; } // Returns 0 if successfull, 1 if Line_Done poll timed out. long CCameraIO::ReadLine( long SkipPixels, long Pixels,unsigned short* pLineBuffer ) { int j; int retval, status; struct apIOparam request; if ( !m_TDI ) { ///////////////////////////////////// // Clock out the line m_RegShadow[ Reg_Command ] |= RegBit_StartNextLine; // set bit to 1 Write( Reg_Command, m_RegShadow[ Reg_Command ] ); m_RegShadow[ Reg_Command ] &= ~RegBit_StartNextLine; // set bit to 0 Write( Reg_Command, m_RegShadow[ Reg_Command ] ); ///////////////////////////////////// } request.reg = RegPCI_ImageData; request.param1=(unsigned long)&retval; for (j = 0; j < SkipPixels; j++) { status=ioctl(fileHandle,APPCI_READ_USHORT,(unsigned long)&request); } for (j = 0; j < Pixels; j++) { status=ioctl(fileHandle,APPCI_READ_USHORT,(unsigned long)&request); *pLineBuffer++ = (unsigned short)retval; } ///////////////////////////////////// // Assert done reading line m_RegShadow[ Reg_Command ] |= RegBit_DoneReading; // set bit to 1 Write( Reg_Command, m_RegShadow[ Reg_Command ] ); m_RegShadow[ Reg_Command ] &= ~RegBit_DoneReading; // set bit to 0 Write( Reg_Command, m_RegShadow[ Reg_Command ] ); ///////////////////////////////////// if ( !m_TDI ) { ///////////////////////////////////// // Wait until camera is done clock_t StopTime = clock() + CLOCKS_PER_SEC; // wait at most one second while ( true ) { unsigned short val = 0; Read( Reg_Status, val ); if ( ( val & RegBit_LineDone ) != 0 ) break;// Line done if ( clock() > StopTime ) return 1; // Timed out } } return 0; } long CCameraIO::ReadImage( unsigned short* pImageBuffer ) { m_RegShadow[ Reg_Command ] |= RegBit_FIFOCache; // set bit to 1 Write( Reg_Command, m_RegShadow[ Reg_Command ] ); long XEnd = long( m_ExposureNumX ); long SkipC = long( m_ExposureSkipC ); for (long i = 0; i < m_ExposureSkipR; i++) { if( InternalReadLine( false, SkipC, XEnd, NULL ) ) return 1; } long YEnd = long( m_ExposureNumY ); unsigned short* pLineBuffer = pImageBuffer; for (long i = 0; i < YEnd; i++) { if ( InternalReadLine( true, SkipC, XEnd, pLineBuffer ) ) return 1; pLineBuffer += XEnd; } m_RegShadow[ Reg_Command ] &= !RegBit_FIFOCache; // set bit to 0 Write( Reg_Command, m_RegShadow[ Reg_Command ] ); return 0; } // Returns 0 if successfull, 1 if Line_Done poll timed out. long CCameraIO::InternalReadLine( bool KeepData, long SkipC, long XEnd, unsigned short* pLineBuffer ) { struct apIOparam request; int retval, status; ///////////////////////////////////// // Clock out the line m_RegShadow[ Reg_Command ] |= RegBit_StartNextLine; // set bit to 1 Write( Reg_Command, m_RegShadow[ Reg_Command ] ); m_RegShadow[ Reg_Command ] &= !RegBit_StartNextLine; // set bit to 0 Write( Reg_Command, m_RegShadow[ Reg_Command ] ); ///////////////////////////////////// request.reg = RegPCI_ImageData; request.param1=(unsigned long)&retval; for (long j = 0; j < SkipC; j++) status=ioctl(fileHandle,APPCI_READ_USHORT,(unsigned long)&request); if ( KeepData ) { for (long j = 0; j < XEnd; j++) { status=ioctl(fileHandle,APPCI_READ_USHORT,(unsigned long)&request); *pLineBuffer++ = (unsigned short)retval; } } else { for (long j = 0; j < XEnd; j++) status=ioctl(fileHandle,APPCI_READ_USHORT,(unsigned long)&request); } ///////////////////////////////////// // Assert done reading line m_RegShadow[ Reg_Command ] |= RegBit_DoneReading; // set bit to 1 Write( Reg_Command, m_RegShadow[ Reg_Command ] ); m_RegShadow[ Reg_Command ] &= !RegBit_DoneReading; // set bit to 0 Write( Reg_Command, m_RegShadow[ Reg_Command ] ); ///////////////////////////////////// ///////////////////////////////////// // Wait until camera is done clocking clock_t StopTime = clock() + CLOCKS_PER_SEC; // wait at most one second while ( true ) { unsigned short val = 0; Read( Reg_Status, val ); if ( ( val & RegBit_LineDone ) != 0 ) break;// Line done clock_t CurrentTime = clock(); if ( CurrentTime > StopTime ) return 1; // Timed out } return 0; } libapogee2-2.2/ApnCamData_KAF10011105.h0000644000175000017500000000222011110507150014555 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_KAF10011105.h: Interface file for the CApnCamData_KAF10011105 class. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #if _MSC_VER > 1000 #pragma once #endif // _MSC_VER> 1000 #include "ApnCamData.h" class CApnCamData_KAF10011105 : public CApnCamData { public: CApnCamData_KAF10011105(); virtual ~CApnCamData_KAF10011105(); void Initialize(); private: void set_vpattern(); void set_hpattern_clamp_sixteen(); void set_hpattern_skip_sixteen(); void set_hpattern_roi_sixteen(); void set_hpattern_clamp_twelve(); void set_hpattern_skip_twelve(); void set_hpattern_roi_twelve(); void set_hpattern( APN_HPATTERN_FILE *Pattern, unsigned short Mask, unsigned short BinningLimit, unsigned short RefNumElements, unsigned short SigNumElements, unsigned short BinNumElements[], unsigned short RefPatternData[], unsigned short SigPatternData[], unsigned short BinPatternData[][APN_MAX_PATTERN_ENTRIES] ); }; libapogee2-2.2/ApnCamData_KAF1401E.cpp0000644000175000017500000006120611110507150014723 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_KAF1401E.cpp: Implementation file for the CApnCamData_KAF1401E class. // // Copyright (c) 2003, 2004 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #include "ApnCamData_KAF1401E.h" #include #include #include ///////////////////////////////////////////////////////////// // Construction/Destruction ///////////////////////////////////////////////////////////// CApnCamData_KAF1401E::CApnCamData_KAF1401E() { } CApnCamData_KAF1401E::~CApnCamData_KAF1401E() { } void CApnCamData_KAF1401E::Initialize() { strcpy( m_Sensor, "KAF1401E" ); strcpy( m_CameraModel, "14" ); m_CameraId = 4; m_InterlineCCD = false; m_SupportsSerialA = true; m_SupportsSerialB = true; m_SensorTypeCCD = true; m_TotalColumns = 1348; m_ImagingColumns = 1320; m_ClampColumns = 26; m_PreRoiSkipColumns = 0; m_PostRoiSkipColumns = 0; m_OverscanColumns = 2; m_TotalRows = 1037; m_ImagingRows = 1035; m_UnderscanRows = 1; m_OverscanRows = 1; m_VFlushBinning = 1; m_EnableSingleRowOffset = false; m_RowOffsetBinning = 1; m_HFlushDisable = false; m_ShutterCloseDelay = 200; m_PixelSizeX = 6.8; m_PixelSizeY = 6.8; m_Color = false; m_ReportedGainSixteenBit = 1; m_MinSuggestedExpTime = 10.0; m_CoolingSupported = true; m_RegulatedCoolingSupported = true; m_TempSetPoint = -20.0; m_TempRampRateOne = 700; m_TempRampRateTwo = 4000; m_TempBackoffPoint = 2.0; m_PrimaryADType = ApnAdType_Alta_Sixteen; m_AlternativeADType = ApnAdType_Alta_Twelve; //m_DefaultGainTwelveBit = 0; //m_DefaultOffsetTwelveBit = 100; m_DefaultRVoltage = 1000; set_vpattern(); set_hpattern_clamp_sixteen(); set_hpattern_skip_sixteen(); set_hpattern_roi_sixteen(); set_hpattern_clamp_twelve(); set_hpattern_skip_twelve(); set_hpattern_roi_twelve(); } void CApnCamData_KAF1401E::set_vpattern() { const unsigned short Mask = 0x0; const unsigned short NumElements = 71; unsigned short Pattern[NumElements] = { 0x0000, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0001, 0x0000 }; m_VerticalPattern.Mask = Mask; m_VerticalPattern.NumElements = NumElements; m_VerticalPattern.PatternData = (unsigned short *)malloc(NumElements * sizeof(unsigned short)); for ( int i=0; iMask = Mask; Pattern->BinningLimit = BinningLimit; Pattern->RefNumElements = RefNumElements; Pattern->SigNumElements = SigNumElements; if ( RefNumElements > 0 ) { Pattern->RefPatternData = (unsigned short *)malloc(RefNumElements * sizeof(unsigned short)); for ( i=0; iRefPatternData[i] = RefPatternData[i]; } } if ( SigNumElements > 0 ) { Pattern->SigPatternData = (unsigned short *)malloc(SigNumElements * sizeof(unsigned short)); for ( i=0; iSigPatternData[i] = SigPatternData[i]; } } if ( BinningLimit > 0 ) { for ( i=0; iBinNumElements[i] = BinNumElements[i]; Pattern->BinPatternData[i] = (unsigned short *)malloc(BinNumElements[i] * sizeof(unsigned short)); for ( j=0; jBinPatternData[i][j] = BinPatternData[i][j]; } } } } libapogee2-2.2/ApnCamData_KAI2020MLB.h0000644000175000017500000000221311110507150014610 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_KAI2020MLB.h: Interface file for the CApnCamData_KAI2020MLB class. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #if _MSC_VER > 1000 #pragma once #endif // _MSC_VER> 1000 #include "ApnCamData.h" class CApnCamData_KAI2020MLB : public CApnCamData { public: CApnCamData_KAI2020MLB(); virtual ~CApnCamData_KAI2020MLB(); void Initialize(); private: void set_vpattern(); void set_hpattern_clamp_sixteen(); void set_hpattern_skip_sixteen(); void set_hpattern_roi_sixteen(); void set_hpattern_clamp_twelve(); void set_hpattern_skip_twelve(); void set_hpattern_roi_twelve(); void set_hpattern( APN_HPATTERN_FILE *Pattern, unsigned short Mask, unsigned short BinningLimit, unsigned short RefNumElements, unsigned short SigNumElements, unsigned short BinNumElements[], unsigned short RefPatternData[], unsigned short SigPatternData[], unsigned short BinPatternData[][APN_MAX_PATTERN_ENTRIES] ); }; libapogee2-2.2/test_hatalta.cpp0000644000175000017500000001062311110507150014350 0ustar jrjr//============================================================================ // Apogee minimal CCD test program // Zoltan Csubry // zcsubry@cfa.harvard.edu //============================================================================ #include #include #include #include //--- Static function declarations ------------------------------------------- static bool ping( std::string address ); static std::string downloadFile( std::string address, std::string file ); //============================================================================ int main() { //--- allocate memory for ccd object --------------------------------- CApnCamera *ccd = new CApnCamera(); //--- define ccd network information --------------------------------- std::string cam_ip_str = "192.168.0.198"; unsigned long cam_ip_long = 3232235718; unsigned short cam_port = 80; std::string cam_mac = "00095100008A"; //--- send ping to camera -------------------------------------------- if ( !ping( cam_ip_str ) ) { std::cout<<"\n=== Address is not available ===\n"; exit ( -1 ); } //--- download session close file ------------------------------------ downloadFile( cam_ip_str, "SESSION?Close" ); //--- init CCD driver ------------------------------------------------ if ( ! ccd->InitDriver( cam_ip_long, cam_port, 0 ) ) { std::cout<<"\n=== Failed to initialize CCD driver ===\n"; exit( -1 ); } std::cout<<"\n=== Initialized Apogee CCD ===\n"; //--- make some CCD action ------------------------------------------- ccd->read_CoolerEnable(); ccd->read_FanMode(); ccd->read_CoolerSetPoint(); ccd->read_CoolerBackoffPoint(); ccd->read_ShutterState(); ccd->read_CoolerStatus(); ccd->read_ImagingStatus(); ccd->read_TempCCD(); ccd->read_TempHeatsink(); //--- close CCD driver ----------------------------------------------- if ( ! ccd->CloseDriver() ) { std::cout<<"\n=== Failed to close CCD driver ===\n"; exit( -1 ); } std::cout<<"\n=== Closed Apogee CCD ===\n"; } //============================================================================ // Network utility functions (using Apogee network functions) //============================================================================ extern "C" { extern int InternetOpen( char *iname, int itype, int *dum, int *dum2, int dum3); extern int InternetOpenUrl( int g_hSession, char *url, int *dum1, int *dum2, int dum3, int dum4 ); extern void InternetQueryDataAvailable(int handle, long *bcount, int dum1, int dum2); extern void InternetReadFile(int handle, char *lpBuffer, long bcount, long *bread); extern void InternetCloseHandle( int handle ); } //============================================================================ // Send ping command to address //============================================================================ bool ping( std::string address ) { std::string cmd = "ping -c 2 -w 5 " + address; if ( system( cmd.c_str() ) != 0 ) return false; return true; } //============================================================================ // Download a file from a web server and return string buffer //============================================================================ std::string downloadFile( std::string address, std::string file ) { std::string szUrl; HINTERNET hService, g_hSession; DWORD dwBytesAvailable, dwBytesRead = 0; char *lpBuffer; //--- Open internet session ------------------------------------------ g_hSession = InternetOpen( "ApogeeNet", INTERNET_OPEN_TYPE_DIRECT, NULL, NULL, 0 ); if ( g_hSession == 0 ) return ""; //--- Open url, close session if failed ------------------------------ szUrl = HTTP_PREAMBLE + address + "/" + file; hService = InternetOpenUrl( g_hSession, (char*) szUrl.c_str(), NULL, 0, 0, 0 ); if ( hService == 0 ) { InternetCloseHandle( g_hSession ); return ""; } //--- Get file content into a buffer --------------------------------- InternetQueryDataAvailable(hService, &dwBytesAvailable, 0, 0); lpBuffer = new char[dwBytesAvailable+1]; InternetReadFile(hService, lpBuffer, dwBytesAvailable, &dwBytesRead); lpBuffer[dwBytesRead] = 0; std::string fbuffer( lpBuffer ); delete lpBuffer; //--- Close session -------------------------------------------------- InternetCloseHandle( g_hSession ); return fbuffer; } //============================================================================ libapogee2-2.2/ApnCamData_KAF0261EB.cpp0000644000175000017500000004414211110507150015030 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_KAF0261EB.cpp: Implementation file for the CApnCamData_KAF0261EB class. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #include "ApnCamData_KAF0261EB.h" #include #include #include ///////////////////////////////////////////////////////////// // Construction/Destruction ///////////////////////////////////////////////////////////// CApnCamData_KAF0261EB::CApnCamData_KAF0261EB() { } CApnCamData_KAF0261EB::~CApnCamData_KAF0261EB() { } void CApnCamData_KAF0261EB::Initialize() { strcpy( m_Sensor, "KAF0261EB" ); strcpy( m_CameraModel, "260" ); m_CameraId = 34; m_InterlineCCD = false; m_SupportsSerialA = true; m_SupportsSerialB = true; m_SensorTypeCCD = true; m_TotalColumns = 530; m_ImagingColumns = 512; m_ClampColumns = 8; m_PreRoiSkipColumns = 0; m_PostRoiSkipColumns = 0; m_OverscanColumns = 10; m_TotalRows = 520; m_ImagingRows = 512; m_UnderscanRows = 4; m_OverscanRows = 4; m_VFlushBinning = 1; m_EnableSingleRowOffset = false; m_RowOffsetBinning = 1; m_HFlushDisable = false; m_ShutterCloseDelay = 20; m_PixelSizeX = 20; m_PixelSizeY = 20; m_Color = false; m_ReportedGainSixteenBit = 3; m_MinSuggestedExpTime = 10.0; m_CoolingSupported = true; m_RegulatedCoolingSupported = true; m_TempSetPoint = -20.0; m_TempRampRateOne = 400; m_TempRampRateTwo = 3500; m_TempBackoffPoint = 2.0; m_PrimaryADType = ApnAdType_Alta_Sixteen; m_AlternativeADType = ApnAdType_Alta_Twelve; m_DefaultGainLeft = 0; m_DefaultOffsetLeft = 250; m_DefaultGainRight = -1; m_DefaultOffsetRight = -1; m_DefaultRVoltage = 1000; m_DefaultSpeed = 0xffff; m_DefaultDataReduction = false; set_vpattern(); set_hpattern_clamp_sixteen(); set_hpattern_skip_sixteen(); set_hpattern_roi_sixteen(); set_hpattern_clamp_twelve(); set_hpattern_skip_twelve(); set_hpattern_roi_twelve(); } void CApnCamData_KAF0261EB::set_vpattern() { const unsigned short Mask = 0x6; const unsigned short NumElements = 71; unsigned short Pattern[NumElements] = { 0x0000, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0001, 0x0000 }; m_VerticalPattern.Mask = Mask; m_VerticalPattern.NumElements = NumElements; m_VerticalPattern.PatternData = (unsigned short *)malloc(NumElements * sizeof(unsigned short)); for ( int i=0; iMask = Mask; Pattern->BinningLimit = BinningLimit; Pattern->RefNumElements = RefNumElements; Pattern->SigNumElements = SigNumElements; if ( RefNumElements > 0 ) { Pattern->RefPatternData = (unsigned short *)malloc(RefNumElements * sizeof(unsigned short)); for ( i=0; iRefPatternData[i] = RefPatternData[i]; } } if ( SigNumElements > 0 ) { Pattern->SigPatternData = (unsigned short *)malloc(SigNumElements * sizeof(unsigned short)); for ( i=0; iSigPatternData[i] = SigPatternData[i]; } } if ( BinningLimit > 0 ) { for ( i=0; iBinNumElements[i] = BinNumElements[i]; Pattern->BinPatternData[i] = (unsigned short *)malloc(BinNumElements[i] * sizeof(unsigned short)); for ( j=0; jBinPatternData[i][j] = BinPatternData[i][j]; } } } } libapogee2-2.2/ApnCamData_CCD5710B.cpp0000644000175000017500000004234111110507150014716 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_CCD5710B.cpp: Implementation file for the CApnCamData_CCD5710B class. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #include "ApnCamData_CCD5710B.h" #include #include #include ///////////////////////////////////////////////////////////// // Construction/Destruction ///////////////////////////////////////////////////////////// CApnCamData_CCD5710B::CApnCamData_CCD5710B() { } CApnCamData_CCD5710B::~CApnCamData_CCD5710B() { } void CApnCamData_CCD5710B::Initialize() { strcpy( m_Sensor, "CCD5710B" ); strcpy( m_CameraModel, "57" ); m_CameraId = 15; m_InterlineCCD = false; m_SupportsSerialA = true; m_SupportsSerialB = true; m_SensorTypeCCD = true; m_TotalColumns = 536; m_ImagingColumns = 512; m_ClampColumns = 24; m_PreRoiSkipColumns = 0; m_PostRoiSkipColumns = 0; m_OverscanColumns = 12; m_TotalRows = 1056; m_ImagingRows = 512; m_UnderscanRows = 540; m_OverscanRows = 4; m_VFlushBinning = 1; m_EnableSingleRowOffset = true; m_RowOffsetBinning = 540; m_HFlushDisable = false; m_ShutterCloseDelay = 0; m_PixelSizeX = 13; m_PixelSizeY = 13; m_Color = false; m_ReportedGainSixteenBit = 2; m_MinSuggestedExpTime = 1.0; m_CoolingSupported = true; m_RegulatedCoolingSupported = true; m_TempSetPoint = -20.0; m_TempRampRateOne = 700; m_TempRampRateTwo = 4000; m_TempBackoffPoint = 2.0; m_PrimaryADType = ApnAdType_Alta_Sixteen; m_AlternativeADType = ApnAdType_Alta_Twelve; m_DefaultGainLeft = 400; m_DefaultOffsetLeft = 200; m_DefaultGainRight = -1; m_DefaultOffsetRight = -1; m_DefaultRVoltage = 1000; m_DefaultSpeed = 0xffff; m_DefaultDataReduction = false; set_vpattern(); set_hpattern_clamp_sixteen(); set_hpattern_skip_sixteen(); set_hpattern_roi_sixteen(); set_hpattern_clamp_twelve(); set_hpattern_skip_twelve(); set_hpattern_roi_twelve(); } void CApnCamData_CCD5710B::set_vpattern() { const unsigned short Mask = 0xE; const unsigned short NumElements = 129; unsigned short Pattern[NumElements] = { 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0001, 0x0000 }; m_VerticalPattern.Mask = Mask; m_VerticalPattern.NumElements = NumElements; m_VerticalPattern.PatternData = (unsigned short *)malloc(NumElements * sizeof(unsigned short)); for ( int i=0; iMask = Mask; Pattern->BinningLimit = BinningLimit; Pattern->RefNumElements = RefNumElements; Pattern->SigNumElements = SigNumElements; if ( RefNumElements > 0 ) { Pattern->RefPatternData = (unsigned short *)malloc(RefNumElements * sizeof(unsigned short)); for ( i=0; iRefPatternData[i] = RefPatternData[i]; } } if ( SigNumElements > 0 ) { Pattern->SigPatternData = (unsigned short *)malloc(SigNumElements * sizeof(unsigned short)); for ( i=0; iSigPatternData[i] = SigPatternData[i]; } } if ( BinningLimit > 0 ) { for ( i=0; iBinNumElements[i] = BinNumElements[i]; Pattern->BinPatternData[i] = (unsigned short *)malloc(BinNumElements[i] * sizeof(unsigned short)); for ( j=0; jBinPatternData[i][j] = BinPatternData[i][j]; } } } } libapogee2-2.2/ApnCamData_KAF1401E.h0000644000175000017500000000221211110507150014360 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_KAF1401E.h: Interface file for the CApnCamData_KAF1401E class. // // Copyright (c) 2003, 2004 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #if _MSC_VER > 1000 #pragma once #endif // _MSC_VER> 1000 #include "ApnCamData.h" class CApnCamData_KAF1401E : public CApnCamData { public: CApnCamData_KAF1401E(); virtual ~CApnCamData_KAF1401E(); void Initialize(); private: void set_vpattern(); void set_hpattern_clamp_sixteen(); void set_hpattern_skip_sixteen(); void set_hpattern_roi_sixteen(); void set_hpattern_clamp_twelve(); void set_hpattern_skip_twelve(); void set_hpattern_roi_twelve(); void set_hpattern( APN_HPATTERN_FILE *Pattern, unsigned short Mask, unsigned short BinningLimit, unsigned short RefNumElements, unsigned short SigNumElements, unsigned short BinNumElements[], unsigned short RefPatternData[], unsigned short SigPatternData[], unsigned short BinPatternData[][APN_MAX_PATTERN_ENTRIES] ); }; libapogee2-2.2/ApnCamData_ASCENT0402ME2.h0000644000175000017500000000223211110507150015135 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_ASCENT0402ME2.h: Interface file for the CApnCamData_ASCENT0402ME2 class. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #if _MSC_VER > 1000 #pragma once #endif // _MSC_VER> 1000 #include "ApnCamData.h" class CApnCamData_ASCENT0402ME2 : public CApnCamData { public: CApnCamData_ASCENT0402ME2(); virtual ~CApnCamData_ASCENT0402ME2(); void Initialize(); private: void set_vpattern(); void set_hpattern_clamp_sixteen(); void set_hpattern_skip_sixteen(); void set_hpattern_roi_sixteen(); void set_hpattern_clamp_twelve(); void set_hpattern_skip_twelve(); void set_hpattern_roi_twelve(); void set_hpattern( APN_HPATTERN_FILE *Pattern, unsigned short Mask, unsigned short BinningLimit, unsigned short RefNumElements, unsigned short SigNumElements, unsigned short BinNumElements[], unsigned short RefPatternData[], unsigned short SigPatternData[], unsigned short BinPatternData[][APN_MAX_PATTERN_ENTRIES] ); }; libapogee2-2.2/ApnCamData_KAF09000X.h0000644000175000017500000000220611110507150014471 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_KAF09000X.h: Interface file for the CApnCamData_KAF09000X class. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #if _MSC_VER > 1000 #pragma once #endif // _MSC_VER> 1000 #include "ApnCamData.h" class CApnCamData_KAF09000X : public CApnCamData { public: CApnCamData_KAF09000X(); virtual ~CApnCamData_KAF09000X(); void Initialize(); private: void set_vpattern(); void set_hpattern_clamp_sixteen(); void set_hpattern_skip_sixteen(); void set_hpattern_roi_sixteen(); void set_hpattern_clamp_twelve(); void set_hpattern_skip_twelve(); void set_hpattern_roi_twelve(); void set_hpattern( APN_HPATTERN_FILE *Pattern, unsigned short Mask, unsigned short BinningLimit, unsigned short RefNumElements, unsigned short SigNumElements, unsigned short BinNumElements[], unsigned short RefPatternData[], unsigned short SigPatternData[], unsigned short BinPatternData[][APN_MAX_PATTERN_ENTRIES] ); }; libapogee2-2.2/ApnCamData_KAF6303EB.cpp0000644000175000017500000004414611110507150015037 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_KAF6303EB.cpp: Implementation file for the CApnCamData_KAF6303EB class. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #include "ApnCamData_KAF6303EB.h" #include #include #include ///////////////////////////////////////////////////////////// // Construction/Destruction ///////////////////////////////////////////////////////////// CApnCamData_KAF6303EB::CApnCamData_KAF6303EB() { } CApnCamData_KAF6303EB::~CApnCamData_KAF6303EB() { } void CApnCamData_KAF6303EB::Initialize() { strcpy( m_Sensor, "KAF6303EB" ); strcpy( m_CameraModel, "9" ); m_CameraId = 37; m_InterlineCCD = false; m_SupportsSerialA = true; m_SupportsSerialB = true; m_SensorTypeCCD = true; m_TotalColumns = 3100; m_ImagingColumns = 3073; m_ClampColumns = 15; m_PreRoiSkipColumns = 0; m_PostRoiSkipColumns = 0; m_OverscanColumns = 12; m_TotalRows = 2056; m_ImagingRows = 2048; m_UnderscanRows = 4; m_OverscanRows = 4; m_VFlushBinning = 1; m_EnableSingleRowOffset = false; m_RowOffsetBinning = 1; m_HFlushDisable = false; m_ShutterCloseDelay = 300; m_PixelSizeX = 9; m_PixelSizeY = 9; m_Color = false; m_ReportedGainSixteenBit = 1.5; m_MinSuggestedExpTime = 20.0; m_CoolingSupported = true; m_RegulatedCoolingSupported = true; m_TempSetPoint = -20.0; m_TempRampRateOne = 700; m_TempRampRateTwo = 4000; m_TempBackoffPoint = 2.0; m_PrimaryADType = ApnAdType_Alta_Sixteen; m_AlternativeADType = ApnAdType_Alta_Twelve; m_DefaultGainLeft = 0; m_DefaultOffsetLeft = 100; m_DefaultGainRight = -1; m_DefaultOffsetRight = -1; m_DefaultRVoltage = 1000; m_DefaultSpeed = 0xffff; m_DefaultDataReduction = false; set_vpattern(); set_hpattern_clamp_sixteen(); set_hpattern_skip_sixteen(); set_hpattern_roi_sixteen(); set_hpattern_clamp_twelve(); set_hpattern_skip_twelve(); set_hpattern_roi_twelve(); } void CApnCamData_KAF6303EB::set_vpattern() { const unsigned short Mask = 0x6; const unsigned short NumElements = 71; unsigned short Pattern[NumElements] = { 0x0000, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0001, 0x0000 }; m_VerticalPattern.Mask = Mask; m_VerticalPattern.NumElements = NumElements; m_VerticalPattern.PatternData = (unsigned short *)malloc(NumElements * sizeof(unsigned short)); for ( int i=0; iMask = Mask; Pattern->BinningLimit = BinningLimit; Pattern->RefNumElements = RefNumElements; Pattern->SigNumElements = SigNumElements; if ( RefNumElements > 0 ) { Pattern->RefPatternData = (unsigned short *)malloc(RefNumElements * sizeof(unsigned short)); for ( i=0; iRefPatternData[i] = RefPatternData[i]; } } if ( SigNumElements > 0 ) { Pattern->SigPatternData = (unsigned short *)malloc(SigNumElements * sizeof(unsigned short)); for ( i=0; iSigPatternData[i] = SigPatternData[i]; } } if ( BinningLimit > 0 ) { for ( i=0; iBinNumElements[i] = BinNumElements[i]; Pattern->BinPatternData[i] = (unsigned short *)malloc(BinNumElements[i] * sizeof(unsigned short)); for ( j=0; jBinPatternData[i][j] = BinPatternData[i][j]; } } } } libapogee2-2.2/Apogee.h0000644000175000017500000000677511110507150012555 0ustar jrjr#if !defined(AFX_APOGEE__INCLUDED_) #define AFX_APOGEE__INCLUDED_ #define Apn_Platform int #define Apn_Platform_Unknown 0 #define Apn_Platform_Alta 1 #define Apn_Platform_Ascent 2 #define Apn_Interface int #define Apn_Interface_NET 0 #define Apn_Interface_USB 1 #define Apn_NetworkMode int #define Apn_NetworkMode_Tcp 0 #define Apn_NetworkMode_Udp 1 #define Apn_Resolution int #define Apn_Resolution_SixteenBit 0 #define Apn_Resolution_TwelveBit 1 #define Apn_CameraMode int #define Apn_CameraMode_Normal 0 #define Apn_CameraMode_TDI 1 #define Apn_CameraMode_Test 2 #define Apn_CameraMode_ExternalTrigger 3 #define Apn_CameraMode_ExternalShutter 4 #define Apn_CameraMode_Kinetics 5 #define Apn_Status int #define Apn_Status_DataError -2 #define Apn_Status_PatternError -1 #define Apn_Status_Idle 0 #define Apn_Status_Exposing 1 #define Apn_Status_ImagingActive 2 #define Apn_Status_ImageReady 3 #define Apn_Status_Flushing 4 #define Apn_Status_WaitingOnTrigger 5 #define Apn_Status_ConnectionError 6 #define Apn_LedMode int #define Apn_LedMode_DisableAll 0 #define Apn_LedMode_DisableWhileExpose 1 #define Apn_LedMode_EnableAll 2 #define Apn_LedState int #define Apn_LedState_Expose 0 #define Apn_LedState_ImageActive 1 #define Apn_LedState_Flushing 2 #define Apn_LedState_ExtTriggerWaiting 3 #define Apn_LedState_ExtTriggerReceived 4 #define Apn_LedState_ExtShutterInput 5 #define Apn_LedState_ExtStartReadout 6 #define Apn_LedState_AtTemp 7 #define Apn_CoolerStatus int #define Apn_CoolerStatus_Off 0 #define Apn_CoolerStatus_RampingToSetPoint 1 #define Apn_CoolerStatus_AtSetPoint 2 #define Apn_CoolerStatus_Revision 3 #define Apn_FanMode int #define Apn_FanMode_Off 0 #define Apn_FanMode_Low 1 #define Apn_FanMode_Medium 2 #define Apn_FanMode_High 3 #define ApnUsbParity int #define ApnNetParity int #define Apn_SerialParity int #define Apn_SerialFlowControl bool #define ApnUsbParity_None 0 #define ApnUsbParity_Odd 1 #define ApnUsbParity_Even 2 #define ApnNetParity_None 0 #define ApnNetParity_Odd 1 #define ApnNetParity_Even 2 #define Apn_SerialFlowControl_Unknown 0 #define Apn_SerialFlowControl_Off 0 #define Apn_SerialFlowControl_On 1 #define Apn_SerialParity_Unknown 0 #define Apn_SerialParity_None 0 #define Apn_SerialParity_Odd 1 #define Apn_SerialParity_Even 2 #define Apn_Filter int #define Apn_Filter_Unknown 0 #define Apn_Filter_FW50_9R 1 #define Apn_Filter_FW50_7S 2 #define Apn_Filter_AFW25_4R 3 #define Apn_Filter_AFW30_7R 4 #define Apn_Filter_AFW50_5R 5 #define Apn_FilterStatus int #define Apn_FilterStatus_NotConnected 0 #define Apn_FilterStatus_Ready 1 #define Apn_FilterStatus_Active 2 #define Apn_BayerShift int #define Apn_BayerShift_None 0 #define Apn_BayerShift_Column 1 #define Apn_BayerShift_Row 2 #define Apn_BayerShift_Both 3 #define Apn_BayerShift_Automatic 4 #define Camera_Status int #define Camera_Status_Idle 0 #define Camera_Status_Waiting 1 #define Camera_Status_Exposing 2 #define Camera_Status_Downloading 3 #define Camera_Status_LineReady 4 #define Camera_Status_ImageReady 5 #define Camera_Status_Flushing 6 #define Camera_CoolerStatus int #define Camera_CoolerStatus_Off 0 #define Camera_CoolerStatus_RampingToSetPoint 1 #define Camera_CoolerStatus_Correcting 2 #define Camera_CoolerStatus_RampingToAmbient 3 #define Camera_CoolerStatus_AtAmbient 4 #define Camera_CoolerStatus_AtMax 5 #define Camera_CoolerStatus_AtMin 6 #define Camera_CoolerStatus_AtSetPoint 7 #define Camera_CoolerMode int #define Camera_CoolerMode_Off 0 #define Camera_CoolerMode_On 1 #define Camera_CoolerMode_Shutdown 2 #endif libapogee2-2.2/ApnCamData_KAF0261E.h0000644000175000017500000000220111110507150014361 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_KAF0261E.h: Interface file for the CApnCamData_KAF0261E class. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #if _MSC_VER > 1000 #pragma once #endif // _MSC_VER> 1000 #include "ApnCamData.h" class CApnCamData_KAF0261E : public CApnCamData { public: CApnCamData_KAF0261E(); virtual ~CApnCamData_KAF0261E(); void Initialize(); private: void set_vpattern(); void set_hpattern_clamp_sixteen(); void set_hpattern_skip_sixteen(); void set_hpattern_roi_sixteen(); void set_hpattern_clamp_twelve(); void set_hpattern_skip_twelve(); void set_hpattern_roi_twelve(); void set_hpattern( APN_HPATTERN_FILE *Pattern, unsigned short Mask, unsigned short BinningLimit, unsigned short RefNumElements, unsigned short SigNumElements, unsigned short BinNumElements[], unsigned short RefPatternData[], unsigned short SigPatternData[], unsigned short BinPatternData[][APN_MAX_PATTERN_ENTRIES] ); }; libapogee2-2.2/ApnCamData_CCD4710B.h0000644000175000017500000000220111110507150014351 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_CCD4710B.h: Interface file for the CApnCamData_CCD4710B class. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #if _MSC_VER > 1000 #pragma once #endif // _MSC_VER> 1000 #include "ApnCamData.h" class CApnCamData_CCD4710B : public CApnCamData { public: CApnCamData_CCD4710B(); virtual ~CApnCamData_CCD4710B(); void Initialize(); private: void set_vpattern(); void set_hpattern_clamp_sixteen(); void set_hpattern_skip_sixteen(); void set_hpattern_roi_sixteen(); void set_hpattern_clamp_twelve(); void set_hpattern_skip_twelve(); void set_hpattern_roi_twelve(); void set_hpattern( APN_HPATTERN_FILE *Pattern, unsigned short Mask, unsigned short BinningLimit, unsigned short RefNumElements, unsigned short SigNumElements, unsigned short BinNumElements[], unsigned short RefPatternData[], unsigned short SigPatternData[], unsigned short BinPatternData[][APN_MAX_PATTERN_ENTRIES] ); }; libapogee2-2.2/ApnCamera_NET.cpp0000644000175000017500000003221211110507150014226 0ustar jrjr////////////////////////////////////////////////////////////////////// // // ApnCamera_NET.cpp: implementation of the CApnCamera_NET class. // // Copyright (c) 2003, 2004 Apogee Instruments, Inc. // ////////////////////////////////////////////////////////////////////// #include "stdafx.h" #include "ApnCamera_NET.h" #include #include #include #include "ApogeeNet.h" #include "ApogeeNetErr.h" ////////////////////////////////////////////////////////////////////// // Construction/Destruction ////////////////////////////////////////////////////////////////////// bool CApnCamera::GetDeviceHandle( void *hCamera, char *CameraInfo ) { strcpy( CameraInfo, m_HostAddr ); return true; } bool CApnCamera::SimpleInitDriver( unsigned long CamIdA, unsigned short CamIdB, unsigned long Option ) { BYTE ipAddr[4]; ipAddr[0] = (BYTE)(CamIdA & 0xFF); ipAddr[1] = (BYTE)((CamIdA >> 8) & 0xFF); ipAddr[2] = (BYTE)((CamIdA >> 16) & 0xFF); ipAddr[3] = (BYTE)((CamIdA >> 24) & 0xFF); sprintf( m_HostAddr, "%u.%u.%u.%u:%u", ipAddr[3], ipAddr[2], ipAddr[1], ipAddr[0], CamIdB ); if ( ApnNetConnect( m_HostAddr ) != APN_NET_SUCCESS ) { return false; } return true; } bool CApnCamera::InitDriver( unsigned long CamIdA, unsigned short CamIdB, unsigned long Option ) { BYTE ipAddr[4]; ipAddr[0] = (BYTE)(CamIdA & 0xFF); ipAddr[1] = (BYTE)((CamIdA >> 8) & 0xFF); ipAddr[2] = (BYTE)((CamIdA >> 16) & 0xFF); ipAddr[3] = (BYTE)((CamIdA >> 24) & 0xFF); sprintf( m_HostAddr, "%u.%u.%u.%u:%u", ipAddr[3], ipAddr[2], ipAddr[1], ipAddr[0], CamIdB ); if ( ApnNetConnect( m_HostAddr ) != APN_NET_SUCCESS ) { return false; } m_ImageSizeBytes = 0; m_ImageInProgress = false; // Before trying to initialize, perform a simple loopback test unsigned short RegData; unsigned short NewRegData; RegData = 0x5AA5; if ( Write( FPGA_REG_SCRATCH, RegData ) != APN_NET_SUCCESS ) return false; if ( Read( FPGA_REG_SCRATCH, NewRegData ) != APN_NET_SUCCESS ) return false; if ( RegData != NewRegData ) return false; RegData = 0xA55A; if ( Write( FPGA_REG_SCRATCH, RegData ) != APN_NET_SUCCESS ) return false; if ( Read( FPGA_REG_SCRATCH, NewRegData ) != APN_NET_SUCCESS ) return false; if ( RegData != NewRegData ) return false; // The loopback test was successful. Proceed with initialization. if ( InitDefaults() != 0 ) return false; return true; } Apn_Interface CApnCamera::GetCameraInterface() { return Apn_Interface_NET; } long CApnCamera::GetCameraSerialNumber( char *CameraSerialNumber, long *BufferLength ) { char pBuffer[256]; if ( *BufferLength < (MAC_ADDRESS_LENGTH + 1) ) { *BufferLength = 0; return CAPNCAMERA_ERR_SN; } if ( ApnNetGetMacAddress( m_HostAddr, pBuffer ) != APN_NET_SUCCESS ) { *BufferLength = 0; return CAPNCAMERA_ERR_SN; } else { strcpy( CameraSerialNumber, pBuffer ); *BufferLength = strlen( CameraSerialNumber ); } return CAPNCAMERA_SUCCESS; } long CApnCamera::GetSystemDriverVersion( char *SystemDriverVersion, long *BufferLength ) { strcpy( SystemDriverVersion, "N/A" ); *BufferLength = strlen( SystemDriverVersion ); return CAPNCAMERA_SUCCESS; } long CApnCamera::GetUsb8051FirmwareRev( char *FirmwareRev, long *BufferLength ) { strcpy( FirmwareRev, "N/A" ); *BufferLength = strlen( FirmwareRev ); return CAPNCAMERA_SUCCESS; } long CApnCamera::GetUsbProductId( unsigned short *pProductId ) { *pProductId = 0x0; return CAPNCAMERA_SUCCESS; } long CApnCamera::GetUsbDeviceId( unsigned short *pDeviceId ) { *pDeviceId = 0x0; return CAPNCAMERA_SUCCESS; } bool CApnCamera::CloseDriver() { ApnNetClose( m_HostAddr ); if ( m_ImageInProgress ) { m_ImageInProgress = false; } return true; } long CApnCamera::GetImageData( unsigned short *pImageBuffer, unsigned short &Width, unsigned short &Height, unsigned long &Count ) { unsigned short Offset; unsigned short *pTempBuffer; unsigned long SequenceHeight; unsigned long i, j; // Check to see if ApnNetStartExp was called first if ( !m_ImageInProgress ) { return CAPNCAMERA_ERR_IMAGE; // Failure -- Image never started } // Make sure it is okay to get the image data // The app *should* have done this on its own, but we have to make sure while ( !ImageReady() ) { Sleep( 50 ); read_ImagingStatus(); } Width = m_pvtExposeWidth; Height = m_pvtExposeHeight; if ( m_pvtBitsPerPixel == 16 ) Offset = 1; if ( m_pvtBitsPerPixel == 12 ) Offset = 10; Width -= Offset; // Calculate the true image width SequenceHeight = Height * m_pvtNumImages; pTempBuffer = new unsigned short[(Width+Offset) * SequenceHeight]; ApnNetGetImageTcp( m_HostAddr, m_ImageSizeBytes, pTempBuffer ); unsigned long TermOne; unsigned long TermTwo; for ( i=0; i BEGIN" ); // All this call is really doing (at this point) is making sure that a valid connection // exists to the camera if ( ApnNetStopExp( m_HostAddr, DigitizeData ) != APN_NET_SUCCESS ) { return 1; } switch( m_pvtExposeCameraMode ) { case Apn_CameraMode_Normal: // First, if we are not triggered in some manner, do a normal stop exposure routine // We check the condition "read_ImagingStatus() == Apn_Status_WaitingOnTrigger" // after this because we don't usually want to read ImagingStatus in the driver if ( !read_ExposureTriggerGroup() && !read_ExposureTriggerEach() && !read_ExposureExternalShutter() ) { AltaDebugOutputString( "APOGEE.DLL - CApnCamera::PostStopExposure() -> Not using H/W trigger" ); if ( !DigitizeData ) { while ( !ImageReady() ) { Sleep( 50 ); read_ImagingStatus(); } ByteCount = m_pvtExposeWidth * m_pvtExposeHeight; pRequestData = new unsigned short[ByteCount]; if ( ApnNetGetImageTcp( m_HostAddr, ByteCount, pRequestData ) != APN_NET_SUCCESS ) { delete [] pRequestData; SignalImagingDone(); m_ImageInProgress = false; return APN_NET_ERR_IMAGE_DATA; } delete [] pRequestData; SignalImagingDone(); m_ImageInProgress = false; } } else { AltaDebugOutputString( "APOGEE.DLL - CApnCamera::PostStopExposure() -> Using H/W trigger" ); if ( read_ImagingStatus() == Apn_Status_WaitingOnTrigger ) { AltaDebugOutputString( "APOGEE.DLL - CApnCamera::PostStopExposure() -> Detected Apn_Status_WaitingOnTrigger" ); SignalImagingDone(); m_ImageInProgress = false; ResetSystem(); } else { AltaDebugOutputString( "APOGEE.DLL - CApnCamera::PostStopExposure() -> Did NOT detect Apn_Status_WaitingOnTrigger" ); if ( !DigitizeData ) { while ( !ImageReady() ) { Sleep( 50 ); read_ImagingStatus(); } ByteCount = m_pvtExposeWidth * m_pvtExposeHeight; pRequestData = new unsigned short[ByteCount]; if ( ApnNetGetImageTcp( m_HostAddr, ByteCount, pRequestData ) != APN_NET_SUCCESS ) { delete [] pRequestData; SignalImagingDone(); m_ImageInProgress = false; return APN_NET_ERR_IMAGE_DATA; } delete [] pRequestData; SignalImagingDone(); m_ImageInProgress = false; if ( m_pvtExposeExternalShutter ) { ResetSystem(); } } } } break; case Apn_CameraMode_TDI: // Clean up after the stop // Restart the system to flush normally SignalImagingDone(); m_ImageInProgress = false; ResetSystem(); break; case Apn_CameraMode_ExternalTrigger: // Included for stopping "legacy" externally triggered exposures if ( !DigitizeData ) { while ( !ImageReady() ) { Sleep( 50 ); read_ImagingStatus(); } ByteCount = m_pvtExposeWidth * m_pvtExposeHeight; pRequestData = new unsigned short[ByteCount]; if ( ApnNetGetImageTcp( m_HostAddr, ByteCount, pRequestData ) != APN_NET_SUCCESS ) { delete [] pRequestData; SignalImagingDone(); m_ImageInProgress = false; return APN_NET_ERR_IMAGE_DATA; } delete [] pRequestData; SignalImagingDone(); m_ImageInProgress = false; } break; case Apn_CameraMode_Kinetics: // Clean up after the stop // Restart the system to flush normally SignalImagingDone(); m_ImageInProgress = false; ResetSystem(); break; default: break; } AltaDebugOutputString( "APOGEE.DLL - CApnCamera::PostStopExposure() -> END" ); return CAPNCAMERA_SUCCESS; } void CApnCamera::SetNetworkTransferMode( Apn_NetworkMode TransferMode ) { switch ( TransferMode ) { case Apn_NetworkMode_Tcp: if ( ApnNetSetSpeed( m_HostAddr, false ) == APN_NET_SUCCESS ) { m_FastDownload = false; } break; case Apn_NetworkMode_Udp: if ( ApnNetSetSpeed( m_HostAddr, true ) == APN_NET_SUCCESS ) { m_FastDownload = true; } break; } } long CApnCamera::Read( unsigned short reg, unsigned short& val ) { if ( ApnNetReadReg( m_HostAddr, reg, &val ) != APN_NET_SUCCESS ) { return CAPNCAMERA_ERR_READ; // Failure } return CAPNCAMERA_SUCCESS; } long CApnCamera::Write( unsigned short reg, unsigned short val ) { if ( ApnNetWriteReg( m_HostAddr, reg, val ) != APN_NET_SUCCESS ) { return CAPNCAMERA_ERR_WRITE; // Failure } return CAPNCAMERA_SUCCESS; } long CApnCamera::WriteMultiSRMD( unsigned short reg, unsigned short val[], unsigned short count ) { if ( ApnNetWriteRegMulti( m_HostAddr, reg, val, count ) != APN_NET_SUCCESS ) { return CAPNCAMERA_ERR_WRITE; } return CAPNCAMERA_SUCCESS; } long CApnCamera::WriteMultiMRMD( unsigned short reg[], unsigned short val[], unsigned short count ) { if ( ApnNetWriteRegMultiMRMD( m_HostAddr, reg, val, count ) != APN_NET_SUCCESS ) { return CAPNCAMERA_ERR_WRITE; } return CAPNCAMERA_SUCCESS; } long CApnCamera::QueryStatusRegs( unsigned short& StatusReg, unsigned short& HeatsinkTempReg, unsigned short& CcdTempReg, unsigned short& CoolerDriveReg, unsigned short& VoltageReg, unsigned short& TdiCounter, unsigned short& SequenceCounter, unsigned short& MostRecentFrame, unsigned short& ReadyFrame, unsigned short& CurrentFrame ) { unsigned short RegNumber[7]; unsigned short RegData[7]; RegNumber[0] = 91; RegNumber[1] = 93; RegNumber[2] = 94; RegNumber[3] = 95; RegNumber[4] = 96; RegNumber[5] = 104; RegNumber[6] = 105; if ( ApnNetReadRegMulti( m_HostAddr, RegNumber, RegData, 7 ) != APN_NET_SUCCESS ) { return 1; } StatusReg = RegData[0]; HeatsinkTempReg = RegData[1]; CcdTempReg = RegData[2]; CoolerDriveReg = RegData[3]; VoltageReg = RegData[4]; TdiCounter = RegData[5]; SequenceCounter = RegData[6]; MostRecentFrame = 0; ReadyFrame = 0; CurrentFrame = 0; return CAPNCAMERA_SUCCESS; } libapogee2-2.2/ApnCamData_KAF1602EB.cpp0000644000175000017500000004414611110507150015034 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_KAF1602EB.cpp: Implementation file for the CApnCamData_KAF1602EB class. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #include "ApnCamData_KAF1602EB.h" #include #include #include ///////////////////////////////////////////////////////////// // Construction/Destruction ///////////////////////////////////////////////////////////// CApnCamData_KAF1602EB::CApnCamData_KAF1602EB() { } CApnCamData_KAF1602EB::~CApnCamData_KAF1602EB() { } void CApnCamData_KAF1602EB::Initialize() { strcpy( m_Sensor, "KAF1602EB" ); strcpy( m_CameraModel, "2" ); m_CameraId = 33; m_InterlineCCD = false; m_SupportsSerialA = true; m_SupportsSerialB = true; m_SensorTypeCCD = true; m_TotalColumns = 1564; m_ImagingColumns = 1536; m_ClampColumns = 14; m_PreRoiSkipColumns = 0; m_PostRoiSkipColumns = 0; m_OverscanColumns = 14; m_TotalRows = 1032; m_ImagingRows = 1024; m_UnderscanRows = 4; m_OverscanRows = 4; m_VFlushBinning = 1; m_EnableSingleRowOffset = false; m_RowOffsetBinning = 1; m_HFlushDisable = false; m_ShutterCloseDelay = 100; m_PixelSizeX = 9; m_PixelSizeY = 9; m_Color = false; m_ReportedGainSixteenBit = 1.5; m_MinSuggestedExpTime = 10.0; m_CoolingSupported = true; m_RegulatedCoolingSupported = true; m_TempSetPoint = -20.0; m_TempRampRateOne = 700; m_TempRampRateTwo = 4000; m_TempBackoffPoint = 2.0; m_PrimaryADType = ApnAdType_Alta_Sixteen; m_AlternativeADType = ApnAdType_Alta_Twelve; m_DefaultGainLeft = 0; m_DefaultOffsetLeft = 100; m_DefaultGainRight = -1; m_DefaultOffsetRight = -1; m_DefaultRVoltage = 1000; m_DefaultSpeed = 0xffff; m_DefaultDataReduction = false; set_vpattern(); set_hpattern_clamp_sixteen(); set_hpattern_skip_sixteen(); set_hpattern_roi_sixteen(); set_hpattern_clamp_twelve(); set_hpattern_skip_twelve(); set_hpattern_roi_twelve(); } void CApnCamData_KAF1602EB::set_vpattern() { const unsigned short Mask = 0x6; const unsigned short NumElements = 71; unsigned short Pattern[NumElements] = { 0x0000, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0001, 0x0000 }; m_VerticalPattern.Mask = Mask; m_VerticalPattern.NumElements = NumElements; m_VerticalPattern.PatternData = (unsigned short *)malloc(NumElements * sizeof(unsigned short)); for ( int i=0; iMask = Mask; Pattern->BinningLimit = BinningLimit; Pattern->RefNumElements = RefNumElements; Pattern->SigNumElements = SigNumElements; if ( RefNumElements > 0 ) { Pattern->RefPatternData = (unsigned short *)malloc(RefNumElements * sizeof(unsigned short)); for ( i=0; iRefPatternData[i] = RefPatternData[i]; } } if ( SigNumElements > 0 ) { Pattern->SigPatternData = (unsigned short *)malloc(SigNumElements * sizeof(unsigned short)); for ( i=0; iSigPatternData[i] = SigPatternData[i]; } } if ( BinningLimit > 0 ) { for ( i=0; iBinNumElements[i] = BinNumElements[i]; Pattern->BinPatternData[i] = (unsigned short *)malloc(BinNumElements[i] * sizeof(unsigned short)); for ( j=0; jBinPatternData[i][j] = BinPatternData[i][j]; } } } } libapogee2-2.2/ApnCamData_KAI4020M.h0000644000175000017500000000221211110507150014373 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_KAI4020M.h: Interface file for the CApnCamData_KAI4020M class. // // Copyright (c) 2003, 2004 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #if _MSC_VER > 1000 #pragma once #endif // _MSC_VER> 1000 #include "ApnCamData.h" class CApnCamData_KAI4020M : public CApnCamData { public: CApnCamData_KAI4020M(); virtual ~CApnCamData_KAI4020M(); void Initialize(); private: void set_vpattern(); void set_hpattern_clamp_sixteen(); void set_hpattern_skip_sixteen(); void set_hpattern_roi_sixteen(); void set_hpattern_clamp_twelve(); void set_hpattern_skip_twelve(); void set_hpattern_roi_twelve(); void set_hpattern( APN_HPATTERN_FILE *Pattern, unsigned short Mask, unsigned short BinningLimit, unsigned short RefNumElements, unsigned short SigNumElements, unsigned short BinNumElements[], unsigned short RefPatternData[], unsigned short SigPatternData[], unsigned short BinPatternData[][APN_MAX_PATTERN_ENTRIES] ); }; libapogee2-2.2/CameraIO_PCI.h0000644000175000017500000000163311110507150013454 0ustar jrjr// CameraIO_PCI.h: interface for the CCameraIO_PCI class. // // Copyright (c) 2000 Apogee Instruments Inc. ////////////////////////////////////////////////////////////////////// #if !defined(AFX_CAMERAIO_PCI_H__0F583058_8596_11D4_915F_0060676644C1__INCLUDED_) #define AFX_CAMERAIO_PCI_H__0F583058_8596_11D4_915F_0060676644C1__INCLUDED_ #if _MSC_VER > 1000 #pragma once #endif // _MSC_VER > 1000 #include "CameraIO.h" class CCameraIO_PCI : public CCameraIO { public: CCameraIO_PCI(); virtual ~CCameraIO_PCI(); bool InitDriver(); 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 ); private: BOOLEAN m_IsWDM; HANDLE m_hDriver; void CloseDriver(); }; #endif // !defined(AFX_CAMERAIO_PCI_H__0F583058_8596_11D4_915F_0060676644C1__INCLUDED_) libapogee2-2.2/ApnCamData_CCD7700B.h0000644000175000017500000000220111110507150014353 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_CCD7700B.h: Interface file for the CApnCamData_CCD7700B class. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #if _MSC_VER > 1000 #pragma once #endif // _MSC_VER> 1000 #include "ApnCamData.h" class CApnCamData_CCD7700B : public CApnCamData { public: CApnCamData_CCD7700B(); virtual ~CApnCamData_CCD7700B(); void Initialize(); private: void set_vpattern(); void set_hpattern_clamp_sixteen(); void set_hpattern_skip_sixteen(); void set_hpattern_roi_sixteen(); void set_hpattern_clamp_twelve(); void set_hpattern_skip_twelve(); void set_hpattern_roi_twelve(); void set_hpattern( APN_HPATTERN_FILE *Pattern, unsigned short Mask, unsigned short BinningLimit, unsigned short RefNumElements, unsigned short SigNumElements, unsigned short BinNumElements[], unsigned short RefPatternData[], unsigned short SigPatternData[], unsigned short BinPatternData[][APN_MAX_PATTERN_ENTRIES] ); }; libapogee2-2.2/ApnCamData_KAF4202.h0000644000175000017500000000220511110507150014257 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_KAF4202.h: Interface file for the CApnCamData_KAF4202 class. // // Copyright (c) 2003, 2004 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #if _MSC_VER > 1000 #pragma once #endif // _MSC_VER> 1000 #include "ApnCamData.h" class CApnCamData_KAF4202 : public CApnCamData { public: CApnCamData_KAF4202(); virtual ~CApnCamData_KAF4202(); void Initialize(); private: void set_vpattern(); void set_hpattern_clamp_sixteen(); void set_hpattern_skip_sixteen(); void set_hpattern_roi_sixteen(); void set_hpattern_clamp_twelve(); void set_hpattern_skip_twelve(); void set_hpattern_roi_twelve(); void set_hpattern( APN_HPATTERN_FILE *Pattern, unsigned short Mask, unsigned short BinningLimit, unsigned short RefNumElements, unsigned short SigNumElements, unsigned short BinNumElements[], unsigned short RefPatternData[], unsigned short SigPatternData[], unsigned short BinPatternData[][APN_MAX_PATTERN_ENTRIES] ); }; libapogee2-2.2/ApnSerial_NET.cpp0000644000175000017500000002022211110507150014253 0ustar jrjr// ApnSerial_NET.cpp: implementation of the CApnSerial class. // ////////////////////////////////////////////////////////////////////// #include "stdafx.h" #include "ApnSerial_NET.h" #include "ApogeeNet.h" #include "ApogeeNetErr.h" #ifdef _DEBUG #undef THIS_FILE static char THIS_FILE[]=__FILE__; #define new DEBUG_NEW #endif ////////////////////////////////////////////////////////////////////// // Construction/Destruction ////////////////////////////////////////////////////////////////////// bool CApnSerial::InitPort( unsigned long CamIdA, unsigned short CamIdB, unsigned short SerialId ) { char Hostname[25]; BYTE ipAddr[4]; ipAddr[0] = (BYTE)(CamIdA & 0xFF); ipAddr[1] = (BYTE)((CamIdA >> 8) & 0xFF); ipAddr[2] = (BYTE)((CamIdA >> 16) & 0xFF); ipAddr[3] = (BYTE)((CamIdA >> 24) & 0xFF); sprintf( m_HostAddr, "%u.%u.%u.%u", ipAddr[3], ipAddr[2], ipAddr[1], ipAddr[0] ); if ( m_SerialId != -1 ) { return false; } if ( (SerialId != 0) && (SerialId != 1) ) { return false; } if ( ApnNetStartSockets() != APN_NET_SUCCESS ) return false; if ( ApnNetSerialPortOpen( &m_SerialSocket, m_HostAddr, CamIdB ) != APN_NET_SUCCESS ) return false; m_PortNum = CamIdB; m_SerialId = SerialId; m_BytesRead = 0; SetBaudRate( 9600 ); SetFlowControl( Apn_SerialFlowControl_Off ); SetParity( Apn_SerialParity_None ); return true; } bool CApnSerial::ClosePort() { if ( m_SerialId == -1 ) return false; // just close the port and not care whether it was successful. if it was, // great. if not, we'll still set m_SerialId to -1 so that another call // can at least be tried to connect to the port. ApnNetSerialPortClose( &m_SerialSocket ); ApnNetStopSockets(); m_SerialId = -1; return true; } bool CApnSerial::GetBaudRate( unsigned long *BaudRate ) { if ( m_SerialId == -1 ) return false; if ( ApnNetSerialReadBaudRate( m_HostAddr, m_SerialId, BaudRate) != 0 ) { *BaudRate = 0; return false; } return true; } bool CApnSerial::SetBaudRate(unsigned long BaudRate ) { if ( m_SerialId == -1 ) return false; if ( ApnNetSerialWriteBaudRate( m_HostAddr, m_SerialId, BaudRate) != APN_NET_SUCCESS ) { return false; } else { ApnNetSerialPortClose( &m_SerialSocket ); ApnNetSerialPortOpen( &m_SerialSocket, m_HostAddr, m_PortNum ); } return true; } bool CApnSerial::GetFlowControl( Apn_SerialFlowControl *FlowControl ) { bool FlowControlRead; *FlowControl = Apn_SerialFlowControl_Unknown; if ( m_SerialId == -1 ) return false; if ( ApnNetSerialReadFlowControl(m_HostAddr, m_SerialId, &FlowControlRead) != APN_NET_SUCCESS ) { return false; } else { if ( FlowControlRead ) *FlowControl = Apn_SerialFlowControl_On; else *FlowControl = Apn_SerialFlowControl_Off; } return true; } bool CApnSerial::SetFlowControl( Apn_SerialFlowControl FlowControl ) { bool FlowControlWrite; if ( m_SerialId == -1 ) return false; if ( FlowControl == Apn_SerialFlowControl_On ) FlowControlWrite = true; else FlowControlWrite = false; if ( ApnNetSerialWriteFlowControl(m_HostAddr, m_SerialId, FlowControlWrite) != APN_NET_SUCCESS ) { return false; } else { ApnNetSerialPortClose( &m_SerialSocket ); ApnNetSerialPortOpen( &m_SerialSocket, m_HostAddr, m_PortNum ); } return true; } bool CApnSerial::GetParity( Apn_SerialParity *Parity ) { ApnNetParity ParityRead; *Parity = Apn_SerialParity_Unknown; if ( m_SerialId == -1 ) return false; if ( ApnNetSerialReadParity(m_HostAddr, m_SerialId, &ParityRead) != APN_NET_SUCCESS ) return false; if ( ParityRead == ApnNetParity_None ) *Parity = Apn_SerialParity_None; else if ( ParityRead == ApnNetParity_Even ) *Parity = Apn_SerialParity_Even; else if ( ParityRead == ApnNetParity_Odd ) *Parity = Apn_SerialParity_Odd; return true; } bool CApnSerial::SetParity( Apn_SerialParity Parity ) { ApnNetParity ParityWrite; if ( m_SerialId == -1 ) return false; if ( Parity == Apn_SerialParity_None ) ParityWrite = ApnNetParity_None; else if ( Parity == Apn_SerialParity_Even ) ParityWrite = ApnNetParity_Even; else if ( Parity == Apn_SerialParity_Odd ) ParityWrite = ApnNetParity_Odd; else return false; if ( ApnNetSerialWriteParity(m_HostAddr, m_SerialId, ParityWrite) != APN_NET_SUCCESS ) { return false; } else { ApnNetSerialPortClose( &m_SerialSocket ); ApnNetSerialPortOpen( &m_SerialSocket, m_HostAddr, m_PortNum ); } return true; } bool CApnSerial::Read(int dsocket ,char *ReadBuffer, unsigned short *ReadCount ) { if ( m_SerialId == -1 ) return false; if ( ApnNetSerialRead(&m_SerialSocket, ReadBuffer, ReadCount) != APN_NET_SUCCESS ) { *ReadCount = 0; m_BytesRead = 0; return false; } m_BytesRead = *ReadCount; return true; } char *CApnSerial::ReadBuffer(void) { int dummy; unsigned short count; Read(dummy,m_SerialBuffer,&count); return m_SerialBuffer; } bool CApnSerial::Write(int dsocket,char *WriteBuffer, unsigned short WriteCount ) { if ( m_SerialId == -1 ) return false; if ( ApnNetSerialWrite(&m_SerialSocket, WriteBuffer, WriteCount) != APN_NET_SUCCESS ) return false; return true; } libapogee2-2.2/ApnCamData_KAF3200EB.cpp0000644000175000017500000006054511110507150015031 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_KAF3200EB.cpp: Implementation file for the CApnCamData_KAF3200EB class. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #include "ApnCamData_KAF3200EB.h" #include #include #include ///////////////////////////////////////////////////////////// // Construction/Destruction ///////////////////////////////////////////////////////////// CApnCamData_KAF3200EB::CApnCamData_KAF3200EB() { } CApnCamData_KAF3200EB::~CApnCamData_KAF3200EB() { } void CApnCamData_KAF3200EB::Initialize() { strcpy( m_Sensor, "KAF3200EB" ); strcpy( m_CameraModel, "32" ); m_CameraId = 7; m_InterlineCCD = false; m_SupportsSerialA = true; m_SupportsSerialB = true; m_SensorTypeCCD = true; m_TotalColumns = 2267; m_ImagingColumns = 2184; m_ClampColumns = 46; m_PreRoiSkipColumns = 0; m_PostRoiSkipColumns = 0; m_OverscanColumns = 37; m_TotalRows = 1510; m_ImagingRows = 1472; m_UnderscanRows = 34; m_OverscanRows = 4; m_VFlushBinning = 1; m_EnableSingleRowOffset = false; m_RowOffsetBinning = 1; m_HFlushDisable = false; m_ShutterCloseDelay = 100; m_PixelSizeX = 6.8; m_PixelSizeY = 6.8; m_Color = false; m_ReportedGainSixteenBit = 1; m_MinSuggestedExpTime = 10.0; m_CoolingSupported = true; m_RegulatedCoolingSupported = true; m_TempSetPoint = -20.0; m_TempRampRateOne = 700; m_TempRampRateTwo = 4000; m_TempBackoffPoint = 2.0; m_PrimaryADType = ApnAdType_Alta_Sixteen; m_AlternativeADType = ApnAdType_Alta_Twelve; m_DefaultGainLeft = 100; m_DefaultOffsetLeft = 100; m_DefaultGainRight = -1; m_DefaultOffsetRight = -1; m_DefaultRVoltage = 1000; m_DefaultSpeed = 0xffff; m_DefaultDataReduction = false; set_vpattern(); set_hpattern_clamp_sixteen(); set_hpattern_skip_sixteen(); set_hpattern_roi_sixteen(); set_hpattern_clamp_twelve(); set_hpattern_skip_twelve(); set_hpattern_roi_twelve(); } void CApnCamData_KAF3200EB::set_vpattern() { const unsigned short Mask = 0x6; const unsigned short NumElements = 39; unsigned short Pattern[NumElements] = { 0x0000, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0204, 0x0204, 0x0204, 0x0204, 0x0204, 0x0204, 0x0204, 0x0204, 0x0204, 0x0204, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0001, 0x0000 }; m_VerticalPattern.Mask = Mask; m_VerticalPattern.NumElements = NumElements; m_VerticalPattern.PatternData = (unsigned short *)malloc(NumElements * sizeof(unsigned short)); for ( int i=0; iMask = Mask; Pattern->BinningLimit = BinningLimit; Pattern->RefNumElements = RefNumElements; Pattern->SigNumElements = SigNumElements; if ( RefNumElements > 0 ) { Pattern->RefPatternData = (unsigned short *)malloc(RefNumElements * sizeof(unsigned short)); for ( i=0; iRefPatternData[i] = RefPatternData[i]; } } if ( SigNumElements > 0 ) { Pattern->SigPatternData = (unsigned short *)malloc(SigNumElements * sizeof(unsigned short)); for ( i=0; iSigPatternData[i] = SigPatternData[i]; } } if ( BinningLimit > 0 ) { for ( i=0; iBinNumElements[i] = BinNumElements[i]; Pattern->BinPatternData[i] = (unsigned short *)malloc(BinNumElements[i] * sizeof(unsigned short)); for ( j=0; jBinPatternData[i][j] = BinPatternData[i][j]; } } } } libapogee2-2.2/ApnCamData_S101401109.cpp0000644000175000017500000004265111110507150015015 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_S101401109.cpp: Implementation file for the CApnCamData_S101401109 class. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #include "ApnCamData_S101401109.h" #include #include #include ///////////////////////////////////////////////////////////// // Construction/Destruction ///////////////////////////////////////////////////////////// CApnCamData_S101401109::CApnCamData_S101401109() { } CApnCamData_S101401109::~CApnCamData_S101401109() { } void CApnCamData_S101401109::Initialize() { strcpy( m_Sensor, "S101401109" ); strcpy( m_CameraModel, "1109" ); m_CameraId = 41; m_InterlineCCD = false; m_SupportsSerialA = true; m_SupportsSerialB = true; m_SensorTypeCCD = true; m_TotalColumns = 2068; m_ImagingColumns = 2048; m_ClampColumns = 10; m_PreRoiSkipColumns = 0; m_PostRoiSkipColumns = 0; m_OverscanColumns = 10; m_TotalRows = 512; m_ImagingRows = 506; m_UnderscanRows = 4; m_OverscanRows = 2; m_VFlushBinning = 4; m_EnableSingleRowOffset = false; m_RowOffsetBinning = 1; m_HFlushDisable = false; m_ShutterCloseDelay = 50; m_PixelSizeX = 6.8; m_PixelSizeY = 6.8; m_Color = false; m_ReportedGainSixteenBit = 1; m_MinSuggestedExpTime = 10.0; m_CoolingSupported = true; m_RegulatedCoolingSupported = true; m_TempSetPoint = -20.0; m_TempRampRateOne = 700; m_TempRampRateTwo = 4000; m_TempBackoffPoint = 2.0; m_PrimaryADType = ApnAdType_Alta_Sixteen; m_AlternativeADType = ApnAdType_Alta_Twelve; m_DefaultGainLeft = 100; m_DefaultOffsetLeft = 100; m_DefaultGainRight = -1; m_DefaultOffsetRight = -1; m_DefaultRVoltage = 1000; m_DefaultSpeed = 0xffff; m_DefaultDataReduction = false; set_vpattern(); set_hpattern_clamp_sixteen(); set_hpattern_skip_sixteen(); set_hpattern_roi_sixteen(); set_hpattern_clamp_twelve(); set_hpattern_skip_twelve(); set_hpattern_roi_twelve(); } void CApnCamData_S101401109::set_vpattern() { const unsigned short Mask = 0x6; const unsigned short NumElements = 61; unsigned short Pattern[NumElements] = { 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0003, 0x0002 }; m_VerticalPattern.Mask = Mask; m_VerticalPattern.NumElements = NumElements; m_VerticalPattern.PatternData = (unsigned short *)malloc(NumElements * sizeof(unsigned short)); for ( int i=0; iMask = Mask; Pattern->BinningLimit = BinningLimit; Pattern->RefNumElements = RefNumElements; Pattern->SigNumElements = SigNumElements; if ( RefNumElements > 0 ) { Pattern->RefPatternData = (unsigned short *)malloc(RefNumElements * sizeof(unsigned short)); for ( i=0; iRefPatternData[i] = RefPatternData[i]; } } if ( SigNumElements > 0 ) { Pattern->SigPatternData = (unsigned short *)malloc(SigNumElements * sizeof(unsigned short)); for ( i=0; iSigPatternData[i] = SigPatternData[i]; } } if ( BinningLimit > 0 ) { for ( i=0; iBinNumElements[i] = BinNumElements[i]; Pattern->BinPatternData[i] = (unsigned short *)malloc(BinNumElements[i] * sizeof(unsigned short)); for ( j=0; jBinPatternData[i][j] = BinPatternData[i][j]; } } } } libapogee2-2.2/ApnCamData_KAF09000H.h0000644000175000017500000000220611110507150014451 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_KAF09000H.h: Interface file for the CApnCamData_KAF09000H class. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #if _MSC_VER > 1000 #pragma once #endif // _MSC_VER> 1000 #include "ApnCamData.h" class CApnCamData_KAF09000H : public CApnCamData { public: CApnCamData_KAF09000H(); virtual ~CApnCamData_KAF09000H(); void Initialize(); private: void set_vpattern(); void set_hpattern_clamp_sixteen(); void set_hpattern_skip_sixteen(); void set_hpattern_roi_sixteen(); void set_hpattern_clamp_twelve(); void set_hpattern_skip_twelve(); void set_hpattern_roi_twelve(); void set_hpattern( APN_HPATTERN_FILE *Pattern, unsigned short Mask, unsigned short BinningLimit, unsigned short RefNumElements, unsigned short SigNumElements, unsigned short BinNumElements[], unsigned short RefPatternData[], unsigned short SigPatternData[], unsigned short BinPatternData[][APN_MAX_PATTERN_ENTRIES] ); }; libapogee2-2.2/ApogeeLinux.h0000644000175000017500000000305111110507150013555 0ustar jrjr #define APISA_READ_USHORT _IOR('a', 0x01, unsigned int) #define APISA_READ_LINE _IOR('a', 0x02, unsigned int) #define APISA_WRITE_USHORT _IOW('a', 0x03, unsigned int) #define APPPI_READ_USHORT _IOR('a', 0x01, unsigned int) #define APPPI_READ_LINE _IOR('a', 0x02, unsigned int) #define APPPI_WRITE_USHORT _IOW('a', 0x03, unsigned int) #define APPCI_READ_USHORT _IOR('a', 0x01, unsigned int) #define APPCI_READ_LINE _IOR('a', 0x02, unsigned int) #define APPCI_WRITE_USHORT _IOW('a', 0x03, unsigned int) #define APUSB_READ_USHORT _IOR('a', 0x01, unsigned int) #define APUSB_WRITE_USHORT _IOW('a', 0x02, unsigned int) #define APUSB_USB_STATUS _IOR('a', 0x03, unsigned int) #define APUSB_PRIME_USB_DOWNLOAD _IOR('a', 0x04, unsigned int) #define APUSB_STOP_USB_IMAGE _IOR('a', 0x05, unsigned int) #define APUSB_READ_USB_IMAGE _IOR('a', 0x06, unsigned int) #define APUSB_USB_RESET _IOR('a', 0x07, unsigned int) #define APUSB_READ_USB_SERIAL _IOR('a', 0x08, unsigned int) #define APUSB_WRITE_USB_SERIAL _IOR('a', 0x09, unsigned int) #define APUSB_USB_SET_SERIAL _IOR('a', 0x0A, unsigned int) #define APUSB_USB_REQUEST _IOR('a', 0x0B, unsigned int) #define APUSB_READ_STATUS _IOR('a', 0x0C, unsigned int) #define appci_major_number 60 #define apppi_major_number 61 #define apisa_major_number 62 struct apIOparam // IOCTL data { unsigned int reg; unsigned long param1, param2; }; #define APOGEE_PCI_DEVICE "/dev/appci" #define APOGEE_PPI_DEVICE "/dev/apppi" #define APOGEE_ISA_DEVICE "/dev/apisa" #define APOGEE_USB_DEVICE "/dev/usb/alta" libapogee2-2.2/ApnCamData_KAF16801E.cpp0000644000175000017500000006173611110507150015025 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_KAF16801E.cpp: Implementation file for the CApnCamData_KAF16801E class. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #include "ApnCamData_KAF16801E.h" #include #include #include ///////////////////////////////////////////////////////////// // Construction/Destruction ///////////////////////////////////////////////////////////// CApnCamData_KAF16801E::CApnCamData_KAF16801E() { } CApnCamData_KAF16801E::~CApnCamData_KAF16801E() { } void CApnCamData_KAF16801E::Initialize() { strcpy( m_Sensor, "KAF16801E" ); strcpy( m_CameraModel, "16" ); m_CameraId = 9; m_InterlineCCD = false; m_SupportsSerialA = true; m_SupportsSerialB = true; m_SensorTypeCCD = true; m_TotalColumns = 4145; m_ImagingColumns = 4098; m_ClampColumns = 35; m_PreRoiSkipColumns = 0; m_PostRoiSkipColumns = 0; m_OverscanColumns = 12; m_TotalRows = 4128; m_ImagingRows = 4098; m_UnderscanRows = 10; m_OverscanRows = 20; m_VFlushBinning = 1; m_EnableSingleRowOffset = false; m_RowOffsetBinning = 1; m_HFlushDisable = false; m_ShutterCloseDelay = 300; m_PixelSizeX = 9; m_PixelSizeY = 9; m_Color = false; m_ReportedGainSixteenBit = 1.5; m_MinSuggestedExpTime = 30.0; m_CoolingSupported = true; m_RegulatedCoolingSupported = true; m_TempSetPoint = -20.0; m_TempRampRateOne = 1500; m_TempRampRateTwo = 4000; m_TempBackoffPoint = 2.0; m_PrimaryADType = ApnAdType_Alta_Sixteen; m_AlternativeADType = ApnAdType_Alta_Twelve; m_DefaultGainLeft = 100; m_DefaultOffsetLeft = 255; m_DefaultGainRight = -1; m_DefaultOffsetRight = -1; m_DefaultRVoltage = 1000; m_DefaultSpeed = 0xffff; m_DefaultDataReduction = false; set_vpattern(); set_hpattern_clamp_sixteen(); set_hpattern_skip_sixteen(); set_hpattern_roi_sixteen(); set_hpattern_clamp_twelve(); set_hpattern_skip_twelve(); set_hpattern_roi_twelve(); } void CApnCamData_KAF16801E::set_vpattern() { const unsigned short Mask = 0x0; const unsigned short NumElements = 116; unsigned short Pattern[NumElements] = { 0x0000, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0204, 0x0204, 0x0204, 0x0204, 0x0204, 0x0204, 0x0204, 0x0204, 0x0204, 0x0204, 0x0004, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0001, 0x0000 }; m_VerticalPattern.Mask = Mask; m_VerticalPattern.NumElements = NumElements; m_VerticalPattern.PatternData = (unsigned short *)malloc(NumElements * sizeof(unsigned short)); for ( int i=0; iMask = Mask; Pattern->BinningLimit = BinningLimit; Pattern->RefNumElements = RefNumElements; Pattern->SigNumElements = SigNumElements; if ( RefNumElements > 0 ) { Pattern->RefPatternData = (unsigned short *)malloc(RefNumElements * sizeof(unsigned short)); for ( i=0; iRefPatternData[i] = RefPatternData[i]; } } if ( SigNumElements > 0 ) { Pattern->SigPatternData = (unsigned short *)malloc(SigNumElements * sizeof(unsigned short)); for ( i=0; iSigPatternData[i] = SigPatternData[i]; } } if ( BinningLimit > 0 ) { for ( i=0; iBinNumElements[i] = BinNumElements[i]; Pattern->BinPatternData[i] = (unsigned short *)malloc(BinNumElements[i] * sizeof(unsigned short)); for ( j=0; jBinPatternData[i][j] = BinPatternData[i][j]; } } } } libapogee2-2.2/LICENSE0000644000175000017500000004307611110507150012204 0ustar jrjr GNU GENERAL PUBLIC LICENSE Version 2, June 1991 Copyright (C) 1989, 1991 Free Software Foundation, Inc. 675 Mass Ave, Cambridge, MA 02139, USA Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. Preamble The licenses for most software are designed to take away your freedom to share and change it. By contrast, the GNU General Public License is intended to guarantee your freedom to share and change free software--to make sure the software is free for all its users. This General Public License applies to most of the Free Software Foundation's software and to any other program whose authors commit to using it. (Some other Free Software Foundation software is covered by the GNU Library General Public License instead.) You can apply it to your programs, too. When we speak of free software, we are referring to freedom, not price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for this service if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs; and that you know you can do these things. To protect your rights, we need to make restrictions that forbid anyone to deny you these rights or to ask you to surrender the rights. These restrictions translate to certain responsibilities for you if you distribute copies of the software, or if you modify it. For example, if you distribute copies of such a program, whether gratis or for a fee, you must give the recipients all the rights that you have. You must make sure that they, too, receive or can get the source code. And you must show them these terms so they know their rights. We protect your rights with two steps: (1) copyright the software, and (2) offer you this license which gives you legal permission to copy, distribute and/or modify the software. Also, for each author's protection and ours, we want to make certain that everyone understands that there is no warranty for this free software. If the software is modified by someone else and passed on, we want its recipients to know that what they have is not the original, so that any problems introduced by others will not reflect on the original authors' reputations. Finally, any free program is threatened constantly by software patents. We wish to avoid the danger that redistributors of a free program will individually obtain patent licenses, in effect making the program proprietary. To prevent this, we have made it clear that any patent must be licensed for everyone's free use or not licensed at all. The precise terms and conditions for copying, distribution and modification follow. GNU GENERAL PUBLIC LICENSE TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 0. This License applies to any program or other work which contains a notice placed by the copyright holder saying it may be distributed under the terms of this General Public License. The "Program", below, refers to any such program or work, and a "work based on the Program" means either the Program or any derivative work under copyright law: that is to say, a work containing the Program or a portion of it, either verbatim or with modifications and/or translated into another language. (Hereinafter, translation is included without limitation in the term "modification".) Each licensee is addressed as "you". Activities other than copying, distribution and modification are not covered by this License; they are outside its scope. The act of running the Program is not restricted, and the output from the Program is covered only if its contents constitute a work based on the Program (independent of having been made by running the Program). Whether that is true depends on what the Program does. 1. You may copy and distribute verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice and disclaimer of warranty; keep intact all the notices that refer to this License and to the absence of any warranty; and give any other recipients of the Program a copy of this License along with the Program. You may charge a fee for the physical act of transferring a copy, and you may at your option offer warranty protection in exchange for a fee. 2. You may modify your copy or copies of the Program or any portion of it, thus forming a work based on the Program, and copy and distribute such modifications or work under the terms of Section 1 above, provided that you also meet all of these conditions: a) You must cause the modified files to carry prominent notices stating that you changed the files and the date of any change. b) You must cause any work that you distribute or publish, that in whole or in part contains or is derived from the Program or any part thereof, to be licensed as a whole at no charge to all third parties under the terms of this License. c) If the modified program normally reads commands interactively when run, you must cause it, when started running for such interactive use in the most ordinary way, to print or display an announcement including an appropriate copyright notice and a notice that there is no warranty (or else, saying that you provide a warranty) and that users may redistribute the program under these conditions, and telling the user how to view a copy of this License. (Exception: if the Program itself is interactive but does not normally print such an announcement, your work based on the Program is not required to print an announcement.) These requirements apply to the modified work as a whole. If identifiable sections of that work are not derived from the Program, and can be reasonably considered independent and separate works in themselves, then this License, and its terms, do not apply to those sections when you distribute them as separate works. But when you distribute the same sections as part of a whole which is a work based on the Program, the distribution of the whole must be on the terms of this License, whose permissions for other licensees extend to the entire whole, and thus to each and every part regardless of who wrote it. Thus, it is not the intent of this section to claim rights or contest your rights to work written entirely by you; rather, the intent is to exercise the right to control the distribution of derivative or collective works based on the Program. In addition, mere aggregation of another work not based on the Program with the Program (or with a work based on the Program) on a volume of a storage or distribution medium does not bring the other work under the scope of this License. 3. You may copy and distribute the Program (or a work based on it, under Section 2) in object code or executable form under the terms of Sections 1 and 2 above provided that you also do one of the following: a) Accompany it with the complete corresponding machine-readable source code, which must be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or, b) Accompany it with a written offer, valid for at least three years, to give any third party, for a charge no more than your cost of physically performing source distribution, a complete machine-readable copy of the corresponding source code, to be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or, c) Accompany it with the information you received as to the offer to distribute corresponding source code. (This alternative is allowed only for noncommercial distribution and only if you received the program in object code or executable form with such an offer, in accord with Subsection b above.) The source code for a work means the preferred form of the work for making modifications to it. For an executable work, complete source code means all the source code for all modules it contains, plus any associated interface definition files, plus the scripts used to control compilation and installation of the executable. However, as a special exception, the source code distributed need not include anything that is normally distributed (in either source or binary form) with the major components (compiler, kernel, and so on) of the operating system on which the executable runs, unless that component itself accompanies the executable. If distribution of executable or object code is made by offering access to copy from a designated place, then offering equivalent access to copy the source code from the same place counts as distribution of the source code, even though third parties are not compelled to copy the source along with the object code. 4. You may not copy, modify, sublicense, or distribute the Program except as expressly provided under this License. Any attempt otherwise to copy, modify, sublicense or distribute the Program is void, and will automatically terminate your rights under this License. However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance. 5. You are not required to accept this License, since you have not signed it. However, nothing else grants you permission to modify or distribute the Program or its derivative works. These actions are prohibited by law if you do not accept this License. Therefore, by modifying or distributing the Program (or any work based on the Program), you indicate your acceptance of this License to do so, and all its terms and conditions for copying, distributing or modifying the Program or works based on it. 6. Each time you redistribute the Program (or any work based on the Program), the recipient automatically receives a license from the original licensor to copy, distribute or modify the Program subject to these terms and conditions. You may not impose any further restrictions on the recipients' exercise of the rights granted herein. You are not responsible for enforcing compliance by third parties to this License. 7. If, as a consequence of a court judgment or allegation of patent infringement or for any other reason (not limited to patent issues), conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot distribute so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not distribute the Program at all. For example, if a patent license would not permit royalty-free redistribution of the Program by all those who receive copies directly or indirectly through you, then the only way you could satisfy both it and this License would be to refrain entirely from distribution of the Program. If any portion of this section is held invalid or unenforceable under any particular circumstance, the balance of the section is intended to apply and the section as a whole is intended to apply in other circumstances. It is not the purpose of this section to induce you to infringe any patents or other property right claims or to contest validity of any such claims; this section has the sole purpose of protecting the integrity of the free software distribution system, which is implemented by public license practices. Many people have made generous contributions to the wide range of software distributed through that system in reliance on consistent application of that system; it is up to the author/donor to decide if he or she is willing to distribute software through any other system and a licensee cannot impose that choice. This section is intended to make thoroughly clear what is believed to be a consequence of the rest of this License. 8. If the distribution and/or use of the Program is restricted in certain countries either by patents or by copyrighted interfaces, the original copyright holder who places the Program under this License may add an explicit geographical distribution limitation excluding those countries, so that distribution is permitted only in or among countries not thus excluded. In such case, this License incorporates the limitation as if written in the body of this License. 9. The Free Software Foundation may publish revised and/or new versions of the General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. Each version is given a distinguishing version number. If the Program specifies a version number of this License which applies to it and "any later version", you have the option of following the terms and conditions either of that version or of any later version published by the Free Software Foundation. If the Program does not specify a version number of this License, you may choose any version ever published by the Free Software Foundation. 10. If you wish to incorporate parts of the Program into other free programs whose distribution conditions are different, write to the author to ask for permission. For software which is copyrighted by the Free Software Foundation, write to the Free Software Foundation; we sometimes make exceptions for this. Our decision will be guided by the two goals of preserving the free status of all derivatives of our free software and of promoting the sharing and reuse of software generally. NO WARRANTY 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. END OF TERMS AND CONDITIONS Appendix: How to Apply These Terms to Your New Programs If you develop a new program, and you want it to be of the greatest possible use to the public, the best way to achieve this is to make it free software which everyone can redistribute and change under these terms. To do so, attach the following notices to the program. It is safest to attach them to the start of each source file to most effectively convey the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found. Copyright (C) 19yy This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. Also add information on how to contact you by electronic and paper mail. If the program is interactive, make it output a short notice like this when it starts in an interactive mode: Gnomovision version 69, Copyright (C) 19yy name of author Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. This is free software, and you are welcome to redistribute it under certain conditions; type `show c' for details. The hypothetical commands `show w' and `show c' should show the appropriate parts of the General Public License. Of course, the commands you use may be called something other than `show w' and `show c'; they could even be mouse-clicks or menu items--whatever suits your program. You should also get your employer (if you work as a programmer) or your school, if any, to sign a "copyright disclaimer" for the program, if necessary. Here is a sample; alter the names: Yoyodyne, Inc., hereby disclaims all copyright interest in the program `Gnomovision' (which makes passes at compilers) written by James Hacker. , 1 April 1989 Ty Coon, President of Vice This General Public License does not permit incorporating your program into proprietary programs. If your program is a subroutine library, you may consider it more useful to permit linking proprietary applications with the library. If this is what you want to do, use the GNU Library General Public License instead of this License. libapogee2-2.2/ApnCamData_ASCENT0402ME4.cpp0000644000175000017500000002223711110507150015501 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_ASCENT0402ME4.cpp: Implementation file for the CApnCamData_ASCENT0402ME4 class. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #include "ApnCamData_ASCENT0402ME4.h" #include #include #include ///////////////////////////////////////////////////////////// // Construction/Destruction ///////////////////////////////////////////////////////////// CApnCamData_ASCENT0402ME4::CApnCamData_ASCENT0402ME4() { } CApnCamData_ASCENT0402ME4::~CApnCamData_ASCENT0402ME4() { } void CApnCamData_ASCENT0402ME4::Initialize() { strcpy( m_Sensor, "ASCENT0402ME4" ); strcpy( m_CameraModel, "4" ); m_CameraId = 259; m_InterlineCCD = false; m_SupportsSerialA = false; m_SupportsSerialB = false; m_SensorTypeCCD = true; m_TotalColumns = 38; m_ImagingColumns = 30; m_ClampColumns = 4; m_PreRoiSkipColumns = 0; m_PostRoiSkipColumns = 0; m_OverscanColumns = 4; m_TotalRows = 38; m_ImagingRows = 30; m_UnderscanRows = 4; m_OverscanRows = 4; m_VFlushBinning = 1; m_EnableSingleRowOffset = false; m_RowOffsetBinning = 1; m_HFlushDisable = false; m_ShutterCloseDelay = 10; m_PixelSizeX = 9; m_PixelSizeY = 9; m_Color = false; m_ReportedGainSixteenBit = 1.5; m_MinSuggestedExpTime = 50.0; m_CoolingSupported = true; m_RegulatedCoolingSupported = true; m_TempSetPoint = -20.0; m_TempRampRateOne = 1200; m_TempRampRateTwo = 4000; m_TempBackoffPoint = 2.0; m_PrimaryADType = ApnAdType_Ascent_Sixteen; m_AlternativeADType = ApnAdType_None; m_DefaultGainLeft = 0; m_DefaultOffsetLeft = 100; m_DefaultGainRight = 0; m_DefaultOffsetRight = 100; m_DefaultRVoltage = 1000; m_DefaultSpeed = 0x0; m_DefaultDataReduction = true; set_vpattern(); set_hpattern_clamp_sixteen(); set_hpattern_skip_sixteen(); set_hpattern_roi_sixteen(); set_hpattern_clamp_twelve(); set_hpattern_skip_twelve(); set_hpattern_roi_twelve(); } void CApnCamData_ASCENT0402ME4::set_vpattern() { const unsigned short Mask = 0x6; const unsigned short NumElements = 71; unsigned short Pattern[NumElements] = { 0x0000, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0001, 0x0000 }; m_VerticalPattern.Mask = Mask; m_VerticalPattern.NumElements = NumElements; m_VerticalPattern.PatternData = (unsigned short *)malloc(NumElements * sizeof(unsigned short)); for ( int i=0; iMask = Mask; Pattern->BinningLimit = BinningLimit; Pattern->RefNumElements = RefNumElements; Pattern->SigNumElements = SigNumElements; if ( RefNumElements > 0 ) { Pattern->RefPatternData = (unsigned short *)malloc(RefNumElements * sizeof(unsigned short)); for ( i=0; iRefPatternData[i] = RefPatternData[i]; } } if ( SigNumElements > 0 ) { Pattern->SigPatternData = (unsigned short *)malloc(SigNumElements * sizeof(unsigned short)); for ( i=0; iSigPatternData[i] = SigPatternData[i]; } } if ( BinningLimit > 0 ) { for ( i=0; iBinNumElements[i] = BinNumElements[i]; Pattern->BinPatternData[i] = (unsigned short *)malloc(BinNumElements[i] * sizeof(unsigned short)); for ( j=0; jBinPatternData[i][j] = BinPatternData[i][j]; } } } } libapogee2-2.2/ApnCamData_KAF1602E.cpp0000644000175000017500000006135211110507150014730 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_KAF1602E.cpp: Implementation file for the CApnCamData_KAF1602E class. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #include "ApnCamData_KAF1602E.h" #include #include #include ///////////////////////////////////////////////////////////// // Construction/Destruction ///////////////////////////////////////////////////////////// CApnCamData_KAF1602E::CApnCamData_KAF1602E() { } CApnCamData_KAF1602E::~CApnCamData_KAF1602E() { } void CApnCamData_KAF1602E::Initialize() { strcpy( m_Sensor, "KAF1602E" ); strcpy( m_CameraModel, "2" ); m_CameraId = 1; m_InterlineCCD = false; m_SupportsSerialA = true; m_SupportsSerialB = true; m_SensorTypeCCD = true; m_TotalColumns = 1564; m_ImagingColumns = 1536; m_ClampColumns = 14; m_PreRoiSkipColumns = 0; m_PostRoiSkipColumns = 0; m_OverscanColumns = 14; m_TotalRows = 1032; m_ImagingRows = 1024; m_UnderscanRows = 4; m_OverscanRows = 4; m_VFlushBinning = 1; m_EnableSingleRowOffset = false; m_RowOffsetBinning = 1; m_HFlushDisable = false; m_ShutterCloseDelay = 100; m_PixelSizeX = 9; m_PixelSizeY = 9; m_Color = false; m_ReportedGainSixteenBit = 1.5; m_MinSuggestedExpTime = 10.0; m_CoolingSupported = true; m_RegulatedCoolingSupported = true; m_TempSetPoint = -20.0; m_TempRampRateOne = 700; m_TempRampRateTwo = 4000; m_TempBackoffPoint = 2.0; m_PrimaryADType = ApnAdType_Alta_Sixteen; m_AlternativeADType = ApnAdType_Alta_Twelve; m_DefaultGainLeft = 0; m_DefaultOffsetLeft = 100; m_DefaultGainRight = -1; m_DefaultOffsetRight = -1; m_DefaultRVoltage = 1000; m_DefaultSpeed = 0xffff; m_DefaultDataReduction = false; set_vpattern(); set_hpattern_clamp_sixteen(); set_hpattern_skip_sixteen(); set_hpattern_roi_sixteen(); set_hpattern_clamp_twelve(); set_hpattern_skip_twelve(); set_hpattern_roi_twelve(); } void CApnCamData_KAF1602E::set_vpattern() { const unsigned short Mask = 0x0; const unsigned short NumElements = 71; unsigned short Pattern[NumElements] = { 0x0000, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0001, 0x0000 }; m_VerticalPattern.Mask = Mask; m_VerticalPattern.NumElements = NumElements; m_VerticalPattern.PatternData = (unsigned short *)malloc(NumElements * sizeof(unsigned short)); for ( int i=0; iMask = Mask; Pattern->BinningLimit = BinningLimit; Pattern->RefNumElements = RefNumElements; Pattern->SigNumElements = SigNumElements; if ( RefNumElements > 0 ) { Pattern->RefPatternData = (unsigned short *)malloc(RefNumElements * sizeof(unsigned short)); for ( i=0; iRefPatternData[i] = RefPatternData[i]; } } if ( SigNumElements > 0 ) { Pattern->SigPatternData = (unsigned short *)malloc(SigNumElements * sizeof(unsigned short)); for ( i=0; iSigPatternData[i] = SigPatternData[i]; } } if ( BinningLimit > 0 ) { for ( i=0; iBinNumElements[i] = BinNumElements[i]; Pattern->BinPatternData[i] = (unsigned short *)malloc(BinNumElements[i] * sizeof(unsigned short)); for ( j=0; jBinPatternData[i][j] = BinPatternData[i][j]; } } } } libapogee2-2.2/ApnCamData_CCD4710ALT.cpp0000644000175000017500000004326311110507150015160 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_CCD4710ALT.cpp: Implementation file for the CApnCamData_CCD4710ALT class. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #include "ApnCamData_CCD4710ALT.h" #include #include #include ///////////////////////////////////////////////////////////// // Construction/Destruction ///////////////////////////////////////////////////////////// CApnCamData_CCD4710ALT::CApnCamData_CCD4710ALT() { } CApnCamData_CCD4710ALT::~CApnCamData_CCD4710ALT() { } void CApnCamData_CCD4710ALT::Initialize() { strcpy( m_Sensor, "CCD4710ALT" ); strcpy( m_CameraModel, "47" ); m_CameraId = 12; m_InterlineCCD = false; m_SupportsSerialA = true; m_SupportsSerialB = true; m_SensorTypeCCD = true; m_TotalColumns = 1072; m_ImagingColumns = 1024; m_ClampColumns = 24; m_PreRoiSkipColumns = 0; m_PostRoiSkipColumns = 0; m_OverscanColumns = 24; m_TotalRows = 1027; m_ImagingRows = 1024; m_UnderscanRows = 3; m_OverscanRows = 0; m_VFlushBinning = 1; m_EnableSingleRowOffset = false; m_RowOffsetBinning = 1; m_HFlushDisable = true; m_ShutterCloseDelay = 300; m_PixelSizeX = 13; m_PixelSizeY = 13; m_Color = false; m_ReportedGainSixteenBit = 2; m_MinSuggestedExpTime = 20.0; m_CoolingSupported = true; m_RegulatedCoolingSupported = true; m_TempSetPoint = -20.0; m_TempRampRateOne = 700; m_TempRampRateTwo = 4000; m_TempBackoffPoint = 2.0; m_PrimaryADType = ApnAdType_Alta_Sixteen; m_AlternativeADType = ApnAdType_Alta_Twelve; m_DefaultGainLeft = 400; m_DefaultOffsetLeft = 200; m_DefaultGainRight = -1; m_DefaultOffsetRight = -1; m_DefaultRVoltage = 1000; m_DefaultSpeed = 0xffff; m_DefaultDataReduction = false; set_vpattern(); set_hpattern_clamp_sixteen(); set_hpattern_skip_sixteen(); set_hpattern_roi_sixteen(); set_hpattern_clamp_twelve(); set_hpattern_skip_twelve(); set_hpattern_roi_twelve(); } void CApnCamData_CCD4710ALT::set_vpattern() { const unsigned short Mask = 0x0; const unsigned short NumElements = 180; unsigned short Pattern[NumElements] = { 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0001, 0x0000, }; m_VerticalPattern.Mask = Mask; m_VerticalPattern.NumElements = NumElements; m_VerticalPattern.PatternData = (unsigned short *)malloc(NumElements * sizeof(unsigned short)); for ( int i=0; iMask = Mask; Pattern->BinningLimit = BinningLimit; Pattern->RefNumElements = RefNumElements; Pattern->SigNumElements = SigNumElements; if ( RefNumElements > 0 ) { Pattern->RefPatternData = (unsigned short *)malloc(RefNumElements * sizeof(unsigned short)); for ( i=0; iRefPatternData[i] = RefPatternData[i]; } } if ( SigNumElements > 0 ) { Pattern->SigPatternData = (unsigned short *)malloc(SigNumElements * sizeof(unsigned short)); for ( i=0; iSigPatternData[i] = SigPatternData[i]; } } if ( BinningLimit > 0 ) { for ( i=0; iBinNumElements[i] = BinNumElements[i]; Pattern->BinPatternData[i] = (unsigned short *)malloc(BinNumElements[i] * sizeof(unsigned short)); for ( j=0; jBinPatternData[i][j] = BinPatternData[i][j]; } } } } libapogee2-2.2/libapogee.cpp0000644000175000017500000001356011110507150013625 0ustar jrjr#include "ApnCamera.h" #include "libapogee.h" #include #include #include #include #include #include #include "ApnCamera.h" #include "libapogee.h" /* master object */ static CApnCamera *alta; static void checkalta(); /* connect to the camera and perform any one-time setup. * return 0 if ok else -1 */ int ApnGlueOpen(unsigned int id) { char *ipaddress; unsigned int uaddr=0; unsigned int ip[4]; switch (id) { // USB case APOGEE_USB_ONLY: uaddr = 1; break; // Ethernet case APOGEE_ETH_ONLY: ipaddress = getenv("APOGEE_ALTA_IP"); if (ipaddress == NULL) return (-1); // Try Ehternet, if not then USB default: ipaddress = getenv("APOGEE_ALTA_IP"); if (ipaddress == NULL) { uaddr = 1; } else { sscanf(ipaddress,"%d.%d.%d.%d",ip,ip+1,ip+2,ip+3); uaddr = ip[0]*256*256*256 + ip[1]*256*256 + ip[2]*256 + ip[3]; } break; } alta = (CApnCamera *)new CApnCamera(); if (!alta->InitDriver(uaddr,80,0) || !alta->ResetSystem()) return (-1); alta->write_LedState (0, Apn_LedState_Expose); alta->write_LedState (1, Apn_LedState_AtTemp); return (0); } /* return the max values for the camera. */ void ApnGlueGetMaxValues (double * /*exptime*/, int *roiw, int *roih, int *osw, int *osh, int *binw, int *binh, int *shutter, double *mintemp) { checkalta(); *roiw = alta->m_ApnSensorInfo->m_ImagingColumns; *roih = alta->m_ApnSensorInfo->m_ImagingRows; *osw = alta->m_ApnSensorInfo->m_OverscanColumns; *osh = alta->m_ApnSensorInfo->m_OverscanRows; *binw = alta->read_MaxBinningH(); *binh = alta->read_MaxBinningV(); *shutter = 1; /* TODO */ *mintemp = alta->m_ApnSensorInfo->m_CoolingSupported ? -30 : 0; /*TODO*/ } /* set parameters for subsequent exposures. * if anything can't be done return -1 with explanation in whynot[], else 0. * also return final image size in net binned pixels, allowing for overscan, * binning etc. */ int ApnGlueSetExpGeom (int roiw, int roih, int osw, int osh, int binw, int binh, int roix, int roiy, int *impixw, int *impixh, char whynot[]) { int maxw, maxh; checkalta(); maxw = alta->m_ApnSensorInfo->m_ImagingColumns; maxh = alta->m_ApnSensorInfo->m_ImagingRows; /* be kind */ if (!binw) binw = 1; if (!binh) binh = 1; if (!roiw) roiw = maxw; if (!roih) roih = maxh; /* check maxes */ if (roiw > maxw) { sprintf (whynot, "Max width is %d", maxw); return (-1); } if (roih > maxh) { sprintf (whynot, "Max height is %d", maxh); return (-1); } /* check overscan */ if (osw > 0 || osh > 0) { int maxosw = alta->read_OverscanColumns(); int maxosh = alta->m_ApnSensorInfo->m_OverscanRows; if (osw > maxosw) { sprintf (whynot, "Max overscan columns is %d", maxosw); return (-1); } if (osh > maxosh) { sprintf (whynot, "Max overscan rows is %d", maxosh); return (-1); } if (roix > 0 || roiw < maxw || roiy > 0 || roih < maxh) { sprintf (whynot, "Can not overscan with windowing"); return (-1); } roiw += osw; roih += osh; alta->write_DigitizeOverscan(1); } else alta->write_DigitizeOverscan(0); /* ok */ alta->write_RoiStartX (roix); alta->write_RoiStartY (roiy); alta->write_RoiPixelsH (roiw/binw); alta->write_RoiPixelsV (roih/binh); alta->write_RoiBinningH (binw); alta->write_RoiBinningV (binh); *impixw = roiw/binw; *impixh = roih/binh; return (0); } /* start an exposure with the given duration (secs) and whether to open shutter. * update *exptime with the actual exposure time (may have been bumped to min). * return 0 if ok, else -1 */ int ApnGlueStartExp (double *exptime, int shutter) { double minsecs; checkalta(); minsecs = alta->m_ApnSensorInfo->m_MinSuggestedExpTime/1000.0; if (*exptime < minsecs) *exptime = minsecs; alta->write_ImageCount(1); return (alta->Expose(*exptime, shutter) ? 0 : -1); } /* abort an exposure */ void ApnGlueExpAbort(void) { checkalta(); alta->StopExposure(0); } /* return 1 if the current exposure is complete, else 0 */ int ApnGlueExpDone(void) { checkalta(); return (alta->read_ImagingStatus() == Apn_Status_ImageReady); } /* read pixels from the camera into the given buffer of length nbuf. * return 0 if ok else -1 with reason in whynot[]. */ int ApnGlueReadPixels (unsigned short *buf, int nbuf, char whynot[]) { unsigned short w, h; unsigned long c, r; checkalta(); r = alta->GetImageData (buf, w, h, c); if (r != CAPNCAMERA_SUCCESS) { sprintf (whynot, "GetImageData returned %ld\n", r); return (-1); } if (w*h != nbuf) { sprintf (whynot, "Expecting %d pixels but found %d", nbuf, w*h); return (-1); } return (0); } /* set cooler target to given value, C * turn cooler off it target is 0. */ void ApnGlueSetTemp (double C) { checkalta(); if (C == 0) { alta->write_CoolerEnable(0); } else { alta->write_CoolerEnable(1); alta->write_CoolerSetPoint(C); } } /* fetch current cooler temp, C, and return status: * 0 = off * 1 = ramping to set point * 2 = at set point */ int ApnGlueGetTemp (double *Cp) { int status; checkalta(); *Cp = alta->read_TempCCD(); status = alta->read_CoolerStatus(); if (status > 2) status = 2; return (status); } /* set fan speed: 0..3 */ void ApnGlueSetFan (int speed) { alta->write_FanMode(0); /* helps to do this first */ alta->write_FanMode(speed&3); } /* return pointers to sensor and camera names. * N.B. caller should neither modify nor free these strings. */ void ApnGlueGetName(char **sensor, char **camera) { *sensor = alta->m_ApnSensorInfo->m_Sensor; *camera = alta->m_ApnSensorInfo->m_CameraModel; } /* check that the alta object has been created, else complain and exit. */ static void checkalta() { if (!alta) { fprintf (stderr, "Bug! Alta used before open\n"); exit(1); } } libapogee2-2.2/ApnCamData_KAF10011105.cpp0000644000175000017500000004420711110507150015123 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_KAF10011105.cpp: Implementation file for the CApnCamData_KAF10011105 class. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #include "ApnCamData_KAF10011105.h" #include #include #include ///////////////////////////////////////////////////////////// // Construction/Destruction ///////////////////////////////////////////////////////////// CApnCamData_KAF10011105::CApnCamData_KAF10011105() { } CApnCamData_KAF10011105::~CApnCamData_KAF10011105() { } void CApnCamData_KAF10011105::Initialize() { strcpy( m_Sensor, "KAF10011105" ); strcpy( m_CameraModel, "6" ); m_CameraId = 31; m_InterlineCCD = false; m_SupportsSerialA = true; m_SupportsSerialB = true; m_SensorTypeCCD = true; m_TotalColumns = 1044; m_ImagingColumns = 1024; m_ClampColumns = 8; m_PreRoiSkipColumns = 0; m_PostRoiSkipColumns = 0; m_OverscanColumns = 12; m_TotalRows = 1032; m_ImagingRows = 1024; m_UnderscanRows = 4; m_OverscanRows = 4; m_VFlushBinning = 8; m_EnableSingleRowOffset = false; m_RowOffsetBinning = 1; m_HFlushDisable = false; m_ShutterCloseDelay = 100; m_PixelSizeX = 24; m_PixelSizeY = 24; m_Color = false; m_ReportedGainSixteenBit = 3; m_MinSuggestedExpTime = 20.0; m_CoolingSupported = true; m_RegulatedCoolingSupported = true; m_TempSetPoint = -20.0; m_TempRampRateOne = 700; m_TempRampRateTwo = 4000; m_TempBackoffPoint = 2.0; m_PrimaryADType = ApnAdType_Alta_Sixteen; m_AlternativeADType = ApnAdType_Alta_Twelve; m_DefaultGainLeft = 0; m_DefaultOffsetLeft = 250; m_DefaultGainRight = -1; m_DefaultOffsetRight = -1; m_DefaultRVoltage = 1000; m_DefaultSpeed = 0xffff; m_DefaultDataReduction = false; set_vpattern(); set_hpattern_clamp_sixteen(); set_hpattern_skip_sixteen(); set_hpattern_roi_sixteen(); set_hpattern_clamp_twelve(); set_hpattern_skip_twelve(); set_hpattern_roi_twelve(); } void CApnCamData_KAF10011105::set_vpattern() { const unsigned short Mask = 0x6; const unsigned short NumElements = 71; unsigned short Pattern[NumElements] = { 0x0000, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0001, 0x0000 }; m_VerticalPattern.Mask = Mask; m_VerticalPattern.NumElements = NumElements; m_VerticalPattern.PatternData = (unsigned short *)malloc(NumElements * sizeof(unsigned short)); for ( int i=0; iMask = Mask; Pattern->BinningLimit = BinningLimit; Pattern->RefNumElements = RefNumElements; Pattern->SigNumElements = SigNumElements; if ( RefNumElements > 0 ) { Pattern->RefPatternData = (unsigned short *)malloc(RefNumElements * sizeof(unsigned short)); for ( i=0; iRefPatternData[i] = RefPatternData[i]; } } if ( SigNumElements > 0 ) { Pattern->SigPatternData = (unsigned short *)malloc(SigNumElements * sizeof(unsigned short)); for ( i=0; iSigPatternData[i] = SigPatternData[i]; } } if ( BinningLimit > 0 ) { for ( i=0; iBinNumElements[i] = BinNumElements[i]; Pattern->BinPatternData[i] = (unsigned short *)malloc(BinNumElements[i] * sizeof(unsigned short)); for ( j=0; jBinPatternData[i][j] = BinPatternData[i][j]; } } } } libapogee2-2.2/ApnCamData_KAF09000X.cpp0000644000175000017500000006064611110507150015040 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_KAF09000X.cpp: Implementation file for the CApnCamData_KAF09000X class. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #include "ApnCamData_KAF09000X.h" #include #include #include ///////////////////////////////////////////////////////////// // Construction/Destruction ///////////////////////////////////////////////////////////// CApnCamData_KAF09000X::CApnCamData_KAF09000X() { } CApnCamData_KAF09000X::~CApnCamData_KAF09000X() { } void CApnCamData_KAF09000X::Initialize() { strcpy( m_Sensor, "KAF09000X" ); strcpy( m_CameraModel, "9000x" ); m_CameraId = 39; m_InterlineCCD = false; m_SupportsSerialA = true; m_SupportsSerialB = true; m_SensorTypeCCD = true; m_TotalColumns = 3103; m_ImagingColumns = 3056; m_ClampColumns = 35; m_PreRoiSkipColumns = 0; m_PostRoiSkipColumns = 0; m_OverscanColumns = 12; m_TotalRows = 3086; m_ImagingRows = 3056; m_UnderscanRows = 20; m_OverscanRows = 10; m_VFlushBinning = 1; m_EnableSingleRowOffset = false; m_RowOffsetBinning = 1; m_HFlushDisable = false; m_ShutterCloseDelay = 300; m_PixelSizeX = 12; m_PixelSizeY = 12; m_Color = false; m_ReportedGainSixteenBit = 1.5; m_MinSuggestedExpTime = 30.0; m_CoolingSupported = true; m_RegulatedCoolingSupported = true; m_TempSetPoint = -20.0; m_TempRampRateOne = 1500; m_TempRampRateTwo = 4000; m_TempBackoffPoint = 2.0; m_PrimaryADType = ApnAdType_Alta_Sixteen; m_AlternativeADType = ApnAdType_Alta_Twelve; m_DefaultGainLeft = 0; m_DefaultOffsetLeft = 150; m_DefaultGainRight = -1; m_DefaultOffsetRight = -1; m_DefaultRVoltage = 1000; m_DefaultSpeed = 0xffff; m_DefaultDataReduction = false; set_vpattern(); set_hpattern_clamp_sixteen(); set_hpattern_skip_sixteen(); set_hpattern_roi_sixteen(); set_hpattern_clamp_twelve(); set_hpattern_skip_twelve(); set_hpattern_roi_twelve(); } void CApnCamData_KAF09000X::set_vpattern() { const unsigned short Mask = 0x0; const unsigned short NumElements = 116; unsigned short Pattern[NumElements] = { 0x0000, 0x0000, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0202, 0x0202, 0x0202, 0x0202, 0x0202, 0x0202, 0x0202, 0x0202, 0x0202, 0x0202, 0x0002, 0x0002, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0001, 0x0000 }; m_VerticalPattern.Mask = Mask; m_VerticalPattern.NumElements = NumElements; m_VerticalPattern.PatternData = (unsigned short *)malloc(NumElements * sizeof(unsigned short)); for ( int i=0; iMask = Mask; Pattern->BinningLimit = BinningLimit; Pattern->RefNumElements = RefNumElements; Pattern->SigNumElements = SigNumElements; if ( RefNumElements > 0 ) { Pattern->RefPatternData = (unsigned short *)malloc(RefNumElements * sizeof(unsigned short)); for ( i=0; iRefPatternData[i] = RefPatternData[i]; } } if ( SigNumElements > 0 ) { Pattern->SigPatternData = (unsigned short *)malloc(SigNumElements * sizeof(unsigned short)); for ( i=0; iSigPatternData[i] = SigPatternData[i]; } } if ( BinningLimit > 0 ) { for ( i=0; iBinNumElements[i] = BinNumElements[i]; Pattern->BinPatternData[i] = (unsigned short *)malloc(BinNumElements[i] * sizeof(unsigned short)); for ( j=0; jBinPatternData[i][j] = BinPatternData[i][j]; } } } } libapogee2-2.2/ApnCamData_KAI2020ML.cpp0000644000175000017500000005316611110507150015056 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_KAI2020ML.cpp: Implementation file for the CApnCamData_KAI2020ML class. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #include "ApnCamData_KAI2020ML.h" #include #include #include ///////////////////////////////////////////////////////////// // Construction/Destruction ///////////////////////////////////////////////////////////// CApnCamData_KAI2020ML::CApnCamData_KAI2020ML() { } CApnCamData_KAI2020ML::~CApnCamData_KAI2020ML() { } void CApnCamData_KAI2020ML::Initialize() { strcpy( m_Sensor, "KAI2020ML" ); strcpy( m_CameraModel, "2020ml" ); m_CameraId = 64; m_InterlineCCD = true; m_SupportsSerialA = true; m_SupportsSerialB = true; m_SensorTypeCCD = true; m_TotalColumns = 1648; m_ImagingColumns = 1600; m_ClampColumns = 24; m_PreRoiSkipColumns = 0; m_PostRoiSkipColumns = 0; m_OverscanColumns = 24; m_TotalRows = 1214; m_ImagingRows = 1200; m_UnderscanRows = 6; m_OverscanRows = 8; m_VFlushBinning = 1; m_EnableSingleRowOffset = false; m_RowOffsetBinning = 1; m_HFlushDisable = false; m_ShutterCloseDelay = 0; m_PixelSizeX = 7.4; m_PixelSizeY = 7.4; m_Color = false; m_ReportedGainSixteenBit = 1; m_MinSuggestedExpTime = 0.05; m_CoolingSupported = true; m_RegulatedCoolingSupported = true; m_TempSetPoint = -20.0; m_TempRampRateOne = 700; m_TempRampRateTwo = 4000; m_TempBackoffPoint = 2.0; m_PrimaryADType = ApnAdType_Alta_Sixteen; m_AlternativeADType = ApnAdType_Alta_Twelve; m_DefaultGainLeft = 0; m_DefaultOffsetLeft = 100; m_DefaultGainRight = -1; m_DefaultOffsetRight = -1; m_DefaultRVoltage = 1000; m_DefaultSpeed = 0xffff; m_DefaultDataReduction = false; set_vpattern(); set_hpattern_clamp_sixteen(); set_hpattern_skip_sixteen(); set_hpattern_roi_sixteen(); set_hpattern_clamp_twelve(); set_hpattern_skip_twelve(); set_hpattern_roi_twelve(); } void CApnCamData_KAI2020ML::set_vpattern() { const unsigned short Mask = 0x106; const unsigned short NumElements = 38; unsigned short Pattern[NumElements] = { 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0302, 0x0302, 0x0302, 0x0302, 0x0302, 0x0302, 0x0302, 0x0302, 0x0302, 0x0302, 0x0002, 0x0002, 0x0002, 0x0003, 0x0002 }; m_VerticalPattern.Mask = Mask; m_VerticalPattern.NumElements = NumElements; m_VerticalPattern.PatternData = (unsigned short *)malloc(NumElements * sizeof(unsigned short)); for ( int i=0; iMask = Mask; Pattern->BinningLimit = BinningLimit; Pattern->RefNumElements = RefNumElements; Pattern->SigNumElements = SigNumElements; if ( RefNumElements > 0 ) { Pattern->RefPatternData = (unsigned short *)malloc(RefNumElements * sizeof(unsigned short)); for ( i=0; iRefPatternData[i] = RefPatternData[i]; } } if ( SigNumElements > 0 ) { Pattern->SigPatternData = (unsigned short *)malloc(SigNumElements * sizeof(unsigned short)); for ( i=0; iSigPatternData[i] = SigPatternData[i]; } } if ( BinningLimit > 0 ) { for ( i=0; iBinNumElements[i] = BinNumElements[i]; Pattern->BinPatternData[i] = (unsigned short *)malloc(BinNumElements[i] * sizeof(unsigned short)); for ( j=0; jBinPatternData[i][j] = BinPatternData[i][j]; } } } } libapogee2-2.2/ApnCamData_KAI2020M.cpp0000644000175000017500000005277611110507150014750 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_KAI2020M.cpp: Implementation file for the CApnCamData_KAI2020M class. // // Copyright (c) 2003, 2004 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #include "ApnCamData_KAI2020M.h" #include #include #include ///////////////////////////////////////////////////////////// // Construction/Destruction ///////////////////////////////////////////////////////////// CApnCamData_KAI2020M::CApnCamData_KAI2020M() { } CApnCamData_KAI2020M::~CApnCamData_KAI2020M() { } void CApnCamData_KAI2020M::Initialize() { strcpy( m_Sensor, "KAI2020M" ); strcpy( m_CameraModel, "2020m" ); m_CameraId = 80; m_InterlineCCD = true; m_SupportsSerialA = true; m_SupportsSerialB = true; m_SensorTypeCCD = true; m_TotalColumns = 1648; m_ImagingColumns = 1600; m_ClampColumns = 24; m_PreRoiSkipColumns = 0; m_PostRoiSkipColumns = 0; m_OverscanColumns = 24; m_TotalRows = 1214; m_ImagingRows = 1200; m_UnderscanRows = 6; m_OverscanRows = 8; m_VFlushBinning = 1; m_EnableSingleRowOffset = false; m_RowOffsetBinning = 1; m_HFlushDisable = false; m_ShutterCloseDelay = 0; m_PixelSizeX = 7.4; m_PixelSizeY = 7.4; m_Color = false; m_ReportedGainSixteenBit = 1; m_MinSuggestedExpTime = 0.05; m_CoolingSupported = true; m_RegulatedCoolingSupported = true; m_TempSetPoint = -20.0; m_TempRampRateOne = 700; m_TempRampRateTwo = 4000; m_TempBackoffPoint = 2.0; m_PrimaryADType = ApnAdType_Alta_Sixteen; m_AlternativeADType = ApnAdType_Alta_Twelve; //m_DefaultGainTwelveBit = 0; //m_DefaultOffsetTwelveBit = 100; m_DefaultRVoltage = 1000; set_vpattern(); set_hpattern_clamp_sixteen(); set_hpattern_skip_sixteen(); set_hpattern_roi_sixteen(); set_hpattern_clamp_twelve(); set_hpattern_skip_twelve(); set_hpattern_roi_twelve(); } void CApnCamData_KAI2020M::set_vpattern() { const unsigned short Mask = 0x106; const unsigned short NumElements = 38; unsigned short Pattern[NumElements] = { 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0302, 0x0302, 0x0302, 0x0302, 0x0302, 0x0302, 0x0302, 0x0302, 0x0302, 0x0302, 0x0002, 0x0002, 0x0002, 0x0003, 0x0002 }; m_VerticalPattern.Mask = Mask; m_VerticalPattern.NumElements = NumElements; m_VerticalPattern.PatternData = (unsigned short *)malloc(NumElements * sizeof(unsigned short)); for ( int i=0; iMask = Mask; Pattern->BinningLimit = BinningLimit; Pattern->RefNumElements = RefNumElements; Pattern->SigNumElements = SigNumElements; if ( RefNumElements > 0 ) { Pattern->RefPatternData = (unsigned short *)malloc(RefNumElements * sizeof(unsigned short)); for ( i=0; iRefPatternData[i] = RefPatternData[i]; } } if ( SigNumElements > 0 ) { Pattern->SigPatternData = (unsigned short *)malloc(SigNumElements * sizeof(unsigned short)); for ( i=0; iSigPatternData[i] = SigPatternData[i]; } } if ( BinningLimit > 0 ) { for ( i=0; iBinNumElements[i] = BinNumElements[i]; Pattern->BinPatternData[i] = (unsigned short *)malloc(BinNumElements[i] * sizeof(unsigned short)); for ( j=0; jBinPatternData[i][j] = BinPatternData[i][j]; } } } } libapogee2-2.2/ApnCamData_KAI4020CLB.cpp0000644000175000017500000005456211110507150015151 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_KAI4020CLB.cpp: Implementation file for the CApnCamData_KAI4020CLB class. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #include "ApnCamData_KAI4020CLB.h" #include #include #include ///////////////////////////////////////////////////////////// // Construction/Destruction ///////////////////////////////////////////////////////////// CApnCamData_KAI4020CLB::CApnCamData_KAI4020CLB() { } CApnCamData_KAI4020CLB::~CApnCamData_KAI4020CLB() { } void CApnCamData_KAI4020CLB::Initialize() { strcpy( m_Sensor, "KAI4020CLB" ); strcpy( m_CameraModel, "4020cl" ); m_CameraId = 75; m_InterlineCCD = true; m_SupportsSerialA = true; m_SupportsSerialB = true; m_SensorTypeCCD = true; m_TotalColumns = 2136; m_ImagingColumns = 2048; m_ClampColumns = 44; m_PreRoiSkipColumns = 0; m_PostRoiSkipColumns = 0; m_OverscanColumns = 44; m_TotalRows = 2072; m_ImagingRows = 2048; m_UnderscanRows = 16; m_OverscanRows = 8; m_VFlushBinning = 1; m_EnableSingleRowOffset = false; m_RowOffsetBinning = 1; m_HFlushDisable = false; m_ShutterCloseDelay = 0; m_PixelSizeX = 7.4; m_PixelSizeY = 7.4; m_Color = true; m_ReportedGainSixteenBit = 1; m_MinSuggestedExpTime = 0.05; m_CoolingSupported = true; m_RegulatedCoolingSupported = true; m_TempSetPoint = -20.0; m_TempRampRateOne = 700; m_TempRampRateTwo = 4000; m_TempBackoffPoint = 2.0; m_PrimaryADType = ApnAdType_Alta_Sixteen; m_AlternativeADType = ApnAdType_Alta_Twelve; m_DefaultGainLeft = 0; m_DefaultOffsetLeft = 100; m_DefaultGainRight = -1; m_DefaultOffsetRight = -1; m_DefaultRVoltage = 1000; m_DefaultSpeed = 0xffff; m_DefaultDataReduction = false; set_vpattern(); set_hpattern_clamp_sixteen(); set_hpattern_skip_sixteen(); set_hpattern_roi_sixteen(); set_hpattern_clamp_twelve(); set_hpattern_skip_twelve(); set_hpattern_roi_twelve(); } void CApnCamData_KAI4020CLB::set_vpattern() { const unsigned short Mask = 0x16; const unsigned short NumElements = 38; unsigned short Pattern[NumElements] = { 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0302, 0x0302, 0x0302, 0x0302, 0x0302, 0x0302, 0x0302, 0x0302, 0x0302, 0x0302, 0x0002, 0x0002, 0x0002, 0x0003, 0x0002 }; m_VerticalPattern.Mask = Mask; m_VerticalPattern.NumElements = NumElements; m_VerticalPattern.PatternData = (unsigned short *)malloc(NumElements * sizeof(unsigned short)); for ( int i=0; iMask = Mask; Pattern->BinningLimit = BinningLimit; Pattern->RefNumElements = RefNumElements; Pattern->SigNumElements = SigNumElements; if ( RefNumElements > 0 ) { Pattern->RefPatternData = (unsigned short *)malloc(RefNumElements * sizeof(unsigned short)); for ( i=0; iRefPatternData[i] = RefPatternData[i]; } } if ( SigNumElements > 0 ) { Pattern->SigPatternData = (unsigned short *)malloc(SigNumElements * sizeof(unsigned short)); for ( i=0; iSigPatternData[i] = SigPatternData[i]; } } if ( BinningLimit > 0 ) { for ( i=0; iBinNumElements[i] = BinNumElements[i]; Pattern->BinPatternData[i] = (unsigned short *)malloc(BinNumElements[i] * sizeof(unsigned short)); for ( j=0; jBinPatternData[i][j] = BinPatternData[i][j]; } } } } libapogee2-2.2/CMakeLists.txt0000644000175000017500000001517511110507150013736 0ustar jrjrcmake_minimum_required(VERSION 2.4.7) set(CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake_modules/") set(BIN_INSTALL_DIR "${CMAKE_INSTALL_PREFIX}/bin") set(INCLUDE_INSTALL_DIR "${CMAKE_INSTALL_PREFIX}/include") set(APOGEE_VERSION "2.2") set(APOGEE_SOVERSION "2") Include (CheckCXXSourceCompiles) include (MacroOptionalFindPackage) include (MacroLogFeature) include (MacroBoolTo01) include (CheckIncludeFiles) find_package(USB REQUIRED) find_package(CURL REQUIRED) include_directories( ${CMAKE_CURRENT_BINARY_DIR}) include_directories( ${CMAKE_SOURCE_DIR}) include_directories( ${CMAKE_SOURCE_DIR}/ApogeeNet) include_directories( ${CMAKE_SOURCE_DIR}/ApogeeUsb) include_directories( ${CMAKE_SOURCE_DIR}/FpgaRegs) set(AltaCommon_SRCS ${CMAKE_SOURCE_DIR}/ApnCamData_KAF6303E.cpp ${CMAKE_SOURCE_DIR}/ApnCamData_KAI11000ML.cpp ${CMAKE_SOURCE_DIR}/ApnCamData_KAF4202.cpp ${CMAKE_SOURCE_DIR}/ApnCamData_KAI2020C.cpp ${CMAKE_SOURCE_DIR}/ApnCamData_CCD5520.cpp ${CMAKE_SOURCE_DIR}/ApnCamData.cpp ${CMAKE_SOURCE_DIR}/ApnCamData_CCD4710ALT.cpp ${CMAKE_SOURCE_DIR}/ApnCamData_KAI4020C.cpp ${CMAKE_SOURCE_DIR}/ApnCamData_KAF1301E.cpp ${CMAKE_SOURCE_DIR}/ApnCamData_CCD4240B.cpp ${CMAKE_SOURCE_DIR}/ApnCamData_KAI4020CLB.cpp ${CMAKE_SOURCE_DIR}/ApnCamData_ASCENT0402ME3.cpp ${CMAKE_SOURCE_DIR}/ApnCamData_KAI11000CL.cpp ${CMAKE_SOURCE_DIR}/ApnCamData_KAF09000.cpp ${CMAKE_SOURCE_DIR}/ApnCamData_KAI2001CL.cpp ${CMAKE_SOURCE_DIR}/ApnCamData_KAF16801E.cpp ${CMAKE_SOURCE_DIR}/ApnCamData_KAI2001ML.cpp ${CMAKE_SOURCE_DIR}/ApnCamData_KAI4020M.cpp ${CMAKE_SOURCE_DIR}/ApnCamData_KAF16803.cpp ${CMAKE_SOURCE_DIR}/ApnCamData_CCD4720B.cpp ${CMAKE_SOURCE_DIR}/ApnCamData_KAF1301EB.cpp ${CMAKE_SOURCE_DIR}/ApnCamData_CCD5710F.cpp ${CMAKE_SOURCE_DIR}/ApnCamData_KAI2020CL.cpp ${CMAKE_SOURCE_DIR}/ApnCamData_KAF1001EB.cpp ${CMAKE_SOURCE_DIR}/ApnCamData_CCD7700.cpp ${CMAKE_SOURCE_DIR}/ApnCamData_CCD4240.cpp ${CMAKE_SOURCE_DIR}/ApnCamData_S101401107.cpp ${CMAKE_SOURCE_DIR}/ApnCamData_KAF1001E.cpp ${CMAKE_SOURCE_DIR}/ApnCamData_KAI4020MLB.cpp ${CMAKE_SOURCE_DIR}/ApnCamData_CCD4710B.cpp ${CMAKE_SOURCE_DIR}/ApnCamData_ASCENT16000.cpp ${CMAKE_SOURCE_DIR}/ApnCamData_KAF0401E.cpp ${CMAKE_SOURCE_DIR}/ApnCamData_KAI2001M.cpp ${CMAKE_SOURCE_DIR}/ApnCamData_KAF1401E.cpp ${CMAKE_SOURCE_DIR}/ApnCamData_KAI11000C.cpp ${CMAKE_SOURCE_DIR}/ApnCamData_KAF0261E.cpp ${CMAKE_SOURCE_DIR}/ApnCamData_CCD5520B.cpp ${CMAKE_SOURCE_DIR}/ApnCamData_CCD5710B.cpp ${CMAKE_SOURCE_DIR}/ApnCamData_CCD5710.cpp ${CMAKE_SOURCE_DIR}/ApnCamData_KAI11000M.cpp ${CMAKE_SOURCE_DIR}/ApnCamData_KAF1602EB.cpp ${CMAKE_SOURCE_DIR}/ApnCamData_KAI2020MLB.cpp ${CMAKE_SOURCE_DIR}/ApnCamData_KAF0261EB.cpp ${CMAKE_SOURCE_DIR}/ApnCamData_KAI4020CL.cpp ${CMAKE_SOURCE_DIR}/ApnCamData_ASCENT4000.cpp ${CMAKE_SOURCE_DIR}/ApnCamData_KAF3200EB.cpp ${CMAKE_SOURCE_DIR}/ApnCamData_KAF10011105.cpp ${CMAKE_SOURCE_DIR}/ApnCamData_CCD3011.cpp ${CMAKE_SOURCE_DIR}/ApnCamData_ASCENT2000.cpp ${CMAKE_SOURCE_DIR}/ApnCamData_KAF1001ENS.cpp ${CMAKE_SOURCE_DIR}/ApnCamData_KAF6303EB.cpp ${CMAKE_SOURCE_DIR}/ApnCamData_ASCENT0402ME2.cpp ${CMAKE_SOURCE_DIR}/ApnCamData_KAI4020ML.cpp ${CMAKE_SOURCE_DIR}/ApnCamData_KAI2020ML.cpp ${CMAKE_SOURCE_DIR}/ApnCamData_ASCENT340.cpp ${CMAKE_SOURCE_DIR}/ApnCamData_KAF0401EB.cpp ${CMAKE_SOURCE_DIR}/ApnCamData_CCD7700B.cpp ${CMAKE_SOURCE_DIR}/ApnCamData_ASCENT0402ME4.cpp ${CMAKE_SOURCE_DIR}/ApnCamData_KAF3200E.cpp ${CMAKE_SOURCE_DIR}/ApnCamData_ASCENT0402ME.cpp ${CMAKE_SOURCE_DIR}/ApnCamData_TH7899.cpp ${CMAKE_SOURCE_DIR}/ApnCamData_CCD3011B.cpp ${CMAKE_SOURCE_DIR}/ApnCamData_KAI2020M.cpp ${CMAKE_SOURCE_DIR}/ApnCamData_KAF1602E.cpp ${CMAKE_SOURCE_DIR}/ApnCamData_CCD4720.cpp ${CMAKE_SOURCE_DIR}/ApnCamData_KAF09000X.cpp ${CMAKE_SOURCE_DIR}/ApnCamData_CCD4710.cpp ${CMAKE_SOURCE_DIR}/ApnCamData_KAI2020CLB.cpp ${CMAKE_SOURCE_DIR}/ApnCamData_KAF09000H.cpp ${CMAKE_SOURCE_DIR}/ApnCamData_S101401109.cpp ${CMAKE_SOURCE_DIR}/ApnCamTable.cpp ) add_definitions("-O2 -g -fpic -DWall -DLINUX -DALTA_STANDALONE -DHAVE_STRERROR") ########### libapogeeAltaU ########### set(AltaU_SRCS ${CMAKE_SOURCE_DIR}/libapogee.cpp ${CMAKE_SOURCE_DIR}/ApnCamera.cpp ${CMAKE_SOURCE_DIR}/ApnCamera_USB.cpp ${CMAKE_SOURCE_DIR}/ApnCamera_Linux.cpp ${CMAKE_SOURCE_DIR}/ApogeeUsb/ApogeeUsbLinux.cpp ${AltaCommon_SRCS} ) add_library(apogeeu SHARED ${AltaU_SRCS}) set_target_properties(apogeeu PROPERTIES VERSION ${APOGEE_VERSION} SOVERSION ${APOGEE_SOVERSION}) target_link_libraries(apogeeu ${LIBUSB_LIBRARIES}) install(TARGETS apogeeu LIBRARY DESTINATION lib${LIB_POSTFIX} ) ########### libapogeeAltaE ########### set(AltaE_SRCS ${CMAKE_SOURCE_DIR}/libapogee.cpp ${CMAKE_SOURCE_DIR}/ApnCamera.cpp ${CMAKE_SOURCE_DIR}/ApnCamera_NET.cpp ${CMAKE_SOURCE_DIR}/ApnCamera_Linux.cpp ${CMAKE_SOURCE_DIR}/ApogeeNet/ApogeeNet.cpp ${CMAKE_SOURCE_DIR}/ApogeeNet/ApogeeNetLinux.c ${AltaCommon_SRCS} ) add_library(apogeee SHARED ${AltaE_SRCS}) set_target_properties(apogeee PROPERTIES VERSION ${APOGEE_VERSION} SOVERSION ${APOGEE_SOVERSION}) target_link_libraries(apogeee ${LIBUSB_LIBRARIES} ${CURL_LIBRARIES}) install(TARGETS apogeee LIBRARY DESTINATION lib${LIB_POSTFIX} ) install( FILES libapogee.h DESTINATION ${INCLUDE_INSTALL_DIR}/libapogee COMPONENT Devel) libapogee2-2.2/ApnCamData_KAF6303EB.h0000644000175000017500000000220611110507150014473 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_KAF6303EB.h: Interface file for the CApnCamData_KAF6303EB class. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #if _MSC_VER > 1000 #pragma once #endif // _MSC_VER> 1000 #include "ApnCamData.h" class CApnCamData_KAF6303EB : public CApnCamData { public: CApnCamData_KAF6303EB(); virtual ~CApnCamData_KAF6303EB(); void Initialize(); private: void set_vpattern(); void set_hpattern_clamp_sixteen(); void set_hpattern_skip_sixteen(); void set_hpattern_roi_sixteen(); void set_hpattern_clamp_twelve(); void set_hpattern_skip_twelve(); void set_hpattern_roi_twelve(); void set_hpattern( APN_HPATTERN_FILE *Pattern, unsigned short Mask, unsigned short BinningLimit, unsigned short RefNumElements, unsigned short SigNumElements, unsigned short BinNumElements[], unsigned short RefPatternData[], unsigned short SigPatternData[], unsigned short BinPatternData[][APN_MAX_PATTERN_ENTRIES] ); }; libapogee2-2.2/ApnCamData_KAI2001M.cpp0000644000175000017500000005251211110507150014733 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_KAI2001M.cpp: Implementation file for the CApnCamData_KAI2001M class. // ///////////////////////////////////////////////////////////// #include "ApnCamData_KAI2001M.h" #include #include #include ///////////////////////////////////////////////////////////// // Construction/Destruction ///////////////////////////////////////////////////////////// CApnCamData_KAI2001M::CApnCamData_KAI2001M() { } CApnCamData_KAI2001M::~CApnCamData_KAI2001M() { } void CApnCamData_KAI2001M::Initialize() { strcpy( m_Sensor, "KAI2001M" ); strcpy( m_CameraModel, "2001" ); m_CameraId = 65; m_InterlineCCD = true; m_SupportsSerialA = true; m_SupportsSerialB = true; m_SensorTypeCCD = true; m_TotalColumns = 1648; m_ImagingColumns = 1600; m_ClampColumns = 24; m_PreRoiSkipColumns = 0; m_PostRoiSkipColumns = 0; m_OverscanColumns = 24; m_TotalRows = 1214; m_ImagingRows = 1200; m_UnderscanRows = 6; m_OverscanRows = 8; m_VFlushBinning = 1; m_EnableSingleRowOffset = false; m_RowOffsetBinning = 1; m_HFlushDisable = false; m_ShutterCloseDelay = 0; m_PixelSizeX = 7.4; m_PixelSizeY = 7.4; m_Color = false; m_ReportedGainSixteenBit = 1; m_MinSuggestedExpTime = 0.05; m_CoolingSupported = true; m_RegulatedCoolingSupported = true; m_TempSetPoint = -20.0; m_TempRampRateOne = 3000; m_TempRampRateTwo = 3000; m_TempBackoffPoint = 2.0; //m_DefaultGainTwelveBit = 300; //m_DefaultOffsetTwelveBit = 50; m_DefaultRVoltage = 1000; set_vpattern(); set_hpattern_clamp_sixteen(); set_hpattern_skip_sixteen(); set_hpattern_roi_sixteen(); set_hpattern_clamp_twelve(); set_hpattern_skip_twelve(); set_hpattern_roi_twelve(); } void CApnCamData_KAI2001M::set_vpattern() { const unsigned short Mask = 0x106; const unsigned short NumElements = 38; unsigned short Pattern[NumElements] = { 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0302, 0x0302, 0x0302, 0x0302, 0x0302, 0x0302, 0x0302, 0x0302, 0x0302, 0x0302, 0x0002, 0x0002, 0x0002, 0x0003, 0x0002 }; m_VerticalPattern.Mask = Mask; m_VerticalPattern.NumElements = NumElements; m_VerticalPattern.PatternData = (unsigned short *)malloc(NumElements * sizeof(unsigned short)); for ( int i=0; iMask = Mask; Pattern->BinningLimit = BinningLimit; Pattern->RefNumElements = RefNumElements; Pattern->SigNumElements = SigNumElements; if ( RefNumElements > 0 ) { Pattern->RefPatternData = (unsigned short *)malloc(RefNumElements * sizeof(unsigned short)); for ( i=0; iRefPatternData[i] = RefPatternData[i]; } } if ( SigNumElements > 0 ) { Pattern->SigPatternData = (unsigned short *)malloc(SigNumElements * sizeof(unsigned short)); for ( i=0; iSigPatternData[i] = SigPatternData[i]; } } if ( BinningLimit > 0 ) { for ( i=0; iBinNumElements[i] = BinNumElements[i]; Pattern->BinPatternData[i] = (unsigned short *)malloc(BinNumElements[i] * sizeof(unsigned short)); for ( j=0; jBinPatternData[i][j] = BinPatternData[i][j]; } } } } libapogee2-2.2/ApnGlue.h0000644000175000017500000000154311110507150012674 0ustar jrjr/* glue so C can make use of key operations available in CApnCamera. */ #ifdef __cplusplus extern "C" { #endif extern int ApnGlueOpen(void); extern void ApnGlueGetMaxValues (double *exptime, int *roiw, int *roih, int *osw, int *osh, int *binw, int *binh, int *shutter, double *mintemp); extern int ApnGlueSetExpGeom (int roiw, int roih, int osw, int osh, int binw, int binh, int roix, int roiy, int *impixw, int *impixh, char whynot[]); extern void ApnGlueExpAbort(void); extern int ApnGlueStartExp (double *exptime, int shutter); extern int ApnGlueExpDone(void); extern int ApnGlueReadPixels (unsigned short *buf, int nbuf, char whynot[]); extern void ApnGlueSetTemp (double C); extern int ApnGlueGetTemp (double *Cp); extern void ApnGlueSetFan (int speed); extern void ApnGlueGetName(char **sensor, char **camera); #ifdef __cplusplus } #endif libapogee2-2.2/ApogeeUsb/0000755000175000017500000000000011110507150013037 5ustar jrjrlibapogee2-2.2/ApogeeUsb/usb.h0000644000175000017500000001744711110507150014016 0ustar jrjr/* * Prototypes, structure definitions and macros. * * Copyright (c) 2000-2003 Johannes Erdfelt * * This library is covered by the LGPL, read LICENSE for details. * * This file (and only this file) may alternatively be licensed under the * BSD license as well, read LICENSE for details. */ #ifndef __USB_H__ #define __USB_H__ #include #include #include #include /* * USB spec information * * This is all stuff grabbed from various USB specs and is pretty much * not subject to change */ /* * Device and/or Interface Class codes */ #define USB_CLASS_PER_INTERFACE 0 /* for DeviceClass */ #define USB_CLASS_AUDIO 1 #define USB_CLASS_COMM 2 #define USB_CLASS_HID 3 #define USB_CLASS_PRINTER 7 #define USB_CLASS_MASS_STORAGE 8 #define USB_CLASS_HUB 9 #define USB_CLASS_DATA 10 #define USB_CLASS_VENDOR_SPEC 0xff /* * Descriptor types */ #define USB_DT_DEVICE 0x01 #define USB_DT_CONFIG 0x02 #define USB_DT_STRING 0x03 #define USB_DT_INTERFACE 0x04 #define USB_DT_ENDPOINT 0x05 #define USB_DT_HID 0x21 #define USB_DT_REPORT 0x22 #define USB_DT_PHYSICAL 0x23 #define USB_DT_HUB 0x29 /* * Descriptor sizes per descriptor type */ #define USB_DT_DEVICE_SIZE 18 #define USB_DT_CONFIG_SIZE 9 #define USB_DT_INTERFACE_SIZE 9 #define USB_DT_ENDPOINT_SIZE 7 #define USB_DT_ENDPOINT_AUDIO_SIZE 9 /* Audio extension */ #define USB_DT_HUB_NONVAR_SIZE 7 /* All standard descriptors have these 2 fields in common */ struct usb_descriptor_header { u_int8_t bLength; u_int8_t bDescriptorType; }; /* String descriptor */ struct usb_string_descriptor { u_int8_t bLength; u_int8_t bDescriptorType; u_int16_t wData[1]; }; /* HID descriptor */ struct usb_hid_descriptor { u_int8_t bLength; u_int8_t bDescriptorType; u_int16_t bcdHID; u_int8_t bCountryCode; u_int8_t bNumDescriptors; /* u_int8_t bReportDescriptorType; */ /* u_int16_t wDescriptorLength; */ /* ... */ }; /* Endpoint descriptor */ #define USB_MAXENDPOINTS 32 struct usb_endpoint_descriptor { u_int8_t bLength; u_int8_t bDescriptorType; u_int8_t bEndpointAddress; u_int8_t bmAttributes; u_int16_t wMaxPacketSize; u_int8_t bInterval; u_int8_t bRefresh; u_int8_t bSynchAddress; unsigned char *extra; /* Extra descriptors */ int extralen; }; #define USB_ENDPOINT_ADDRESS_MASK 0x0f /* in bEndpointAddress */ #define USB_ENDPOINT_DIR_MASK 0x80 #define USB_ENDPOINT_TYPE_MASK 0x03 /* in bmAttributes */ #define USB_ENDPOINT_TYPE_CONTROL 0 #define USB_ENDPOINT_TYPE_ISOCHRONOUS 1 #define USB_ENDPOINT_TYPE_BULK 2 #define USB_ENDPOINT_TYPE_INTERRUPT 3 /* Interface descriptor */ #define USB_MAXINTERFACES 32 struct usb_interface_descriptor { u_int8_t bLength; u_int8_t bDescriptorType; u_int8_t bInterfaceNumber; u_int8_t bAlternateSetting; u_int8_t bNumEndpoints; u_int8_t bInterfaceClass; u_int8_t bInterfaceSubClass; u_int8_t bInterfaceProtocol; u_int8_t iInterface; struct usb_endpoint_descriptor *endpoint; unsigned char *extra; /* Extra descriptors */ int extralen; }; #define USB_MAXALTSETTING 128 /* Hard limit */ struct usb_interface { struct usb_interface_descriptor *altsetting; int num_altsetting; }; /* Configuration descriptor information.. */ #define USB_MAXCONFIG 8 struct usb_config_descriptor { u_int8_t bLength; u_int8_t bDescriptorType; u_int16_t wTotalLength; u_int8_t bNumInterfaces; u_int8_t bConfigurationValue; u_int8_t iConfiguration; u_int8_t bmAttributes; u_int8_t MaxPower; struct usb_interface *interface; unsigned char *extra; /* Extra descriptors */ int extralen; }; /* Device descriptor */ struct usb_device_descriptor { u_int8_t bLength; u_int8_t bDescriptorType; u_int16_t bcdUSB; u_int8_t bDeviceClass; u_int8_t bDeviceSubClass; u_int8_t bDeviceProtocol; u_int8_t bMaxPacketSize0; u_int16_t idVendor; u_int16_t idProduct; u_int16_t bcdDevice; u_int8_t iManufacturer; u_int8_t iProduct; u_int8_t iSerialNumber; u_int8_t bNumConfigurations; }; struct usb_ctrl_setup { u_int8_t bRequestType; u_int8_t bRequest; u_int16_t wValue; u_int16_t wIndex; u_int16_t wLength; }; /* * Standard requests */ #define USB_REQ_GET_STATUS 0x00 #define USB_REQ_CLEAR_FEATURE 0x01 /* 0x02 is reserved */ #define USB_REQ_SET_FEATURE 0x03 /* 0x04 is reserved */ #define USB_REQ_SET_ADDRESS 0x05 #define USB_REQ_GET_DESCRIPTOR 0x06 #define USB_REQ_SET_DESCRIPTOR 0x07 #define USB_REQ_GET_CONFIGURATION 0x08 #define USB_REQ_SET_CONFIGURATION 0x09 #define USB_REQ_GET_INTERFACE 0x0A #define USB_REQ_SET_INTERFACE 0x0B #define USB_REQ_SYNCH_FRAME 0x0C #define USB_TYPE_STANDARD (0x00 << 5) #define USB_TYPE_CLASS (0x01 << 5) #define USB_TYPE_VENDOR (0x02 << 5) #define USB_TYPE_RESERVED (0x03 << 5) #define USB_RECIP_DEVICE 0x00 #define USB_RECIP_INTERFACE 0x01 #define USB_RECIP_ENDPOINT 0x02 #define USB_RECIP_OTHER 0x03 /* * Various libusb API related stuff */ #define USB_ENDPOINT_IN 0x80 #define USB_ENDPOINT_OUT 0x00 /* Error codes */ #define USB_ERROR_BEGIN 500000 /* * This is supposed to look weird. This file is generated from autoconf * and I didn't want to make this too complicated. */ #if 0 #define USB_LE16_TO_CPU(x) do { x = ((x & 0xff) << 8) | ((x & 0xff00) >> 8); } while(0) #else #define USB_LE16_TO_CPU(x) #endif /* Data types */ struct usb_device; struct usb_bus; struct usb_device { struct usb_device *next, *prev; char filename[PATH_MAX + 1]; struct usb_bus *bus; struct usb_device_descriptor descriptor; struct usb_config_descriptor *config; void *dev; /* Darwin support */ }; struct usb_bus { struct usb_bus *next, *prev; char dirname[PATH_MAX + 1]; struct usb_device *devices; u_int32_t location; }; struct usb_dev_handle; typedef struct usb_dev_handle usb_dev_handle; /* Variables */ extern struct usb_bus *usb_busses; #ifdef __cplusplus extern "C" { #endif /* Function prototypes */ /* usb.c */ usb_dev_handle *usb_open(struct usb_device *dev); int usb_close(usb_dev_handle *dev); int usb_get_string(usb_dev_handle *dev, int index, int langid, char *buf, size_t buflen); int usb_get_string_simple(usb_dev_handle *dev, int index, char *buf, size_t buflen); /* descriptors.c */ int usb_get_descriptor_by_endpoint(usb_dev_handle *udev, int ep, unsigned char type, unsigned char index, void *buf, int size); int usb_get_descriptor(usb_dev_handle *udev, unsigned char type, unsigned char index, void *buf, int size); /* .c */ int usb_bulk_write(usb_dev_handle *dev, int ep, char *bytes, int size, int timeout); int usb_bulk_read(usb_dev_handle *dev, int ep, char *bytes, int size, int timeout); int usb_interrupt_write(usb_dev_handle *dev, int ep, char *bytes, int size, int timeout); int usb_interrupt_read(usb_dev_handle *dev, int ep, char *bytes, int size, int timeout); int usb_control_msg(usb_dev_handle *dev, int requesttype, int request, int value, int index, char *bytes, int size, int timeout); int usb_set_configuration(usb_dev_handle *dev, int configuration); int usb_claim_interface(usb_dev_handle *dev, int interface); int usb_release_interface(usb_dev_handle *dev, int interface); int usb_set_altinterface(usb_dev_handle *dev, int alternate); int usb_resetep(usb_dev_handle *dev, unsigned int ep); int usb_clear_halt(usb_dev_handle *dev, unsigned int ep); int usb_reset(usb_dev_handle *dev); #if 1 #define LIBUSB_HAS_GET_DRIVER_NP 1 int usb_get_driver_np(usb_dev_handle *dev, int interface, char *name, unsigned int namelen); #define LIBUSB_HAS_DETACH_KERNEL_DRIVER_NP 1 int usb_detach_kernel_driver_np(usb_dev_handle *dev, int interface); #endif char *usb_strerror(void); void usb_init(void); void usb_set_debug(int level); int usb_find_busses(void); int usb_find_devices(void); struct usb_device *usb_device(usb_dev_handle *dev); struct usb_bus *usb_get_busses(void); #ifdef __cplusplus } #endif #endif /* __USB_H__ */ libapogee2-2.2/ApogeeUsb/ApogeeUsb.h0000644000175000017500000001224211110507150015063 0ustar jrjr#if !defined(_APOGEEUSB_H__INCLUDED_) #define _APOGEEUSB_H__INCLUDED_ #if _MSC_VER > 1000 #pragma once #endif // _MSC_VER > 1000 #ifndef APN_USB_TYPE #define APN_USB_TYPE unsigned short #endif #define APN_USB_MAXCAMERAS 255 // The following lists the driver versions for feature support // within the .sys driver #define APN_USB_DRIVER_VER_SEQUENCE_SUPPORT 2.0 // The following lists the PID of the USB interface board // for supporting various features #define APN_USB_PID_SEQUENCE_SUPPORT #define APN_USB_SERIAL_SETTINGS_BYTE_COUNT 5 #define APN_USB_SERIAL_SETTINGS_CTRL_INDEX 4 #define APN_USB_SERIAL_BIT_FLOW_CONTROL 0x01 #define APN_USB_SERIAL_BIT_PARITY_ENABLE 0x10 #define APN_USB_SERIAL_BIT_PARITY_ODD 0x20 // The following is for the custom USB serial number feature #define APN_USB_SN_BYTE_COUNT 64 // Byte count for getting the revision of the 8051 firmware #define APN_USB_8051_REV_BYTE_COUNT 3 #ifndef IN #define IN #endif #ifndef OUT #define OUT #endif #define DWORD long #define UCHAR unsigned char typedef struct usb_dev_handle HANDLE; typedef struct _APN_USB_CAMINFO { bool bCamera; unsigned short CamNumber; unsigned short CamModel; unsigned short CamFirmware; } APN_USB_CAMINFO; #define ApnUsbParity_None 0 #define ApnUsbParity_Odd 1 #define ApnUsbParity_Even 2 APN_USB_TYPE ApnUsbOpen( unsigned short DevNumber, char *SysDeviceName ); APN_USB_TYPE ApnUsbClose( ); APN_USB_TYPE ApnUsbDiscovery( unsigned short *UsbCamCount, APN_USB_CAMINFO UsbCamInfo[] ); APN_USB_TYPE ApnUsbReadReg( unsigned short FpgaReg, unsigned short *FpgaData ); APN_USB_TYPE ApnUsbWriteReg( unsigned short FpgaReg, unsigned short FpgaData ); APN_USB_TYPE ApnUsbWriteRegMulti( unsigned short FpgaReg, unsigned short FpgaData[], unsigned short RegCount ); APN_USB_TYPE ApnUsbWriteRegMultiMRMD( unsigned short FpgaReg[], unsigned short FpgaData[], unsigned short RegCount ); APN_USB_TYPE ApnUsbReadStatusRegs( bool UseAdvStatus, bool *DoneFlag, unsigned short *StatusReg, unsigned short *HeatsinkTempReg, unsigned short *CcdTempReg, unsigned short *CoolerDriveReg, unsigned short *VoltageReg, unsigned short *TdiCounter, unsigned short *SequenceCounter, unsigned short *MostRecentFrame, unsigned short *ReadyFrame, unsigned short *CurrentFrame ); APN_USB_TYPE ApnUsbStartExp( unsigned short ImageCount, unsigned short ImageWidth, unsigned short ImageHeight ); APN_USB_TYPE ApnUsbStartCI( unsigned short ImageWidth, unsigned short ImageHeight ); APN_USB_TYPE ApnUsbStopExp( bool DigitizeData ); APN_USB_TYPE ApnUsbStopCI( unsigned short PostStopCount ); APN_USB_TYPE ApnUsbGetImage( unsigned long ImgSizeBytes, unsigned short *pMem ); APN_USB_TYPE ApnUsbReset( ); APN_USB_TYPE ApnUsbSerialReadSettings( unsigned short SerialId, unsigned char *Settings ); APN_USB_TYPE ApnUsbSerialWriteSettings( unsigned short SerialId, unsigned char *Settings ); APN_USB_TYPE ApnUsbSerialReadBaudRate( unsigned short SerialId, unsigned long *BaudRate ); APN_USB_TYPE ApnUsbSerialWriteBaudRate( unsigned short SerialId, unsigned long BaudRate ); APN_USB_TYPE ApnUsbSerialReadFlowControl( unsigned short SerialId, bool *FlowControl ); APN_USB_TYPE ApnUsbSerialWriteFlowControl( unsigned short SerialId, bool FlowControl ); APN_USB_TYPE ApnUsbSerialReadParity( unsigned short SerialId, int *Parity ); APN_USB_TYPE ApnUsbSerialWriteParity( unsigned short SerialId, int Parity ); APN_USB_TYPE ApnUsbSerialRead( unsigned short SerialId, char *ReadBuffer, unsigned short *BufferCount ); APN_USB_TYPE ApnUsbSerialWrite( unsigned short SerialId, char *WriteBuffer, unsigned short BufferCount ); APN_USB_TYPE ApnUsbReadVendorInfo( unsigned short *VendorId, unsigned short *ProductId, unsigned short *DeviceId ); APN_USB_TYPE ApnUsbSysDriverVersion( double *VersionNumber ); APN_USB_TYPE ApnUsbReadCustomSerialNumber( char *SerialNumber, unsigned short *SerialNumberLength ); APN_USB_TYPE ApnUsbRead8051FirmwareRevision( char *Revision ); APN_USB_TYPE ApnUsbConfigureDataPort( unsigned short Assignment ); APN_USB_TYPE ApnUsbReadDataPort( unsigned short *DataValue ); APN_USB_TYPE ApnUsbWriteDataPort( unsigned short DataValue ); APN_USB_TYPE ApnUsbConfigureControlPort( unsigned short Assignment ); APN_USB_TYPE ApnUsbReadControlPort( unsigned char *ControlValue, unsigned char *OptionPinValue ); APN_USB_TYPE ApnUsbWriteControlPort( unsigned char ControlValue, unsigned char OptionPinValue ); #endif // !defined(_APOGEEUSB_H__INCLUDED_) libapogee2-2.2/ApogeeUsb/reb1100.cpp0000644000175000017500000001250011110507150014613 0ustar jrjr/*************************************************************************** reb1100.cpp - REB1100 communication class ------------------- begin : Thu Mar 27 2003 copyright : (C) 2003 by Igor Izyumin email : igor@mlug.missouri.edu ***************************************************************************/ /*************************************************************************** This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. **********************************************************************/ #include "reb1100.h" REB1100::REB1100(){ struct usb_bus *bus; struct usb_device *dev; usb_init(); usb_find_busses(); usb_find_devices(); char string[256]; int found = 0; /* find ebook device */ for(bus = usb_busses; bus && !found; bus = bus->next) { for(dev = bus->devices; dev && !found; dev = dev->next) { if (dev->descriptor.idVendor == 0x993 && dev->descriptor.idProduct == 0x1) { hDevice = usb_open(dev); cerr << "Found eBook. Attempting to open... "; found = 1; if (hDevice) { // if (!usb_get_string_simple(hDevice, dev->descriptor.iSerialNumber, string, sizeof(string))) throw DevOpenError(); cerr << "Success.\n"; // cerr << "Serial number: " << string << endl; } else throw DevOpenError(); } } } if (!found) throw DevNotFoundError(); if (!usb_set_configuration(hDevice, 0x0)) throw DevOpenError(); if (!usb_claim_interface(hDevice, 0x1)) throw DevOpenError(); memTarget = INTERNAL; } REB1100::~REB1100(){ usb_release_interface(hDevice, 0x0); usb_close(hDevice); } void REB1100::getFile(string filename, string &data) { long flength = filename.length(); char buf[4096]; char zeros[4] = {0, 0, 0, 0}; int ret; string request; // first four bytes are the length of the filename // (low-endian) char *byte = reinterpret_cast(&flength); request += *byte; byte++; request += *byte; byte++; request += *byte; byte++; request += *byte; // the rest is the filename request += filename; // send a USB control request to tell the device what file we want char *temp; temp = new char[request.length()]; request.copy(temp, string::npos); ret = usb_control_msg(hDevice, 0x42, 0x01, 0x00, 0x00, temp, request.length(), 300); if (ret == -1) throw DevControlError(); delete temp; temp = NULL; // read the return code ret = usb_control_msg(hDevice, 0xc2, 0x02, 0x00, 0x00, zeros, 4, 300); if (ret == -1) throw DevControlError(); // read file from pipe do { ret = usb_bulk_read(hDevice, 2, buf, 4096, 1000); if (ret == -1) throw DevReadError(); for(int i = 0; i < ret; i++) { data += buf[i]; } } while(ret == 4096); } void REB1100::sendFile(string filename, string &data) { string prefix = ""; if (memTarget == MEMCARD) { // prefix with \SM\ when sending to memory card prefix = "\\SM\\"; } filename = prefix + filename; long flength = data.length(); long fnlength = filename.length(); // prepare initial request string request; // first four bytes are the length of the file // (low-endian) char *byte = reinterpret_cast(&flength); request += *byte; byte++; request += *byte; byte++; request += *byte; byte++; request += *byte; // next four bytes are the length of the filename // (low-endian) byte = reinterpret_cast(&fnlength); request += *byte; byte++; request += *byte; byte++; request += *byte; byte++; request += *byte; // append filename request += filename; // send message to device int ret; char *temp; temp = new char[request.length()]; request.copy(temp, string::npos); ret = usb_control_msg(hDevice, 0x42, 0x00, 0x00, 0x00, temp, request.length(), 3000); delete temp; temp = NULL; if (ret == -1) throw DevControlError(); // read from device and check for error char temp2[4] = {0, 0, 0, 0}; ret = usb_control_msg(hDevice, 0xc2, 0x03, 0x00, 0x00, temp2, 4, 3000); if (ret == -1) throw DevControlError(); if (temp2[0] || temp2[1] || temp2[2] || temp2[3]) throw DevControlError(); // now start bulk writing to the device string buf; int n, offset = 0; char *temp3; do { buf = data.substr(offset, 4096); n = buf.length(); if (buf.length() > 0) { temp3 = new char[buf.length()]; buf.copy(temp3, string::npos); // cout << "Sending block (" << n << " bytes)\n"; ret = usb_bulk_write(hDevice, 2, temp3, n, 3000); if (ret == -1) throw DevWriteError(); delete temp3; temp3 = NULL; offset += 4096; } } while(offset + 1 < data.length()); // send empty packet to signify end of file ret = usb_bulk_write(hDevice, 2, 0, 0, 3000); if (ret == -1) throw DevWriteError(); } void REB1100::setTarget(bool target) { memTarget = target; } libapogee2-2.2/ApogeeUsb/ApogeeUsbLinux.cpp0000644000175000017500000010207211110507150016437 0ustar jrjr// ApogeeUsb.cpp : Library of basic USB functions for Apogee APn/Alta. // #include #ifndef OSX #ifndef OSXI #include #endif #endif #include #include #include #include #include #include #include #include #include #include #include #include "usb.h" extern int usb_debug; /*#define HANDLE unsigned long */ #define ULONG unsigned int #define BOOLEAN unsigned int #define USHORT unsigned short #define PUCHAR unsigned char * #define APUSB_VERSION_MAJOR 1 #define APUSB_VERSION_MINOR 4 #define APUSB_CUSTOM_SN_BYTE_COUNT 64 #define APUSB_8051_REV_BYTE_COUNT 3 #define APUSB_CUSTOM_SN_DID_SUPPORT 0x0011 #define APUSB_8051_REV_DID_SUPPORT 0x0011 #define APUSB_CI_DID_SUPPORT 0x0011 #define APUSB_PID_ALTA 0x0010 #define APUSB_PID_ASCENT 0x0020 #include "ApogeeUsb.h" #include "ApogeeUsbErr.h" #include "ApogeeLinux.h" #include "ApnCamera_USB.h" #define FALSE false #define BYTE char #define APOGEE_USB_DEVICE "/dev/usb/alta" #define INVALID_HANDLE_VALUE -1 #define VND_ANCHOR_LOAD_INTERNAL 0xA0 #define VND_APOGEE_CMD_BASE 0xC0 #define VND_APOGEE_STATUS ( VND_APOGEE_CMD_BASE + 0x0 ) #define VND_APOGEE_CAMCON_REG ( VND_APOGEE_CMD_BASE + 0x2 ) #define VND_APOGEE_BUFCON_REG ( VND_APOGEE_CMD_BASE + 0x3 ) #define VND_APOGEE_SET_SERIAL ( VND_APOGEE_CMD_BASE + 0x4 ) #define VND_APOGEE_SERIAL ( VND_APOGEE_CMD_BASE + 0x5 ) #define VND_APOGEE_EEPROM ( VND_APOGEE_CMD_BASE + 0x6 ) #define VND_APOGEE_SOFT_RESET ( VND_APOGEE_CMD_BASE + 0x8 ) #define VND_APOGEE_GET_IMAGE ( VND_APOGEE_CMD_BASE + 0x9 ) #define VND_APOGEE_STOP_IMAGE ( VND_APOGEE_CMD_BASE + 0xA ) #define VND_APOGEE_VENDOR ( VND_APOGEE_CMD_BASE + 0xB ) #define VND_APOGEE_VERSION ( VND_APOGEE_CMD_BASE + 0xC ) #define VND_APOGEE_DATA_PORT ( VND_APOGEE_CMD_BASE + 0xD ) #define VND_APOGEE_CONTROL_PORT ( VND_APOGEE_CMD_BASE + 0xE ) #define USB_ALTA_VENDOR_ID 0x125c #define USB_ALTA_PRODUCT_ID 0x0010 #define USB_ASCENT_PRODUCT_ID 0x0020 #define USB_DIR_IN USB_ENDPOINT_IN #define USB_DIR_OUT USB_ENDPOINT_OUT typedef struct _APN_USB_REQUEST { unsigned char Request; unsigned char Direction; unsigned short Value; unsigned short Index; } APN_USB_REQUEST, *PAPN_USB_REQUEST; // Global variables used in this DLL struct usb_dev_handle *g_hSysDriver; ULONG g_UsbImgSizeBytes; char controlBuffer[1024]; ULONG firmwareRevision; unsigned char idProduct; #define IMAGE_BUFFER_SIZE 126976 // Number of requested bytes in a transfer //#define IMAGE_BUFFER_SIZE 253952 // Number of requested bytes in a transfer // This is an example of an exported function. bool ApnUsbCreateRequest( unsigned char Request, bool InputRequest, unsigned short Index, unsigned short Value, unsigned long Length, unsigned char *pBuffer ) { APN_USB_REQUEST UsbRequest; BOOLEAN Success; DWORD BytesReceived; UCHAR Direction; PUCHAR pSendBuffer; ULONG SendBufferLen; unsigned short Detail; unsigned char sDetail[2]; if ( InputRequest ) Direction = USB_DIR_IN; else Direction = USB_DIR_OUT; UsbRequest.Request = Request; UsbRequest.Direction = Direction; UsbRequest.Index = Index; UsbRequest.Value = Value; sDetail[0] = Index; sDetail[1] = Value; if ( Direction == USB_DIR_IN ) { SendBufferLen = sizeof(APN_USB_REQUEST); pSendBuffer = new UCHAR[SendBufferLen]; memcpy( pSendBuffer, &UsbRequest, sizeof(APN_USB_REQUEST) ); } else { SendBufferLen = sizeof(APN_USB_REQUEST) + Length; pSendBuffer = new UCHAR[SendBufferLen]; memcpy( pSendBuffer, &UsbRequest, sizeof(APN_USB_REQUEST) ); memcpy( pSendBuffer + sizeof(APN_USB_REQUEST), pBuffer, Length ); } Success = usb_control_msg((struct usb_dev_handle *)g_hSysDriver, Direction | USB_TYPE_VENDOR | USB_RECIP_DEVICE, Request, 0, Detail,(char *)&BytesReceived, 2, 10000); delete [] pSendBuffer; if ( !Success ) return false; return true; } APN_USB_TYPE ApnUsbOpen( unsigned short DevNumber , char *SysDeviceName ) { char deviceName[128]; struct usb_bus *bus; struct usb_device *dev; // struct usb_dev_; struct usb_dev_handle *hDevice; usb_init(); usb_find_busses(); usb_find_devices(); char string[256]; int found = 0; /* find ALTA device */ for(bus = usb_busses; bus && !found; bus = bus->next) { for(dev = bus->devices; dev && !found; dev = dev->next) { if (dev->descriptor.idVendor == USB_ALTA_VENDOR_ID && ( (dev->descriptor.idProduct == USB_ALTA_PRODUCT_ID) || (dev->descriptor.idProduct == USB_ASCENT_PRODUCT_ID) ) ) { found = found+1; if (found == DevNumber) { hDevice = usb_open(dev); firmwareRevision = dev->descriptor.bcdDevice; idProduct = dev->descriptor.idProduct; // cerr << "Found ALTA USB. Attempting to open... "; if (hDevice) { // if (!usb_get_string_simple(hDevice, // dev->descriptor.iSerialNumber, // string, sizeof(string))) // throw DevOpenError(); // cerr << "Success.\n"; // cerr << "Serial number: " << string << endl; } else return APN_USB_ERR_OPEN; } } } } if (found == 0) return APN_USB_ERR_OPEN; #ifdef OSX usb_set_configuration(hDevice, 0x0); usb_claim_interface(hDevice, 0x0); printf("DRIVER: claimed interface\n"); #endif g_hSysDriver = hDevice; g_UsbImgSizeBytes = 0; // printf("DRIVER: opened device\n"); // usb_debug = 4; return APN_USB_SUCCESS; // Success } APN_USB_TYPE ApnUsbClose( void ) { if ( g_hSysDriver != 0 ) { usb_release_interface(g_hSysDriver, 0x0); usb_close(g_hSysDriver); g_hSysDriver = 0; } return APN_USB_SUCCESS; // Success } APN_USB_TYPE ApnUsbReadReg( unsigned short FpgaReg, unsigned short *FpgaData ) { int Success; unsigned short RegData; Success = usb_control_msg((struct usb_dev_handle *)g_hSysDriver, USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE, VND_APOGEE_CAMCON_REG, 0, FpgaReg,(char *)&RegData, 2, 10000); #ifdef OSX swab(&RegData,FpgaData,2); #else *FpgaData = RegData; #endif // printf("DRIVER: usb read reg=%x data=%x s=%x\n",FpgaReg,*FpgaData,Success); if ( !Success ) return APN_USB_ERR_WRITE; return APN_USB_SUCCESS; // Success } APN_USB_TYPE ApnUsbWriteReg( unsigned short FpgaReg, unsigned short FpgaData ) { char *cbuf; int Success; #ifdef OSX char cswap; cbuf = (char *)&FpgaData; cswap = cbuf[0]; cbuf[0] = cbuf[1]; cbuf[1] = cswap; #else cbuf = (char *)&FpgaData; #endif Success = usb_control_msg((struct usb_dev_handle *)g_hSysDriver, USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE, VND_APOGEE_CAMCON_REG, 0, FpgaReg, cbuf, 2, 10000); // printf("DRIVER: usb write reg=%x data=%x s=%x\n",FpgaReg,FpgaData,Success); if ( !Success ) return APN_USB_ERR_WRITE; return APN_USB_SUCCESS; // Success } APN_USB_TYPE ApnUsbWriteRegMulti( unsigned short FpgaReg, unsigned short FpgaData[], unsigned short RegCount ) { unsigned short Counter; for ( Counter=0; Counter> 16) & 0xFFFF, (ImageSize & 0xFFFF), (char *)&BytesReceived, 4, 10000); } else { Success = usb_control_msg(g_hSysDriver, USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE, VND_APOGEE_GET_IMAGE, (ImageSize >> 16) & 0xFFFF, (ImageSize & 0xFFFF), NULL, 0, 10000); } } else { DeviceData[0] = (UCHAR)(ImageCount & 0xFF); DeviceData[1] = (UCHAR)((ImageCount >> 8) & 0xFF); DeviceData[2] = 0; Success = usb_control_msg(g_hSysDriver, USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE, VND_APOGEE_GET_IMAGE, (ImageSize >> 16) & 0xFFFF, (ImageSize & 0xFFFF), (char *) &DeviceData, 3, 10000); } // printf("DRIVER: startexp s=%x\n",Success); // if ( !Success ) // { // return APN_USB_ERR_START_EXP; // } return APN_USB_SUCCESS; } APN_USB_TYPE ApnUsbStartCI( unsigned short ImageWidth, unsigned short ImageHeight ) { BOOLEAN Success; ULONG ImageSize; ULONG BytesReceived; UCHAR DeviceData[3]; // if ( (g_hSysDriver) == 0) // { // return APN_USB_ERR_OPEN; // } if ( (ImageWidth == 0) || (ImageHeight == 0 ) ) { return APN_USB_ERR_START_CI; } ImageSize = ImageWidth * ImageHeight; DeviceData[0] = 0x2; DeviceData[1] = 0xFF; DeviceData[2] = 0xFF; Success = usb_control_msg(g_hSysDriver, USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE, VND_APOGEE_GET_IMAGE, (ImageSize >> 16) & 0xFFFF, (ImageSize & 0xFFFF), (char *)&DeviceData, 3, 10000); if ( !Success ) { return APN_USB_ERR_START_CI; } return APN_USB_SUCCESS; } APN_USB_TYPE ApnUsbStopExp( bool DigitizeData ) { BOOLEAN Success; unsigned short BytesReceived; // if ( (g_hSysDriver) == 0) // { // return APN_USB_ERR_OPEN; // } if ( DigitizeData == false ) { Success = usb_control_msg(g_hSysDriver, USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE, VND_APOGEE_STOP_IMAGE, 0, 0,(char *)&BytesReceived, 2, 10000); // if ( !Success ) // { // return APN_USB_ERR_STOP_EXP; // } } return APN_USB_SUCCESS; } APN_USB_TYPE ApnUsbStopCI( unsigned short PostStopCount ) { BOOLEAN Success; ULONG BytesReceived; ULONG DownloadCountPostStop; // if ( (g_hSysDriver) == 0) // { // return APN_USB_ERR_OPEN; // } //JM: This fails to compile on x86_64 platforms //DownloadCountPostStop = (unsigned int)&PostStopCount; //JM: Temporary solution: DownloadCountPostStop = (unsigned int) PostStopCount; Success = usb_control_msg(g_hSysDriver, USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE, VND_APOGEE_STOP_IMAGE, DownloadCountPostStop, 1, 0, 0, 10000); if ( !Success ) { return APN_USB_ERR_STOP_CI; } return APN_USB_SUCCESS; } APN_USB_TYPE ApnUsbGetImage( unsigned long ImgSizeBytes, unsigned short *pMem ) { BOOLEAN Success; ULONG ImageBytesRemaining; ULONG ReceivedSize; PUCHAR pRequestData; Success = 1; // if ( (g_hSysDriver) == 0 ) // { // return APN_USB_ERR_OPEN; // } ImageBytesRemaining = ImgSizeBytes; //////////////////////// ULONG LoopCount = ImgSizeBytes / IMAGE_BUFFER_SIZE; ULONG Remainder = ImgSizeBytes - ( LoopCount * IMAGE_BUFFER_SIZE ); ULONG MemIterator = IMAGE_BUFFER_SIZE / 2; ULONG Counter; ULONG obuffersize,swabbuffersize; ULONG TotalPixels = 0; Success = 1; for ( Counter=0; Counter= APUSB_CUSTOM_SN_DID_SUPPORT)) { Length = APN_USB_SN_BYTE_COUNT + 1; Success = usb_control_msg((struct usb_dev_handle *)g_hSysDriver, USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE, VND_APOGEE_CAMCON_REG, 1, 0,(char *)&pBuffer,APUSB_CUSTOM_SN_BYTE_COUNT, 10000); if ( !Success ) { strncpy( SerialNumber, pBuffer, APUSB_CUSTOM_SN_BYTE_COUNT ); *SerialNumberLength = 0; return APN_USB_ERR_CUSTOM_SN_READ; } pBuffer[APN_USB_SN_BYTE_COUNT] = '\0'; strcpy( SerialNumber, strtok( pBuffer, "" ) ); *SerialNumberLength = strlen( SerialNumber ); } return APN_USB_SUCCESS; } APN_USB_TYPE ApnUsbRead8051FirmwareRevision( char *Revision ) { BOOLEAN Success; char pBuffer[APN_USB_8051_REV_BYTE_COUNT+1]; DWORD BytesReceived; DWORD Length; if ( (idProduct == APUSB_PID_ALTA) && (firmwareRevision >= APUSB_8051_REV_DID_SUPPORT)) { Length = APN_USB_8051_REV_BYTE_COUNT+1; Success = usb_control_msg((struct usb_dev_handle *)g_hSysDriver, USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE, VND_APOGEE_CAMCON_REG, 2, 0,(char *)&pBuffer, APUSB_8051_REV_BYTE_COUNT, 10000); if ( !Success ) { Revision[0] = 'F'; Revision[1] = 'F'; Revision[2] = 'F'; Revision[APN_USB_8051_REV_BYTE_COUNT] = '\0'; return APN_USB_ERR_8051_REV_READ; } Revision[APN_USB_8051_REV_BYTE_COUNT] = '\0'; } else { Revision[0] = 0x0; Revision[1] = 0x0; Revision[2] = 0x0; } return APN_USB_SUCCESS; } APN_USB_TYPE ApnUsbConfigureDataPort( unsigned short Assignment ) { bool Success; unsigned short TempValue; TempValue = Assignment; Success = ApnUsbCreateRequest( VND_APOGEE_DATA_PORT, false, 0, TempValue, 0, NULL ); return APN_USB_SUCCESS; } APN_USB_TYPE ApnUsbReadDataPort( unsigned short *DataValue ) { bool Success; unsigned short TempValue; Success = ApnUsbCreateRequest( VND_APOGEE_DATA_PORT, true, 0, 2, 2, (unsigned char *)&TempValue ); *DataValue = TempValue; return APN_USB_SUCCESS; } APN_USB_TYPE ApnUsbWriteDataPort( unsigned short DataValue ) { bool Success; unsigned short TempValue; TempValue = DataValue; Success = ApnUsbCreateRequest( VND_APOGEE_DATA_PORT, false, 0, 2, 2, (unsigned char *)&TempValue ); return APN_USB_SUCCESS; } APN_USB_TYPE ApnUsbConfigureControlPort( unsigned short Assignment ) { bool Success; unsigned short TempValue; TempValue = Assignment; Success = ApnUsbCreateRequest( VND_APOGEE_CONTROL_PORT, false, 0, TempValue, 0, NULL ); return APN_USB_SUCCESS; } APN_USB_TYPE ApnUsbReadControlPort( unsigned char *ControlValue, unsigned char *OptionPinValue ) { bool Success; unsigned short TempValue; Success = ApnUsbCreateRequest( VND_APOGEE_CONTROL_PORT, true, 0, 2, 2, (unsigned char *)&TempValue ); *ControlValue = TempValue & 0x00FF; *OptionPinValue = (TempValue & 0xFF00) >> 8; return APN_USB_SUCCESS; } APN_USB_TYPE ApnUsbWriteControlPort( unsigned char ControlValue, unsigned char OptionPinValue ) { bool Success; unsigned short TempValue; TempValue = 0x0; TempValue = OptionPinValue << 8; TempValue |= ControlValue; Success = ApnUsbCreateRequest( VND_APOGEE_CONTROL_PORT, false, 0, 2, 2, (unsigned char *)&TempValue ); return APN_USB_SUCCESS; } libapogee2-2.2/ApogeeUsb/ApogeeUsbErr.h0000644000175000017500000000166511110507150015543 0ustar jrjr// Error codes for the ApogeeUsb* files #define APN_USB_SUCCESS 0 #define APN_USB_ERR_OPEN 1 #define APN_USB_ERR_READ 2 #define APN_USB_ERR_WRITE 3 #define APN_USB_ERR_IMAGE_DOWNLOAD 4 #define APN_USB_ERR_START_EXP 5 #define APN_USB_ERR_STOP_EXP 6 #define APN_USB_ERR_STATUS 7 #define APN_USB_ERR_RESET 8 #define APN_USB_ERR_VENDOR_INFO 9 #define APN_USB_ERR_DRIVER_VERSION 10 #define APN_USB_ERR_CUSTOM_SN_READ 11 #define APN_USB_ERR_CUSTOM_SN_WRITE 12 #define APN_USB_ERR_8051_REV_READ 13 #define APN_USB_ERR_START_CI 14 #define APN_USB_ERR_STOP_CI 15 #define APN_USB_ERR_SERIAL_ID 20 #define APN_USB_ERR_SERIAL_OPEN 21 #define APN_USB_ERR_SERIAL_READ_SETTINGS 22 #define APN_USB_ERR_SERIAL_WRITE_SETTINGS 23 #define APN_USB_ERR_SERIAL_READ_PORT 24 #define APN_USB_ERR_SERIAL_WRITE_PORT 25 #define APN_USB_FAIL_DEVNAME_COMPARE 100 libapogee2-2.2/ApogeeUsb/ApogeeUsbLinuxForKernel.cpp0000644000175000017500000002404611110507150020253 0ustar jrjr// ApogeeUsb.cpp : Library of basic USB functions for Apogee APn/Alta. // #include #include #include #include #include #include #include #include #include #include #include #include #include #include "ApogeeUsb.h" #include "ApogeeUsbErr.h" #include "ApogeeLinux.h" #define HANDLE unsigned int #define ULONG unsigned int #define BOOLEAN unsigned int #define USHORT unsigned short #define APOGEE_USB_DEVICE "/dev/usb/alta" #define INVALID_HANDLE_VALUE -1 // Global variables used in this DLL HANDLE g_hSysDriver; ULONG g_UsbImgSizeBytes; // 1044480 // 520192 // 126976 // 61440 // 49152 // 4096 #define IMAGE_BUFFER_SIZE 126976 // Number of requested bytes in a transfer //#define IMAGE_BUFFER_SIZE 253952 // Number of requested bytes in a transfer // This is an example of an exported function. APN_USB_TYPE ApnUsbOpen( unsigned short DevNumber ) { char deviceName[128]; g_hSysDriver = 0; g_UsbImgSizeBytes = 0; // Open the driver sprintf(deviceName,"%s%d",APOGEE_USB_DEVICE,DevNumber); g_hSysDriver = ::open(deviceName,O_RDONLY); if ( g_hSysDriver == INVALID_HANDLE_VALUE ) { return APN_USB_ERR_OPEN; // Failure to open device } return APN_USB_SUCCESS; // Success } APN_USB_TYPE ApnUsbClose( void ) { if ( (g_hSysDriver != INVALID_HANDLE_VALUE ) && (g_hSysDriver != 0) ) { ::close( g_hSysDriver ); g_hSysDriver = 0; } return APN_USB_SUCCESS; // Success } APN_USB_TYPE ApnUsbDiscovery( unsigned short *UsbCamCount, APN_USB_CAMINFO UsbCamInfo[] ) { HANDLE hDriver; char deviceName[64]; unsigned short RegNumber; unsigned short retval; struct apIOparam request; USHORT RegData; *UsbCamCount = 0; for ( int i=0; i #include #include ///////////////////////////////////////////////////////////// // Construction/Destruction ///////////////////////////////////////////////////////////// CApnCamData_KAF0261E::CApnCamData_KAF0261E() { } CApnCamData_KAF0261E::~CApnCamData_KAF0261E() { } void CApnCamData_KAF0261E::Initialize() { strcpy( m_Sensor, "KAF0261E" ); strcpy( m_CameraModel, "260" ); m_CameraId = 2; m_InterlineCCD = false; m_SupportsSerialA = true; m_SupportsSerialB = true; m_SensorTypeCCD = true; m_TotalColumns = 530; m_ImagingColumns = 512; m_ClampColumns = 8; m_PreRoiSkipColumns = 0; m_PostRoiSkipColumns = 0; m_OverscanColumns = 10; m_TotalRows = 520; m_ImagingRows = 512; m_UnderscanRows = 4; m_OverscanRows = 4; m_VFlushBinning = 1; m_EnableSingleRowOffset = false; m_RowOffsetBinning = 1; m_HFlushDisable = false; m_ShutterCloseDelay = 20; m_PixelSizeX = 20; m_PixelSizeY = 20; m_Color = false; m_ReportedGainSixteenBit = 3; m_MinSuggestedExpTime = 10.0; m_CoolingSupported = true; m_RegulatedCoolingSupported = true; m_TempSetPoint = -20.0; m_TempRampRateOne = 700; m_TempRampRateTwo = 4000; m_TempBackoffPoint = 2.0; m_PrimaryADType = ApnAdType_Alta_Sixteen; m_AlternativeADType = ApnAdType_Alta_Twelve; m_DefaultGainLeft = 0; m_DefaultOffsetLeft = 250; m_DefaultGainRight = -1; m_DefaultOffsetRight = -1; m_DefaultRVoltage = 1000; m_DefaultSpeed = 0xffff; m_DefaultDataReduction = false; set_vpattern(); set_hpattern_clamp_sixteen(); set_hpattern_skip_sixteen(); set_hpattern_roi_sixteen(); set_hpattern_clamp_twelve(); set_hpattern_skip_twelve(); set_hpattern_roi_twelve(); } void CApnCamData_KAF0261E::set_vpattern() { const unsigned short Mask = 0x0; const unsigned short NumElements = 71; unsigned short Pattern[NumElements] = { 0x0000, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0001, 0x0000 }; m_VerticalPattern.Mask = Mask; m_VerticalPattern.NumElements = NumElements; m_VerticalPattern.PatternData = (unsigned short *)malloc(NumElements * sizeof(unsigned short)); for ( int i=0; iMask = Mask; Pattern->BinningLimit = BinningLimit; Pattern->RefNumElements = RefNumElements; Pattern->SigNumElements = SigNumElements; if ( RefNumElements > 0 ) { Pattern->RefPatternData = (unsigned short *)malloc(RefNumElements * sizeof(unsigned short)); for ( i=0; iRefPatternData[i] = RefPatternData[i]; } } if ( SigNumElements > 0 ) { Pattern->SigPatternData = (unsigned short *)malloc(SigNumElements * sizeof(unsigned short)); for ( i=0; iSigPatternData[i] = SigPatternData[i]; } } if ( BinningLimit > 0 ) { for ( i=0; iBinNumElements[i] = BinNumElements[i]; Pattern->BinPatternData[i] = (unsigned short *)malloc(BinNumElements[i] * sizeof(unsigned short)); for ( j=0; jBinPatternData[i][j] = BinPatternData[i][j]; } } } } libapogee2-2.2/ApnCamData_ASCENT16000.cpp0000644000175000017500000002221711110507150015252 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_ASCENT16000.cpp: Implementation file for the CApnCamData_ASCENT16000 class. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #include "ApnCamData_ASCENT16000.h" #include #include #include ///////////////////////////////////////////////////////////// // Construction/Destruction ///////////////////////////////////////////////////////////// CApnCamData_ASCENT16000::CApnCamData_ASCENT16000() { } CApnCamData_ASCENT16000::~CApnCamData_ASCENT16000() { } void CApnCamData_ASCENT16000::Initialize() { strcpy( m_Sensor, "ASCENT16000" ); strcpy( m_CameraModel, "16000" ); m_CameraId = 320; m_InterlineCCD = true; m_SupportsSerialA = false; m_SupportsSerialB = false; m_SensorTypeCCD = true; m_TotalColumns = 4942; m_ImagingColumns = 4872; m_ClampColumns = 35; m_PreRoiSkipColumns = 0; m_PostRoiSkipColumns = 0; m_OverscanColumns = 35; m_TotalRows = 3324; m_ImagingRows = 3248; m_UnderscanRows = 56; m_OverscanRows = 20; m_VFlushBinning = 10; m_EnableSingleRowOffset = false; m_RowOffsetBinning = 1; m_HFlushDisable = false; m_ShutterCloseDelay = 0; m_PixelSizeX = 7.4; m_PixelSizeY = 7.4; m_Color = false; m_ReportedGainSixteenBit = 0.8; m_MinSuggestedExpTime = 0.1; m_CoolingSupported = true; m_RegulatedCoolingSupported = true; m_TempSetPoint = -20.0; m_TempRampRateOne = 1200; m_TempRampRateTwo = 4000; m_TempBackoffPoint = 2.0; m_PrimaryADType = ApnAdType_Ascent_Sixteen; m_AlternativeADType = ApnAdType_None; m_DefaultGainLeft = 0; m_DefaultOffsetLeft = 100; m_DefaultGainRight = 0; m_DefaultOffsetRight = 100; m_DefaultRVoltage = 1000; m_DefaultSpeed = 0x1; m_DefaultDataReduction = true; set_vpattern(); set_hpattern_clamp_sixteen(); set_hpattern_skip_sixteen(); set_hpattern_roi_sixteen(); set_hpattern_clamp_twelve(); set_hpattern_skip_twelve(); set_hpattern_roi_twelve(); } void CApnCamData_ASCENT16000::set_vpattern() { const unsigned short Mask = 0x6; const unsigned short NumElements = 71; unsigned short Pattern[NumElements] = { 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0202, 0x0202, 0x0202, 0x0202, 0x0202, 0x0202, 0x0202, 0x0202, 0x0202, 0x0202, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0003, 0x0002 }; m_VerticalPattern.Mask = Mask; m_VerticalPattern.NumElements = NumElements; m_VerticalPattern.PatternData = (unsigned short *)malloc(NumElements * sizeof(unsigned short)); for ( int i=0; iMask = Mask; Pattern->BinningLimit = BinningLimit; Pattern->RefNumElements = RefNumElements; Pattern->SigNumElements = SigNumElements; if ( RefNumElements > 0 ) { Pattern->RefPatternData = (unsigned short *)malloc(RefNumElements * sizeof(unsigned short)); for ( i=0; iRefPatternData[i] = RefPatternData[i]; } } if ( SigNumElements > 0 ) { Pattern->SigPatternData = (unsigned short *)malloc(SigNumElements * sizeof(unsigned short)); for ( i=0; iSigPatternData[i] = SigPatternData[i]; } } if ( BinningLimit > 0 ) { for ( i=0; iBinNumElements[i] = BinNumElements[i]; Pattern->BinPatternData[i] = (unsigned short *)malloc(BinNumElements[i] * sizeof(unsigned short)); for ( j=0; jBinPatternData[i][j] = BinPatternData[i][j]; } } } } libapogee2-2.2/ApnCamData_KAI11000C.h0000644000175000017500000000221711110507150014442 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_KAI11000C.h: Interface file for the CApnCamData_KAI11000C class. // // Copyright (c) 2003, 2004 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #if _MSC_VER > 1000 #pragma once #endif // _MSC_VER> 1000 #include "ApnCamData.h" class CApnCamData_KAI11000C : public CApnCamData { public: CApnCamData_KAI11000C(); virtual ~CApnCamData_KAI11000C(); void Initialize(); private: void set_vpattern(); void set_hpattern_clamp_sixteen(); void set_hpattern_skip_sixteen(); void set_hpattern_roi_sixteen(); void set_hpattern_clamp_twelve(); void set_hpattern_skip_twelve(); void set_hpattern_roi_twelve(); void set_hpattern( APN_HPATTERN_FILE *Pattern, unsigned short Mask, unsigned short BinningLimit, unsigned short RefNumElements, unsigned short SigNumElements, unsigned short BinNumElements[], unsigned short RefPatternData[], unsigned short SigPatternData[], unsigned short BinPatternData[][APN_MAX_PATTERN_ENTRIES] ); }; libapogee2-2.2/ApnCamData_KAF6303E.cpp0000644000175000017500000006135211110507147014741 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_KAF6303E.cpp: Implementation file for the CApnCamData_KAF6303E class. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #include "ApnCamData_KAF6303E.h" #include #include #include ///////////////////////////////////////////////////////////// // Construction/Destruction ///////////////////////////////////////////////////////////// CApnCamData_KAF6303E::CApnCamData_KAF6303E() { } CApnCamData_KAF6303E::~CApnCamData_KAF6303E() { } void CApnCamData_KAF6303E::Initialize() { strcpy( m_Sensor, "KAF6303E" ); strcpy( m_CameraModel, "9" ); m_CameraId = 8; m_InterlineCCD = false; m_SupportsSerialA = true; m_SupportsSerialB = true; m_SensorTypeCCD = true; m_TotalColumns = 3100; m_ImagingColumns = 3073; m_ClampColumns = 15; m_PreRoiSkipColumns = 0; m_PostRoiSkipColumns = 0; m_OverscanColumns = 12; m_TotalRows = 2056; m_ImagingRows = 2048; m_UnderscanRows = 4; m_OverscanRows = 4; m_VFlushBinning = 1; m_EnableSingleRowOffset = false; m_RowOffsetBinning = 1; m_HFlushDisable = false; m_ShutterCloseDelay = 300; m_PixelSizeX = 9; m_PixelSizeY = 9; m_Color = false; m_ReportedGainSixteenBit = 1.5; m_MinSuggestedExpTime = 20.0; m_CoolingSupported = true; m_RegulatedCoolingSupported = true; m_TempSetPoint = -20.0; m_TempRampRateOne = 700; m_TempRampRateTwo = 4000; m_TempBackoffPoint = 2.0; m_PrimaryADType = ApnAdType_Alta_Sixteen; m_AlternativeADType = ApnAdType_Alta_Twelve; m_DefaultGainLeft = 0; m_DefaultOffsetLeft = 100; m_DefaultGainRight = -1; m_DefaultOffsetRight = -1; m_DefaultRVoltage = 1000; m_DefaultSpeed = 0xffff; m_DefaultDataReduction = false; set_vpattern(); set_hpattern_clamp_sixteen(); set_hpattern_skip_sixteen(); set_hpattern_roi_sixteen(); set_hpattern_clamp_twelve(); set_hpattern_skip_twelve(); set_hpattern_roi_twelve(); } void CApnCamData_KAF6303E::set_vpattern() { const unsigned short Mask = 0x0; const unsigned short NumElements = 71; unsigned short Pattern[NumElements] = { 0x0000, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0001, 0x0000 }; m_VerticalPattern.Mask = Mask; m_VerticalPattern.NumElements = NumElements; m_VerticalPattern.PatternData = (unsigned short *)malloc(NumElements * sizeof(unsigned short)); for ( int i=0; iMask = Mask; Pattern->BinningLimit = BinningLimit; Pattern->RefNumElements = RefNumElements; Pattern->SigNumElements = SigNumElements; if ( RefNumElements > 0 ) { Pattern->RefPatternData = (unsigned short *)malloc(RefNumElements * sizeof(unsigned short)); for ( i=0; iRefPatternData[i] = RefPatternData[i]; } } if ( SigNumElements > 0 ) { Pattern->SigPatternData = (unsigned short *)malloc(SigNumElements * sizeof(unsigned short)); for ( i=0; iSigPatternData[i] = SigPatternData[i]; } } if ( BinningLimit > 0 ) { for ( i=0; iBinNumElements[i] = BinNumElements[i]; Pattern->BinPatternData[i] = (unsigned short *)malloc(BinNumElements[i] * sizeof(unsigned short)); for ( j=0; jBinPatternData[i][j] = BinPatternData[i][j]; } } } } libapogee2-2.2/ApnCamData_KAF1301E.h0000644000175000017500000000220111110507150014355 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_KAF1301E.h: Interface file for the CApnCamData_KAF1301E class. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #if _MSC_VER > 1000 #pragma once #endif // _MSC_VER> 1000 #include "ApnCamData.h" class CApnCamData_KAF1301E : public CApnCamData { public: CApnCamData_KAF1301E(); virtual ~CApnCamData_KAF1301E(); void Initialize(); private: void set_vpattern(); void set_hpattern_clamp_sixteen(); void set_hpattern_skip_sixteen(); void set_hpattern_roi_sixteen(); void set_hpattern_clamp_twelve(); void set_hpattern_skip_twelve(); void set_hpattern_roi_twelve(); void set_hpattern( APN_HPATTERN_FILE *Pattern, unsigned short Mask, unsigned short BinningLimit, unsigned short RefNumElements, unsigned short SigNumElements, unsigned short BinNumElements[], unsigned short RefPatternData[], unsigned short SigPatternData[], unsigned short BinPatternData[][APN_MAX_PATTERN_ENTRIES] ); }; libapogee2-2.2/ApnCamData_TH7899.h0000644000175000017500000000216711110507150014231 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_TH7899.h: Interface file for the CApnCamData_TH7899 class. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #if _MSC_VER > 1000 #pragma once #endif // _MSC_VER> 1000 #include "ApnCamData.h" class CApnCamData_TH7899 : public CApnCamData { public: CApnCamData_TH7899(); virtual ~CApnCamData_TH7899(); void Initialize(); private: void set_vpattern(); void set_hpattern_clamp_sixteen(); void set_hpattern_skip_sixteen(); void set_hpattern_roi_sixteen(); void set_hpattern_clamp_twelve(); void set_hpattern_skip_twelve(); void set_hpattern_roi_twelve(); void set_hpattern( APN_HPATTERN_FILE *Pattern, unsigned short Mask, unsigned short BinningLimit, unsigned short RefNumElements, unsigned short SigNumElements, unsigned short BinNumElements[], unsigned short RefPatternData[], unsigned short SigPatternData[], unsigned short BinPatternData[][APN_MAX_PATTERN_ENTRIES] ); }; libapogee2-2.2/ApnCamData_KAI2020MLB.cpp0000644000175000017500000005456211110507150015161 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_KAI2020MLB.cpp: Implementation file for the CApnCamData_KAI2020MLB class. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #include "ApnCamData_KAI2020MLB.h" #include #include #include ///////////////////////////////////////////////////////////// // Construction/Destruction ///////////////////////////////////////////////////////////// CApnCamData_KAI2020MLB::CApnCamData_KAI2020MLB() { } CApnCamData_KAI2020MLB::~CApnCamData_KAI2020MLB() { } void CApnCamData_KAI2020MLB::Initialize() { strcpy( m_Sensor, "KAI2020MLB" ); strcpy( m_CameraModel, "2020ml" ); m_CameraId = 72; m_InterlineCCD = true; m_SupportsSerialA = true; m_SupportsSerialB = true; m_SensorTypeCCD = true; m_TotalColumns = 1648; m_ImagingColumns = 1600; m_ClampColumns = 24; m_PreRoiSkipColumns = 0; m_PostRoiSkipColumns = 0; m_OverscanColumns = 24; m_TotalRows = 1214; m_ImagingRows = 1200; m_UnderscanRows = 6; m_OverscanRows = 8; m_VFlushBinning = 1; m_EnableSingleRowOffset = false; m_RowOffsetBinning = 1; m_HFlushDisable = false; m_ShutterCloseDelay = 0; m_PixelSizeX = 7.4; m_PixelSizeY = 7.4; m_Color = false; m_ReportedGainSixteenBit = 1; m_MinSuggestedExpTime = 0.05; m_CoolingSupported = true; m_RegulatedCoolingSupported = true; m_TempSetPoint = -20.0; m_TempRampRateOne = 700; m_TempRampRateTwo = 4000; m_TempBackoffPoint = 2.0; m_PrimaryADType = ApnAdType_Alta_Sixteen; m_AlternativeADType = ApnAdType_Alta_Twelve; m_DefaultGainLeft = 0; m_DefaultOffsetLeft = 100; m_DefaultGainRight = -1; m_DefaultOffsetRight = -1; m_DefaultRVoltage = 1000; m_DefaultSpeed = 0xffff; m_DefaultDataReduction = false; set_vpattern(); set_hpattern_clamp_sixteen(); set_hpattern_skip_sixteen(); set_hpattern_roi_sixteen(); set_hpattern_clamp_twelve(); set_hpattern_skip_twelve(); set_hpattern_roi_twelve(); } void CApnCamData_KAI2020MLB::set_vpattern() { const unsigned short Mask = 0x16; const unsigned short NumElements = 38; unsigned short Pattern[NumElements] = { 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0302, 0x0302, 0x0302, 0x0302, 0x0302, 0x0302, 0x0302, 0x0302, 0x0302, 0x0302, 0x0002, 0x0002, 0x0002, 0x0003, 0x0002 }; m_VerticalPattern.Mask = Mask; m_VerticalPattern.NumElements = NumElements; m_VerticalPattern.PatternData = (unsigned short *)malloc(NumElements * sizeof(unsigned short)); for ( int i=0; iMask = Mask; Pattern->BinningLimit = BinningLimit; Pattern->RefNumElements = RefNumElements; Pattern->SigNumElements = SigNumElements; if ( RefNumElements > 0 ) { Pattern->RefPatternData = (unsigned short *)malloc(RefNumElements * sizeof(unsigned short)); for ( i=0; iRefPatternData[i] = RefPatternData[i]; } } if ( SigNumElements > 0 ) { Pattern->SigPatternData = (unsigned short *)malloc(SigNumElements * sizeof(unsigned short)); for ( i=0; iSigPatternData[i] = SigPatternData[i]; } } if ( BinningLimit > 0 ) { for ( i=0; iBinNumElements[i] = BinNumElements[i]; Pattern->BinPatternData[i] = (unsigned short *)malloc(BinNumElements[i] * sizeof(unsigned short)); for ( j=0; jBinPatternData[i][j] = BinPatternData[i][j]; } } } } libapogee2-2.2/ApnSerial.h0000644000175000017500000000277611110507150013230 0ustar jrjr// ApnSerial.h: interface for the CApnSerial class. // ////////////////////////////////////////////////////////////////////// #if !defined(AFX_APNSERIAL_H__A27F1749_FA8F_40E8_A03F_4A28C8378DD1__INCLUDED_) #define AFX_APNSERIAL_H__A27F1749_FA8F_40E8_A03F_4A28C8378DD1__INCLUDED_ #if _MSC_VER > 1000 #pragma once #endif // _MSC_VER > 1000 #include "Apogee.h" class CApnSerial { public: CApnSerial(); ~CApnSerial(); bool InitPort( unsigned long CamIdA, unsigned short CamIdB, unsigned short SerialId ); bool ClosePort(); bool GetBaudRate( unsigned long *BaudRate ); bool SetBaudRate( unsigned long BaudRate ); bool GetFlowControl( Apn_SerialFlowControl *FlowControl ); bool SetFlowControl( Apn_SerialFlowControl FlowControl ); bool GetParity( Apn_SerialParity *Parity ); bool SetParity( Apn_SerialParity Parity ); bool Read( int SerialSock, char *ReadBuffer, unsigned short *ReadCount ); bool Write( int SerialSock, char *WriteBuffer, unsigned short WriteCount ); char *ReadBuffer(void); // Variables Apn_Interface m_CameraInterface; int m_ConnectionOpen; char m_SysDeviceName[80]; int m_SerialId; short m_BytesRead; long m_hSession; int m_SerialSocket; char m_HostAddr[80]; unsigned short m_PortNum; char m_SerialBuffer[4096]; }; #endif // !defined(AFX_APNSERIAL_H__A27F1749_FA8F_40E8_A03F_4A28C8378DD1__INCLUDED_) libapogee2-2.2/ApnCamData_KAF09000.cpp0000644000175000017500000006151711110507150014706 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_KAF09000.cpp: Implementation file for the CApnCamData_KAF09000 class. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #include "ApnCamData_KAF09000.h" #include #include #include ///////////////////////////////////////////////////////////// // Construction/Destruction ///////////////////////////////////////////////////////////// CApnCamData_KAF09000::CApnCamData_KAF09000() { } CApnCamData_KAF09000::~CApnCamData_KAF09000() { } void CApnCamData_KAF09000::Initialize() { strcpy( m_Sensor, "KAF09000" ); strcpy( m_CameraModel, "9000" ); m_CameraId = 4; m_InterlineCCD = false; m_SupportsSerialA = true; m_SupportsSerialB = true; m_SensorTypeCCD = true; m_TotalColumns = 3103; m_ImagingColumns = 3056; m_ClampColumns = 35; m_PreRoiSkipColumns = 0; m_PostRoiSkipColumns = 0; m_OverscanColumns = 12; m_TotalRows = 3086; m_ImagingRows = 3056; m_UnderscanRows = 20; m_OverscanRows = 10; m_VFlushBinning = 1; m_EnableSingleRowOffset = false; m_RowOffsetBinning = 1; m_HFlushDisable = false; m_ShutterCloseDelay = 300; m_PixelSizeX = 12; m_PixelSizeY = 12; m_Color = false; m_ReportedGainSixteenBit = 1.5; m_MinSuggestedExpTime = 30.0; m_CoolingSupported = true; m_RegulatedCoolingSupported = true; m_TempSetPoint = -20.0; m_TempRampRateOne = 1500; m_TempRampRateTwo = 4000; m_TempBackoffPoint = 2.0; m_PrimaryADType = ApnAdType_Alta_Sixteen; m_AlternativeADType = ApnAdType_Alta_Twelve; m_DefaultGainLeft = 0; m_DefaultOffsetLeft = 150; m_DefaultGainRight = -1; m_DefaultOffsetRight = -1; m_DefaultRVoltage = 1000; m_DefaultSpeed = 0xffff; m_DefaultDataReduction = false; set_vpattern(); set_hpattern_clamp_sixteen(); set_hpattern_skip_sixteen(); set_hpattern_roi_sixteen(); set_hpattern_clamp_twelve(); set_hpattern_skip_twelve(); set_hpattern_roi_twelve(); } void CApnCamData_KAF09000::set_vpattern() { const unsigned short Mask = 0x0; const unsigned short NumElements = 116; unsigned short Pattern[NumElements] = { 0x0000, 0x0000, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0202, 0x0202, 0x0202, 0x0202, 0x0202, 0x0202, 0x0202, 0x0202, 0x0202, 0x0202, 0x0002, 0x0002, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0001, 0x0000 }; m_VerticalPattern.Mask = Mask; m_VerticalPattern.NumElements = NumElements; m_VerticalPattern.PatternData = (unsigned short *)malloc(NumElements * sizeof(unsigned short)); for ( int i=0; iMask = Mask; Pattern->BinningLimit = BinningLimit; Pattern->RefNumElements = RefNumElements; Pattern->SigNumElements = SigNumElements; if ( RefNumElements > 0 ) { Pattern->RefPatternData = (unsigned short *)malloc(RefNumElements * sizeof(unsigned short)); for ( i=0; iRefPatternData[i] = RefPatternData[i]; } } if ( SigNumElements > 0 ) { Pattern->SigPatternData = (unsigned short *)malloc(SigNumElements * sizeof(unsigned short)); for ( i=0; iSigPatternData[i] = SigPatternData[i]; } } if ( BinningLimit > 0 ) { for ( i=0; iBinNumElements[i] = BinNumElements[i]; Pattern->BinPatternData[i] = (unsigned short *)malloc(BinNumElements[i] * sizeof(unsigned short)); for ( j=0; jBinPatternData[i][j] = BinPatternData[i][j]; } } } } libapogee2-2.2/ApnCamData_CCD3011.cpp0000644000175000017500000004410311110507150014602 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_CCD3011.cpp: Implementation file for the CApnCamData_CCD3011 class. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #include "ApnCamData_CCD3011.h" #include #include #include ///////////////////////////////////////////////////////////// // Construction/Destruction ///////////////////////////////////////////////////////////// CApnCamData_CCD3011::CApnCamData_CCD3011() { } CApnCamData_CCD3011::~CApnCamData_CCD3011() { } void CApnCamData_CCD3011::Initialize() { strcpy( m_Sensor, "CCD3011" ); strcpy( m_CameraModel, "30" ); m_CameraId = 20; m_InterlineCCD = false; m_SupportsSerialA = true; m_SupportsSerialB = true; m_SensorTypeCCD = true; m_TotalColumns = 1040; m_ImagingColumns = 1024; m_ClampColumns = 8; m_PreRoiSkipColumns = 0; m_PostRoiSkipColumns = 0; m_OverscanColumns = 8; m_TotalRows = 256; m_ImagingRows = 256; m_UnderscanRows = 0; m_OverscanRows = 0; m_VFlushBinning = 1; m_EnableSingleRowOffset = false; m_RowOffsetBinning = 1; m_HFlushDisable = false; m_ShutterCloseDelay = 300; m_PixelSizeX = 26; m_PixelSizeY = 26; m_Color = false; m_ReportedGainSixteenBit = 2; m_MinSuggestedExpTime = 20.0; m_CoolingSupported = true; m_RegulatedCoolingSupported = true; m_TempSetPoint = -20.0; m_TempRampRateOne = 700; m_TempRampRateTwo = 4000; m_TempBackoffPoint = 2.0; m_PrimaryADType = ApnAdType_Alta_Sixteen; m_AlternativeADType = ApnAdType_Alta_Twelve; m_DefaultGainLeft = 400; m_DefaultOffsetLeft = 200; m_DefaultGainRight = -1; m_DefaultOffsetRight = -1; m_DefaultRVoltage = 1000; m_DefaultSpeed = 0xffff; m_DefaultDataReduction = false; set_vpattern(); set_hpattern_clamp_sixteen(); set_hpattern_skip_sixteen(); set_hpattern_roi_sixteen(); set_hpattern_clamp_twelve(); set_hpattern_skip_twelve(); set_hpattern_roi_twelve(); } void CApnCamData_CCD3011::set_vpattern() { const unsigned short Mask = 0x0; const unsigned short NumElements = 253; unsigned short Pattern[NumElements] = { 0x0000, 0x0000, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x000A, 0x000A, 0x000A, 0x000A, 0x000A, 0x000A, 0x000A, 0x000A, 0x000A, 0x000A, 0x000A, 0x000A, 0x000A, 0x000A, 0x000A, 0x000A, 0x000A, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0000, 0x0000, 0x0000, 0x0001, 0x0000 }; m_VerticalPattern.Mask = Mask; m_VerticalPattern.NumElements = NumElements; m_VerticalPattern.PatternData = (unsigned short *)malloc(NumElements * sizeof(unsigned short)); for ( int i=0; iMask = Mask; Pattern->BinningLimit = BinningLimit; Pattern->RefNumElements = RefNumElements; Pattern->SigNumElements = SigNumElements; if ( RefNumElements > 0 ) { Pattern->RefPatternData = (unsigned short *)malloc(RefNumElements * sizeof(unsigned short)); for ( i=0; iRefPatternData[i] = RefPatternData[i]; } } if ( SigNumElements > 0 ) { Pattern->SigPatternData = (unsigned short *)malloc(SigNumElements * sizeof(unsigned short)); for ( i=0; iSigPatternData[i] = SigPatternData[i]; } } if ( BinningLimit > 0 ) { for ( i=0; iBinNumElements[i] = BinNumElements[i]; Pattern->BinPatternData[i] = (unsigned short *)malloc(BinNumElements[i] * sizeof(unsigned short)); for ( j=0; jBinPatternData[i][j] = BinPatternData[i][j]; } } } } libapogee2-2.2/ApnCamData_KAI2001ML.h0000644000175000017500000000220611110507150014507 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_KAI2001ML.h: Interface file for the CApnCamData_KAI2001ML class. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #if _MSC_VER > 1000 #pragma once #endif // _MSC_VER> 1000 #include "ApnCamData.h" class CApnCamData_KAI2001ML : public CApnCamData { public: CApnCamData_KAI2001ML(); virtual ~CApnCamData_KAI2001ML(); void Initialize(); private: void set_vpattern(); void set_hpattern_clamp_sixteen(); void set_hpattern_skip_sixteen(); void set_hpattern_roi_sixteen(); void set_hpattern_clamp_twelve(); void set_hpattern_skip_twelve(); void set_hpattern_roi_twelve(); void set_hpattern( APN_HPATTERN_FILE *Pattern, unsigned short Mask, unsigned short BinningLimit, unsigned short RefNumElements, unsigned short SigNumElements, unsigned short BinNumElements[], unsigned short RefPatternData[], unsigned short SigPatternData[], unsigned short BinPatternData[][APN_MAX_PATTERN_ENTRIES] ); }; libapogee2-2.2/ApnCamData_KAF1602EB.h0000644000175000017500000000220611110507150014470 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_KAF1602EB.h: Interface file for the CApnCamData_KAF1602EB class. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #if _MSC_VER > 1000 #pragma once #endif // _MSC_VER> 1000 #include "ApnCamData.h" class CApnCamData_KAF1602EB : public CApnCamData { public: CApnCamData_KAF1602EB(); virtual ~CApnCamData_KAF1602EB(); void Initialize(); private: void set_vpattern(); void set_hpattern_clamp_sixteen(); void set_hpattern_skip_sixteen(); void set_hpattern_roi_sixteen(); void set_hpattern_clamp_twelve(); void set_hpattern_skip_twelve(); void set_hpattern_roi_twelve(); void set_hpattern( APN_HPATTERN_FILE *Pattern, unsigned short Mask, unsigned short BinningLimit, unsigned short RefNumElements, unsigned short SigNumElements, unsigned short BinNumElements[], unsigned short RefPatternData[], unsigned short SigPatternData[], unsigned short BinPatternData[][APN_MAX_PATTERN_ENTRIES] ); }; libapogee2-2.2/ApnCamData.cpp0000644000175000017500000000622011110507150013622 0ustar jrjr////////////////////////////////////////////////////////////////////// // // ApnCamData.cpp: Implementation of the CApnCamData class. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ////////////////////////////////////////////////////////////////////// #include "stdafx.h" #include "ApnCamData.h" #include #include ////////////////////////////////////////////////////////////////////// // Construction/Destruction ////////////////////////////////////////////////////////////////////// CApnCamData::CApnCamData() { init_vpattern(); init_hpattern( &m_ClampPatternSixteen ); init_hpattern( &m_SkipPatternSixteen ); init_hpattern( &m_RoiPatternSixteen ); init_hpattern( &m_ClampPatternTwelve ); init_hpattern( &m_SkipPatternTwelve ); init_hpattern( &m_RoiPatternTwelve ); } CApnCamData::~CApnCamData() { clear_vpattern(); clear_hpattern( &m_ClampPatternSixteen ); clear_hpattern( &m_SkipPatternSixteen ); clear_hpattern( &m_RoiPatternSixteen ); clear_hpattern( &m_ClampPatternTwelve ); clear_hpattern( &m_SkipPatternTwelve ); clear_hpattern( &m_RoiPatternTwelve ); } void CApnCamData::init_vpattern( ) { // OutputDebugString( "init_vpattern()" ); m_VerticalPattern.Mask = 0x0; m_VerticalPattern.NumElements = 0; m_VerticalPattern.PatternData = NULL; } void CApnCamData::clear_vpattern( ) { // OutputDebugString( "clear_vpattern()" ); m_VerticalPattern.Mask = 0x0; m_VerticalPattern.NumElements = 0; if ( m_VerticalPattern.PatternData != NULL ) { free( m_VerticalPattern.PatternData ); m_VerticalPattern.PatternData = NULL; } } void CApnCamData::init_hpattern( APN_HPATTERN_FILE *Pattern ) { int Counter; // OutputDebugString( "init_hpattern()" ); Pattern->Mask = 0x0; Pattern->RefNumElements = 0; Pattern->SigNumElements = 0; Pattern->BinningLimit = 0; Pattern->RefPatternData = NULL; Pattern->SigPatternData = NULL; for ( Counter=0; CounterBinNumElements[Counter] = 0; Pattern->BinPatternData[Counter] = NULL; } } void CApnCamData::clear_hpattern( APN_HPATTERN_FILE *Pattern ) { int Counter; // char szMsg[80]; // OutputDebugString( "clear_hpattern()" ); Pattern->Mask = 0x0; Pattern->RefNumElements = 0; Pattern->SigNumElements = 0; Pattern->BinningLimit = 0; if ( Pattern->RefPatternData != NULL ) { // OutputDebugString( "Freeing Allocated Reference Pattern Memory" ); free( Pattern->RefPatternData ); Pattern->RefPatternData = NULL; } if ( Pattern->SigPatternData != NULL ) { // OutputDebugString( "Freeing Allocated Signal Pattern Memory" ); free( Pattern->SigPatternData ); Pattern->SigPatternData = NULL; } for ( Counter=0; CounterBinNumElements[Counter] = 0; if ( Pattern->BinPatternData[Counter] != NULL ) { // sprintf( szMsg, "Freeing Allocated Binning Pattern Memory (Binning = %d)", Counter+1 ); // OutputDebugString( szMsg ); free( Pattern->BinPatternData[Counter] ); Pattern->BinPatternData[Counter] = NULL; } } } libapogee2-2.2/ApogeeNet/0000755000175000017500000000000011110507150013034 5ustar jrjrlibapogee2-2.2/ApogeeNet/ApogeeNet.h0000644000175000017500000001451511110507150015062 0ustar jrjr#if !defined(_APOGEENET_H__INCLUDED_) #define _APOGEENET_H__INCLUDED_ #if _MSC_VER > 1000 #pragma once #endif // _MSC_VER > 1000 #define WIN32_LEAN_AND_MEAN // Exclude rarely-used stuff from Windows headers #include #include #include #ifndef LINUX #include #include #endif #include "Apogee.h" #define HINTERNET int #define SOCKET int #ifndef APN_NET_TYPE #define APN_NET_TYPE unsigned short #endif #ifndef IN #define IN #endif #ifndef OUT #define OUT #endif #define ApnNetParity_None 0 #define ApnNetParity_Odd 1 #define ApnNetParity_Even 2 #define APOGEE_IP_PORT_NUMBER 2571 #define MAX_FILENAME_LENGTH 256 #define MAX_REG_NUMBER 80 #define MAX_WRITE_VAL 0xFFFF #define OPS_PER_BATCH 16 #define OUTPUT_PATH "results.txt" #define APOGEE_USERNAME "admin" #define APOGEE_USERNAME_LENGTH 5 #define APOGEE_PASSWORD "configure" #define APOGEE_PASSWORD_LENGTH 9 #define HTTP_PREAMBLE "http://" #define FPGA_DEFERRED_ACCESS "/FPGADPC?" #define FPGA_ACCESS "/FPGA?" #define FPGA_FW_UPLOAD "Load" #define FPGA_FW_CLEAR "InitStart" #define MAC_ADDRESS_READ "/NVRAM?Tag=10&Length=6&Get" #define MAC_ADDRESS_LENGTH 6 #define SERIAL_GET_IP_PORT "/SERCFG?GetIpPort=" #define SERIAL_GET_BAUD_RATE "/SERCFG?GetBitRate=" #define SERIAL_SET_BAUD_RATE "/SERCFG?SetBitRate=" #define SERIAL_GET_FLOW_CONTROL "/SERCFG?GetFlowControl=" #define SERIAL_SET_FLOW_CONTROL "/SERCFG?SetFlowControl=" #define SERIAL_GET_PARITY "/SERCFG?GetParityBits=" #define SERIAL_SET_PARITY "/SERCFG?SetParityBits=" #define SERIAL_PORT_A "A" #define SERIAL_PORT_B "B" #define SERIAL_BAUD_RATE_1200 1200 #define SERIAL_BAUD_RATE_2400 2400 #define SERIAL_BAUD_RATE_4800 4800 #define SERIAL_BAUD_RATE_9600 9600 #define SERIAL_BAUD_RATE_19200 19200 #define SERIAL_BAUD_RATE_38400 38400 #define SERIAL_BAUD_RATE_57600 57600 #define SERIAL_BAUD_RATE_115200 115200 #define SERIAL_PARITY_NONE "N" #define SERIAL_PARITY_ODD "O" #define SERIAL_PARITY_EVEN "E" #define SERIAL_FLOW_CONTROL_NONE "N" #define SERIAL_FLOW_CONTROL_SW "S" #define REBOOT_CMD "/REBOOT?Submit=Reboot" #define SESSION_OPEN "/SESSION?Open" #define SESSION_CLOSE "/SESSION?Close" #define WRITE_REG "WR=" #define WRITE_DATA "WD=" #define READ_REG "RR=" #define APN_UPLOAD_FILE_NAME "ApnFile.bin" #define APN_MAX_WRITES_PER_URL 40 #define APN_MAX_READS_PER_URL 40 #define APOGEE_BOUNDARY "-----------------------------7270616F4070616F6E65742E6F7267" #define APOGEE_CRLF "\r\n" #define DISCOVERY_TIMEOUT_SECS 10 #define DISCOVERY_MAXLINESIZE 255 #define DISCOVERY_MAXBUFFER (16 * 1024) #define DISCOVERY_TOKEN_LENGTH 40 #define DISCOVERY_TOKEN_ID_LENGTH 60 #define SESSION_OPEN_RETVAL "SessionId=" #define SESSION_CLOSE_RETVAL "SessionId=\"\"\r\n" APN_NET_TYPE ApnNetConnect( char *HostName ); APN_NET_TYPE ApnNetClose( char *HostName ); APN_NET_TYPE ApnNetDiscovery( unsigned long Subnet, unsigned short *CameraCount, char *CameraList ); APN_NET_TYPE ApnNetReboot( char *HostName ); APN_NET_TYPE ApnNetReadReg( char *HostName, short FpgaReg, unsigned short *FpgaData ); APN_NET_TYPE ApnNetWriteReg( char *HostName, short FpgaReg, unsigned short FpgaData ); APN_NET_TYPE ApnNetReadRegMulti( char *HostName, unsigned short FpgaReg[], unsigned short FpgaData[], unsigned short RegCount ); APN_NET_TYPE ApnNetWriteRegMulti( char *HostName, unsigned short FpgaReg, unsigned short FpgaData[], unsigned short RegCount ); APN_NET_TYPE ApnNetWriteRegMultiMRMD( char *HostName, unsigned short FpgaReg[], unsigned short FpgaData[], unsigned short RegCount ); APN_NET_TYPE ApnNetStartExp( char *HostName, unsigned long ImageWidth, unsigned long ImageHeight ); APN_NET_TYPE ApnNetStopExp( char *HostName, bool DigitizeData ); APN_NET_TYPE ApnNetSetSpeed( char *HostName, bool HighSpeed ); APN_NET_TYPE ApnNetGetImageTcp( char *HostName, unsigned long ImageByteCount, unsigned short *pMem ); APN_NET_TYPE ApnNetGetNvramData( char *HostAddr, char *pMem ); APN_NET_TYPE ApnNetGetMacAddress( char *HostAddr, char *pMacAddr ); APN_NET_TYPE ApnNetSerialReadIpPort( char *HostName, unsigned short SerialId, unsigned short *PortNumber ); APN_NET_TYPE ApnNetStartSockets( ); APN_NET_TYPE ApnNetStopSockets( ); APN_NET_TYPE ApnNetSerialPortOpen( SOCKET *SerialSocket, char *HostAddr, unsigned short PortNumber ); APN_NET_TYPE ApnNetSerialPortClose( SOCKET *SerialSocket ); APN_NET_TYPE ApnNetSerialReadBaudRate( char *HostName, unsigned short SerialId, unsigned long *BaudRate ); APN_NET_TYPE ApnNetSerialWriteBaudRate( char *HostName, unsigned short SerialId, unsigned long BaudRate ); APN_NET_TYPE ApnNetSerialReadFlowControl( char *HostName, unsigned short SerialId, bool *FlowControl ); APN_NET_TYPE ApnNetSerialWriteFlowControl( char *HostName, unsigned short SerialId, bool FlowControl ); APN_NET_TYPE ApnNetSerialReadParity( char *HostName, unsigned short SerialId, ApnNetParity *Parity ); APN_NET_TYPE ApnNetSerialWriteParity( char *HostName, unsigned short SerialId, ApnNetParity Parity ); APN_NET_TYPE ApnNetSerialRead( SOCKET *SerialSocket, char *ReadBuffer, unsigned short *BufferCount ); APN_NET_TYPE ApnNetSerialWrite( SOCKET *SerialSocket, char *WriteBuffer, unsigned short BufferCount ); #endif libapogee2-2.2/ApogeeNet/ApogeeNet.cpp.old0000644000175000017500000010736611110507150016201 0ustar jrjr// ApogeeNet.cpp : Library of basic networking functions for Apogee APn/Alta. // // Copyright (c) 2003, 2004 Apogee Instruments, Inc. ////////////////////////////////////////////////////////////////////// #include "ApogeeNet.h" #include "ApogeeNetErr.h" #ifdef LINUX #include "stdafx.h" #include #include #include #include #include #define HINTERNET int #define _snprintf snprintf extern "C" { extern int InternetOpen( char *iname, int itype, int *dum, int *dum2, int dum3); extern int InternetOpenUrl( int g_hSession, char *url, int *dum1, int *dum2, int dum3, int dum4 ); extern void InternetQueryDataAvailable(int handle, long *bcount, int dum1, int dum2); extern void InternetReadFile(int handle, char *lpBuffer, long bcount, long *bread); extern void InternetCloseHandle( int handle ); } #endif // Global variables used in this DLL HINTERNET g_hSession; ULONG g_NetImgSizeBytes; BOOLEAN g_NetImgInProgress; BOOLEAN g_FastDownload; char g_HostAddr[80]; // This is an example of an exported function. APN_NET_TYPE ApnNetConnect( char *HostName ) { DWORD dwBytesAvailable, dwBytesRead; HINTERNET hService; int RetLength; char szUrl[8096]; char *lpBuffer; strcpy( g_HostAddr, HostName ); g_hSession = InternetOpen( "ApogeeNet", INTERNET_OPEN_TYPE_DIRECT, NULL, NULL, 0 ); if ( g_hSession == 0 ) { return APNET_ERR_CONNECT; } sprintf( szUrl, "%s%s%s", HTTP_PREAMBLE, g_HostAddr, SESSION_OPEN ); hService = InternetOpenUrl( g_hSession, szUrl, NULL, 0, 0, 0 ); if ( hService == 0 ) { return APNET_ERR_GENERIC_CGI; // Failure } else { InternetQueryDataAvailable(hService, &dwBytesAvailable, 0, 0); lpBuffer = (char *)malloc(dwBytesAvailable+1); InternetReadFile(hService, lpBuffer, dwBytesAvailable, &dwBytesRead); lpBuffer[dwBytesRead] = 0; RetLength = strlen( SESSION_OPEN_RETVAL ); if ( strncmp( lpBuffer, SESSION_OPEN_RETVAL, RetLength ) != 0 ) { free( lpBuffer ); return APNET_ERR_CONNECT; } free( lpBuffer ); InternetCloseHandle( hService ); } g_NetImgInProgress = FALSE; g_NetImgSizeBytes = 0; return APNET_SUCCESS; } APN_NET_TYPE ApnNetClose( void ) { DWORD dwBytesAvailable, dwBytesRead; HINTERNET hService; char szUrl[8096]; char *lpBuffer; // First make sure we have a valid session already if ( g_hSession == 0) { // Return successful since there is no session open anyway return APNET_SUCCESS; } sprintf( szUrl, "%s%s%s", HTTP_PREAMBLE, g_HostAddr, SESSION_CLOSE ); hService = InternetOpenUrl( g_hSession, szUrl, NULL, 0, 0, 0 ); if ( hService == 0 ) { return APNET_ERR_GENERIC_CGI; // Failure } else { InternetQueryDataAvailable(hService, &dwBytesAvailable, 0, 0); lpBuffer = (char *)malloc(dwBytesAvailable+1); InternetReadFile(hService, lpBuffer, dwBytesAvailable, &dwBytesRead); lpBuffer[dwBytesRead] = 0; if ( strcmp( lpBuffer, SESSION_CLOSE_RETVAL ) != 0 ) { free( lpBuffer ); return APNET_ERR_CLOSE; } free( lpBuffer ); InternetCloseHandle( hService ); } if ( g_NetImgInProgress ) { // Add cleanup code g_NetImgInProgress = FALSE; } g_hSession = 0; return APNET_SUCCESS; } APN_NET_TYPE ApnNetDiscovery( unsigned long Subnet, unsigned short *CameraCount, char *CameraList ) { #ifndef LINUX WSADATA WinSockData; #endif int LineLen, UdpPacketLen; int sd; struct sockaddr_in servaddr; struct in_addr in_val; const int on = 1; char Line[DISCOVERY_MAXLINESIZE + 1]; char pUdpPacket[DISCOVERY_MAXBUFFER + 1]; char szTemp[256]; char* CurCamList; clock_t ct; unsigned long addr; // Initial count of cameras on network should be zero *CameraCount = 0; #ifndef LINUX // Try to start the Windows sockets library if ( WSAStartup(MAKEWORD(1, 0), &WinSockData) != 0 ) { return 1; } #endif memset(&servaddr, 0, sizeof(servaddr)); servaddr.sin_family = AF_INET; servaddr.sin_port = htons( APOGEE_IP_PORT_NUMBER ); servaddr.sin_addr.s_addr = Subnet; sd = socket( AF_INET, SOCK_DGRAM, 0 ); setsockopt( sd, SOL_SOCKET, SO_BROADCAST, (char*) &on, sizeof(on) ); LineLen = _snprintf( Line, DISCOVERY_MAXLINESIZE, "Discovery::Request-Except: \"%s\"; 0x%lX; %ld; %ld; %ld; %ld" APOGEE_CRLF APOGEE_CRLF, "Apogee", 0x12345678, 0, DISCOVERY_TIMEOUT_SECS / 2, 0, 0 ); // Build the header for the message UdpPacketLen = _snprintf( pUdpPacket, DISCOVERY_MAXBUFFER, "MIME-Version: 1.0" APOGEE_CRLF "Content-Type: application/octet-stream" APOGEE_CRLF "Content-Transfer-Encoding: binary" APOGEE_CRLF "Content-Length: 0x%X" APOGEE_CRLF "X-Project: Apogee" APOGEE_CRLF "X-Project-Version: 0.1" APOGEE_CRLF APOGEE_CRLF, LineLen ); memcpy(pUdpPacket + UdpPacketLen, Line, LineLen); UdpPacketLen += LineLen; sendto( sd, pUdpPacket, UdpPacketLen, 0, (struct sockaddr *)&servaddr, sizeof(servaddr) ); // Wait for UDP replies struct timeval tv; fd_set rset; int n; char szResponseToken[DISCOVERY_TOKEN_ID_LENGTH]; char szId[DISCOVERY_TOKEN_LENGTH]; char szTag[DISCOVERY_TOKEN_LENGTH]; char szTime[DISCOVERY_TOKEN_LENGTH]; char szIpAddrToken[DISCOVERY_TOKEN_ID_LENGTH]; char szIpAddr[DISCOVERY_TOKEN_LENGTH]; char szPortToken[DISCOVERY_TOKEN_ID_LENGTH]; char szPort[DISCOVERY_TOKEN_LENGTH]; char szNameToken[DISCOVERY_TOKEN_ID_LENGTH]; char szName[DISCOVERY_TOKEN_LENGTH]; char szCamNumber[DISCOVERY_TOKEN_LENGTH]; ct = clock() + DISCOVERY_TIMEOUT_SECS * CLOCKS_PER_SEC; tv.tv_sec = 0; tv.tv_usec = 0; size_t CurLength; size_t NewLength; while (clock() <= ct) { FD_ZERO( &rset ); FD_SET( sd, &rset ); if ( select( sd + 1, &rset, NULL, NULL, &tv ) > 0 ) { n = recvfrom(sd, pUdpPacket, DISCOVERY_MAXBUFFER, 0, NULL, NULL); // Process the returned packets. pUdpPacket[n] = '\0'; // add a NULL to the close of the string sscanf( pUdpPacket, "%s %s %s %s" "%s %s" "%s %s" "%s", szResponseToken, szId, szTag, szTime, szIpAddrToken, szIpAddr, szPortToken, szPort, szNameToken ); strtok(pUdpPacket, "\""); strtok(NULL, "\""); strtok(NULL, "\""); strcpy(szName, strtok(NULL, "\"")); if ( strcmp("\r\nSessionId=", szName) == 0 ) { strcpy(szName, "Camera Unnamed"); } // Increment number of cameras on network (*CameraCount)++; sprintf( szCamNumber, "%u ", *CameraCount ); sprintf( szTemp, "%u 0x%08X %u ", szCamNumber, szIpAddr, szPort ); // determine string lengths NewLength = strlen( szTemp ); CurLength = strlen( CameraList ); CurCamList = (char*)calloc( CurLength + 1, sizeof(char) ); // copy current string for safe keeping strcpy( CurCamList, CameraList ); // allocate space for combined string CameraList = (char*)calloc( CurLength + NewLength + 1, sizeof(char) ); sprintf( CameraList, "%s%s", CameraList, szTemp ); } } CurLength = strlen( CameraList ); CurCamList = (char*)calloc( CurLength + 1, sizeof(char) ); // copy current string for safe keeping strcpy( CurCamList, CameraList ); // allocate space for combined string CameraList = (char*)calloc( CurLength + sizeof(szCamNumber) + 1, sizeof(char) ); sprintf( CameraList, "%s%s", szCamNumber, CameraList ); #ifndef LINUX // Stop the Windows sockets library WSACleanup(); #endif return APNET_SUCCESS; } APN_NET_TYPE ApnNetReboot( void ) { HINTERNET hService; DWORD dwBytesAvailable, dwBytesRead; char szUrl[8096]; char* lpBuffer; sprintf(szUrl, "%s%s%s", HTTP_PREAMBLE, g_HostAddr, REBOOT_CMD); hService = InternetOpenUrl(g_hSession, szUrl, NULL, 0, 0, 0); if ( hService == 0 ) { return APNET_ERR_GENERIC_CGI; } else { InternetQueryDataAvailable(hService, &dwBytesAvailable, 0, 0); lpBuffer = (char*)malloc(dwBytesAvailable+1); InternetReadFile(hService, lpBuffer, dwBytesAvailable, &dwBytesRead); lpBuffer[dwBytesRead] = 0; // we actually need to check the buffer passed back here. free( lpBuffer ); InternetCloseHandle( hService ); } return APNET_SUCCESS; } APN_NET_TYPE ApnNetReadReg( short FpgaReg, unsigned short *FpgaData ) { DWORD dwBytesAvailable, dwBytesRead; HINTERNET hService; char szUrl[8096]; char *szStopStr; char *lpBuffer; // First make sure we have a valid session already if ( g_hSession == 0) { return APNET_ERR_CONNECT; } sprintf(szUrl, "%s%s%s%s%d", HTTP_PREAMBLE, g_HostAddr, FPGA_ACCESS, READ_REG, FpgaReg); #ifdef DEBUGURLS printf("url = %s\n",szUrl); #endif hService = InternetOpenUrl(g_hSession, szUrl, NULL, 0, 0, 0); if ( hService == 0 ) { return APNET_ERR_GENERIC_CGI; // Failure } else { InternetQueryDataAvailable(hService, &dwBytesAvailable, 0, 0); lpBuffer = (char *)malloc(dwBytesAvailable+1); InternetReadFile(hService, lpBuffer, dwBytesAvailable, &dwBytesRead); lpBuffer[dwBytesRead] = 0; #ifdef DEBUGURLS printf("reply = %s\n",lpBuffer); #endif strtok( lpBuffer, "="); *FpgaData = (USHORT)strtoul( strtok( NULL, "="), &szStopStr, 16 ); free(lpBuffer); InternetCloseHandle( hService ); } return APNET_SUCCESS; // Success } APN_NET_TYPE ApnNetWriteReg( short FpgaReg, unsigned short FpgaData ) { DWORD dwBytesAvailable, dwBytesRead; HINTERNET hService; char szUrl[8096]; char *szStopStr; char *pBuffer; char *pTokenBuffer; USHORT RetVal; // First make sure we have a valid session already if ( g_hSession == 0) { return APNET_ERR_CONNECT; // Failure } /* if ( FpgaReg == 0 ) { sprintf(szUrl, "%s%s%s%s%u&%s0x%X", HTTP_PREAMBLE, g_HostAddr, FPGA_DEFERRED_ACCESS, WRITE_REG, FpgaReg, WRITE_DATA, FpgaData); } else { sprintf(szUrl, "%s%s%s%s%u&%s0x%X", HTTP_PREAMBLE, g_HostAddr, FPGA_ACCESS, WRITE_REG, FpgaReg, WRITE_DATA, FpgaData); } */ sprintf(szUrl, "%s%s%s%s%u&%s0x%X", HTTP_PREAMBLE, g_HostAddr, FPGA_ACCESS, WRITE_REG, FpgaReg, WRITE_DATA, FpgaData); #ifdef DEBUGURLS printf("url = %s\n",szUrl); #endif hService = InternetOpenUrl(g_hSession, szUrl, NULL, 0, 0, 0); if ( hService == 0 ) { return APNET_ERR_GENERIC_CGI; // Failure } else { InternetQueryDataAvailable( hService, &dwBytesAvailable, 0, 0 ); pBuffer = (char*)malloc( dwBytesAvailable+1 ); InternetReadFile( hService, pBuffer, dwBytesAvailable, &dwBytesRead ); pBuffer[dwBytesRead]= 0; #ifdef DEBUGURLS printf("reply = %s\n",pBuffer); #endif pTokenBuffer = (char*)malloc( dwBytesAvailable+1 ); // strcpy( pTokenBuffer, strtok( pBuffer, "=") ); // OutputDebugString( pTokenBuffer ); // RetVal = (USHORT)strtoul( strtok( NULL, "="), &szStopStr, 16 ); /* if ( (FpgaData != RetVal) && (FpgaReg != 1) ) { return 1; // Failed } */ free( pBuffer ); free( pTokenBuffer ); InternetCloseHandle( hService ); } return APNET_SUCCESS; // Success } APN_NET_TYPE ApnNetWriteRegMulti( unsigned short FpgaReg, unsigned short FpgaData[], unsigned short RegCount ) { DWORD dwBytesAvailable, dwBytesRead; HINTERNET hService; char szUrl[8096]; char szTemp[50]; char *szStopStr; char *lpBuffer; USHORT RetVal; USHORT LoopCount; USHORT LoopCountRemainder; int i; USHORT StartIndex; USHORT EndIndex; // First make sure we have a valid session already if ( g_hSession == 0) { return APNET_ERR_CONNECT; // Failure } LoopCount = (unsigned short)( RegCount / APN_MAX_WRITES_PER_URL ); LoopCountRemainder = (unsigned short)( RegCount % APN_MAX_WRITES_PER_URL ); // Process the main blocks of the loop for ( i=0; i ( 1024 * 1024 * 28 ) ) { return APNET_ERR_IMAGE_PARAMS; // Failure } /////////////////////////////////////////////////////////////////////// // time code // ci= Mode --- poll mode is bit 0 // ci= Mode --- zero mem is bit 3 // Format: CI=Mode,UdpBlockSize,Width,Height sprintf(szUrl, "http://%s/FPGA?CI=0,0,%u,%u", g_HostAddr, ImageWidth, ImageHeight); #ifdef DEBUGURLS printf("url = %s\n",szUrl); #endif hService = InternetOpenUrl( g_hSession, szUrl, NULL, 0, 0, 0 ); if ( hService == 0 ) { return APNET_ERR_GENERIC_CGI; // Failure } else { InternetQueryDataAvailable(hService, &dwBytesAvailable, 0, 0); char *lpBuffer = (char*)malloc(dwBytesAvailable+1); InternetReadFile(hService, lpBuffer, dwBytesAvailable, &dwBytesRead); lpBuffer[dwBytesRead]= 0; free(lpBuffer); InternetCloseHandle( hService ); } // Set our global var indicating image size in bytes g_NetImgSizeBytes = ImageWidth * ImageHeight * 2; g_NetImgInProgress = TRUE; return APNET_SUCCESS; // Success } APN_NET_TYPE ApnNetStopExp( bool DigitizeData ) { // First make sure we have a valid session already if ( g_hSession == 0) { return APNET_ERR_CONNECT; // Failure } // Check to make sure an image isn't already in progress if ( !DigitizeData ) { if ( g_NetImgInProgress ) { g_NetImgInProgress = FALSE; } } return APNET_SUCCESS; // Success } APN_NET_TYPE ApnNetSetSpeed( bool HighSpeed ) { // High speed mode is UDP // Normal mode is TCP if ( HighSpeed ) g_FastDownload = TRUE; else g_FastDownload = FALSE; return APNET_SUCCESS; // Success } APN_NET_TYPE ApnNetGetImageTcp( unsigned short *pMem ) { HINTERNET hService; DWORD dwBytesAvailable, dwBytesRead; ULONG dwImgSize; char szUrl[8096]; // First make sure we have a valid session already if ( g_hSession == 0) { return APNET_ERR_CONNECT; } // Check to see if ApnNetStartExp was called first if ( g_NetImgInProgress == FALSE ) { return APNET_ERR_IMAGE_START; // Failure -- Image never started } sprintf( szUrl, "http://%s/UE/image.bin", g_HostAddr ); #ifdef DEBUGURLS printf("url = %s\n",szUrl); #endif hService = InternetOpenUrl( g_hSession, szUrl, NULL, 0, INTERNET_FLAG_NO_CACHE_WRITE | INTERNET_FLAG_KEEP_CONNECTION, 0 ); if ( hService == 0 ) { return APNET_ERR_GENERIC_CGI; // Failure } else { InternetReadFile( hService, (char *)pMem, g_NetImgSizeBytes, &dwBytesRead ); if ( g_NetImgSizeBytes != dwBytesRead ) { return APNET_ERR_IMAGE_DATA; // Failure -- Retrieved incorrect amount of data } InternetCloseHandle( hService ); } dwImgSize = g_NetImgSizeBytes / 2; for (ULONG j=0; j #include #include #include "ApogeeNet.h" #include "ApogeeNetErr.h" #ifdef LINUX #include "stdafx.h" #endif int main( int argc, char* argv[] ) { unsigned long subnet; unsigned short count; char cameras[1024]; subnet = 256*256*256*192 + 256*256*168 + 255; ApnNetDiscovery(subnet, &count, cameras); printf ("%d %s\n", count, cameras); exit(0); } libapogee2-2.2/ApogeeNet/ApogeeNetLinux.c.old0000644000175000017500000000645611110507150016657 0ustar jrjr#include #include #include #include #include #include "WWWLib.h" #include "WWWHTTP.h" #include "WWWInit.h" #ifdef __cplusplus extern "C" { #endif int *InternetOpen( char *app, int imode, int dum1, int dum2, int dum3); HTChunk *InternetOpenUrl( int g_hSession, char *szUrl, int dum1, int dum2, int iflags, int dum3 ); int InternetReadFile(HTChunk *hService, char *lpBuffer, int dwBytesAvailable, int *dwBytesRead); int InternetCloseHandle( HTChunk *hService ); char * cwd; char * absolute_uri; HTRequest * libwww_request; int libwww_opened = 0; PRIVATE int printer (const char * fmt, va_list pArgs) { return (vfprintf(stdout, fmt, pArgs)); } PRIVATE int tracer (const char * fmt, va_list pArgs) { return (vfprintf(stderr, fmt, pArgs)); } PRIVATE int terminate_handler (HTRequest * request, HTResponse * response, void * param, int status) { HTChunk * chunk = (HTChunk *) HTRequest_context(request); /* Check for status */ HTPrint("Load resulted in status %d\n", status); #if 0 if (status == HT_LOADED && chunk && HTChunk_data(chunk)) HTPrint("%s", HTChunk_data(chunk)); #endif /* Remember to delete our chunk of data */ if (chunk) HTChunk_delete(chunk); /* We are done with this request */ HTRequest_delete(request); /* Terminate libwww */ HTProfile_delete(); return HT_OK; } int *InternetOpen( char *app, int imode, int dum1, int dum2, int dum3) { if (libwww_opened == 0) { /* Set up the application's event loop. We use the example event loop that comes with the Library. */ HTEventInit(); /* Initialize libwww core */ HTLibInit(app, "1.0"); /* Turn on TRACE so we can see what is going on */ HTSetTraceMessageMask("sop"); /* Register the default set of messages and dialog functions */ HTAlertInit(); HTProfile_newPreemptiveClient("ApogeeNET", "1.0"); /* Need our own trace and print functions */ HTPrint_setCallback(printer); HTTrace_setCallback(tracer); /* Add our own filter to handle termination */ /* HTNet_addAfter(terminate_handler, NULL, NULL, HT_ALL, HT_FILTER_LAST); */ } return 1; } HTChunk * InternetOpenUrl( int g_hSession, char *szUrl, int dum1, int dum2, int iflags, int dum3 ) { char *string; HTRequest * request = NULL; HTChunk * chunk = NULL; int arg = 0; HTProfile_newPreemptiveClient("ApogeeNET", "1.0"); HTAlert_setInteractive(NO); cwd = HTGetCurrentDirectoryURL(); absolute_uri = HTParse(szUrl, cwd, PARSE_ALL); libwww_request = HTRequest_new(); /* Set up the request and pass it to the Library */ HTRequest_setOutputFormat(libwww_request, WWW_SOURCE); chunk = HTLoadToChunk(absolute_uri, libwww_request); HTEventList_loop (libwww_request); /* get the data */ string = HTChunk_data(chunk); return chunk; } int InternetReadFile( HTChunk * chunk, char *lpBuffer, int dwBytesAvailable, int *dwBytesRead) { lpBuffer = HTChunk_toCString(chunk); dwBytesAvailable = strlen(lpBuffer); dwBytesRead = strlen(lpBuffer); } int InternetCloseHandle( HTChunk * chunk) { HTChunk_delete(chunk); HTRequest_delete(libwww_request); HT_FREE(absolute_uri); HT_FREE(cwd); return 0; } #ifdef __cplusplus } #endif libapogee2-2.2/ApogeeNet/ApogeeNetErr.h0000644000175000017500000000160011110507150015522 0ustar jrjr// Error codes for the ApogeeNet.cpp file #define APN_NET_SUCCESS 0 #define APN_NET_ERR_CONNECT 1 #define APN_NET_ERR_CLOSE 2 #define APN_NET_ERR_HTTP_SESSION 3 #define APN_NET_ERR_HTTP_OPEN_REQUEST 4 #define APN_NET_ERR_HTTP_SEND_REQUEST 5 #define APN_NET_ERR_GENERIC_CGI 6 #define APN_NET_ERR_IMAGE_PARAMS 7 #define APN_NET_ERR_IMAGE_DATA 8 #define APN_NET_ERR_IMAGE_START 9 #define APN_NET_ERR_IMAGE_EXPOSING 10 #define APN_NET_ERR_UPLOAD_FILE 11 #define APN_NET_ERR_SERIAL_CONNECT 12 #define APN_NET_ERR_SERIAL_ID 13 #define APN_NET_ERR_SERIAL_BAUDRATE 14 #define APN_NET_ERR_SERIAL_PARITY 15 #define APN_NET_ERR_SERIAL_READ_INPUT 16 #define APN_NET_ERR_SERIAL_WRITE_INPUT 17 #define APN_NET_ERR_SERIAL_NO_CONNECTION 18 #define APN_NET_ERR_SERIAL_READ_FAILURE 19 #define APN_NET_ERR_SERIAL_WRITE_FAILURE 20 libapogee2-2.2/ApogeeNet/ApogeeNetLinux.c0000644000175000017500000000525311110507150016074 0ustar jrjr#include #include #include #include #include #include #include #include #include #ifdef __cplusplus extern "C" { #endif struct MemoryStruct { char *memory; size_t size; }; CURL *curl_handle[128]; int active_curls; struct MemoryStruct chunk[128]; int InternetOpen( char *iname, int itype, int *dum, int *dum2, int dum3); int InternetOpenUrl( int g_hSession, char *url, int *dum1, int *dum2, int dum3, int dum4 ); void InternetQueryDataAvailable(int handle, long *bcount, int dum1, int dum2); void InternetReadFile(int handle, char *lpBuffer, long bcount, long *bread); void InternetCloseHandle( int handle ); size_t WriteMemoryCallback(void *ptr, size_t size, size_t nmemb, void *data); size_t WriteMemoryCallback(void *ptr, size_t size, size_t nmemb, void *data) { register int realsize = size * nmemb; struct MemoryStruct *mem = (struct MemoryStruct *)data; mem->memory = (char *)realloc(mem->memory, mem->size + realsize + 1); if (mem->memory) { memcpy(&(mem->memory[mem->size]), ptr, realsize); mem->size += realsize; mem->memory[mem->size] = 0; } return realsize; } int InternetOpen( char *iname, int itype, int *dum, int *dum2, int dum3) { int i; for (i=0;i<128;i++) { chunk[i].memory=NULL; /* we expect realloc(NULL, size) to work */ chunk[i].size = 0; /* no data at this point */ } curl_global_init(CURL_GLOBAL_ALL); active_curls = 0; return(1); } int InternetOpenUrl( int g_hSession, char *url, int *dum1, int *dum2, int dum3, int dum4 ) { /* init the curl session */ active_curls++; curl_handle[active_curls] = curl_easy_init(); /* specify URL to get */ curl_easy_setopt(curl_handle[active_curls], CURLOPT_URL, url); /* send all data to this function */ curl_easy_setopt(curl_handle[active_curls], CURLOPT_WRITEFUNCTION, WriteMemoryCallback); /* we pass our 'chunk' struct to the callback function */ curl_easy_setopt(curl_handle[active_curls], CURLOPT_WRITEDATA, (void *)&chunk[active_curls]); /* get it! */ curl_easy_perform(curl_handle[active_curls]); return(active_curls); } void InternetQueryDataAvailable(int handle, long *bcount, int dum1, int dum2) { *bcount = chunk[handle].size; return; } void InternetReadFile(int handle, char *lpBuffer, long bcount, long *bread) { if (chunk[handle].size > 0) { memcpy(lpBuffer, chunk[handle].memory, bcount); *bread = bcount; } return; } void InternetCloseHandle( int handle ) { /* cleanup curl stuff */ curl_easy_cleanup(curl_handle[handle]); chunk[handle].size = 0; active_curls--; } #ifdef __cplusplus } #endif libapogee2-2.2/ApogeeNet/ApogeeNet.cpp0000644000175000017500000012007611110507150015415 0ustar jrjr////////////////////////////////////////////////////////////////////// // // ApogeeNet.cpp : Library of basic networking functions for Apogee APn/Alta. // // Copyright (c) 2003, 2004 Apogee Instruments, Inc. // ////////////////////////////////////////////////////////////////////// #include "ApogeeNet.h" #include "ApogeeNetErr.h" #ifdef LINUX #include "stdafx.h" #include #include #include #include #include #include #define HINTERNET int #define _snprintf snprintf extern "C" { extern int InternetOpen( char *iname, int itype, int *dum, int *dum2, int dum3); extern int InternetOpenUrl( int g_hSession, char *url, int *dum1, int *dum2, int dum3, int dum4 ); extern void InternetQueryDataAvailable(int handle, long *bcount, int dum1, int dum2); extern void InternetReadFile(int handle, char *lpBuffer, long bcount, long *bread); extern void InternetCloseHandle( int handle ); } #endif // Global variables used in this DLL HINTERNET g_hSession; ULONG g_NetImgSizeBytes; BOOLEAN g_NetImgInProgress; BOOLEAN g_FastDownload; char g_HostAddr[80]; // This is an example of an exported function. APN_NET_TYPE ApnNetConnect(char *HostAddr ) { DWORD dwBytesAvailable, dwBytesRead; HINTERNET hService; int RetLength; char szUrl[8096]; char *lpBuffer; strcpy( g_HostAddr, HostAddr ); g_hSession = InternetOpen( "ApogeeNet", INTERNET_OPEN_TYPE_DIRECT, NULL, NULL, 0 ); if ( g_hSession == 0 ) { return APN_NET_ERR_CONNECT; } sprintf( szUrl, "%s%s%s", HTTP_PREAMBLE, HostAddr, SESSION_OPEN ); hService = InternetOpenUrl( g_hSession, szUrl, NULL, 0, 0, 0 ); if ( hService == 0 ) { return APN_NET_ERR_GENERIC_CGI; // Failure } else { InternetQueryDataAvailable(hService, &dwBytesAvailable, 0, 0); lpBuffer = (char *)malloc(dwBytesAvailable+1); InternetReadFile(hService, lpBuffer, dwBytesAvailable, &dwBytesRead); lpBuffer[dwBytesRead] = 0; RetLength = strlen( SESSION_OPEN_RETVAL ); if ( strncmp( lpBuffer, SESSION_OPEN_RETVAL, RetLength ) != 0 ) { free( lpBuffer ); return APN_NET_ERR_CONNECT; } free( lpBuffer ); InternetCloseHandle( hService ); } g_NetImgInProgress = FALSE; g_NetImgSizeBytes = 0; return APN_NET_SUCCESS; } APN_NET_TYPE ApnNetClose(char *HostAddr ) { DWORD dwBytesAvailable, dwBytesRead; HINTERNET hService; char szUrl[8096]; char *lpBuffer; // First make sure we have a valid session already if ( g_hSession == 0) { // Return successful since there is no session open anyway return APN_NET_SUCCESS; } sprintf( szUrl, "%s%s%s", HTTP_PREAMBLE, HostAddr, SESSION_CLOSE ); hService = InternetOpenUrl( g_hSession, szUrl, NULL, 0, 0, 0 ); if ( hService == 0 ) { return APN_NET_ERR_GENERIC_CGI; // Failure } else { InternetQueryDataAvailable(hService, &dwBytesAvailable, 0, 0); lpBuffer = (char *)malloc(dwBytesAvailable+1); InternetReadFile(hService, lpBuffer, dwBytesAvailable, &dwBytesRead); lpBuffer[dwBytesRead] = 0; if ( strcmp( lpBuffer, SESSION_CLOSE_RETVAL ) != 0 ) { free( lpBuffer ); return APN_NET_ERR_CLOSE; } free( lpBuffer ); InternetCloseHandle( hService ); } g_hSession = 0; return APN_NET_SUCCESS; } APN_NET_TYPE ApnNetDiscovery( unsigned long Subnet, unsigned short *CameraCount, char *CameraList ) { #ifndef LINUX WSADATA WinSockData; #endif int LineLen, UdpPacketLen; int sd; struct sockaddr_in servaddr; struct in_addr in_val; const int on = 1; char Line[DISCOVERY_MAXLINESIZE + 1]; char pUdpPacket[DISCOVERY_MAXBUFFER + 1]; char szTemp[256]; char* CurCamList; clock_t ct; unsigned long addr; // Initial count of cameras on network should be zero *CameraCount = 0; #ifndef LINUX // Try to start the Windows sockets library if ( WSAStartup(MAKEWORD(1, 0), &WinSockData) != 0 ) { return 1; } #endif memset(&servaddr, 0, sizeof(servaddr)); servaddr.sin_family = AF_INET; servaddr.sin_port = htons( APOGEE_IP_PORT_NUMBER ); servaddr.sin_addr.s_addr = Subnet; sd = socket( AF_INET, SOCK_DGRAM, 0 ); setsockopt( sd, SOL_SOCKET, SO_BROADCAST, (char*) &on, sizeof(on) ); LineLen = _snprintf( Line, DISCOVERY_MAXLINESIZE, "Discovery::Request-Except: \"%s\"; 0x%lX; %ld; %ld; %ld; %ld" APOGEE_CRLF APOGEE_CRLF, "Apogee", 0x12345678, 0, DISCOVERY_TIMEOUT_SECS / 2, 0, 0 ); // Build the header for the message UdpPacketLen = _snprintf( pUdpPacket, DISCOVERY_MAXBUFFER, "MIME-Version: 1.0" APOGEE_CRLF "Content-Type: application/octet-stream" APOGEE_CRLF "Content-Transfer-Encoding: binary" APOGEE_CRLF "Content-Length: 0x%X" APOGEE_CRLF "X-Project: Apogee" APOGEE_CRLF "X-Project-Version: 0.1" APOGEE_CRLF APOGEE_CRLF, LineLen ); memcpy(pUdpPacket + UdpPacketLen, Line, LineLen); UdpPacketLen += LineLen; sendto( sd, pUdpPacket, UdpPacketLen, 0, (struct sockaddr *)&servaddr, sizeof(servaddr) ); // Wait for UDP replies struct timeval tv; fd_set rset; int n; char szResponseToken[DISCOVERY_TOKEN_ID_LENGTH]; char szId[DISCOVERY_TOKEN_LENGTH]; char szTag[DISCOVERY_TOKEN_LENGTH]; char szTime[DISCOVERY_TOKEN_LENGTH]; char szIpAddrToken[DISCOVERY_TOKEN_ID_LENGTH]; char szIpAddr[DISCOVERY_TOKEN_LENGTH]; char szPortToken[DISCOVERY_TOKEN_ID_LENGTH]; char szPort[DISCOVERY_TOKEN_LENGTH]; char szNameToken[DISCOVERY_TOKEN_ID_LENGTH]; char szName[DISCOVERY_TOKEN_LENGTH]; char szCamNumber[DISCOVERY_TOKEN_LENGTH]; ct = clock() + DISCOVERY_TIMEOUT_SECS * CLOCKS_PER_SEC; tv.tv_sec = 0; tv.tv_usec = 0; size_t CurLength; size_t NewLength; while (clock() <= ct) { FD_ZERO( &rset ); FD_SET( sd, &rset ); if ( select( sd + 1, &rset, NULL, NULL, &tv ) > 0 ) { n = recvfrom(sd, pUdpPacket, DISCOVERY_MAXBUFFER, 0, NULL, NULL); // Process the returned packets. pUdpPacket[n] = '\0'; // add a NULL to the close of the string sscanf( pUdpPacket, "%s %s %s %s" "%s %s" "%s %s" "%s", szResponseToken, szId, szTag, szTime, szIpAddrToken, szIpAddr, szPortToken, szPort, szNameToken ); strtok(pUdpPacket, "\""); strtok(NULL, "\""); strtok(NULL, "\""); strcpy(szName, strtok(NULL, "\"")); if ( strcmp("\r\nSessionId=", szName) == 0 ) { strcpy(szName, "Camera Unnamed"); } // Increment number of cameras on network (*CameraCount)++; sprintf( szCamNumber, "%u ", *CameraCount ); sprintf( szTemp, "%u 0x%08X %u ", szCamNumber, szIpAddr, szPort ); // determine string lengths NewLength = strlen( szTemp ); CurLength = strlen( CameraList ); CurCamList = (char*)calloc( CurLength + 1, sizeof(char) ); // copy current string for safe keeping strcpy( CurCamList, CameraList ); // allocate space for combined string CameraList = (char*)calloc( CurLength + NewLength + 1, sizeof(char) ); sprintf( CameraList, "%s%s", CameraList, szTemp ); } } CurLength = strlen( CameraList ); CurCamList = (char*)calloc( CurLength + 1, sizeof(char) ); // copy current string for safe keeping strcpy( CurCamList, CameraList ); // allocate space for combined string CameraList = (char*)calloc( CurLength + sizeof(szCamNumber) + 1, sizeof(char) ); sprintf( CameraList, "%s%s", szCamNumber, CameraList ); // Stop the Windows sockets library #ifndef LINUX WSACleanup(); #endif g_NetImgInProgress = FALSE; g_NetImgSizeBytes = 0; return APN_NET_SUCCESS; } APN_NET_TYPE ApnNetReboot( char *HostAddr ) { HINTERNET hService; DWORD dwBytesAvailable, dwBytesRead; char szUrl[8096]; char* lpBuffer; sprintf(szUrl, "%s%s%s", HTTP_PREAMBLE, HostAddr, REBOOT_CMD); hService = InternetOpenUrl( g_hSession, szUrl, NULL, 0, 0, 0 ); if ( hService == 0 ) { return APN_NET_ERR_GENERIC_CGI; } else { InternetQueryDataAvailable(hService, &dwBytesAvailable, 0, 0); lpBuffer = (char*)malloc(dwBytesAvailable+1); InternetReadFile(hService, lpBuffer, dwBytesAvailable, &dwBytesRead); lpBuffer[dwBytesRead] = 0; // we actually need to check the buffer passed back here. free( lpBuffer ); InternetCloseHandle( hService ); } return APN_NET_SUCCESS; } APN_NET_TYPE ApnNetReadReg( char *HostAddr, short FpgaReg, unsigned short *FpgaData ) { DWORD dwBytesAvailable, dwBytesRead; HINTERNET hService; char szUrl[8096]; char *szStopStr; char *lpBuffer; // First make sure we have a valid session already if ( g_hSession == 0) { return APN_NET_ERR_CONNECT; } sprintf(szUrl, "%s%s%s%s%d", HTTP_PREAMBLE, HostAddr, FPGA_ACCESS, READ_REG, FpgaReg); hService = InternetOpenUrl( g_hSession, szUrl, NULL, 0, 0, 0 ); if ( hService == 0 ) { return APN_NET_ERR_GENERIC_CGI; // Failure } else { InternetQueryDataAvailable(hService, &dwBytesAvailable, 0, 0); lpBuffer = (char *)malloc(dwBytesAvailable+1); InternetReadFile(hService, lpBuffer, dwBytesAvailable, &dwBytesRead); lpBuffer[dwBytesRead] = 0; strtok( lpBuffer, "="); *FpgaData = (USHORT)strtoul( strtok( NULL, "="), &szStopStr, 16 ); free(lpBuffer); InternetCloseHandle( hService ); } return APN_NET_SUCCESS; // Success } APN_NET_TYPE ApnNetWriteReg( char *HostAddr, short FpgaReg, unsigned short FpgaData ) { DWORD dwBytesAvailable, dwBytesRead; HINTERNET hService; char szUrl[8096]; char *szStopStr; char *pBuffer; char *pTokenBuffer; USHORT RetVal; // First make sure we have a valid session already if ( g_hSession == 0) { return APN_NET_ERR_CONNECT; // Failure } /* if ( FpgaReg == 0 ) { sprintf(szUrl, "%s%s%s%s%u&%s0x%X", HTTP_PREAMBLE, g_HostAddr, FPGA_DEFERRED_ACCESS, WRITE_REG, FpgaReg, WRITE_DATA, FpgaData); } else { sprintf(szUrl, "%s%s%s%s%u&%s0x%X", HTTP_PREAMBLE, g_HostAddr, FPGA_ACCESS, WRITE_REG, FpgaReg, WRITE_DATA, FpgaData); } */ sprintf(szUrl, "%s%s%s%s%u&%s0x%X", HTTP_PREAMBLE, HostAddr, FPGA_ACCESS, WRITE_REG, FpgaReg, WRITE_DATA, FpgaData); hService = InternetOpenUrl( g_hSession, szUrl, NULL, 0, 0, 0 ); if ( hService == 0 ) { return APN_NET_ERR_GENERIC_CGI; // Failure } else { InternetQueryDataAvailable( hService, &dwBytesAvailable, 0, 0 ); pBuffer = (char*)malloc( dwBytesAvailable+1 ); InternetReadFile( hService, pBuffer, dwBytesAvailable, &dwBytesRead ); pBuffer[dwBytesRead]=0; pTokenBuffer = (char*)malloc( dwBytesAvailable+1 ); // strcpy( pTokenBuffer, strtok( pBuffer, "=") ); // OutputDebugString( pTokenBuffer ); // RetVal = (USHORT)strtoul( strtok( NULL, "="), &szStopStr, 16 ); /* if ( (FpgaData != RetVal) && (FpgaReg != 1) ) { return 1; // Failed } */ free( pBuffer ); free( pTokenBuffer ); InternetCloseHandle( hService ); } return APN_NET_SUCCESS; // Success } APN_NET_TYPE ApnNetWriteRegMulti( char *HostAddr, unsigned short FpgaReg, unsigned short FpgaData[], unsigned short RegCount ) { DWORD dwBytesAvailable, dwBytesRead; HINTERNET hService; char szUrl[8096]; char szTemp[50]; char *szStopStr; char *lpBuffer; USHORT RetVal; USHORT LoopCount; USHORT LoopCountRemainder; int i; USHORT StartIndex; USHORT EndIndex; // First make sure we have a valid session already if ( g_hSession == 0) { return APN_NET_ERR_CONNECT; // Failure } LoopCount = (unsigned short)( RegCount / APN_MAX_WRITES_PER_URL ); LoopCountRemainder = (unsigned short)( RegCount % APN_MAX_WRITES_PER_URL ); // Process the main blocks of the loop for ( i=0; i ( 1024 * 1024 * 28 ) ) { return APN_NET_ERR_IMAGE_PARAMS; // Failure } /////////////////////////////////////////////////////////////////////// // time code // ci= Mode --- poll mode is bit 0 // ci= Mode --- zero mem is bit 3 // Format: CI=Mode,UdpBlockSize,Width,Height sprintf(szUrl, "http://%s/FPGA?CI=0,0,%u,%u,0xFFFFFFFF", HostAddr, ImageWidth, ImageHeight); hService = InternetOpenUrl( g_hSession, szUrl, NULL, 0, 0, 0 ); if ( hService == 0 ) { return APN_NET_ERR_GENERIC_CGI; // Failure } else { InternetQueryDataAvailable(hService, &dwBytesAvailable, 0, 0); char *lpBuffer = (char*)malloc(dwBytesAvailable+1); InternetReadFile(hService, lpBuffer, dwBytesAvailable, &dwBytesRead); lpBuffer[dwBytesRead]=0; free(lpBuffer); InternetCloseHandle( hService ); } return APN_NET_SUCCESS; // Success } APN_NET_TYPE ApnNetStopExp( char *HostAddr, bool DigitizeData ) { // First make sure we have a valid session already if ( g_hSession == 0) { return APN_NET_ERR_CONNECT; // Failure } return APN_NET_SUCCESS; // Success } APN_NET_TYPE ApnNetSetSpeed( char *HostAddr, bool HighSpeed ) { // High speed mode is UDP // Normal mode is TCP if ( HighSpeed ) { } else { } return APN_NET_SUCCESS; // Success } APN_NET_TYPE ApnNetGetImageTcp( char *HostAddr, unsigned long ImageByteCount, unsigned short *pMem ) { HINTERNET hService; DWORD dwBytesAvailable, dwBytesRead; ULONG dwImgSize; char szUrl[8096]; // First make sure we have a valid session already if ( g_hSession == 0) { return APN_NET_ERR_CONNECT; } sprintf( szUrl, "http://%s/UE/image.bin", HostAddr ); hService = InternetOpenUrl( g_hSession, szUrl, NULL, 0, INTERNET_FLAG_NO_CACHE_WRITE | INTERNET_FLAG_KEEP_CONNECTION, 0 ); if ( hService == 0 ) { return APN_NET_ERR_GENERIC_CGI; // Failure } else { InternetReadFile( hService, (char *)pMem, ImageByteCount, &dwBytesRead ); if (dwBytesRead == 0) { return APN_NET_ERR_IMAGE_DATA; // Failure -- Retrieved incorrect amount of data } InternetCloseHandle( hService ); } dwImgSize = ImageByteCount / 2; for (ULONG j=0; j #include #include ///////////////////////////////////////////////////////////// // Construction/Destruction ///////////////////////////////////////////////////////////// CApnCamData_KAI11000C::CApnCamData_KAI11000C() { } CApnCamData_KAI11000C::~CApnCamData_KAI11000C() { } void CApnCamData_KAI11000C::Initialize() { strcpy( m_Sensor, "KAI11000C" ); strcpy( m_CameraModel, "11000c" ); m_CameraId = 86; m_InterlineCCD = true; m_SupportsSerialA = true; m_SupportsSerialB = true; m_SensorTypeCCD = true; m_TotalColumns = 4080; m_ImagingColumns = 4008; m_ClampColumns = 36; m_PreRoiSkipColumns = 0; m_PostRoiSkipColumns = 0; m_OverscanColumns = 36; m_TotalRows = 2720; m_ImagingRows = 2672; m_UnderscanRows = 24; m_OverscanRows = 24; m_VFlushBinning = 1; m_EnableSingleRowOffset = false; m_RowOffsetBinning = 1; m_HFlushDisable = false; m_ShutterCloseDelay = 0; m_PixelSizeX = 9; m_PixelSizeY = 9; m_Color = true; m_ReportedGainSixteenBit = 1; m_MinSuggestedExpTime = 0.05; m_CoolingSupported = true; m_RegulatedCoolingSupported = true; m_TempSetPoint = -20.0; m_TempRampRateOne = 700; m_TempRampRateTwo = 4000; m_TempBackoffPoint = 2.0; m_PrimaryADType = ApnAdType_Alta_Sixteen; m_AlternativeADType = ApnAdType_Alta_Twelve; //m_DefaultGainTwelveBit = 150; //m_DefaultOffsetTwelveBit = 100; m_DefaultRVoltage = 1000; set_vpattern(); set_hpattern_clamp_sixteen(); set_hpattern_skip_sixteen(); set_hpattern_roi_sixteen(); set_hpattern_clamp_twelve(); set_hpattern_skip_twelve(); set_hpattern_roi_twelve(); } void CApnCamData_KAI11000C::set_vpattern() { const unsigned short Mask = 0x106; const unsigned short NumElements = 38; unsigned short Pattern[NumElements] = { 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0302, 0x0302, 0x0302, 0x0302, 0x0302, 0x0302, 0x0302, 0x0302, 0x0302, 0x0302, 0x0002, 0x0002, 0x0002, 0x0003, 0x0002 }; m_VerticalPattern.Mask = Mask; m_VerticalPattern.NumElements = NumElements; m_VerticalPattern.PatternData = (unsigned short *)malloc(NumElements * sizeof(unsigned short)); for ( int i=0; iMask = Mask; Pattern->BinningLimit = BinningLimit; Pattern->RefNumElements = RefNumElements; Pattern->SigNumElements = SigNumElements; if ( RefNumElements > 0 ) { Pattern->RefPatternData = (unsigned short *)malloc(RefNumElements * sizeof(unsigned short)); for ( i=0; iRefPatternData[i] = RefPatternData[i]; } } if ( SigNumElements > 0 ) { Pattern->SigPatternData = (unsigned short *)malloc(SigNumElements * sizeof(unsigned short)); for ( i=0; iSigPatternData[i] = SigPatternData[i]; } } if ( BinningLimit > 0 ) { for ( i=0; iBinNumElements[i] = BinNumElements[i]; Pattern->BinPatternData[i] = (unsigned short *)malloc(BinNumElements[i] * sizeof(unsigned short)); for ( j=0; jBinPatternData[i][j] = BinPatternData[i][j]; } } } } libapogee2-2.2/ApnCamData_KAF1001E.cpp0000644000175000017500000006135111110507150014720 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_KAF1001E.cpp: Implementation file for the CApnCamData_KAF1001E class. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #include "ApnCamData_KAF1001E.h" #include #include #include ///////////////////////////////////////////////////////////// // Construction/Destruction ///////////////////////////////////////////////////////////// CApnCamData_KAF1001E::CApnCamData_KAF1001E() { } CApnCamData_KAF1001E::~CApnCamData_KAF1001E() { } void CApnCamData_KAF1001E::Initialize() { strcpy( m_Sensor, "KAF1001E" ); strcpy( m_CameraModel, "6" ); m_CameraId = 5; m_InterlineCCD = false; m_SupportsSerialA = true; m_SupportsSerialB = true; m_SensorTypeCCD = true; m_TotalColumns = 1044; m_ImagingColumns = 1024; m_ClampColumns = 8; m_PreRoiSkipColumns = 0; m_PostRoiSkipColumns = 0; m_OverscanColumns = 12; m_TotalRows = 1032; m_ImagingRows = 1024; m_UnderscanRows = 4; m_OverscanRows = 4; m_VFlushBinning = 1; m_EnableSingleRowOffset = false; m_RowOffsetBinning = 1; m_HFlushDisable = false; m_ShutterCloseDelay = 300; m_PixelSizeX = 24; m_PixelSizeY = 24; m_Color = false; m_ReportedGainSixteenBit = 3; m_MinSuggestedExpTime = 20.0; m_CoolingSupported = true; m_RegulatedCoolingSupported = true; m_TempSetPoint = -20.0; m_TempRampRateOne = 700; m_TempRampRateTwo = 4000; m_TempBackoffPoint = 2.0; m_PrimaryADType = ApnAdType_Alta_Sixteen; m_AlternativeADType = ApnAdType_Alta_Twelve; m_DefaultGainLeft = 0; m_DefaultOffsetLeft = 250; m_DefaultGainRight = -1; m_DefaultOffsetRight = -1; m_DefaultRVoltage = 1000; m_DefaultSpeed = 0xffff; m_DefaultDataReduction = false; set_vpattern(); set_hpattern_clamp_sixteen(); set_hpattern_skip_sixteen(); set_hpattern_roi_sixteen(); set_hpattern_clamp_twelve(); set_hpattern_skip_twelve(); set_hpattern_roi_twelve(); } void CApnCamData_KAF1001E::set_vpattern() { const unsigned short Mask = 0x0; const unsigned short NumElements = 71; unsigned short Pattern[NumElements] = { 0x0000, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0001, 0x0000 }; m_VerticalPattern.Mask = Mask; m_VerticalPattern.NumElements = NumElements; m_VerticalPattern.PatternData = (unsigned short *)malloc(NumElements * sizeof(unsigned short)); for ( int i=0; iMask = Mask; Pattern->BinningLimit = BinningLimit; Pattern->RefNumElements = RefNumElements; Pattern->SigNumElements = SigNumElements; if ( RefNumElements > 0 ) { Pattern->RefPatternData = (unsigned short *)malloc(RefNumElements * sizeof(unsigned short)); for ( i=0; iRefPatternData[i] = RefPatternData[i]; } } if ( SigNumElements > 0 ) { Pattern->SigPatternData = (unsigned short *)malloc(SigNumElements * sizeof(unsigned short)); for ( i=0; iSigPatternData[i] = SigPatternData[i]; } } if ( BinningLimit > 0 ) { for ( i=0; iBinNumElements[i] = BinNumElements[i]; Pattern->BinPatternData[i] = (unsigned short *)malloc(BinNumElements[i] * sizeof(unsigned short)); for ( j=0; jBinPatternData[i][j] = BinPatternData[i][j]; } } } } libapogee2-2.2/ApnCamData_KAI4020M.cpp0000644000175000017500000005277711110507150014753 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_KAI4020M.cpp: Implementation file for the CApnCamData_KAI4020M class. // // Copyright (c) 2003, 2004 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #include "ApnCamData_KAI4020M.h" #include #include #include ///////////////////////////////////////////////////////////// // Construction/Destruction ///////////////////////////////////////////////////////////// CApnCamData_KAI4020M::CApnCamData_KAI4020M() { } CApnCamData_KAI4020M::~CApnCamData_KAI4020M() { } void CApnCamData_KAI4020M::Initialize() { strcpy( m_Sensor, "KAI4020M" ); strcpy( m_CameraModel, "4020m" ); m_CameraId = 82; m_InterlineCCD = true; m_SupportsSerialA = true; m_SupportsSerialB = true; m_SensorTypeCCD = true; m_TotalColumns = 2136; m_ImagingColumns = 2048; m_ClampColumns = 44; m_PreRoiSkipColumns = 0; m_PostRoiSkipColumns = 0; m_OverscanColumns = 44; m_TotalRows = 2072; m_ImagingRows = 2048; m_UnderscanRows = 16; m_OverscanRows = 8; m_VFlushBinning = 1; m_EnableSingleRowOffset = false; m_RowOffsetBinning = 1; m_HFlushDisable = false; m_ShutterCloseDelay = 0; m_PixelSizeX = 7.4; m_PixelSizeY = 7.4; m_Color = false; m_ReportedGainSixteenBit = 1; m_MinSuggestedExpTime = 0.05; m_CoolingSupported = true; m_RegulatedCoolingSupported = true; m_TempSetPoint = -20.0; m_TempRampRateOne = 700; m_TempRampRateTwo = 4000; m_TempBackoffPoint = 2.0; m_PrimaryADType = ApnAdType_Alta_Sixteen; m_AlternativeADType = ApnAdType_Alta_Twelve; //m_DefaultGainTwelveBit = 0; //m_DefaultOffsetTwelveBit = 100; m_DefaultRVoltage = 1000; set_vpattern(); set_hpattern_clamp_sixteen(); set_hpattern_skip_sixteen(); set_hpattern_roi_sixteen(); set_hpattern_clamp_twelve(); set_hpattern_skip_twelve(); set_hpattern_roi_twelve(); } void CApnCamData_KAI4020M::set_vpattern() { const unsigned short Mask = 0x106; const unsigned short NumElements = 38; unsigned short Pattern[NumElements] = { 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0302, 0x0302, 0x0302, 0x0302, 0x0302, 0x0302, 0x0302, 0x0302, 0x0302, 0x0302, 0x0002, 0x0002, 0x0002, 0x0003, 0x0002 }; m_VerticalPattern.Mask = Mask; m_VerticalPattern.NumElements = NumElements; m_VerticalPattern.PatternData = (unsigned short *)malloc(NumElements * sizeof(unsigned short)); for ( int i=0; iMask = Mask; Pattern->BinningLimit = BinningLimit; Pattern->RefNumElements = RefNumElements; Pattern->SigNumElements = SigNumElements; if ( RefNumElements > 0 ) { Pattern->RefPatternData = (unsigned short *)malloc(RefNumElements * sizeof(unsigned short)); for ( i=0; iRefPatternData[i] = RefPatternData[i]; } } if ( SigNumElements > 0 ) { Pattern->SigPatternData = (unsigned short *)malloc(SigNumElements * sizeof(unsigned short)); for ( i=0; iSigPatternData[i] = SigPatternData[i]; } } if ( BinningLimit > 0 ) { for ( i=0; iBinNumElements[i] = BinNumElements[i]; Pattern->BinPatternData[i] = (unsigned short *)malloc(BinNumElements[i] * sizeof(unsigned short)); for ( j=0; jBinPatternData[i][j] = BinPatternData[i][j]; } } } } libapogee2-2.2/FpgaRegs/0000755000175000017500000000000011110507150012663 5ustar jrjrlibapogee2-2.2/FpgaRegs/FpgaRegs.h0000644000175000017500000001744611110507150014546 0ustar jrjr #ifndef __FPGAREGS_H__APOGEE_APN__ #define __FPGAREGS_H__APOGEE_APN__ #define FPGA_TOTAL_REGISTER_COUNT 105 #define FPGA_REG_COMMAND_A 0 #define FPGA_BIT_CMD_EXPOSE 0x0001 #define FPGA_BIT_CMD_DARK 0x0002 #define FPGA_BIT_CMD_TEST 0x0004 #define FPGA_BIT_CMD_TDI 0x0008 #define FPGA_BIT_CMD_FLUSH 0x0010 #define FPGA_BIT_CMD_TRIGGER_EXPOSE 0x0020 #define FPGA_BIT_CMD_KINETICS 0x0040 #define FPGA_BIT_CMD_GUIDE_ABORT 0x0800 #define FPGA_BIT_CMD_GUIDE_DEC_MINUS 0x1000 #define FPGA_BIT_CMD_GUIDE_DEC_PLUS 0x2000 #define FPGA_BIT_CMD_GUIDE_RA_MINUS 0x4000 #define FPGA_BIT_CMD_GUIDE_RA_PLUS 0x8000 #define FPGA_REG_COMMAND_B 1 #define FPGA_BIT_CMD_RESET 0x0002 #define FPGA_BIT_CMD_CLEAR_ALL 0x0010 #define FPGA_BIT_CMD_END_EXPOSURE 0x0080 #define FPGA_BIT_CMD_RAMP_TO_SETPOINT 0x0200 #define FPGA_BIT_CMD_RAMP_TO_AMBIENT 0x0400 #define FPGA_BIT_CMD_START_TEMP_READ 0x2000 #define FPGA_BIT_CMD_DAC_LOAD 0x4000 #define FPGA_BIT_CMD_AD_CONFIG 0x8000 #define FPGA_REG_OP_A 2 #define FPGA_BIT_LED_DISABLE 0x0001 #define FPGA_BIT_PAUSE_TIMER 0x0002 #define FPGA_BIT_RATIO 0x0004 #define FPGA_BIT_DELAY_MODE 0x0008 #define FPGA_BIT_DUAL_AD_READOUT 0x0010 #define FPGA_BIT_LED_EXPOSE_DISABLE 0x0020 #define FPGA_BIT_DISABLE_H_CLK 0x0040 #define FPGA_BIT_SHUTTER_AMP_CONTROL 0x0080 #define FPGA_BIT_HALT_DISABLE 0x0100 #define FPGA_BIT_SHUTTER_MODE 0x0200 #define FPGA_BIT_DIGITIZATION_RES 0x0400 #define FPGA_BIT_FORCE_SHUTTER 0x0800 #define FPGA_BIT_DISABLE_SHUTTER 0x1000 #define FPGA_BIT_TEMP_SUSPEND 0x2000 #define FPGA_BIT_SHUTTER_SOURCE 0x4000 #define FPGA_BIT_TEST_MODE 0x8000 #define FPGA_REG_OP_B 3 #define FPGA_BIT_AD_AVERAGING 0x0001 #define FPGA_BIT_QUAD_AD_READOUT 0x0002 #define FPGA_BIT_CONT_IMAGE_ENABLE 0x0004 #define FPGA_BIT_HCLAMP_ENABLE 0x0008 #define FPGA_BIT_HSKIP_ENABLE 0x0010 #define FPGA_BIT_HRAM_ENABLE 0x0020 #define FPGA_BIT_VRAM_ENABLE 0x0040 #define FPGA_BIT_DAC_SELECT_ZERO 0x0080 #define FPGA_BIT_DAC_SELECT_ONE 0x0100 #define FPGA_BIT_FIFO_WRITE_BLOCK 0x0200 #define FPGA_BIT_AD_LOAD_SELECT 0x0400 #define FPGA_BIT_DISABLE_FLUSH_COMMANDS 0x0800 #define FPGA_BIT_DISABLE_POST_EXP_FLUSH 0x1000 #define FPGA_BIT_AD_SIM_RATE_ZERO 0x2000 #define FPGA_BIT_AD_SIM_RATE_ONE 0x4000 #define FPGA_BIT_AD_SIMULATION 0x8000 #define FPGA_REG_TIMER_UPPER 4 #define FPGA_REG_TIMER_LOWER 5 #define FPGA_REG_HRAM_INPUT 6 #define FPGA_REG_VRAM_INPUT 7 #define FPGA_REG_HRAM_INV_MASK 8 #define FPGA_REG_VRAM_INV_MASK 9 #define FPGA_REG_HCLAMP_INPUT 10 #define FPGA_REG_HSKIP_INPUT 11 #define FPGA_REG_CLAMP_COUNT 13 #define FPGA_REG_PREROI_SKIP_COUNT 14 #define FPGA_REG_ROI_COUNT 15 #define FPGA_REG_POSTROI_SKIP_COUNT 16 #define FPGA_REG_OVERSCAN_COUNT 17 #define FPGA_REG_IMAGE_COUNT 18 #define FPGA_REG_VFLUSH_BINNING 19 #define FPGA_REG_SHUTTER_CLOSE_DELAY 20 #define FPGA_REG_POSTOVERSCAN_SKIP_COUNT 21 #define FPGA_REG_SHUTTER_STROBE_POSITION 23 #define FPGA_REG_SHUTTER_STROBE_PERIOD 24 #define FPGA_REG_FAN_SPEED_CONTROL 25 #define FPGA_REG_LED_DRIVE 26 #define FPGA_REG_SUBSTRATE_ADJUST 27 #define FPGA_MASK_FAN_SPEED_CONTROL_ALTA 0x0FFF #define FPGA_MASK_LED_ILLUMINATION_ALTA 0x0FFF #define FPGA_MASK_LED_ILLUMINATION_ASCENT 0xFFFF #define FPGA_MASK_SUBSTRATE_ADJUST_ALTA 0x0FFF #define FPGA_REG_TEST_COUNT_UPPER 28 #define FPGA_REG_TEST_COUNT_LOWER 29 #define FPGA_REG_A1_ROW_COUNT 30 #define FPGA_REG_A1_VBINNING 31 #define FPGA_REG_A2_ROW_COUNT 32 #define FPGA_REG_A2_VBINNING 33 #define FPGA_REG_A3_ROW_COUNT 34 #define FPGA_REG_A3_VBINNING 35 #define FPGA_REG_A4_ROW_COUNT 36 #define FPGA_REG_A4_VBINNING 37 #define FPGA_REG_A5_ROW_COUNT 38 #define FPGA_REG_A5_VBINNING 39 #define FPGA_MASK_VBINNING 0x0FFF #define FPGA_BIT_ARRAY_DIGITIZE 0x1000 #define FPGA_BIT_ARRAY_FASTDUMP 0x4000 #define FPGA_REG_GUIDE_RA_PLUS 40 #define FPGA_REG_GUIDE_RA_MINUS 41 #define FPGA_REG_GUIDE_DEC_PLUS 42 #define FPGA_REG_GUIDE_DEC_MINUS 43 #define FPGA_REG_TDI_BINNING 44 #define FPGA_REG_PRIMARY_AD_OFFSET 45 #define FPGA_REG_SECONDARY_AD_OFFSET 56 #define FPGA_REG_SEQUENCE_DELAY 47 #define FPGA_REG_TDI_RATE 48 #define FPGA_REG_IO_PORT_WRITE 49 #define FPGA_REG_IO_PORT_DIRECTION 50 #define FPGA_MASK_IO_PORT_DIRECTION 0x003F #define FPGA_REG_IO_PORT_ASSIGNMENT_ALTA 51 #define FPGA_MASK_IO_PORT_ASSIGNMENT_ALTA 0x003F #define FPGA_REG_LED_SELECT 52 #define FPGA_MASK_LED_SELECT_A 0x000F #define FPGA_MASK_LED_SELECT_B 0x00F0 #define FPGA_BIT_LED_EXPOSE 0x0001 #define FPGA_BIT_LED_IMAGE_ACTIVE 0x0002 #define FPGA_BIT_LED_FLUSHING 0x0004 #define FPGA_BIT_LED_TRIGGER_WAIT 0x0008 #define FPGA_BIT_LED_EXT_TRIGGER 0x0010 #define FPGA_BIT_LED_EXT_SHUTTER_INPUT 0x0020 #define FPGA_BIT_LED_EXT_START_READOUT 0x0040 #define FPGA_BIT_LED_AT_TEMP 0x0080 #define FPGA_REG_SCRATCH 53 #define FPGA_REG_TDI_COUNT 54 #define FPGA_REG_TEMP_DESIRED 55 #define FPGA_REG_IO_PORT_ASSIGNMENT_ASCENT 56 #define FPGA_MASK_IO_PORT_ASSIGNMENT_ASCENT 0x0003 #define FPGA_BIT_IO_INPUT_MODE 0x0001 #define FPGA_BIT_IO_OUTPUT_MODE 0x0002 #define FPGA_REG_TEMP_RAMP_DOWN_A 57 #define FPGA_REG_TEMP_RAMP_DOWN_B 58 #define FPGA_REG_OP_C 59 #define FPGA_BIT_TDI_TRIGGER_GROUP 0x0001 #define FPGA_BIT_TDI_TRIGGER_EACH 0x0002 #define FPGA_BIT_IMAGE_TRIGGER_EACH 0x0004 #define FPGA_BIT_IMAGE_TRIGGER_GROUP 0x0008 #define FPGA_BIT_HCLK_0 0x0010 #define FPGA_BIT_HCLK_1 0x0020 #define FPGA_BIT_HCLK_2 0x0040 #define FPGA_BIT_FILTER_1 0x0100 #define FPGA_BIT_FILTER_2 0x0200 #define FPGA_BIT_FILTER_3 0x0400 #define FPGA_BIT_GUIDE_RA_PLUS 0x1000 #define FPGA_BIT_GUIDE_RA_MINUS 0x2000 #define FPGA_BIT_GUIDE_DEC_PLUS 0x4000 #define FPGA_BIT_GUIDE_DEC_MINUS 0x8000 #define FPGA_MASK_HCLK 0x0070 #define FPGA_MASK_FILTER_POSITION 0x0700 #define FPGA_REG_TEMP_BACKOFF 60 #define FPGA_REG_TEMP_COOLER_OVERRIDE 61 #define FPGA_MASK_TEMP_PARAMS 0x0FFF // 12 bits #define FPGA_REG_AD_CONFIG_DATA 62 #define FPGA_MASK_AD_GAIN 0x07FF // 11 bits #define FPGA_REG_IO_PORT_READ 90 #define FPGA_MASK_IO_PORT_DATA 0x003F #define FPGA_REG_GENERAL_STATUS 91 #define FPGA_BIT_STATUS_IMAGE_EXPOSING 0x0001 #define FPGA_BIT_STATUS_IMAGING_ACTIVE 0x0002 #define FPGA_BIT_STATUS_DATA_HALTED 0x0004 #define FPGA_BIT_STATUS_IMAGE_DONE 0x0008 #define FPGA_BIT_STATUS_FLUSHING 0x0010 #define FPGA_BIT_STATUS_WAITING_TRIGGER 0x0020 #define FPGA_BIT_STATUS_SHUTTER_OPEN 0x0040 #define FPGA_BIT_STATUS_PATTERN_ERROR 0x0080 #define FPGA_BIT_STATUS_TEMP_SUSPEND_ACK 0x0100 #define FPGA_BIT_STATUS_GUIDE_ACTIVE 0x0400 #define FPGA_BIT_STATUS_TEMP_REVISION 0x2000 #define FPGA_BIT_STATUS_TEMP_AT_TEMP 0x4000 #define FPGA_BIT_STATUS_TEMP_ACTIVE 0x8000 #define FPGA_REG_FILTER_STATUS 92 #define FPGA_BIT_STATUS_FILTER_SENSE 0x0001 #define FPGA_REG_TEMP_HEATSINK 93 #define FPGA_REG_TEMP_CCD 94 #define FPGA_REG_TEMP_DRIVE 95 #define FPGA_REG_INPUT_VOLTAGE 96 #define FPGA_MASK_INPUT_VOLTAGE 0x0FFF #define FPGA_REG_TEMP_REVISED 97 #define FPGA_REG_FIFO_DATA 98 #define FPGA_REG_FIFO_STATUS 99 #define FPGA_REG_CAMERA_ID 100 #define FPGA_MASK_CAMERA_ID_ALTA 0x007F #define FPGA_MASK_CAMERA_ID_ASCENT 0x01FF #define FPGA_SIG_CAMERA_ID_ASCENT 0x0100 #define FPGA_REG_FIRMWARE_REV 101 #define FPGA_REG_FIFO_FULL_COUNT 102 #define FPGA_REG_FIFO_EMPTY_COUNT 103 #define FPGA_REG_TDI_COUNTER 104 #define FPGA_REG_SEQUENCE_COUNTER 105 #endif libapogee2-2.2/ApnCamData_ASCENT0402ME3.cpp0000644000175000017500000002223711110507150015500 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_ASCENT0402ME3.cpp: Implementation file for the CApnCamData_ASCENT0402ME3 class. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #include "ApnCamData_ASCENT0402ME3.h" #include #include #include ///////////////////////////////////////////////////////////// // Construction/Destruction ///////////////////////////////////////////////////////////// CApnCamData_ASCENT0402ME3::CApnCamData_ASCENT0402ME3() { } CApnCamData_ASCENT0402ME3::~CApnCamData_ASCENT0402ME3() { } void CApnCamData_ASCENT0402ME3::Initialize() { strcpy( m_Sensor, "ASCENT0402ME3" ); strcpy( m_CameraModel, "3" ); m_CameraId = 258; m_InterlineCCD = false; m_SupportsSerialA = false; m_SupportsSerialB = false; m_SensorTypeCCD = true; m_TotalColumns = 28; m_ImagingColumns = 20; m_ClampColumns = 4; m_PreRoiSkipColumns = 0; m_PostRoiSkipColumns = 0; m_OverscanColumns = 4; m_TotalRows = 28; m_ImagingRows = 20; m_UnderscanRows = 4; m_OverscanRows = 4; m_VFlushBinning = 1; m_EnableSingleRowOffset = false; m_RowOffsetBinning = 1; m_HFlushDisable = false; m_ShutterCloseDelay = 10; m_PixelSizeX = 9; m_PixelSizeY = 9; m_Color = false; m_ReportedGainSixteenBit = 1.5; m_MinSuggestedExpTime = 50.0; m_CoolingSupported = true; m_RegulatedCoolingSupported = true; m_TempSetPoint = -20.0; m_TempRampRateOne = 1200; m_TempRampRateTwo = 4000; m_TempBackoffPoint = 2.0; m_PrimaryADType = ApnAdType_Ascent_Sixteen; m_AlternativeADType = ApnAdType_None; m_DefaultGainLeft = 0; m_DefaultOffsetLeft = 100; m_DefaultGainRight = 0; m_DefaultOffsetRight = 100; m_DefaultRVoltage = 1000; m_DefaultSpeed = 0x1; m_DefaultDataReduction = true; set_vpattern(); set_hpattern_clamp_sixteen(); set_hpattern_skip_sixteen(); set_hpattern_roi_sixteen(); set_hpattern_clamp_twelve(); set_hpattern_skip_twelve(); set_hpattern_roi_twelve(); } void CApnCamData_ASCENT0402ME3::set_vpattern() { const unsigned short Mask = 0x6; const unsigned short NumElements = 71; unsigned short Pattern[NumElements] = { 0x0000, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0001, 0x0000 }; m_VerticalPattern.Mask = Mask; m_VerticalPattern.NumElements = NumElements; m_VerticalPattern.PatternData = (unsigned short *)malloc(NumElements * sizeof(unsigned short)); for ( int i=0; iMask = Mask; Pattern->BinningLimit = BinningLimit; Pattern->RefNumElements = RefNumElements; Pattern->SigNumElements = SigNumElements; if ( RefNumElements > 0 ) { Pattern->RefPatternData = (unsigned short *)malloc(RefNumElements * sizeof(unsigned short)); for ( i=0; iRefPatternData[i] = RefPatternData[i]; } } if ( SigNumElements > 0 ) { Pattern->SigPatternData = (unsigned short *)malloc(SigNumElements * sizeof(unsigned short)); for ( i=0; iSigPatternData[i] = SigPatternData[i]; } } if ( BinningLimit > 0 ) { for ( i=0; iBinNumElements[i] = BinNumElements[i]; Pattern->BinPatternData[i] = (unsigned short *)malloc(BinNumElements[i] * sizeof(unsigned short)); for ( j=0; jBinPatternData[i][j] = BinPatternData[i][j]; } } } } libapogee2-2.2/ApnSerial.cpp0000644000175000017500000000110111110507150013540 0ustar jrjr// ApnSerial.cpp: implementation of the CApnSerial class. // ////////////////////////////////////////////////////////////////////// #include "stdafx.h" #include "ApnSerial.h" #ifdef _DEBUG #undef THIS_FILE static char THIS_FILE[]=__FILE__; #define new DEBUG_NEW #endif ////////////////////////////////////////////////////////////////////// // Construction/Destruction ////////////////////////////////////////////////////////////////////// CApnSerial::CApnSerial() { m_SerialId = -1; m_BytesRead = 0; } CApnSerial::~CApnSerial() { } libapogee2-2.2/ApnCamData_KAI2020ML.h0000644000175000017500000000220611110507150014510 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_KAI2020ML.h: Interface file for the CApnCamData_KAI2020ML class. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #if _MSC_VER > 1000 #pragma once #endif // _MSC_VER> 1000 #include "ApnCamData.h" class CApnCamData_KAI2020ML : public CApnCamData { public: CApnCamData_KAI2020ML(); virtual ~CApnCamData_KAI2020ML(); void Initialize(); private: void set_vpattern(); void set_hpattern_clamp_sixteen(); void set_hpattern_skip_sixteen(); void set_hpattern_roi_sixteen(); void set_hpattern_clamp_twelve(); void set_hpattern_skip_twelve(); void set_hpattern_roi_twelve(); void set_hpattern( APN_HPATTERN_FILE *Pattern, unsigned short Mask, unsigned short BinningLimit, unsigned short RefNumElements, unsigned short SigNumElements, unsigned short BinNumElements[], unsigned short RefPatternData[], unsigned short SigPatternData[], unsigned short BinPatternData[][APN_MAX_PATTERN_ENTRIES] ); }; libapogee2-2.2/ApnCamData_CCD5520B.h0000644000175000017500000000220111110507150014351 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_CCD5520B.h: Interface file for the CApnCamData_CCD5520B class. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #if _MSC_VER > 1000 #pragma once #endif // _MSC_VER> 1000 #include "ApnCamData.h" class CApnCamData_CCD5520B : public CApnCamData { public: CApnCamData_CCD5520B(); virtual ~CApnCamData_CCD5520B(); void Initialize(); private: void set_vpattern(); void set_hpattern_clamp_sixteen(); void set_hpattern_skip_sixteen(); void set_hpattern_roi_sixteen(); void set_hpattern_clamp_twelve(); void set_hpattern_skip_twelve(); void set_hpattern_roi_twelve(); void set_hpattern( APN_HPATTERN_FILE *Pattern, unsigned short Mask, unsigned short BinningLimit, unsigned short RefNumElements, unsigned short SigNumElements, unsigned short BinNumElements[], unsigned short RefPatternData[], unsigned short SigPatternData[], unsigned short BinPatternData[][APN_MAX_PATTERN_ENTRIES] ); }; libapogee2-2.2/ApnCamData_S101401109.h0000644000175000017500000000221311110507150014450 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_S101401109.h: Interface file for the CApnCamData_S101401109 class. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #if _MSC_VER > 1000 #pragma once #endif // _MSC_VER> 1000 #include "ApnCamData.h" class CApnCamData_S101401109 : public CApnCamData { public: CApnCamData_S101401109(); virtual ~CApnCamData_S101401109(); void Initialize(); private: void set_vpattern(); void set_hpattern_clamp_sixteen(); void set_hpattern_skip_sixteen(); void set_hpattern_roi_sixteen(); void set_hpattern_clamp_twelve(); void set_hpattern_skip_twelve(); void set_hpattern_roi_twelve(); void set_hpattern( APN_HPATTERN_FILE *Pattern, unsigned short Mask, unsigned short BinningLimit, unsigned short RefNumElements, unsigned short SigNumElements, unsigned short BinNumElements[], unsigned short RefPatternData[], unsigned short SigPatternData[], unsigned short BinPatternData[][APN_MAX_PATTERN_ENTRIES] ); }; libapogee2-2.2/ApnCamData_KAF3200E.cpp0000644000175000017500000006050411110507150014722 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_KAF3200E.cpp: Implementation file for the CApnCamData_KAF3200E class. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #include "ApnCamData_KAF3200E.h" #include #include #include ///////////////////////////////////////////////////////////// // Construction/Destruction ///////////////////////////////////////////////////////////// CApnCamData_KAF3200E::CApnCamData_KAF3200E() { } CApnCamData_KAF3200E::~CApnCamData_KAF3200E() { } void CApnCamData_KAF3200E::Initialize() { strcpy( m_Sensor, "KAF3200E" ); strcpy( m_CameraModel, "32" ); m_CameraId = 6; m_InterlineCCD = false; m_SupportsSerialA = true; m_SupportsSerialB = true; m_SensorTypeCCD = true; m_TotalColumns = 2267; m_ImagingColumns = 2184; m_ClampColumns = 46; m_PreRoiSkipColumns = 0; m_PostRoiSkipColumns = 0; m_OverscanColumns = 37; m_TotalRows = 1510; m_ImagingRows = 1472; m_UnderscanRows = 34; m_OverscanRows = 4; m_VFlushBinning = 1; m_EnableSingleRowOffset = false; m_RowOffsetBinning = 1; m_HFlushDisable = false; m_ShutterCloseDelay = 100; m_PixelSizeX = 6.8; m_PixelSizeY = 6.8; m_Color = false; m_ReportedGainSixteenBit = 1; m_MinSuggestedExpTime = 10.0; m_CoolingSupported = true; m_RegulatedCoolingSupported = true; m_TempSetPoint = -20.0; m_TempRampRateOne = 700; m_TempRampRateTwo = 4000; m_TempBackoffPoint = 2.0; m_PrimaryADType = ApnAdType_Alta_Sixteen; m_AlternativeADType = ApnAdType_Alta_Twelve; m_DefaultGainLeft = 100; m_DefaultOffsetLeft = 100; m_DefaultGainRight = -1; m_DefaultOffsetRight = -1; m_DefaultRVoltage = 1000; m_DefaultSpeed = 0xffff; m_DefaultDataReduction = false; set_vpattern(); set_hpattern_clamp_sixteen(); set_hpattern_skip_sixteen(); set_hpattern_roi_sixteen(); set_hpattern_clamp_twelve(); set_hpattern_skip_twelve(); set_hpattern_roi_twelve(); } void CApnCamData_KAF3200E::set_vpattern() { const unsigned short Mask = 0x0; const unsigned short NumElements = 39; unsigned short Pattern[NumElements] = { 0x0000, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0204, 0x0204, 0x0204, 0x0204, 0x0204, 0x0204, 0x0204, 0x0204, 0x0204, 0x0204, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0001, 0x0000 }; m_VerticalPattern.Mask = Mask; m_VerticalPattern.NumElements = NumElements; m_VerticalPattern.PatternData = (unsigned short *)malloc(NumElements * sizeof(unsigned short)); for ( int i=0; iMask = Mask; Pattern->BinningLimit = BinningLimit; Pattern->RefNumElements = RefNumElements; Pattern->SigNumElements = SigNumElements; if ( RefNumElements > 0 ) { Pattern->RefPatternData = (unsigned short *)malloc(RefNumElements * sizeof(unsigned short)); for ( i=0; iRefPatternData[i] = RefPatternData[i]; } } if ( SigNumElements > 0 ) { Pattern->SigPatternData = (unsigned short *)malloc(SigNumElements * sizeof(unsigned short)); for ( i=0; iSigPatternData[i] = SigPatternData[i]; } } if ( BinningLimit > 0 ) { for ( i=0; iBinNumElements[i] = BinNumElements[i]; Pattern->BinPatternData[i] = (unsigned short *)malloc(BinNumElements[i] * sizeof(unsigned short)); for ( j=0; jBinPatternData[i][j] = BinPatternData[i][j]; } } } } libapogee2-2.2/testnet.cpp0000644000175000017500000000220511110507150013356 0ustar jrjr#include "stdafx.h" #include "ApogeeNet.h" #include "ApogeeNetErr.h" #define HINTERNET int #ifdef __cplusplus extern "C" { #endif extern int InternetOpen( char *iname, int itype, int *dum, int *dum2, int dum3); extern int InternetOpenUrl( int g_hSession, char *url, int *dum1, int *dum2, int dum3, int dum4 ); extern void InternetQueryDataAvailable(int handle, long *bcount, int dum1, int dum2); extern void InternetReadFile(int handle, char *lpBuffer, long bcount, long *bread); extern void InternetCloseHandle( int handle ); #ifdef __cplusplus } #endif int main(int argc, char **argv) { int i,h; DWORD dwBytesAvailable, dwBytesRead; HINTERNET hService; int RetLength; char *lpBuffer; i = InternetOpen( "ApogeeNet", 0, NULL, NULL, 0 ); h = InternetOpenUrl( i, "http://www.randomfactory.com/" , NULL, 0, 0, 0 ); InternetQueryDataAvailable(h, &dwBytesAvailable, 0, 0); lpBuffer = (char *)malloc(dwBytesAvailable+1); InternetReadFile(h, lpBuffer, dwBytesAvailable, &dwBytesRead); lpBuffer[dwBytesRead] = 0; RetLength = strlen( SESSION_OPEN_RETVAL ); free( lpBuffer ); InternetCloseHandle( h ); } libapogee2-2.2/ApnCamData_KAF0401E.h0000644000175000017500000000220111110507150014355 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_KAF0401E.h: Interface file for the CApnCamData_KAF0401E class. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #if _MSC_VER > 1000 #pragma once #endif // _MSC_VER> 1000 #include "ApnCamData.h" class CApnCamData_KAF0401E : public CApnCamData { public: CApnCamData_KAF0401E(); virtual ~CApnCamData_KAF0401E(); void Initialize(); private: void set_vpattern(); void set_hpattern_clamp_sixteen(); void set_hpattern_skip_sixteen(); void set_hpattern_roi_sixteen(); void set_hpattern_clamp_twelve(); void set_hpattern_skip_twelve(); void set_hpattern_roi_twelve(); void set_hpattern( APN_HPATTERN_FILE *Pattern, unsigned short Mask, unsigned short BinningLimit, unsigned short RefNumElements, unsigned short SigNumElements, unsigned short BinNumElements[], unsigned short RefPatternData[], unsigned short SigPatternData[], unsigned short BinPatternData[][APN_MAX_PATTERN_ENTRIES] ); }; libapogee2-2.2/ApnCamData_CCD4720B.cpp0000644000175000017500000004235011110507150014716 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_CCD4720B.cpp: Implementation file for the CApnCamData_CCD4720B class. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #include "ApnCamData_CCD4720B.h" #include #include #include ///////////////////////////////////////////////////////////// // Construction/Destruction ///////////////////////////////////////////////////////////// CApnCamData_CCD4720B::CApnCamData_CCD4720B() { } CApnCamData_CCD4720B::~CApnCamData_CCD4720B() { } void CApnCamData_CCD4720B::Initialize() { strcpy( m_Sensor, "CCD4720B" ); strcpy( m_CameraModel, "4720" ); m_CameraId = 21; m_InterlineCCD = false; m_SupportsSerialA = true; m_SupportsSerialB = true; m_SensorTypeCCD = true; m_TotalColumns = 1072; m_ImagingColumns = 1024; m_ClampColumns = 24; m_PreRoiSkipColumns = 0; m_PostRoiSkipColumns = 0; m_OverscanColumns = 24; m_TotalRows = 2058; m_ImagingRows = 1024; m_UnderscanRows = 1033; m_OverscanRows = 1; m_VFlushBinning = 1; m_EnableSingleRowOffset = true; m_RowOffsetBinning = 1033; m_HFlushDisable = false; m_ShutterCloseDelay = 0; m_PixelSizeX = 13; m_PixelSizeY = 13; m_Color = false; m_ReportedGainSixteenBit = 2; m_MinSuggestedExpTime = 1.0; m_CoolingSupported = true; m_RegulatedCoolingSupported = true; m_TempSetPoint = -20.0; m_TempRampRateOne = 700; m_TempRampRateTwo = 4000; m_TempBackoffPoint = 2.0; m_PrimaryADType = ApnAdType_Alta_Sixteen; m_AlternativeADType = ApnAdType_Alta_Twelve; m_DefaultGainLeft = 400; m_DefaultOffsetLeft = 200; m_DefaultGainRight = -1; m_DefaultOffsetRight = -1; m_DefaultRVoltage = 1000; m_DefaultSpeed = 0xffff; m_DefaultDataReduction = false; set_vpattern(); set_hpattern_clamp_sixteen(); set_hpattern_skip_sixteen(); set_hpattern_roi_sixteen(); set_hpattern_clamp_twelve(); set_hpattern_skip_twelve(); set_hpattern_roi_twelve(); } void CApnCamData_CCD4720B::set_vpattern() { const unsigned short Mask = 0xE; const unsigned short NumElements = 129; unsigned short Pattern[NumElements] = { 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0001, 0x0000 }; m_VerticalPattern.Mask = Mask; m_VerticalPattern.NumElements = NumElements; m_VerticalPattern.PatternData = (unsigned short *)malloc(NumElements * sizeof(unsigned short)); for ( int i=0; iMask = Mask; Pattern->BinningLimit = BinningLimit; Pattern->RefNumElements = RefNumElements; Pattern->SigNumElements = SigNumElements; if ( RefNumElements > 0 ) { Pattern->RefPatternData = (unsigned short *)malloc(RefNumElements * sizeof(unsigned short)); for ( i=0; iRefPatternData[i] = RefPatternData[i]; } } if ( SigNumElements > 0 ) { Pattern->SigPatternData = (unsigned short *)malloc(SigNumElements * sizeof(unsigned short)); for ( i=0; iSigPatternData[i] = SigPatternData[i]; } } if ( BinningLimit > 0 ) { for ( i=0; iBinNumElements[i] = BinNumElements[i]; Pattern->BinPatternData[i] = (unsigned short *)malloc(BinNumElements[i] * sizeof(unsigned short)); for ( j=0; jBinPatternData[i][j] = BinPatternData[i][j]; } } } } libapogee2-2.2/ApnCamData_CCD3011B.h0000644000175000017500000000220111110507150014342 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_CCD3011B.h: Interface file for the CApnCamData_CCD3011B class. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #if _MSC_VER > 1000 #pragma once #endif // _MSC_VER> 1000 #include "ApnCamData.h" class CApnCamData_CCD3011B : public CApnCamData { public: CApnCamData_CCD3011B(); virtual ~CApnCamData_CCD3011B(); void Initialize(); private: void set_vpattern(); void set_hpattern_clamp_sixteen(); void set_hpattern_skip_sixteen(); void set_hpattern_roi_sixteen(); void set_hpattern_clamp_twelve(); void set_hpattern_skip_twelve(); void set_hpattern_roi_twelve(); void set_hpattern( APN_HPATTERN_FILE *Pattern, unsigned short Mask, unsigned short BinningLimit, unsigned short RefNumElements, unsigned short SigNumElements, unsigned short BinNumElements[], unsigned short RefPatternData[], unsigned short SigPatternData[], unsigned short BinPatternData[][APN_MAX_PATTERN_ENTRIES] ); }; libapogee2-2.2/ApnCamera_USB.h0000644000175000017500000000711111110507150013676 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamera_USB.h: Interface file for the CApnCamera_USB class. // // Copyright (c) 2003, 2004 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #if !defined(AFX_APNCAMERA_USB_H__E83248CA_F0AA_4221_8E10_22FA70CEFAA6__INCLUDED_) #define AFX_APNCAMERA_USB_H__E83248CA_F0AA_4221_8E10_22FA70CEFAA6__INCLUDED_ #if _MSC_VER > 1000 #pragma once #endif // _MSC_VER > 1000 #include "ApnCamera.h" class CApnCamera_USB : public CApnCamera { private: bool m_pvtConnectionOpen; double m_SysDriverVersion; // unsigned long m_CamIdA; unsigned short m_CamIdB; unsigned long m_Option; /* moved to ApnCamera.h unsigned short m_pvtVendorId; unsigned short m_pvtProductId; unsigned short m_pvtDeviceId; bool m_pvtUseAdvancedStatus; Apn_CameraMode m_pvtExposeCameraMode; unsigned short m_pvtExposeBitsPerPixel; unsigned short m_pvtExposeHBinning; bool m_pvtExposeDualReadout; bool m_pvtExposeSequenceBulkDownload; bool m_pvtExposeCI; unsigned short m_pvtExposeWidth; unsigned short m_pvtExposeHeight; bool m_pvtExposeExternalShutter; unsigned short m_pvtNumImages; unsigned short m_pvtSequenceImagesDownloaded; unsigned short m_pvtTdiLinesDownloaded; unsigned short m_pvtMostRecentFrame; unsigned short m_pvtReadyFrame; unsigned short m_pvtCurrentFrame; unsigned long m_SysImgSizeBytes; char m_SysDeviceName[1024]; */ public: CApnCamera_USB(); virtual ~CApnCamera_USB(); bool GetDeviceHandle( void *hCamera, char *CameraInfo ); bool InitDriver( unsigned long CamIdA, unsigned short CamIdB, unsigned long Option ); bool SimpleInitDriver( unsigned long CamIdA, unsigned short CamIdB, unsigned long Option ); Apn_Interface GetCameraInterface(); long GetCameraSerialNumber( char *CameraSerialNumber, long *BufferLength ); long GetSystemDriverVersion( char *SystemDriverVersion, long *BufferLength ); long GetUsb8051FirmwareRev( char *FirmwareRev, long *BufferLength ); long GetUsbProductId( unsigned short *pProductId ); long GetUsbDeviceId( unsigned short *pDeviceId ); bool CloseDriver(); long PreStartExpose( unsigned short BitsPerPixel ); long PostStopExposure( bool DigitizeData ); long GetImageData( unsigned short *pImageData, unsigned short &Width, unsigned short &Height, unsigned long &Count ); long GetLineData( unsigned short *pLineBuffer, unsigned short &Size ); long Read( unsigned short reg, unsigned short& val ); long Write( unsigned short reg, unsigned short val ); long WriteMultiSRMD( unsigned short reg, unsigned short val[], unsigned short count ); long WriteMultiMRMD( unsigned short reg[], unsigned short val[], unsigned short count ); long QueryStatusRegs( unsigned short& StatusReg, unsigned short& HeatsinkTempReg, unsigned short& CcdTempReg, unsigned short& CoolerDriveReg, unsigned short& VoltageReg, unsigned short& TdiCounter, unsigned short& SequenceCounter, unsigned short& MostRecentFrame, unsigned short& ReadyFrame, unsigned short& CurrentFrame ); }; #endif // !defined(AFX_APNCAMERA_USB_H__E83248CA_F0AA_4221_8E10_22FA70CEFAA6__INCLUDED_) libapogee2-2.2/ApnCamData_KAF3200E.h0000644000175000017500000000220111110507150014355 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_KAF3200E.h: Interface file for the CApnCamData_KAF3200E class. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #if _MSC_VER > 1000 #pragma once #endif // _MSC_VER> 1000 #include "ApnCamData.h" class CApnCamData_KAF3200E : public CApnCamData { public: CApnCamData_KAF3200E(); virtual ~CApnCamData_KAF3200E(); void Initialize(); private: void set_vpattern(); void set_hpattern_clamp_sixteen(); void set_hpattern_skip_sixteen(); void set_hpattern_roi_sixteen(); void set_hpattern_clamp_twelve(); void set_hpattern_skip_twelve(); void set_hpattern_roi_twelve(); void set_hpattern( APN_HPATTERN_FILE *Pattern, unsigned short Mask, unsigned short BinningLimit, unsigned short RefNumElements, unsigned short SigNumElements, unsigned short BinNumElements[], unsigned short RefPatternData[], unsigned short SigPatternData[], unsigned short BinPatternData[][APN_MAX_PATTERN_ENTRIES] ); }; libapogee2-2.2/cmake_modules/0000755000175000017500000000000011110507150013775 5ustar jrjrlibapogee2-2.2/cmake_modules/MacroOptionalFindPackage.cmake0000644000175000017500000000205211110507150021622 0ustar jrjr# - MACRO_OPTIONAL_FIND_PACKAGE() combines FIND_PACKAGE() with an OPTION() # MACRO_OPTIONAL_FIND_PACKAGE( [QUIT] ) # This macro is a combination of OPTION() and FIND_PACKAGE(), it # works like FIND_PACKAGE(), but additionally it automatically creates # an option name WITH_, which can be disabled via the cmake GUI. # or via -DWITH_=OFF # The standard _FOUND variables can be used in the same way # as when using the normal FIND_PACKAGE() # Copyright (c) 2006, Alexander Neundorf, # # Redistribution and use is allowed according to the terms of the BSD license. # For details see the accompanying COPYING-CMAKE-SCRIPTS file. MACRO (MACRO_OPTIONAL_FIND_PACKAGE _name ) OPTION(WITH_${_name} "Search for ${_name} package" ON) if (WITH_${_name}) FIND_PACKAGE(${_name} ${ARGN}) else (WITH_${_name}) set(${_name}_FOUND) set(${_name}_INCLUDE_DIR) set(${_name}_INCLUDES) set(${_name}_LIBRARY) set(${_name}_LIBRARIES) endif (WITH_${_name}) ENDMACRO (MACRO_OPTIONAL_FIND_PACKAGE) libapogee2-2.2/cmake_modules/MacroBoolTo01.cmake0000644000175000017500000000121311110507150017315 0ustar jrjr# MACRO_BOOL_TO_01( VAR RESULT0 ... RESULTN ) # This macro evaluates its first argument # and sets all the given vaiables either to 0 or 1 # depending on the value of the first one # Copyright (c) 2006, Alexander Neundorf, # # Redistribution and use is allowed according to the terms of the BSD license. # For details see the accompanying COPYING-CMAKE-SCRIPTS file. MACRO(MACRO_BOOL_TO_01 FOUND_VAR ) FOREACH (_current_VAR ${ARGN}) IF(${FOUND_VAR}) SET(${_current_VAR} 1) ELSE(${FOUND_VAR}) SET(${_current_VAR} 0) ENDIF(${FOUND_VAR}) ENDFOREACH(_current_VAR) ENDMACRO(MACRO_BOOL_TO_01) libapogee2-2.2/cmake_modules/FindUSB.cmake0000644000175000017500000000271311110507150016234 0ustar jrjr# - Try to find LIBUSB # Once done this will define # # LIBUSB_FOUND - system has LIBUSB # LIBUSB_INCLUDE_DIR - the LIBUSB include directory # LIBUSB_LIBRARIES - Link these to use LIBUSB # Copyright (c) 2006, Jasem Mutlaq # Based on FindLibfacile by Carsten Niehaus, # # Redistribution and use is allowed according to the terms of the BSD license. # For details see the accompanying COPYING-CMAKE-SCRIPTS file. if (LIBUSB_INCLUDE_DIR AND LIBUSB_LIBRARIES) # in cache already set(LIBUSB_FOUND TRUE) message(STATUS "Found LIBUSB: ${LIBUSB_LIBRARIES}") else (LIBUSB_INCLUDE_DIR AND LIBUSB_LIBRARIES) find_path(LIBUSB_INCLUDE_DIR usb.h ${_obIncDir} ${GNUWIN32_DIR}/include ) find_library(LIBUSB_LIBRARIES NAMES usb PATHS ${_obLinkDir} ${GNUWIN32_DIR}/lib ) if(LIBUSB_INCLUDE_DIR AND LIBUSB_LIBRARIES) set(LIBUSB_FOUND TRUE) else (LIBUSB_INCLUDE_DIR AND LIBUSB_LIBRARIES) set(LIBUSB_FOUND FALSE) endif(LIBUSB_INCLUDE_DIR AND LIBUSB_LIBRARIES) if (LIBUSB_FOUND) if (NOT USB_FIND_QUIETLY) message(STATUS "Found LIBUSB: ${LIBUSB_LIBRARIES}") endif (NOT USB_FIND_QUIETLY) else (LIBUSB_FOUND) if (USB_FIND_REQUIRED) message(FATAL_ERROR "LIBUSB not found. Please install libusb-devel and try again.") endif (USB_FIND_REQUIRED) endif (LIBUSB_FOUND) mark_as_advanced(LIBUSB_INCLUDE_DIR LIBUSB_LIBRARIES) endif (LIBUSB_INCLUDE_DIR AND LIBUSB_LIBRARIES) libapogee2-2.2/cmake_modules/MacroLogFeature.cmake0000644000175000017500000001157711110507150020031 0ustar jrjr# This file defines the Feature Logging macros. # # MACRO_LOG_FEATURE(VAR FEATURE DESCRIPTION URL [REQUIRED [MIN_VERSION [COMMENTS]]]) # Logs the information so that it can be displayed at the end # of the configure run # VAR : TRUE or FALSE, indicating whether the feature is supported # FEATURE: name of the feature, e.g. "libjpeg" # DESCRIPTION: description what this feature provides # URL: home page # REQUIRED: TRUE or FALSE, indicating whether the featue is required # MIN_VERSION: minimum version number. empty string if unneeded # COMMENTS: More info you may want to provide. empty string if unnecessary # # MACRO_DISPLAY_FEATURE_LOG() # Call this to display the collected results. # Exits CMake with a FATAL error message if a required feature is missing # # Example: # # INCLUDE(MacroLogFeature) # # FIND_PACKAGE(JPEG) # MACRO_LOG_FEATURE(JPEG_FOUND "libjpeg" "Support JPEG images" "http://www.ijg.org" TRUE "3.2a" "") # ... # MACRO_DISPLAY_FEATURE_LOG() # Copyright (c) 2006, Alexander Neundorf, # Copyright (c) 2006, Allen Winter, # # Redistribution and use is allowed according to the terms of the BSD license. # For details see the accompanying COPYING-CMAKE-SCRIPTS file. IF (NOT _macroLogFeatureAlreadyIncluded) SET(_file ${CMAKE_BINARY_DIR}/MissingRequirements.txt) IF (EXISTS ${_file}) FILE(REMOVE ${_file}) ENDIF (EXISTS ${_file}) SET(_file ${CMAKE_BINARY_DIR}/EnabledFeatures.txt) IF (EXISTS ${_file}) FILE(REMOVE ${_file}) ENDIF (EXISTS ${_file}) SET(_file ${CMAKE_BINARY_DIR}/DisabledFeatures.txt) IF (EXISTS ${_file}) FILE(REMOVE ${_file}) ENDIF (EXISTS ${_file}) SET(_macroLogFeatureAlreadyIncluded TRUE) ENDIF (NOT _macroLogFeatureAlreadyIncluded) MACRO(MACRO_LOG_FEATURE _var _package _description _url ) # _required _minvers _comments) SET(_required "${ARGV4}") SET(_minvers "${ARGV5}") SET(_comments "${ARGV6}") IF (${_var}) SET(_LOGFILENAME ${CMAKE_BINARY_DIR}/EnabledFeatures.txt) ELSE (${_var}) IF (${_required} MATCHES "[Tt][Rr][Uu][Ee]") SET(_LOGFILENAME ${CMAKE_BINARY_DIR}/MissingRequirements.txt) ELSE (${_required} MATCHES "[Tt][Rr][Uu][Ee]") SET(_LOGFILENAME ${CMAKE_BINARY_DIR}/DisabledFeatures.txt) ENDIF (${_required} MATCHES "[Tt][Rr][Uu][Ee]") ENDIF (${_var}) SET(_logtext "+ ${_package}") IF (NOT ${_var}) IF (${_minvers} MATCHES ".*") SET(_logtext "${_logtext}, ${_minvers}") ENDIF (${_minvers} MATCHES ".*") SET(_logtext "${_logtext}: ${_description} <${_url}>") IF (${_comments} MATCHES ".*") SET(_logtext "${_logtext}\n${_comments}") ENDIF (${_comments} MATCHES ".*") # SET(_logtext "${_logtext}\n") #double-space missing features? ENDIF (NOT ${_var}) FILE(APPEND "${_LOGFILENAME}" "${_logtext}\n") ENDMACRO(MACRO_LOG_FEATURE) MACRO(MACRO_DISPLAY_FEATURE_LOG) SET(_file ${CMAKE_BINARY_DIR}/MissingRequirements.txt) IF (EXISTS ${_file}) FILE(READ ${_file} _requirements) MESSAGE(STATUS "\n-----------------------------------------------------------------------------\n-- The following REQUIRED packages could NOT be located on your system.\n-- Please install them before continuing this software installation.\n-----------------------------------------------------------------------------\n${_requirements}-----------------------------------------------------------------------------") FILE(REMOVE ${_file}) MESSAGE(FATAL_ERROR "Exiting: Missing Requirements") ENDIF (EXISTS ${_file}) SET(_summary "\n") SET(_elist 0) SET(_file ${CMAKE_BINARY_DIR}/EnabledFeatures.txt) IF (EXISTS ${_file}) SET(_elist 1) FILE(READ ${_file} _enabled) FILE(REMOVE ${_file}) SET(_summary "${_summary}-----------------------------------------------------------------------------\n-- The following external packages were located on your system.\n-- This installation will have the extra features provided by these packages.\n${_enabled}") ENDIF (EXISTS ${_file}) SET(_dlist 0) SET(_file ${CMAKE_BINARY_DIR}/DisabledFeatures.txt) IF (EXISTS ${_file}) SET(_dlist 1) FILE(READ ${_file} _disabled) FILE(REMOVE ${_file}) SET(_summary "${_summary}-----------------------------------------------------------------------------\n-- The following OPTIONAL packages could NOT be located on your system.\n-- Consider installing them to enable more features from this software.\n${_disabled}") ELSE (EXISTS ${_file}) IF (${_elist}) SET(_summary "${_summary}Congratulations! All external packages have been found.\n") ENDIF (${_elist}) ENDIF (EXISTS ${_file}) IF (${_elist} OR ${_dlist}) SET(_summary "${_summary}-----------------------------------------------------------------------------\n") ENDIF (${_elist} OR ${_dlist}) MESSAGE(STATUS "${_summary}") ENDMACRO(MACRO_DISPLAY_FEATURE_LOG) libapogee2-2.2/ApnCamData_KAI11000M.cpp0000644000175000017500000006010411110507150015006 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_KAI11000M.cpp: Implementation file for the CApnCamData_KAI11000M class. // // Copyright (c) 2003, 2004 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #include "ApnCamData_KAI11000M.h" #include #include #include ///////////////////////////////////////////////////////////// // Construction/Destruction ///////////////////////////////////////////////////////////// CApnCamData_KAI11000M::CApnCamData_KAI11000M() { } CApnCamData_KAI11000M::~CApnCamData_KAI11000M() { } void CApnCamData_KAI11000M::Initialize() { strcpy( m_Sensor, "KAI11000M" ); strcpy( m_CameraModel, "11000m" ); m_CameraId = 83; m_InterlineCCD = true; m_SupportsSerialA = true; m_SupportsSerialB = true; m_SensorTypeCCD = true; m_TotalColumns = 4080; m_ImagingColumns = 4008; m_ClampColumns = 36; m_PreRoiSkipColumns = 0; m_PostRoiSkipColumns = 0; m_OverscanColumns = 36; m_TotalRows = 2720; m_ImagingRows = 2672; m_UnderscanRows = 24; m_OverscanRows = 24; m_VFlushBinning = 1; m_EnableSingleRowOffset = false; m_RowOffsetBinning = 1; m_HFlushDisable = false; m_ShutterCloseDelay = 0; m_PixelSizeX = 9; m_PixelSizeY = 9; m_Color = false; m_ReportedGainSixteenBit = 1; m_MinSuggestedExpTime = 0.05; m_CoolingSupported = true; m_RegulatedCoolingSupported = true; m_TempSetPoint = -20.0; m_TempRampRateOne = 700; m_TempRampRateTwo = 4000; m_TempBackoffPoint = 2.0; m_PrimaryADType = ApnAdType_Alta_Sixteen; m_AlternativeADType = ApnAdType_Alta_Twelve; //m_DefaultGainTwelveBit = 150; //m_DefaultOffsetTwelveBit = 100; m_DefaultRVoltage = 1000; set_vpattern(); set_hpattern_clamp_sixteen(); set_hpattern_skip_sixteen(); set_hpattern_roi_sixteen(); set_hpattern_clamp_twelve(); set_hpattern_skip_twelve(); set_hpattern_roi_twelve(); } void CApnCamData_KAI11000M::set_vpattern() { const unsigned short Mask = 0x106; const unsigned short NumElements = 38; unsigned short Pattern[NumElements] = { 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0302, 0x0302, 0x0302, 0x0302, 0x0302, 0x0302, 0x0302, 0x0302, 0x0302, 0x0302, 0x0002, 0x0002, 0x0002, 0x0003, 0x0002 }; m_VerticalPattern.Mask = Mask; m_VerticalPattern.NumElements = NumElements; m_VerticalPattern.PatternData = (unsigned short *)malloc(NumElements * sizeof(unsigned short)); for ( int i=0; iMask = Mask; Pattern->BinningLimit = BinningLimit; Pattern->RefNumElements = RefNumElements; Pattern->SigNumElements = SigNumElements; if ( RefNumElements > 0 ) { Pattern->RefPatternData = (unsigned short *)malloc(RefNumElements * sizeof(unsigned short)); for ( i=0; iRefPatternData[i] = RefPatternData[i]; } } if ( SigNumElements > 0 ) { Pattern->SigPatternData = (unsigned short *)malloc(SigNumElements * sizeof(unsigned short)); for ( i=0; iSigPatternData[i] = SigPatternData[i]; } } if ( BinningLimit > 0 ) { for ( i=0; iBinNumElements[i] = BinNumElements[i]; Pattern->BinPatternData[i] = (unsigned short *)malloc(BinNumElements[i] * sizeof(unsigned short)); for ( j=0; jBinPatternData[i][j] = BinPatternData[i][j]; } } } } libapogee2-2.2/Camera_Example.cpp0000644000175000017500000004244211110507150014542 0ustar jrjr// Example source code for implementing the CCameraIO object #include "windows.h" #include "stdio.h" #include "CameraIO.h" #include "CameraIO_ISA_9x.h" #include "CameraIO_PPI_9x.h" #include "CameraIO_ISA_NT.h" #include "CameraIO_PPI_NT.h" #include "CameraIO_PCI.h" // Error codes returned from config_load const long CCD_OPEN_NOERR = 0; // No error detected const long CCD_OPEN_CFGNAME = 1; // No config file specified const long CCD_OPEN_CFGDATA = 2; // Config missing or missing required data const long CCD_OPEN_LOOPTST = 3; // Loopback test failed, no camera found const long CCD_OPEN_ALLOC = 4; // Memory alloc failed - system error const long CCD_OPEN_NTIO = 5; // NT I/O driver not present CCameraIO* cam; // the Camera interface object // Function declarations for this file int InitCam( char* cfgname ); long config_load( char* cfgname, short BaseAddress, short RegOffset ); bool CfgGet ( FILE* inifp, char* inisect, char* iniparm, char* retbuff, short bufflen, short* parmlen); unsigned short hextoi(char* instr); void trimstr(char* s); // Initializes the CameraIO object from an INI file specified by cfgname int InitCam( char* cfgname ) { long ret = config_load( cfgname, -1, -1 ); if ( ret == 0 ) { // We can now access the cam objects members cam->Flush(); // Start the camera flushing return 0; } else { switch ( ret ) { case CCD_OPEN_CFGNAME: // "No config file specified." break; case CCD_OPEN_CFGDATA: // "Config file missing or missing required data." break; case CCD_OPEN_LOOPTST: // "Loopback test failed, no camera found" break; case CCD_OPEN_ALLOC: // "Memory allocation failed - system error" break; case CCD_OPEN_NTIO: // "NT I/O driver not present" break; } return ret; } } // Convert a string to a decimal or hexadecimal integer unsigned short hextoi(char *instr) { unsigned short val, tot = 0; bool IsHEX = false; long n = strlen( instr ); if ( n > 1 ) { // Look for hex format e.g. 8Fh, A3H or 0x5D if ( instr[ n - 1 ] == 'h' || instr[ n - 1 ] == 'H' ) IsHEX = true; else if ( *instr == '0' && *(instr+1) == 'x' ) { IsHEX = true; instr += 2; } } if ( IsHEX ) { while (instr && *instr && isxdigit(*instr)) { val = *instr++ - '0'; if (9 < val) val -= 7; tot <<= 4; tot |= (val & 0x0f); } } else tot = atoi( instr ); return tot; } // Trim trailing spaces from a string void trimstr(char *s) { char *p; p = s + (strlen(s) - 1); while (isspace(*p)) p--; *(++p) = '\0'; } //------------------------------------------------------------- // CfgGet // // Retrieve a parameter from an INI file. Returns a status code // and the paramter string in retbuff. //------------------------------------------------------------- bool CfgGet ( FILE* inifp, char *inisect, char *iniparm, char *retbuff, short bufflen, short *parmlen) { short gotsect; char tbuf[256]; char *ss, *eq, *ps, *vs, *ptr; rewind( inifp ); // find the target section gotsect = 0; while (fgets(tbuf,256,inifp) != NULL) { if ((ss = strchr(tbuf,'[')) != NULL) { if (strnicmp(ss+1,inisect,strlen(inisect)) == 0) { gotsect = 1; break; } } } if (!gotsect) { // section not found return false; } while (fgets(tbuf,256,inifp) != NULL) { // find parameter in sect if ((ptr = strrchr(tbuf,'\n')) != NULL) // remove newline if there *ptr = '\0'; ps = tbuf+strspn(tbuf," \t"); // find the first non-blank if (*ps == ';') // Skip line if comment continue; if (*ps == '[') { // Start of next section return false; } eq = strchr(ps,'='); // Find '=' sign in string if (eq) vs = eq + 1 + strspn(eq+1," \t"); // Find start of value str else continue; // found the target parameter if (strnicmp(ps,iniparm,strlen(iniparm)) == 0) { if ((ptr = strchr(vs,';')) != NULL) // cut off an EOL comment *ptr = '\0'; if (short(strlen(vs)) > bufflen - 1) {// not enough buffer space strncpy(retbuff,vs,bufflen - 1); retbuff[bufflen - 1] = '\0'; // put EOL in string *parmlen = bufflen; return true; } else { strcpy(retbuff,vs); // got it trimstr(retbuff); // trim any trailing blanks *parmlen = strlen(retbuff); return true; } } } return false; // parameter not found } // Initializes internal variables to their default value and reads the parameters in the // specified INI file. Then initializes the camera using current settings. If BaseAddress // or RegOffset parameters are specified (not equal to -1) then one or both of these // values are used for the m_BaseAddress and m_RegisterOffset properties overriding those // settings in the INI file. long config_load( char* cfgname, short BaseAddress, short RegOffset ) { short plen; char retbuf[256]; if ((strlen(cfgname) == 0) || (cfgname[0] == '\0')) return CCD_OPEN_CFGNAME; // attempt to open INI file FILE* inifp = NULL; if ((inifp = fopen(cfgname,"r")) == NULL) return CCD_OPEN_CFGDATA; // Check whether we are on an NT platform OSVERSIONINFO VersionInfo; memset(&VersionInfo, 0, sizeof(OSVERSIONINFO)); VersionInfo.dwOSVersionInfoSize = sizeof (OSVERSIONINFO); GetVersionEx ( &VersionInfo ); bool IsNT = VersionInfo.dwPlatformId != VER_PLATFORM_WIN32_WINDOWS; // System if (CfgGet (inifp, "system", "interface", retbuf, sizeof(retbuf), &plen)) { // Assume cam is currently null if ( stricmp( "isa", retbuf ) == 0 ) { if ( IsNT ) cam = new CCameraIO_ISA_NT; else cam = new CCameraIO_ISA_9x; } else if ( stricmp( "ppi", retbuf ) == 0 ) { if ( IsNT ) cam = new CCameraIO_PPI_NT; else cam = new CCameraIO_PPI_9x; } else if ( stricmp( "pci", retbuf ) == 0 ) { cam = new CCameraIO_PCI; } if ( cam == NULL ) { fclose( inifp ); return CCD_OPEN_ALLOC; } } else { fclose( inifp ); return CCD_OPEN_CFGDATA; } ///////////////////////////////////////////////////////////////////////////////// // Settings which are stored in a class member (not in firmware) are already set // to a default value in the constructor. Settings accessed by get/put functions // must be set to a default value in this routine, after the base address and // communication protocal is setup. ///////////////////////////////////////////////////////////////////////////////// // These settings must done first since they affect communication with the camera if ( BaseAddress == -1 ) { if (CfgGet (inifp, "system", "base", retbuf, sizeof(retbuf), &plen)) cam->m_BaseAddress = hextoi(retbuf) & 0xFFF; else { fclose( inifp ); delete cam; cam = NULL; return CCD_OPEN_CFGDATA; // base address MUST be defined } } else cam->m_BaseAddress = BaseAddress & 0xFFF; if ( RegOffset == -1 ) { if (CfgGet (inifp, "system", "reg_offset", retbuf, sizeof(retbuf), &plen)) { unsigned short val = hextoi(retbuf); if ( val >= 0x0 && val <= 0xF0 ) cam->m_RegisterOffset = val & 0xF0; } } else { if ( RegOffset >= 0x0 && RegOffset <= 0xF0 ) cam->m_RegisterOffset = RegOffset & 0xF0; } ///////////////////////////////////////////////////////////////////////////////// // Necessary geometry settings if (CfgGet (inifp, "geometry", "rows", retbuf, sizeof(retbuf), &plen)) { short val = hextoi(retbuf); if ( val >= 1 && val <= MAXTOTALROWS ) cam->m_Rows = val; } else { fclose( inifp ); delete cam; cam = NULL; return CCD_OPEN_CFGDATA; // rows MUST be defined } if (CfgGet (inifp, "geometry", "columns", retbuf, sizeof(retbuf), &plen)) { short val = hextoi(retbuf); if ( val >= 1 && val <= MAXTOTALCOLUMNS ) cam->m_Columns = val; } else { fclose( inifp ); delete cam; cam = NULL; return CCD_OPEN_CFGDATA; // columns MUST be defined } ///////////////////////////////////////////////////////////////////////////////// if (CfgGet (inifp, "system", "pp_repeat", retbuf, sizeof(retbuf), &plen)) { short val = hextoi( retbuf ); if ( val > 0 && val <= 1000 ) cam->m_PPRepeat = val; } ///////////////////////////////////////////////////////////////////////////////// // First actual communication with camera if in PPI mode if ( !cam->InitDriver() ) { delete cam; cam = NULL; fclose( inifp ); if ( IsNT ) return CCD_OPEN_NTIO; else return CCD_OPEN_LOOPTST; } ///////////////////////////////////////////////////////////////////////////////// // First actual communication with camera if in ISA mode cam->Reset(); // Read in command register to set shadow register known state ///////////////////////////////////////////////////////////////////////////////// if (CfgGet (inifp, "system", "cable", retbuf, sizeof(retbuf), &plen)) { if (!stricmp("LONG",retbuf)) cam->write_LongCable( true ); else if ( !stricmp("SHORT",retbuf) ) cam->write_LongCable( false ); } else cam->write_LongCable( false ); // default if ( !cam->read_Present() ) { delete cam; cam = NULL; fclose( inifp ); return CCD_OPEN_LOOPTST; } ///////////////////////////////////////////////////////////////////////////////// // Set default setting and read other settings from ini file cam->write_UseTrigger( false ); cam->write_ForceShutterOpen( false ); if (CfgGet (inifp, "system", "high_priority", retbuf, sizeof(retbuf), &plen)) { if (!stricmp("ON",retbuf) || !stricmp("TRUE",retbuf) || !stricmp("1",retbuf)) { cam->m_HighPriority = true; } else if (!stricmp("OFF",retbuf) || !stricmp("FALSE",retbuf) || !stricmp("0",retbuf)) { cam->m_HighPriority = false; } } if (CfgGet (inifp, "system", "data_bits", retbuf, sizeof(retbuf), &plen)) { short val = hextoi( retbuf ); if ( val >= 8 && val <= 18 ) cam->m_DataBits = val; } if (CfgGet (inifp, "system", "sensor", retbuf, sizeof(retbuf), &plen)) { if ( stricmp( "ccd", retbuf ) == 0 ) { cam->m_SensorType = Camera_SensorType_CCD; } else if ( stricmp( "cmos", retbuf ) == 0 ) { cam->m_SensorType = Camera_SensorType_CMOS; } } if (CfgGet (inifp, "system", "mode", retbuf, sizeof(retbuf), &plen)) { unsigned short val = hextoi(retbuf) & 0xF; cam->write_Mode( val ); } else cam->write_Mode( 0 ); // default if (CfgGet (inifp, "system", "test", retbuf, sizeof(retbuf), &plen)) { unsigned short val = hextoi(retbuf) & 0xF; cam->write_TestBits( val ); } else cam->write_TestBits( 0 ); //default if (CfgGet (inifp, "system", "test2", retbuf, sizeof(retbuf), &plen)) { unsigned short val = hextoi(retbuf) & 0xF; cam->write_Test2Bits( val ); } else cam->write_Test2Bits( 0 ); // default cam->write_FastReadout( false ); //default if (CfgGet (inifp, "system", "shutter_speed", retbuf, sizeof(retbuf), &plen)) { if (!stricmp("normal",retbuf)) { cam->m_FastShutter = false; cam->m_MaxExposure = 10485.75; cam->m_MinExposure = 0.01; } else if (!stricmp("fast",retbuf)) { cam->m_FastShutter = true; cam->m_MaxExposure = 1048.575; cam->m_MinExposure = 0.001; } else if ( !stricmp("dual",retbuf)) { cam->m_FastShutter = true; cam->m_MaxExposure = 10485.75; cam->m_MinExposure = 0.001; } } if (CfgGet (inifp, "system", "shutter_bits", retbuf, sizeof(retbuf), &plen)) { unsigned short val = hextoi(retbuf); cam->m_FastShutterBits_Mode = val & 0x0F; cam->m_FastShutterBits_Test = ( val & 0xF0 ) >> 4; } if (CfgGet (inifp, "system", "maxbinx", retbuf, sizeof(retbuf), &plen)) { short val = hextoi(retbuf); if ( val >= 1 && val <= MAXHBIN ) cam->m_MaxBinX = val; } if (CfgGet (inifp, "system", "maxbiny", retbuf, sizeof(retbuf), &plen)) { short val = hextoi(retbuf); if ( val >= 1 && val <= MAXVBIN ) cam->m_MaxBinY = val; } if (CfgGet (inifp, "system", "guider_relays", retbuf, sizeof(retbuf), &plen)) { if (!stricmp("ON",retbuf) || !stricmp("TRUE",retbuf) || !stricmp("1",retbuf)) { cam->m_GuiderRelays = true; } else if (!stricmp("OFF",retbuf) || !stricmp("FALSE",retbuf) || !stricmp("0",retbuf)) { cam->m_GuiderRelays = false; } } if (CfgGet (inifp, "system", "timeout", retbuf, sizeof(retbuf), &plen)) { double val = atof(retbuf); if ( val >= 0.0 && val <= 10000.0 ) cam->m_Timeout = val; } ///////////////////////////////////////////////////////////////////////////////// // Geometry if (CfgGet (inifp, "geometry", "bic", retbuf, sizeof(retbuf), &plen)) { short val = hextoi(retbuf); if ( val >= 1 && val <= MAXCOLUMNS ) cam->m_BIC = val; } if (CfgGet (inifp, "geometry", "bir", retbuf, sizeof(retbuf), &plen)) { short val = hextoi(retbuf); if ( val >= 1 && val <= MAXROWS ) cam->m_BIR = val; } if (CfgGet (inifp, "geometry", "skipc", retbuf, sizeof(retbuf), &plen)) { short val = hextoi(retbuf); if ( val >= 0 && val <= MAXCOLUMNS ) cam->m_SkipC = val; } if (CfgGet (inifp, "geometry", "skipr", retbuf, sizeof(retbuf), &plen)) { short val = hextoi(retbuf); if ( val >= 0 && val <= MAXROWS ) cam->m_SkipR = val; } if (CfgGet (inifp, "geometry", "imgcols", retbuf, sizeof(retbuf), &plen)) { short val = hextoi(retbuf); if ( val >= 1 && val <= MAXTOTALCOLUMNS ) cam->m_ImgColumns = val; } else cam->m_ImgColumns = cam->m_Columns - cam->m_BIC - cam->m_SkipC; if (CfgGet (inifp, "geometry", "imgrows", retbuf, sizeof(retbuf), &plen)) { short val = hextoi(retbuf); if ( val >= 1 && val <= MAXTOTALROWS ) cam->m_ImgRows = val; } else cam->m_ImgRows = cam->m_Rows - cam->m_BIR - cam->m_SkipR; if (CfgGet (inifp, "geometry", "hflush", retbuf, sizeof(retbuf), &plen)) { short val = hextoi(retbuf); if ( val >= 1 && val <= MAXHBIN ) cam->m_HFlush = val; } if (CfgGet (inifp, "geometry", "vflush", retbuf, sizeof(retbuf), &plen)) { short val = hextoi(retbuf); if ( val >= 1 && val <= MAXVBIN ) cam->m_VFlush = val; } // Default to full frame cam->m_NumX = cam->m_ImgColumns; cam->m_NumY = cam->m_ImgRows; ///////////////////////////////////////////////////////////////////////////////// // Temperature if (CfgGet (inifp, "temp", "control", retbuf, sizeof(retbuf), &plen)) { if (!stricmp("ON",retbuf) || !stricmp("TRUE",retbuf) || !stricmp("1",retbuf)) { cam->m_TempControl = true; } else if (!stricmp("OFF",retbuf) || !stricmp("FALSE",retbuf) || !stricmp("0",retbuf)) { cam->m_TempControl = false; } } if (CfgGet (inifp, "temp", "cal", retbuf, sizeof(retbuf), &plen)) { short val = hextoi(retbuf); if ( val >= 1 && val <= 255 ) cam->m_TempCalibration = val; } if (CfgGet (inifp, "temp", "scale", retbuf, sizeof(retbuf), &plen)) { double val = atof(retbuf); if ( val >= 1.0 && val <= 10.0 ) cam->m_TempScale = val; } if (CfgGet (inifp, "temp", "target", retbuf, sizeof(retbuf), &plen)) { double val = atof(retbuf); if ( val >= -60.0 && val <= 40.0 ) cam->write_CoolerSetPoint( val ); else cam->write_CoolerSetPoint( -10.0 ); } else cam->write_CoolerSetPoint( -10.0 ); //default ///////////////////////////////////////////////////////////////////////////////// // CCD if (CfgGet (inifp, "ccd", "sensor", retbuf, sizeof(retbuf), &plen)) { if ( plen > 256 ) plen = 256; memcpy( cam->m_Sensor, retbuf, plen ); } if (CfgGet (inifp, "ccd", "color", retbuf, sizeof(retbuf), &plen)) { if (!stricmp("ON",retbuf) || !stricmp("TRUE",retbuf) || !stricmp("1",retbuf)) { cam->m_Color = true; } else if (!stricmp("OFF",retbuf) || !stricmp("FALSE",retbuf) || !stricmp("0",retbuf)) { cam->m_Color = false; } } if (CfgGet (inifp, "ccd", "noise", retbuf, sizeof(retbuf), &plen)) { cam->m_Noise = atof( retbuf ); } if (CfgGet (inifp, "ccd", "gain", retbuf, sizeof(retbuf), &plen)) { cam->m_Gain = atof( retbuf ); } if (CfgGet (inifp, "ccd", "pixelxsize", retbuf, sizeof(retbuf), &plen)) { cam->m_PixelXSize = atof( retbuf ); } if (CfgGet (inifp, "ccd", "pixelysize", retbuf, sizeof(retbuf), &plen)) { cam->m_PixelYSize = atof( retbuf ); } fclose( inifp ); return CCD_OPEN_NOERR; } libapogee2-2.2/ApnCamData_KAF1301E.cpp0000644000175000017500000006135211110507150014724 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_KAF1301E.cpp: Implementation file for the CApnCamData_KAF1301E class. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #include "ApnCamData_KAF1301E.h" #include #include #include ///////////////////////////////////////////////////////////// // Construction/Destruction ///////////////////////////////////////////////////////////// CApnCamData_KAF1301E::CApnCamData_KAF1301E() { } CApnCamData_KAF1301E::~CApnCamData_KAF1301E() { } void CApnCamData_KAF1301E::Initialize() { strcpy( m_Sensor, "KAF1301E" ); strcpy( m_CameraModel, "13" ); m_CameraId = 3; m_InterlineCCD = false; m_SupportsSerialA = true; m_SupportsSerialB = true; m_SensorTypeCCD = true; m_TotalColumns = 1305; m_ImagingColumns = 1280; m_ClampColumns = 4; m_PreRoiSkipColumns = 0; m_PostRoiSkipColumns = 0; m_OverscanColumns = 21; m_TotalRows = 1028; m_ImagingRows = 1024; m_UnderscanRows = 2; m_OverscanRows = 2; m_VFlushBinning = 1; m_EnableSingleRowOffset = false; m_RowOffsetBinning = 1; m_HFlushDisable = false; m_ShutterCloseDelay = 300; m_PixelSizeX = 16; m_PixelSizeY = 16; m_Color = false; m_ReportedGainSixteenBit = 3; m_MinSuggestedExpTime = 20.0; m_CoolingSupported = true; m_RegulatedCoolingSupported = true; m_TempSetPoint = -20.0; m_TempRampRateOne = 700; m_TempRampRateTwo = 4000; m_TempBackoffPoint = 2.0; m_PrimaryADType = ApnAdType_Alta_Sixteen; m_AlternativeADType = ApnAdType_Alta_Twelve; m_DefaultGainLeft = 0; m_DefaultOffsetLeft = 200; m_DefaultGainRight = -1; m_DefaultOffsetRight = -1; m_DefaultRVoltage = 1000; m_DefaultSpeed = 0xffff; m_DefaultDataReduction = false; set_vpattern(); set_hpattern_clamp_sixteen(); set_hpattern_skip_sixteen(); set_hpattern_roi_sixteen(); set_hpattern_clamp_twelve(); set_hpattern_skip_twelve(); set_hpattern_roi_twelve(); } void CApnCamData_KAF1301E::set_vpattern() { const unsigned short Mask = 0x0; const unsigned short NumElements = 71; unsigned short Pattern[NumElements] = { 0x0000, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0001, 0x0000 }; m_VerticalPattern.Mask = Mask; m_VerticalPattern.NumElements = NumElements; m_VerticalPattern.PatternData = (unsigned short *)malloc(NumElements * sizeof(unsigned short)); for ( int i=0; iMask = Mask; Pattern->BinningLimit = BinningLimit; Pattern->RefNumElements = RefNumElements; Pattern->SigNumElements = SigNumElements; if ( RefNumElements > 0 ) { Pattern->RefPatternData = (unsigned short *)malloc(RefNumElements * sizeof(unsigned short)); for ( i=0; iRefPatternData[i] = RefPatternData[i]; } } if ( SigNumElements > 0 ) { Pattern->SigPatternData = (unsigned short *)malloc(SigNumElements * sizeof(unsigned short)); for ( i=0; iSigPatternData[i] = SigPatternData[i]; } } if ( BinningLimit > 0 ) { for ( i=0; iBinNumElements[i] = BinNumElements[i]; Pattern->BinPatternData[i] = (unsigned short *)malloc(BinNumElements[i] * sizeof(unsigned short)); for ( j=0; jBinPatternData[i][j] = BinPatternData[i][j]; } } } } libapogee2-2.2/ApnCamData_KAI2001ML.cpp0000644000175000017500000005316711110507150015056 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_KAI2001ML.cpp: Implementation file for the CApnCamData_KAI2001ML class. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #include "ApnCamData_KAI2001ML.h" #include #include #include ///////////////////////////////////////////////////////////// // Construction/Destruction ///////////////////////////////////////////////////////////// CApnCamData_KAI2001ML::CApnCamData_KAI2001ML() { } CApnCamData_KAI2001ML::~CApnCamData_KAI2001ML() { } void CApnCamData_KAI2001ML::Initialize() { strcpy( m_Sensor, "KAI2001ML" ); strcpy( m_CameraModel, "2001ml" ); m_CameraId = 65; m_InterlineCCD = true; m_SupportsSerialA = true; m_SupportsSerialB = true; m_SensorTypeCCD = true; m_TotalColumns = 1648; m_ImagingColumns = 1600; m_ClampColumns = 24; m_PreRoiSkipColumns = 0; m_PostRoiSkipColumns = 0; m_OverscanColumns = 24; m_TotalRows = 1214; m_ImagingRows = 1200; m_UnderscanRows = 6; m_OverscanRows = 8; m_VFlushBinning = 1; m_EnableSingleRowOffset = false; m_RowOffsetBinning = 1; m_HFlushDisable = false; m_ShutterCloseDelay = 0; m_PixelSizeX = 7.4; m_PixelSizeY = 7.4; m_Color = false; m_ReportedGainSixteenBit = 1; m_MinSuggestedExpTime = 0.05; m_CoolingSupported = true; m_RegulatedCoolingSupported = true; m_TempSetPoint = -20.0; m_TempRampRateOne = 700; m_TempRampRateTwo = 4000; m_TempBackoffPoint = 2.0; m_PrimaryADType = ApnAdType_Alta_Sixteen; m_AlternativeADType = ApnAdType_Alta_Twelve; m_DefaultGainLeft = 300; m_DefaultOffsetLeft = 50; m_DefaultGainRight = -1; m_DefaultOffsetRight = -1; m_DefaultRVoltage = 1000; m_DefaultSpeed = 0xffff; m_DefaultDataReduction = false; set_vpattern(); set_hpattern_clamp_sixteen(); set_hpattern_skip_sixteen(); set_hpattern_roi_sixteen(); set_hpattern_clamp_twelve(); set_hpattern_skip_twelve(); set_hpattern_roi_twelve(); } void CApnCamData_KAI2001ML::set_vpattern() { const unsigned short Mask = 0x106; const unsigned short NumElements = 38; unsigned short Pattern[NumElements] = { 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0302, 0x0302, 0x0302, 0x0302, 0x0302, 0x0302, 0x0302, 0x0302, 0x0302, 0x0302, 0x0002, 0x0002, 0x0002, 0x0003, 0x0002 }; m_VerticalPattern.Mask = Mask; m_VerticalPattern.NumElements = NumElements; m_VerticalPattern.PatternData = (unsigned short *)malloc(NumElements * sizeof(unsigned short)); for ( int i=0; iMask = Mask; Pattern->BinningLimit = BinningLimit; Pattern->RefNumElements = RefNumElements; Pattern->SigNumElements = SigNumElements; if ( RefNumElements > 0 ) { Pattern->RefPatternData = (unsigned short *)malloc(RefNumElements * sizeof(unsigned short)); for ( i=0; iRefPatternData[i] = RefPatternData[i]; } } if ( SigNumElements > 0 ) { Pattern->SigPatternData = (unsigned short *)malloc(SigNumElements * sizeof(unsigned short)); for ( i=0; iSigPatternData[i] = SigPatternData[i]; } } if ( BinningLimit > 0 ) { for ( i=0; iBinNumElements[i] = BinNumElements[i]; Pattern->BinPatternData[i] = (unsigned short *)malloc(BinNumElements[i] * sizeof(unsigned short)); for ( j=0; jBinPatternData[i][j] = BinPatternData[i][j]; } } } } libapogee2-2.2/ApnCamData_KAI2020CL.cpp0000644000175000017500000005316511110507150015043 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_KAI2020CL.cpp: Implementation file for the CApnCamData_KAI2020CL class. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #include "ApnCamData_KAI2020CL.h" #include #include #include ///////////////////////////////////////////////////////////// // Construction/Destruction ///////////////////////////////////////////////////////////// CApnCamData_KAI2020CL::CApnCamData_KAI2020CL() { } CApnCamData_KAI2020CL::~CApnCamData_KAI2020CL() { } void CApnCamData_KAI2020CL::Initialize() { strcpy( m_Sensor, "KAI2020CL" ); strcpy( m_CameraModel, "2020cl" ); m_CameraId = 68; m_InterlineCCD = true; m_SupportsSerialA = true; m_SupportsSerialB = true; m_SensorTypeCCD = true; m_TotalColumns = 1648; m_ImagingColumns = 1600; m_ClampColumns = 24; m_PreRoiSkipColumns = 0; m_PostRoiSkipColumns = 0; m_OverscanColumns = 24; m_TotalRows = 1214; m_ImagingRows = 1200; m_UnderscanRows = 6; m_OverscanRows = 8; m_VFlushBinning = 1; m_EnableSingleRowOffset = false; m_RowOffsetBinning = 1; m_HFlushDisable = false; m_ShutterCloseDelay = 0; m_PixelSizeX = 7.4; m_PixelSizeY = 7.4; m_Color = true; m_ReportedGainSixteenBit = 1; m_MinSuggestedExpTime = 0.05; m_CoolingSupported = true; m_RegulatedCoolingSupported = true; m_TempSetPoint = -20.0; m_TempRampRateOne = 700; m_TempRampRateTwo = 4000; m_TempBackoffPoint = 2.0; m_PrimaryADType = ApnAdType_Alta_Sixteen; m_AlternativeADType = ApnAdType_Alta_Twelve; m_DefaultGainLeft = 0; m_DefaultOffsetLeft = 100; m_DefaultGainRight = -1; m_DefaultOffsetRight = -1; m_DefaultRVoltage = 1000; m_DefaultSpeed = 0xffff; m_DefaultDataReduction = false; set_vpattern(); set_hpattern_clamp_sixteen(); set_hpattern_skip_sixteen(); set_hpattern_roi_sixteen(); set_hpattern_clamp_twelve(); set_hpattern_skip_twelve(); set_hpattern_roi_twelve(); } void CApnCamData_KAI2020CL::set_vpattern() { const unsigned short Mask = 0x106; const unsigned short NumElements = 38; unsigned short Pattern[NumElements] = { 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0302, 0x0302, 0x0302, 0x0302, 0x0302, 0x0302, 0x0302, 0x0302, 0x0302, 0x0302, 0x0002, 0x0002, 0x0002, 0x0003, 0x0002 }; m_VerticalPattern.Mask = Mask; m_VerticalPattern.NumElements = NumElements; m_VerticalPattern.PatternData = (unsigned short *)malloc(NumElements * sizeof(unsigned short)); for ( int i=0; iMask = Mask; Pattern->BinningLimit = BinningLimit; Pattern->RefNumElements = RefNumElements; Pattern->SigNumElements = SigNumElements; if ( RefNumElements > 0 ) { Pattern->RefPatternData = (unsigned short *)malloc(RefNumElements * sizeof(unsigned short)); for ( i=0; iRefPatternData[i] = RefPatternData[i]; } } if ( SigNumElements > 0 ) { Pattern->SigPatternData = (unsigned short *)malloc(SigNumElements * sizeof(unsigned short)); for ( i=0; iSigPatternData[i] = SigPatternData[i]; } } if ( BinningLimit > 0 ) { for ( i=0; iBinNumElements[i] = BinNumElements[i]; Pattern->BinPatternData[i] = (unsigned short *)malloc(BinNumElements[i] * sizeof(unsigned short)); for ( j=0; jBinPatternData[i][j] = BinPatternData[i][j]; } } } } libapogee2-2.2/ApnCamData_KAI4020C.h0000644000175000017500000000221211110507150014361 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_KAI4020C.h: Interface file for the CApnCamData_KAI4020C class. // // Copyright (c) 2003, 2004 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #if _MSC_VER > 1000 #pragma once #endif // _MSC_VER> 1000 #include "ApnCamData.h" class CApnCamData_KAI4020C : public CApnCamData { public: CApnCamData_KAI4020C(); virtual ~CApnCamData_KAI4020C(); void Initialize(); private: void set_vpattern(); void set_hpattern_clamp_sixteen(); void set_hpattern_skip_sixteen(); void set_hpattern_roi_sixteen(); void set_hpattern_clamp_twelve(); void set_hpattern_skip_twelve(); void set_hpattern_roi_twelve(); void set_hpattern( APN_HPATTERN_FILE *Pattern, unsigned short Mask, unsigned short BinningLimit, unsigned short RefNumElements, unsigned short SigNumElements, unsigned short BinNumElements[], unsigned short RefPatternData[], unsigned short SigPatternData[], unsigned short BinPatternData[][APN_MAX_PATTERN_ENTRIES] ); }; libapogee2-2.2/ApnCamTable.h0000644000175000017500000001323611110507150013452 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamTable.h: Camera models and description strings. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #ifndef __APN_CAM_TABLE_H__ #define __APN_CAM_TABLE_H__ // Used to derive camera platform type from camera ID #define APN_SIG_CAMERA_ID_ASCENT 0x0100 #define APN_MASK_CAMERA_ID_ALTA 0x007F #define APN_MASK_CAMERA_ID_ASCENT 0x01FF ////////////////////////////////////////////////////////// // Alta Camera Models ////////////////////////////////////////////////////////// #define APN_ALTA_KAF0401E_CAM_ID 0 #define APN_ALTA_KAF0401E_CAM_SZ "1" #define APN_ALTA_KAF1602E_CAM_ID 1 #define APN_ALTA_KAF1602E_CAM_SZ "2" #define APN_ALTA_KAF0261E_CAM_ID 2 #define APN_ALTA_KAF0261E_CAM_SZ "260" #define APN_ALTA_KAF1301E_CAM_ID 3 #define APN_ALTA_KAF1301E_CAM_SZ "13" #define APN_ALTA_KAF1001E_CAM_ID 5 #define APN_ALTA_KAF1001E_CAM_SZ "6" #define APN_ALTA_KAF1001ENS_CAM_ID 30 #define APN_ALTA_KAF1001ENS_CAM_SZ "6NS" #define APN_ALTA_KAF10011105_CAM_ID 31 #define APN_ALTA_KAF10011105_CAM_SZ "6-1105" #define APN_ALTA_KAF3200E_CAM_ID 6 #define APN_ALTA_KAF3200E_CAM_SZ "32" #define APN_ALTA_KAF6303E_CAM_ID 8 #define APN_ALTA_KAF6303E_CAM_SZ "9" #define APN_ALTA_KAF16801E_CAM_ID 9 #define APN_ALTA_KAF16801E_CAM_SZ "16" #define APN_ALTA_KAF09000_CAM_ID 4 #define APN_ALTA_KAF09000_CAM_SZ "9000" #define APN_ALTA_KAF09000X_CAM_ID 39 #define APN_ALTA_KAF09000X_CAM_SZ "9000X" #define APN_ALTA_KAF0401EB_CAM_ID 32 #define APN_ALTA_KAF0401EB_CAM_SZ "1" #define APN_ALTA_KAF1602EB_CAM_ID 33 #define APN_ALTA_KAF1602EB_CAM_SZ "2" #define APN_ALTA_KAF0261EB_CAM_ID 34 #define APN_ALTA_KAF0261EB_CAM_SZ "260" #define APN_ALTA_KAF1301EB_CAM_ID 35 #define APN_ALTA_KAF1301EB_CAM_SZ "13" #define APN_ALTA_KAF1001EB_CAM_ID 36 #define APN_ALTA_KAF1001EB_CAM_SZ "6" #define APN_ALTA_KAF6303EB_CAM_ID 37 #define APN_ALTA_KAF6303EB_CAM_SZ "9" #define APN_ALTA_KAF16803_CAM_ID 38 #define APN_ALTA_KAF16803_CAM_SZ "16M" #define APN_ALTA_KAF3200EB_CAM_ID 7 #define APN_ALTA_KAF3200EB_CAM_SZ "32" #define APN_ALTA_TH7899_CAM_ID 14 #define APN_ALTA_TH7899_CAM_SZ "10" #define APN_ALTA_S101401107_CAM_ID 40 #define APN_ALTA_S101401107_CAM_SZ "1107" #define APN_ALTA_S101401109_CAM_ID 41 #define APN_ALTA_S101401109_CAM_SZ "1109" #define APN_ALTA_CCD4710_CAM_ID 10 #define APN_ALTA_CCD4710_CAM_SZ "47" #define APN_ALTA_CCD4710ALT_CAM_ID 12 #define APN_ALTA_CCD4710ALT_CAM_SZ "47" #define APN_ALTA_CCD4240_CAM_ID 16 #define APN_ALTA_CCD4240_CAM_SZ "42" #define APN_ALTA_CCD5710_CAM_ID 18 #define APN_ALTA_CCD5710_CAM_SZ "57" #define APN_ALTA_CCD3011_CAM_ID 20 #define APN_ALTA_CCD3011_CAM_SZ "30" #define APN_ALTA_CCD5520_CAM_ID 22 #define APN_ALTA_CCD5520_CAM_SZ "55" #define APN_ALTA_CCD4720_CAM_ID 24 #define APN_ALTA_CCD4720_CAM_SZ "4720" #define APN_ALTA_CCD7700_CAM_ID 26 #define APN_ALTA_CCD7700_CAM_SZ "77" #define APN_ALTA_CCD4710B_CAM_ID 11 #define APN_ALTA_CCD4710B_CAM_SZ "47" #define APN_ALTA_CCD4240B_CAM_ID 13 #define APN_ALTA_CCD4240B_CAM_SZ "42" #define APN_ALTA_CCD5710B_CAM_ID 15 #define APN_ALTA_CCD5710B_CAM_SZ "57" #define APN_ALTA_CCD3011B_CAM_ID 17 #define APN_ALTA_CCD3011B_CAM_SZ "30" #define APN_ALTA_CCD5520B_CAM_ID 19 #define APN_ALTA_CCD5520B_CAM_SZ "55" #define APN_ALTA_CCD4720B_CAM_ID 21 #define APN_ALTA_CCD4720B_CAM_SZ "4720" #define APN_ALTA_CCD7700B_CAM_ID 23 #define APN_ALTA_CCD7700B_CAM_SZ "77" #define APN_ALTA_KAI2001ML_CAM_ID 65 #define APN_ALTA_KAI2001ML_CAM_SZ "2001ML" #define APN_ALTA_KAI2020ML_CAM_ID 64 #define APN_ALTA_KAI2020ML_CAM_SZ "2020ML" #define APN_ALTA_KAI4020ML_CAM_ID 66 #define APN_ALTA_KAI4020ML_CAM_SZ "4020ML" #define APN_ALTA_KAI11000ML_CAM_ID 67 #define APN_ALTA_KAI11000ML_CAM_SZ "11000ML" #define APN_ALTA_KAI2020CL_CAM_ID 68 #define APN_ALTA_KAI2020CL_CAM_SZ "2020CL" #define APN_ALTA_KAI2001CL_CAM_ID 71 #define APN_ALTA_KAI2001CL_CAM_SZ "2001CL" #define APN_ALTA_KAI4020CL_CAM_ID 69 #define APN_ALTA_KAI4020CL_CAM_SZ "4020CL" #define APN_ALTA_KAI11000CL_CAM_ID 70 #define APN_ALTA_KAI11000CL_CAM_SZ "11000CL" #define APN_ALTA_KAI2020MLB_CAM_ID 72 #define APN_ALTA_KAI2020MLB_CAM_SZ "2020ML" #define APN_ALTA_KAI4020MLB_CAM_ID 73 #define APN_ALTA_KAI4020MLB_CAM_SZ "4020ML" #define APN_ALTA_KAI2020CLB_CAM_ID 74 #define APN_ALTA_KAI2020CLB_CAM_SZ "2020CL" #define APN_ALTA_KAI4020CLB_CAM_ID 75 #define APN_ALTA_KAI4020CLB_CAM_SZ "4020CL" ////////////////////////////////////////////////////////// // Ascent Camera Models ////////////////////////////////////////////////////////// #define APN_ASCENT_KAF0402E_CAM_ID 256 #define APN_ASCENT_KAF0402E_CAM_SZ "1" #define APN_ASCENT_KAF0402E2_CAM_ID 257 #define APN_ASCENT_KAF0402E2_CAM_SZ "2" #define APN_ASCENT_KAF0402E3_CAM_ID 258 #define APN_ASCENT_KAF0402E3_CAM_SZ "3" #define APN_ASCENT_KAF0402E4_CAM_ID 259 #define APN_ASCENT_KAF0402E4_CAM_SZ "4" #define APN_ASCENT_KAI340_CAM_ID 323 #define APN_ASCENT_KAI340_CAM_SZ "340" #define APN_ASCENT_KAI2000_CAM_ID 322 #define APN_ASCENT_KAI2000_CAM_SZ "2000" #define APN_ASCENT_KAI4000_CAM_ID 321 #define APN_ASCENT_KAI4000_CAM_SZ "4000" #define APN_ASCENT_KAI16000_CAM_ID 320 #define APN_ASCENT_KAI16000_CAM_SZ "16000" // Helper function prototype void ApnCamModelLookup( unsigned short CamId, int FwRev, unsigned short Interface, char *szCamModel ); bool ApnCamModelIsAlta( unsigned short CamId, int FwRev ); bool ApnCamModelIsAscent( unsigned short CamId, int FwRev ); #endif libapogee2-2.2/testTDI.cpp0000644000175000017500000000700511110507150013213 0ustar jrjr#include #include #include #include #include #include #include "ApnCamera.h" int main() { CApnCamera *ApogeeCamera; // Camera interface int hr; // Return code FILE* filePtr; // File pointer unsigned short NumTdiRows; // Number of images to take double TdiRate; // TDI rate (in seconds) unsigned short* pBuffer; unsigned long ImgSizeBytes; char szFilename[80]; // File name printf( "Apogee Alta Bulk TDI Sample Applet\n" ); // Create the CApnCamera object ApogeeCamera = (CApnCamera *)new CApnCamera(); // Initialize camera using the default properties hr = ApogeeCamera->InitDriver( 0xC0A800C6, 0x50, 0x0 ); if ( hr ) { printf( "Connection to camera succeeded.\n" ); } else { printf( "Failed to connect to camera" ); ApogeeCamera = NULL; // Release CApnCamera object exit(1); } /* Do a system reset to ensure known state, flushing enabled etc */ ApogeeCamera->ResetSystem(); printf("Current CCD temperature : %f\n",ApogeeCamera->read_TempCCD()); // Query user for number of TDI rows printf( "Number of TDI Rows: " ); scanf( "%d", &NumTdiRows ); printf( "Image to contain %d rows.\n", NumTdiRows ); // Query user for TDI rate printf( "Interval between rows (TDI rate): " ); scanf( "%lf", &TdiRate ); printf( "TDI rate set to %lf seconds.\n", TdiRate ); // Set the TDI row count ApogeeCamera->write_TDIRows (NumTdiRows); // Set the TDI rate ApogeeCamera->write_TDIRate (TdiRate); // Toggle the camera mode for TDI ApogeeCamera->write_CameraMode (Apn_CameraMode_TDI); // Toggle the sequence download variable ApogeeCamera->write_SequenceBulkDownload (true); // Set the image size long ImgXSize = ApogeeCamera->m_ApnSensorInfo->m_ImagingColumns; long ImgYSize = NumTdiRows; // Since SequenceBulkDownload = true // Display the camera model // _bstr_t szCamModel( ApogeeCamera->CameraModel ); // printf( "Camera Model: %s\n", (char*)szCamModel ); // Display the driver version // _bstr_t szDriverVer( ApogeeCamera->DriverVersion ); // printf( "Driver Version: %s\n", (char*)szDriverVer ); // Create a buffer for one image, which will be reused for // each image in the sequence pBuffer = new unsigned short[ ImgXSize * ImgYSize]; ImgSizeBytes = ImgXSize * ImgYSize * 2; // Initialize the output file sprintf( szFilename, "BulkTdiData.raw" ); filePtr = fopen( szFilename, "wb" ); if ( filePtr == NULL ) { printf( "ERROR: Failed to open output file. No file will be written." ); } // Do a sequence of 0.001s dark frames (bias frames) printf( "Starting camera exposure...\n" ); ApogeeCamera->Expose( 0.1, true ); // Check camera status to make sure image data is ready while ( ApogeeCamera->read_ImagingStatus() != Apn_Status_ImageReady ); // Get the image data from the camera printf( "Retrieving image data from camera...\n" ); ApogeeCamera->GetImage( pBuffer ); if ( filePtr == NULL ) { printf( "ERROR: Failed to open file for writing output data." ); } else { printf( "Writing line data to output file \"%s...\"\n", szFilename ); fwrite( pBuffer, sizeof(unsigned short), (ImgSizeBytes/2), filePtr ); } // Close the file if ( filePtr != NULL ) { printf( "Closing output file.\n" ); fclose( filePtr ); } ApogeeCamera->CloseDriver(); delete ApogeeCamera; // Release CApnCamera COM object // Delete the memory buffer for storing the image delete [] pBuffer; exit(0); } libapogee2-2.2/testTDIu.cpp0000644000175000017500000000663711110507150013412 0ustar jrjr#include #include #include #include #include #include #include "ApnCamera.h" int main() { CApnCamera *ApogeeCamera; // Camera interface int hr; // Return code FILE* filePtr; // File pointer unsigned short NumTdiRows; // Number of images to take double TdiRate; // TDI rate (in seconds) unsigned short* pBuffer; unsigned long ImgSizeBytes; char szFilename[80]; // File name printf( "Apogee Alta Bulk TDI Sample Applet\n" ); // Create the CApnCamera object ApogeeCamera = (CApnCamera *)new CApnCamera(); // Initialize camera using the default properties hr = ApogeeCamera->InitDriver( 1,0,0 ); if ( hr ) { printf( "Connection to camera succeeded.\n" ); } else { printf( "Failed to connect to camera" ); ApogeeCamera = NULL; // Release CApnCamera object exit(1); } /* Do a system reset to ensure known state, flushing enabled etc */ ApogeeCamera->ResetSystem(); printf("Current CCD temperature : %f\n",ApogeeCamera->read_TempCCD()); // Query user for number of TDI rows printf( "Number of TDI Rows: " ); scanf( "%d", &NumTdiRows ); printf( "Image to contain %d rows.\n", NumTdiRows ); // Query user for TDI rate printf( "Interval between rows (TDI rate): " ); scanf( "%lf", &TdiRate ); printf( "TDI rate set to %lf seconds.\n", TdiRate ); // Set the TDI row count ApogeeCamera->write_TDIRows (NumTdiRows); // Set the TDI rate ApogeeCamera->write_TDIRate (TdiRate); // Toggle the camera mode for TDI ApogeeCamera->write_CameraMode (Apn_CameraMode_TDI); // Toggle the sequence download variable ApogeeCamera->write_SequenceBulkDownload (true); // Set the image size long ImgXSize = ApogeeCamera->m_ApnSensorInfo->m_ImagingColumns; long ImgYSize = NumTdiRows; // Since SequenceBulkDownload = true // Display the camera model // _bstr_t szCamModel( ApogeeCamera->CameraModel ); // printf( "Camera Model: %s\n", (char*)szCamModel ); // Display the driver version // _bstr_t szDriverVer( ApogeeCamera->DriverVersion ); // printf( "Driver Version: %s\n", (char*)szDriverVer ); // Create a buffer for one image, which will be reused for // each image in the sequence pBuffer = new unsigned short[ ImgXSize * ImgYSize]; ImgSizeBytes = ImgXSize * ImgYSize * 2; // Initialize the output file sprintf( szFilename, "BulkTdiData.raw" ); filePtr = fopen( szFilename, "wb" ); if ( filePtr == NULL ) { printf( "ERROR: Failed to open output file. No file will be written." ); } // Do a sequence of 0.001s dark frames (bias frames) printf( "Starting camera exposure...\n" ); ApogeeCamera->Expose( 0.1, true ); // Check camera status to make sure image data is ready while ( ApogeeCamera->read_ImagingStatus() != Apn_Status_ImageReady ); // Get the image data from the camera printf( "Retrieving image data from camera...\n" ); ApogeeCamera->GetImage( pBuffer ); if ( filePtr == NULL ) { printf( "ERROR: Failed to open file for writing output data." ); } else { printf( "Writing line data to output file \"%s...\"\n", szFilename ); fwrite( pBuffer, sizeof(unsigned short), (ImgSizeBytes/2), filePtr ); } // Close the file if ( filePtr != NULL ) { printf( "Closing output file.\n" ); fclose( filePtr ); } ApogeeCamera->CloseDriver(); delete ApogeeCamera; // Release CApnCamera COM object // Delete the memory buffer for storing the image delete [] pBuffer; exit(0); } libapogee2-2.2/ApnCamData_KAI2020C.h0000644000175000017500000000221211110507150014357 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_KAI2020C.h: Interface file for the CApnCamData_KAI2020C class. // // Copyright (c) 2003, 2004 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #if _MSC_VER > 1000 #pragma once #endif // _MSC_VER> 1000 #include "ApnCamData.h" class CApnCamData_KAI2020C : public CApnCamData { public: CApnCamData_KAI2020C(); virtual ~CApnCamData_KAI2020C(); void Initialize(); private: void set_vpattern(); void set_hpattern_clamp_sixteen(); void set_hpattern_skip_sixteen(); void set_hpattern_roi_sixteen(); void set_hpattern_clamp_twelve(); void set_hpattern_skip_twelve(); void set_hpattern_roi_twelve(); void set_hpattern( APN_HPATTERN_FILE *Pattern, unsigned short Mask, unsigned short BinningLimit, unsigned short RefNumElements, unsigned short SigNumElements, unsigned short BinNumElements[], unsigned short RefPatternData[], unsigned short SigPatternData[], unsigned short BinPatternData[][APN_MAX_PATTERN_ENTRIES] ); }; libapogee2-2.2/ApnCamData_KAI4020MLB.cpp0000644000175000017500000005456311110507150015164 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_KAI4020MLB.cpp: Implementation file for the CApnCamData_KAI4020MLB class. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #include "ApnCamData_KAI4020MLB.h" #include #include #include ///////////////////////////////////////////////////////////// // Construction/Destruction ///////////////////////////////////////////////////////////// CApnCamData_KAI4020MLB::CApnCamData_KAI4020MLB() { } CApnCamData_KAI4020MLB::~CApnCamData_KAI4020MLB() { } void CApnCamData_KAI4020MLB::Initialize() { strcpy( m_Sensor, "KAI4020MLB" ); strcpy( m_CameraModel, "4020ml" ); m_CameraId = 73; m_InterlineCCD = true; m_SupportsSerialA = true; m_SupportsSerialB = true; m_SensorTypeCCD = true; m_TotalColumns = 2136; m_ImagingColumns = 2048; m_ClampColumns = 44; m_PreRoiSkipColumns = 0; m_PostRoiSkipColumns = 0; m_OverscanColumns = 44; m_TotalRows = 2072; m_ImagingRows = 2048; m_UnderscanRows = 16; m_OverscanRows = 8; m_VFlushBinning = 1; m_EnableSingleRowOffset = false; m_RowOffsetBinning = 1; m_HFlushDisable = false; m_ShutterCloseDelay = 0; m_PixelSizeX = 7.4; m_PixelSizeY = 7.4; m_Color = false; m_ReportedGainSixteenBit = 1; m_MinSuggestedExpTime = 0.05; m_CoolingSupported = true; m_RegulatedCoolingSupported = true; m_TempSetPoint = -20.0; m_TempRampRateOne = 700; m_TempRampRateTwo = 4000; m_TempBackoffPoint = 2.0; m_PrimaryADType = ApnAdType_Alta_Sixteen; m_AlternativeADType = ApnAdType_Alta_Twelve; m_DefaultGainLeft = 0; m_DefaultOffsetLeft = 100; m_DefaultGainRight = -1; m_DefaultOffsetRight = -1; m_DefaultRVoltage = 1000; m_DefaultSpeed = 0xffff; m_DefaultDataReduction = false; set_vpattern(); set_hpattern_clamp_sixteen(); set_hpattern_skip_sixteen(); set_hpattern_roi_sixteen(); set_hpattern_clamp_twelve(); set_hpattern_skip_twelve(); set_hpattern_roi_twelve(); } void CApnCamData_KAI4020MLB::set_vpattern() { const unsigned short Mask = 0x16; const unsigned short NumElements = 38; unsigned short Pattern[NumElements] = { 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0302, 0x0302, 0x0302, 0x0302, 0x0302, 0x0302, 0x0302, 0x0302, 0x0302, 0x0302, 0x0002, 0x0002, 0x0002, 0x0003, 0x0002 }; m_VerticalPattern.Mask = Mask; m_VerticalPattern.NumElements = NumElements; m_VerticalPattern.PatternData = (unsigned short *)malloc(NumElements * sizeof(unsigned short)); for ( int i=0; iMask = Mask; Pattern->BinningLimit = BinningLimit; Pattern->RefNumElements = RefNumElements; Pattern->SigNumElements = SigNumElements; if ( RefNumElements > 0 ) { Pattern->RefPatternData = (unsigned short *)malloc(RefNumElements * sizeof(unsigned short)); for ( i=0; iRefPatternData[i] = RefPatternData[i]; } } if ( SigNumElements > 0 ) { Pattern->SigPatternData = (unsigned short *)malloc(SigNumElements * sizeof(unsigned short)); for ( i=0; iSigPatternData[i] = SigPatternData[i]; } } if ( BinningLimit > 0 ) { for ( i=0; iBinNumElements[i] = BinNumElements[i]; Pattern->BinPatternData[i] = (unsigned short *)malloc(BinNumElements[i] * sizeof(unsigned short)); for ( j=0; jBinPatternData[i][j] = BinPatternData[i][j]; } } } } libapogee2-2.2/ApnCamData_KAI4020C.cpp0000644000175000017500000005277611110507150014740 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_KAI4020C.cpp: Implementation file for the CApnCamData_KAI4020C class. // // Copyright (c) 2003, 2004 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #include "ApnCamData_KAI4020C.h" #include #include #include ///////////////////////////////////////////////////////////// // Construction/Destruction ///////////////////////////////////////////////////////////// CApnCamData_KAI4020C::CApnCamData_KAI4020C() { } CApnCamData_KAI4020C::~CApnCamData_KAI4020C() { } void CApnCamData_KAI4020C::Initialize() { strcpy( m_Sensor, "KAI4020C" ); strcpy( m_CameraModel, "4020c" ); m_CameraId = 85; m_InterlineCCD = true; m_SupportsSerialA = true; m_SupportsSerialB = true; m_SensorTypeCCD = true; m_TotalColumns = 2136; m_ImagingColumns = 2048; m_ClampColumns = 44; m_PreRoiSkipColumns = 0; m_PostRoiSkipColumns = 0; m_OverscanColumns = 44; m_TotalRows = 2072; m_ImagingRows = 2048; m_UnderscanRows = 16; m_OverscanRows = 8; m_VFlushBinning = 1; m_EnableSingleRowOffset = false; m_RowOffsetBinning = 1; m_HFlushDisable = false; m_ShutterCloseDelay = 0; m_PixelSizeX = 7.4; m_PixelSizeY = 7.4; m_Color = true; m_ReportedGainSixteenBit = 1; m_MinSuggestedExpTime = 0.05; m_CoolingSupported = true; m_RegulatedCoolingSupported = true; m_TempSetPoint = -20.0; m_TempRampRateOne = 700; m_TempRampRateTwo = 4000; m_TempBackoffPoint = 2.0; m_PrimaryADType = ApnAdType_Alta_Sixteen; m_AlternativeADType = ApnAdType_Alta_Twelve; //m_DefaultGainTwelveBit = 0; //m_DefaultOffsetTwelveBit = 100; m_DefaultRVoltage = 1000; set_vpattern(); set_hpattern_clamp_sixteen(); set_hpattern_skip_sixteen(); set_hpattern_roi_sixteen(); set_hpattern_clamp_twelve(); set_hpattern_skip_twelve(); set_hpattern_roi_twelve(); } void CApnCamData_KAI4020C::set_vpattern() { const unsigned short Mask = 0x106; const unsigned short NumElements = 38; unsigned short Pattern[NumElements] = { 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0302, 0x0302, 0x0302, 0x0302, 0x0302, 0x0302, 0x0302, 0x0302, 0x0302, 0x0302, 0x0002, 0x0002, 0x0002, 0x0003, 0x0002 }; m_VerticalPattern.Mask = Mask; m_VerticalPattern.NumElements = NumElements; m_VerticalPattern.PatternData = (unsigned short *)malloc(NumElements * sizeof(unsigned short)); for ( int i=0; iMask = Mask; Pattern->BinningLimit = BinningLimit; Pattern->RefNumElements = RefNumElements; Pattern->SigNumElements = SigNumElements; if ( RefNumElements > 0 ) { Pattern->RefPatternData = (unsigned short *)malloc(RefNumElements * sizeof(unsigned short)); for ( i=0; iRefPatternData[i] = RefPatternData[i]; } } if ( SigNumElements > 0 ) { Pattern->SigPatternData = (unsigned short *)malloc(SigNumElements * sizeof(unsigned short)); for ( i=0; iSigPatternData[i] = SigPatternData[i]; } } if ( BinningLimit > 0 ) { for ( i=0; iBinNumElements[i] = BinNumElements[i]; Pattern->BinPatternData[i] = (unsigned short *)malloc(BinNumElements[i] * sizeof(unsigned short)); for ( j=0; jBinPatternData[i][j] = BinPatternData[i][j]; } } } } libapogee2-2.2/ApnCamData_ASCENT0402ME2.cpp0000644000175000017500000002223511110507150015475 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_ASCENT0402ME2.cpp: Implementation file for the CApnCamData_ASCENT0402ME2 class. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #include "ApnCamData_ASCENT0402ME2.h" #include #include #include ///////////////////////////////////////////////////////////// // Construction/Destruction ///////////////////////////////////////////////////////////// CApnCamData_ASCENT0402ME2::CApnCamData_ASCENT0402ME2() { } CApnCamData_ASCENT0402ME2::~CApnCamData_ASCENT0402ME2() { } void CApnCamData_ASCENT0402ME2::Initialize() { strcpy( m_Sensor, "ASCENT0402ME2" ); strcpy( m_CameraModel, "2" ); m_CameraId = 257; m_InterlineCCD = false; m_SupportsSerialA = false; m_SupportsSerialB = false; m_SensorTypeCCD = true; m_TotalColumns = 18; m_ImagingColumns = 10; m_ClampColumns = 4; m_PreRoiSkipColumns = 0; m_PostRoiSkipColumns = 0; m_OverscanColumns = 4; m_TotalRows = 4; m_ImagingRows = 2; m_UnderscanRows = 1; m_OverscanRows = 1; m_VFlushBinning = 1; m_EnableSingleRowOffset = false; m_RowOffsetBinning = 1; m_HFlushDisable = false; m_ShutterCloseDelay = 10; m_PixelSizeX = 9; m_PixelSizeY = 9; m_Color = false; m_ReportedGainSixteenBit = 1.5; m_MinSuggestedExpTime = 50.0; m_CoolingSupported = true; m_RegulatedCoolingSupported = true; m_TempSetPoint = -20.0; m_TempRampRateOne = 1200; m_TempRampRateTwo = 4000; m_TempBackoffPoint = 2.0; m_PrimaryADType = ApnAdType_Ascent_Sixteen; m_AlternativeADType = ApnAdType_None; m_DefaultGainLeft = 0; m_DefaultOffsetLeft = 100; m_DefaultGainRight = 0; m_DefaultOffsetRight = 100; m_DefaultRVoltage = 1000; m_DefaultSpeed = 0x2; m_DefaultDataReduction = true; set_vpattern(); set_hpattern_clamp_sixteen(); set_hpattern_skip_sixteen(); set_hpattern_roi_sixteen(); set_hpattern_clamp_twelve(); set_hpattern_skip_twelve(); set_hpattern_roi_twelve(); } void CApnCamData_ASCENT0402ME2::set_vpattern() { const unsigned short Mask = 0x6; const unsigned short NumElements = 71; unsigned short Pattern[NumElements] = { 0x0000, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0001, 0x0000 }; m_VerticalPattern.Mask = Mask; m_VerticalPattern.NumElements = NumElements; m_VerticalPattern.PatternData = (unsigned short *)malloc(NumElements * sizeof(unsigned short)); for ( int i=0; iMask = Mask; Pattern->BinningLimit = BinningLimit; Pattern->RefNumElements = RefNumElements; Pattern->SigNumElements = SigNumElements; if ( RefNumElements > 0 ) { Pattern->RefPatternData = (unsigned short *)malloc(RefNumElements * sizeof(unsigned short)); for ( i=0; iRefPatternData[i] = RefPatternData[i]; } } if ( SigNumElements > 0 ) { Pattern->SigPatternData = (unsigned short *)malloc(SigNumElements * sizeof(unsigned short)); for ( i=0; iSigPatternData[i] = SigPatternData[i]; } } if ( BinningLimit > 0 ) { for ( i=0; iBinNumElements[i] = BinNumElements[i]; Pattern->BinPatternData[i] = (unsigned short *)malloc(BinNumElements[i] * sizeof(unsigned short)); for ( j=0; jBinPatternData[i][j] = BinPatternData[i][j]; } } } } libapogee2-2.2/ApnCamData_KAF16803.h0000644000175000017500000000220111110507150014345 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_KAF16803.h: Interface file for the CApnCamData_KAF16803 class. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #if _MSC_VER > 1000 #pragma once #endif // _MSC_VER> 1000 #include "ApnCamData.h" class CApnCamData_KAF16803 : public CApnCamData { public: CApnCamData_KAF16803(); virtual ~CApnCamData_KAF16803(); void Initialize(); private: void set_vpattern(); void set_hpattern_clamp_sixteen(); void set_hpattern_skip_sixteen(); void set_hpattern_roi_sixteen(); void set_hpattern_clamp_twelve(); void set_hpattern_skip_twelve(); void set_hpattern_roi_twelve(); void set_hpattern( APN_HPATTERN_FILE *Pattern, unsigned short Mask, unsigned short BinningLimit, unsigned short RefNumElements, unsigned short SigNumElements, unsigned short BinNumElements[], unsigned short RefPatternData[], unsigned short SigPatternData[], unsigned short BinPatternData[][APN_MAX_PATTERN_ENTRIES] ); }; libapogee2-2.2/ApnFilterWheel.h0000644000175000017500000000306111110507150014207 0ustar jrjr// ApnFilterWheel.h: interface for the CApnFilterWheel class. // // Copyright (c) 2007 Apogee Instruments, Inc. ////////////////////////////////////////////////////////////////////// #if !defined(AFX_APNFILTERWHEEL_H__6B02FF9C_AB8E_4488_A166_04C6B378E35E__INCLUDED_) #define AFX_APNFILTERWHEEL_H__6B02FF9C_AB8E_4488_A166_04C6B378E35E__INCLUDED_ #if _MSC_VER > 1000 #pragma once #endif // _MSC_VER > 1000 #include "Apogee.h" class CApnFilterWheel { public: CApnFilterWheel(); virtual ~CApnFilterWheel(); bool Init( Apn_Filter FilterType, unsigned long DeviceNum ); bool Close(); bool GetVendorId( unsigned short *VendorId ); bool GetProductId( unsigned short *ProductId ); bool GetDeviceId( unsigned short *DeviceId ); bool GetUsbFirmwareRev( char *FirmwareRev, long *BufferLength ); bool GetWheelType( Apn_Filter *WheelType ); bool GetWheelModel( char *WheelDescr, long *BufferLength ); bool GetStatus( Apn_FilterStatus *FilterStatus ); bool GetMaxPositions( unsigned long *MaxPositions ); bool SetPosition( unsigned long Position ); bool GetPosition( unsigned long *Position ); private: bool m_ConnectionOpen; unsigned long m_DeviceNum; unsigned short m_VendorId; unsigned short m_ProductId; unsigned short m_DeviceId; Apn_Filter m_WheelType; unsigned long m_MaxPositions; char m_SysDeviceName[1024]; void InitMemberVars(); // message map functions }; #endif // !defined(AFX_APNFILTERWHEEL_H__6B02FF9C_AB8E_4488_A166_04C6B378E35E__INCLUDED_) libapogee2-2.2/ApnCamData_KAF3200EB.h0000644000175000017500000000220611110507150014464 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_KAF3200EB.h: Interface file for the CApnCamData_KAF3200EB class. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #if _MSC_VER > 1000 #pragma once #endif // _MSC_VER> 1000 #include "ApnCamData.h" class CApnCamData_KAF3200EB : public CApnCamData { public: CApnCamData_KAF3200EB(); virtual ~CApnCamData_KAF3200EB(); void Initialize(); private: void set_vpattern(); void set_hpattern_clamp_sixteen(); void set_hpattern_skip_sixteen(); void set_hpattern_roi_sixteen(); void set_hpattern_clamp_twelve(); void set_hpattern_skip_twelve(); void set_hpattern_roi_twelve(); void set_hpattern( APN_HPATTERN_FILE *Pattern, unsigned short Mask, unsigned short BinningLimit, unsigned short RefNumElements, unsigned short SigNumElements, unsigned short BinNumElements[], unsigned short RefPatternData[], unsigned short SigPatternData[], unsigned short BinPatternData[][APN_MAX_PATTERN_ENTRIES] ); }; libapogee2-2.2/ApnCamData_KAI11000ML.h0000644000175000017500000000221311110507150014564 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_KAI11000ML.h: Interface file for the CApnCamData_KAI11000ML class. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #if _MSC_VER > 1000 #pragma once #endif // _MSC_VER> 1000 #include "ApnCamData.h" class CApnCamData_KAI11000ML : public CApnCamData { public: CApnCamData_KAI11000ML(); virtual ~CApnCamData_KAI11000ML(); void Initialize(); private: void set_vpattern(); void set_hpattern_clamp_sixteen(); void set_hpattern_skip_sixteen(); void set_hpattern_roi_sixteen(); void set_hpattern_clamp_twelve(); void set_hpattern_skip_twelve(); void set_hpattern_roi_twelve(); void set_hpattern( APN_HPATTERN_FILE *Pattern, unsigned short Mask, unsigned short BinningLimit, unsigned short RefNumElements, unsigned short SigNumElements, unsigned short BinNumElements[], unsigned short RefPatternData[], unsigned short SigPatternData[], unsigned short BinPatternData[][APN_MAX_PATTERN_ENTRIES] ); }; libapogee2-2.2/ApnCamData_CCD5520B.cpp0000644000175000017500000004430611110507150014720 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_CCD5520B.cpp: Implementation file for the CApnCamData_CCD5520B class. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #include "ApnCamData_CCD5520B.h" #include #include #include ///////////////////////////////////////////////////////////// // Construction/Destruction ///////////////////////////////////////////////////////////// CApnCamData_CCD5520B::CApnCamData_CCD5520B() { } CApnCamData_CCD5520B::~CApnCamData_CCD5520B() { } void CApnCamData_CCD5520B::Initialize() { strcpy( m_Sensor, "CCD5520B" ); strcpy( m_CameraModel, "55" ); m_CameraId = 19; m_InterlineCCD = false; m_SupportsSerialA = true; m_SupportsSerialB = true; m_SensorTypeCCD = true; m_TotalColumns = 804; m_ImagingColumns = 770; m_ClampColumns = 17; m_PreRoiSkipColumns = 0; m_PostRoiSkipColumns = 0; m_OverscanColumns = 17; m_TotalRows = 1152; m_ImagingRows = 1152; m_UnderscanRows = 0; m_OverscanRows = 0; m_VFlushBinning = 1; m_EnableSingleRowOffset = false; m_RowOffsetBinning = 1; m_HFlushDisable = false; m_ShutterCloseDelay = 300; m_PixelSizeX = 22.5; m_PixelSizeY = 22.5; m_Color = false; m_ReportedGainSixteenBit = 2; m_MinSuggestedExpTime = 20.0; m_CoolingSupported = true; m_RegulatedCoolingSupported = true; m_TempSetPoint = -20.0; m_TempRampRateOne = 700; m_TempRampRateTwo = 4000; m_TempBackoffPoint = 2.0; m_PrimaryADType = ApnAdType_Alta_Sixteen; m_AlternativeADType = ApnAdType_Alta_Twelve; m_DefaultGainLeft = 400; m_DefaultOffsetLeft = 200; m_DefaultGainRight = -1; m_DefaultOffsetRight = -1; m_DefaultRVoltage = 1000; m_DefaultSpeed = 0xffff; m_DefaultDataReduction = false; set_vpattern(); set_hpattern_clamp_sixteen(); set_hpattern_skip_sixteen(); set_hpattern_roi_sixteen(); set_hpattern_clamp_twelve(); set_hpattern_skip_twelve(); set_hpattern_roi_twelve(); } void CApnCamData_CCD5520B::set_vpattern() { const unsigned short Mask = 0xE; const unsigned short NumElements = 247; unsigned short Pattern[NumElements] = { 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x000A, 0x000A, 0x000A, 0x000A, 0x000A, 0x000A, 0x000A, 0x000A, 0x000A, 0x000A, 0x000A, 0x000A, 0x000A, 0x000A, 0x000A, 0x000A, 0x000A, 0x000A, 0x000A, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0001, 0x0000 }; m_VerticalPattern.Mask = Mask; m_VerticalPattern.NumElements = NumElements; m_VerticalPattern.PatternData = (unsigned short *)malloc(NumElements * sizeof(unsigned short)); for ( int i=0; iMask = Mask; Pattern->BinningLimit = BinningLimit; Pattern->RefNumElements = RefNumElements; Pattern->SigNumElements = SigNumElements; if ( RefNumElements > 0 ) { Pattern->RefPatternData = (unsigned short *)malloc(RefNumElements * sizeof(unsigned short)); for ( i=0; iRefPatternData[i] = RefPatternData[i]; } } if ( SigNumElements > 0 ) { Pattern->SigPatternData = (unsigned short *)malloc(SigNumElements * sizeof(unsigned short)); for ( i=0; iSigPatternData[i] = SigPatternData[i]; } } if ( BinningLimit > 0 ) { for ( i=0; iBinNumElements[i] = BinNumElements[i]; Pattern->BinPatternData[i] = (unsigned short *)malloc(BinNumElements[i] * sizeof(unsigned short)); for ( j=0; jBinPatternData[i][j] = BinPatternData[i][j]; } } } } libapogee2-2.2/ApnCamData_KAI2001M.h0000644000175000017500000000212611110507150014374 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_KAI2001M.h: Interface file for the CApnCamData_KAI2001M class. // ///////////////////////////////////////////////////////////// #if _MSC_VER > 1000 #pragma once #endif // _MSC_VER> 1000 #include "ApnCamData.h" class CApnCamData_KAI2001M : public CApnCamData { public: CApnCamData_KAI2001M(); virtual ~CApnCamData_KAI2001M(); void Initialize(); private: void set_vpattern(); void set_hpattern_clamp_sixteen(); void set_hpattern_skip_sixteen(); void set_hpattern_roi_sixteen(); void set_hpattern_clamp_twelve(); void set_hpattern_skip_twelve(); void set_hpattern_roi_twelve(); void set_hpattern( APN_HPATTERN_FILE *Pattern, unsigned short Mask, unsigned short BinningLimit, unsigned short RefNumElements, unsigned short SigNumElements, unsigned short BinNumElements[], unsigned short RefPatternData[], unsigned short SigPatternData[], unsigned short BinPatternData[][APN_MAX_PATTERN_ENTRIES] ); }; libapogee2-2.2/ApnSerial_USB.h0000644000175000017500000000250111110507150013723 0ustar jrjr// ApnSerial_USB.h: interface for the CApnSerial_USB class. // ////////////////////////////////////////////////////////////////////// #if !defined(AFX_APNSERIAL_USB_H__D7A1A328_6505_438F_BCCE_FA3F3B5EECC2__INCLUDED_) #define AFX_APNSERIAL_USB_H__D7A1A328_6505_438F_BCCE_FA3F3B5EECC2__INCLUDED_ #if _MSC_VER > 1000 #pragma once #endif // _MSC_VER > 1000 #include "ApnSerial.h" class CApnSerial_USB : public CApnSerial { public: CApnSerial_USB(); virtual ~CApnSerial_USB(); bool InitPort( unsigned long CamIdA, unsigned short CamIdB, unsigned short SerialId ); bool ClosePort(); bool GetBaudRate(unsigned long *BaudRate ); bool SetBaudRate(unsigned long BaudRate ); bool GetFlowControl( Apn_SerialFlowControl *FlowControl ); bool SetFlowControl( Apn_SerialFlowControl FlowControl ); bool GetParity( Apn_SerialParity *Parity ); bool SetParity( Apn_SerialParity Parity ); bool Read(int dummy, char *ReadBuffer, unsigned short *ReadCount ); bool Write( int dummy, char *WriteBuffer, unsigned short WriteCount ); char *ReadBuffer(void); private: bool m_ConnectionOpen; long m_hSysDriver; char m_SysDeviceName[1024]; }; #endif // !defined(AFX_APNSERIAL_USB_H__D7A1A328_6505_438F_BCCE_FA3F3B5EECC2__INCLUDED_) libapogee2-2.2/ApnCamData_ASCENT4000.cpp0000644000175000017500000002217411110507150015171 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_ASCENT4000.cpp: Implementation file for the CApnCamData_ASCENT4000 class. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #include "ApnCamData_ASCENT4000.h" #include #include #include ///////////////////////////////////////////////////////////// // Construction/Destruction ///////////////////////////////////////////////////////////// CApnCamData_ASCENT4000::CApnCamData_ASCENT4000() { } CApnCamData_ASCENT4000::~CApnCamData_ASCENT4000() { } void CApnCamData_ASCENT4000::Initialize() { strcpy( m_Sensor, "ASCENT4000" ); strcpy( m_CameraModel, "4000" ); m_CameraId = 321; m_InterlineCCD = true; m_SupportsSerialA = false; m_SupportsSerialB = false; m_SensorTypeCCD = true; m_TotalColumns = 4942; m_ImagingColumns = 4872; m_ClampColumns = 35; m_PreRoiSkipColumns = 0; m_PostRoiSkipColumns = 0; m_OverscanColumns = 35; m_TotalRows = 3324; m_ImagingRows = 3248; m_UnderscanRows = 56; m_OverscanRows = 20; m_VFlushBinning = 4; m_EnableSingleRowOffset = false; m_RowOffsetBinning = 1; m_HFlushDisable = false; m_ShutterCloseDelay = 0; m_PixelSizeX = 7.4; m_PixelSizeY = 7.4; m_Color = false; m_ReportedGainSixteenBit = 0.8; m_MinSuggestedExpTime = 0.1; m_CoolingSupported = true; m_RegulatedCoolingSupported = true; m_TempSetPoint = -20.0; m_TempRampRateOne = 1200; m_TempRampRateTwo = 4000; m_TempBackoffPoint = 2.0; m_PrimaryADType = ApnAdType_Ascent_Sixteen; m_AlternativeADType = ApnAdType_None; m_DefaultGainLeft = 0; m_DefaultOffsetLeft = 100; m_DefaultGainRight = 0; m_DefaultOffsetRight = 100; m_DefaultRVoltage = 1000; m_DefaultSpeed = 0x0; m_DefaultDataReduction = true; set_vpattern(); set_hpattern_clamp_sixteen(); set_hpattern_skip_sixteen(); set_hpattern_roi_sixteen(); set_hpattern_clamp_twelve(); set_hpattern_skip_twelve(); set_hpattern_roi_twelve(); } void CApnCamData_ASCENT4000::set_vpattern() { const unsigned short Mask = 0x6; const unsigned short NumElements = 71; unsigned short Pattern[NumElements] = { 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0202, 0x0202, 0x0202, 0x0202, 0x0202, 0x0202, 0x0202, 0x0202, 0x0202, 0x0202, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0003, 0x0002 }; m_VerticalPattern.Mask = Mask; m_VerticalPattern.NumElements = NumElements; m_VerticalPattern.PatternData = (unsigned short *)malloc(NumElements * sizeof(unsigned short)); for ( int i=0; iMask = Mask; Pattern->BinningLimit = BinningLimit; Pattern->RefNumElements = RefNumElements; Pattern->SigNumElements = SigNumElements; if ( RefNumElements > 0 ) { Pattern->RefPatternData = (unsigned short *)malloc(RefNumElements * sizeof(unsigned short)); for ( i=0; iRefPatternData[i] = RefPatternData[i]; } } if ( SigNumElements > 0 ) { Pattern->SigPatternData = (unsigned short *)malloc(SigNumElements * sizeof(unsigned short)); for ( i=0; iSigPatternData[i] = SigPatternData[i]; } } if ( BinningLimit > 0 ) { for ( i=0; iBinNumElements[i] = BinNumElements[i]; Pattern->BinPatternData[i] = (unsigned short *)malloc(BinNumElements[i] * sizeof(unsigned short)); for ( j=0; jBinPatternData[i][j] = BinPatternData[i][j]; } } } } libapogee2-2.2/CameraIO_LinuxPPI.cpp0000644000175000017500000002230311110507150015041 0ustar jrjr// CameraIO.cpp: implementation of the CCameraIO class. // // Copyright (c) 2000 Apogee Instruments Inc. ////////////////////////////////////////////////////////////////////// #ifndef LINUX #include "stdafx.h" #else #include #include #include #include #include #include #include #include #include #define HANDLE int #define FALSE 0 #define DWORD long #define _ASSERT assert #define REALTIME_PRIORITY_CLASS 1 #define GetCurrentProcess getpid #define LOBYTE(x) ((x) & 0xff) #define HIBYTE(x) ((x >> 8) & 0xff) #endif #define MIRQ1 0x21 #define MIRQ2 0xA1 #include "time.h" #include "tcl.h" #include "ccd.h" #include "CameraIO_Linux.h" #include "ApogeeLinux.h" const int NUM_POSITIONS = 6; const int NUM_STEPS_PER_FILTER = 48; const int STEP_DELAY = 10; const unsigned char Steps[] = { 0x10, 0x30, 0x20, 0x60, 0x40, 0xc0, 0x80, 0x90 }; const int NUM_STEPS = sizeof ( Steps ); ////////////////////////////////////////////////////////////////////// // Construction/Destruction ////////////////////////////////////////////////////////////////////// void CCameraIO::InitDefaults() { //////////////////////////////////////////////////////////// // Camera Settings m_HighPriority = true; m_PPRepeat = 1; m_DataBits = 16; m_FastShutter = false; m_MaxBinX = 8; m_MaxBinY = 63; m_MaxExposure = 10485.75; m_MinExposure = 0.01; m_GuiderRelays = false; m_Timeout = 2.0; //////////////////////////////////////////////////////////// // Cooler Settings m_TempControl = true; m_TempCalibration = 160; m_TempScale = 2.1; //////////////////////////////////////////////////////////// // Exposure Settings m_BinX = 1; m_BinY = 1; m_StartX = 0; m_StartY = 0; m_NumX = 1; m_NumY = 1; //////////////////////////////////////////////////////////// // Geometry Settings m_Columns = 0; m_Rows = 0; m_SkipC = 0; m_SkipR = 0; m_HFlush = 1; m_VFlush = 1; m_BIC = 4; m_BIR = 4; m_ImgColumns = 0; m_ImgRows = 0; //////////////////////////////////////////////////////////// // CCD Settings memset( m_Sensor, 0, 256 ); m_Color = false; m_Noise = 0.0; m_Gain = 0.0; m_PixelXSize = 0.0; m_PixelYSize = 0.0; //////////////////////////////////////////////////////////// // Internal variables fileHandle = 0; m_RegisterOffset = 0; m_Interface = Camera_Interface_PPI; m_SensorType = Camera_SensorType_CCD; } bool CCameraIO::InitDriver(unsigned short camnum) { char deviceName[64]; sprintf(deviceName,"%s%d",APOGEE_PPI_DEVICE,camnum); fileHandle = ::open(deviceName,O_RDONLY); if (fileHandle == -1) return false; return true; } long CCameraIO::Write( unsigned short reg, unsigned short val ) { int status; struct apIOparam request; unsigned short realreg = ( reg << 1 ) & 0xE; // limit input to our address range request.reg = realreg; request.param1=(int)val; request.param2=(int)m_PPRepeat; status=ioctl(fileHandle,APPPI_WRITE_USHORT,(unsigned long)&request); return 0; } long CCameraIO::Read( unsigned short reg, unsigned short& val ) { unsigned short realreg; int retval, status; struct apIOparam request; switch ( reg ) { case Reg_ImageData: realreg = RegISA_ImageData; break; case Reg_TempData: realreg = RegISA_TempData; break; case Reg_Status: realreg = RegISA_Status; break; case Reg_CommandReadback: realreg = RegISA_CommandReadback; break; default: assert( 1 ); // application program bug val = 0; return 0; } request.reg = realreg; request.param1=(unsigned long)&retval; request.param2=(int)m_PPRepeat; status=ioctl(fileHandle,APPPI_READ_USHORT,(unsigned long)&request); val = (unsigned short)retval; return 0; } // Returns 0 if successfull, 1 if Line_Done poll timed out. long CCameraIO::ReadLine( long SkipPixels, long Pixels,unsigned short* pLineBuffer ) { int j; int retval, status; struct apIOparam request; if ( !m_TDI ) { ///////////////////////////////////// // Clock out the line m_RegShadow[ Reg_Command ] |= RegBit_StartNextLine; // set bit to 1 Write( Reg_Command, m_RegShadow[ Reg_Command ] ); m_RegShadow[ Reg_Command ] &= ~RegBit_StartNextLine; // set bit to 0 Write( Reg_Command, m_RegShadow[ Reg_Command ] ); ///////////////////////////////////// } request.reg = RegISA_ImageData; request.param1=(unsigned long)&retval; request.param2=(int)m_PPRepeat; for (j = 0; j < SkipPixels; j++) { status=ioctl(fileHandle,APPPI_READ_USHORT,(unsigned long)&request); } for (j = 0; j < Pixels; j++) { status=ioctl(fileHandle,APPPI_READ_USHORT,(unsigned long)&request); *pLineBuffer++ = (unsigned short)retval; } ///////////////////////////////////// // Assert done reading line m_RegShadow[ Reg_Command ] |= RegBit_DoneReading; // set bit to 1 Write( Reg_Command, m_RegShadow[ Reg_Command ] ); m_RegShadow[ Reg_Command ] &= ~RegBit_DoneReading; // set bit to 0 Write( Reg_Command, m_RegShadow[ Reg_Command ] ); ///////////////////////////////////// if ( !m_TDI ) { ///////////////////////////////////// // Wait until camera is done clock_t StopTime = clock() + CLOCKS_PER_SEC; // wait at most one second while ( true ) { unsigned short val = 0; Read( Reg_Status, val ); if ( ( val & RegBit_LineDone ) != 0 ) break;// Line done if ( clock() > StopTime ) return 1; // Timed out } } return 0; } long CCameraIO::ReadImage( unsigned short* pImageBuffer ) { m_RegShadow[ Reg_Command ] |= RegBit_FIFOCache; // set bit to 1 Write( Reg_Command, m_RegShadow[ Reg_Command ] ); long XEnd = long( m_ExposureNumX ); long SkipC = long( m_ExposureSkipC ); for (long i = 0; i < m_ExposureSkipR; i++) { if( InternalReadLine( false, SkipC, XEnd, NULL ) ) return 1; } long YEnd = long( m_ExposureNumY ); unsigned short* pLineBuffer = pImageBuffer; for (long i = 0; i < YEnd; i++) { if ( InternalReadLine( true, SkipC, XEnd, pLineBuffer ) ) return 1; pLineBuffer += XEnd; } m_RegShadow[ Reg_Command ] &= !RegBit_FIFOCache; // set bit to 0 Write( Reg_Command, m_RegShadow[ Reg_Command ] ); return 0; } // Returns 0 if successfull, 1 if Line_Done poll timed out. long CCameraIO::InternalReadLine( bool KeepData, long SkipC, long XEnd, unsigned short* pLineBuffer ) { struct apIOparam request; int retval, status; ///////////////////////////////////// // Clock out the line m_RegShadow[ Reg_Command ] |= RegBit_StartNextLine; // set bit to 1 Write( Reg_Command, m_RegShadow[ Reg_Command ] ); m_RegShadow[ Reg_Command ] &= !RegBit_StartNextLine; // set bit to 0 Write( Reg_Command, m_RegShadow[ Reg_Command ] ); ///////////////////////////////////// request.reg = RegISA_ImageData; request.param1=(unsigned long)&retval; request.param2=(int)m_PPRepeat; for (long j = 0; j < SkipC; j++) status=ioctl(fileHandle,APPPI_READ_USHORT,(unsigned long)&request); if ( KeepData ) { for (long j = 0; j < XEnd; j++) { status=ioctl(fileHandle,APPPI_READ_USHORT,(unsigned long)&request); *pLineBuffer++ = (unsigned short)retval; } } else { for (long j = 0; j < XEnd; j++) status=ioctl(fileHandle,APPPI_READ_USHORT,(unsigned long)&request); } ///////////////////////////////////// // Assert done reading line m_RegShadow[ Reg_Command ] |= RegBit_DoneReading; // set bit to 1 Write( Reg_Command, m_RegShadow[ Reg_Command ] ); m_RegShadow[ Reg_Command ] &= !RegBit_DoneReading; // set bit to 0 Write( Reg_Command, m_RegShadow[ Reg_Command ] ); ///////////////////////////////////// ///////////////////////////////////// // Wait until camera is done clocking clock_t StopTime = clock() + CLOCKS_PER_SEC; // wait at most one second while ( true ) { unsigned short val = 0; Read( Reg_Status, val ); if ( ( val & RegBit_LineDone ) != 0 ) break;// Line done clock_t CurrentTime = clock(); if ( CurrentTime > StopTime ) return 1; // Timed out } return 0; } libapogee2-2.2/ApnCamData_CCD5710.h0000644000175000017500000000217411110507150014261 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_CCD5710.h: Interface file for the CApnCamData_CCD5710 class. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #if _MSC_VER > 1000 #pragma once #endif // _MSC_VER> 1000 #include "ApnCamData.h" class CApnCamData_CCD5710 : public CApnCamData { public: CApnCamData_CCD5710(); virtual ~CApnCamData_CCD5710(); void Initialize(); private: void set_vpattern(); void set_hpattern_clamp_sixteen(); void set_hpattern_skip_sixteen(); void set_hpattern_roi_sixteen(); void set_hpattern_clamp_twelve(); void set_hpattern_skip_twelve(); void set_hpattern_roi_twelve(); void set_hpattern( APN_HPATTERN_FILE *Pattern, unsigned short Mask, unsigned short BinningLimit, unsigned short RefNumElements, unsigned short SigNumElements, unsigned short BinNumElements[], unsigned short RefPatternData[], unsigned short SigPatternData[], unsigned short BinPatternData[][APN_MAX_PATTERN_ENTRIES] ); }; libapogee2-2.2/ApnCamData_CCD5520.cpp0000644000175000017500000004435111110507150014616 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_CCD5520.cpp: Implementation file for the CApnCamData_CCD5520 class. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #include "ApnCamData_CCD5520.h" #include #include #include ///////////////////////////////////////////////////////////// // Construction/Destruction ///////////////////////////////////////////////////////////// CApnCamData_CCD5520::CApnCamData_CCD5520() { } CApnCamData_CCD5520::~CApnCamData_CCD5520() { } void CApnCamData_CCD5520::Initialize() { strcpy( m_Sensor, "CCD5520" ); strcpy( m_CameraModel, "55" ); m_CameraId = 22; m_InterlineCCD = false; m_SupportsSerialA = true; m_SupportsSerialB = true; m_SensorTypeCCD = true; m_TotalColumns = 804; m_ImagingColumns = 770; m_ClampColumns = 17; m_PreRoiSkipColumns = 0; m_PostRoiSkipColumns = 0; m_OverscanColumns = 17; m_TotalRows = 1152; m_ImagingRows = 1152; m_UnderscanRows = 0; m_OverscanRows = 0; m_VFlushBinning = 1; m_EnableSingleRowOffset = false; m_RowOffsetBinning = 1; m_HFlushDisable = false; m_ShutterCloseDelay = 300; m_PixelSizeX = 22.5; m_PixelSizeY = 22.5; m_Color = false; m_ReportedGainSixteenBit = 2; m_MinSuggestedExpTime = 20.0; m_CoolingSupported = true; m_RegulatedCoolingSupported = true; m_TempSetPoint = -20.0; m_TempRampRateOne = 700; m_TempRampRateTwo = 4000; m_TempBackoffPoint = 2.0; m_PrimaryADType = ApnAdType_Alta_Sixteen; m_AlternativeADType = ApnAdType_Alta_Twelve; m_DefaultGainLeft = 400; m_DefaultOffsetLeft = 200; m_DefaultGainRight = -1; m_DefaultOffsetRight = -1; m_DefaultRVoltage = 1000; m_DefaultSpeed = 0xffff; m_DefaultDataReduction = false; set_vpattern(); set_hpattern_clamp_sixteen(); set_hpattern_skip_sixteen(); set_hpattern_roi_sixteen(); set_hpattern_clamp_twelve(); set_hpattern_skip_twelve(); set_hpattern_roi_twelve(); } void CApnCamData_CCD5520::set_vpattern() { const unsigned short Mask = 0x0; const unsigned short NumElements = 253; unsigned short Pattern[NumElements] = { 0x0000, 0x0000, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x000A, 0x000A, 0x000A, 0x000A, 0x000A, 0x000A, 0x000A, 0x000A, 0x000A, 0x000A, 0x000A, 0x000A, 0x000A, 0x000A, 0x000A, 0x000A, 0x000A, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0000, 0x0000, 0x0000, 0x0001, 0x0000 }; m_VerticalPattern.Mask = Mask; m_VerticalPattern.NumElements = NumElements; m_VerticalPattern.PatternData = (unsigned short *)malloc(NumElements * sizeof(unsigned short)); for ( int i=0; iMask = Mask; Pattern->BinningLimit = BinningLimit; Pattern->RefNumElements = RefNumElements; Pattern->SigNumElements = SigNumElements; if ( RefNumElements > 0 ) { Pattern->RefPatternData = (unsigned short *)malloc(RefNumElements * sizeof(unsigned short)); for ( i=0; iRefPatternData[i] = RefPatternData[i]; } } if ( SigNumElements > 0 ) { Pattern->SigPatternData = (unsigned short *)malloc(SigNumElements * sizeof(unsigned short)); for ( i=0; iSigPatternData[i] = SigPatternData[i]; } } if ( BinningLimit > 0 ) { for ( i=0; iBinNumElements[i] = BinNumElements[i]; Pattern->BinPatternData[i] = (unsigned short *)malloc(BinNumElements[i] * sizeof(unsigned short)); for ( j=0; jBinPatternData[i][j] = BinPatternData[i][j]; } } } } libapogee2-2.2/ApnCamData_KAF09000H.cpp0000644000175000017500000006064611110507150015020 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_KAF09000H.cpp: Implementation file for the CApnCamData_KAF09000H class. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #include "ApnCamData_KAF09000H.h" #include #include #include ///////////////////////////////////////////////////////////// // Construction/Destruction ///////////////////////////////////////////////////////////// CApnCamData_KAF09000H::CApnCamData_KAF09000H() { } CApnCamData_KAF09000H::~CApnCamData_KAF09000H() { } void CApnCamData_KAF09000H::Initialize() { strcpy( m_Sensor, "KAF09000H" ); strcpy( m_CameraModel, "9000h" ); m_CameraId = 39; m_InterlineCCD = false; m_SupportsSerialA = true; m_SupportsSerialB = true; m_SensorTypeCCD = true; m_TotalColumns = 3103; m_ImagingColumns = 3056; m_ClampColumns = 35; m_PreRoiSkipColumns = 0; m_PostRoiSkipColumns = 0; m_OverscanColumns = 12; m_TotalRows = 3086; m_ImagingRows = 3056; m_UnderscanRows = 20; m_OverscanRows = 10; m_VFlushBinning = 1; m_EnableSingleRowOffset = false; m_RowOffsetBinning = 1; m_HFlushDisable = false; m_ShutterCloseDelay = 300; m_PixelSizeX = 12; m_PixelSizeY = 12; m_Color = false; m_ReportedGainSixteenBit = 1.5; m_MinSuggestedExpTime = 30.0; m_CoolingSupported = true; m_RegulatedCoolingSupported = true; m_TempSetPoint = -20.0; m_TempRampRateOne = 1500; m_TempRampRateTwo = 4000; m_TempBackoffPoint = 2.0; m_PrimaryADType = ApnAdType_Alta_Sixteen; m_AlternativeADType = ApnAdType_Alta_Twelve; m_DefaultGainLeft = 0; m_DefaultOffsetLeft = 150; m_DefaultGainRight = -1; m_DefaultOffsetRight = -1; m_DefaultRVoltage = 1000; m_DefaultSpeed = 0xffff; m_DefaultDataReduction = false; set_vpattern(); set_hpattern_clamp_sixteen(); set_hpattern_skip_sixteen(); set_hpattern_roi_sixteen(); set_hpattern_clamp_twelve(); set_hpattern_skip_twelve(); set_hpattern_roi_twelve(); } void CApnCamData_KAF09000H::set_vpattern() { const unsigned short Mask = 0x0; const unsigned short NumElements = 116; unsigned short Pattern[NumElements] = { 0x0000, 0x0000, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0202, 0x0202, 0x0202, 0x0202, 0x0202, 0x0202, 0x0202, 0x0202, 0x0202, 0x0202, 0x0002, 0x0002, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0001, 0x0000 }; m_VerticalPattern.Mask = Mask; m_VerticalPattern.NumElements = NumElements; m_VerticalPattern.PatternData = (unsigned short *)malloc(NumElements * sizeof(unsigned short)); for ( int i=0; iMask = Mask; Pattern->BinningLimit = BinningLimit; Pattern->RefNumElements = RefNumElements; Pattern->SigNumElements = SigNumElements; if ( RefNumElements > 0 ) { Pattern->RefPatternData = (unsigned short *)malloc(RefNumElements * sizeof(unsigned short)); for ( i=0; iRefPatternData[i] = RefPatternData[i]; } } if ( SigNumElements > 0 ) { Pattern->SigPatternData = (unsigned short *)malloc(SigNumElements * sizeof(unsigned short)); for ( i=0; iSigPatternData[i] = SigPatternData[i]; } } if ( BinningLimit > 0 ) { for ( i=0; iBinNumElements[i] = BinNumElements[i]; Pattern->BinPatternData[i] = (unsigned short *)malloc(BinNumElements[i] * sizeof(unsigned short)); for ( j=0; jBinPatternData[i][j] = BinPatternData[i][j]; } } } } libapogee2-2.2/CameraIO_LinuxISA.cpp0000644000175000017500000002204211110507150015025 0ustar jrjr// CameraIO.cpp: implementation of the CCameraIO class. // // Copyright (c) 2000 Apogee Instruments Inc. ////////////////////////////////////////////////////////////////////// #ifndef LINUX #include "stdafx.h" #else #include #include #include #include #include #include #include #include #include #define HANDLE int #define FALSE 0 #define DWORD long #define _ASSERT assert #define REALTIME_PRIORITY_CLASS 1 #define GetCurrentProcess getpid #define LOBYTE(x) ((x) & 0xff) #define HIBYTE(x) ((x >> 8) & 0xff) #endif #define MIRQ1 0x21 #define MIRQ2 0xA1 #include "time.h" #include "tcl.h" #include "ccd.h" #include "CameraIO_Linux.h" #include "ApogeeLinux.h" const int NUM_POSITIONS = 6; const int NUM_STEPS_PER_FILTER = 48; const int STEP_DELAY = 10; const unsigned char Steps[] = { 0x10, 0x30, 0x20, 0x60, 0x40, 0xc0, 0x80, 0x90 }; const int NUM_STEPS = sizeof ( Steps ); ////////////////////////////////////////////////////////////////////// // Construction/Destruction ////////////////////////////////////////////////////////////////////// void CCameraIO::InitDefaults() { //////////////////////////////////////////////////////////// // Camera Settings m_HighPriority = true; m_PPRepeat = 1; m_DataBits = 16; m_FastShutter = false; m_MaxBinX = 8; m_MaxBinY = 63; m_MaxExposure = 10485.75; m_MinExposure = 0.01; m_GuiderRelays = false; m_Timeout = 2.0; //////////////////////////////////////////////////////////// // Cooler Settings m_TempControl = true; m_TempCalibration = 160; m_TempScale = 2.1; //////////////////////////////////////////////////////////// // Exposure Settings m_BinX = 1; m_BinY = 1; m_StartX = 0; m_StartY = 0; m_NumX = 1; m_NumY = 1; //////////////////////////////////////////////////////////// // Geometry Settings m_Columns = 0; m_Rows = 0; m_SkipC = 0; m_SkipR = 0; m_HFlush = 1; m_VFlush = 1; m_BIC = 4; m_BIR = 4; m_ImgColumns = 0; m_ImgRows = 0; //////////////////////////////////////////////////////////// // CCD Settings memset( m_Sensor, 0, 256 ); m_Color = false; m_Noise = 0.0; m_Gain = 0.0; m_PixelXSize = 0.0; m_PixelYSize = 0.0; //////////////////////////////////////////////////////////// // Internal variables fileHandle = 0; m_RegisterOffset = 0; m_Interface = Camera_Interface_ISA; m_SensorType = Camera_SensorType_CCD; } bool CCameraIO::InitDriver(unsigned short camnum) { char deviceName[64]; sprintf(deviceName,"%s%d",APOGEE_ISA_DEVICE,camnum); fileHandle = ::open(deviceName,O_RDONLY); if (fileHandle == -1) return false; return true; } long CCameraIO::Write( unsigned short reg, unsigned short val ) { int status; struct apIOparam request; unsigned short realreg = ( reg << 1 ) & 0xE; // limit input to our address range request.reg = realreg; request.param1=(int)val; status=ioctl(fileHandle,APISA_WRITE_USHORT,(unsigned long)&request); return 0; } long CCameraIO::Read( unsigned short reg, unsigned short& val ) { unsigned short realreg; int retval, status; struct apIOparam request; switch ( reg ) { case Reg_ImageData: realreg = RegISA_ImageData; break; case Reg_TempData: realreg = RegISA_TempData; break; case Reg_Status: realreg = RegISA_Status; break; case Reg_CommandReadback: realreg = RegISA_CommandReadback; break; default: assert( 1 ); // application program bug val = 0; return 0; } request.reg = realreg; request.param1=(unsigned long)&retval; status=ioctl(fileHandle,APISA_READ_USHORT,(unsigned long)&request); val = (unsigned short)retval; return 0; } // Returns 0 if successfull, 1 if Line_Done poll timed out. long CCameraIO::ReadLine( long SkipPixels, long Pixels,unsigned short* pLineBuffer ) { int j; int retval, status; struct apIOparam request; if ( !m_TDI ) { ///////////////////////////////////// // Clock out the line m_RegShadow[ Reg_Command ] |= RegBit_StartNextLine; // set bit to 1 Write( Reg_Command, m_RegShadow[ Reg_Command ] ); m_RegShadow[ Reg_Command ] &= ~RegBit_StartNextLine; // set bit to 0 Write( Reg_Command, m_RegShadow[ Reg_Command ] ); ///////////////////////////////////// } request.reg = RegISA_ImageData; request.param1=(unsigned long)&retval; for (j = 0; j < SkipPixels; j++) { status=ioctl(fileHandle,APISA_READ_USHORT,(unsigned long)&request); } for (j = 0; j < Pixels; j++) { status=ioctl(fileHandle,APISA_READ_USHORT,(unsigned long)&request); *pLineBuffer++ = (unsigned short)retval; } ///////////////////////////////////// // Assert done reading line m_RegShadow[ Reg_Command ] |= RegBit_DoneReading; // set bit to 1 Write( Reg_Command, m_RegShadow[ Reg_Command ] ); m_RegShadow[ Reg_Command ] &= ~RegBit_DoneReading; // set bit to 0 Write( Reg_Command, m_RegShadow[ Reg_Command ] ); ///////////////////////////////////// if ( !m_TDI ) { ///////////////////////////////////// // Wait until camera is done clock_t StopTime = clock() + CLOCKS_PER_SEC; // wait at most one second while ( true ) { unsigned short val = 0; Read( Reg_Status, val ); if ( ( val & RegBit_LineDone ) != 0 ) break;// Line done if ( clock() > StopTime ) return 1; // Timed out } } return 0; } long CCameraIO::ReadImage( unsigned short* pImageBuffer ) { m_RegShadow[ Reg_Command ] |= RegBit_FIFOCache; // set bit to 1 Write( Reg_Command, m_RegShadow[ Reg_Command ] ); long XEnd = long( m_ExposureNumX ); long SkipC = long( m_ExposureSkipC ); for (long i = 0; i < m_ExposureSkipR; i++) { if( InternalReadLine( false, SkipC, XEnd, NULL ) ) return 1; } long YEnd = long( m_ExposureNumY ); unsigned short* pLineBuffer = pImageBuffer; for (long i = 0; i < YEnd; i++) { if ( InternalReadLine( true, SkipC, XEnd, pLineBuffer ) ) return 1; pLineBuffer += XEnd; } m_RegShadow[ Reg_Command ] &= !RegBit_FIFOCache; // set bit to 0 Write( Reg_Command, m_RegShadow[ Reg_Command ] ); return 0; } // Returns 0 if successfull, 1 if Line_Done poll timed out. long CCameraIO::InternalReadLine( bool KeepData, long SkipC, long XEnd, unsigned short* pLineBuffer ) { struct apIOparam request; int retval, status; ///////////////////////////////////// // Clock out the line m_RegShadow[ Reg_Command ] |= RegBit_StartNextLine; // set bit to 1 Write( Reg_Command, m_RegShadow[ Reg_Command ] ); m_RegShadow[ Reg_Command ] &= !RegBit_StartNextLine; // set bit to 0 Write( Reg_Command, m_RegShadow[ Reg_Command ] ); ///////////////////////////////////// request.reg = RegISA_ImageData; request.param1=(unsigned long)&retval; for (long j = 0; j < SkipC; j++) status=ioctl(fileHandle,APISA_READ_USHORT,(unsigned long)&request); if ( KeepData ) { for (long j = 0; j < XEnd; j++) { status=ioctl(fileHandle,APISA_READ_USHORT,(unsigned long)&request); *pLineBuffer++ = (unsigned short)retval; } } else { for (long j = 0; j < XEnd; j++) status=ioctl(fileHandle,APISA_READ_USHORT,(unsigned long)&request); } ///////////////////////////////////// // Assert done reading line m_RegShadow[ Reg_Command ] |= RegBit_DoneReading; // set bit to 1 Write( Reg_Command, m_RegShadow[ Reg_Command ] ); m_RegShadow[ Reg_Command ] &= !RegBit_DoneReading; // set bit to 0 Write( Reg_Command, m_RegShadow[ Reg_Command ] ); ///////////////////////////////////// ///////////////////////////////////// // Wait until camera is done clocking clock_t StopTime = clock() + CLOCKS_PER_SEC; // wait at most one second while ( true ) { unsigned short val = 0; Read( Reg_Status, val ); if ( ( val & RegBit_LineDone ) != 0 ) break;// Line done clock_t CurrentTime = clock(); if ( CurrentTime > StopTime ) return 1; // Timed out } return 0; } libapogee2-2.2/ApnCamData_KAF16803.cpp0000644000175000017500000006151711110507150014717 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_KAF16803.cpp: Implementation file for the CApnCamData_KAF16803 class. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #include "ApnCamData_KAF16803.h" #include #include #include ///////////////////////////////////////////////////////////// // Construction/Destruction ///////////////////////////////////////////////////////////// CApnCamData_KAF16803::CApnCamData_KAF16803() { } CApnCamData_KAF16803::~CApnCamData_KAF16803() { } void CApnCamData_KAF16803::Initialize() { strcpy( m_Sensor, "KAF16803" ); strcpy( m_CameraModel, "16m" ); m_CameraId = 38; m_InterlineCCD = false; m_SupportsSerialA = true; m_SupportsSerialB = true; m_SensorTypeCCD = true; m_TotalColumns = 4145; m_ImagingColumns = 4098; m_ClampColumns = 35; m_PreRoiSkipColumns = 0; m_PostRoiSkipColumns = 0; m_OverscanColumns = 12; m_TotalRows = 4128; m_ImagingRows = 4098; m_UnderscanRows = 10; m_OverscanRows = 20; m_VFlushBinning = 1; m_EnableSingleRowOffset = false; m_RowOffsetBinning = 1; m_HFlushDisable = false; m_ShutterCloseDelay = 300; m_PixelSizeX = 9; m_PixelSizeY = 9; m_Color = false; m_ReportedGainSixteenBit = 1.5; m_MinSuggestedExpTime = 30.0; m_CoolingSupported = true; m_RegulatedCoolingSupported = true; m_TempSetPoint = -20.0; m_TempRampRateOne = 1500; m_TempRampRateTwo = 4000; m_TempBackoffPoint = 2.0; m_PrimaryADType = ApnAdType_Alta_Sixteen; m_AlternativeADType = ApnAdType_Alta_Twelve; m_DefaultGainLeft = 100; m_DefaultOffsetLeft = 255; m_DefaultGainRight = -1; m_DefaultOffsetRight = -1; m_DefaultRVoltage = 1000; m_DefaultSpeed = 0xffff; m_DefaultDataReduction = false; set_vpattern(); set_hpattern_clamp_sixteen(); set_hpattern_skip_sixteen(); set_hpattern_roi_sixteen(); set_hpattern_clamp_twelve(); set_hpattern_skip_twelve(); set_hpattern_roi_twelve(); } void CApnCamData_KAF16803::set_vpattern() { const unsigned short Mask = 0x0; const unsigned short NumElements = 116; unsigned short Pattern[NumElements] = { 0x0000, 0x0000, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0202, 0x0202, 0x0202, 0x0202, 0x0202, 0x0202, 0x0202, 0x0202, 0x0202, 0x0202, 0x0002, 0x0002, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0001, 0x0000 }; m_VerticalPattern.Mask = Mask; m_VerticalPattern.NumElements = NumElements; m_VerticalPattern.PatternData = (unsigned short *)malloc(NumElements * sizeof(unsigned short)); for ( int i=0; iMask = Mask; Pattern->BinningLimit = BinningLimit; Pattern->RefNumElements = RefNumElements; Pattern->SigNumElements = SigNumElements; if ( RefNumElements > 0 ) { Pattern->RefPatternData = (unsigned short *)malloc(RefNumElements * sizeof(unsigned short)); for ( i=0; iRefPatternData[i] = RefPatternData[i]; } } if ( SigNumElements > 0 ) { Pattern->SigPatternData = (unsigned short *)malloc(SigNumElements * sizeof(unsigned short)); for ( i=0; iSigPatternData[i] = SigPatternData[i]; } } if ( BinningLimit > 0 ) { for ( i=0; iBinNumElements[i] = BinNumElements[i]; Pattern->BinPatternData[i] = (unsigned short *)malloc(BinNumElements[i] * sizeof(unsigned short)); for ( j=0; jBinPatternData[i][j] = BinPatternData[i][j]; } } } } libapogee2-2.2/ApnCamData_TH7899.cpp0000644000175000017500000006067311110507150014572 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_TH7899.cpp: Implementation file for the CApnCamData_TH7899 class. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #include "ApnCamData_TH7899.h" #include #include #include ///////////////////////////////////////////////////////////// // Construction/Destruction ///////////////////////////////////////////////////////////// CApnCamData_TH7899::CApnCamData_TH7899() { } CApnCamData_TH7899::~CApnCamData_TH7899() { } void CApnCamData_TH7899::Initialize() { strcpy( m_Sensor, "TH7899" ); strcpy( m_CameraModel, "10" ); m_CameraId = 14; m_InterlineCCD = false; m_SupportsSerialA = true; m_SupportsSerialB = true; m_SensorTypeCCD = true; m_TotalColumns = 2110; m_ImagingColumns = 2048; m_ClampColumns = 25; m_PreRoiSkipColumns = 5; m_PostRoiSkipColumns = 5; m_OverscanColumns = 27; m_TotalRows = 2054; m_ImagingRows = 2048; m_UnderscanRows = 3; m_OverscanRows = 3; m_VFlushBinning = 4; m_EnableSingleRowOffset = false; m_RowOffsetBinning = 1; m_HFlushDisable = false; m_ShutterCloseDelay = 500; m_PixelSizeX = 14; m_PixelSizeY = 14; m_Color = false; m_ReportedGainSixteenBit = 2; m_MinSuggestedExpTime = 20.0; m_CoolingSupported = true; m_RegulatedCoolingSupported = true; m_TempSetPoint = -20.0; m_TempRampRateOne = 700; m_TempRampRateTwo = 4000; m_TempBackoffPoint = 2.0; m_PrimaryADType = ApnAdType_Alta_Sixteen; m_AlternativeADType = ApnAdType_Alta_Twelve; m_DefaultGainLeft = 100; m_DefaultOffsetLeft = 255; m_DefaultGainRight = -1; m_DefaultOffsetRight = -1; m_DefaultRVoltage = 1000; m_DefaultSpeed = 0xffff; m_DefaultDataReduction = false; set_vpattern(); set_hpattern_clamp_sixteen(); set_hpattern_skip_sixteen(); set_hpattern_roi_sixteen(); set_hpattern_clamp_twelve(); set_hpattern_skip_twelve(); set_hpattern_roi_twelve(); } void CApnCamData_TH7899::set_vpattern() { const unsigned short Mask = 0x0; const unsigned short NumElements = 24; unsigned short Pattern[NumElements] = { 0x0000, 0x0018, 0x0018, 0x001A, 0x001A, 0x0012, 0x0012, 0x0016, 0x0016, 0x0006, 0x0006, 0x000E, 0x000E, 0x000C, 0x000C, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0200, 0x0201, 0x0200 }; m_VerticalPattern.Mask = Mask; m_VerticalPattern.NumElements = NumElements; m_VerticalPattern.PatternData = (unsigned short *)malloc(NumElements * sizeof(unsigned short)); for ( int i=0; iMask = Mask; Pattern->BinningLimit = BinningLimit; Pattern->RefNumElements = RefNumElements; Pattern->SigNumElements = SigNumElements; if ( RefNumElements > 0 ) { Pattern->RefPatternData = (unsigned short *)malloc(RefNumElements * sizeof(unsigned short)); for ( i=0; iRefPatternData[i] = RefPatternData[i]; } } if ( SigNumElements > 0 ) { Pattern->SigPatternData = (unsigned short *)malloc(SigNumElements * sizeof(unsigned short)); for ( i=0; iSigPatternData[i] = SigPatternData[i]; } } if ( BinningLimit > 0 ) { for ( i=0; iBinNumElements[i] = BinNumElements[i]; Pattern->BinPatternData[i] = (unsigned short *)malloc(BinNumElements[i] * sizeof(unsigned short)); for ( j=0; jBinPatternData[i][j] = BinPatternData[i][j]; } } } } libapogee2-2.2/ApnCamData_CCD4710B.cpp0000644000175000017500000004322211110507150014714 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_CCD4710B.cpp: Implementation file for the CApnCamData_CCD4710B class. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #include "ApnCamData_CCD4710B.h" #include #include #include ///////////////////////////////////////////////////////////// // Construction/Destruction ///////////////////////////////////////////////////////////// CApnCamData_CCD4710B::CApnCamData_CCD4710B() { } CApnCamData_CCD4710B::~CApnCamData_CCD4710B() { } void CApnCamData_CCD4710B::Initialize() { strcpy( m_Sensor, "CCD4710B" ); strcpy( m_CameraModel, "47" ); m_CameraId = 11; m_InterlineCCD = false; m_SupportsSerialA = true; m_SupportsSerialB = true; m_SensorTypeCCD = true; m_TotalColumns = 1072; m_ImagingColumns = 1024; m_ClampColumns = 24; m_PreRoiSkipColumns = 0; m_PostRoiSkipColumns = 0; m_OverscanColumns = 24; m_TotalRows = 1027; m_ImagingRows = 1024; m_UnderscanRows = 3; m_OverscanRows = 0; m_VFlushBinning = 1; m_EnableSingleRowOffset = false; m_RowOffsetBinning = 1; m_HFlushDisable = false; m_ShutterCloseDelay = 300; m_PixelSizeX = 13; m_PixelSizeY = 13; m_Color = false; m_ReportedGainSixteenBit = 2; m_MinSuggestedExpTime = 20.0; m_CoolingSupported = true; m_RegulatedCoolingSupported = true; m_TempSetPoint = -20.0; m_TempRampRateOne = 700; m_TempRampRateTwo = 4000; m_TempBackoffPoint = 2.0; m_PrimaryADType = ApnAdType_Alta_Sixteen; m_AlternativeADType = ApnAdType_Alta_Twelve; m_DefaultGainLeft = 400; m_DefaultOffsetLeft = 200; m_DefaultGainRight = -1; m_DefaultOffsetRight = -1; m_DefaultRVoltage = 1000; m_DefaultSpeed = 0xffff; m_DefaultDataReduction = false; set_vpattern(); set_hpattern_clamp_sixteen(); set_hpattern_skip_sixteen(); set_hpattern_roi_sixteen(); set_hpattern_clamp_twelve(); set_hpattern_skip_twelve(); set_hpattern_roi_twelve(); } void CApnCamData_CCD4710B::set_vpattern() { const unsigned short Mask = 0xE; const unsigned short NumElements = 180; unsigned short Pattern[NumElements] = { 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0001, 0x0000, }; m_VerticalPattern.Mask = Mask; m_VerticalPattern.NumElements = NumElements; m_VerticalPattern.PatternData = (unsigned short *)malloc(NumElements * sizeof(unsigned short)); for ( int i=0; iMask = Mask; Pattern->BinningLimit = BinningLimit; Pattern->RefNumElements = RefNumElements; Pattern->SigNumElements = SigNumElements; if ( RefNumElements > 0 ) { Pattern->RefPatternData = (unsigned short *)malloc(RefNumElements * sizeof(unsigned short)); for ( i=0; iRefPatternData[i] = RefPatternData[i]; } } if ( SigNumElements > 0 ) { Pattern->SigPatternData = (unsigned short *)malloc(SigNumElements * sizeof(unsigned short)); for ( i=0; iSigPatternData[i] = SigPatternData[i]; } } if ( BinningLimit > 0 ) { for ( i=0; iBinNumElements[i] = BinNumElements[i]; Pattern->BinPatternData[i] = (unsigned short *)malloc(BinNumElements[i] * sizeof(unsigned short)); for ( j=0; jBinPatternData[i][j] = BinPatternData[i][j]; } } } } libapogee2-2.2/ApnCamData_ASCENT0402ME.h0000644000175000017500000000222511110507150015055 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_ASCENT0402ME.h: Interface file for the CApnCamData_ASCENT0402ME class. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #if _MSC_VER > 1000 #pragma once #endif // _MSC_VER> 1000 #include "ApnCamData.h" class CApnCamData_ASCENT0402ME : public CApnCamData { public: CApnCamData_ASCENT0402ME(); virtual ~CApnCamData_ASCENT0402ME(); void Initialize(); private: void set_vpattern(); void set_hpattern_clamp_sixteen(); void set_hpattern_skip_sixteen(); void set_hpattern_roi_sixteen(); void set_hpattern_clamp_twelve(); void set_hpattern_skip_twelve(); void set_hpattern_roi_twelve(); void set_hpattern( APN_HPATTERN_FILE *Pattern, unsigned short Mask, unsigned short BinningLimit, unsigned short RefNumElements, unsigned short SigNumElements, unsigned short BinNumElements[], unsigned short RefPatternData[], unsigned short SigPatternData[], unsigned short BinPatternData[][APN_MAX_PATTERN_ENTRIES] ); }; libapogee2-2.2/ApnCamData_KAF1001EB.h0000644000175000017500000000220611110507150014461 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_KAF1001EB.h: Interface file for the CApnCamData_KAF1001EB class. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #if _MSC_VER > 1000 #pragma once #endif // _MSC_VER> 1000 #include "ApnCamData.h" class CApnCamData_KAF1001EB : public CApnCamData { public: CApnCamData_KAF1001EB(); virtual ~CApnCamData_KAF1001EB(); void Initialize(); private: void set_vpattern(); void set_hpattern_clamp_sixteen(); void set_hpattern_skip_sixteen(); void set_hpattern_roi_sixteen(); void set_hpattern_clamp_twelve(); void set_hpattern_skip_twelve(); void set_hpattern_roi_twelve(); void set_hpattern( APN_HPATTERN_FILE *Pattern, unsigned short Mask, unsigned short BinningLimit, unsigned short RefNumElements, unsigned short SigNumElements, unsigned short BinNumElements[], unsigned short RefPatternData[], unsigned short SigPatternData[], unsigned short BinPatternData[][APN_MAX_PATTERN_ENTRIES] ); }; libapogee2-2.2/CameraIO_Linux.h0000644000175000017500000004402311110507150014140 0ustar jrjr// 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_ #if _MSC_VER > 1000 #pragma once #endif // _MSC_VER > 1000 #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 ); 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_) libapogee2-2.2/ApnCamData_KAI11000CL.h0000644000175000017500000000221311110507150014552 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_KAI11000CL.h: Interface file for the CApnCamData_KAI11000CL class. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #if _MSC_VER > 1000 #pragma once #endif // _MSC_VER> 1000 #include "ApnCamData.h" class CApnCamData_KAI11000CL : public CApnCamData { public: CApnCamData_KAI11000CL(); virtual ~CApnCamData_KAI11000CL(); void Initialize(); private: void set_vpattern(); void set_hpattern_clamp_sixteen(); void set_hpattern_skip_sixteen(); void set_hpattern_roi_sixteen(); void set_hpattern_clamp_twelve(); void set_hpattern_skip_twelve(); void set_hpattern_roi_twelve(); void set_hpattern( APN_HPATTERN_FILE *Pattern, unsigned short Mask, unsigned short BinningLimit, unsigned short RefNumElements, unsigned short SigNumElements, unsigned short BinNumElements[], unsigned short RefPatternData[], unsigned short SigPatternData[], unsigned short BinPatternData[][APN_MAX_PATTERN_ENTRIES] ); }; libapogee2-2.2/stdafx.h0000644000175000017500000000100511110507150012623 0ustar jrjr#if !defined(STDAFX__INCLUDED_) #define STDAFX__INCLUDED_ #ifdef LINUX #include #include #include #include #define ULONG unsigned long #define USHORT unsigned short #define PUSHORT unsigned short * #define BYTE unsigned char #define DWORD long #define BOOLEAN unsigned long #define TRUE 1 #define FALSE 0 #define INTERNET_OPEN_TYPE_DIRECT 1 #define INTERNET_FLAG_NO_CACHE_WRITE 1 #define INTERNET_FLAG_KEEP_CONNECTION 1 #define Sleep(x) usleep(1000*x) #endif #endif libapogee2-2.2/ApnCamData_KAI11000M.h0000644000175000017500000000221711110507150014454 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_KAI11000M.h: Interface file for the CApnCamData_KAI11000M class. // // Copyright (c) 2003, 2004 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #if _MSC_VER > 1000 #pragma once #endif // _MSC_VER> 1000 #include "ApnCamData.h" class CApnCamData_KAI11000M : public CApnCamData { public: CApnCamData_KAI11000M(); virtual ~CApnCamData_KAI11000M(); void Initialize(); private: void set_vpattern(); void set_hpattern_clamp_sixteen(); void set_hpattern_skip_sixteen(); void set_hpattern_roi_sixteen(); void set_hpattern_clamp_twelve(); void set_hpattern_skip_twelve(); void set_hpattern_roi_twelve(); void set_hpattern( APN_HPATTERN_FILE *Pattern, unsigned short Mask, unsigned short BinningLimit, unsigned short RefNumElements, unsigned short SigNumElements, unsigned short BinNumElements[], unsigned short RefPatternData[], unsigned short SigPatternData[], unsigned short BinPatternData[][APN_MAX_PATTERN_ENTRIES] ); }; libapogee2-2.2/ApnCamData_ASCENT340.h0000644000175000017500000000220611110507150014553 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_ASCENT340.h: Interface file for the CApnCamData_ASCENT340 class. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #if _MSC_VER > 1000 #pragma once #endif // _MSC_VER> 1000 #include "ApnCamData.h" class CApnCamData_ASCENT340 : public CApnCamData { public: CApnCamData_ASCENT340(); virtual ~CApnCamData_ASCENT340(); void Initialize(); private: void set_vpattern(); void set_hpattern_clamp_sixteen(); void set_hpattern_skip_sixteen(); void set_hpattern_roi_sixteen(); void set_hpattern_clamp_twelve(); void set_hpattern_skip_twelve(); void set_hpattern_roi_twelve(); void set_hpattern( APN_HPATTERN_FILE *Pattern, unsigned short Mask, unsigned short BinningLimit, unsigned short RefNumElements, unsigned short SigNumElements, unsigned short BinNumElements[], unsigned short RefPatternData[], unsigned short SigPatternData[], unsigned short BinPatternData[][APN_MAX_PATTERN_ENTRIES] ); }; libapogee2-2.2/ApnCamData_ASCENT16000.h0000644000175000017500000000222011110507150014707 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_ASCENT16000.h: Interface file for the CApnCamData_ASCENT16000 class. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #if _MSC_VER > 1000 #pragma once #endif // _MSC_VER> 1000 #include "ApnCamData.h" class CApnCamData_ASCENT16000 : public CApnCamData { public: CApnCamData_ASCENT16000(); virtual ~CApnCamData_ASCENT16000(); void Initialize(); private: void set_vpattern(); void set_hpattern_clamp_sixteen(); void set_hpattern_skip_sixteen(); void set_hpattern_roi_sixteen(); void set_hpattern_clamp_twelve(); void set_hpattern_skip_twelve(); void set_hpattern_roi_twelve(); void set_hpattern( APN_HPATTERN_FILE *Pattern, unsigned short Mask, unsigned short BinningLimit, unsigned short RefNumElements, unsigned short SigNumElements, unsigned short BinNumElements[], unsigned short RefPatternData[], unsigned short SigPatternData[], unsigned short BinPatternData[][APN_MAX_PATTERN_ENTRIES] ); }; libapogee2-2.2/ApnCamData_ASCENT0402ME3.h0000644000175000017500000000223211110507150015136 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_ASCENT0402ME3.h: Interface file for the CApnCamData_ASCENT0402ME3 class. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #if _MSC_VER > 1000 #pragma once #endif // _MSC_VER> 1000 #include "ApnCamData.h" class CApnCamData_ASCENT0402ME3 : public CApnCamData { public: CApnCamData_ASCENT0402ME3(); virtual ~CApnCamData_ASCENT0402ME3(); void Initialize(); private: void set_vpattern(); void set_hpattern_clamp_sixteen(); void set_hpattern_skip_sixteen(); void set_hpattern_roi_sixteen(); void set_hpattern_clamp_twelve(); void set_hpattern_skip_twelve(); void set_hpattern_roi_twelve(); void set_hpattern( APN_HPATTERN_FILE *Pattern, unsigned short Mask, unsigned short BinningLimit, unsigned short RefNumElements, unsigned short SigNumElements, unsigned short BinNumElements[], unsigned short RefPatternData[], unsigned short SigPatternData[], unsigned short BinPatternData[][APN_MAX_PATTERN_ENTRIES] ); }; libapogee2-2.2/ApnCamData_S101401107.cpp0000644000175000017500000004265111110507150015013 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_S101401107.cpp: Implementation file for the CApnCamData_S101401107 class. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #include "ApnCamData_S101401107.h" #include #include #include ///////////////////////////////////////////////////////////// // Construction/Destruction ///////////////////////////////////////////////////////////// CApnCamData_S101401107::CApnCamData_S101401107() { } CApnCamData_S101401107::~CApnCamData_S101401107() { } void CApnCamData_S101401107::Initialize() { strcpy( m_Sensor, "S101401107" ); strcpy( m_CameraModel, "1107" ); m_CameraId = 40; m_InterlineCCD = false; m_SupportsSerialA = true; m_SupportsSerialB = true; m_SensorTypeCCD = true; m_TotalColumns = 2068; m_ImagingColumns = 2048; m_ClampColumns = 10; m_PreRoiSkipColumns = 0; m_PostRoiSkipColumns = 0; m_OverscanColumns = 10; m_TotalRows = 128; m_ImagingRows = 122; m_UnderscanRows = 4; m_OverscanRows = 2; m_VFlushBinning = 4; m_EnableSingleRowOffset = false; m_RowOffsetBinning = 1; m_HFlushDisable = false; m_ShutterCloseDelay = 50; m_PixelSizeX = 6.8; m_PixelSizeY = 6.8; m_Color = false; m_ReportedGainSixteenBit = 1; m_MinSuggestedExpTime = 10.0; m_CoolingSupported = true; m_RegulatedCoolingSupported = true; m_TempSetPoint = -20.0; m_TempRampRateOne = 700; m_TempRampRateTwo = 4000; m_TempBackoffPoint = 2.0; m_PrimaryADType = ApnAdType_Alta_Sixteen; m_AlternativeADType = ApnAdType_Alta_Twelve; m_DefaultGainLeft = 100; m_DefaultOffsetLeft = 100; m_DefaultGainRight = -1; m_DefaultOffsetRight = -1; m_DefaultRVoltage = 1000; m_DefaultSpeed = 0xffff; m_DefaultDataReduction = false; set_vpattern(); set_hpattern_clamp_sixteen(); set_hpattern_skip_sixteen(); set_hpattern_roi_sixteen(); set_hpattern_clamp_twelve(); set_hpattern_skip_twelve(); set_hpattern_roi_twelve(); } void CApnCamData_S101401107::set_vpattern() { const unsigned short Mask = 0x6; const unsigned short NumElements = 61; unsigned short Pattern[NumElements] = { 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0003, 0x0002 }; m_VerticalPattern.Mask = Mask; m_VerticalPattern.NumElements = NumElements; m_VerticalPattern.PatternData = (unsigned short *)malloc(NumElements * sizeof(unsigned short)); for ( int i=0; iMask = Mask; Pattern->BinningLimit = BinningLimit; Pattern->RefNumElements = RefNumElements; Pattern->SigNumElements = SigNumElements; if ( RefNumElements > 0 ) { Pattern->RefPatternData = (unsigned short *)malloc(RefNumElements * sizeof(unsigned short)); for ( i=0; iRefPatternData[i] = RefPatternData[i]; } } if ( SigNumElements > 0 ) { Pattern->SigPatternData = (unsigned short *)malloc(SigNumElements * sizeof(unsigned short)); for ( i=0; iSigPatternData[i] = SigPatternData[i]; } } if ( BinningLimit > 0 ) { for ( i=0; iBinNumElements[i] = BinNumElements[i]; Pattern->BinPatternData[i] = (unsigned short *)malloc(BinNumElements[i] * sizeof(unsigned short)); for ( j=0; jBinPatternData[i][j] = BinPatternData[i][j]; } } } } libapogee2-2.2/ApnCamData_KAF1001EB.cpp0000644000175000017500000004414511110507150015024 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_KAF1001EB.cpp: Implementation file for the CApnCamData_KAF1001EB class. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #include "ApnCamData_KAF1001EB.h" #include #include #include ///////////////////////////////////////////////////////////// // Construction/Destruction ///////////////////////////////////////////////////////////// CApnCamData_KAF1001EB::CApnCamData_KAF1001EB() { } CApnCamData_KAF1001EB::~CApnCamData_KAF1001EB() { } void CApnCamData_KAF1001EB::Initialize() { strcpy( m_Sensor, "KAF1001EB" ); strcpy( m_CameraModel, "6" ); m_CameraId = 36; m_InterlineCCD = false; m_SupportsSerialA = true; m_SupportsSerialB = true; m_SensorTypeCCD = true; m_TotalColumns = 1044; m_ImagingColumns = 1024; m_ClampColumns = 8; m_PreRoiSkipColumns = 0; m_PostRoiSkipColumns = 0; m_OverscanColumns = 12; m_TotalRows = 1032; m_ImagingRows = 1024; m_UnderscanRows = 4; m_OverscanRows = 4; m_VFlushBinning = 1; m_EnableSingleRowOffset = false; m_RowOffsetBinning = 1; m_HFlushDisable = false; m_ShutterCloseDelay = 300; m_PixelSizeX = 24; m_PixelSizeY = 24; m_Color = false; m_ReportedGainSixteenBit = 3; m_MinSuggestedExpTime = 20.0; m_CoolingSupported = true; m_RegulatedCoolingSupported = true; m_TempSetPoint = -20.0; m_TempRampRateOne = 700; m_TempRampRateTwo = 4000; m_TempBackoffPoint = 2.0; m_PrimaryADType = ApnAdType_Alta_Sixteen; m_AlternativeADType = ApnAdType_Alta_Twelve; m_DefaultGainLeft = 0; m_DefaultOffsetLeft = 250; m_DefaultGainRight = -1; m_DefaultOffsetRight = -1; m_DefaultRVoltage = 1000; m_DefaultSpeed = 0xffff; m_DefaultDataReduction = false; set_vpattern(); set_hpattern_clamp_sixteen(); set_hpattern_skip_sixteen(); set_hpattern_roi_sixteen(); set_hpattern_clamp_twelve(); set_hpattern_skip_twelve(); set_hpattern_roi_twelve(); } void CApnCamData_KAF1001EB::set_vpattern() { const unsigned short Mask = 0x6; const unsigned short NumElements = 71; unsigned short Pattern[NumElements] = { 0x0000, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0001, 0x0000 }; m_VerticalPattern.Mask = Mask; m_VerticalPattern.NumElements = NumElements; m_VerticalPattern.PatternData = (unsigned short *)malloc(NumElements * sizeof(unsigned short)); for ( int i=0; iMask = Mask; Pattern->BinningLimit = BinningLimit; Pattern->RefNumElements = RefNumElements; Pattern->SigNumElements = SigNumElements; if ( RefNumElements > 0 ) { Pattern->RefPatternData = (unsigned short *)malloc(RefNumElements * sizeof(unsigned short)); for ( i=0; iRefPatternData[i] = RefPatternData[i]; } } if ( SigNumElements > 0 ) { Pattern->SigPatternData = (unsigned short *)malloc(SigNumElements * sizeof(unsigned short)); for ( i=0; iSigPatternData[i] = SigPatternData[i]; } } if ( BinningLimit > 0 ) { for ( i=0; iBinNumElements[i] = BinNumElements[i]; Pattern->BinPatternData[i] = (unsigned short *)malloc(BinNumElements[i] * sizeof(unsigned short)); for ( j=0; jBinPatternData[i][j] = BinPatternData[i][j]; } } } } libapogee2-2.2/ApnSerial_USB.cpp0000644000175000017500000002404611110507150014266 0ustar jrjr// ApnSerial_USB.cpp: implementation of the CApnSerial class. // ////////////////////////////////////////////////////////////////////// #include "stdafx.h" #include "ApogeeUsb.h" #include "ApogeeUsbErr.h" #include "ApnSerial_USB.h" #ifdef _DEBUG #undef THIS_FILE static char THIS_FILE[]=__FILE__; #define new DEBUG_NEW #endif ////////////////////////////////////////////////////////////////////// // Construction/Destruction ////////////////////////////////////////////////////////////////////// bool CApnSerial::InitPort( unsigned long CamIdA, unsigned short CamIdB, unsigned short SerialId ) { double VersionNum; unsigned short VendorId; unsigned short ProductId; unsigned short DeviceId; if ( m_SerialId != -1 ) { return false; } if ( (SerialId != 0) && (SerialId != 1) ) { return false; } m_ConnectionOpen = false; if ( ApnUsbOpen( (unsigned short)CamIdA, m_SysDeviceName ) != APN_USB_SUCCESS ) { return false; } if ( (ApnUsbSysDriverVersion( &VersionNum) != APN_USB_SUCCESS) || (ApnUsbReadVendorInfo( &VendorId, &ProductId, &DeviceId) != APN_USB_SUCCESS) ) { ClosePort(); return false; } if ( (VersionNum < 1.3) || (DeviceId < 5) ) { // Serial port operation requires AltaUsb.sys version 1.3 or higher // and the Device ID of the firmware on the USB board should be 5 or higher ClosePort(); return false; } m_ConnectionOpen = true; m_SerialId = SerialId; m_BytesRead = 0; SetBaudRate( 9600 ); SetFlowControl( Apn_SerialFlowControl_Off ); SetParity( Apn_SerialParity_None ); return true; } bool CApnSerial::ClosePort() { if ( m_SerialId == -1 ) return false; // just close the port and not care whether it was successful. if it was, // great. if not, we'll still set m_SerialId to -1 so that another call // can at least be tried to connect to the port. ApnUsbClose( ); m_SerialId = -1; return true; } bool CApnSerial::GetBaudRate(unsigned long *BaudRate ) { if ( (m_ConnectionOpen == false) || (m_SerialId == -1) ) return false; if ( ApnUsbSerialReadBaudRate( m_SerialId, BaudRate) != APN_USB_SUCCESS ) { *BaudRate = 0; return false; } return true; } bool CApnSerial::SetBaudRate(unsigned long BaudRate ) { if ( (m_ConnectionOpen == false) || (m_SerialId == -1) ) return false; if ( ApnUsbSerialWriteBaudRate( m_SerialId, BaudRate ) != APN_USB_SUCCESS ) { return false; } return true; } bool CApnSerial::GetFlowControl( Apn_SerialFlowControl *FlowControl ) { bool EnableFlowControl; if ( (m_ConnectionOpen == false) || (m_SerialId == -1) ) return false; if ( ApnUsbSerialReadFlowControl( m_SerialId, &EnableFlowControl) != APN_USB_SUCCESS ) { *FlowControl = Apn_SerialFlowControl_Unknown; return false; } if ( EnableFlowControl ) *FlowControl = Apn_SerialFlowControl_On; else *FlowControl = Apn_SerialFlowControl_Off; return true; } bool CApnSerial::SetFlowControl( Apn_SerialFlowControl FlowControl ) { bool EnableFlowControl; if ( (m_ConnectionOpen == false) || (m_SerialId == -1) ) return false; if ( FlowControl == Apn_SerialFlowControl_Unknown ) return false; if ( FlowControl == Apn_SerialFlowControl_On ) EnableFlowControl = true; else EnableFlowControl = false; if ( ApnUsbSerialWriteFlowControl( m_SerialId, EnableFlowControl) != APN_USB_SUCCESS ) { return false; } return true; } bool CApnSerial::GetParity( Apn_SerialParity *Parity ) { ApnUsbParity ParityRead; if ( (m_ConnectionOpen == false) || (m_SerialId == -1) ) return false; if ( ApnUsbSerialReadParity( m_SerialId, &ParityRead) != APN_USB_SUCCESS ) { *Parity = Apn_SerialParity_Unknown; return false; } if ( ParityRead == ApnUsbParity_None ) *Parity = Apn_SerialParity_None; else if ( ParityRead == ApnUsbParity_Even ) *Parity = Apn_SerialParity_Even; else if ( ParityRead == ApnUsbParity_Odd ) *Parity = Apn_SerialParity_Odd; return true; } bool CApnSerial::SetParity( Apn_SerialParity Parity ) { ApnUsbParity ParityWrite; if ( (m_ConnectionOpen == false) || (m_SerialId == -1) ) return false; if ( Parity == Apn_SerialParity_Unknown ) return false; if ( Parity == Apn_SerialParity_None ) ParityWrite = ApnUsbParity_None; else if ( Parity == Apn_SerialParity_Even ) ParityWrite = ApnUsbParity_Even; else if ( Parity == Apn_SerialParity_Odd ) ParityWrite = ApnUsbParity_Odd; if ( ApnUsbSerialWriteParity( m_SerialId, ParityWrite) != APN_USB_SUCCESS ) { return false; } return true; } bool CApnSerial::Read(int dummy,char *ReadBuffer, unsigned short *ReadCount ) { if ( (m_ConnectionOpen == false) || (m_SerialId == -1) ) return false; if ( ApnUsbSerialRead( m_SerialId, ReadBuffer, ReadCount) != APN_USB_SUCCESS ) { *ReadCount = 0; m_BytesRead = 0; return false; } m_BytesRead = *ReadCount; return true; } bool CApnSerial::Write(int dummy, char *WriteBuffer, unsigned short WriteCount ) { if ( (m_ConnectionOpen == false) || (m_SerialId == -1) ) return false; if ( ApnUsbSerialWrite( m_SerialId, WriteBuffer, WriteCount) != APN_USB_SUCCESS ) { return false; } return true; } char *CApnSerial::ReadBuffer(void) { int dummy; unsigned short count; Read(dummy,m_SerialBuffer,&count); return m_SerialBuffer; } libapogee2-2.2/ApnCamData_CCD4720.cpp0000644000175000017500000004232711110507150014620 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_CCD4720.cpp: Implementation file for the CApnCamData_CCD4720 class. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #include "ApnCamData_CCD4720.h" #include #include #include ///////////////////////////////////////////////////////////// // Construction/Destruction ///////////////////////////////////////////////////////////// CApnCamData_CCD4720::CApnCamData_CCD4720() { } CApnCamData_CCD4720::~CApnCamData_CCD4720() { } void CApnCamData_CCD4720::Initialize() { strcpy( m_Sensor, "CCD4720" ); strcpy( m_CameraModel, "4720" ); m_CameraId = 24; m_InterlineCCD = false; m_SupportsSerialA = true; m_SupportsSerialB = true; m_SensorTypeCCD = true; m_TotalColumns = 1072; m_ImagingColumns = 1024; m_ClampColumns = 24; m_PreRoiSkipColumns = 0; m_PostRoiSkipColumns = 0; m_OverscanColumns = 24; m_TotalRows = 2058; m_ImagingRows = 1024; m_UnderscanRows = 1033; m_OverscanRows = 1; m_VFlushBinning = 1; m_EnableSingleRowOffset = true; m_RowOffsetBinning = 1033; m_HFlushDisable = false; m_ShutterCloseDelay = 0; m_PixelSizeX = 13; m_PixelSizeY = 13; m_Color = false; m_ReportedGainSixteenBit = 2; m_MinSuggestedExpTime = 1.0; m_CoolingSupported = true; m_RegulatedCoolingSupported = true; m_TempSetPoint = -20.0; m_TempRampRateOne = 700; m_TempRampRateTwo = 4000; m_TempBackoffPoint = 2.0; m_PrimaryADType = ApnAdType_Alta_Sixteen; m_AlternativeADType = ApnAdType_Alta_Twelve; m_DefaultGainLeft = 400; m_DefaultOffsetLeft = 200; m_DefaultGainRight = -1; m_DefaultOffsetRight = -1; m_DefaultRVoltage = 1000; m_DefaultSpeed = 0xffff; m_DefaultDataReduction = false; set_vpattern(); set_hpattern_clamp_sixteen(); set_hpattern_skip_sixteen(); set_hpattern_roi_sixteen(); set_hpattern_clamp_twelve(); set_hpattern_skip_twelve(); set_hpattern_roi_twelve(); } void CApnCamData_CCD4720::set_vpattern() { const unsigned short Mask = 0x0; const unsigned short NumElements = 129; unsigned short Pattern[NumElements] = { 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0001, 0x0000 }; m_VerticalPattern.Mask = Mask; m_VerticalPattern.NumElements = NumElements; m_VerticalPattern.PatternData = (unsigned short *)malloc(NumElements * sizeof(unsigned short)); for ( int i=0; iMask = Mask; Pattern->BinningLimit = BinningLimit; Pattern->RefNumElements = RefNumElements; Pattern->SigNumElements = SigNumElements; if ( RefNumElements > 0 ) { Pattern->RefPatternData = (unsigned short *)malloc(RefNumElements * sizeof(unsigned short)); for ( i=0; iRefPatternData[i] = RefPatternData[i]; } } if ( SigNumElements > 0 ) { Pattern->SigPatternData = (unsigned short *)malloc(SigNumElements * sizeof(unsigned short)); for ( i=0; iSigPatternData[i] = SigPatternData[i]; } } if ( BinningLimit > 0 ) { for ( i=0; iBinNumElements[i] = BinNumElements[i]; Pattern->BinPatternData[i] = (unsigned short *)malloc(BinNumElements[i] * sizeof(unsigned short)); for ( j=0; jBinPatternData[i][j] = BinPatternData[i][j]; } } } } libapogee2-2.2/ApnCamData_CCD5710F.cpp0000644000175000017500000004025211110507150014721 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_CCD5710F.cpp: Implementation file for the CApnCamData_CCD5710F class. // ///////////////////////////////////////////////////////////// #include "ApnCamData_CCD5710F.h" #include #include #include ///////////////////////////////////////////////////////////// // Construction/Destruction ///////////////////////////////////////////////////////////// CApnCamData_CCD5710F::CApnCamData_CCD5710F() { } CApnCamData_CCD5710F::~CApnCamData_CCD5710F() { } void CApnCamData_CCD5710F::Initialize() { strcpy( m_Sensor, "CCD5710F" ); strcpy( m_CameraModel, "57f" ); m_CameraId = 19; m_InterlineCCD = false; m_SupportsSerialA = true; m_SupportsSerialB = true; m_SensorTypeCCD = true; m_TotalColumns = 536; m_ImagingColumns = 512; m_ClampColumns = 24; m_PreRoiSkipColumns = 0; m_PostRoiSkipColumns = 0; m_OverscanColumns = 12; m_TotalRows = 1056; m_ImagingRows = 512; m_UnderscanRows = 540; m_OverscanRows = 4; m_VFlushBinning = 4; m_EnableSingleRowOffset = true; m_RowOffsetBinning = 540; m_HFlushDisable = false; m_ShutterCloseDelay = 0; m_PixelSizeX = 13; m_PixelSizeY = 13; m_Color = false; m_ReportedGainSixteenBit = 2; m_MinSuggestedExpTime = 1.0; m_CoolingSupported = true; m_RegulatedCoolingSupported = true; m_TempSetPoint = -20.0; m_TempRampRateOne = 3000; m_TempRampRateTwo = 3000; m_TempBackoffPoint = 2.0; //m_DefaultGainTwelveBit = 300; //m_DefaultOffsetTwelveBit = 100; m_DefaultRVoltage = 1000; set_vpattern(); set_hpattern_clamp_sixteen(); set_hpattern_skip_sixteen(); set_hpattern_roi_sixteen(); set_hpattern_clamp_twelve(); set_hpattern_skip_twelve(); set_hpattern_roi_twelve(); } void CApnCamData_CCD5710F::set_vpattern() { const unsigned short Mask = 0x0; const unsigned short NumElements = 129; unsigned short Pattern[NumElements] = { 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x000C, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0001, 0x0000 }; m_VerticalPattern.Mask = Mask; m_VerticalPattern.NumElements = NumElements; m_VerticalPattern.PatternData = (unsigned short *)malloc(NumElements * sizeof(unsigned short)); for ( int i=0; iMask = Mask; Pattern->BinningLimit = BinningLimit; Pattern->RefNumElements = RefNumElements; Pattern->SigNumElements = SigNumElements; if ( RefNumElements > 0 ) { Pattern->RefPatternData = (unsigned short *)malloc(RefNumElements * sizeof(unsigned short)); for ( i=0; iRefPatternData[i] = RefPatternData[i]; } } if ( SigNumElements > 0 ) { Pattern->SigPatternData = (unsigned short *)malloc(SigNumElements * sizeof(unsigned short)); for ( i=0; iSigPatternData[i] = SigPatternData[i]; } } if ( BinningLimit > 0 ) { for ( i=0; iBinNumElements[i] = BinNumElements[i]; Pattern->BinPatternData[i] = (unsigned short *)malloc(BinNumElements[i] * sizeof(unsigned short)); for ( j=0; jBinPatternData[i][j] = BinPatternData[i][j]; } } } } libapogee2-2.2/ApnCamData_CCD5710F.h0000644000175000017500000000212611110507150014364 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_CCD5710F.h: Interface file for the CApnCamData_CCD5710F class. // ///////////////////////////////////////////////////////////// #if _MSC_VER > 1000 #pragma once #endif // _MSC_VER> 1000 #include "ApnCamData.h" class CApnCamData_CCD5710F : public CApnCamData { public: CApnCamData_CCD5710F(); virtual ~CApnCamData_CCD5710F(); void Initialize(); private: void set_vpattern(); void set_hpattern_clamp_sixteen(); void set_hpattern_skip_sixteen(); void set_hpattern_roi_sixteen(); void set_hpattern_clamp_twelve(); void set_hpattern_skip_twelve(); void set_hpattern_roi_twelve(); void set_hpattern( APN_HPATTERN_FILE *Pattern, unsigned short Mask, unsigned short BinningLimit, unsigned short RefNumElements, unsigned short SigNumElements, unsigned short BinNumElements[], unsigned short RefPatternData[], unsigned short SigPatternData[], unsigned short BinPatternData[][APN_MAX_PATTERN_ENTRIES] ); }; libapogee2-2.2/ApnCamData_KAF1001ENS.h0000644000175000017500000000221311110507150014616 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_KAF1001ENS.h: Interface file for the CApnCamData_KAF1001ENS class. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #if _MSC_VER > 1000 #pragma once #endif // _MSC_VER> 1000 #include "ApnCamData.h" class CApnCamData_KAF1001ENS : public CApnCamData { public: CApnCamData_KAF1001ENS(); virtual ~CApnCamData_KAF1001ENS(); void Initialize(); private: void set_vpattern(); void set_hpattern_clamp_sixteen(); void set_hpattern_skip_sixteen(); void set_hpattern_roi_sixteen(); void set_hpattern_clamp_twelve(); void set_hpattern_skip_twelve(); void set_hpattern_roi_twelve(); void set_hpattern( APN_HPATTERN_FILE *Pattern, unsigned short Mask, unsigned short BinningLimit, unsigned short RefNumElements, unsigned short SigNumElements, unsigned short BinNumElements[], unsigned short RefPatternData[], unsigned short SigPatternData[], unsigned short BinPatternData[][APN_MAX_PATTERN_ENTRIES] ); }; libapogee2-2.2/ApnCamData_KAI11000CL.cpp0000644000175000017500000005346711110507150015126 0ustar jrjr///////////////////////////////////////////////////////////// // // ApnCamData_KAI11000CL.cpp: Implementation file for the CApnCamData_KAI11000CL class. // // Copyright (c) 2003-2007 Apogee Instruments, Inc. // ///////////////////////////////////////////////////////////// #include "ApnCamData_KAI11000CL.h" #include #include #include ///////////////////////////////////////////////////////////// // Construction/Destruction ///////////////////////////////////////////////////////////// CApnCamData_KAI11000CL::CApnCamData_KAI11000CL() { } CApnCamData_KAI11000CL::~CApnCamData_KAI11000CL() { } void CApnCamData_KAI11000CL::Initialize() { strcpy( m_Sensor, "KAI11000CL" ); strcpy( m_CameraModel, "11002cl" ); m_CameraId = 70; m_InterlineCCD = true; m_SupportsSerialA = true; m_SupportsSerialB = true; m_SensorTypeCCD = true; m_TotalColumns = 4080; m_ImagingColumns = 4008; m_ClampColumns = 36; m_PreRoiSkipColumns = 0; m_PostRoiSkipColumns = 0; m_OverscanColumns = 36; m_TotalRows = 2720; m_ImagingRows = 2672; m_UnderscanRows = 24; m_OverscanRows = 24; m_VFlushBinning = 1; m_EnableSingleRowOffset = false; m_RowOffsetBinning = 1; m_HFlushDisable = false; m_ShutterCloseDelay = 0; m_PixelSizeX = 9; m_PixelSizeY = 9; m_Color = true; m_ReportedGainSixteenBit = 1; m_MinSuggestedExpTime = 0.05; m_CoolingSupported = true; m_RegulatedCoolingSupported = true; m_TempSetPoint = -20.0; m_TempRampRateOne = 700; m_TempRampRateTwo = 4000; m_TempBackoffPoint = 2.0; m_PrimaryADType = ApnAdType_Alta_Sixteen; m_AlternativeADType = ApnAdType_Alta_Twelve; m_DefaultGainLeft = 150; m_DefaultOffsetLeft = 100; m_DefaultGainRight = -1; m_DefaultOffsetRight = -1; m_DefaultRVoltage = 1000; m_DefaultSpeed = 0xffff; m_DefaultDataReduction = false; set_vpattern(); set_hpattern_clamp_sixteen(); set_hpattern_skip_sixteen(); set_hpattern_roi_sixteen(); set_hpattern_clamp_twelve(); set_hpattern_skip_twelve(); set_hpattern_roi_twelve(); } void CApnCamData_KAI11000CL::set_vpattern() { const unsigned short Mask = 0x106; const unsigned short NumElements = 59; unsigned short Pattern[NumElements] = { 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0302, 0x0302, 0x0302, 0x0302, 0x0302, 0x0302, 0x0302, 0x0302, 0x0302, 0x0302, 0x0002, 0x0002, 0x0002, 0x0003, 0x0002 }; m_VerticalPattern.Mask = Mask; m_VerticalPattern.NumElements = NumElements; m_VerticalPattern.PatternData = (unsigned short *)malloc(NumElements * sizeof(unsigned short)); for ( int i=0; iMask = Mask; Pattern->BinningLimit = BinningLimit; Pattern->RefNumElements = RefNumElements; Pattern->SigNumElements = SigNumElements; if ( RefNumElements > 0 ) { Pattern->RefPatternData = (unsigned short *)malloc(RefNumElements * sizeof(unsigned short)); for ( i=0; iRefPatternData[i] = RefPatternData[i]; } } if ( SigNumElements > 0 ) { Pattern->SigPatternData = (unsigned short *)malloc(SigNumElements * sizeof(unsigned short)); for ( i=0; iSigPatternData[i] = SigPatternData[i]; } } if ( BinningLimit > 0 ) { for ( i=0; iBinNumElements[i] = BinNumElements[i]; Pattern->BinPatternData[i] = (unsigned short *)malloc(BinNumElements[i] * sizeof(unsigned short)); for ( j=0; jBinPatternData[i][j] = BinPatternData[i][j]; } } } }