DCU.cpp

Go to the documentation of this file.

// $Id: DCU.cpp,v 1.6 2007/10/11 11:06:55 fmachefe Exp $

// include files
#include <algorithm>
#include <sstream>

// Include files
#include "Element.h"
#include "Tools.h"

// local
#include "DCU.h"

#if defined(_DEBUG) && !defined(USE_ROOT) && defined(WIN32)
#define new DEBUG_NEW
#endif 

//-----------------------------------------------------------------------------
// Implementation file for class : DCU
//
// 2005-05-31 : Frédéric Machefert
//-----------------------------------------------------------------------------

//=============================================================================
// Standard constructor, initializes variables
//=============================================================================
DCU::DCU(  ) {
  setType( "DCU" ) ;
  setId( 0 ) ;
  debug("DCU::DCU" , "DCU built" ) ;
  m_outputSelect = 0xF ;  
}
//=============================================================================
// Destructor
//=============================================================================
DCU::~DCU( )  { }

/*
bool DCU::cmdline(std::vector <std::string> cmd){
  if ( 0==cmd.size() ){
    char line[200];
    std::string tmp;

    U8 dcumode = 0 ;
    readMode ( dcumode );
    if ( 0 == dcumode ) {
      msgSvc (INFO,"cmdline","DCU Mode : HIR");
    }      
    else {
      msgSvc (INFO,"cmdline","DCU Mode : LIR");
    }

    U16    data [7];
    double value[7];
    for (int i = 0 ; i < 7 ; ++i ) {
      acquire ( i , data[i] , value[i] );      
    }    

    sprintf(line,"Raw Data  %6i %6i %6i %6i %6i %6i %6i",
            data[0], data[1],
            data[2], data[3],
            data[4], data[5],
            data[6]);
    msgSvc(INFO,"cmdline",line);

    sprintf(line,"Value (v) %6.3lf %6.3lf %6.3lf %6.3lf %6.3lf %6.3lf %6.3lf",
            value[0],value[1],
            value[2],value[3],
            value[4],value[5],
            value[6]);
    msgSvc(INFO,"cmdline",line);
    return true;
  }

  transform(cmd[0].begin(),cmd[0].end(),cmd[0].begin(),tolower);

  if (cmd[0].compare("reset")==0){
    reset();
    return true;
  }

  if (cmd[0].compare("lir")==0){
    setLIR();
    return true;
  }

  if (cmd[0].compare("hir")==0){
    setHIR();
    return true;
  }
  return false;
}
*/

//=============================================================================
// perform acqUsition on a DCU channel
//=============================================================================
bool DCU::acquire( U8 channel , U16 & data , double & value ) {
#ifndef _NODEVICE_
  SPECSSLAVE *specsSlv=specsSlaveDevice();
  if ( 0==specsSlv ){
    warning("DCU::acquire",
           "Could not reach proper Specs Master and/or Slave.");
    return false;
  }

  SpecsError status = specs_dcu_acquire (specsSlv
#ifdef  _OLDSPECSLIB_
                                         ,address()
#endif
                     ,channel,
                     &data, 
                     &value);

  if (0!=status){
    warning("DCU::acquire","Acquisition failure channel " + 
        itos (channel) + 
        "[code=" + itos(status) + "]" );
    return false; 
  }
  else {
    verbose("DCU::acquire","Channel " + itos (channel) + 
       " -> Acquisition :  " + itos(data) );
  }
#else
  verbose("DCU::acquire","Compilation in _NODEVICE_ mode.");
#endif
  return true;
}

// ============================================================================
// Reset DCU
// ============================================================================
void DCU::reset( ) {
#ifndef _NODEVICE_
  SPECSSLAVE *specsSlv=specsSlaveDevice();
  if ( 0==specsSlv ){
    warning"DCU::reset","Could not reach proper Specs Master and/or Slave.");
    return;
  }
  SpecsError status = specs_dcu_reset (specsSlv
#ifdef _OLDSPECSLIB_
                                       ,address()
#endif
);
  if (0!=status){
    warning("DCU::reset","Could not properly reset the DCU.");
    return; 
  }
  else {
    verbose("DCU::reset","DCU reset.");
  }
#else
verbose("DCU::reset","Compilation in _NODEVICE_ mode.");
#endif
}

// ============================================================================
// Initialize DCU
// ============================================================================
StatusCode DCU::init( ){
#ifndef _NODEVICE_
  SPECSSLAVE *specsSlv=specsSlaveDevice();
  if ( 0==specsSlv ){
    warning("DCU::init",
           "Could not reach proper Specs Master and/or Slave.");
    return StatusCode::FAILURE;
  }
  SpecsError status = specs_dcu_initialize (specsSlv
#ifdef _OLDSPECSLIB_                                            
                                            ,address()
#endif
);
  if (0!=status){
    warning("DCU::init","Could not properly init the DCU.");
    return StatusCode::FAILURE;
  }
  else {
    verbose("DCU::init","DCU init.");
  }
#else
  verbose("DCU::init","Compilation in _NODEVICE_ mode.");
#endif
  return StatusCode::SUCCESS;
}

// ============================================================================
// set LIR Mode
// ============================================================================
bool DCU::setLIR( ) {
#ifndef _NODEVICE_
  SPECSSLAVE *specsSlv=specsSlaveDevice();
  if ( 0==specsSlv ){
    warning("DCU::setLIR",
           "Could not reach proper Specs Master and/or Slave.");
    return false;
  }
  SpecsError status = specs_dcu_set_LIR (specsSlv
#ifdef _OLDSPECSLIB_
                                         ,address()
#endif
);
  if (0!=status){
    msgSvc( WARNING, "DCU::setLIR","Could not properly set LIR Mode");
    return false; 
  }
  else {
    verbose("DCU::setLIR","DCU LIR Mode set");
  }
#else
  verbose("DCU::setLIR",
         "Compilation in _NODEVICE_ mode.");
#endif
  return true;
}

// ============================================================================
// set HIR Mode
// ============================================================================
bool DCU::setHIR( ) {
#ifndef _NODEVICE_
  SPECSSLAVE *specsSlv=specsSlaveDevice();
  if ( 0==specsSlv ){
    warning("DCU::setHIR",
           "Could not reach proper Specs Master and/or Slave.");
    return false;
  }
  SpecsError status = specs_dcu_set_HIR (specsSlv
#ifdef _OLDSPECSLIB_
                                         ,address()
#endif
);
  if (0!=status){
    msgSvc( WARNING, "DCU::setHIR","Could not properly set HIR Mode");
    return false; 
  }
  else {
    verbose("DCU::setHIR","DCU HIR Mode set");
  }
#else
  verbose("DCU::setHIR",
         "Compilation in _NODEVICE_ mode.");
#endif
  return true;
}

//=============================================================================
// Read DCU Mode
//=============================================================================
bool DCU::readMode( U8 & mode ){
#ifndef _NODEVICE_
  SPECSSLAVE *specsSlv=specsSlaveDevice();
  if ( 0==specsSlv ){
    warning("DCU::readMode",
           "Could not reach proper Specs Master and/or Slave.");
    return false;
  }

  SpecsError status = specs_dcu_read_mode (specsSlv
#ifdef _OLDSPECSLIB_
                                           ,address()
#endif
                                           ,&mode);

  if (0!=status){
    msgSvc( WARNING, "DCU::readMode","Could not properly read DCU Mode");
    return false; 
  }
  else {
    switch (mode){
    case 0:
      verbose("DCU::readMode","DCU read Mode HIR" );
      break;
    default:
      verbose("DCU::readMode","DCU read Mode LIR" );
    }
  }
#else
  verbose("DCU::readMode",
         "Compilation in _NODEVICE_ mode.");
#endif
  return true;
}

//=============================================================================
// Convert input value
//=============================================================================
bool DCU::convert( std::string & output_value ,
           U16 input_value ,
           U8  channel ){
  U8 mode = 0 ;
  if ( ! ( readMode( mode ) ) ) {
    warning("DCU::convertInputValueViaI2c","Cannot read mode" ) ;
    return false ;
  }
  
  std::string unit = "V" ;
  
  if ( channel == 7 ) unit = "C" ;
  
  double value ;
  
  if ( channel == 7 ) 
    value = ( (double) ( input_value - 2469 ) ) / 9.22 + 25. ;
  else
    if ( mode == 1 )
      value = input_value * 0.0003052 ;
    else if ( mode == 0 )
      value = 2.5 - input_value * 0.0003052 ;
  
  std::ostringstream outstr ;
  outstr << value << " " << unit ;
  
  output_value = outstr.str() ;  

  return true ;
}