UsbFTInterface.cpp

Go to the documentation of this file.

//$Id: UsbFTInterface.cpp,v 1.1.1.1 2005/01/05 16:42:10 machefer Exp $
//------------------------------------------------------------------------------
//
//  Package    : UsbFTInterface
//
//  Description:
//
//  Author(s)  : F. Machefert -
//  Date       : 14 January 2004
//
//------------------------------------------------------------------------------

#include "UsbFTInterface.h"


//=========================================================================
//  
//=========================================================================
UsbFTInterface::UsbFTInterface ( ) : 
  m_usbId(-1),
  m_serialNum(std::string("None")),
  m_deviceDesc(std::string("None")),
  m_latencyTimer(2),
  m_txTimeOut(1000),
  m_rxTimeOut(1000),
  m_txBuffer(4096),
  m_rxBuffer(32768),
  m_nFrames (0),
  m_wordSize(WS_DWord),
  m_fakeErr (FK_LETSBETRUE),
  m_rdBlockMax(32768),
  m_wrBlockMax(256),
  m_interrupts(true),
  m_showEpromState(false),
  m_printout(false)
{ 
  setName("usb");
  setType("UsbFTInterface");
  info("Todo : time efficiency by creating the buffer once for all ?");
  //  add(Attrib::INTERFACE);
}


//=========================================================================
//  
//=========================================================================
StatusCode UsbFTInterface::init ( ) {
  unsigned char msecs=0;
  char desc[64];
  char serial[9];      

  strcpy(desc  , m_deviceDesc.c_str());
  strcpy(serial, m_serialNum.c_str());  

  info("Start USB device initialisation.","UsbFTInterface::init");

  if (m_usbId>0)
  {
    error("Usb device already open.","UsbFTInterface::init");    
    close();
  }
  if (!USB_FindDevices(desc))
  {
    USB_Perror(USB_GetLastError());
    error("Cannot find Usb Device "+name()+" with device description "+
          m_deviceDesc,"UsbFTInterface::init");
  }
  else
  {
    info("Device with device description "+m_deviceDesc+" found.","UsbFTInterface::init");
    info("Try to open device with serial number "+m_serialNum+".","UsbFTInterface::init");
    m_usbId=OpenUsbDevice(serial);
    if (m_usbId<0)
    {
      error("Could not find device with serial number "+m_serialNum,"UsbFTInterface::init");
      if (GetDeviceSerNum(serial,0)!=FT_OK)
      {
        error("Serial number do not match first device found.","UsbFTInterface::init");
      }
      else
      {
        info("Extracted serial number "+std::string(serial)+".","UsbFTInterface::init");
        if (GetDeviceDesc(desc,0)!=FT_OK)
        {
          USB_Perror(USB_GetLastError());  
          fatal("Device description do not match first device either. Abort",
                "UsbFTInterface::init");
        }
        else
        {
          info("Device found. Extracted description "+std::string(desc)+".",
               "UsbFTInterface::init");
          m_usbId=OpenUsbDevice(serial);
          if (m_usbId<0)
          {
            USB_Perror(USB_GetLastError());  
            fatal("Cannot open device. Abort.","UsbFTInterface::init"); 
          }          
        }
      }
    };
    info("Device opened with UsbId "+itos(m_usbId)+".","UsbFTInterface::init");

    m_deviceDesc = std::string(desc);
    m_serialNum  = std::string(serial);
    
    UsbSetIntCheckingState(m_interrupts);
    if (!USB_Init(m_usbId,true))
    {
      USB_Perror(USB_GetLastError());  
      fatal("Could not initialize the USB device "+name()+". Abort.",
            "UsbFTInterface::init");
    }

    info("Usb device initialization done.","UsbFTInterface::init");

    USB_SetLatencyTimer(m_usbId,m_latencyTimer);
    USB_SetTimeouts(m_usbId,m_txTimeOut,m_rxTimeOut);
    USB_SetXferSize(m_usbId,m_txBuffer ,m_rxBuffer);
    USB_GetLatencyTimer(m_usbId, &msecs);

    //    USB_ResetDevice(m_usbId);
/*
    if (USB_ReadEEpromData(m_usbId,m_showEpromState))
    {
      m_deviceDesc=std::string(USB_GetEpromDeviceDesc());
      m_serialNum =std::string(USB_GetEpromSerialNum());
      info("EPROM data : ","UsbFTInterface::init");
      info("  Device Description -> "+m_deviceDesc,"UsbFTInterface::init");
      info("  Serial Number      -> "+m_serialNum,"UsbFTInterface::init");      
    }
*/
  }
  wait(1000);
  return StatusCode::SUCCESS;
}


//=========================================================================
//  
//=========================================================================
StatusCode UsbFTInterface::read(unsigned long int address,
                                unsigned long int nWords,
                                boost::python::list &obj)
{
  StatusCode status;
  verbose("USB Reading :","UsbFTInterface::read");
  switch (m_wordSize)
  {
  case WS_Byte:
    {  
      unsigned char *data=new unsigned char[nWords];
      status = usbReadU8( address, nWords, data);
      verbose("Data format is "+itos(WS_Byte),"UsbFTInterface::read");
      for(unsigned int i = 0; i < nWords; i++){
        verbose("wd "+itos(i)+" "+itos(data[i]),"UsbFTInterface::read");
        obj.append(data[i]);
      };
      delete data;
    }
    break;
  case WS_Word:
    {
      unsigned short *data=new unsigned short[nWords];
      status = usbReadU16( address, nWords, data);
      verbose("Data format is "+itos(WS_Word),"UsbFTInterface::read");
      for(unsigned int i = 0; i < nWords; i++){
        verbose("wd "+itos(i)+" "+itos(data[i]),"UsbFTInterface::read");
        obj.append(data[i]);
      };
      delete data;
    }
    break;
  case WS_DWord:
    {
      unsigned long *data=new unsigned long[nWords];
      status = usbReadU32( address, nWords, data);
      verbose("Data format is "+itos(WS_DWord),"UsbFTInterface::read");
      for(unsigned int i = 0; i < nWords; i++){
        verbose("wd "+itos(i)+" "+itos(data[i]),"UsbFTInterface::read");
        obj.append(data[i]);
      };
      delete data;
    }
    break;    
  default:
    error("Wrong word size.","UsbFTInterface::read");
    status=StatusCode::FAILURE;
  }
  return status;
}

//=========================================================================
//  
//=========================================================================
StatusCode UsbFTInterface::write(unsigned long int address,
                                 boost::python::list obj) 
{
  unsigned long int nWords = len(obj);
  StatusCode status;
  verbose("USB Writing :");
  switch (m_wordSize)
  {
  case WS_Byte:
    {  
      unsigned char *data=new unsigned char[nWords];
      for(unsigned int i = 0; i < nWords; i++){
        data[i]=(boost::python::extract<unsigned char>(obj[i]));
        verbose("Data format is "+itos(WS_Byte),"UsbFTInterface::write");
        verbose("wd "+itos(i)+" "+itos(data[i]),"UsbFTInterface::write");
      };
      status = usbWriteU8(address, nWords, data);
      delete data;
    }
    break;
  case WS_Word:
    { 
      unsigned short *data=new unsigned short[nWords];
      for(unsigned int i = 0; i < nWords; i++){
        verbose("Data format is "+itos(WS_Word),"UsbFTInterface::write");
        data[i]=(boost::python::extract<unsigned short>(obj[i]));
        verbose("wd "+itos(i)+" "+itos(data[i]),"UsbFTInterface::write");
      };
      status = usbWriteU16(address, nWords, data);
      delete data;
    }
    break;
  case WS_DWord:
    {
      unsigned long *data=new unsigned long[nWords];
      for(unsigned int i = 0; i < nWords; i++){
        data[i]=(boost::python::extract<unsigned long>(obj[i]));
        verbose("Data format is "+itos(WS_DWord),"UsbFTInterface::write");
        verbose("wd "+itos(i)+" "+itos(data[i]),"UsbFTInterface::write");
      }    
      status = usbWriteU32(address, nWords, data);
      delete data;
    }
    break;
  default:
    error("Wrong word size.","read");
    status=StatusCode::FAILURE;
  }
  return status;
}

//=========================================================================
//  
//=========================================================================
StatusCode UsbFTInterface::usbRead(unsigned long int address,
                                  unsigned long int nWords,
                                  std::vector<U32> &words)
{
  StatusCode status;
  verbose("USB Reading :","UsbFTInterface::read");
  words.clear();
  words.reserve(nWords);
  switch (m_wordSize)
  {
  case WS_Byte:
    {
      unsigned char *data=new unsigned char[nWords];
      status = usbReadU8( address, nWords, data);
      for(unsigned int i = 0; i < nWords; i++){
        verbose("wd "+itos(i)+" "+itos(data[i]),"UsbFTInterface::usbRead");
        words.push_back(data[i]);
      };
      delete data;
    }
    break;
  case WS_Word:
    {
      unsigned short *data=new unsigned short[nWords];
      status = usbReadU16( address, nWords, data);
      for(unsigned int i = 0; i < nWords; i++){
        verbose("wd "+itos(i)+" "+itos(data[i]),"UsbFTInterface::usbRead");
        words.push_back(data[i]);
      };
      delete data;
    }
    break;
  case WS_DWord:
    {
      unsigned long *data=new unsigned long[nWords];
      status = usbReadU32( address, nWords, data);
      for(unsigned int i = 0; i < nWords; i++){
        verbose("wd "+itos(i)+" "+itos(data[i]),"UsbFTInterface::usbRead");
        words.push_back(data[i]);
      };
      delete data;
    }
    break;
  default:
    error("Wrong word size.","UsbFTInterface::read");
    status=StatusCode::FAILURE;
  }
  return status;
}

//=========================================================================
//
//=========================================================================
StatusCode UsbFTInterface::usbWrite(unsigned long int address,
                    std::vector<U32> words)
{
  unsigned long int nWords = words.size();
  StatusCode status;
  verbose("USB Writing :");
  switch (m_wordSize)
  {
  case WS_Byte:
    {
      unsigned char *data=new unsigned char[nWords];
      for(unsigned int i = 0; i < nWords; i++){
        data[i]=words[i];
        verbose("Data format is "+itos(WS_Byte),"UsbFTInterface::usbWrite");
        verbose("wd "+itos(i)+" "+itos(data[i]),"UsbFTInterface::usbWrite");
      };
      status = usbWriteU8(address, nWords, data);
      delete data;
    }
    break;
  case WS_Word:
    {
      unsigned short *data=new unsigned short[nWords];
      for(unsigned int i = 0; i < nWords; i++){
        data[i]=words[i];
        verbose("Data format is "+itos(WS_Word),"UsbFTInterface::usbWrite");
        verbose("wd "+itos(i)+" "+itos(data[i]),"UsbFTInterface::usbWrite");
      };
      status = usbWriteU16(address, nWords, data);
      delete data;
    }
    break;
  case WS_DWord:
    {
      unsigned long *data=new unsigned long[nWords];
      for(unsigned int i = 0; i < nWords; i++){
        data[i]=words[i];
        verbose("Data format is "+itos(WS_DWord),"UsbFTInterface::usbWrite");
        verbose("wd "+itos(i)+" "+itos(data[i]) ,"UsbFTInterface::usbWrite");
      }
      status = usbWriteU32(address, nWords, data);
      delete data;
    }
    break;
  default:
    error("Wrong word size.","read");
    status=StatusCode::FAILURE;
  }
  return status;
}
/*
//=========================================================================
//
//=========================================================================
StatusCode UsbFTInterface::usbReadU8 ( unsigned long int address,
                                       unsigned long int nData,
                                       std::vector<U8> &data ) {
  data.clear();
  data.reserve(nData);
  unsigned char * buf=new unsigned char [nData];
  StatusCode status = usbReadU8 (address, nData, buf);
  for(unsigned long int j=0; j<nData; ++j) data.push_back((unsigned char)(buf[j]));
  return status;
}

//=========================================================================
//  
//=========================================================================
StatusCode UsbFTInterface::usbWriteU8 (unsigned long int address,
                                       std::vector<U8> data ) {

  const unsigned long int nData = data.size();
  unsigned char *buf=new unsigned char [nData];
  for(unsigned long int j=0; j<nData; ++j) buf[j] = (unsigned char)(data[j]);
  StatusCode status = usbWriteU8 (address, nData, buf);
  return status;
}

//=========================================================================
//  
//=========================================================================
StatusCode UsbFTInterface::usbReadU16 ( unsigned long int address,
                                        unsigned long int nData,
                                        std::vector<U16> &data ) {
  data.clear();
  data.reserve(nData);
  unsigned short * buf=new unsigned short [nData];
  StatusCode status = usbReadU16 (address, nData, buf);
  for(unsigned long int j=0; j<nData; ++j) data.push_back((unsigned char)(buf[j]));
  return status;
}

//=========================================================================
//
//=========================================================================
StatusCode UsbFTInterface::usbWriteU16 (unsigned long int address,
                                        std::vector<U16> data ) {

  const unsigned long int nData = data.size();
  unsigned short *buf=new unsigned short [nData];
  for(unsigned long int j=0; j<nData; ++j) buf[j] = (unsigned char)(data[j]);
  StatusCode status = usbWriteU16 (address, nData, buf);
  return status;
}

//=========================================================================
//
//=========================================================================
StatusCode UsbFTInterface::usbRead ( unsigned long int address,
                                     unsigned long int nData,
                                     std::vector<U32> &data ) {
  data.clear();
  data.reserve(nData);
  unsigned long * buf=new unsigned long [nData];
  StatusCode status = usbReadU32 (address, nData, buf);
  for(unsigned long int j=0; j<nData; ++j) data.push_back((unsigned char)(buf[j]));
  return status;
}

//=========================================================================
//
//=========================================================================
StatusCode UsbFTInterface::usbWrite (unsigned long int address,
                                     std::vector<U32> data ) {

  const unsigned long int nData = data.size();
  unsigned long *buf=new unsigned long [nData];
  for(unsigned long int j=0; j<nData; ++j) buf[j] = (unsigned char)(data[j]);
  StatusCode status = usbWriteU32 (address, nData, buf);
  return status;
}
*/
//=========================================================================
//
//=========================================================================
StatusCode UsbFTInterface::usbReadU8 ( unsigned long int address, 
                                       unsigned long int nWords, 
                                       unsigned char *data ) {
  
  USB_Error rdErr=USB_NoErr;
  long int bytecount=0;

  long int nData = (long int)(nWords);

  bytecount=UsbRd(m_usbId, address, data, nData);

  if (nData==bytecount){
    verbose(itos(bytecount)+" bytes read from USB Interface "+name(),
            "UsbFTInterface::usbRead8");
    return StatusCode::SUCCESS;
  }

  if (bytecount<0){
    rdErr=USB_GetLastError();
    error("USB error number "+itos(rdErr)+" - USB_INT_FRAME="+itos(USB_INT_FRAME),
            " UsbFTInterface::usbRead8");
    if (rdErr==USB_INT_FRAME){
      PrintFrameInfo();
    } 
    return StatusCode::FAILURE;
  }
  
  if (0==bytecount){
    error(" O Byte read from USB interface "+name()+".","UsbFTInterface::usbRead8");
    return StatusCode::FAILURE;
  }

  if (nData!=bytecount){
    error(itos(bytecount)+" byte(s) read from USB interface "+name()+
            " out of "+itos(nData)+" bytes expected.","UsbFTInterface::usbRead8");
    return StatusCode::FAILURE;    
  }

  return StatusCode::SUCCESS;
}

//=========================================================================
//  
//=========================================================================
StatusCode UsbFTInterface::usbReadU16 ( unsigned long int address, 
                                        unsigned long int nWords, 
                                        unsigned short *data ) {
  
  USB_Error rdErr=USB_NoErr;
  long int bytecount=0;

    verbose("in UsbReadU16.");


  long int nData = (long int)(2*nWords);
  
  unsigned char *buff=new unsigned char [nData];


    verbose("before usbread");  
  bytecount=UsbRd(m_usbId, address, buff, nData);
    verbose("after usbread");

  for (unsigned long word=0; word<nWords; ++word)
  {
    data[word]=buff[2*word+1];
    data[word]=(data[word]<<8)|buff[2*word];
  }

  delete buff;

  if (nData==bytecount){
    verbose(itos(bytecount)+" bytes read from USB Interface "+name(),
            "UsbFTInterface::usbReadU16");
    return StatusCode::SUCCESS;
  }

  if (bytecount<0){
    rdErr=USB_GetLastError();
    error("USB error number "+itos(rdErr)+" - USB_INT_FRAME="+itos(USB_INT_FRAME),
            " UsbFTInterface::usbReadU16");
    if (rdErr==USB_INT_FRAME){
      PrintFrameInfo();
    } 
    return StatusCode::FAILURE;
  }
  
  if (0==bytecount){
    error(" O Byte read from USB interface "+name()+".",
      "UsbFTInterface::usbReadU16");
    return StatusCode::FAILURE;
  }

  if (nData!=bytecount){
    error(itos(bytecount)+" byte(s) read from USB interface "+name()+
            " out of "+itos(nData)+" bytes expected.",
      "UsbFTInterface::usbReadU16");
    return StatusCode::FAILURE;    
  }

  return StatusCode::SUCCESS;
}

//=========================================================================
//  
//========================================================================= 
StatusCode UsbFTInterface::usbReadU32 ( unsigned long int address, 
                                        unsigned long int nWords, 
                                        unsigned long *data ) {
  
  USB_Error rdErr=USB_NoErr;
  long int bytecount=0;

  long int nData = (long int)(4*nWords);
  
  unsigned char *buff=new unsigned char [nData];

  bytecount=UsbRd(m_usbId, address, buff, nData);

  for (unsigned long word=0; word<nWords; ++word)
  {
    data[word]=buff[4*word+3];
    data[word]=(data[word]<<8)|buff[4*word+2];
    data[word]=(data[word]<<8)|buff[4*word+1];
    data[word]=(data[word]<<8)|buff[4*word];
  }

  delete buff;

  if (nData==bytecount){
    verbose(itos(bytecount)+" bytes read from USB Interface "+name(),
            "UsbFTInterface::usbRead");
    return StatusCode::SUCCESS;
  }

  if (bytecount<0){
    rdErr=USB_GetLastError();
    error("USB error number "+itos(rdErr)+" - USB_INT_FRAME="+itos(USB_INT_FRAME),
            " UsbFTInterface::usbRead32");
    if (rdErr==USB_INT_FRAME){
      PrintFrameInfo();
    } 
    return StatusCode::FAILURE;
  }
  
  if (0==bytecount){
    error(" O Byte read from USB interface "+name()+".","UsbFTInterface::usbRead32");
    return StatusCode::FAILURE;
  }

  if (nData!=bytecount){
    error(itos(bytecount)+" byte(s) read from USB interface "+name()+
            " out of "+itos(nData)+" bytes expected.","UsbFTInterface::usbRead32");
    return StatusCode::FAILURE;    
  }
  return StatusCode::SUCCESS;
}

//=========================================================================
//  
//=========================================================================
StatusCode UsbFTInterface::usbWriteU8 (unsigned long int address ,
                                       unsigned long int nWords, 
                                       unsigned char *data ) {
  USB_Error wrErr=USB_NoErr;
  long int  bytecount=0;

  long int nData=(long int)(nWords);

  bytecount=UsbWrt(m_usbId, address, data, nData);

  if (bytecount<0){
    wrErr=USB_GetLastError();
    error("USB error number "+itos(wrErr)+" - USB_INT_FRAME="+itos(USB_INT_FRAME),
            "UsbFTInterface::usbWrite8");
    if (wrErr==USB_INT_FRAME){
      PrintFrameInfo();
    } 
    return StatusCode::FAILURE;
  }

  if (nData==bytecount){
    verbose(itos(bytecount)+" bytes written on USB Interface "+name(),
            "UsbFTInterface::usbWrite8");
  }
  
  if (0==bytecount){
    error(" O Byte written on USB interface "+name()+".","UsbFTInterface::usbWrite8");
    return StatusCode::FAILURE;
  }

  if (nData!=bytecount){
    error(itos(bytecount)+" byte(s) written on USB interface "+name()+
            " out of "+itos(nData)+" bytes to be sent.","UsbFTInterface::usbWrite8");
    return StatusCode::FAILURE;    
  }

  return StatusCode::SUCCESS;  
}

//=========================================================================
//  
//=========================================================================
StatusCode UsbFTInterface::usbWriteU16 (unsigned long int address ,
                                        unsigned long int nWords, 
                                        unsigned short *data ) {
  USB_Error wrErr=USB_NoErr;
  long int  bytecount=0;

  long int nData=(long int)(2*nWords);

  bytecount=UsbWrt(m_usbId, address, data, nData);

  if (bytecount<0){
    wrErr=USB_GetLastError();
    error("USB error number "+itos(wrErr)+" - USB_INT_FRAME="+itos(USB_INT_FRAME),
            "UsbFTInterface::usbWrite16");
    if (wrErr==USB_INT_FRAME){
      PrintFrameInfo();
    } 
    return StatusCode::FAILURE;
  }

  if (nData==bytecount){
    verbose(itos(bytecount)+" bytes written on USB Interface "+name(),
            "UsbFTInterface::usbWrite16");
  }
  
  if (0==bytecount){
    error(" O Byte written on USB interface "+name()+".","UsbFTInterface::usbWrite16");
    return StatusCode::FAILURE;
  }

  if (nData!=bytecount){
    error(itos(bytecount)+" byte(s) written on USB interface "+name()+
            " out of "+itos(nData)+" bytes to be sent.","UsbFTInterface::usbWrite16");
    return StatusCode::FAILURE;    
  }

  return StatusCode::SUCCESS;  
}

//=========================================================================
//  
//=========================================================================
StatusCode UsbFTInterface::usbWriteU32 (unsigned long int address ,
                                        unsigned long int nWords, 
                                        unsigned long *data ) {
  USB_Error wrErr=USB_NoErr;
  long int  bytecount=0;

  long int nData=(long int)(4*nWords);

  bytecount=UsbWrt(m_usbId, address, data, nData);

  if (bytecount<0){
    wrErr=USB_GetLastError();
    error("USB error number "+itos(wrErr)+" - USB_INT_FRAME="+itos(USB_INT_FRAME),
            "UsbFTInterface::usbWrite32");
    if (wrErr==USB_INT_FRAME){
      PrintFrameInfo();
    } 
    return StatusCode::FAILURE;
  }

  if (nData==bytecount){
    verbose(itos(bytecount)+" bytes written on USB Interface "+name(),
            "UsbFTInterface::usbWrite32");
  }
  
  if (0==bytecount){
    error(" O Byte written on USB interface "+name()+".","UsbFTInterface::usbWrite32");
    return StatusCode::FAILURE;
  }

  if (nData!=bytecount){
    error(itos(bytecount)+" byte(s) written on USB interface "+name()+
            " out of "+itos(nData)+" bytes to be sent.","UsbFTInterface::usbWrite32");
    return StatusCode::FAILURE;    
  }

  return StatusCode::SUCCESS;  
}

//=========================================================================
//  
//=========================================================================
StatusCode UsbFTInterface::usbWriteRead ( unsigned long int address, 
                                          std::vector<U8> dataWrite, 
                                          std::vector<U8> &dataRead ) {
  USB_Error rdErr=USB_NoErr, wrErr=USB_NoErr;
  long int bytecount=0;
  long int nData=dataWrite.size();
  const unsigned long int bufSize=nData+4;
  U8* bufWr=new U8[bufSize];
  U8* bufRd=new U8[bufSize];

  for(int j=0; j<nData; ++j) bufWr[j] = static_cast<unsigned char>(dataWrite[j]);

  bytecount=UsbWrt(m_usbId, address, bufWr, nData);

  if (bytecount<0){
    wrErr=USB_GetLastError();
    error("USB error number "+itos(wrErr)+" - USB_INT_FRAME="+itos(USB_INT_FRAME),
            " UsbFTInterface::usbWriteRead");
    if (wrErr==USB_INT_FRAME){
      PrintFrameInfo();
    } 
    return StatusCode::FAILURE;
  }

  if (nData==bytecount){
    verbose(itos(bytecount)+" bytes written on USB Interface "+name(),
            "UsbFTInterface::usbWriteRead");

    bytecount=UsbRd(m_usbId, address, bufRd, nData);

    if (nData==bytecount){
      verbose(itos(bytecount)+" bytes read from USB Interface "+name(),
              "UsbFTInterface::usbRead");
      for(int j=0; j<nData; ++j) dataRead[j] = static_cast<unsigned char>(bufRd[j]);
      return StatusCode::SUCCESS;
    }

    if (bytecount<0){
      rdErr=USB_GetLastError();
      error("USB error number "+itos(rdErr)+" - USB_INT_FRAME="+itos(USB_INT_FRAME),
              " UsbFTInterface::usbWriteRead");
      if (rdErr==USB_INT_FRAME){
        PrintFrameInfo();
      } 
      return StatusCode::FAILURE;
    }
  
    if (0==bytecount){
      error(" O Byte read from USB interface "+name()+".","UsbFTInterface::usbRead");
      return StatusCode::FAILURE;
    }

    if (nData!=bytecount){
      error(itos(bytecount)+" byte(s) read from USB interface "+name()+
              " out of "+itos(nData)+" bytes expected.","UsbFTInterface::usbRead");
      return StatusCode::FAILURE;    
    } 
  }
  
  
  if (0==bytecount){
    error(" O Byte written n USB interface "+name()+".","UsbFTInterface::usbWrite");
    return StatusCode::FAILURE;
  }

  if (nData!=bytecount){
    error(itos(bytecount)+" byte(s) written USB interface "+name()+
            " out of "+itos(nData)+" bytes to be sent.","UsbFTInterface::usbWrite");
    return StatusCode::FAILURE;    
  }

  return StatusCode::SUCCESS;    return StatusCode::SUCCESS;  
}

//=========================================================================
//  
//=========================================================================
void UsbFTInterface::close ( ) {
  if (m_usbId>0)
  {    
    info("Close USB device "+name()+" [id="+itos(m_usbId)+"]","UsbFTInterface::close");
    CloseUsbDevice( m_usbId );
  }
  m_usbId=-1;
}

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


//=========================================================================
//
//=========================================================================
StatusCode UsbFTInterface::read(IOdata *io){
  unsigned long int address = io->address();
  unsigned long int nWords  = io->length();
  StatusCode status;
  switch (io->wordSize())
  {
  case (IOdata::Byte):
    if (nWords<m_rdBlockMax+1){
      verbose("Reading a single block "+itos(nWords)+"/"+itos(m_rdBlockMax),
          "UsbFTInterface::read");
      status = usbReadU8( address, nWords, io->dataU8());   
    }
    else {
      //      int nwords=nWords;
      U8* data=io->dataU8();
      int nXfer=(int)(nWords/m_rdBlockMax)+1;
      for (int i=0; i<nXfer ; ++i){
    if (i<nXfer-1){
      verbose("Reading block "+itos(i)+
          " of size "+itos(m_rdBlockMax),
          "UsbFTInterface::read");
      status = usbReadU8( address, 
                  m_rdBlockMax , 
                  data);
      data+=sizeof(U8*)*m_rdBlockMax;
    }
    else {
      verbose("Reading last block "+itos(i)+
          " of size "+itos(nWords%m_rdBlockMax),
          "UsbFTInterface::read");
      status = usbReadU8( address, 
                  nWords%m_rdBlockMax , 
                  data); 
      data+=sizeof(U8*)*(nWords%m_rdBlockMax);
    }
      }
    }
    break;
  case (IOdata::Word):
    status = usbReadU16( address, nWords, io->dataU16());
    break;
  case (IOdata::DWord):
    status = usbReadU32( address, nWords, io->dataU32());
    break;
  default:
    error("Wrong word size.","UsbFTInterface::read");
    status=StatusCode::FAILURE;
  }
  return status;
}

//=========================================================================
//
//=========================================================================
StatusCode UsbFTInterface::write(IOdata *io){
  unsigned long int address = io->address();
  unsigned long int nWords  = io->length();
  StatusCode status;
  switch (io->wordSize())
  {
  case (IOdata::Byte):
    if (nWords<m_wrBlockMax+1){
      verbose("Writing a single block "+itos(nWords)+"/"+itos(m_wrBlockMax),
          "UsbFTInterface::write");
      status = usbWriteU8(address, nWords, io->dataU8());
    }
    else {
      //      int nwords=nWords;
      U8* data=io->dataU8();
      int nXfer=(int)ceil((float)(nWords)/(float)(m_wrBlockMax));
      verbose("number of Xfer="+itos(nXfer)+
          " "+itos(m_wrBlockMax)+
          " "+itos(nWords),"");
      for (int i=0; i<nXfer ; ++i){
    if (i<nXfer-1){
      verbose("Writing block "+itos(i)+
          " of size "+itos(m_wrBlockMax),
          "UsbFTInterface::write");
      status = usbWriteU8( address, 
                   m_wrBlockMax , 
                   data);
      data+=sizeof(U8)*m_wrBlockMax;
    }
    else {
      //nWords%m_wrBlockMax
      unsigned int nwords=nWords-(nXfer-1)*m_wrBlockMax;
      verbose("Writing last block "+itos(i)+
          " of size "+itos(nwords),
          "UsbFTInterface::write");
      status = usbWriteU8( address, 
                   nwords, 
                   data); 
      data+=sizeof(U8)*(nwords);
    }
      }
    }
    break;
  case (IOdata::Word):
    status = usbWriteU16(address, nWords, io->dataU16());
    break;
  case (IOdata::DWord):
    status = usbWriteU32(address, nWords, io->dataU32());
    break;
  default:
    error("Wrong word size.","UsbFTInterface::read");
    status=StatusCode::FAILURE;
  }
  return status;
}