#define EXTERN
#define MAIN     1

/*--------------------------
**  include files
**--------------------------
*/
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/time.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <stdarg.h>
#include <math.h>
#include <errno.h>
#include <fcntl.h>
#include <netdb.h>
#include <semaphore.h>
#include <mqueue.h>

/*-----------------------------
 *  non standard includes
 *-----------------------------
 */

#define IXON  1

#if IXON
#include "atmcdLXd.h"   // Andor SDK include file
#endif

#include "moris_lib.h"

/*---------------------------
** function prototypes
**---------------------------
*/
int cmd_execute( char * cmd_buf);

int do_g1( char *par );
int do_q1( char *par );
int do_q2( char *par );
int do_t1( char *par );
int do_help( char *par );
int do_quit( char *par );


ulong get_ulong( char *prompt, ulong cur_val, ulong min, ulong max );
long  get_long ( char *prompt, long cur_val, long min, long max );
double get_dbl( char *prompt, double cur_val, double min, double max );

int buf_2_dv( char * host, int dvport, int naxis1, int naxis2, long *data );
char * Gbuild_card2( char * cptr, char * keyword, char * value, char * comment );

/*-------------------------------------
*  Global variables
*-------------------------------------
*/
long Data[NAXIS1*NAXIS2];              // space for an image + extra FITS record size.

int  Quit;

struct PARSE_TABLE
{
  char * kw;          /* The opcode string  */
  int (* pfi)(char*); /* pfi is pointer to function returning an integer */
   char * desc;       /* command description */
};

struct PARSE_TABLE parse_table[] =
{
   { "g1",               do_g1,              "g1     - GO #1" },
   { "q1",               do_q1,              "q1     - Query the Camera #1" },
   { "q2",               do_q2,              "q2     - Query the Camera #2" },
   { "t1",               do_t1,              "t1     - test 1" },
   { "help",             do_help,            "Help   - List commands" },
   { "Quit",             do_quit,            "Quit   - quits app" },
};

int num_parse_item = { sizeof(parse_table) / sizeof(struct PARSE_TABLE) };


/*---------------------------------
** main()
**---------------------------------
*/
int main( int argc, char * argv[])
{
  int i, err;
  extern char *optarg;
  extern int optind;
  char buf[80];

  /* parse options */
  err = 0;
  while((i = getopt(argc, argv, "")) != EOF)
  {
      switch(i)
      {
         case '?':
         err++;
         break;
      }
   }

   if( err )
   {
      fprintf(stderr, "Usage: %s [] \n", argv[0]);
      exit(0);
   }

   /*--------------------------------------
   **  Initialize CCD
   */
#if IXON
   printf("Calling Andor Initialize() .. takes a few seconds\n");
   err = Initialize("/usr/local/etc/andor");
   if( err != DRV_SUCCESS )
   {
      printf("Andor Initialize() error %d\n", err);
      return (0);
   }
   sleep(2); //sleep to allow initialization to complete
   SetTemperature( -20 );
   CoolerON();
   SetShutter( 1, 2/*close*/, 0, 0 );
#endif

   /* main loop for commands */
   Quit = FALSE;
   while( !Quit )
   {
      /* Get command */
      printf("Enter Command: ");
      fgets( buf, sizeof(buf), stdin );
      unpad( buf, '\n');

      cmd_execute( buf );
   }

#if IXON
   SetShutter( 1, 2/*close*/, 0, 0 );
   CoolerOFF();
   printf("Calling Andor ShutDown().. takes a few seconds\n");
   sleep(1);
   ShutDown();
#endif
   return 0;
}

/*-------------------------------------------------------------
** cmd_execute() - Executes a command line instruction
**-------------------------------------------------------------
*/
int cmd_execute( cmd_buf )
   char * cmd_buf;
{
   char copy_buf[80];
   int error,
      found,
      i;

   char * kw,
        * par;
   /*
   **  Search table for keyword
   */
   strxcpy( copy_buf, cmd_buf, sizeof(copy_buf));

   kw  = strtok(copy_buf, " ");
   if( (kw == NULL) || (*kw=='#') )
      return( 0 );

   if( (par = strtok( (char*)NULL, "")) != NULL )
      unpad( par, ' ' );
   else
      par = "";

   /*
   **  Search table for keyword. If found call function.
   */
   error = ERR_INV_KW;
   for(i=0, found = FALSE; i<num_parse_item && found == FALSE; )
   {
      if( !stricmp( kw, parse_table[i].kw ) )
      {
         found = TRUE;
         error = (parse_table[i].pfi)(par);
      }
      else
         i++;
   }
   /*
   **  Provide user feedback
   */

   if( error != 0 )
   {
      printf("%s - %s\n", cmd_buf, error_string(error) );
   }

   return( error );
}

/********************************************************************
**                      COMMAND FUNCTIONS                          **
********************************************************************/

/*----------------------------------------------------------------------
**  do_g1 - Go #1
**----------------------------------------------------------------------
*/
int do_g1( char * par )
{

#if IXON
  // make sure acquition is not in progress, then proceed...
  int rc;
  int naxis1, naxis2, i;
  float itime = 1.0;


   /*---- general camera setup ----------------------------------------------*/

   rc = GetDetector( &naxis1, &naxis2);
   if( rc != DRV_SUCCESS )
   {
      printf("GetDetector() error.\n");
      return ERR_DEVICE_ERROR;
   }
   printf("Detector is %d x %d \n", naxis1, naxis2 );

#if 0
   // turn off EM Gain.
   rc = SetEMAdvanced( 0 /* disable */);
   if( rc != DRV_SUCCESS )
   {
      printf("SetEMAdvanced() error.\n");
      return ERR_DEVICE_ERROR;
   }
#endif
   rc = SetReadMode( 4 /*image*/);   // moris only does "image" .
   if( rc != DRV_SUCCESS )
   {
      printf("SetReadMode() error.\n");
      return ERR_DEVICE_ERROR;
   }

   // FT
   rc = SetFrameTransferMode( 1 );
   if( rc != DRV_SUCCESS )
   {
      printf("SetFrameTrasferMode() error.\n");
      return ERR_DEVICE_ERROR;
   }

#if 0
   // shutter - set to open, zero 0 because we have a frame transfer CCD.
   rc = SetShutter( 1, 1/*open*/, 0, 0 );  // type=TTL_high, mode=open, closing_ms=0, opening_ms=0
   if( rc != DRV_SUCCESS )
   {
      printf("SetShutter() error.\n");
      return ERR_DEVICE_ERROR;
   }
#endif

   // SetVSSpeed
   rc = SetVSSpeed( 4 );  // moris legal values are 0 to 4. (slow to fast)
   if( rc != DRV_SUCCESS )
   {
      printf("SetVSSpeed() error.\n");
      return ERR_DEVICE_ERROR;
   }

   // HSS: Select amp=1 (conventional), ch=1(16bit Channel), HHS=0 (1Mhz).
   // Preamp gail = 1x
   int amp = 1;
   int ch  = 1;
   int hss = 0;
   int gain = 0;

   rc = SetADChannel( ch );
   if( rc != DRV_SUCCESS )
   {
      printf("SetADChannel() error.\n");
      return ERR_DEVICE_ERROR;
   }

   rc = SetOutputAmplifier( amp );
   if( rc != DRV_SUCCESS )
   {
      printf("SetOutputAmplifier() error.\n");
      return ERR_DEVICE_ERROR;
   }

   rc = SetHSSpeed( amp, hss );
   if( rc != DRV_SUCCESS )
   {
      printf("SetHSSpeed() error.\n");
      return ERR_DEVICE_ERROR;
   }

   rc = SetPreAmpGain( gain  );
   if( rc != DRV_SUCCESS )
   {
      printf("SetPreAmpGain() error.\n");
      return ERR_DEVICE_ERROR;
   }

   /*---- basic mode setup ----------------------------------------------*/

   rc = SetImage( 1, 1, 1, naxis1, 1, naxis2);
   if( rc != DRV_SUCCESS )
   {
      printf("SetImage() error.\n");
      return ERR_DEVICE_ERROR;
   }

   rc = SetAcquisitionMode( 2 /*accumulate*/);
   if( rc != DRV_SUCCESS )
   {
      printf("SetAcquisitionMode() error.\n");
      return ERR_DEVICE_ERROR;
   }

   rc = SetTriggerMode( 0 /*internal*/);
   if( rc != DRV_SUCCESS )
   {
      printf("SetTriggerMode() error.\n");
      return ERR_DEVICE_ERROR;
   }

   rc = SetExposureTime( itime );
   if( rc != DRV_SUCCESS )
   {
      printf("SetExposureTime() error.\n");
      return ERR_DEVICE_ERROR;
   }

   rc = SetNumberAccumulations( 1 );
   if( rc != DRV_SUCCESS )
   {
      printf("SetNumberAccumulations() error.\n");
      return ERR_DEVICE_ERROR;
   }

   rc = SetAccumulationCycleTime( itime );   // set to itime, system will calculated real value.
   if( rc != DRV_SUCCESS )
   {
      printf("SetAccumulationCycleTime() error.\n");
      return ERR_DEVICE_ERROR;
   }

   /*---- start Acquistion ----------------------------------------------*/

   float a_itime, a_atime, a_ktime;
   rc = GetAcquisitionTimings( &a_itime, &a_atime, &a_ktime );   // set to itime, system will calculated real value.
   if( rc != DRV_SUCCESS )
   {
      printf("GetAcquisitionTimings() error.\n");
      return ERR_DEVICE_ERROR;
   }
   printf("AcquisitionTimings() itime=%.3f  atime=%.3f  ktime=%.3f \n", a_itime, a_atime, a_ktime );
   int wid, hgt, temp_c;
   long  l;
   float f;
   GetDetector( &wid, &hgt);              printf("GetDetector() w %d h %d \n", wid, hgt);
   GetMaximumExposure( &f );              printf("GetMaximumExposure() = %f \n", f);
   GetMaximumBinning( 4/*image*/,0, &i);  printf("GetMaximumBinning(H) = %d \n", i);
   GetMaximumBinning( 4/*image*/,1, &i);  printf("GetMaximumBinning(V) = %d \n", i);
   GetReadOutTime( &f );                  printf("GetReadOutTime()  %f \n", f);
   GetTemperature( &temp_c );             printf("GetTemperature() %d DegC \n", temp_c);
   GetSizeOfCircularBuffer( &l );         printf("GetSizeOfCircularBuffer()  %ld \n", l);
   GetKeepCleanTime( &f );                printf("GetKeepCleanTime() %f seconds \n", f);


   rc = StartAcquisition( );
   if( rc != DRV_SUCCESS )
   {
      printf("StartAcquisition() error.\n");
      return ERR_DEVICE_ERROR;
   }

   int status;
   long nimages;
   do
   {
      usleep(100000);  /* 0.1 sec  */

      GetStatus( &status );
   }
   while ( status ==DRV_ACQUIRING );

   GetTotalNumberImagesAcquired( &nimages );
   printf("Acquistion Ended with status=%d. Number Image Acq=%ld \n", status, nimages);

   long first, last;
   GetNumberNewImages( &first, &last );
   printf("GetNumberNewImages() before F=%ld L=%ld \n", first, last);

   rc = GetAcquiredData( Data, naxis1*naxis2 );
   if( rc != DRV_SUCCESS )
   {
      printf("GetAcquiredData() error %d.\n", rc);
      return ERR_DEVICE_ERROR;
   }

  GetNumberNewImages( &first, &last );
  printf("GetNumberNewImages() after  F=%ld L=%ld \n", first, last);

#else
  int i;
  for( i=0; i<NAXIS1*NAXIS2; i++)
  {
     Data[i] = 1000 + (drand48() * 20.0);
  }
#endif
   // send data to DV
   printf("Sending to DV..\n");
   buf_2_dv( "localhost", 30123, NAXIS1, NAXIS2, Data);

   return 0;
}


/*----------------------------------------------------------------------
**  do_q1 - Query #1
**----------------------------------------------------------------------
*/
int do_q1( char * par )
{
#if IXON
   int rc;

   AndorCapabilities caps;

   caps.ulSize = sizeof(caps);
   if( (rc=GetCapabilities( &caps )) != DRV_SUCCESS )
   {
      printf("GetCapabilities() error %d\n", rc);
      return 0;
   }

   printf("ulAcqModes: 0x%04lx\n", caps.ulAcqModes);
   printf("   AC_ACQMODE_SINGLE: %ld\n", caps.ulAcqModes & AC_ACQMODE_SINGLE);
   printf("   AC_ACQMODE_VIDEO: %ld\n", caps.ulAcqModes & AC_ACQMODE_VIDEO);
   printf("   AC_ACQMODE_ACCUMULATE: %ld\n", caps.ulAcqModes & AC_ACQMODE_ACCUMULATE);
   printf("   AC_ACQMODE_KINETIC: %ld\n", caps.ulAcqModes & AC_ACQMODE_KINETIC);
   printf("   AC_ACQMODE_FRAMETRANSFER: %ld\n", caps.ulAcqModes & AC_ACQMODE_FRAMETRANSFER);
   printf("   AC_ACQMODE_FASTKINETICS: %ld\n", caps.ulAcqModes & AC_ACQMODE_FASTKINETICS);
   printf("   AC_ACQMODE_OVERLAP: %ld\n", caps.ulAcqModes & AC_ACQMODE_OVERLAP);
   printf("\n");

   printf("ulReadModes: 0x%04lx\n", caps.ulReadModes);
   printf("   AC_READMODE_FULLIMAGE: %ld\n", caps.ulReadModes & AC_READMODE_FULLIMAGE);
   printf("   AC_READMODE_SUBIMAGE: %ld\n", caps.ulReadModes & AC_READMODE_SUBIMAGE);
   printf("   AC_READMODE_SINGLETRACK: %ld\n", caps.ulReadModes & AC_READMODE_SINGLETRACK);
   printf("   AC_READMODE_FVB: %ld\n", caps.ulReadModes & AC_READMODE_FVB);
   printf("   AC_READMODE_MULTITRACK: %ld\n", caps.ulReadModes & AC_READMODE_MULTITRACK);
   printf("   AC_READMODE_RANDOMTRACK: %ld\n", caps.ulReadModes & AC_READMODE_RANDOMTRACK);
   printf("   AC_READMODE_MULTITRACKSCAN: %ld\n", caps.ulReadModes & AC_READMODE_MULTITRACKSCAN);
   printf("\n");

   printf("ulFTReadModes using Frame Transfer Mode: 0x%04lx\n", caps.ulFTReadModes);
   printf("   AC_READMODE_FULLIMAGE: %ld\n", caps.ulFTReadModes & AC_READMODE_FULLIMAGE);
   printf("   AC_READMODE_SUBIMAGE: %ld\n", caps.ulFTReadModes & AC_READMODE_SUBIMAGE);
   printf("   AC_READMODE_SINGLETRACK: %ld\n", caps.ulFTReadModes & AC_READMODE_SINGLETRACK);
   printf("   AC_READMODE_FVB: %ld\n", caps.ulFTReadModes & AC_READMODE_FVB);
   printf("   AC_READMODE_MULTITRACK: %ld\n", caps.ulFTReadModes & AC_READMODE_MULTITRACK);
   printf("   AC_READMODE_RANDOMTRACK: %ld\n", caps.ulFTReadModes & AC_READMODE_RANDOMTRACK);
   printf("   AC_READMODE_MULTITRACKSCAN: %ld\n", caps.ulFTReadModes & AC_READMODE_MULTITRACKSCAN);
   printf("\n");

   printf("ulTriggerModes: 0x%04lx\n", caps.ulTriggerModes);
   printf("   AC_TRIGGERMODE_INTERNAL: %ld\n", caps.ulTriggerModes & AC_TRIGGERMODE_INTERNAL);
   printf("   AC_TRIGGERMODE_EXTERNAL: %ld\n", caps.ulTriggerModes & AC_TRIGGERMODE_EXTERNAL);
   printf("   AC_TRIGGERMODE_EXTERNAL_FVB_EM: %ld\n", caps.ulTriggerModes & AC_TRIGGERMODE_EXTERNAL_FVB_EM);
   printf("   AC_TRIGGERMODE_CONTINUOUS: %ld\n", caps.ulTriggerModes & AC_TRIGGERMODE_CONTINUOUS);
   printf("   AC_TRIGGERMODE_EXTERNALSTART: %ld\n", caps.ulTriggerModes & AC_TRIGGERMODE_EXTERNALSTART);
   printf("   AC_TRIGGERMODE_EXTERNALEXPOSURE: %ld\n", caps.ulTriggerModes & AC_TRIGGERMODE_EXTERNALEXPOSURE);
   printf("   AC_TRIGGERMODE_INVERTED: %ld\n", caps.ulTriggerModes & AC_TRIGGERMODE_INVERTED);
   printf("\n");

   printf("ulCameraType: %ld\n", caps.ulCameraType);
   printf("\n");

   printf("ulPixelMode: 0x%04lx\n", caps.ulPixelMode);
   printf("   AC_PIXELMODE_8BIT: %ld\n", caps.ulPixelMode & AC_PIXELMODE_8BIT);
   printf("   AC_PIXELMODE_14BIT: %ld\n", caps.ulPixelMode & AC_PIXELMODE_14BIT);
   printf("   AC_PIXELMODE_16BIT: %ld\n", caps.ulPixelMode & AC_PIXELMODE_16BIT);
   printf("   AC_PIXELMODE_32BIT: %ld\n", caps.ulPixelMode & AC_PIXELMODE_32BIT);
   printf("   AC_PIXELMODE_MONO: %ld\n", caps.ulPixelMode & AC_PIXELMODE_MONO);
   printf("   AC_PIXELMODE_RGB: %ld\n", caps.ulPixelMode & AC_PIXELMODE_RGB);
   printf("   AC_PIXELMODE_CMY: %ld\n", caps.ulPixelMode & AC_PIXELMODE_CMY);
   printf("\n");

   printf("ulSetFunctions: 0x%04lx\n", caps.ulSetFunctions);
   printf("   AC_SETFUNCTION_VREADOUT : %ld\n", caps.ulSetFunctions & AC_SETFUNCTION_VREADOUT );
   printf("   AC_SETFUNCTION_HREADOUT : %ld\n", caps.ulSetFunctions & AC_SETFUNCTION_HREADOUT );
   printf("   AC_SETFUNCTION_TEMPERATURE : %ld\n", caps.ulSetFunctions & AC_SETFUNCTION_TEMPERATURE );
   printf("   AC_SETFUNCTION_MCPGAIN : %ld\n", caps.ulSetFunctions & AC_SETFUNCTION_MCPGAIN );
   printf("   AC_SETFUNCTION_EMCCDGAIN : %ld\n", caps.ulSetFunctions & AC_SETFUNCTION_EMCCDGAIN );
   printf("   AC_SETFUNCTION_BASELINECLAMP : %ld\n", caps.ulSetFunctions & AC_SETFUNCTION_BASELINECLAMP );
   printf("   AC_SETFUNCTION_VSAMPLITUDE : %ld\n", caps.ulSetFunctions & AC_SETFUNCTION_VSAMPLITUDE );
   printf("   AC_SETFUNCTION_HIGHCAPACITY : %ld\n", caps.ulSetFunctions & AC_SETFUNCTION_HIGHCAPACITY );
   printf("   AC_SETFUNCTION_BASELINEOFFSET : %ld\n", caps.ulSetFunctions & AC_SETFUNCTION_BASELINEOFFSET );
   printf("   AC_SETFUNCTION_PREAMPGAIN : %ld\n", caps.ulSetFunctions & AC_SETFUNCTION_PREAMPGAIN );
   printf("   AC_SETFUNCTION_CROPMODE : %ld\n", caps.ulSetFunctions & AC_SETFUNCTION_CROPMODE );
   printf("   AC_SETFUNCTION_DMAPARAMETERS : %ld\n", caps.ulSetFunctions & AC_SETFUNCTION_DMAPARAMETERS );
   printf("   AC_SETFUNCTION_HORIZONTALBIN : %ld\n", caps.ulSetFunctions & AC_SETFUNCTION_HORIZONTALBIN );
   printf("   AC_SETFUNCTION_MULTITRACKHRANGE : %ld\n", caps.ulSetFunctions & AC_SETFUNCTION_MULTITRACKHRANGE );
   printf("   AC_SETFUNCTION_RANDOMTRACKNOGAPS : %ld\n", caps.ulSetFunctions & AC_SETFUNCTION_RANDOMTRACKNOGAPS );
   printf("   AC_SETFUNCTION_EMADVANCED : %ld\n", caps.ulSetFunctions & AC_SETFUNCTION_EMADVANCED );
   printf("   AC_SETFUNCTION_GATEMODE : %ld\n", caps.ulSetFunctions & AC_SETFUNCTION_GATEMODE );
   printf("   AC_SETFUNCTION_DDGTIMES : %ld\n", caps.ulSetFunctions & AC_SETFUNCTION_DDGTIMES );
   printf("   AC_SETFUNCTION_IOC : %ld\n", caps.ulSetFunctions & AC_SETFUNCTION_IOC );
   printf("   AC_SETFUNCTION_INTELLIGATE : %ld\n", caps.ulSetFunctions & AC_SETFUNCTION_INTELLIGATE );
   printf("   AC_SETFUNCTION_INSERTION_DELAY : %ld\n", caps.ulSetFunctions & AC_SETFUNCTION_INSERTION_DELAY );
   printf("   AC_SETFUNCTION_GATESTEP : %ld\n", caps.ulSetFunctions & AC_SETFUNCTION_GATESTEP );
   printf("   AC_SETFUNCTION_TRIGGERTERMINATION : %ld\n", caps.ulSetFunctions & AC_SETFUNCTION_TRIGGERTERMINATION );
   printf("\n");

   printf("ulGetFunctions: 0x%04lx\n", caps.ulGetFunctions);
   printf("   AC_GETFUNCTION_TEMPERATURE : %ld\n", caps.ulGetFunctions & AC_GETFUNCTION_TEMPERATURE );
   printf("   AC_GETFUNCTION_TARGETTEMPERATURE : %ld\n", caps.ulGetFunctions & AC_GETFUNCTION_TARGETTEMPERATURE );
   printf("   AC_GETFUNCTION_TEMPERATURERANGE : %ld\n", caps.ulGetFunctions & AC_GETFUNCTION_TEMPERATURERANGE );
   printf("   AC_GETFUNCTION_DETECTORSIZE : %ld\n", caps.ulGetFunctions & AC_GETFUNCTION_DETECTORSIZE );
   printf("   AC_GETFUNCTION_MCPGAIN : %ld\n", caps.ulGetFunctions & AC_GETFUNCTION_MCPGAIN );
   printf("   AC_GETFUNCTION_EMCCDGAIN : %ld\n", caps.ulGetFunctions & AC_GETFUNCTION_EMCCDGAIN );
   printf("   AC_GETFUNCTION_HVFLAG : %ld\n", caps.ulGetFunctions & AC_GETFUNCTION_HVFLAG );
   printf("   AC_GETFUNCTION_GATEMODE : %ld\n", caps.ulGetFunctions & AC_GETFUNCTION_GATEMODE );
   printf("   AC_GETFUNCTION_DDGTIMES : %ld\n", caps.ulGetFunctions & AC_GETFUNCTION_DDGTIMES );
   printf("   AC_GETFUNCTION_IOC : %ld\n", caps.ulGetFunctions & AC_GETFUNCTION_IOC );
   printf("   AC_GETFUNCTION_INTELLIGATE : %ld\n", caps.ulGetFunctions & AC_GETFUNCTION_INTELLIGATE );
   printf("   AC_GETFUNCTION_INSERTION_DELAY : %ld\n", caps.ulGetFunctions & AC_GETFUNCTION_INSERTION_DELAY );
   printf("   AC_GETFUNCTION_GATESTEP : %ld\n", caps.ulGetFunctions & AC_GETFUNCTION_GATESTEP );
   printf("   AC_GETFUNCTION_PHOSPHORSTATUS : %ld\n", caps.ulGetFunctions & AC_GETFUNCTION_PHOSPHORSTATUS );
   printf("   AC_GETFUNCTION_MCPGAINTABLE : %ld\n", caps.ulGetFunctions & AC_GETFUNCTION_MCPGAINTABLE );
   printf("   AC_GETFUNCTION_BASELINECLAMP : %ld\n", caps.ulGetFunctions & AC_GETFUNCTION_BASELINECLAMP );
   printf("\n");

   printf("ulFeatures: 0x%04lx\n", caps.ulFeatures);
   printf("   AC_FEATURES_POLLING : %ld\n", caps.ulFeatures & AC_FEATURES_POLLING );
   printf("   AC_FEATURES_EVENTS : %ld\n", caps.ulFeatures & AC_FEATURES_EVENTS );
   printf("   AC_FEATURES_SPOOLING : %ld\n", caps.ulFeatures & AC_FEATURES_SPOOLING );
   printf("   AC_FEATURES_SHUTTER : %ld\n", caps.ulFeatures & AC_FEATURES_SHUTTER );
   printf("   AC_FEATURES_SHUTTEREX : %ld\n", caps.ulFeatures & AC_FEATURES_SHUTTEREX );
   printf("   AC_FEATURES_EXTERNAL_I2C : %ld\n", caps.ulFeatures & AC_FEATURES_EXTERNAL_I2C );
   printf("   AC_FEATURES_SATURATIONEVENT : %ld\n", caps.ulFeatures & AC_FEATURES_SATURATIONEVENT );
   printf("   AC_FEATURES_FANCONTROL : %ld\n", caps.ulFeatures & AC_FEATURES_FANCONTROL );
   printf("   AC_FEATURES_MIDFANCONTROL : %ld\n", caps.ulFeatures & AC_FEATURES_MIDFANCONTROL );
   printf("   AC_FEATURES_TEMPERATUREDURINGACQUISITION : %ld\n", caps.ulFeatures & AC_FEATURES_TEMPERATUREDURINGACQUISITION );
   printf("   AC_FEATURES_KEEPCLEANCONTROL : %ld\n", caps.ulFeatures & AC_FEATURES_KEEPCLEANCONTROL );
   printf("   AC_FEATURES_DDGLITE : %ld\n", caps.ulFeatures & AC_FEATURES_DDGLITE );
   printf("   AC_FEATURES_FTEXTERNALEXPOSURE : %ld\n", caps.ulFeatures & AC_FEATURES_FTEXTERNALEXPOSURE );
   printf("   AC_FEATURES_KINETICEXTERNALEXPOSURE : %ld\n", caps.ulFeatures & AC_FEATURES_KINETICEXTERNALEXPOSURE );
   printf("   AC_FEATURES_DACCONTROL : %ld\n", caps.ulFeatures & AC_FEATURES_DACCONTROL );
   printf("   AC_FEATURES_METADATA : %ld\n", caps.ulFeatures & AC_FEATURES_METADATA );
   printf("   AC_FEATURES_IOCONTROL : %ld\n", caps.ulFeatures & AC_FEATURES_IOCONTROL );
   printf("   AC_FEATURES_PHOTONCOUNTING : %ld\n", caps.ulFeatures & AC_FEATURES_PHOTONCOUNTING );
   printf("   AC_FEATURES_COUNTCONVERT : %ld\n", caps.ulFeatures & AC_FEATURES_COUNTCONVERT );
   printf("   AC_FEATURES_DUALMODE : %ld\n", caps.ulFeatures & AC_FEATURES_DUALMODE );
   printf("   AC_FEATURES_OPTACQUIRE : %ld\n", caps.ulFeatures & AC_FEATURES_OPTACQUIRE );
   printf("   AC_FEATURES_REALTIMESPURIOUSNOISEFILTER : %ld\n", caps.ulFeatures & AC_FEATURES_REALTIMESPURIOUSNOISEFILTER );
   printf("   AC_FEATURES_POSTPROCESSSPURIOUSNOISEFILTER : %ld\n", caps.ulFeatures & AC_FEATURES_POSTPROCESSSPURIOUSNOISEFILTER );
   printf("\n");

   printf("ulPCICard: %ld    // max speed on Hz PCI card can go.\n", caps.ulPCICard);
   printf("\n");

   printf("ulEMGainCapability: 0x%04lx\n", caps.ulEMGainCapability);
   printf("   AC_EMGAIN_8BIT : %ld\n", caps.ulEMGainCapability & AC_EMGAIN_8BIT );
   printf("   AC_EMGAIN_12BIT : %ld\n", caps.ulEMGainCapability & AC_EMGAIN_12BIT );
   printf("   AC_EMGAIN_LINEAR12 : %ld\n", caps.ulEMGainCapability & AC_EMGAIN_LINEAR12 );
   printf("   AC_EMGAIN_REAL12 : %ld\n", caps.ulEMGainCapability & AC_EMGAIN_REAL12 );
#endif
   return 0;
}

/*----------------------------------------------------------------------
**  do_q2 - Query #2
**----------------------------------------------------------------------
*/
int do_q2( char * par )
{
#if IXON
   int rc;
   int  naxis1, naxis2, offon, i;
   int  serial_no;
   char buf[260];   // per manual
   float f;

   AndorCapabilities caps;

   // general queries.
   if( (rc=GetCameraSerialNumber( &serial_no )) != DRV_SUCCESS )
      printf("GetCameraSerialNumber() error %d", rc );
   else
      printf("Camera Serial No: %d \n", serial_no);

   if( (rc=GetHeadModel( buf )) != DRV_SUCCESS )
      printf("GetHeadModel() error %d\n", rc);
   else
      printf("head_model: %s \n", buf);

   if( (rc=GetControllerCardModel( buf )) != DRV_SUCCESS )
      printf("GetControllerCardModel() error %d\n", rc);
   else
      printf("CardModel: %s \n", buf);

   if( (rc=GetDetector( &naxis1, &naxis2 )) != DRV_SUCCESS )
      printf("GetDetector() error %d\n", rc);
   else
      printf("GetDetector: %dx%d \n", naxis1, naxis2);

   // needed to other queries.
   caps.ulSize = sizeof(caps);
   if( (rc=GetCapabilities( &caps )) != DRV_SUCCESS )
   {
      printf("GetCapabilities() error %d\n", rc);
      return 0;
   }
   // make sure we are using IXON
   if( caps.ulCameraType != AC_CAMERATYPE_IXON )
      printf("CameraType is NOT AC_CAMERATYPE_IXON\n.");

   // about the shutter.
   int has_mech_shutter;
   if( (rc=IsInternalMechanicalShutter( &has_mech_shutter )) != DRV_SUCCESS )
      printf("IsInternalMechanicalShutter() error %d\n", rc);
   else
      printf("IsInternalMechanicalShutter: installed=%d \n", has_mech_shutter );

   // about the cooler.
   int temp_min, temp_max;
   if( (rc=GetTemperatureRange( &temp_min, &temp_max )) != DRV_SUCCESS )
      printf("GetTemperatureRange() error %d\n", rc);
   else
      printf("GetTemperatureRange: %d %d\n", temp_min, temp_max );

   if( (rc=IsCoolerOn( &offon )) != DRV_SUCCESS )
      printf("IsCoolerOn() error %d\n", rc);
   else
      printf("IsCoolerOn: %d\n", offon );

   int temp_c;
   int temp_status;
   rc = GetTemperature( &temp_c );
   temp_status = rc - DRV_TEMP_OFF;   // convert from SDK status code to moris IXON_TEMP_STATUS_
   if( !INRANGE( IXON_TEMP_STATUS_OFF, temp_status, IXON_TEMP_STATUS_DRIFT) )
      temp_status = IXON_TEMP_STATUS_ERROR; /* error */
   printf("GetTemperature: status=%d(%s)  temp_c=%d\n",
      temp_status, Ixon_temperature_status[temp_status], temp_c );

   // About Vertical Pixel Shift options
   int num_VSS;
   if( (rc=GetNumberVSSpeeds( &num_VSS )) != DRV_SUCCESS )
      printf("GetNumberVSSpeeds() error %d\n", rc);
   else
   {
      printf( "GetNumberVSSpeeds=%d  \n", num_VSS);
      for(i=0; i<num_VSS; i++ )
      {
         GetVSSpeed( i, &f);
         printf( "VSS %d  %f usec \n", i, f);
      }
   }
   GetFastestRecommendedVSSpeed( &i, &f );
   printf("Fastest Recommended VSSpeed is %d %f\n", i, f);

   printf("\n");

   //
   // moris just lets user adjust converntional HHS
   //
   int num_channels, num_amps, num_preamp_gains;
   int num_HSS ;
   int ch, bits, amp, hhs, g;
   float gain;
   
   GetNumberADChannels( &num_channels );
   printf("GetNumberADChannels() is %d\n", num_channels);
   GetNumberAmp( &num_amps );
   printf("GetNumberAmp() is %d\n", num_amps);
   GetNumberPreAmpGains( &num_preamp_gains );
   printf("GetNumberPreAmpGains() is %d\n", num_preamp_gains);

   for( ch=0; ch<num_channels; ch++ )
   {
      GetBitDepth( ch, &bits);
      for( amp=0; amp<num_amps; amp++ )
      {
         GetNumberHSSpeeds( ch, amp, &num_HSS );
         for(hhs=0; hhs<num_HSS; hhs++ )
         {
            GetHSSpeed( ch, amp, hhs, &f);
            printf( "ch=%d bits=%d amp=%d HSS=%d is %f MHz \n", ch, bits, amp, hhs, f);
            for( g=0; g<num_preamp_gains; g++)
            {
               GetPreAmpGain( g, &gain);
               IsPreAmpGainAvailable( ch, amp, hhs, g, &i);
               printf("   g=%d gain=%f OK=%d \n", g, gain, i);
            }
         }
      }
   }

#endif
   return 0;
}


/*----------------------------------------------------------------------
**  do_t1 - return status
**----------------------------------------------------------------------
*/
int do_t1( char * par )
{
   return 0;
}


/*----------------------------------------------------------------------
**  do_help() - set Quit flag to TRUE.
**----------------------------------------------------------------------
*/
int do_help( char *par )
{
   int i;

   printf("\n"
          "This program communicates with the andor IXON camera. \n"
          "Summary of commands:\n");

   for( i=0; i<num_parse_item; i++)
   {
      printf("   %s\n", parse_table[i].desc);
   }
   printf("\n");
   return 0;
}


/*----------------------------------------------------------------------
**  do_quit() - set Quit flag to TRUE.
**----------------------------------------------------------------------
*/
int do_quit( char * par )
{
   Quit = TRUE;
   return 0;
}

/*----------------------------------------------------------------------
**  get_long() - prompt the user and reads a long from the keyboard.
**----------------------------------------------------------------------
*/
long get_long (  char *prompt, long cur_val, long min, long max )
{
   char buf[80];

   while( 1 )
   {
      printf( "%s (%ld): ", prompt, cur_val );
      scanf("%s", buf );
      unpad( buf, ' ' );
      if( strlen(buf) >= 1 )
         cur_val = atol(buf);

      if( INRANGE(min, cur_val, max))
      {
         return cur_val;
      }
      else
         printf("\007INVALID Input. Range is %ld to %ld.\n", min, max);
   }
}



/*------------------------------------------------------------
**  buf_2_dv() - Send data to dv as a FITS file.
**------------------------------------------------------------
*/
int buf_2_dv(
   char * host,   // I: dv's socket on this host
   int dvport,    // I: dv's socket port number.
   int   naxis1,  // I: naxis1 - size of array x axis.
   int   naxis2,  // I: naxis2 - size of array y axis
   long  *data    // I: array of longs.
)
{
   char *cptr,
        *buf;
   long *sp, *dp;
   char tstr[80];
   int i, j, n, loop, one, npixels;
   int fd_socket;

   #define FITS_RECORD_LEN 2880

   if( NULL == (buf=(char*)malloc( FITS_RECORD_LEN )) )
      { return ERR_MEM_ALLOC; }

   if( (fd_socket = sock_open( host, dvport, SOCK_STREAM, 0)) > 0)
   {
      one = 1;
      setsockopt( fd_socket , SOL_SOCKET, SO_REUSEADDR, &one, sizeof( one ));

      /* Give command to read a fits file from socket */
      strcpy( tstr, "ReadSock A ");
      sock_write_msg( fd_socket, tstr, TRUE, SOCK_TIMEOUT_MS );

      /* write header */
      cptr = buf;
      memset( buf, ' ', 2880);
      cptr = Gbuild_card2( cptr, "SIMPLE",   "T", "DATA IS IN FITS FORMAT");
      cptr = Gbuild_card2( cptr, "BITPIX",  "32", "32 BITS TWOS COMPLEMENT INT");
      cptr = Gbuild_card2( cptr, "NAXIS",    "2", "NUMBER OF AXIS");
      sprintf( tstr, "%d", naxis1);
      cptr = Gbuild_card2( cptr, "NAXIS1", tstr, "1st MOST VARYING AXIS");
      sprintf( tstr, "%d", naxis2);
      cptr = Gbuild_card2( cptr, "NAXIS2", tstr, "2nd MOST VARYING AXIS");
      cptr = Gbuild_card2( cptr, "END", " ", "End of header");
      sock_write_data( fd_socket, (char*) buf, 2880, TRUE, SOCK_TIMEOUT_MS);

      npixels = naxis1 * naxis2;
      n = sizeof(long) * naxis1 * naxis2;
      loop = n / FITS_RECORD_LEN;
      if( n % FITS_RECORD_LEN )
         loop++;

      sp = data;
      for( i=0; i<loop; i++)
      {
         dp = (long*) buf;
         for( j=0; j<720; j++)
         {
            if( npixels > 0 )
            {
               *dp++ = htonl(*sp);
               sp++;
               npixels--;
            }
            else
            {
               *dp++ = 0;   // ran out of pixels, set destination to 0.
            }
         }
         sock_write_data( fd_socket, (char*) buf, FITS_RECORD_LEN, TRUE, SOCK_TIMEOUT_MS);
      }
      close( fd_socket );
   }
   free( buf );

   return ERR_NONE;
}

/*--------------------------------------------------------------------
**  Gbuild_card2 () - creates a FITS header card in a memory area.
**--------------------------------------------------------------------
*/
char * Gbuild_card2( char * cptr, char * keyword, char * value, char * comment )
{
   char outbuf[85];
   int l;
   if( strlen(value) > 18 )
      sprintf(outbuf, "%-8.8s= %30.30s / %-s ", keyword, value, comment);
   else
      sprintf(outbuf, "%-8.8s= %20.20s / %-s ", keyword, value, comment);
   l = strlen(outbuf);
   if( l < 80 )
      memset( &outbuf[l], ' ', 80-l);
   outbuf[80] = '\0';

   strncpy( cptr, outbuf, 80);
   return ( cptr + 80 );
}