00001
00002
00003
00005
00006 #include <assert.h>
00007 #include <sys/time.h>
00008 #include <sys/resource.h>
00009 #include <sys/ioctl.h>
00010 #include <string.h>
00011 #include <sched.h>
00012 #include <unistd.h>
00013 #include <fcntl.h>
00014 #include <stdio.h>
00015 #define HANDLE int
00016 #define FALSE 0
00017 #define DWORD long
00018 #define _ASSERT assert
00019 #define REALTIME_PRIORITY_CLASS 1
00020 #define GetCurrentProcess getpid
00021 #define LOBYTE(x) ((x) & 0xff)
00022 #define HIBYTE(x) ((x >> 8) & 0xff)
00023
00024 #define MIRQ1 0x21
00025 #define MIRQ2 0xA1
00026
00027 #include "time.h"
00028
00029
00030 #include "CameraIO_Linux.h"
00031 #include "ApogeeLinux.h"
00032
00033 const int NUM_POSITIONS = 6;
00034 const int NUM_STEPS_PER_FILTER = 48;
00035 const int STEP_DELAY = 10;
00036
00037 const unsigned char Steps[] = { 0x10, 0x30, 0x20, 0x60, 0x40, 0xc0, 0x80, 0x90 };
00038 const int NUM_STEPS = sizeof ( Steps );
00039
00041
00043
00044 void CCameraIO::InitDefaults()
00045 {
00047
00048
00049 m_HighPriority = true;
00050 m_PPRepeat = 1;
00051 m_DataBits = 16;
00052 m_FastShutter = false;
00053 m_MaxBinX = 8;
00054 m_MaxBinY = 63;
00055 m_MaxExposure = 10485.75;
00056 m_MinExposure = 0.01;
00057 m_GuiderRelays = false;
00058 m_Timeout = 2.0;
00059
00061
00062
00063 m_TempControl = true;
00064 m_TempCalibration = 160;
00065 m_TempScale = 2.1;
00066
00068
00069
00070 m_BinX = 1;
00071 m_BinY = 1;
00072 m_StartX = 0;
00073 m_StartY = 0;
00074 m_NumX = 1;
00075 m_NumY = 1;
00076
00078
00079
00080 m_Columns = 0;
00081 m_Rows = 0;
00082 m_SkipC = 0;
00083 m_SkipR = 0;
00084 m_HFlush = 1;
00085 m_VFlush = 1;
00086 m_BIC = 4;
00087 m_BIR = 4;
00088 m_ImgColumns = 0;
00089 m_ImgRows = 0;
00090
00092
00093
00094 memset( m_Sensor, 0, 256 );
00095 m_Color = false;
00096 m_Noise = 0.0;
00097 m_Gain = 0.0;
00098 m_PixelXSize = 0.0;
00099 m_PixelYSize = 0.0;
00100
00102
00103
00104 fileHandle = 0;
00105 m_RegisterOffset = 0;
00106 m_Interface = Camera_Interface_PCI;
00107 m_SensorType = Camera_SensorType_CCD;
00108 }
00109
00110
00111
00112 bool CCameraIO::InitDriver(unsigned short camnum)
00113 {
00114 char deviceName[64];
00115
00116 sprintf(deviceName,"%s%d",APOGEE_PCI_DEVICE,camnum);
00117 fileHandle = ::open(deviceName,O_RDONLY);
00118 if (fileHandle == -1) return false;
00119 return true;
00120 }
00121
00122 long CCameraIO::Write( unsigned short reg, unsigned short val )
00123 {
00124 int status;
00125 unsigned short RegNumber;
00126 struct apIOparam request;
00127
00128 switch ( reg )
00129 {
00130 case Reg_Command:
00131 RegNumber = RegPCI_Command;
00132 break;
00133 case Reg_Timer:
00134 RegNumber = RegPCI_Timer;
00135 break;
00136 case Reg_VBinning:
00137 RegNumber = RegPCI_VBinning;
00138 break;
00139 case Reg_AICCounter:
00140 RegNumber = RegPCI_AICCounter;
00141 break;
00142 case Reg_TempSetPoint:
00143 RegNumber = RegPCI_TempSetPoint;
00144 break;
00145 case Reg_PixelCounter:
00146 RegNumber = RegPCI_PixelCounter;
00147 break;
00148 case Reg_LineCounter:
00149 RegNumber = RegPCI_LineCounter;
00150 break;
00151 case Reg_BICCounter:
00152 RegNumber = RegPCI_BICCounter;
00153 break;
00154 default:
00155 _ASSERT ( false );
00156 return 0;
00157 }
00158 request.reg = RegNumber;
00159 request.param1=(int)val;
00160 status=ioctl(fileHandle,APPCI_WRITE_USHORT,(unsigned long)&request);
00161 return 0;
00162 }
00163
00164 long CCameraIO::Read( unsigned short reg, unsigned short& val )
00165 {
00166 int retval, status;
00167 struct apIOparam request;
00168 unsigned short RegNumber;
00169
00170 switch ( reg )
00171 {
00172 case Reg_Command:
00173 RegNumber = RegPCI_CommandRead;
00174 break;
00175 case Reg_Timer:
00176 RegNumber = RegPCI_TimerRead;
00177 break;
00178 case Reg_VBinning:
00179 RegNumber = RegPCI_VBinningRead;
00180 break;
00181 case Reg_AICCounter:
00182 RegNumber = RegPCI_AICCounterRead;
00183 break;
00184 case Reg_TempSetPoint:
00185 RegNumber = RegPCI_TempSetPointRead;
00186 break;
00187 case Reg_PixelCounter:
00188 RegNumber = RegPCI_PixelCounterRead;
00189 break;
00190 case Reg_LineCounter:
00191 RegNumber = RegPCI_LineCounterRead;
00192 break;
00193 case Reg_BICCounter:
00194 RegNumber = RegPCI_BICCounterRead;
00195 break;
00196 case Reg_ImageData:
00197 RegNumber = RegPCI_ImageData;
00198 break;
00199 case Reg_TempData:
00200 RegNumber = RegPCI_TempData;
00201 break;
00202 case Reg_Status:
00203 RegNumber = RegPCI_Status;
00204 break;
00205 case Reg_CommandReadback:
00206 RegNumber = RegPCI_CommandReadback;
00207 break;
00208 default:
00209 assert( 1 );
00210 val = 0;
00211 return 0;
00212 }
00213
00214 request.reg = RegNumber;
00215 request.param1=(unsigned long)&retval;
00216 status=ioctl(fileHandle,APPCI_READ_USHORT,(unsigned long)&request);
00217 val = (unsigned short)retval;
00218 return 0;
00219 }
00220
00221
00222 long CCameraIO::ReadLine( long SkipPixels, long Pixels,unsigned short* pLineBuffer )
00223 {
00224 int j;
00225 int retval, status;
00226 struct apIOparam request;
00227
00228 if ( !m_TDI )
00229 {
00231
00232 m_RegShadow[ Reg_Command ] |= RegBit_StartNextLine;
00233 Write( Reg_Command, m_RegShadow[ Reg_Command ] );
00234
00235 m_RegShadow[ Reg_Command ] &= ~RegBit_StartNextLine;
00236 Write( Reg_Command, m_RegShadow[ Reg_Command ] );
00238 }
00239
00240 request.reg = RegPCI_ImageData;
00241 request.param1=(unsigned long)&retval;
00242
00243 for (j = 0; j < SkipPixels; j++)
00244 {
00245 status=ioctl(fileHandle,APPCI_READ_USHORT,(unsigned long)&request);
00246 }
00247 for (j = 0; j < Pixels; j++)
00248 {
00249 status=ioctl(fileHandle,APPCI_READ_USHORT,(unsigned long)&request);
00250 *pLineBuffer++ = (unsigned short)retval;
00251 }
00253
00254 m_RegShadow[ Reg_Command ] |= RegBit_DoneReading;
00255 Write( Reg_Command, m_RegShadow[ Reg_Command ] );
00256
00257 m_RegShadow[ Reg_Command ] &= ~RegBit_DoneReading;
00258 Write( Reg_Command, m_RegShadow[ Reg_Command ] );
00260
00261 if ( !m_TDI )
00262 {
00264
00265 clock_t StopTime = clock() + CLOCKS_PER_SEC;
00266 while ( true )
00267 {
00268 unsigned short val = 0;
00269 Read( Reg_Status, val );
00270 if ( ( val & RegBit_LineDone ) != 0 ) break;
00271
00272 if ( clock() > StopTime ) return 1;
00273 }
00274 }
00275
00276 return 0;
00277 }
00278
00279
00280
00281 long CCameraIO::ReadImage( unsigned short* pImageBuffer )
00282 {
00283 m_RegShadow[ Reg_Command ] |= RegBit_FIFOCache;
00284 Write( Reg_Command, m_RegShadow[ Reg_Command ] );
00285
00286 long XEnd = long( m_ExposureNumX );
00287 long SkipC = long( m_ExposureSkipC );
00288 for (long i = 0; i < m_ExposureSkipR; i++)
00289 {
00290 if( InternalReadLine( false, SkipC, XEnd, NULL ) ) return 1;
00291 }
00292
00293 long YEnd = long( m_ExposureNumY );
00294 unsigned short* pLineBuffer = pImageBuffer;
00295 for (long i = 0; i < YEnd; i++)
00296 {
00297 if ( InternalReadLine( true, SkipC, XEnd, pLineBuffer ) ) return 1;
00298 pLineBuffer += XEnd;
00299 }
00300
00301 m_RegShadow[ Reg_Command ] &= !RegBit_FIFOCache;
00302 Write( Reg_Command, m_RegShadow[ Reg_Command ] );
00303
00304 return 0;
00305 }
00306
00307
00308
00309
00310 long CCameraIO::InternalReadLine( bool KeepData, long SkipC, long XEnd, unsigned short* pLineBuffer )
00311 {
00312 struct apIOparam request;
00313 int retval, status;
00314
00316
00317 m_RegShadow[ Reg_Command ] |= RegBit_StartNextLine;
00318 Write( Reg_Command, m_RegShadow[ Reg_Command ] );
00319
00320 m_RegShadow[ Reg_Command ] &= !RegBit_StartNextLine;
00321 Write( Reg_Command, m_RegShadow[ Reg_Command ] );
00323
00324 request.reg = RegPCI_ImageData;
00325 request.param1=(unsigned long)&retval;
00326
00327 for (long j = 0; j < SkipC; j++)
00328 status=ioctl(fileHandle,APPCI_READ_USHORT,(unsigned long)&request);
00329
00330 if ( KeepData )
00331 {
00332 for (long j = 0; j < XEnd; j++) {
00333 status=ioctl(fileHandle,APPCI_READ_USHORT,(unsigned long)&request);
00334 *pLineBuffer++ = (unsigned short)retval;
00335 }
00336 }
00337 else
00338 {
00339 for (long j = 0; j < XEnd; j++)
00340 status=ioctl(fileHandle,APPCI_READ_USHORT,(unsigned long)&request);
00341 }
00342
00344
00345 m_RegShadow[ Reg_Command ] |= RegBit_DoneReading;
00346 Write( Reg_Command, m_RegShadow[ Reg_Command ] );
00347
00348 m_RegShadow[ Reg_Command ] &= !RegBit_DoneReading;
00349 Write( Reg_Command, m_RegShadow[ Reg_Command ] );
00351
00353
00354 clock_t StopTime = clock() + CLOCKS_PER_SEC;
00355 while ( true )
00356 {
00357 unsigned short val = 0;
00358 Read( Reg_Status, val );
00359 if ( ( val & RegBit_LineDone ) != 0 ) break;
00360
00361 clock_t CurrentTime = clock();
00362 if ( CurrentTime > StopTime ) return 1;
00363 }
00364
00365 return 0;
00366 }
00367
00368
00369
00370
00371
00372
00373