ngcdcsEXP.hpp

Go to the documentation of this file.

#ifndef ngcdcsEXP_H
#define ngcdcsEXP_H
 
 
#ifndef __cplusplus
#error This is a C++ include file and cannot be used from plain C
#endif
 
#include <stdlib.h>
#include <stdio.h>
#include <stdarg.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>
 
#include <ngc/core/ngcbSocket.h>
#include <ngc/core/ngcbTHREAD.hpp>
#include <ngc/core/ngcbFITS.hpp>
 
/*
 * Exposure states
 */
#define ngcdcsEXP_NONE                0  //< not configured
#define ngcdcsEXP_INACTIVE            1  //< exposure is inactive
#define ngcdcsEXP_PENDING             2  //< exposure is pending
#define ngcdcsEXP_INTEGRATING         4  //< integrating
#define ngcdcsEXP_PAUSED              8  //< exposure is paused
#define ngcdcsEXP_READING            16  //< reading out
#define ngcdcsEXP_PROCESSING         32  //< processing
#define ngcdcsEXP_TRANSFERRING       64  //< transferring
#define ngcdcsEXP_COMPL_SUCCESS     128  //< successful completion 
#define ngcdcsEXP_COMPL_FAILURE     256  //< failure
#define ngcdcsEXP_COMPL_ABORTED     512  //< exposure has been aborted
#define ngcdcsEXP_COMPL_STOPPED    1024  //< exposure has been stopped/ended

#define ngcdcsEXP_STARTING (ngcdcsEXP_INTEGRATING | ngcdcsEXP_INACTIVE)

#define ngcdcsEXP_WIPING (ngcdcsEXP_READING | ngcdcsEXP_INACTIVE)

#define ngcdcsEXP_ACTIVE(status) ((status > ngcdcsEXP_INACTIVE) && \
                                  (status < ngcdcsEXP_COMPL_SUCCESS))
 
/*
 * Exposure types
 */
#define ngcdcsEXP_SUSTAINED  1  //< sustained read-out
#define ngcdcsEXP_SINGLE     2  //< single exposure
 
/*
 * Exposure data file format
 */
#define ngcdcsEXP_FORMAT_SINGLE       1  //< single FITS files
#define ngcdcsEXP_FORMAT_CUBE         2  //< data cube
#define ngcdcsEXP_FORMAT_EXTENSION    3  //< image extension
#define ngcdcsEXP_FORMAT_SINGLE_EXT   4  //< image extension (as single files)
#define ngcdcsEXP_FORMAT_CUBE_EXT     5  //< data cube (as extension)
#define ngcdcsEXP_FORMAT_GENERIC_1    6  //< generic-1
#define ngcdcsEXP_FORMAT_GENERIC_2    7  //< generic-2
 
/*
 * Exposure naming schemes
 */
#define ngcdcsEXP_NAMING_REQUEST      1  //< request name
#define ngcdcsEXP_NAMING_SEQUENCE     2  //< name + sequence index
#define ngcdcsEXP_NAMING_AUTO         3  //< name + automatic index
#define ngcdcsEXP_NAMING_REC_ID       4  //< use recording id
#define ngcdcsEXP_NAMING_AUTO_ID      5  //< name + automatic id

#define ngcdcsEXP_MAX_CLIENTS 8
 
/*
 * Event tags
 */
#define ngcdcsEXP_EVT_IMG    0x01   //< image event 
#define ngcdcsEXP_EVT_2AG    0x02   //< secondary autoguiding event
#define ngcdcsEXP_EVT_ERR    0x04   //< eror event
#define ngcdcsEXP_EVT_LOCK   0x08   //< lock EVH
#define ngcdcsEXP_EVT_UNLOCK 0x10   //< unlock EVH

struct ngcdcs_2ag_t {
  float offsetX; //< Offset in x-direction
  float offsetY; //< Offset in y-direction
  float quality; //< Quality good (1.0), bad (-1.0) or unknown (0.0)
  double ts;     //< Timestamp
};

struct ngcdcs_expevt_t {
  int tag;             //< Event tag
  int instance;        //< Instance
  int merge;           //< Merge flag
  unsigned int status; //< Status
  int errorId;         //< Error id
  int ioError;         //< An i/o-error occured
  char msg[1024];      //< Message
  ngcdcs_2ag_t ag;     //< 2AG event

  ngcdcs_expevt_t() {
    tag = ngcdcsEXP_EVT_IMG;
    instance = 0;
    merge = 0;
    status = ngcdcsEXP_NONE;
    errorId = 0;
    ioError = 0;
    msg[0] = '\0';
    ag.offsetX = 0.0;
    ag.offsetY = 0.0;
    ag.quality = 0.0;
    ag.ts = 0.0;
  }
};

struct ngcdcs_exp_topic {
  char id[64];        //< Exposure id
  char host[64];      //< Host name
  char fileName[256]; //< File name
  char status[32];    //< Status
  int method;         //< Requested publishing method
  
  ngcdcs_exp_topic &operator=(const ngcdcs_exp_topic &other) {
    strcpy(id, other.id);
    strcpy(host, other.host);
    strcpy(fileName, other.fileName);
    strcpy(status, other.status);
    method = other.method;
    return (*this);
  }

  ngcdcs_exp_topic(const ngcdcs_exp_topic &other) {
    strcpy(id, other.id);
    strcpy(host, other.host);
    strcpy(fileName, other.fileName);
    strcpy(status, other.status);
    method = other.method;
  }

  ngcdcs_exp_topic() {
    id[0] = '\0'; host[0] = '\0'; fileName[0] = '\0'; status[0] = '\0';
    method = 0;
  }
};

class ngcdcsEXP
{
public:
  int extFits;  

  int numExtBlocks;  

  int sequenceNumber; 

  int oneFile; 

  int instLock; 

  int split; 

  char fileName[512]; 

  FILE *fd;

  FILE *fdList;

  int nopen; 

  int merge;

  ngcbFITS fits;

  ngcbFITS appHdr;

  unsigned int status;

  unsigned int statusSaved;

  int format;

  int naming;

  int time;

  char baseName[256]; 

  char lastName[256 + 16]; 

  char id[64];

  char uuid[48];

  int rev;

  double integrationTime; 

  int fileCheck;           

  int useLock;

  int expType;

  int secure;

  int tmpFile;

  int checkFrames;                   

  int numFitsExt;                   

  int numFiles;                   

  struct timeval startTime;

  unsigned int drvStatus;

  char drvStatusName[32];

  char drvMsg[256];

  char origin[80];

  ngcdcsEXP &operator=(const ngcdcsEXP &other) {
    if (this != &other)
      {
      /*
       * Initialize exposure class
       */
      Init_();
      
      /*
       * Exposure handling cannot be copied...
       */
      }
    return (*this);
  }

  ngcdcsEXP(const ngcdcsEXP &other) {
    /*
     * Initialize exposure class
     */
    Init_();
 
    /*
     * Exposure handling cannot be copied...
     */
  }

  ngcdcsEXP() {
    /*
     * Initialize exposure class
     */
    Init_();
  }
  
  virtual ~ngcdcsEXP() {
    
    /*
     * Close the communication pipe
     */
    Lock();
    if (pipe_[0] >= 0)
      {
      if (fdIn_ == pipe_[0]) fdIn_ = -1;
      close(pipe_[0]); pipe_[0] = -1;
      }
    if (pipe_[1] >= 0)
      {
      if (fdOut_ == pipe_[1]) fdOut_ = -1;
      shutdown(pipe_[1], SHUT_WR);
      close(pipe_[1]); pipe_[1] = -1;
      }
    Unlock();
 
    /*
     * Delete protection semaphore
     */
    if (semExpEvt_ != NULL) delete semExpEvt_;
    if (semExpLock_ != NULL)  delete semExpLock_;
    if (semExpSync_ != NULL)  delete semExpSync_;
  }

  void SetFdIn(int f) {fdIn_ = f;}

  void SetFdOut(int f) {fdOut_ = f;}

  void ResetFd() {fdIn_ = pipe_[0]; fdOut_ = pipe_[1];}

  int StatusFdIn() {return (fdIn_);}
  
  int StatusFdOut() {return (fdOut_);}

  int Active() {return ngcdcsEXP_ACTIVE(status);}

  void Lock() {if (semExpEvt_ != NULL) semExpEvt_->Lock();}

  void Unlock() {if (semExpEvt_ != NULL) semExpEvt_->Unlock();}

  void ResetInstLock() {
    if (semExpSync_ != NULL) semExpSync_->Set(0);
  }

  void InitInstLock(int n) {
    numInst_ = n;
    if (semExpSync_ != NULL)
      {
      if (instLock) semExpSync_->Set(1);
      else semExpSync_->Set(0);
      }
  }

  void Lock(int inst) {
    if (semExpSync_ != NULL) semExpSync_->WaitCnt(inst + 1);
  }

  void Unlock(int inst) {
    if ((semExpSync_ != NULL) && (numInst_ != 0))
      {
      if (semExpSync_->Cnt() != 0)
    {
    semExpSync_->Set(((inst + 1) % numInst_) + 1);
    }
      }
  }

  void Release() {
    if (semExpSync_ != NULL) ResetInstLock();
    if (semExpEvt_ != NULL)
      {
      semExpEvt_->TryLock();
      semExpEvt_->Unlock();
      }
    if (semExpLock_ != NULL) semExpLock_->Set(ngcdcsEXP_MAX_CLIENTS * 2);
  }

  void Attach(int inst) {
    instanceList_ |= (1 << inst);
    abortList_ &= ~(1 << inst);
  }

  void Detach() {
    instanceList_ = 0;
    abortList_ = 0;
    lastTransferList_ = 0;
  }

  void Detach(int inst) {
    instanceList_ &= ~(1 << inst);
    abortList_ &= ~(1 << inst);
    lastTransferList_ &= ~(1 << inst);
  }

  int LastTransfer(int inst) {return ((lastTransferList_ & (1 << inst)) != 0);}

  int LastTransfer() {return ((lastTransferList_ == instanceList_));}

  int Attached() {return ((instanceList_ != 0));}

  int Aborted() {return ((abortList_ != 0));}

  int IssueEvt(ngcdcs_expevt_t evt) {
    Lock();
    if (StatusFdOut() >= 0)
      {
      char p[(7 * sizeof(int)) + sizeof(ngcdcs_2ag_t)]; // message buffer
      int *buf; 
 
      /*
       * Copy
       */
      buf = (int *)p;
      buf[0] = evt.tag;
      buf[1] = evt.instance;
      buf[2] = evt.merge;
      buf[3] = *(int *)&evt.status;
      buf[4] = evt.errorId;
      buf[5] = evt.ioError;
      buf[6] = (int)strlen(evt.msg);
      memcpy(buf + 7, &evt.ag, sizeof(ngcdcs_2ag_t));
 
      /*
       * Send event structure
       */
      if (write(StatusFdOut(), p, sizeof(p)) != sizeof(p))
    {
    sprintf(ErrMsg(), "internal pipe error - %s", strerror(errno));
    CkFdOut_();
    Unlock();
    return (ngcbFAILURE);
    }
      else if (buf[6] > 0)
    {
    /*
     * Send message buffer
     */
    if (write(StatusFdOut(), evt.msg, buf[6]) != buf[6])
      {
      sprintf(ErrMsg(), "internal pipe error - %s", strerror(errno));
      CkFdOut_();
      Unlock();
      return (ngcbFAILURE);
      }
    }
      }    
    Unlock();
 
    return (ngcbSUCCESS);
  }
  
  int RecvEvt(ngcdcs_expevt_t *evt) {
    if (StatusFdIn() >= 0)
      {
      char p[(7 * sizeof(int)) + sizeof(ngcdcs_2ag_t)]; // message buffer
      int *buf; 
 
      /*
       * Receive event structure
       */
      if (read(StatusFdIn(), p, sizeof(p)) != sizeof(p))
    {
    sprintf(ErrMsg(), "internal pipe error - %s", strerror(errno));
    strcpy(evt->msg, ErrMsg());
    evt->ioError = 0;
    evt->status = ngcdcsEXP_NONE;
    return (ngcbFAILURE);
    }
 
      /*
       * Copy
       */
      buf = (int *)p;
      evt->tag = buf[0];
      evt->instance = buf[1];
      evt->merge = buf[2];
      evt->status = *(unsigned int *)&buf[3];
      evt->errorId = buf[4];
      evt->ioError = buf[5];
      memcpy(&evt->ag, buf + 7, sizeof(ngcdcs_2ag_t));
 
      if ((evt->tag == ngcdcsEXP_EVT_IMG) && (evt->status != ngcdcsEXP_NONE))
    {
    /*
     * Update internal lists (instance management)
     */
    if (!ngcdcsEXP_ACTIVE(evt->status))
      {
      /*
       * Mark instance as inactive
       */
      instanceList_ &= ~(1 << evt->instance);
      
      /*
       * We remove it also from the last-transfer-list
       */
      lastTransferList_ &= ~(1 << evt->instance); 
      }
    else if (evt->status == ngcdcsEXP_TRANSFERRING)
      {
      /*
       * Add instance to the last-transfer-list
       */
      lastTransferList_ |= (1 << evt->instance);
      }
 
    if (evt->status == ngcdcsEXP_COMPL_ABORTED)
      {
      /*
       * Mark instance as aborted
       */
      abortList_ |= (1 << evt->instance);
      }
    }
 
      if (buf[6] > 0)
    {
    /*
     * Receive message buffer
     */
    if (read(StatusFdIn(), evt->msg, buf[6]) != buf[6]) 
      {
      sprintf(ErrMsg(), "internal pipe error - %s", strerror(errno));
      strcpy(evt->msg, ErrMsg());
      evt->ioError = 0;
      evt->status = ngcdcsEXP_NONE;
      return (ngcbFAILURE);
      }
 
    /* 
     * Terminate the message string
     */
    evt->msg[buf[6]] = '\0';
    }
      else
    {
    /* 
     * Terminate the message string
     */
    evt->msg[0] = '\0'; 
    }
      }
    
    return (ngcbSUCCESS);
  }

  int WaitApplLocked() {
    /*
     * Wait until application is locked
     */
    semExpLock_->Wait();
 
    /*
     * Check if lock has been cancelled
     */
    if (lockCancelled_)
      {
      skipLock_++;
      return (0);
      }
 
    return (1);
  }

  void ApplLocked() {semExpLock_->Post();}

  void ApplRelease() {
    if (useLock)
      {
      /*
       * Signal that lock has been cancelled
       */
      Lock();
      lockCancelled_ = 1;
      Unlock();
      semExpLock_->Post();
      }
  }

  void ApplClear() {
    if (useLock && lockCancelled_)
      {
      Lock();
      lockCancelled_ = 0;
      Unlock();
      while (semExpLock_->TryWait() == 0);
      }
  }
      
  int ApplCancelled() {
    int flag;
    Lock();
    flag = lockCancelled_;
    Unlock();
    return (flag);
  }

  int ApplSkip() {
    if (skipLock_ > 0)
      {
      skipLock_--;
      return (1);
      }
    else
      {
      return (0);
      }
  }
      
  char *ErrMsg() {return (erms_);}

  int Format(const char *name) {
    if ((strcmp(name, "single") == 0) || 
    (strcmp(name, "fits-single") == 0))
      {
      format = ngcdcsEXP_FORMAT_SINGLE;
      }
    else if ((strcmp(name, "cube") == 0) || 
         (strcmp(name, "fits-cube") == 0))
      {
      format = ngcdcsEXP_FORMAT_CUBE;
      }
    else if ((strcmp(name, "extension") == 0) || 
         (strcmp(name, "fits-mef") == 0))
      {
      format = ngcdcsEXP_FORMAT_EXTENSION;
      }
    else if ((strcmp(name, "single-ext") == 0) || 
         (strcmp(name, "fits-sef") == 0))
      {
      format = ngcdcsEXP_FORMAT_SINGLE_EXT;
      }
    else if ((strcmp(name, "cube-ext") == 0) || 
         (strcmp(name, "fits-cef") == 0))
      {
      format = ngcdcsEXP_FORMAT_CUBE_EXT;
      }
    else if (strcmp(name, "generic-1") == 0)
      {
      format = ngcdcsEXP_FORMAT_GENERIC_1;
      }
    else if (strcmp(name, "generic-2") == 0)
      {
      format = ngcdcsEXP_FORMAT_GENERIC_2;
      }
    else
      {
      strcpy(ErrMsg(), "unsupported data file format");
      return (ngcbFAILURE);
      }
    return (ngcbSUCCESS);
  }

  int Format(int newFormat) {
    if ((newFormat != ngcdcsEXP_FORMAT_SINGLE) &&
    (newFormat != ngcdcsEXP_FORMAT_CUBE) &&
    (newFormat != ngcdcsEXP_FORMAT_SINGLE_EXT) &&
    (newFormat != ngcdcsEXP_FORMAT_CUBE_EXT) &&
    (newFormat != ngcdcsEXP_FORMAT_EXTENSION) &&
    (newFormat != ngcdcsEXP_FORMAT_GENERIC_1) &&
    (newFormat != ngcdcsEXP_FORMAT_GENERIC_2))
      {
      sprintf(ErrMsg(), "unsupported data file format (%d)", newFormat);
      return (ngcbFAILURE);
      }
    else
      {
      format = newFormat;
      return (ngcbSUCCESS);
      }
  }

  int Format() {return (format);}

  const char *FormatName() {
    switch (format)
      {
      case ngcdcsEXP_FORMAT_SINGLE:
        {
    strcpy(formatName_, "single");
    break;
    }
      case ngcdcsEXP_FORMAT_CUBE:
        {
    strcpy(formatName_, "cube");
    break;
    }
      case ngcdcsEXP_FORMAT_EXTENSION:
        {
    strcpy(formatName_, "extension");
    break;
    }
      case ngcdcsEXP_FORMAT_SINGLE_EXT:
        {
    strcpy(formatName_, "single-ext");
    break;
    }
      case ngcdcsEXP_FORMAT_CUBE_EXT:
        {
    strcpy(formatName_, "cube-ext");
    break;
    }
      case ngcdcsEXP_FORMAT_GENERIC_1:
        {
    strcpy(formatName_, "generic-1");
    break;
    }
      case ngcdcsEXP_FORMAT_GENERIC_2:
        {
    strcpy(formatName_, "generic-2");
    break;
    }
      default:
        {
    strcpy(formatName_, "unknown");
    break;
    }
      }
 
    return (formatName_);
  }

  const char *FormatNameELT() {
    switch (format)
      {
      case ngcdcsEXP_FORMAT_SINGLE:
        {
    strcpy(formatName_, "FITS-Single");
    break;
    }
      case ngcdcsEXP_FORMAT_CUBE:
        {
    strcpy(formatName_, "FITS-Cube");
    break;
    }
      case ngcdcsEXP_FORMAT_EXTENSION:
        {
    strcpy(formatName_, "FITS-MEF");
    break;
    }
      case ngcdcsEXP_FORMAT_SINGLE_EXT:
        {
    strcpy(formatName_, "FITS-SEF");
    break;
    }
      case ngcdcsEXP_FORMAT_CUBE_EXT:
        {
    strcpy(formatName_, "FITS-CEF");
    break;
    }
      case ngcdcsEXP_FORMAT_GENERIC_1:
        {
    strcpy(formatName_, "generic-1");
    break;
    }
      case ngcdcsEXP_FORMAT_GENERIC_2:
        {
    strcpy(formatName_, "generic-2");
    break;
    }
      default:
        {
    strcpy(formatName_, "unknown");
    break;
    }
      }
 
    return (formatName_);
  }

  int Naming(int newNaming) {
    if ((newNaming != ngcdcsEXP_NAMING_REQUEST) &&
    (newNaming != ngcdcsEXP_NAMING_SEQUENCE) &&
    (newNaming != ngcdcsEXP_NAMING_REC_ID) &&
    (newNaming != ngcdcsEXP_NAMING_AUTO_ID) &&
    (newNaming != ngcdcsEXP_NAMING_AUTO))
      {
      sprintf(ErrMsg(), "unsupported naming scheme %d", newNaming);
      return (ngcbFAILURE);
      }
    else
      {
      naming = newNaming;
      return (ngcbSUCCESS);
      }
  }

  int Naming() {return (naming);}

  int DataPath(const char *path) {
    if (strlen(path) > 0)
      {
      if (strlen(path) >= (256 - 64))
    {
    sprintf(ErrMsg(), "path name is too long");
    return (ngcbFAILURE);
    }
 
      if (fileCheck)
    {
    /*
     * Check permissions
     */
    if (!ngcbIsDir(path))
      {
      sprintf(ErrMsg(), "%s is no directory", path);
      return (ngcbFAILURE);
      }
    else if (!ngcbWritePerm(path))
      {
      sprintf(ErrMsg(), "no write permission on %s", path);
      return (ngcbFAILURE);
      }
    }
 
      strcpy(dataPath_, path);
      }
    else
      {
      dataPath_[0] = '\0';
      }
 
    if ((baseName[0] != '/') && (baseName[0] != '.'))
      {
      if (strlen(dataPath_) > 0) sprintf(path_, "%s/%s", dataPath_, baseName);
      else strcpy(path_, baseName);
      }
    else
      {
      strcpy(path_, baseName);
      }
    
    return (ngcbSUCCESS);
  }

  char *DataPath() {return (dataPath_);}

  int BaseName(const char *name) {
    char tmpPath[512];
 
    if (strlen(name) == 0)
      {
      baseName[0] = '\0'; path_[0] = '\0';
      return (ngcbSUCCESS);
      }
    else if (strlen(name) > (256 - 64))
      {
      sprintf(ErrMsg(), "exposure base name is too long");
      return (ngcbFAILURE);
      }
    else if ((name[0] != '/') && (name[0] != '.'))
      {
      if (strlen(dataPath_) > 0) sprintf(tmpPath, "%s/%s", dataPath_, name);
      else strcpy(tmpPath, name);
      }
    else
      {
      strcpy(tmpPath, name);
      }
 
    if (fileCheck)
      {
      char tmp[224];
 
      /*
       * Check permissions
       */
      ngcbParentDir(tmp, tmpPath);
      if (!ngcbIsDir(tmp))
    {
    sprintf(ErrMsg(), "%s is no directory", tmp);
    return (ngcbFAILURE);
    }
      else if (!ngcbWritePerm(tmp))
    {
    sprintf(ErrMsg(), "no write permission on %s", tmp);
    return (ngcbFAILURE);
    }
      }
 
    strcpy(baseName, name);
    strcpy(path_, tmpPath);
 
    return (ngcbSUCCESS);
  }

  const char *BaseName() {return (baseName);}

  void AssignUUID(const char *value) {
    str2str(uuid, value, sizeof(uuid) - 1);
  }

  const char *Path() {
    if (naming == ngcdcsEXP_NAMING_REC_ID)
      {
      if (strlen(id) == 0) path_[0] = '\0';
      else if (strlen(dataPath_) > 0) sprintf(path_, "%s/%s", dataPath_, id);
      else strcpy(path_, id);
      }
    else
      {
      if (strlen(baseName) == 0)
    {
    path_[0] = '\0';
    }
      else if ((baseName[0] != '/') && (baseName[0] != '.'))
    {
    if (strlen(dataPath_) > 0) sprintf(path_, "%s/%s", dataPath_, baseName);
    else strcpy(path_, baseName);
    }
      else
    {
    strcpy(path_, baseName);
    }
      if ((naming == ngcdcsEXP_NAMING_AUTO_ID) && (strlen(uuid) > 0))
    {
    strcat(path_, "_");
    strcat(path_, uuid);
    }
      }
    return (path_);
  }

  const char *TmpPath() {
    if (strlen(dataPath_) > 0) sprintf(path_, "%s/_ngctmp", dataPath_);
    else strcpy(path_, "_ngctmp");
    return (path_);
  }

  int NextIndex() {
    if (naming == ngcdcsEXP_NAMING_SEQUENCE)
      {
      /*
       * Increment sequence number
       */
      sequenceNumber++;
      return (ngcbSUCCESS);
      }
    else if (naming == ngcdcsEXP_NAMING_AUTO)
      {
      int idx;
      const char *p = Path();
 
      if (p == NULL)
    {
    /*
     * We have no path where to look for the index
     */
    strcpy(ErrMsg(), "no valid path");
    return (ngcbFAILURE);
    }
      
      /*
       * Find next matching index
       */
      idx = ngcbFindIndex(p, sequenceNumber, ErrMsg());
      if (idx < 0) return (ngcbFAILURE);
      else if (idx == 0) sequenceNumber = 1;
      else sequenceNumber = idx;
 
      return (ngcbSUCCESS);
      }
 
    return (ngcbSUCCESS);
  }

  void StatStr(char *s) {Stat2Str(s, status);}

  void Stat2Str(char *s, unsigned int stat) {
    switch (stat) 
      {
      case ngcdcsEXP_NONE: s[0] = '\0'; break;
      case ngcdcsEXP_INACTIVE: strcpy(s, "inactive"); break;
      case ngcdcsEXP_PENDING: strcpy(s, "pending"); break;
      case ngcdcsEXP_STARTING: strcpy(s, "starting"); break;
      case ngcdcsEXP_WIPING: strcpy(s, "wiping"); break;
      case ngcdcsEXP_INTEGRATING: strcpy(s, "integrating"); break;
      case ngcdcsEXP_PAUSED: strcpy(s, "paused"); break;
      case ngcdcsEXP_READING: strcpy(s, "reading"); break;
      case ngcdcsEXP_PROCESSING: strcpy(s, "processing"); break;
      case ngcdcsEXP_TRANSFERRING: strcpy(s, "transferring"); break;
      case ngcdcsEXP_COMPL_ABORTED: strcpy(s, "aborted"); break;
      case ngcdcsEXP_COMPL_FAILURE: strcpy(s, "failure"); break;
      case ngcdcsEXP_COMPL_SUCCESS: strcpy(s, "success"); break;
      case ngcdcsEXP_COMPL_STOPPED: strcpy(s, "success"); break;
      default: strcpy(s, "unknown"); break;
      }
  }

  void ExpStartTime(struct timeval &timeVal) {
    int hour, min;
    double sec;
    Lock();
    expStartTimeMJD_ = ngcbTime2MJD(timeVal);
    ngcbTime2UTC(timeVal, expStartTime_, 4);
    startTime.tv_sec = timeVal.tv_sec;
    startTime.tv_usec = timeVal.tv_usec;
    if (sscanf(expStartTime_, "%*[^T]%*[T]%2d:%2d:%80lf\n", &hour, &min, &sec) == 3)
      {
      expStartTimeUTC_ = (static_cast<double>(hour) * 3600.0) + (static_cast<double>(min) * 60.0) + sec;
      }
    Unlock();
  }

  const char *ExpStartTime() {return (expStartTime_);}
  
  double ExpStartTimeMJD() {return (expStartTimeMJD_);}

  double ExpStartTimeUTC() {return (expStartTimeUTC_);}

  void TimeStamp() {
    struct timeval timeVal;
    ngcbGetTime(&timeVal);
    Lock();
    expStartTimeMJD_ = ngcbTime2MJD(timeVal);
    ngcbTime2UTC(timeVal, expStartTime_, 4);
    Unlock();
  }

  void DrvStatus(unsigned int stat) {
    drvStatus = stat;
    Stat2Str(drvStatusName, drvStatus);
  }

  void EndFlag(int flag) {
    Lock();
    endFlag_ = flag;
    Unlock();
  }

  int EndFlag() {
    int flag;
    Lock();
    flag = endFlag_;
    Unlock();
    return (flag);
  }
 
protected:
 
private:
  char erms_[256]; 

  char path_[512];

  char dataPath_[256];

  char formatName_[64];

  int pipe_[2];

  ngcdcs_expevt_t expEvt_;

  int numInst_;

  ngcbSEM *semExpSync_;

  ngcbSEM *semExpEvt_;

  ngcbSEM *semExpLock_;

  char expStartTime_[64];

  double expStartTimeMJD_;   

  double expStartTimeUTC_;   

  int endFlag_;

  int instanceList_;

  int abortList_;  

  int lastTransferList_;     

  int fdIn_;

  int fdOut_;                

  int lockCancelled_;

  int skipLock_;

  void Init_() {
    char *evar;
 
    /*
     * Initialize with zero to avoid UMR
     */
    memset(baseName, 0, sizeof(baseName));
    memset(lastName, 0, sizeof(lastName));
    memset(dataPath_, 0, sizeof(dataPath_));
    memset(formatName_, 0, sizeof(formatName_));
 
    /*
     * Construct basic data path
     */
    evar = getenv("INS_ROOT");
    if (evar != NULL)
      {
      sprintf(dataPath_, "%s/", evar);
      evar = getenv("INS_USER");
      if (evar != NULL) strcat(dataPath_, evar);
      else strcat(dataPath_, "SYSTEM");
      strcat(dataPath_, "/DETDATA");
      }
    else
      {
      evar = getenv("DATAROOT");
      if (evar != NULL)
    {
    sprintf(dataPath_, "%s/data", evar);
    }
      else
    {
    dataPath_[0] = '\0';
    }
      }
 
    /*
     * Default exposure type
     */
    expType = ngcdcsEXP_SUSTAINED;
 
    /*
     * Default format and naming scheme
     */
    format = ngcdcsEXP_FORMAT_SINGLE;
    naming = ngcdcsEXP_NAMING_REQUEST;
    strcpy(baseName, "ngc");
    sprintf(path_, "%s/%s", dataPath_, baseName);
    extFits = 0;
    numExtBlocks = 2;
    sequenceNumber = 0;
    oneFile = 1;
    instLock = 0;
    split = 0;
    fileName[0] = '\0';
    fileCheck = 1;
    secure = 1;
    tmpFile = 0;
    checkFrames = 1;
    numFitsExt = 0;
    numFiles = 0;
 
    /*
     * Exposure parameters
     */
    status = ngcdcsEXP_INACTIVE;
    statusSaved = ngcdcsEXP_NONE;
    expStartTimeMJD_ = 0.0;
    expStartTimeUTC_ = 0.0;
    expStartTime_[0] = '\0';
    time = 0;
    integrationTime = 0.0;
    id[0] = '\0';
    uuid[0] = '\0';
    rev = 1;
    merge = 0;
    startTime.tv_sec = 0;
    startTime.tv_usec = 0;
    strcpy(origin, "ESO-PARANAL");
    endFlag_ = 0;
 
    /*
     * For file sharing between multiple instances
     */
    nopen = 0;
    fd = NULL;
    fdList = NULL;
 
    /*
     * Socket pair for internal event-communication
     */
    if (ngcbSocketPair(pipe_, 16384, NULL) != 0)
      {
      pipe_[0] = -1; pipe_[1] = -1;
      }
    fdIn_ = pipe_[0]; fdOut_ = pipe_[1];
 
    /*
     * Protection semaphore for multiple instances
     */
    semExpEvt_ = new ngcbSEMC(1);
    semExpSync_ = new ngcbSEMC(0);
    numInst_ = 1;
    
    /*
     * Signal semaphore for EVH lock
     */
    useLock = 0;
    semExpLock_ = new ngcbSEMC(0);
    lockCancelled_ = 0;
    skipLock_ = 0;
 
    /*
     * Instance management
     */
    instanceList_ = 0;
    lastTransferList_ = 0;
    abortList_ = 0;
 
    /*
     * Clear error message
     */
    erms_[0] = '\0';
 
    /*
     * Exposure driver
     */
    memset(drvStatusName, 0, sizeof(drvStatusName));
    memset(drvMsg, 0, sizeof(drvMsg));
    DrvStatus(ngcdcsEXP_NONE);
  }

  void CkFdOut_() {
    if ((fdOut_ >= 0) && (fdOut_ == pipe_[1]))
      {
      close(pipe_[1]); pipe_[1] = -1; fdOut_ = -1;
      }
  }
};
 
#endif