ngcdcsDTT_COM.hpp

Go to the documentation of this file.

#ifndef ngcdcsDTT_COM_H
#define ngcdcsDTT_COM_H
 
 
#ifndef __cplusplus
#error This is a C++ include file and cannot be used from plain C
#endif
 
#include <ngc/core/ngcb.h>
#include <ngc/core/ngcbSIO.hpp>
#include <ngc/core/ngcdcsEXP.hpp>
 
 
/*
 * Simple private tagged DTT protocol
 */
#define ngcdcsDTT_NOP       0
#define ngcdcsDTT_CONFIG    1
#define ngcdcsDTT_BASENAME  2
#define ngcdcsDTT_SETUP     3
#define ngcdcsDTT_START     4
#define ngcdcsDTT_EXPSTART  5
#define ngcdcsDTT_EXPSTOP   6
#define ngcdcsDTT_STOP      7
#define ngcdcsDTT_CLOSE     8
 

struct ngcdcs_dtt_exp_t {
  int extFits;

  int sequenceNumber; 

  int format; 

  int naming;

  char expId[64];

  int setupId;

  int numFitsBlock;

  double integrationTime;  

  ngcdcs_dtt_exp_t() {
    extFits = 1;
    sequenceNumber = 0;
    format = ngcdcsEXP_FORMAT_SINGLE;
    naming = ngcdcsEXP_NAMING_REQUEST;
    expId[0] = '\0';
    setupId = 0;
    integrationTime = 0.0;
    numFitsBlock = 16;
  }
 
};

struct ngcdcs_dtt_frame_t {
  int type; 

  int store;             

  int gen;

  int breakCond; 

  int sx;

  int sy; 

  int nx;

  int ny; 

  char name[64];                             

  ngcdcs_dtt_frame_t() {
    type = 0;
    name[0] = '\0';
    store = 0;
    gen = 0;
    breakCond = 0;       // no break condition (take all until exp.-end)
    sx = 1;              // take frame as it is
    sy = 1;              // take frame as it is
    nx = 0;              // take frame as it is
    ny = 0;              // take frame as it is
  }
};

class ngcdcsDTT_COM: public ngcbSIO
{
public:
  int xterm;

  char acqHost[64];

  int acqPort;

  int enabled;

  ngcdcsDTT_COM() {
    pid_ = 0;
    host_[0] = '\0';
    fdCmd_ = -1;
    fdEvt_ = -1;
    xterm = 0;
    acqHost[0] = '\0';
    acqPort = 0;
    enabled = 0;
    endian_ = ngcbEndian();
  }                             

  virtual ~ngcdcsDTT_COM() {
    Shutdown();
  }

  int Launch(const char *host) {
    char cmd[256];
    char reply[256];
    char tmp[256];
    int cmdPort, evtPort;
 
    if (pid_ > 0)
      {
      return (ngcbSUCCESS); // already running
      }
    else if (strlen(acqHost) < 1)
      {
      strcpy(ErrMsg(), "invalid acquisition process host");
      return (ngcbFAILURE);
      }
    else if (acqPort <= 0)
      {
      strcpy(ErrMsg(), "invalid acquisition process data port");
      return (ngcbFAILURE);
      }
 
    sprintf(cmd, "ngcdcsDtt -host %s -port %d", acqHost, acqPort);
    if (xterm && (verboseLevel > 0))
      {
      sprintf(tmp, " -verbose %d", verboseLevel);
      strcat(cmd, tmp);
      }
    if (logLevel > 0)
      {
      sprintf(tmp, " -log %d", logLevel);
      strcat(cmd, tmp);
      }
 
    /*
     * Execute DTT
     */
    if (xterm) pid_ = ExecXt(host, cmd, reply);
    else pid_ = Exec(host, cmd, reply);
    if (pid_ <= 0)
      {
      pid_ = 0;
      return (ngcbFAILURE);
      }
 
    sscanf(reply, "%10d %10d", &cmdPort, &evtPort);
    sprintf(tmp, "%s,%d", host, cmdPort);
    fdCmd_ = TcpConnect(tmp);
    if (fdCmd_ < 0)
      {
      strcpy(tmp, ErrMsg());
      Kill(host, pid_); pid_ = 0;
      strcpy(ErrMsg(), tmp);
      return (ngcbFAILURE);
      }
    sprintf(tmp, "%s,%d", host, evtPort);
    fdEvt_ = TcpConnect(tmp);
    if (fdCmd_ < 0)
      {
      strcpy(tmp, ErrMsg());
      TcpClose(fdCmd_); fdCmd_ = -1; Kill(host, pid_); pid_ = 0;
      strcpy(ErrMsg(), tmp);
      return (ngcbFAILURE);
      }
    
    strcpy(host_, host);
    return (ngcbSUCCESS);
  }

  int Shutdown() {
    int res = ngcbSUCCESS;
    if (fdEvt_ >= 0)
      {
      TcpClose(fdEvt_); fdEvt_ = -1;
      }
    if (fdCmd_ >= 0)
      {
      res = SendCmd_(ngcdcsDTT_CLOSE);
      TcpClose(fdCmd_); fdCmd_ = -1;
      if (res == ngcbSUCCESS) pid_ = 0;
      }
    if (pid_ > 0)
      {
      res = Kill(host_, pid_);
      pid_ = 0;
      }
    return (res);
  }

  int Ping() {
      return (SendCmd_(ngcdcsDTT_NOP));
  }

  int BaseName(const char *name) {
    char tmp[256];
    strcpy(tmp, name);
    return (SendCmd_(ngcdcsDTT_BASENAME, tmp, sizeof(tmp)));    
  }

  int Transfer(int flag) {
    if (flag)
      {
      return (SendCmd_(ngcdcsDTT_START));
      }
    else
      {
      return (SendCmd_(ngcdcsDTT_STOP));
      }
  }

  int StartExp() {
    return (SendCmd_(ngcdcsDTT_EXPSTART));
  }
  
  int StopExp() {
    return (SendCmd_(ngcdcsDTT_EXPSTOP));
  }

  int Setup(ngcdcs_dtt_exp_t expSetup, ngcdcs_dtt_frame_t *frameSetup,
        ngcbFITS *fits) {
    int xsize;
    int intVal;
    ngcdcs_dtt_frame_t *fs;
    ngcdcs_dtt_frame_t fs1[ngcdcsMAX_FRAME_TYPES];
 
    if (SendTag_(ngcdcsDTT_SETUP) != ngcbSUCCESS)
      {
      return (ngcbFAILURE);
      }
 
    xsize = (int)sizeof(ngcdcs_dtt_exp_t);
    if (endian_ == ngcbBIG_ENDIAN)
      {
      ngcbSwap4(&expSetup, 7);
      ngcbSwap8(&expSetup.integrationTime, 1);
      }
    if (TcpWrite(fdCmd_, &expSetup, xsize) != ngcbSUCCESS)
      {
      TcpClose(fdCmd_); fdCmd_ = -1;
      return (ngcbFAILURE);
      }
 
    xsize = ngcdcsMAX_FRAME_TYPES * (int)sizeof(ngcdcs_dtt_frame_t);
    fs = frameSetup;
    if (endian_ == ngcbBIG_ENDIAN)
      {
      int i;
      memcpy(fs1, fs, xsize);
      for (i=0;i<ngcdcsMAX_FRAME_TYPES;i++)
    {
    if (endian_ == ngcbBIG_ENDIAN) ngcbSwap4(&fs1[i], 8);
    }
      fs = fs1;
      }
    if (TcpWrite(fdCmd_, fs, xsize) != ngcbSUCCESS)
      {
      TcpClose(fdCmd_); fdCmd_ = -1;
      return (ngcbFAILURE);
      }
 
    xsize = fits->HeaderSize();
    intVal = xsize;
    if (endian_ == ngcbBIG_ENDIAN) ngcbSwap4(&intVal, 1);
    if (TcpWrite(fdCmd_, &intVal, sizeof(int)) != ngcbSUCCESS)
      {
      TcpClose(fdCmd_); fdCmd_ = -1;
      return (ngcbFAILURE);
      }
    if (TcpWrite(fdCmd_, fits->Header(), xsize) != ngcbSUCCESS)
      {
      TcpClose(fdCmd_); fdCmd_ = -1;
      return (ngcbFAILURE);
      }
   
    return (RecvReply_());
  }
 
protected: 
 
private:
  char host_[64];

  int pid_;

  int fdCmd_;

  int fdEvt_;                

  int endian_;               

  int SendTag_(int cmd) {
    int tag = cmd;
 
    if (fdCmd_ < 0)
      {
      sprintf(ErrMsg(), "connection closed");
      return (ngcbFAILURE);
      }
 
    if (endian_ == ngcbBIG_ENDIAN) ngcbSwap4(&tag, 1);
 
    if (TcpWrite(fdCmd_, &tag, sizeof(int)) != ngcbSUCCESS)
      {
      TcpClose(fdCmd_); fdCmd_ = -1;
      return (ngcbFAILURE);
      }
    
    return (ngcbSUCCESS);
  }

  int RecvReply_() {
    int result;
 
    if (TcpRead(fdCmd_, &result, sizeof(int)) != ngcbSUCCESS)
      {
      TcpClose(fdCmd_); fdCmd_ = -1;
      return (ngcbFAILURE);
      }
 
    if (endian_ == ngcbBIG_ENDIAN) ngcbSwap4(&result, 1);
 
    if (result != ngcbSUCCESS)
      {
      char tmp[256];
      if (TcpRead(fdCmd_, tmp, 256) != ngcbSUCCESS)
    {
    TcpClose(fdCmd_); fdCmd_ = -1;
    return (ngcbFAILURE);
    }
      strcpy(ErrMsg(), tmp);
      return (ngcbFAILURE);
      }
 
    return (ngcbSUCCESS);
  }
  
  int SendCmd_(int cmd, const char *p, int size) {
    if (SendTag_(cmd) != ngcbSUCCESS)
      {
      return (ngcbFAILURE);
      }
 
    if ((p != NULL) && (size > 0))
      {
      if (TcpWrite(fdCmd_, p, size) != ngcbSUCCESS)
    {
    TcpClose(fdCmd_); fdCmd_ = -1;
    return (ngcbFAILURE);
    }
      }
 
    return (RecvReply_());
  }
 
  // Send command
  int SendCmd_(int cmd) {return (SendCmd_(cmd, NULL, 0));}
 
};
 
#endif