kstars/kstars/indi/apogee/CameraIO_LinuxISA.cpp

   1 // CameraIO.cpp: implementation of the CCameraIO class.
   2 //
   3 // Copyright (c) 2000 Apogee Instruments Inc.
   4 //////////////////////////////////////////////////////////////////////
   5
   6 #include <assert.h>
   7 #include <sys/io.h>
   8 #include <sys/time.h>
   9 #include <sys/resource.h>
  10 #include <sys/ioctl.h>
  11 #include <string.h>
  12 #include <sched.h>
  13 #include <unistd.h>
  14 #include <fcntl.h>
  15 #include <stdio.h>
  16 #define HANDLE int
  17 #define FALSE 0
  18 #define DWORD long
  19 #define _ASSERT assert
  20 #define REALTIME_PRIORITY_CLASS 1
  21 #define GetCurrentProcess getpid
  22 #define LOBYTE(x) ((x) & 0xff)
  23 #define HIBYTE(x) ((x >> 8) & 0xff)
  24
  25 #define MIRQ1   0x21
  26 #define MIRQ2   0xA1
  27
  28 #include "time.h"
  29 //#include "tcl.h"
  30 //#include "ccd.h"
  31 #include "CameraIO_Linux.h"
  32 #include "ApogeeLinux.h"
  33
  34 const int NUM_POSITIONS = 6;
  35 const int NUM_STEPS_PER_FILTER = 48;
  36 const int STEP_DELAY = 10;
  37
  38 const unsigned char Steps[] = { 0x10, 0x30, 0x20, 0x60, 0x40, 0xc0, 0x80, 0x90 };
  39 const int NUM_STEPS = sizeof ( Steps );
  40
  41 //////////////////////////////////////////////////////////////////////
  42 // Construction/Destruction
  43 //////////////////////////////////////////////////////////////////////
  44
  45 void CCameraIO::InitDefaults()
  46 {
  47         ////////////////////////////////////////////////////////////
  48         // Camera Settings
  49
  50                 m_HighPriority = true;
  51                 m_PPRepeat = 1;
  52                 m_DataBits = 16;
  53                 m_FastShutter = false;
  54                 m_MaxBinX = 8;
  55                 m_MaxBinY = 63;
  56                 m_MaxExposure = 10485.75;
  57                 m_MinExposure = 0.01;
  58                 m_GuiderRelays = false;
  59                 m_Timeout = 2.0;
  60
  61         ////////////////////////////////////////////////////////////
  62         // Cooler Settings
  63
  64                 m_TempControl = true;
  65                 m_TempCalibration = 160;
  66                 m_TempScale = 2.1;
  67
  68         ////////////////////////////////////////////////////////////
  69         // Exposure Settings
  70
  71                 m_BinX = 1;
  72                 m_BinY = 1;
  73                 m_StartX = 0;
  74                 m_StartY = 0;
  75                 m_NumX = 1;
  76                 m_NumY = 1;
  77
  78         ////////////////////////////////////////////////////////////
  79         // Geometry Settings
  80
  81                 m_Columns = 0;
  82                 m_Rows = 0;
  83                 m_SkipC = 0;
  84                 m_SkipR = 0;
  85                 m_HFlush = 1;
  86                 m_VFlush = 1;
  87                 m_BIC = 4;
  88                 m_BIR = 4;
  89                 m_ImgColumns = 0;
  90                 m_ImgRows = 0;
  91
  92         ////////////////////////////////////////////////////////////
  93         // CCD Settings
  94
  95                 memset( m_Sensor, 0, 256 );
  96                 m_Color = false;
  97                 m_Noise = 0.0;
  98                 m_Gain = 0.0;
  99                 m_PixelXSize = 0.0;
 100                 m_PixelYSize = 0.0;
 101
 102         ////////////////////////////////////////////////////////////
 103         // Internal variables
 104
 105                 fileHandle = 0;
 106                 m_RegisterOffset = 0;
 107                 m_Interface = Camera_Interface_ISA;
 108                 m_SensorType = Camera_SensorType_CCD;
 109 }
 110
 111
 112
 113 bool CCameraIO::InitDriver(unsigned short camnum)
 114 {
 115     char deviceName[64];
 116
 117         sprintf(deviceName,"%s%d",APOGEE_ISA_DEVICE,camnum);
 118         fileHandle = ::open(deviceName,O_RDONLY);
 119         if (fileHandle == -1) return false;
 120         return true;
 121 }
 122
 123 long CCameraIO::Write( unsigned short reg, unsigned short val )
 124 {
 125         int status;
 126
 127         struct apIOparam request;
 128         unsigned short realreg = ( reg << 1 ) & 0xE;    // limit input to our address range
 129         request.reg = realreg;
 130         request.param1=(int)val;
 131         status=ioctl(fileHandle,APISA_WRITE_USHORT,(unsigned long)&request);
 132         return 0;
 133 }
 134
 135 long CCameraIO::Read( unsigned short reg, unsigned short& val )
 136 {
 137         unsigned short realreg;
 138         int retval, status;
 139         struct apIOparam request;
 140
 141         switch ( reg )
 142         {
 143         case Reg_ImageData:
 144                 realreg = RegISA_ImageData;
 145                 break;
 146         case Reg_TempData:
 147                 realreg = RegISA_TempData;
 148                 break;
 149         case Reg_Status:
 150                 realreg = RegISA_Status;
 151                 break;
 152         case Reg_CommandReadback:
 153                 realreg = RegISA_CommandReadback;
 154                 break;
 155         default:
 156                 assert( 1 );    // application program bug
 157                 val = 0;
 158                 return 0;
 159         }
 160
 161         request.reg = realreg;
 162         request.param1=(unsigned long)&retval;
 163         status=ioctl(fileHandle,APISA_READ_USHORT,(unsigned long)&request);
 164         val = (unsigned short)retval;
 165         return 0;
 166 }
 167
 168 // Returns 0 if successfull, 1 if Line_Done poll timed out.
 169 long CCameraIO::ReadLine( long SkipPixels, long Pixels,unsigned short* pLineBuffer )
 170 {
 171     int j;
 172     int retval, status;
 173     struct apIOparam request;
 174
 175         if ( !m_TDI )
 176         {
 177                 /////////////////////////////////////
 178                 // Clock out the line
 179                 m_RegShadow[ Reg_Command ] |= RegBit_StartNextLine;             // set bit to 1
 180                 Write( Reg_Command, m_RegShadow[ Reg_Command ] );
 181
 182                 m_RegShadow[ Reg_Command ] &= ~RegBit_StartNextLine;    // set bit to 0
 183                 Write( Reg_Command, m_RegShadow[ Reg_Command ] );
 184                 /////////////////////////////////////
 185         }
 186
 187         request.reg = RegISA_ImageData;
 188         request.param1=(unsigned long)&retval;
 189
 190         for (j = 0; j < SkipPixels; j++)
 191         {
 192              status=ioctl(fileHandle,APISA_READ_USHORT,(unsigned long)&request);
 193         }
 194         for (j = 0; j < Pixels; j++)
 195         {
 196              status=ioctl(fileHandle,APISA_READ_USHORT,(unsigned long)&request);
 197              *pLineBuffer++ = (unsigned short)retval;
 198         }
 199         /////////////////////////////////////
 200         // Assert done reading line
 201         m_RegShadow[ Reg_Command ] |= RegBit_DoneReading;       // set bit to 1
 202         Write( Reg_Command, m_RegShadow[ Reg_Command ] );
 203
 204         m_RegShadow[ Reg_Command ] &= ~RegBit_DoneReading;      // set bit to 0
 205         Write( Reg_Command, m_RegShadow[ Reg_Command ] );
 206         /////////////////////////////////////
 207
 208         if ( !m_TDI )
 209         {
 210                 /////////////////////////////////////
 211                 // Wait until camera is done
 212                 clock_t StopTime = clock() + CLOCKS_PER_SEC;    // wait at most one second
 213                 while ( true )
 214                 {
 215                         unsigned short val = 0;
 216                         Read( Reg_Status, val );
 217                         if ( ( val & RegBit_LineDone ) != 0 ) break;// Line done
 218
 219                         if ( clock() > StopTime ) return 1;             // Timed out
 220                 }
 221         }
 222
 223         return 0;
 224 }
 225
 226
 227
 228 long CCameraIO::ReadImage( unsigned short* pImageBuffer )
 229 {
 230         m_RegShadow[ Reg_Command ] |= RegBit_FIFOCache;         // set bit to 1
 231         Write( Reg_Command, m_RegShadow[ Reg_Command ] );
 232
 233         long XEnd = long( m_ExposureNumX );
 234         long SkipC = long( m_ExposureSkipC );
 235         for (long i = 0; i < m_ExposureSkipR; i++)
 236         {
 237                 if( InternalReadLine( false, SkipC, XEnd, NULL ) ) return 1;
 238         }
 239
 240         long YEnd = long( m_ExposureNumY );
 241         unsigned short* pLineBuffer = pImageBuffer;
 242         for (long i = 0; i < YEnd; i++)
 243         {
 244                 if ( InternalReadLine( true, SkipC, XEnd, pLineBuffer ) ) return 1;
 245                 pLineBuffer += XEnd;
 246         }
 247
 248         m_RegShadow[ Reg_Command ] &= !RegBit_FIFOCache;        // set bit to 0
 249         Write( Reg_Command, m_RegShadow[ Reg_Command ] );
 250
 251         return 0;
 252 }
 253
 254
 255
 256 // Returns 0 if successfull, 1 if Line_Done poll timed out.
 257 long CCameraIO::InternalReadLine( bool KeepData, long SkipC, long XEnd, unsigned short* pLineBuffer )
 258 {
 259       struct apIOparam request;
 260       int retval, status;
 261
 262         /////////////////////////////////////
 263         // Clock out the line
 264         m_RegShadow[ Reg_Command ] |= RegBit_StartNextLine;             // set bit to 1
 265         Write( Reg_Command, m_RegShadow[ Reg_Command ] );
 266
 267         m_RegShadow[ Reg_Command ] &= !RegBit_StartNextLine;    // set bit to 0
 268         Write( Reg_Command, m_RegShadow[ Reg_Command ] );
 269         /////////////////////////////////////
 270
 271         request.reg = RegISA_ImageData;
 272         request.param1=(unsigned long)&retval;
 273
 274         for (long j = 0; j < SkipC; j++)
 275              status=ioctl(fileHandle,APISA_READ_USHORT,(unsigned long)&request);
 276
 277         if ( KeepData )
 278         {
 279                 for (long j = 0; j < XEnd; j++) {
 280                   status=ioctl(fileHandle,APISA_READ_USHORT,(unsigned long)&request);
 281                   *pLineBuffer++ = (unsigned short)retval;
 282                 }
 283         }
 284         else
 285         {
 286                 for (long j = 0; j < XEnd; j++)
 287                   status=ioctl(fileHandle,APISA_READ_USHORT,(unsigned long)&request);
 288         }
 289
 290         /////////////////////////////////////
 291         // Assert done reading line
 292         m_RegShadow[ Reg_Command ] |= RegBit_DoneReading;       // set bit to 1
 293         Write( Reg_Command, m_RegShadow[ Reg_Command ] );
 294
 295         m_RegShadow[ Reg_Command ] &= !RegBit_DoneReading;      // set bit to 0
 296         Write( Reg_Command, m_RegShadow[ Reg_Command ] );
 297         /////////////////////////////////////
 298
 299         /////////////////////////////////////
 300         // Wait until camera is done clocking
 301         clock_t StopTime = clock() + CLOCKS_PER_SEC;    // wait at most one second
 302         while ( true )
 303         {
 304                 unsigned short val = 0;
 305                 Read( Reg_Status, val );
 306                 if ( ( val & RegBit_LineDone ) != 0 ) break;// Line done
 307
 308                 clock_t CurrentTime = clock();
 309                 if ( CurrentTime > StopTime ) return 1;         // Timed out
 310         }
 311
 312         return 0;
 313 }
 314
 315
 316
 317
 318
 319
 320