UsbFTInterface Class Reference

#include <include/UsbFTInterface.h>

Inheritance diagram for UsbFTInterface:

Public Types
enum	WordSize { WS_Byte =1, WS_Word, WS_DWord }
enum	IOMode {   USB_IORead, USB_IOWrite, USB_IOReadWrite, USB_WriteReadBurst,   USB_IOExtebdedRead }
typedef unsigned long	U32
typedef unsigned short	U16
typedef unsigned char	U8
Public Types inherited from Attrib
enum	Attribut {   UNDEFINED, PASSIVE, ACTIVE, INTERFACE,   IO, IODATA, ELEMENT, HARDWARE,   PROCESSUS, SOFTWARE }

Public Member Functions
	UsbFTInterface ()
virtual	~UsbFTInterface ()
virtual void	help ()
virtual StatusCode	init ()
void	close ()
virtual void	reset ()
virtual void	update ()
StatusCode	read (IOdata *)
StatusCode	write (IOdata *)
StatusCode	read (unsigned long int, unsigned long int, boost::python::list &)
StatusCode	write (unsigned long int, boost::python::list)
StatusCode	usbRead (unsigned long int, unsigned long int, std::vector< U32 > &)
StatusCode	usbWrite (unsigned long int, std::vector< U32 >)
StatusCode	usbReadU8 (unsigned long int, unsigned long int, unsigned char *)
StatusCode	usbReadU16 (unsigned long int, unsigned long int, unsigned short *)
StatusCode	usbReadU32 (unsigned long int, unsigned long int, unsigned long *)
StatusCode	usbWriteU8 (unsigned long int, unsigned long int, unsigned char *)
StatusCode	usbWriteU16 (unsigned long int, unsigned long int, unsigned short *)
StatusCode	usbWriteU32 (unsigned long int, unsigned long int, unsigned long *)
StatusCode	usbWriteRead (unsigned long int, std::vector< U8 >, std::vector< U8 > &)
void	setUsbId (int usbId)
int	usbId ()
void	setSerialNum (std::string serialNum)
std::string	serialNum ()
void	setDeviceDesc (std::string deviceDesc)
std::string	deviceDesc ()
void	setLatencyTimer (unsigned char latencyTimer)
unsigned char	latencyTimer ()
void	setTimeOut (int txTimeOut, int rxTimeOut)
int	txTimeOut ()
int	rxTimeOut ()
void	setBuffer (int txBuffer, int rxBuffer)
int	txBuffer ()
int	rxBuffer ()
void	setNFrames (long int nFrames)
long int	nFrames ()
void	setWordCount (unsigned long wordCount)
unsigned long	wordCount ()
void	setWordSize (unsigned long wordSize)
unsigned long	wordSize ()
void	setFakeErr (unsigned int fakeErr)
unsigned int	fakeErr ()
void	setInterrupts (bool interrupts)
bool	interrupts ()
void	setShowEpromState (bool showEpromState)
bool	showEpromState ()
bool	wrBlockMax ()
void	setWrBlockMax (bool wrBlockMax)
bool	rdBlockMax ()
void	setRdBlockMax (bool rdBlockMax)
void	setPrintout (bool printout)
bool	printout ()
Public Member Functions inherited from Interface
	Interface ()
	Standard constructor. More...
virtual	~Interface ()
	Destructor. More...
Public Member Functions inherited from Element
	Element ()
	Standard constructor. More...
virtual	~Element ()
	Destructor. More...
void	recursiveInitElement ()
void	recursiveInitCommunications ()
StatusCode	setConnection (Hierarchy *)
Hierarchy *	connection ()
Public Member Functions inherited from Hierarchy
	Hierarchy ()
	Standard constructor. More...
virtual	~Hierarchy ()
	Destructor. More...
void	clear ()
void	setParent (Hierarchy *parent)
Hierarchy *	parent ()
Hierarchy *	parent (std::string)
Hierarchy *	origin ()
virtual void	addChild (Hierarchy *element)
std::vector< Hierarchy * >	children ()
Hierarchy *	child (std::string)
Hierarchy *	childTyped (std::string)
unsigned long	numberOfChildren ()
bool	hasChildren ()
void	delChild (Hierarchy *)
void	delChild (std::string)
std::string	path (std::string=std::string(""))
std::string	pathTyped (std::string=std::string(""))
void	tree (std::string indent=std::string(""))
void	tree ()
Public Member Functions inherited from Object
	Object ()
	Standard constructor. More...
virtual	~Object ()
	Destructor. More...
std::string	name () const
std::string	type ()
unsigned char	id ()
std::string	title ()
void	msgSvc (int level, std::string msg, std::string name)
void	msg (std::string mymsg)
void	verbose (std::string mymsg)
void	debug (std::string mymsg)
void	info (std::string mymsg)
void	warning (std::string mymsg)
void	error (std::string mymsg)
void	fatal (std::string mymsg)
void	msg (std::string mymsg, std::string name)
void	verbose (std::string mymsg, std::string name)
void	debug (std::string mymsg, std::string name)
void	info (std::string mymsg, std::string name)
void	warning (std::string mymsg, std::string name)
void	error (std::string mymsg, std::string name)
void	fatal (std::string mymsg, std::string name)
void	setName (std::string name)
void	setType (std::string type)
void	setId (unsigned char id)
void	setTitle (std::string title)
void	setDllName (std::string dllName)
std::string	dllName ()
Public Member Functions inherited from Attrib
	Attrib ()
	Standard constructor. More...
virtual	~Attrib ()
	Destructor. More...
bool	is (int attribut)
void	add (int attribut)
void	remove (int attribut)
std::string	attributs ()

Private Attributes
int	m_usbId
std::string	m_serialNum
std::string	m_deviceDesc
unsigned char	m_latencyTimer
int	m_txTimeOut
int	m_rxTimeOut
int	m_txBuffer
int	m_rxBuffer
long int	m_nFrames
unsigned long	m_wordCount
unsigned long	m_wordSize
unsigned int	m_fakeErr
bool	m_interrupts
bool	m_showEpromState
bool	m_printout
int	m_rdBlockMax
int	m_wrBlockMax

Additional Inherited Members
Protected Attributes inherited from Element
Hierarchy *	m_connection
Protected Attributes inherited from Attrib
std::string	m_attribString [10]

Detailed Description

Class to describe general electronics object

Author

Frederic Machefert

Date

2004-01-18

Definition at line 40 of file UsbFTInterface.h.

Member Typedef Documentation

U16

typedef unsigned short UsbFTInterface::U16

Definition at line 43 of file UsbFTInterface.h.

U32

typedef unsigned long UsbFTInterface::U32

Definition at line 42 of file UsbFTInterface.h.

U8

typedef unsigned char UsbFTInterface::U8

Definition at line 44 of file UsbFTInterface.h.

Member Enumeration Documentation

IOMode

enum UsbFTInterface::IOMode

Enumerator
USB_IORead
USB_IOWrite
USB_IOReadWrite
USB_WriteReadBurst
USB_IOExtebdedRead

Definition at line 53 of file UsbFTInterface.h.

    {
      USB_IORead,
      USB_IOWrite,
      USB_IOReadWrite,
      USB_WriteReadBurst,
      USB_IOExtebdedRead
    };

WordSize

enum UsbFTInterface::WordSize

Enumerator
WS_Byte
WS_Word
WS_DWord

Definition at line 46 of file UsbFTInterface.h.

    {
      WS_Byte=1,
      WS_Word,
      WS_DWord
    };

Constructor & Destructor Documentation

UsbFTInterface()

UsbFTInterface::UsbFTInterface

(

)

Definition at line 19 of file UsbFTInterface.cpp.

References Object::info(), Object::setName(), and Object::setType().

                                 : 
  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);
}

~UsbFTInterface()

virtual UsbFTInterface::~UsbFTInterface ( )

inlinevirtual

Definition at line 63 of file UsbFTInterface.h.

References close().

                            {
    close();
  } //< Destructor

Member Function Documentation

close()

void UsbFTInterface::close

(

)

Close the usb device

Definition at line 802 of file UsbFTInterface.cpp.

References CloseUsbDevice(), Object::info(), itos(), m_usbId, and Object::name().

Referenced by BOOST_PYTHON_MODULE(), help(), init(), reset(), and ~UsbFTInterface().

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

deviceDesc()

std::string UsbFTInterface::deviceDesc ( )

inline

Get accessor to member m_deviceDesc

Returns

the current value of m_deviceDesc

Definition at line 272 of file UsbFTInterface.h.

References m_deviceDesc.

Referenced by BOOST_PYTHON_MODULE(), and setDeviceDesc().

                          {
    return m_deviceDesc;
  }

fakeErr()

unsigned int UsbFTInterface::fakeErr ( )

inline

Get accessor to member m_fakeErr

Returns

the current value of m_fakeErr

Definition at line 409 of file UsbFTInterface.h.

References m_fakeErr.

Referenced by setFakeErr().

                          {
    return m_fakeErr;
  }

help()

virtual void UsbFTInterface::help ( )

inlinevirtual

printout help for the element

Implements Interface.

Definition at line 71 of file UsbFTInterface.h.

References close(), Object::info(), init(), and Object::name().

{ info("UsbFTInterface "+name()+". No help.","UsbFTInterface::help"); };

init()

StatusCode UsbFTInterface::init ( )

virtual

init the component

Returns

void

Implements Interface.

Definition at line 47 of file UsbFTInterface.cpp.

References close(), Object::error(), Object::fatal(), FT_OK, GetDeviceDesc(), GetDeviceSerNum(), Object::info(), itos(), m_deviceDesc, m_interrupts, m_latencyTimer, m_rxBuffer, m_rxTimeOut, m_serialNum, m_txBuffer, m_txTimeOut, m_usbId, Object::name(), OpenUsbDevice(), StatusCode::SUCCESS, USB_FindDevices(), USB_GetLastError(), USB_GetLatencyTimer(), USB_Init(), USB_Perror(), USB_SetLatencyTimer(), USB_SetTimeouts(), USB_SetXferSize(), UsbSetIntCheckingState(), and wait().

Referenced by BOOST_PYTHON_MODULE(), help(), and reset().

                                  {
  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;
}

interrupts()

bool UsbFTInterface::interrupts ( )

inline

Get accessor to member m_interrupts

Returns

the current value of m_interrupts

Definition at line 425 of file UsbFTInterface.h.

References m_interrupts.

Referenced by setInterrupts().

                     {
    return m_interrupts;
  }

latencyTimer()

unsigned char UsbFTInterface::latencyTimer ( )

inline

Get accessor to member m_latTimer

Returns

the current value of m_latTimer

Definition at line 289 of file UsbFTInterface.h.

References m_latencyTimer, m_usbId, and USB_GetLatencyTimer().

Referenced by BOOST_PYTHON_MODULE(), and setLatencyTimer().

                                {
    USB_GetLatencyTimer(m_usbId,&m_latencyTimer);
    return m_latencyTimer;
  }

nFrames()

long int UsbFTInterface::nFrames ( )

inline

Get accessor to member m_nFrames

Returns

the current value of m_nFrames

Definition at line 360 of file UsbFTInterface.h.

References m_nFrames.

Referenced by setNFrames().

                      {
    return m_nFrames;
  }

printout()

bool UsbFTInterface::printout ( )

inline

Get accessor to member m_printout

Returns

the current value of m_printout

Definition at line 489 of file UsbFTInterface.h.

References m_printout.

Referenced by setPrintout().

                   {
    return m_printout;
  }

rdBlockMax()

bool UsbFTInterface::rdBlockMax ( )

inline

Get accessor to member m_rdBlockMax

Returns

the current value of m_rdBlockMax

Definition at line 465 of file UsbFTInterface.h.

References m_rdBlockMax.

Referenced by setRdBlockMax().

                     {
    return m_rdBlockMax;
  }

read() [1/2]

StatusCode UsbFTInterface::read ( IOdata *  io )

virtual

Implements Interface.

Definition at line 817 of file UsbFTInterface.cpp.

References IOdata::address(), IOdata::Byte, shell::data(), IOdata::dataU16(), IOdata::dataU32(), IOdata::dataU8(), IOdata::DWord, Object::error(), StatusCode::FAILURE, itos(), IOdata::length(), m_rdBlockMax, usbReadU16(), usbReadU32(), usbReadU8(), Object::verbose(), IOdata::Word, and IOdata::wordSize().

Referenced by BOOST_PYTHON_MODULE(), and update().

                                         {
  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;
}

read() [2/2]

StatusCode UsbFTInterface::read	(	unsigned long int	address,
		unsigned long int	nWords,
		boost::python::list &	obj
	)

Python interpreter wrapping for usb read

Definition at line 142 of file UsbFTInterface.cpp.

References shell::data(), Object::error(), StatusCode::FAILURE, itos(), m_wordSize, usbReadU16(), usbReadU32(), usbReadU8(), Object::verbose(), WS_Byte, WS_DWord, and WS_Word.

{
  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;
}

reset()

virtual void UsbFTInterface::reset ( )

inlinevirtual

Resets the Element so that is is in a standard and safe situation. Different from Element::init which configure the Element. Element::reset() is more an Emergency pull. It is often/usually called by the recursiveInitElement method at the start of the program.

Implements Interface.

Definition at line 91 of file UsbFTInterface.h.

References close(), Object::info(), init(), and Object::name().

                       {
    //    USB_ResetDevice(m_usbId);
    info("Reset of the Usb interface "+name(),"UsbFTInterface::reset");
    close();
    init();
  };

rxBuffer()

int UsbFTInterface::rxBuffer ( )

inline

Get accessor to member m_rxBuffer

Returns

the current value of m_rxBuffer

Definition at line 344 of file UsbFTInterface.h.

References m_rxBuffer.

Referenced by BOOST_PYTHON_MODULE(), and setBuffer().

                  {
    return m_rxBuffer;
  }

rxTimeOut()

int UsbFTInterface::rxTimeOut ( )

inline

Get accessor to member m_rxTimeOut

Returns

the current value of m_rxTimeOut

Definition at line 317 of file UsbFTInterface.h.

References m_rxTimeOut.

Referenced by BOOST_PYTHON_MODULE(), and setTimeOut().

                   {
    //    USB_SetTimeouts(m_usbId,&m_txTimeOut,&m_rxTimeOut)
    return m_rxTimeOut;
  }

serialNum()

std::string UsbFTInterface::serialNum ( )

inline

Get accessor to member m_serialNum

Returns

the current value of m_serialNum

Definition at line 256 of file UsbFTInterface.h.

References m_serialNum.

Referenced by BOOST_PYTHON_MODULE(), and setSerialNum().

                         {
    return m_serialNum;
  }

setBuffer()

void UsbFTInterface::setBuffer ( int  txBuffer, int  rxBuffer  )

inline

Set accessor to member m_txBuffer

Parameters

txBuffer

the new value for m_txBuffer

Definition at line 326 of file UsbFTInterface.h.

References m_rxBuffer, m_txBuffer, m_usbId, rxBuffer(), txBuffer(), and USB_SetXferSize().

Referenced by BOOST_PYTHON_MODULE().

                                              {
    m_txBuffer = txBuffer;
    m_rxBuffer = rxBuffer;
    USB_SetXferSize(m_usbId,m_txBuffer , m_rxBuffer);
  }

setDeviceDesc()

void UsbFTInterface::setDeviceDesc ( std::string  deviceDesc )

inline

Set accessor to member m_deviceDesc

Parameters

deviceDesc

the new value for m_deviceDesc

Definition at line 264 of file UsbFTInterface.h.

References deviceDesc(), and m_deviceDesc.

Referenced by BOOST_PYTHON_MODULE().

                                            {
    m_deviceDesc = deviceDesc;
  }

setFakeErr()

void UsbFTInterface::setFakeErr ( unsigned int  fakeErr )

inline

Set accessor to member m_fakeErr

Parameters

fakeErr

the new value for m_fakeErr

Definition at line 401 of file UsbFTInterface.h.

References fakeErr(), and m_fakeErr.

                                         {
    m_fakeErr = fakeErr;
  }

setInterrupts()

void UsbFTInterface::setInterrupts ( bool  interrupts )

inline

Set accessor to member m_interrupts

Parameters

interrupts

the new value for m_interrupts

Definition at line 417 of file UsbFTInterface.h.

References interrupts(), and m_interrupts.

                                       {
    m_interrupts = interrupts;
  }

setLatencyTimer()

void UsbFTInterface::setLatencyTimer ( unsigned char  latencyTimer )

inline

Set accessor to member m_latencyTimer

Parameters

latTimer

the new value for m_latencyTimer

Definition at line 280 of file UsbFTInterface.h.

References latencyTimer(), m_latencyTimer, m_usbId, and USB_SetLatencyTimer().

Referenced by BOOST_PYTHON_MODULE().

                                                    {
    m_latencyTimer = latencyTimer;
    USB_SetLatencyTimer(m_usbId, m_latencyTimer);
  }

setNFrames()

void UsbFTInterface::setNFrames ( long int  nFrames )

inline

Set accessor to member m_nFrames

Parameters

nFrames

the new value for m_nFrames

Definition at line 352 of file UsbFTInterface.h.

References m_nFrames, and nFrames().

                                     {
    m_nFrames = nFrames;
  }

setPrintout()

void UsbFTInterface::setPrintout ( bool  printout )

inline

Set accessor to member m_printout

Parameters

printout

the new value for m_printout

Definition at line 481 of file UsbFTInterface.h.

References m_printout, and printout().

                                   {
    m_printout = printout;
  }

setRdBlockMax()

void UsbFTInterface::setRdBlockMax ( bool  rdBlockMax )

inline

Set accessor to member m_rdBlockMax

Parameters

rdBlockMax

the new value for m_rdBlockMax

Definition at line 473 of file UsbFTInterface.h.

References m_rdBlockMax, and rdBlockMax().

                                       {
    m_rdBlockMax = rdBlockMax;
  }

setSerialNum()

void UsbFTInterface::setSerialNum ( std::string  serialNum )

inline

Set accessor to member m_serialNum

Parameters

serialNum

the new value for m_serialNum

Definition at line 248 of file UsbFTInterface.h.

References m_serialNum, and serialNum().

Referenced by BOOST_PYTHON_MODULE().

                                          {
    m_serialNum = serialNum;
  }

setShowEpromState()

void UsbFTInterface::setShowEpromState ( bool  showEpromState )

inline

Set accessor to member m_showEpromState

Parameters

showEpromState

the new value for m_showEpromState

Definition at line 433 of file UsbFTInterface.h.

References m_showEpromState, and showEpromState().

                                               {
    m_showEpromState = showEpromState;
  }

setTimeOut()

void UsbFTInterface::setTimeOut ( int  txTimeOut, int  rxTimeOut  )

inline

Set accessor to member m_txTimeOut

Parameters

txTimeOut

the new value for m_txTimeOut

Definition at line 298 of file UsbFTInterface.h.

References m_rxTimeOut, m_txTimeOut, m_usbId, rxTimeOut(), txTimeOut(), and USB_SetTimeouts().

Referenced by BOOST_PYTHON_MODULE().

                                                {
    m_txTimeOut = txTimeOut;
    m_rxTimeOut = rxTimeOut;
    USB_SetTimeouts(m_usbId, m_txTimeOut, m_rxTimeOut);
  }

setUsbId()

void UsbFTInterface::setUsbId ( int  usbId )

inline

Set accessor to member m_usbId

Parameters

usbId

the new value for m_usbId

Definition at line 232 of file UsbFTInterface.h.

References m_usbId, and usbId().

                            {
    m_usbId = usbId;
  }

setWordCount()

void UsbFTInterface::setWordCount ( unsigned long  wordCount )

inline

Set accessor to member m_wordCount

Parameters

wordCount

the new value for m_wordCount

Definition at line 369 of file UsbFTInterface.h.

References m_wordCount, and wordCount().

                                              {
    m_wordCount = wordCount;
  }

setWordSize()

void UsbFTInterface::setWordSize ( unsigned long  wordSize )

inline

Set accessor to member m_wordSize

Parameters

wordSize

the new value for m_wordSize

Definition at line 385 of file UsbFTInterface.h.

References m_wordSize, and wordSize().

Referenced by BOOST_PYTHON_MODULE(), and UsbFTInterfaceTest::execute().

                                            {
    m_wordSize = wordSize;
  }

setWrBlockMax()

void UsbFTInterface::setWrBlockMax ( bool  wrBlockMax )

inline

Set accessor to member m_wrBlockMax

Parameters

wrBlockMax

the new value for m_wrBlockMax

Definition at line 457 of file UsbFTInterface.h.

References m_wrBlockMax, and wrBlockMax().

                                       {
    m_wrBlockMax = wrBlockMax;
  }

showEpromState()

bool UsbFTInterface::showEpromState ( )

inline

Get accessor to member m_showEpromState

Returns

the current value of m_showEpromState

Definition at line 441 of file UsbFTInterface.h.

References m_showEpromState.

Referenced by setShowEpromState().

                         {
    return m_showEpromState;
  }  

txBuffer()

int UsbFTInterface::txBuffer ( )

inline

Get accessor to member m_txBuffer

Returns

the current value of m_txBuffer

Definition at line 336 of file UsbFTInterface.h.

References m_txBuffer.

Referenced by BOOST_PYTHON_MODULE(), and setBuffer().

                  {
    return m_txBuffer;
  }

txTimeOut()

int UsbFTInterface::txTimeOut ( )

inline

Get accessor to member m_txTimeOut

Returns

the current value of m_txTimeOut

Definition at line 308 of file UsbFTInterface.h.

References m_txTimeOut.

Referenced by BOOST_PYTHON_MODULE(), and setTimeOut().

                   {
    //    USB_SetTimeouts(m_usbId,&m_txTimeOut,&m_rxTimeOut)
    return m_txTimeOut;
  }  

update()

virtual void UsbFTInterface::update ( )

inlinevirtual

Update the Element configuration from the actual hardware

Implements Interface.

Definition at line 101 of file UsbFTInterface.h.

References Object::info(), Object::name(), read(), usbRead(), usbReadU16(), usbReadU32(), usbReadU8(), usbWrite(), usbWriteRead(), usbWriteU16(), usbWriteU32(), usbWriteU8(), and write().

Referenced by A3PE_BitFlip.A3PE_BitFlip::__init__(), Acquisition.Acquisition::__init__(), EmulateFE.EmulateFE::__init__(), AppFrame.AppFrame::deleteHardware(), ConfFrame.ConfFrame::onChange(), GraphFrame.GraphFrame::onChange(), CfgFrame.CfgFrame::onChange(), ConfFrame.ConfFrame::onEdit(), AppFrame.AppFrame::onLoad(), ConfFrame.ConfFrame::onReLoad(), GraphFrame.GraphFrame::onReLoad(), CfgFrame.CfgFrame::onReLoad(), and AppFrame.AppFrame::onReLoad().

                         {
    info("UsbFTInterface "+name()+". Nothing to do.","UsbFTInterface::update");
  };

usbId()

int UsbFTInterface::usbId ( )

inline

Get accessor to member m_usbId

Returns

the current value of m_usbId

Definition at line 240 of file UsbFTInterface.h.

References m_usbId.

Referenced by setUsbId().

               {
    return m_usbId;
  }

usbRead()

StatusCode UsbFTInterface::usbRead	(	unsigned long int	address,
		unsigned long int	nWords,
		std::vector< U32 > &	words
	)

Read usb in std::vector format – Do not use : Only supports U8 ! Write usb in std::vector<U8> format – Do not use yet : Only supports U8 ! Read usb in std::vector format – Do not use : Only supports U8 ! Write usb in std::vector<U16> format – Do not use yet : Only supports U8 ! Read usb in std::vector format – Do not use : Only supports U8 !

Definition at line 250 of file UsbFTInterface.cpp.

References shell::data(), Object::error(), StatusCode::FAILURE, itos(), m_wordSize, usbReadU16(), usbReadU32(), usbReadU8(), Object::verbose(), WS_Byte, WS_DWord, and WS_Word.

Referenced by UsbFTInterfaceTest::execute(), and update().

{
  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;
}

usbReadU16()

StatusCode UsbFTInterface::usbReadU16	(	unsigned long int	address,
		unsigned long int	nWords,
		unsigned short *	data
	)

Definition at line 482 of file UsbFTInterface.cpp.

References Object::error(), StatusCode::FAILURE, itos(), m_usbId, Object::name(), PrintFrameInfo(), StatusCode::SUCCESS, USB_GetLastError(), USB_INT_FRAME, USB_NoErr, UsbRd(), and Object::verbose().

Referenced by read(), update(), and usbRead().

                                                               {
  
  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;
}

usbReadU32()

StatusCode UsbFTInterface::usbReadU32	(	unsigned long int	address,
		unsigned long int	nWords,
		unsigned long *	data
	)

Definition at line 544 of file UsbFTInterface.cpp.

References Object::error(), StatusCode::FAILURE, itos(), m_usbId, Object::name(), PrintFrameInfo(), StatusCode::SUCCESS, USB_GetLastError(), USB_INT_FRAME, USB_NoErr, UsbRd(), and Object::verbose().

Referenced by read(), update(), and usbRead().

                                                              {
  
  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;
}

usbReadU8()

StatusCode UsbFTInterface::usbReadU8	(	unsigned long int	address,
		unsigned long int	nWords,
		unsigned char *	data
	)

Read usb (U8 format)

Definition at line 438 of file UsbFTInterface.cpp.

References Object::error(), StatusCode::FAILURE, itos(), m_usbId, Object::name(), PrintFrameInfo(), StatusCode::SUCCESS, USB_GetLastError(), USB_INT_FRAME, USB_NoErr, UsbRd(), and Object::verbose().

Referenced by read(), update(), and usbRead().

                                                             {
  
  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;
}

usbWrite()

StatusCode UsbFTInterface::usbWrite	(	unsigned long int	address,
		std::vector< U32 >	words
	)

Write usb in std::vector<U32> format – Do not use yet : Only supports U8 !

Definition at line 303 of file UsbFTInterface.cpp.

References shell::data(), Object::error(), StatusCode::FAILURE, itos(), m_wordSize, usbWriteU16(), usbWriteU32(), usbWriteU8(), Object::verbose(), WS_Byte, WS_DWord, and WS_Word.

Referenced by UsbFTInterfaceTest::execute(), and update().

{
  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;
}

usbWriteRead()

StatusCode UsbFTInterface::usbWriteRead	(	unsigned long int	address,
		std::vector< U8 >	dataWrite,
		std::vector< U8 > &	dataRead
	)

Write/Read std::vector<U8> format – Do not use yet : Only supports U8 !

Definition at line 725 of file UsbFTInterface.cpp.

References Object::error(), StatusCode::FAILURE, itos(), m_usbId, Object::name(), PrintFrameInfo(), StatusCode::SUCCESS, USB_GetLastError(), USB_INT_FRAME, USB_NoErr, UsbRd(), UsbWrt(), and Object::verbose().

Referenced by update().

                                                                    {
  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;  
}

usbWriteU16()

StatusCode UsbFTInterface::usbWriteU16	(	unsigned long int	address,
		unsigned long int	nWords,
		unsigned short *	data
	)

Write usb (U16 format)

Definition at line 641 of file UsbFTInterface.cpp.

References Object::error(), StatusCode::FAILURE, itos(), m_usbId, Object::name(), PrintFrameInfo(), StatusCode::SUCCESS, USB_GetLastError(), USB_INT_FRAME, USB_NoErr, UsbWrt(), and Object::verbose().

Referenced by update(), usbWrite(), and write().

                                                               {
  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;  
}

usbWriteU32()

StatusCode UsbFTInterface::usbWriteU32	(	unsigned long int	address,
		unsigned long int	nWords,
		unsigned long *	data
	)

Write usb (U32 format)

Definition at line 683 of file UsbFTInterface.cpp.

References Object::error(), StatusCode::FAILURE, itos(), m_usbId, Object::name(), PrintFrameInfo(), StatusCode::SUCCESS, USB_GetLastError(), USB_INT_FRAME, USB_NoErr, UsbWrt(), and Object::verbose().

Referenced by update(), usbWrite(), and write().

                                                              {
  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;  
}

usbWriteU8()

StatusCode UsbFTInterface::usbWriteU8	(	unsigned long int	address,
		unsigned long int	nWords,
		unsigned char *	data
	)

Write usb (U8 format)

Definition at line 599 of file UsbFTInterface.cpp.

References Object::error(), StatusCode::FAILURE, itos(), m_usbId, Object::name(), PrintFrameInfo(), StatusCode::SUCCESS, USB_GetLastError(), USB_INT_FRAME, USB_NoErr, UsbWrt(), and Object::verbose().

Referenced by update(), usbWrite(), and write().

                                                             {
  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;  
}

wordCount()

unsigned long UsbFTInterface::wordCount ( )

inline

Get accessor to member m_wordCount

Returns

the current value of m_wordCount

Definition at line 377 of file UsbFTInterface.h.

References m_wordCount.

Referenced by setWordCount().

                             {
    return m_wordCount;
  }

wordSize()

unsigned long UsbFTInterface::wordSize ( )

inline

Get accessor to member m_wordSize

Returns

the current value of m_wordSize

Definition at line 393 of file UsbFTInterface.h.

References m_wordSize.

Referenced by BOOST_PYTHON_MODULE(), and setWordSize().

                            {
    return m_wordSize;
  }  

wrBlockMax()

bool UsbFTInterface::wrBlockMax ( )

inline

Get accessor to member m_wrBlockMax

Returns

the current value of m_wrBlockMax

Definition at line 449 of file UsbFTInterface.h.

References m_wrBlockMax.

Referenced by setWrBlockMax().

                     {
    return m_wrBlockMax;
  }

write() [1/2]

StatusCode UsbFTInterface::write ( IOdata *  io )

virtual

Implements Interface.

Definition at line 871 of file UsbFTInterface.cpp.

References IOdata::address(), IOdata::Byte, shell::data(), IOdata::dataU16(), IOdata::dataU32(), IOdata::dataU8(), IOdata::DWord, Object::error(), StatusCode::FAILURE, itos(), IOdata::length(), m_wrBlockMax, usbWriteU16(), usbWriteU32(), usbWriteU8(), Object::verbose(), IOdata::Word, and IOdata::wordSize().

Referenced by BOOST_PYTHON_MODULE(), and update().

                                          {
  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;
}

write() [2/2]

StatusCode UsbFTInterface::write	(	unsigned long int	address,
		boost::python::list	obj
	)

Python interpreter wrapping for usb write

Definition at line 196 of file UsbFTInterface.cpp.

References shell::data(), Object::error(), StatusCode::FAILURE, itos(), m_wordSize, usbWriteU16(), usbWriteU32(), usbWriteU8(), Object::verbose(), WS_Byte, WS_DWord, and WS_Word.

{
  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;
}

Member Data Documentation

m_deviceDesc

std::string UsbFTInterface::m_deviceDesc

private

Definition at line 496 of file UsbFTInterface.h.

Referenced by deviceDesc(), init(), and setDeviceDesc().

m_fakeErr

unsigned int UsbFTInterface::m_fakeErr

private

Definition at line 505 of file UsbFTInterface.h.

Referenced by fakeErr(), and setFakeErr().

m_interrupts

bool UsbFTInterface::m_interrupts

private

Definition at line 506 of file UsbFTInterface.h.

Referenced by init(), interrupts(), and setInterrupts().

m_latencyTimer

unsigned char UsbFTInterface::m_latencyTimer

private

Definition at line 497 of file UsbFTInterface.h.

Referenced by init(), latencyTimer(), and setLatencyTimer().

m_nFrames

long int UsbFTInterface::m_nFrames

private

Definition at line 502 of file UsbFTInterface.h.

Referenced by nFrames(), and setNFrames().

m_printout

bool UsbFTInterface::m_printout

private

Definition at line 508 of file UsbFTInterface.h.

Referenced by printout(), and setPrintout().

m_rdBlockMax

int UsbFTInterface::m_rdBlockMax

private

Definition at line 509 of file UsbFTInterface.h.

Referenced by rdBlockMax(), read(), and setRdBlockMax().

m_rxBuffer

int UsbFTInterface::m_rxBuffer

private

Definition at line 501 of file UsbFTInterface.h.

Referenced by init(), rxBuffer(), and setBuffer().

m_rxTimeOut

int UsbFTInterface::m_rxTimeOut

private

Definition at line 499 of file UsbFTInterface.h.

Referenced by init(), rxTimeOut(), and setTimeOut().

m_serialNum

std::string UsbFTInterface::m_serialNum

private

Definition at line 495 of file UsbFTInterface.h.

Referenced by init(), serialNum(), and setSerialNum().

m_showEpromState

bool UsbFTInterface::m_showEpromState

private

Definition at line 507 of file UsbFTInterface.h.

Referenced by setShowEpromState(), and showEpromState().

m_txBuffer

int UsbFTInterface::m_txBuffer

private

Definition at line 500 of file UsbFTInterface.h.

Referenced by init(), setBuffer(), and txBuffer().

m_txTimeOut

int UsbFTInterface::m_txTimeOut

private

Definition at line 498 of file UsbFTInterface.h.

Referenced by init(), setTimeOut(), and txTimeOut().

m_usbId

int UsbFTInterface::m_usbId

private

Definition at line 494 of file UsbFTInterface.h.

Referenced by close(), init(), latencyTimer(), setBuffer(), setLatencyTimer(), setTimeOut(), setUsbId(), usbId(), usbReadU16(), usbReadU32(), usbReadU8(), usbWriteRead(), usbWriteU16(), usbWriteU32(), and usbWriteU8().

m_wordCount

unsigned long UsbFTInterface::m_wordCount

private

Definition at line 503 of file UsbFTInterface.h.

Referenced by setWordCount(), and wordCount().

m_wordSize

unsigned long UsbFTInterface::m_wordSize

private

Definition at line 504 of file UsbFTInterface.h.

Referenced by read(), setWordSize(), usbRead(), usbWrite(), wordSize(), and write().

m_wrBlockMax

int UsbFTInterface::m_wrBlockMax

private

Definition at line 510 of file UsbFTInterface.h.

Referenced by setWrBlockMax(), wrBlockMax(), and write().

---

The documentation for this class was generated from the following files:

• /home/eleclhcb/LHCb/lbcat-cmake/CatCaloProto40MHz/inc/UsbFTInterface.h
• /home/eleclhcb/LHCb/lbcat-cmake/CatCaloProto40MHz/src/UsbFTInterface.cpp