kstars/kstars/indi/sbigccd.cpp

   1 #if 0
   2     INDI driver for SBIG CCD
   3     Copyright (C) 2005 Chris Curran (ccurran AT planetcurran DOT com)
   4
   5     Based on Apogee PPI driver by Jasem Mutlaq (mutlaqja AT ikarustech DOT com)
   6
   7     This library is free software; you can redistribute it and/or
   8     modify it under the terms of the GNU Lesser General Public
   9     License as published by the Free Software Foundation; either
  10     version 2.1 of the License, or (at your option) any later version.
  11
  12     This library is distributed in the hope that it will be useful,
  13     but WITHOUT ANY WARRANTY; without even the implied warranty of
  14     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15     Lesser General Public License for more details.
  16
  17     You should have received a copy of the GNU Lesser General Public
  18     License along with this library; if not, write to the Free Software
  19     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  20
  21 #endif
  22
  23 #include <ctype.h>
  24 #include <sys/stat.h>
  25 #include <sys/time.h>
  26 #include <sys/types.h>
  27 #include <sys/socket.h>
  28 #include <netinet/in.h>
  29 #include <netdb.h>
  30 #include <zlib.h>
  31
  32 #include "sbigccd.h"
  33 #include "lilxml.h"
  34 #include "base64.h"
  35
  36 extern char* me;                        /* argv[0] */
  37 SBIGCam *MainCam = NULL;                /* Main and only camera */
  38
  39 /* send client definitions of all properties */
  40 void ISInit()
  41 {
  42   if (MainCam == NULL)
  43     MainCam = new SBIGCam();
  44 }
  45
  46 void ISGetProperties (const char *dev)
  47 {
  48   if (dev && strcmp (mydev, dev))
  49     return;
  50
  51    ISInit();
  52
  53   MainCam->ISGetProperties(dev);
  54 }
  55
  56
  57 void ISNewSwitch (const char *dev, const char *name, ISState *states, char *names[], int n)
  58 {
  59
  60   /* ignore if not ours */
  61   if (dev && strcmp (dev, mydev))
  62     return;
  63
  64   ISInit();
  65
  66   MainCam->ISNewSwitch(dev, name, states, names, n);
  67 }
  68
  69 void ISNewText (const char *dev, const char *name, char *texts[], char *names[], int n)
  70 {
  71   /* ignore if not ours */
  72   if (dev && strcmp (mydev, dev))
  73     return;
  74
  75    ISInit();
  76
  77    MainCam->ISNewText(dev, name, texts, names, n);
  78 }
  79
  80
  81 void ISNewNumber (const char *dev, const char *name, double values[], char *names[], int n)
  82 {
  83
  84   /* ignore if not ours */
  85   if (dev && strcmp (dev, mydev))
  86     return;
  87
  88   ISInit();
  89
  90   MainCam->ISNewNumber(dev, name, values, names, n);
  91 }
  92
  93 void ISNewBLOB (const char */*dev*/, const char */*name*/, int */*sizes[]*/, char **/*blobs[]*/, char **/*formats[]*/, char **/*names[]*/, int /*n*/)
  94 {
  95
  96   // We use this if we're receving binary data from the client. Most likely we won't for this driver.
  97
  98 }
  99
 100 SBIGCam::SBIGCam()
 101 {
 102   initProperties();
 103   IEAddTimer (POLLMS, SBIGCam::ISStaticPoll, this);
 104 }
 105
 106 SBIGCam::~SBIGCam()
 107 {
 108
 109 }
 110
 111 void SBIGCam::initProperties()
 112 {
 113   fillSwitch(&PowerS[0], "CONNECT", "Connect", ISS_OFF);
 114   fillSwitch(&PowerS[1], "DISCONNECT", "Disconnect", ISS_ON);
 115   fillSwitchVector(&PowerSP, PowerS, NARRAY(PowerS), mydev, "CONNECTION", "Connection", COMM_GROUP, IP_RW, ISR_1OFMANY, 60, IPS_IDLE);
 116
 117   fillSwitch(&FrameTypeS[0], "FRAME_LIGHT", "Light", ISS_ON);
 118   fillSwitch(&FrameTypeS[1], "FRAME_BIAS", "Bias", ISS_OFF);
 119   fillSwitch(&FrameTypeS[2], "FRAME_DARK", "Dark", ISS_OFF);
 120   fillSwitch(&FrameTypeS[3], "FRAME_FLAT", "Flat Field", ISS_OFF);
 121   fillSwitchVector(&FrameTypeSP, FrameTypeS, NARRAY(FrameTypeS), mydev, "FRAME_TYPE", "Frame Type", EXPOSE_GROUP, IP_RW, ISR_1OFMANY, 60, IPS_IDLE);
 122
 123   fillNumber(&FrameN[0], "X", "", "%.0f", 0., MAX_PIXELS, 1., 0.);
 124   fillNumber(&FrameN[1], "Y", "", "%.0f", 0., MAX_PIXELS, 1., 0.);
 125   fillNumber(&FrameN[2], "Width", "", "%.0f", 0., MAX_PIXELS, 1., 0.);
 126   fillNumber(&FrameN[3], "Height", "", "%.0f", 0., MAX_PIXELS, 1., 0.);
 127   fillNumberVector(&FrameNP, FrameN, NARRAY(FrameN), mydev, "FRAME", "Frame", IMAGE_GROUP, IP_RW, 60, IPS_IDLE);
 128
 129   fillNumber(&BinningN[0], "HOR_BIN", "X", "%0.f", 1., MAXHBIN, 1., 1.);
 130   fillNumber(&BinningN[1], "VER_BIN", "Y", "%0.f", 1., MAXVBIN, 1., 1.);
 131   fillNumberVector(&BinningNP, BinningN, NARRAY(BinningN), mydev, "BINNING", "Binning", IMAGE_GROUP, IP_RW, 60, IPS_IDLE);
 132
 133   fillNumber(&ExposeTimeN[0], "EXPOSE_S", "Duration (s)", "%5.2f", 0., 36000., 0.5, 1.);
 134   fillNumberVector(&ExposeTimeNP, ExposeTimeN, NARRAY(ExposeTimeN), mydev, "EXPOSE_DURATION", "Expose", EXPOSE_GROUP, IP_RW, 60, IPS_IDLE);
 135
 136   fillNumber(&TemperatureN[0], "TEMPERATURE", "Temperature", "%+06.2f", MIN_CCD_TEMP, MAX_CCD_TEMP, 0.2, 0.);
 137   fillNumberVector(&TemperatureNP, TemperatureN, NARRAY(TemperatureN), mydev, "CCD_TEMPERATURE", "Expose", EXPOSE_GROUP, IP_RW, 60, IPS_IDLE);
 138
 139   // We need to setup the BLOB (Binary Large Object) below. Using this property, we can send FITS to our client
 140   strcpy(imageB.name, "CCD1");
 141   strcpy(imageB.label, "Feed");
 142   strcpy(imageB.format, "");
 143   imageB.blob    = 0;
 144   imageB.bloblen = 0;
 145   imageB.size    = 0;
 146   imageB.bvp     = 0;
 147   imageB.aux0    = 0;
 148   imageB.aux1    = 0;
 149   imageB.aux2    = 0;
 150
 151   strcpy(imageBP.device, mydev);
 152   strcpy(imageBP.name, "Video");
 153   strcpy(imageBP.label, "Video");
 154   strcpy(imageBP.group, COMM_GROUP);
 155   strcpy(imageBP.timestamp, "");
 156   imageBP.p       = IP_RO;
 157   imageBP.timeout = 0;
 158   imageBP.s       = IPS_IDLE;
 159   imageBP.bp      = &imageB;
 160   imageBP.nbp     = 1;
 161   imageBP.aux     = 0;
 162
 163 }
 164
 165 void SBIGCam::ISGetProperties(const char */*dev*/)
 166 {
 167
 168   /* COMM_GROUP */
 169   IDDefSwitch(&PowerSP, NULL);
 170   IDDefBLOB(&imageBP, NULL);
 171
 172   /* Expose */
 173   IDDefSwitch(&FrameTypeSP, NULL);
 174   IDDefNumber(&ExposeTimeNP, NULL);
 175   IDDefNumber(&TemperatureNP, NULL);
 176
 177   /* Image Group */
 178   IDDefNumber(&FrameNP, NULL);
 179   IDDefNumber(&BinningNP, NULL);
 180
 181 }
 182
 183 void SBIGCam::ISNewSwitch (const char */*dev*/, const char *name, ISState *states, char *names[], int n)
 184 {
 185
 186         /* Connection */
 187         if (!strcmp (name, PowerSP.name))
 188         {
 189                 IUResetSwitches(&PowerSP);
 190                 IUUpdateSwitches(&PowerSP, states, names, n);
 191                 connectCCD();
 192                 return;
 193         }
 194
 195         /* Frame Type */
 196         if (!strcmp(FrameTypeSP.name, name))
 197         {
 198                 if (checkPowerS(&FrameTypeSP))
 199                 return;
 200
 201                 IUResetSwitches(&FrameTypeSP);
 202                 IUUpdateSwitches(&FrameTypeSP, states, names, n);
 203                 FrameTypeSP.s = IPS_OK;
 204                 IDSetSwitch(&FrameTypeSP, NULL);
 205
 206                 return;
 207         }
 208
 209 }
 210
 211 void SBIGCam::ISNewText (const char */*dev*/, const char */*name*/, char **/*texts[]*/, char **/*names[]*/, int /*n*/)
 212 {
 213
 214 }
 215
 216 void SBIGCam::ISNewNumber (const char */*dev*/, const char *name, double values[], char *names[], int n)
 217 {
 218     /* Exposure time */
 219     if (!strcmp (ExposeTimeNP.name, name))
 220     {
 221        if (checkPowerN(&ExposeTimeNP))
 222          return;
 223
 224        if (ExposeTimeNP.s == IPS_BUSY)
 225        {
 226           ExposeTimeNP.s = IPS_IDLE;
 227           ExposeTimeN[0].value = 0;
 228
 229           IDSetNumber(&ExposeTimeNP, "Exposure cancelled.");
 230           IDLog("Exposure Cancelled.\n");
 231           return;
 232         }
 233
 234        ExposeTimeNP.s = IPS_IDLE;
 235
 236        IUUpdateNumbers(&ExposeTimeNP, values, names, n);
 237
 238       IDLog("Exposure Time (ms) is: %g\n", ExposeTimeN[0].value);
 239
 240       handleExposure(NULL);
 241       return;
 242     }
 243
 244   if (!strcmp(TemperatureNP.name, name))
 245   {
 246     if (checkPowerN(&TemperatureNP))
 247       return;
 248
 249     TemperatureNP.s = IPS_IDLE;
 250
 251     if (values[0] < MIN_CCD_TEMP || values[0] > MAX_CCD_TEMP)
 252     {
 253       IDSetNumber(&TemperatureNP, "Error: valid range of temperature is from %d to %d", MIN_CCD_TEMP, MAX_CCD_TEMP);
 254       return;
 255     }
 256
 257     targetTemp = values[0];
 258
 259     // JM: Below, tell SBIG to update to temperature to targetTemp
 260     // e.g. cam->setTemp(targetTemp);
 261
 262
 263     // Now we set property to busy and poll in ISPoll for CCD temp
 264     TemperatureNP.s = IPS_BUSY;
 265
 266     IDSetNumber(&TemperatureNP, "Setting CCD temperature to %+06.2f C", values[0]);
 267     IDLog("Setting CCD temperature to %+06.2f C\n", values[0]);
 268     return;
 269    }
 270
 271    // Subframing
 272    if (!strcmp(FrameNP.name, name))
 273    {
 274      if (checkPowerN(&FrameNP))
 275       return;
 276
 277      FrameNP.s = IPS_OK;
 278      IUUpdateNumbers(&FrameNP, values, names, n);
 279
 280      // JM: Below, we setup the frame size we want to take exposure of
 281      // The way it is done depends on the camera API. Example below
 282      //cam->m_StartX = (int) FrameN[0].value;
 283      //cam->m_StartY = (int) FrameN[1].value;
 284      //cam->m_Width   = (int) FrameN[2].value;
 285      //cam->m_Height  = (int) FrameN[3].value;
 286
 287      IDSetNumber(&FrameNP, NULL);
 288
 289    } /* end FrameNP */
 290
 291
 292    // Binning
 293    if (!strcmp(BinningNP.name, name))
 294    {
 295      if (checkPowerN(&BinningNP))
 296        return;
 297
 298
 299      BinningNP.s = IPS_OK;
 300      IUUpdateNumbers(&BinningNP, values, names, n);
 301
 302      // JM: Below we set the camera binning.
 303      // eg:
 304      //cam->m_BinX = (int) BinningN[0].value;
 305      //cam->m_BinY = (int) BinningN[1].value;
 306
 307      IDLog("Binning is: %.0f x %.0f\n", BinningN[0].value, BinningN[1].value);
 308      return;
 309    }
 310 }
 311
 312
 313 void SBIGCam::ISStaticPoll(void *p)
 314 {
 315         if (!((SBIGCam *)p)->isCCDConnected())
 316         {
 317           IEAddTimer (POLLMS, SBIGCam::ISStaticPoll, p);
 318           return;
 319         }
 320
 321         ((SBIGCam *) p)->ISPoll();
 322
 323         IEAddTimer (POLLMS, SBIGCam::ISStaticPoll, p);
 324 }
 325
 326 void SBIGCam::ISPoll()
 327 {
 328   static int mtc=5;
 329   int readStatus=0;
 330   double ccdTemp (0);
 331
 332   switch (ExposeTimeNP.s)
 333   {
 334     case IPS_IDLE:
 335     case IPS_OK:
 336       break;
 337
 338     case IPS_BUSY:
 339
 340       // JM: Here we check the status of the camera (whether it's still capturing an image or has finished that)
 341       // ISPoll is called once per second. e.g. below for how we do this for Apogee Cameras
 342       /*
 343       readStatus = cam->read_Status();
 344       if (readStatus < 0)
 345       {
 346         IDLog("Error in exposure!\n");
 347         ExposeTimeNP.s = IPS_IDLE;
 348         ExposeTimeN[0].value = 0;
 349         IDSetNumber(&ExposeTimeNP, "Error in exposure procedure.");
 350         return;
 351       }
 352       else if (readStatus == Camera_Status_ImageReady)
 353       {
 354         ExposeTimeN[0].value = 0;
 355         ExposeTimeNP.s = IPS_OK;
 356         IDSetNumber(&ExposeTimeNP, "Exposure done, downloading image...");
 357         IDLog("Exposure done, downloading image...\n");
 358         // grab and save image. Don't forget to call this!
 359         grabImage();
 360         return;
 361       } */
 362
 363       ExposeTimeN[0].value --;
 364       IDSetNumber(&ExposeTimeNP, NULL);
 365       break;
 366
 367         case IPS_ALERT:
 368             break;
 369         }
 370
 371
 372      switch (TemperatureNP.s)
 373      {
 374            // JM: If we're not setting a new temperature (i.e. state is either ok or idle)
 375            // We simply check for the temp every 5 seconds (this is why mtc = 5 and then decremented).
 376            case IPS_IDLE:
 377            case IPS_OK:
 378              mtc--;
 379
 380              if (mtc == 0)
 381              {
 382                //TemperatureN[0].value = cam->read_Temperature();
 383                IDSetNumber(&TemperatureNP, NULL);
 384                mtc = 5;
 385              }
 386              break;
 387
 388            // JM: If we're setting a new temperature, we continously check for it here untill we get
 389            // a "close enough" value. This close enough value as seen below is the TEMP_THRESHOLD (0.25 C)
 390            case IPS_BUSY:
 391
 392              // Read in current CCD temp
 393              //ccdTemp = cam->read_Temperature();
 394
 395              if (fabs(targetTemp - ccdTemp) <= TEMP_THRESHOLD)
 396                TemperatureNP.s = IPS_OK;
 397
 398               mtc = 1;
 399               TemperatureN[0].value = ccdTemp;
 400               IDSetNumber(&TemperatureNP, NULL);
 401               break;
 402
 403             case IPS_ALERT:
 404              break;
 405           }
 406
 407 }
 408
 409 /* Downloads the image from the CCD row by row and store them
 410    in a raw file.
 411  N.B. No processing is done on the image */
 412 void SBIGCam::grabImage()
 413 {
 414
 415   long err;
 416   int img_size, fd;
 417   char errmsg[1024];
 418   char filename[] = "/tmp/fitsXXXXXX";
 419
 420    if ((fd = mkstemp(filename)) < 0)
 421    {
 422     IDMessage(mydev, "Error making temporary filename.");
 423     IDLog("Error making temporary filename.\n");
 424     return;
 425    }
 426    close(fd);
 427
 428    // JM: allocate memory for buffer. In most cameras, the bit depth is 16 bit and so we use unsigned short
 429    // But change if the bit depth is different
 430    img_size = SBIGFrame.width * SBIGFrame.height * sizeof(unsigned short);
 431
 432    SBIGFrame.img = (unsigned short *) malloc (img_size);
 433
 434   if (SBIGFrame.img == NULL)
 435   {
 436     IDMessage(mydev, "Not enough memory to store image.");
 437     IDLog("Not enough memory to store image.\n");
 438     return;
 439   }
 440
 441   // JM: Here we fetch the image from the camera
 442   //
 443   /*if (!cam->GetImage( SBIGFrame.img , SBIGFrame.width, SBIGFrame.height ))
 444   {
 445        free(SBIGFrame.img);
 446        IDMessage(mydev, "GetImage() failed.");
 447        IDLog("GetImage() failed.");
 448        return;
 449   }*/
 450
 451    err = writeFITS(filename, errmsg);
 452
 453    if (err)
 454    {
 455        free(SBIGFrame.img);
 456        IDMessage(mydev, errmsg, NULL);
 457        return;
 458    }
 459
 460   free(SBIGFrame.img);
 461
 462 }
 463
 464 int SBIGCam::writeFITS(char *filename, char errmsg[])
 465 {
 466
 467   FITS_FILE* ofp;
 468   int bpp, bpsl, width, height;
 469   long nbytes;
 470   FITS_HDU_LIST *hdu;
 471
 472   ofp = fits_open (filename, "w");
 473   if (!ofp)
 474   {
 475     sprintf(errmsg, "Error: cannot open file for writing.");
 476     return (-1);
 477   }
 478
 479   // We're assuming bit depth is 16 (unsigned short). Change as desired.
 480   width  = SBIGFrame.width;
 481   height = SBIGFrame.height;
 482   bpp    = sizeof(unsigned short);   /* Bytes per Pixel */
 483   bpsl   = bpp * SBIGFrame.width;    /* Bytes per Line */
 484   nbytes = 0;
 485
 486   hdu = create_fits_header (ofp, width, height, bpp);
 487   if (hdu == NULL)
 488   {
 489      sprintf(errmsg, "Error: creating FITS header failed.");
 490      return (-1);
 491   }
 492   if (fits_write_header (ofp, hdu) < 0)
 493   {
 494     sprintf(errmsg, "Error: writing to FITS header failed.");
 495     return (-1);
 496   }
 497
 498   // JM: Here we're performing little endian to big endian (network order) conversion
 499   // Since FITS is stored in big endian. If the camera provides the image buffer in big endian
 500   // then there is no need for this conversion
 501   for (int i=0; i < height; i++)
 502     for (int j=0 ; j < width; j++)
 503       SBIGFrame.img[width * i + j] = getBigEndian( (SBIGFrame.img[width * i + j]) );
 504
 505   // The "2" below is for two bytes (16 bit or unsigned short). Again, change as desired.
 506   for (int i= 0; i < height  ; i++)
 507   {
 508     fwrite(SBIGFrame.img + (i * width), 2, width, ofp->fp);
 509     nbytes += bpsl;
 510   }
 511
 512   nbytes = nbytes % FITS_RECORD_SIZE;
 513   if (nbytes)
 514   {
 515     while (nbytes++ < FITS_RECORD_SIZE)
 516       putc (0, ofp->fp);
 517   }
 518
 519   if (ferror (ofp->fp))
 520   {
 521     sprintf(errmsg, "Error: write error occured");
 522     return (-1);
 523   }
 524
 525  fits_close (ofp);
 526
 527   /* Success */
 528  ExposeTimeNP.s = IPS_OK;
 529  IDSetNumber(&ExposeTimeNP, NULL);
 530  IDLog("Loading FITS image...\n");
 531
 532  uploadFile(filename);
 533
 534  return 0;
 535
 536 }
 537
 538 void SBIGCam::uploadFile(char * filename)
 539 {
 540
 541    FILE * fitsFile;
 542    unsigned char *fitsData, *compressedData;
 543    int r=0;
 544    unsigned int i =0, nr = 0;
 545    uLongf compressedBytes=0;
 546    uLong  totalBytes;
 547    struct stat stat_p;
 548
 549    if ( -1 ==  stat (filename, &stat_p))
 550    {
 551      IDLog(" Error occoured attempting to stat %s\n", filename);
 552      return;
 553    }
 554
 555    totalBytes     = stat_p.st_size;
 556    fitsData       = (unsigned char *) malloc (sizeof(unsigned char) * totalBytes);
 557    compressedData = (unsigned char *) malloc (sizeof(unsigned char) * totalBytes + totalBytes / 64 + 16 + 3);
 558
 559    if (fitsData == NULL || compressedData == NULL)
 560    {
 561      IDLog("Error! low memory. Unable to initialize fits buffers.\n");
 562      return;
 563    }
 564
 565    fitsFile = fopen(filename, "r");
 566
 567    if (fitsFile == NULL)
 568     return;
 569
 570    /* #1 Read file from disk */
 571    for (i=0; i < totalBytes; i+= nr)
 572    {
 573       nr = fread(fitsData + i, 1, totalBytes - i, fitsFile);
 574
 575      if (nr <= 0)
 576      {
 577         IDLog("Error reading temporary FITS file.\n");
 578         return;
 579      }
 580    }
 581
 582    compressedBytes = sizeof(char) * totalBytes + totalBytes / 64 + 16 + 3;
 583
 584    /* #2 Compress it */
 585    r = compress2(compressedData, &compressedBytes, fitsData, totalBytes, 9);
 586    if (r != Z_OK)
 587    {
 588         /* this should NEVER happen */
 589         IDLog("internal error - compression failed: %d\n", r);
 590         return;
 591    }
 592
 593    /* #3 Send it */
 594    imageB.blob = compressedData;
 595    imageB.bloblen = compressedBytes;
 596    imageB.size = totalBytes;
 597    strcpy(imageB.format, ".fits.z");
 598    imageBP.s = IPS_OK;
 599    IDSetBLOB (&imageBP, NULL);
 600
 601    free (fitsData);
 602    free (compressedData);
 603
 604 }
 605
 606 /* Initiates the exposure procedure */
 607 void SBIGCam::handleExposure(void */*p*/)
 608 {
 609
 610   int curFrame = getOnSwitch(&FrameTypeSP);
 611
 612   switch (curFrame)
 613   {
 614     /* Light frame */
 615    case LIGHT_FRAME:
 616
 617    /*if (!cam->Expose( (int) ExposeTimeN[0].value, true ))
 618    {
 619      ExposeTimeNP.s = IPS_IDLE;
 620      IDSetNumber(&ExposeTimeNP, "Light Camera exposure failed.");
 621      IDLog("Light Camera exposure failed.\n");
 622      return;
 623    }*/
 624    break;
 625
 626    /* BIAS frame is the same as DARK but with minimum period. i.e. readout from camera electronics.
 627    */
 628     case BIAS_FRAME:
 629
 630       /*if (!cam->Expose( 0.05 , false ))
 631       {
 632         ExposeTimeNP.s = IPS_IDLE;
 633         IDSetNumber(&ExposeTimeNP, "Bias Camera exposure failed.");
 634         IDLog("Bias Camera exposure failed.\n");
 635         return;
 636       }*/
 637       break;
 638
 639       /* Dark frame */
 640     case DARK_FRAME:
 641
 642       /*if (!cam->Expose( (int) ExposeTimeN[0].value , false ))
 643       {
 644         ExposeTimeNP.s = IPS_IDLE;
 645         IDSetNumber(&ExposeTimeNP, "Dark Camera exposure failed.");
 646         IDLog("Dark Camera exposure failed.\n");
 647         return;
 648       }*/
 649       break;
 650
 651     case FLAT_FRAME:
 652
 653       /*if (!cam->Expose( (int) ExposeTimeN[0].value , true ))
 654       {
 655         ExposeTimeNP.s = IPS_IDLE;
 656         IDSetNumber(&ExposeTimeNP, "Flat Camera exposure failed.");
 657         IDLog("Flat Camera exposure failed.\n");
 658         return;
 659       }*/
 660       break;
 661   }
 662
 663   SBIGFrame.frameType   = curFrame;
 664   SBIGFrame.width       = (int) FrameN[2].value;
 665   SBIGFrame.height      = (int) FrameN[3].value;
 666   SBIGFrame.expose      = (int) ExposeTimeN[0].value;
 667   SBIGFrame.temperature =       TemperatureN[0].value;
 668   SBIGFrame.binX        = (int) BinningN[0].value;
 669   SBIGFrame.binY        = (int) BinningN[1].value;
 670
 671   ExposeTimeNP.s = IPS_BUSY;
 672
 673   IDSetNumber(&ExposeTimeNP, "Taking a %g seconds frame...", ExposeTimeN[0].value);
 674   IDLog("Taking a frame...\n");
 675
 676 }
 677
 678 /* Retrieves basic data from the CCD upon connection like temperature, array size, firmware..etc */
 679 void SBIGCam::getBasicData()
 680 {
 681
 682
 683   // Maximum resolution
 684
 685   // JM: Update here basic variables upon connection.
 686
 687   /*
 688   FrameN[2].max = cam->m_NumX;
 689   FrameN[3].max = cam->m_NumY;
 690   IUUpdateMinMax(&FrameNP);
 691
 692   // Maximum Bin
 693   BinningN[0].max = cam->m_MaxBinX;
 694   BinningN[1].max = cam->m_MaxBinX;
 695   IUUpdateMinMax(&BinningNP);
 696
 697   // Current Temperature
 698   TemperatureN[0].value = cam->read_Temperature();
 699   IDSetNumber(&TemperatureNP, NULL);*/
 700
 701 }
 702
 703 int SBIGCam::getOnSwitch(ISwitchVectorProperty *sp)
 704 {
 705  for (int i=0; i < sp->nsp ; i++)
 706  {
 707      if (sp->sp[i].s == ISS_ON)
 708       return i;
 709  }
 710
 711  return -1;
 712 }
 713
 714 int SBIGCam::checkPowerS(ISwitchVectorProperty *sp)
 715 {
 716   if (PowerSP.s != IPS_OK)
 717   {
 718     if (!strcmp(sp->label, ""))
 719         IDMessage (mydev, "Cannot change property %s while the CCD is offline.", sp->name);
 720     else
 721         IDMessage (mydev, "Cannot change property %s while the CCD is offline.", sp->label);
 722
 723     sp->s = IPS_IDLE;
 724     IDSetSwitch(sp, NULL);
 725     return -1;
 726   }
 727
 728   return 0;
 729 }
 730
 731 int SBIGCam::checkPowerN(INumberVectorProperty *np)
 732 {
 733   if (PowerSP.s != IPS_OK)
 734   {
 735      if (!strcmp(np->label, ""))
 736         IDMessage (mydev, "Cannot change property %s while the CCD is offline.", np->name);
 737     else
 738         IDMessage (mydev, "Cannot change property %s while the CCD is offline.", np->label);
 739
 740     np->s = IPS_IDLE;
 741     IDSetNumber(np, NULL);
 742     return -1;
 743   }
 744
 745   return 0;
 746 }
 747
 748 int SBIGCam::checkPowerT(ITextVectorProperty *tp)
 749 {
 750
 751   if (PowerSP.s != IPS_OK)
 752   {
 753     if (!strcmp(tp->label, ""))
 754         IDMessage (mydev, "Cannot change property %s while the CCD is offline.", tp->name);
 755     else
 756         IDMessage (mydev, "Cannot change property %s while the CCD is offline.", tp->label);
 757
 758     tp->s = IPS_IDLE;
 759     IDSetText(tp, NULL);
 760     return -1;
 761   }
 762
 763   return 0;
 764
 765 }
 766
 767 void SBIGCam::connectCCD()
 768 {
 769
 770   switch (PowerS[0].s)
 771   {
 772     case ISS_ON:
 773       if (initCamera())
 774       {
 775         /* Sucess! */
 776         PowerS[0].s = ISS_ON;
 777         PowerS[1].s = ISS_OFF;
 778         PowerSP.s = IPS_OK;
 779         IDSetSwitch(&PowerSP, "CCD is online. Retrieving basic data.");
 780         IDLog("CCD is online. Retrieving basic data.\n");
 781         getBasicData();
 782
 783       }
 784       else
 785       {
 786         PowerSP.s = IPS_IDLE;
 787         PowerS[0].s = ISS_OFF;
 788         PowerS[1].s = ISS_ON;
 789         IDSetSwitch(&PowerSP, "Error: no cameras were detected.");
 790         IDLog("Error: no cameras were detected.\n");
 791         return;
 792       }
 793
 794       break;
 795
 796     case ISS_OFF:
 797       PowerS[0].s = ISS_OFF;
 798       PowerS[1].s = ISS_ON;
 799       PowerSP.s = IPS_IDLE;
 800       IDSetSwitch(&PowerSP, "CCD is offline.");
 801
 802       // JM: Disconnect cam and clean up
 803       // e.g. disConnectSBIG();
 804       break;
 805      }
 806
 807 }
 808
 809 bool SBIGCam::initCamera()
 810 {
 811   // JM: Here, we do all camera initilization stuff and we establish a connection to the camera
 812   // If everything goes well, we return true, otherwise false
 813   // Please use IDLog(...) to report errors.
 814
 815   return false;
 816 }
 817
 818 /* isCCDConnected: return 1 if we have a connection, 0 otherwise */
 819 int SBIGCam::isCCDConnected(void)
 820 {
 821   return ((PowerS[0].s == ISS_ON) ? 1 : 0);
 822 }
 823
 824 FITS_HDU_LIST * SBIGCam::create_fits_header (FITS_FILE *ofp, uint width, uint height, uint bpp)
 825 {
 826
 827  FITS_HDU_LIST *hdulist;
 828
 829  char temp_s[FITS_CARD_SIZE], expose_s[FITS_CARD_SIZE], binning_s[FITS_CARD_SIZE], pixel_s[FITS_CARD_SIZE], frame_s[FITS_CARD_SIZE];
 830  char obsDate[FITS_CARD_SIZE];
 831
 832  snprintf(obsDate, FITS_CARD_SIZE, "DATE-OBS= '%s' /Observation Date UTC", timestamp());
 833
 834  hdulist = fits_add_hdu (ofp);
 835  if (hdulist == NULL) return (NULL);
 836
 837  hdulist->used.simple = 1;
 838  hdulist->bitpix = 16;
 839  hdulist->naxis = 2;
 840  hdulist->naxisn[0] = width;
 841  hdulist->naxisn[1] = height;
 842  hdulist->naxisn[2] = bpp;
 843  // JM: Record here the minimum and maximum pixel values
 844  /*hdulist->used.datamin = min();
 845  hdulist->datamin = min();
 846  hdulist->used.datamax = max();
 847  hdulist->datamax = max();*/
 848  hdulist->used.bzero = 1;
 849  hdulist->bzero = 0.0;
 850  hdulist->used.bscale = 1;
 851  hdulist->bscale = 1.0;
 852
 853  snprintf(temp_s, FITS_CARD_SIZE, "CCD-TEMP= %g / degrees celcius", SBIGFrame.temperature);
 854  snprintf(expose_s, FITS_CARD_SIZE, "EXPOSURE= %d / milliseconds", SBIGFrame.expose);
 855  snprintf(binning_s, FITS_CARD_SIZE, "BINNING = '(%d x %d)'", SBIGFrame.binX, SBIGFrame.binY);
 856  //sprintf(pixel_s, "PIX-SIZ = '%.0f microns square'", PixelSizeN[0].value);
 857  switch (SBIGFrame.frameType)
 858   {
 859     case LIGHT_FRAME:
 860         strcpy(frame_s, "FRAME   = 'Light'");
 861         break;
 862     case BIAS_FRAME:
 863         strcpy(frame_s, "FRAME   = 'Bias'");
 864         break;
 865     case FLAT_FRAME:
 866         strcpy(frame_s, "FRAME   = 'Flat Field'");
 867         break;
 868     case DARK_FRAME:
 869         strcpy(frame_s, "FRAME   = 'Dark'");
 870         break;
 871   }
 872
 873  fits_add_card (hdulist, frame_s);
 874  fits_add_card (hdulist, temp_s);
 875  fits_add_card (hdulist, expose_s);
 876  //fits_add_card (hdulist, pixel_s);
 877
 878  // JM: If there is a way to get the specific model of the camera, use that.
 879  fits_add_card (hdulist, "INSTRUME= 'SBIG CCD'");
 880  fits_add_card (hdulist, obsDate);
 881
 882  return (hdulist);
 883 }
 884