NI6008.cpp

Go to the documentation of this file.

// $Id: $
#include <NIDAQmxBase.h>
// Include files 
#include "Application.h"

// local
#include "NI6008.h"

//-----------------------------------------------------------------------------
// ImplementatI_On file for class : NI6008
//
// 2016-05-27 : 
//-----------------------------------------------------------------------------

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

//=============================================================================
// Standard constructor, initializes variables
//=============================================================================
NI6008::NI6008(  ) {
  setName("NI6008");
  setType("NI6008");
  m_host = application()->hostname();
}
//=============================================================================
// Destructor
//=============================================================================
NI6008::~NI6008() {
  info("Closing the NI6008 socket.");
  close(m_sockfd);
}

//=============================================================================
// 
//=============================================================================
std::string NI6008::cmd(std::string dev, std::string mess){
  int n; 
  std::string cmd = dev + std::string(" ") + mess; 
  std::copy(cmd.begin(), cmd.end(), buffer);
  //  strcat(buffer, " ");
  //  strcat(buffer, mess.c_str());
  buffer[cmd.size()] = '\0';
  //  std::cout<<"sending:"<<buffer<<" length="<<strlen(buffer)<<std::endl;
  n = write(m_sockfd,buffer,strlen(buffer));
  if (n < 0) error("ERROR writing to socket");
  bzero(buffer,256);
  n = read(m_sockfd,buffer,255);
  if (n < 0) error("ERROR reading from socket");
  //  printf("%s\n",buffer);
  return std::string(buffer);
}

// //=============================================================================
// // 
// //=============================================================================
// std::vector<double> NI6008::ai(){
//     // 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", 
//     //       m_device.c_str(), m_device.c_str(), m_device.c_str(), m_device.c_str());
//         char chan[] = "Dev1/ai0,Dev1/ai1,Dev1/ai2,Dev1/ai3";

//     // 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 = 10.0;
//     //    float64     timeout = m_timeout;
//     bool32 done = false;
//     float64 data[4];
//     data[0]=0.;
//     data[1]=0.;
//     data[2]=0.;
//     data[3]=0.;
//     std::cout<<"ai "<<chan<<std::endl;
//     std::cout<<data[0]<<" "<<data[1]<<" "<<data[2]<<" "<<data[3]<<std::endl;
//     //#ifndef NODAQ
//     error = DAQmxBaseCreateTask("",&taskHandle);
//     std::cout<<"error create task:"<<error<<std::endl;;
//     std::cout<<&taskHandle<<std::endl;
//     error = DAQmxBaseCreateAIVoltageChan(taskHandle,
//                   chan,
//                   "",
//                   DAQmx_Val_Cfg_Default,
//                   min,max,
//                   DAQmx_Val_Volts,
//                   NULL);
//     std::cout<<"error ai task:"<<error<<std::endl;
//     error = DAQmxBaseStartTask(taskHandle);
//     std::cout<<"error start task:"<<error<<std::endl;
//     wait(1000);
//     error = DAQmxBaseReadAnalogF64(taskHandle,
//                 pointsToRead,
//                 timeout,
//                 DAQmx_Val_GroupByChannel,
//                 data,
//                 samplesPerChan,
//                 &pointsRead,
//                 NULL);
//     wait(1000);
//     std::cout<<"error read analog:"<<error<<std::endl;
//     std::cout<<done<<std::endl;
//     error = DAQmxBaseIsTaskDone(taskHandle, &done);
//     std::cout<<"error task done:"<<error<<std::endl;
//     std::cout<<done<<std::endl;
//     error = DAQmxBaseStopTask(taskHandle);
//     std::cout<<"error stop task:"<<error<<std::endl;
//     error = DAQmxBaseClearTask(taskHandle);
//     std::cout<<"error clear task:"<<error<<std::endl;

// // 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
//     std::cout<<data[0]<<" "<<data[1]<<" "<<data[2]<<" "<<data[3]<<std::endl;
//     std::vector<double> result; 
//     result.push_back(data[0]);
//     result.push_back(data[1]);
//     result.push_back(data[2]);
//     result.push_back(data[3]);
//     std::cout<<result[0]<<" "<<result[1]<<" "<<result[2]<<" "<<result[3]<<std::endl;
//     return result;
// }

// //=============================================================================
// // 
// //=============================================================================
// int NI6008::di( ) {
//   // 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";
//   unsigned char r_data[2];
//   // 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,
//       10.0,
//       DAQmx_Val_GroupByChannel,
//       r_data,
//       num_ports,
//       &read,
//       NULL)
//   );
//   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
//    return 0;
// }