Server_NI6008.cpp

Go to the documentation of this file.

#include "Server_NI6008.h"

int main(int argc, char *argv[]){
  int port = 5555; 
  if (argc>2) {
    fprintf(stderr,"usage: %s port[=5555].\n", argv[1]);
    exit(0);}
  if (argc==2) port = atoi(argv[1]);
  Server_NI6008 server(port);
}

#ifndef NODAQ
#define DAQmxErrChk(functionCall) { if( DAQmxFailed(error=(functionCall)) ) { goto Error; } }
#endif

//-----------------------------------------------------------------------------
// Implementation file for class : Server_NI6008
//
// 2016-05-27 : 
//-----------------------------------------------------------------------------

//=============================================================================
// Standard constructor, initializes variables
//=============================================================================
Server_NI6008::Server_NI6008(int port):
  callSize   (18),
  lineLength (200),
  m_aiMin(-10.0),
  m_aiMax(10.0),
  m_aoMin(0.0),
  m_aoMax(5.0),
  m_timeout(10.0)
{
  portno = port;
  
  colors.push_back(std::string("\033[94m"));
  colors.push_back(std::string("\033[92m"));
  colors.push_back(std::string("\033[93m"));
  colors.push_back(std::string("\033[95m"));
  colors.push_back(std::string("\033[33m"));
  colors.push_back(std::string("\033[91m"));
  colors.push_back(std::string("\033[0m"));

  std::string _accountName = accountName();
  std::string _hostName    = hostName();
  std::string _osName      = osName();
  std::string _osVersion   = osVersion();

  msgSvc(INFO,"","");
  msgSvc(INFO,"                          ***********************************************","");
  msgSvc(INFO,"                          *               C      A      T               *","");
  msgSvc(INFO,"                          *                                             *","");
  msgSvc(INFO,"                          *          |\\-''-/|.___..--''\"`-._            *","");
  msgSvc(INFO,"                          *          `6_ 6  )   `-.  (     ).`-.__.`)   *","");
  msgSvc(INFO,"                          *          (_Y_.)'  ._   )  `._ `. ``-..-'    *","");
  msgSvc(INFO,"                          *         _..`--'_..-  _/ /--'_.' ,'          *","");
  msgSvc(INFO,"                          *     (il),-''  (li),' ((!.-'                 *","");
  msgSvc(INFO,"                          ***********************************************","");
  msgSvc(INFO,"","");
  msgSvc(INFO,"Application running on "+
         _accountName+"@"+
         _hostName+" ("+
         _osName+" - "+
         _osVersion+")","");
  
  msgSvc(INFO, "Connecting port "+itos(port),"Server_NI6008");

#ifdef NODAQ
  msgSvc(WARNING,"NO HARDWARE - FAKE ACQUISITION");
#endif  
  start();
}

//=============================================================================
// Destructor
//=============================================================================
Server_NI6008::~Server_NI6008(){
}

//=============================================================================
// 
//=============================================================================
void Server_NI6008::error(const char *msg)
{
    perror(msg);
    exit(1);
}

//=============================================================================
// 
//=============================================================================
void Server_NI6008::msgSvc(MsgLevel level, 
                    std::string  msg,
                    std::string  call ){
  const int OUTLEVEL = DEBUG;
  if (level<OUTLEVEL) return;
  log ( level, msg, call);  
} 

//=============================================================================
// 
//=============================================================================
std::string Server_NI6008::logtime(){
  time_t rawtime;
  struct tm * timeinfo;
  
  time ( &rawtime );
  timeinfo = localtime ( &rawtime );
  char* timechar =  asctime (timeinfo) ;
  std::string timing = std::string(timechar,24) + " ";

  return timing;
}

//=============================================================================
// 
//=============================================================================
void Server_NI6008::log (MsgLevel level,  
                  std::string  msg,
                  std::string  call){

  bool isFatal=false;   
  
  //#ifndef WIN32
  std::string output(colors[BLUE]);
  output+=std::string(call,0,callSize);
  //#else
  //  std::string output=std::string(call,0,callSize);
  //#endif



  int clen=call.length();

  if (clen>0)
  {
    if (clen>callSize) output.replace(callSize+5-3,3,"...");
    if (clen<callSize) output.insert (clen+5,callSize-clen,' ');
  }
  
  std::string color;
  
  switch(level) {       
  case VERBOSE:
    color=colors[BLUE];
    output+=color;
    output+=" VERBOSE ";
    break;
  case DEBUG:
    color=colors[BLUE];
    output+=color;
    output+=" DEBUG   ";
    break;
  case INFO:
    color=colors[GREEN];
    output+=color;
    output+=" INFO    ";
    break;
  case WARNING:
    color=colors[YELLOW];    
    output+=color;
    output+=" WARNING ";
    break;
  case ERR:
    color=colors[MAGENTA];    
    output+=color;
    output+=" ERROR   ";
    break;
  case FATAL:
    color=colors[RED];
    output+=color;
    output+=" FATAL   ";
    isFatal=true;
    break;
  default:
    color  = colors[CYAN];
    output+=color;
    output = call;
    break;
  }
  output+=colors[WHITE];
  output+=logtime();
  output+=color;
  output+=msg;
  output+=colors[WHITE];
  
  std::cout << output << std::endl;

  if (isFatal) {exit(0);}
}

//=============================================================================
// 
//=============================================================================
void Server_NI6008::start(){
  sockfd = socket(AF_INET, SOCK_STREAM, 0);
  if (sockfd < 0) 
    error("ERROR opening socket");
  bzero((char *) &serv_addr, sizeof(serv_addr));
  serv_addr.sin_family = AF_INET;
  serv_addr.sin_addr.s_addr = INADDR_ANY;
  serv_addr.sin_port = htons(portno);
  if (bind(sockfd, (struct sockaddr *) &serv_addr,
       sizeof(serv_addr)) < 0) 
    error("ERROR on binding");
  listen(sockfd,5);
  clilen = sizeof(cli_addr);
  newsockfd = accept(sockfd, 
             (struct sockaddr *) &cli_addr, 
             &clilen);
  if (newsockfd < 0) error("ERROR on accept");
     while(1) {
       bzero(buffer,256);
       cmd();
     }
  close(newsockfd);
  close(sockfd);
}

//=============================================================================
// 
//=============================================================================
int Server_NI6008::cmd(){
  n = read(newsockfd,buffer,255);
  if (n < 0) {
    error("ERROR reading from socket");
  }
 
  char   result[4096];
  int    size = 0 ;
  
  std::string newcmd = std::string(buffer);
  std::string delimiter = " ";
  size_t pos = 0;
  int cmdsize = 0;
  std::vector<std::string> cmdvec;
  while ((pos = newcmd.find(delimiter)) != std::string::npos) {
    cmdvec.push_back(newcmd.substr(0, pos));
    newcmd.erase(0, pos + delimiter.length());
    cmdsize++;
  }
  cmdvec.push_back(newcmd);
  cmdsize++;
  //  for (int i =0 ; i<cmdsize; i++) std::cout<<" command: "<<cmdvec[i]<<" "<<cmdsize<<std::endl;
  
  bool understood = false;
  std::string instr = cmdvec[1];
  std::transform(instr.begin(), instr.end(),instr.begin(), ::tolower);
  size = -1 ; 
  // Server status
  if ( instr=="status"){
    //    status();
    understood = true;
  }
  // Time out
  if ( instr=="timeout" && cmdsize==2 ){
    setTimeout(atof(cmdvec[2].c_str()));
    //    status();
    understood = true;
  }
  // AI
  if ( instr=="ai" && cmdsize==2 ){
    const char* dev = cmdvec[0].c_str();
    double data[4];
    AI(dev, data);
    size = sprintf(result,"%f %f %f %f", data[0], data[1], data[2], data[3]);
    if ( write(newsockfd, result, size)<0 ) error("ERROR writing to socket");
    understood = true; 
  }
  // AI range 
  if ( instr=="airange" && cmdsize==4 ){
    setAIRange(atof(cmdvec[2].c_str()), atof(cmdvec[3].c_str()));
    //    status();
    understood = true;
  }
  // AO
  if ( instr=="ao" && cmdsize==4){
    const char* dev = cmdvec[0].c_str();
    double data[2];
    data[0]=atof(cmdvec[2].c_str());
    data[1]=atof(cmdvec[3].c_str());
    //    std::cout<<data[0]<<" "<<data[1]<<std::endl;
    AO(dev, data);
    size = sprintf(result,"AO set.");
    if ( write(newsockfd, result, size)<0 ) error("ERROR writing to socket");
    understood = true;
  }
  // // AO0
  // if ( instr=="ao0" && cmdsize==1){
  //   double data;
  //   data=atof(cmdvec[1].c_str());
  //   AO0(data);
  //   size = sprintf(result,"AO0 set.");
  //   if ( write(newsockfd, result, size)<0 ) error("ERROR writing to socket");
  // }
  // // AO1
  // if ( instr=="ao1" && cmdsize==1){
  //   double data;
  //   data=atof(cmdvec[1].c_str());
  //   AO1(data);
  //   size = sprintf(result,"AO1 set.");
  //   if ( write(newsockfd, result, size)<0 ) error("ERROR writing to socket");
  // }
  // AO range 
  if ( instr=="aorange" && cmdsize==4 ){
    setAORange(atof(cmdvec[2].c_str()), atof(cmdvec[3].c_str()));
    //    status();
    understood = true;
  }
  // DI
  if ( instr=="di"){
    const char* dev = cmdvec[0].c_str();
    unsigned char idata[2];
    DI(dev, idata);
    unsigned int data = idata[0]+256*idata[1];
    unsigned int data2 = 
      (data>>3&1)+2*(data>>2&1)+4*(data>>1&1)+8*(data&1)+
      16*(data>>11&1)+32*(data>>10&1)+64*(data>>9&1)+128*(data>>8&1)+
      256*(data>>7&1)+512*(data>>6&1)+1024*(data>>5&1)+2048*(data>>4&1);

    size = sprintf(result,"%d %d - %d / %d -> %i%i%i%i%i%i%i%i%i%i%i%i ", idata[0], idata[1], data, data2,  
           data>>11&1, data>>10& 1, data>>9&1, data>>8&1,
           data>>7&1, data>>6&1, data>>5&1, data>>4&1,
           data>>3&1, data>>2&1, data>>1&1, data&1
           );
    std::cout<< "digit :" << result<< std::endl;
    if ( write(newsockfd, result, size)<0 ) error("ERROR writing to socket");
    understood = true;
  }
  // DI
  if ( instr=="reset"){
    Reset();
    if ( write(newsockfd, result, size)<0 ) error("ERROR writing to socket");
    understood = true; 
  }
  // Stop
  if ( instr=="stop"){
    msgSvc(WARNING, "Closing the server connection.");
    n = send("exit");
    if (n < 0) error("ERROR writing to socket");
    close(newsockfd);
    close(sockfd);
    exit(0);
  }
  if (!understood){
    size = sprintf(result,"Instruction not understood.");
    if ( write(newsockfd, result, size)<0 ) error("ERROR writing to socket");
  }
  return 0; 
}

//=============================================================================
// 
//=============================================================================
void Server_NI6008::status() {
  send(std::string("Port   : "+itos(portno)));
  send(std::string("   - Timeout = "+ftos(m_timeout)));
  send(std::string("   - AI"));
  send(std::string("       . min = "+ftos(m_aiMin)));
  send(std::string("       . max = "+ftos(m_aiMax)));
  send(std::string("   - AO"));
  send(std::string("       . min = "+ftos(m_aoMin)));  
  send(std::string("       . max = "+ftos(m_aoMax)));
}
//=============================================================================
// 
//=============================================================================
int Server_NI6008::AI(const char* dev, double data[4]){
    // Task parameters
    int32       error = 0;
    TaskHandle  taskHandle = 0;
    char        errBuff[2048]={'\0'};
    char chan[80];
    sprintf(chan,"%s/ai0,%s/ai1,%s/ai2,%s/ai3", dev, dev, dev, dev);

    //    std::cout<<chan<<std::endl;

    // Channel parameters
    float64     min = -10.0;
    float64     max = 10.0;

    // Timing parameters
    uInt64      samplesPerChan = 4;

    // Data read parameters
    int32       pointsToRead = 1;
    int32       pointsRead;
    float64     timeout = m_timeout;

#ifndef NODAQ
    
    DAQmxErrChk (DAQmxBaseCreateTask("",&taskHandle));
    DAQmxErrChk (
         DAQmxBaseCreateAIVoltageChan(taskHandle,
                          chan,
                          "",
                          DAQmx_Val_Cfg_Default,
                          min,max,
                          DAQmx_Val_Volts,
                          NULL));
    DAQmxErrChk (DAQmxBaseStartTask(taskHandle));
    DAQmxErrChk (DAQmxBaseReadAnalogF64(taskHandle,
                    pointsToRead,
                    timeout,
                    DAQmx_Val_GroupByChannel,
                    data,
                    samplesPerChan,
                    &pointsRead,
                    NULL));
Error:
    if( DAQmxFailed(error) )
        DAQmxBaseGetExtendedErrorInfo(errBuff,2048);
    if( taskHandle!=0 ) {
        DAQmxBaseStopTask(taskHandle);
        DAQmxBaseClearTask(taskHandle);
    }
    if( DAQmxFailed(error) )
    printf ("DAQmxBase Error %ld: %s\n", error, errBuff);
#endif
    sprintf(errBuff,"Readout AI: Ch %s - Val = %2.4f %2.4f %2.4f %2.4f", chan, data[0], data[1], data[2], data[3]);
    std::cout<<errBuff<<std::endl;
    return 0;
}

//=============================================================================
// 
//=============================================================================
int Server_NI6008::AO(const char *dev, double data[2]){
  // Task parameters
  int         code  = 0;
  int32       error = 0;
  TaskHandle  taskHandle = 0;
  char        errBuff[2048]={'\0'};
  char chan[80];
  sprintf(chan,"%s/ao0,%s/ao1", dev, dev);
  //  char        chan[] = "Dev1/ao0,Dev1/ao1";
  
  // Channel parameters
  float64     min = m_aoMin;
  float64     max = m_aoMax;
  // Timing parameters
  uInt64      samplesPerChan = 1;
  // Data write parameters
  int32       pointsWritten;

#ifndef NODAQ
  
  DAQmxErrChk (DAQmxBaseCreateTask("",&taskHandle));
  DAQmxErrChk (DAQmxBaseCreateAOVoltageChan(taskHandle,
                        chan,
                        "",
                        min,max,
                        DAQmx_Val_Volts,
                        NULL));
  DAQmxErrChk (DAQmxBaseStartTask(taskHandle));
  
  DAQmxErrChk (DAQmxBaseWriteAnalogF64(taskHandle,
                       samplesPerChan,
                       0,
                       m_timeout,
                       DAQmx_Val_GroupByChannel,
                       data,
                       &pointsWritten,NULL)
           );
Error:
    if( DAQmxFailed(error) )
        DAQmxBaseGetExtendedErrorInfo(errBuff,2048);
    if( taskHandle!=0 ) {
        DAQmxBaseStopTask(taskHandle);
        DAQmxBaseClearTask(taskHandle);
    }
    if( DAQmxFailed(error) )
        printf ("DAQmxBase Error %ld: %s\n", error, errBuff);
#endif
    sprintf(errBuff,"Setting AO: Ch %s - Val = %2.2f %2.2f", chan, data[0], data[1]);
    std::cout<<errBuff<<std::endl;
    return 0;
}

//=============================================================================
// 
//=============================================================================
int Server_NI6008::DI(const char *dev, unsigned char r_data[2] ) {
  // Task parameters
  int          code  = 0;
  int32        error = 0;
  TaskHandle   taskHandle = 0;
  int32        i;
  const uInt32 num_ports = 2;
  char         errBuff[2048];

  // Channel parameters
  char chan1[32];
  char chan2[32];

  sprintf(chan1,"%s/port0", dev);
  sprintf(chan2,"%s/port1", dev);
  //  char         chan1[] = "Dev1/port0";
  //  char         chan2[] = "Dev1/port1";

  // Read parameters
  int32        read;

#ifndef NODAQ
  // Create Digital Input (DI) Task and Channel
  DAQmxErrChk (DAQmxBaseCreateTask ("", &taskHandle));
  DAQmxErrChk (DAQmxBaseCreateDIChan(taskHandle,chan1,"",DAQmx_Val_ChanForAllLines));
  DAQmxErrChk (DAQmxBaseCreateDIChan(taskHandle,chan2,"",DAQmx_Val_ChanForAllLines));

  // Start Task (configure port)
  DAQmxErrChk (DAQmxBaseStartTask (taskHandle));

  // Read from port
  DAQmxErrChk (
    code = DAQmxBaseReadDigitalU8(
      taskHandle,
      1,
      m_timeout,
      DAQmx_Val_GroupByChannel,
      r_data,
      num_ports,
      &read,
      NULL)
  );
  // msgSvc(INFO,"Processing DI "+std::string(chan1)+"/"+std::string(chan2)+
  //   " ->"+ itos(r_data[0])+", "+itos(r_data[1]));

Error:

   if (DAQmxFailed (error))
      DAQmxBaseGetExtendedErrorInfo (errBuff, 2048);
   if (taskHandle != 0){
      DAQmxBaseStopTask (taskHandle);
      DAQmxBaseClearTask (taskHandle);
   }
   if (error)printf ("DAQmxBase Error %ld: %s\n", error, errBuff);
#endif   
   sprintf(errBuff,"Reading DI: Ch %s %s - Val = %3i %3i", chan1, chan2, r_data[0], r_data[1]);
    std::cout<<errBuff<<std::endl;
   return 0;
}

//=============================================================================
// 
//=============================================================================
int Server_NI6008::Reset(){
  msgSvc(INFO,"Reset has not been implemented yet.");
  return 0;
}

//=============================================================================
// 
//=============================================================================
int Server_NI6008::AO0(double data){
  // Task parameters
  int         code  = 0;
  int32       error = 0;
  TaskHandle  taskHandle = 0;
  char        errBuff[2048]={'\0'};
  char        chan[] = "Dev1/ao0\0";
  // Channel parameters
  float64     min = m_aoMin;
  float64     max = m_aoMax;
  // Timing parameters
  uInt64      samplesPerChan = 1;
  // Data write parameters
  int32       pointsWritten;

#ifndef NODAQ
  
  DAQmxErrChk (DAQmxBaseCreateTask("",&taskHandle));
  DAQmxErrChk (DAQmxBaseCreateAOVoltageChan(taskHandle,
                        chan,
                        "",
                        min,max,
                        DAQmx_Val_Volts,
                        NULL));
  DAQmxErrChk (DAQmxBaseStartTask(taskHandle));
  
  DAQmxErrChk (DAQmxBaseWriteAnalogF64(taskHandle,
                       samplesPerChan,
                       0,
                       m_timeout,
                       DAQmx_Val_GroupByChannel,
                       &data,
                       &pointsWritten,NULL)
           );
  msgSvc(INFO,"Processing AO "+std::string(chan)+".");
  return code;

Error:
    if( DAQmxFailed(error) )
        DAQmxBaseGetExtendedErrorInfo(errBuff,2048);
    if( taskHandle!=0 ) {
        DAQmxBaseStopTask(taskHandle);
        DAQmxBaseClearTask(taskHandle);
    }
    if( DAQmxFailed(error) )
        printf ("DAQmxBase Error %ld: %s\n", error, errBuff);
#endif
    return 0;
}

//=============================================================================
// 
//=============================================================================
int Server_NI6008::AO1(double data){
  // Task parameters
  int         code  = 0;
  int32       error = 0;
  TaskHandle  taskHandle = 0;
  char        errBuff[2048]={'\0'};
  char        chan[] = "Dev1/ao1";
  // Channel parameters
  float64     min = m_aoMin;
  float64     max = m_aoMax;
  // Timing parameters
  uInt64      samplesPerChan = 1;
  // Data write parameters
  int32       pointsWritten;

  #ifndef NODAQ
  DAQmxErrChk (DAQmxBaseCreateTask("",&taskHandle));
  DAQmxErrChk (DAQmxBaseCreateAOVoltageChan(taskHandle,
                        chan,
                        "",
                        min,max,
                        DAQmx_Val_Volts,
                        NULL));
  DAQmxErrChk (DAQmxBaseStartTask(taskHandle));
  
  DAQmxErrChk (DAQmxBaseWriteAnalogF64(taskHandle,
                       samplesPerChan,
                       0,
                       m_timeout,
                       DAQmx_Val_GroupByChannel,
                       &data,
                       &pointsWritten,NULL)
           );
  msgSvc(INFO,"Processing AO1 "+std::string(chan)+".");
#endif
  return code;

#ifndef NODAQ
Error:
    if( DAQmxFailed(error) )
        DAQmxBaseGetExtendedErrorInfo(errBuff,2048);
    if( taskHandle!=0 ) {
        DAQmxBaseStopTask(taskHandle);
        DAQmxBaseClearTask(taskHandle);
    }
    if( DAQmxFailed(error) )
        printf ("DAQmxBase Error %ld: %s\n", error, errBuff);
    return 0;
#endif
}