SpecsInterface.cpp

Go to the documentation of this file.

//$Id: SpecsInterface.cpp,v 1.15 2006/10/04 19:53:25 fmachefe Exp $
//-----------------------------------------------------------------------------
//
//  Package    : SpecsInterface
//
//  Description:
//
//  Author(s)  : F. Machefert -
//  Date       : 18 January 2004
//
//-----------------------------------------------------------------------------

// Include files
//#include "Tools.h"
#include "SpecsMaster.h"
#include "SpecsSlave.h"

// local
#include "SpecsInterface.h"

SpecsInterface::SpecsInterface(){
  m_address=0;
  m_outputSelect=0x0;
  setId(0);


}

void SpecsInterface::setAddress(unsigned char address){
    m_address=address;
}

unsigned char SpecsInterface::address() {
    return m_address;
}

void SpecsInterface::setOutputSelect(unsigned char outputSelect){
    m_outputSelect=outputSelect;
}

unsigned char SpecsInterface::outputSelect() {
    return m_outputSelect;
}

//=========================================================================
//  
//=========================================================================

SpecsSlave* SpecsInterface::specsSlave(){
    if (0!=parent()){
    SpecsInterface* tmp = dynamic_cast <SpecsInterface*> (parent());
    if ( 0 != tmp ) return tmp->specsSlave();
  }
  return (SpecsSlave*)NULL; 
}

SpecsMaster* SpecsInterface::specsMaster(){
    if (0!=parent()){
    SpecsInterface* tmp = dynamic_cast <SpecsInterface*> (parent());
    if ( 0 != tmp ) return tmp->specsMaster();
  }
  return (SpecsMaster*)NULL;
}

#ifndef _NODEVICE_
SPECSSLAVE* SpecsInterface::specsSlaveDevice(){
    if (0!=parent()){
    SpecsInterface* tmp = dynamic_cast <SpecsInterface*> (parent());
    if ( 0 != tmp ) return tmp->specsSlaveDevice();
    }
  return (SPECSSLAVE*)NULL;
}
#endif

#ifndef _NODEVICE_
SPECSMASTER* SpecsInterface::specsMasterDevice(){
    if (0!=parent()){
    SpecsInterface* tmp = dynamic_cast <SpecsInterface*> (parent());
    if ( 0 != tmp ) return tmp->specsMasterDevice();
    }
  return (SPECSMASTER*)NULL;
}
#endif

bool SpecsInterface::specsWriteI2c(unsigned char i2cAdd,
                                 unsigned char nWord,
                                 U8* data){
#ifndef _NODEVICE_
  SPECSSLAVE *specsSlv=specsSlaveDevice();
  if ( 0==specsSlv ){
    warning("Could not reach proper Specs Master and/or Slave.","SpecsInterface::specsWriteI2c");
    return false;
  }
  SpecsError status = specs_i2c_write ( specsSlv, outputSelect() , i2cAdd , nWord , data );
  if (0!=status){
    warning("failure at address " + itos (i2cAdd) + "[code=" + itos(status) + "]" ,
            "specsWriteI2c");
    //    specsMaster() -> reset();
  }
  else {
    verbose(itos(nWord) + " words written at address " + itos(i2cAdd),
            "SpecsWriteI2c");
  }
#else
  verbose("Compilation in _NODEVICE_ mode.","SpecsInterface::specsWriteI2c");
#endif
  return true;
}


bool SpecsInterface::specsWriteI2c( unsigned char address ,
                                  std::vector<U8> data ){

  unsigned char nword = static_cast<unsigned int>( data.size() );
  if ( nword == 0 ) {
    warning("Request to write data of size 0","SpecsInterface::specsWriteI2c");
    return false;
  }
  unsigned char* new_data = new unsigned char[nword];
  for(unsigned int i=0; i<data.size(); ++i) new_data[i] = data[i];
 
  bool status =     specsWriteI2c(address, nword, new_data);
  delete [] new_data;
  return status;

  return true;
}

bool SpecsInterface::specsWriteI2c( unsigned char i2cAdd ,
                                  unsigned char subAdd ,
                                  unsigned char nWord ,
                                  U8* data ){
#ifndef _NODEVICE_
  SPECSSLAVE *specsSlv=specsSlaveDevice();
  if ( 0==specsSlv ){
    warning("Could not reach proper Specs Master and/or Slave.","SpecsInterface::specsWriteI2c");
    return false;
  }
  SpecsError status = specs_i2c_write_sub ( specsSlv, outputSelect() , i2cAdd , subAdd , nWord , data );
  if (0!=status){
    warning("failure at address " + itos (i2cAdd) + "/ subAddress " + itos(subAdd) +
            " [code=" + itos(status) + "]","specsWriteI2c");
    //    specsMaster() -> reset();
  }
  else {
    verbose(itos(nWord) + 
            " words written at address " + 
            itos(i2cAdd) + 
            "/ subAddress " + 
            itos(subAdd),
            "SpecsWriteI2c");
  }
#else
  verbose("Compilation in _NODEVICE_ mode.","SpecsInterface::specsWriteI2c");
#endif
  return true;
}

bool SpecsInterface::specsWriteI2c( unsigned char i2cAdd ,
                                  unsigned char outputSel,
                                  unsigned char subAdd ,
                                  unsigned char nWord ,
                                  U8* data ){
#ifndef _NODEVICE_
  SPECSSLAVE *specsSlv=specsSlaveDevice();
  if ( 0==specsSlv ){
    warning("Could not reach proper Specs Master and/or Slave.",
            "SpecsInterface::specsWriteI2c");
    return false;
  }
  SpecsError status = specs_i2c_write_sub ( specsSlv, outputSel , 
                                            i2cAdd , subAdd , 
                                            nWord , data );
  if (0!=status){
    warning("failure at address " + itos (i2cAdd) + "/ subAddress " + itos(subAdd) +
            " [code=" + itos(status) + "]" ,
            "specsWriteI2c");
    //    specsMaster() -> reset();
  }
  else {
    verbose(itos(nWord) + " words written at address " + itos(i2cAdd) + 
            "/ subAddress " + itos(subAdd),
            "SpecsWriteI2c");
  }
#else
  verbose("Compilation in _NODEVICE_ mode.","SpecsInterface::specsWriteI2c");
#endif
  return true;
}

bool SpecsInterface::specsReadI2c(unsigned char i2cAdd,
                                unsigned char nOctets,
                                U8* i2cWords ){
#ifndef _NODEVICE_
  SPECSSLAVE *specsSlv=specsSlaveDevice();
  if ( 0==specsSlv ){
    warning("Could not reach proper Specs Master and/or Slave.",
            "SpecsInterface::specsReadI2c");
    return false;
  }
  SpecsError status = specs_i2c_read ( specsSlv, outputSelect() , i2cAdd , nOctets , i2cWords );
  if (0!=status){
    warning("failure at address " + itos (i2cAdd) + "[code=" + itos(status) + "]",
            "specsReadI2c" );
    //    specsMaster() -> reset();
  }
  else {
    verbose(itos(nOctets) + " words read at address " + itos(i2cAdd),"SpecsReadI2c");
  }
#else
  verbose("Compilation in _NODEVICE_ mode.","SpecsInterface::specsReadI2c");
#endif
  return true;
}

bool SpecsInterface::specsReadI2c( unsigned char address ,
                                 std::vector<unsigned char>& specsWords ){

  int nOctets = specsWords.size();
  if( nOctets==0) {
    warning("The vector of data to read should have a non-zero size",
            "SpecsInterface::specsReadI2c");
    return false;
  }

  U8 BufferSource[50];
 
  bool status = specsReadI2c(address, nOctets, BufferSource);

  for(int j=0; j<nOctets; ++j) specsWords[j] = static_cast<unsigned char>(BufferSource[j]);

  return status;
}

bool SpecsInterface::specsReadI2c(unsigned char i2cAdd,
                                unsigned char subAdd,
                                unsigned char nOctets,
                                U8* i2cWords){
#ifndef _NODEVICE_
  SPECSSLAVE *specsSlv=specsSlaveDevice();
  if ( 0==specsSlv ){
    warning("Could not reach proper Specs Master and/or Slave.","SpecsInterface::specsReadI2c");
    return false;
  }
  SpecsError status = specs_i2c_read_sub ( specsSlv, outputSelect() , i2cAdd , subAdd , nOctets , i2cWords );
  if (0!=status){
    warning("failure at address " + itos (i2cAdd) + "/ subAddress " + itos(subAdd) +
            " [code=" + itos(status) + "]" ,
            "specsReadI2c");
    //    specsMaster() -> reset();
  }
  else {
    verbose(itos(nOctets) + " words read at address " + itos(i2cAdd) +
            "/ subAddress " + itos(subAdd),
            "SpecsReadI2c");
  }
#else
  verbose("Compilation in _NODEVICE_ mode.","SpecsInterface::specsReadI2c");
#endif
  return true;
}

bool SpecsInterface::specsReadI2c(unsigned char i2cAdd,
                                unsigned char outputSel,
                                unsigned char subAdd,
                                unsigned char nOctets,
                                U8* i2cWords){
#ifndef _NODEVICE_
  SPECSSLAVE *specsSlv=specsSlaveDevice();
  if ( 0==specsSlv ){
    warning("Could not reach proper Specs Master and/or Slave.",
            "SpecsInterface::specsReadI2c");
    return false;
  }
  SpecsError status = specs_i2c_read_sub ( specsSlv, outputSel ,
                                           i2cAdd , subAdd , 
                                           nOctets , i2cWords );
  if (0!=status){
    warning("failure at address " + itos (i2cAdd) + "/ subAddress " + itos(subAdd) +
            " [code=" + itos(status) + "]",
            "specsReadI2c" );
    //    specsMaster() -> reset();
  }
  else {
    verbose(itos(nOctets) + " words read at address " + itos(i2cAdd) +
            "/ subAddress " + itos(subAdd),
            "SpecsReadI2c");
  }
#else
  verbose("Compilation in _NODEVICE_ mode.","SpecsInterface::specsReadI2c");
#endif
  return true;
}

bool SpecsInterface::specsWriteParallel(unsigned char add,
                                      U16 value){
#ifndef _NODEVICE_
  SPECSSLAVE *specsSlv=specsSlaveDevice();
  if ( 0==specsSlv ){
    warning("Could not reach proper Specs Master and/or Slave.",
            "SpecsInterface::specsWriteParallel");
    return false;
  }
  SpecsError status = specs_parallel_write( specsSlv , add , 1 , &value );
  if (0!=status){
    warning("failure at address " + itos (add) +
            " [code=" + itos(status) + "]" ,
            "specsWriteParallel");
    //    specsMaster() -> reset();
  }
  else {
    verbose("Word " + itos( value ) +
            " successfully written at address " + itos(add),
            "SpecsWriteParallel");
  }
#else
  verbose("Compilation in _NODEVICE_ mode.",
          "SpecsWriteParallel");
#endif
  return true;
}

bool SpecsInterface::specsReadParallel(unsigned char add,
                                     U16 &parallelBus){
#ifndef _NODEVICE_
  SPECSSLAVE *specsSlv=specsSlaveDevice();
  if ( 0==specsSlv ){
    warning("Could not reach proper SpecsSlave/Master.","SpecsInterface::specsReadI2c");
    return false;
  }
  SpecsError status = specs_parallel_read( specsSlv , add , 1 , &parallelBus );
  if (0!=status){
    warning("failure at address " + itos (add) +
            " [code=" + itos(status) + "]",
            "specsReadParallel" );
    //    specsMaster() -> reset();
  }
  else {
    verbose("Word " + itos(parallelBus) +
            " successfully read at address " + itos(add),
            "SpecsReadParallel");
  }
#else
  verbose("Compilation in _NODEVICE_ mode.",
          "SpecsReadParallel");
#endif
  return true;
}


bool SpecsInterface::specsWriteRegister(unsigned char reg,
                                      unsigned short value){
#ifndef _NODEVICE_
  SPECSSLAVE *specsSlv=specsSlaveDevice();

  if ( 0==specsSlv  ){
    warning("Could not reach proper SpecsSlave/Master.",
            "SpecsInterface::specsWriteRegister");
    return false;
  }
  
  SpecsError status ;
  status = specs_register_write ( specsSlv , reg , value ); 
  if ( 0 != status ){
    warning("failure at register " + itos (reg) +
            " [code=" + itos(status) + "]" ,
            "specsWriteRegister");
    //    specsMaster() -> reset();
    return false;
  }
  else {
    verbose("register " + itos(reg) +
            " successfully written with value " + itos (value),
            "SpecsWriteRegister");
  }
#else
  verbose("Compilation in _NODEVICE_ mode.",
          "SpecsInterface::specsWriteRegister");
#endif
  return true;
}

bool SpecsInterface::specsReadRegister(unsigned char reg,
                                     U16 & value){
#ifndef _NODEVICE_
  SPECSSLAVE *specsSlv=specsSlaveDevice();

  if ( 0==specsSlv  ){
    warning("Could not reach proper SpecsSlave/Master.",
            "SpecsInterface::specsReadRegister");
    return false;
  }
  
  SpecsError status ;
  status = specs_register_read ( specsSlv , reg , &value );
  if (0!=status){
    warning("failure at register " + itos (reg) +
            " [code=" + itos(status) + "]" ,
            "specsReadRegister");
    //    specsMaster() -> reset();
    return false;
  }
  else {
    verbose("register " + itos(reg) +
            " successfully read with value " + itos(value),
            "SpecsReadRegister");
  }
#else
  verbose("Compilation in _NODEVICE_ mode.",
          "SpecsInterface::specsReadRegister");
#endif
  return true;
}