#include <include/UsbFTMLInterface.h>

Inheritance diagram for UsbFTMLInterface:

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
	UsbFTMLInterface ()

virtual	~UsbFTMLInterface ()

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 ()

void	resetMode ()

void	purgeBuffers ()

void	setSynchronousMode ()

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 41 of file UsbFTMLInterface.h.

Member Typedef Documentation

◆ U16

typedef unsigned short UsbFTMLInterface::U16

Definition at line 44 of file UsbFTMLInterface.h.

◆ U32

typedef unsigned long UsbFTMLInterface::U32

Definition at line 43 of file UsbFTMLInterface.h.

◆ U8

typedef unsigned char UsbFTMLInterface::U8

Definition at line 45 of file UsbFTMLInterface.h.

Member Enumeration Documentation

◆ IOMode

enum UsbFTMLInterface::IOMode

Enumerator
USB_IORead
USB_IOWrite
USB_IOReadWrite
USB_WriteReadBurst
USB_IOExtebdedRead

Definition at line 54 of file UsbFTMLInterface.h.

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

◆ WordSize

enum UsbFTMLInterface::WordSize

Enumerator
WS_Byte
WS_Word
WS_DWord

Definition at line 47 of file UsbFTMLInterface.h.

     {
       WS_Byte=1,
       WS_Word,
       WS_DWord
     };

Constructor & Destructor Documentation

◆ UsbFTMLInterface()

UsbFTMLInterface::UsbFTMLInterface ( )

Definition at line 19 of file UsbFTMLInterface.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(65536),
   m_wrBlockMax(65536),
   m_interrupts(true),
   m_showEpromState(false),
   m_printout(false)
 { 
   setName("usb");
   setType("UsbFTMLInterface");
   info("Todo : time efficiency by creating the buffer once for all ?");
   //  add(Attrib::INTERFACE);
 }

◆ ~UsbFTMLInterface()

virtual UsbFTMLInterface::~UsbFTMLInterface ( )

inlinevirtual

Definition at line 64 of file UsbFTMLInterface.h.

References close().

                               {
     close();
   } //< Destructor

Member Function Documentation

◆ close()

void UsbFTMLInterface::close ( )

Close the usb device

Definition at line 727 of file UsbFTMLInterface.cpp.

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

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

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

◆ deviceDesc()

std::string UsbFTMLInterface::deviceDesc ( )

inline

Get accessor to member m_deviceDesc

Returns: the current value of m_deviceDesc

Definition at line 273 of file UsbFTMLInterface.h.

References m_deviceDesc.

Referenced by BOOST_PYTHON_MODULE(), and setDeviceDesc().

                           {
     return m_deviceDesc;
   }

◆ fakeErr()

unsigned int UsbFTMLInterface::fakeErr ( )

inline

Get accessor to member m_fakeErr

Returns: the current value of m_fakeErr

Definition at line 410 of file UsbFTMLInterface.h.

References m_fakeErr.

Referenced by setFakeErr().

                           {
     return m_fakeErr;
   }

◆ help()

virtual void UsbFTMLInterface::help ( )

inlinevirtual

printout help for the element

Implements Interface.

Definition at line 71 of file UsbFTMLInterface.h.

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

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

Object::info

void info(std::string mymsg)

Definition: Object.h:38

Object::name

std::string name() const

Definition: Object.h:28

◆ init()

StatusCode UsbFTMLInterface::init ( )

virtual

init the component

Returns: void

Implements Interface.

Definition at line 47 of file UsbFTMLInterface.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_PurgeBuffers(), USB_ResetDevice(), USB_ResetMode(), USB_SetLatencyTimer(), USB_SetSynchronousMode(), USB_SetTimeouts(), USB_SetXferSize(), UsbSetIntCheckingState(), and wait().

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

                                     {
   unsigned char msecs=0;
   char desc[256];
   char serial[64];      
 
   strcpy(desc  , m_deviceDesc.c_str());
   strcpy(serial, m_serialNum.c_str());  
 
   info("Start USB device initialisation.","UsbFTMLInterface::init");
   if (m_usbId>0)
   {
     error("Usb device already open.","UsbFTMLInterface::init");    
     close();
   }
   if (!USB_FindDevices(desc))
   {
     USB_Perror(USB_GetLastError());
     error("Cannot find Usb Device "+name()+" with device description "+
           m_deviceDesc,"UsbFTMLInterface::init");
   }
   else
     {  
     info("Device with device description "+m_deviceDesc+" found.","UsbFTMLInterface::init");
     info("Try to open device with serial number "+m_serialNum+".","UsbFTMLInterface::init");
     m_usbId=OpenUsbDevice(serial);
     if (m_usbId<0)
     {
       error("Could not find device with serial number "+m_serialNum,"UsbFTMLInterface::init");
       if (GetDeviceSerNum(serial,0)!=FT_OK)
       {
         error("Serial number do not match first device found.","UsbFTMLInterface::init");
       }
       else
       {
         info("Extracted serial number "+std::string(serial)+".","UsbFTMLInterface::init");
         if (GetDeviceDesc(desc,0)!=FT_OK)
         {
           USB_Perror(USB_GetLastError());  
           fatal("Device description do not match first device either. Abort",
                 "UsbFTMLInterface::init");
         }
         else
         {
           info("Device found. Extracted description "+std::string(desc)+".",
                "UsbFTMLInterface::init");
           m_usbId=OpenUsbDevice(serial);
           if (m_usbId<0)
           {
             USB_Perror(USB_GetLastError());  
             fatal("Cannot open device. Abort.","UsbFTMLInterface::init"); 
           }          
         }
       }
     }
     
     info("Device opened with UsbId "+itos(m_usbId)+".","UsbFTMLInterface::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.",
             "UsbFTMLInterface::init");
     }
 
     info("Usb device initialization done.","UsbFTMLInterface::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_SetSynchronousMode(m_usbId, 100);
     USB_ResetMode(m_usbId);
     //   UsbSetMaxLayer(m_usbId,1);
   }
   USB_PurgeBuffers(m_usbId); // PurgeBuffers après le reset cause une erreur lors de la première lecture effectuée via le port usb.
   USB_ResetDevice(m_usbId);
   wait(1000);
   USB_PurgeBuffers(m_usbId); 
   return StatusCode::SUCCESS;
 }

◆ interrupts()

bool UsbFTMLInterface::interrupts ( )

inline

Get accessor to member m_interrupts

Returns: the current value of m_interrupts

Definition at line 426 of file UsbFTMLInterface.h.

References m_interrupts.

Referenced by setInterrupts().

                      {
     return m_interrupts;
   }

◆ latencyTimer()

unsigned char UsbFTMLInterface::latencyTimer ( )

inline

Get accessor to member m_latTimer

Returns: the current value of m_latTimer

Definition at line 290 of file UsbFTMLInterface.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 UsbFTMLInterface::nFrames ( )

inline

Get accessor to member m_nFrames

Returns: the current value of m_nFrames

Definition at line 361 of file UsbFTMLInterface.h.

References m_nFrames.

Referenced by setNFrames().

                       {
     return m_nFrames;
   }

◆ printout()

bool UsbFTMLInterface::printout ( )

inline

Get accessor to member m_printout

Returns: the current value of m_printout

Definition at line 490 of file UsbFTMLInterface.h.

References m_printout.

Referenced by setPrintout().

                    {
     return m_printout;
   }

◆ purgeBuffers()

void UsbFTMLInterface::purgeBuffers ( )

inline

Definition at line 496 of file UsbFTMLInterface.h.

References m_usbId, and USB_PurgeBuffers().

Referenced by BOOST_PYTHON_MODULE().

496 {USB_PurgeBuffers(m_usbId);}

USB_PurgeBuffers

LALUSB_API BOOL _cstmcall USB_PurgeBuffers(int id)

UsbFTMLInterface::m_usbId

int m_usbId

Definition: UsbFTMLInterface.h:501

◆ rdBlockMax()

bool UsbFTMLInterface::rdBlockMax ( )

inline

Get accessor to member m_rdBlockMax

Returns: the current value of m_rdBlockMax

Definition at line 466 of file UsbFTMLInterface.h.

References m_rdBlockMax.

Referenced by setRdBlockMax().

                      {
     return m_rdBlockMax;
   }

◆ read() [1/2]

StatusCode UsbFTMLInterface::read ( IOdata * io )

virtual

Implements Interface.

Definition at line 739 of file UsbFTMLInterface.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),
               "UsbFTMLInterface::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),
                   "UsbFTMLInterface::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),
                   "UsbFTMLInterface::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.","UsbFTMLInterface::read");
     status=StatusCode::FAILURE;
   }
   return status;
 }

◆ read() [2/2]

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

Python interpreter wrapping for usb read

Definition at line 137 of file UsbFTMLInterface.cpp.

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

 {
   StatusCode status;
   verbose("USB Reading :","UsbFTMLInterface::read");
   switch (m_wordSize)
   {
   case WS_Byte:
     {  
       unsigned char *data=new unsigned char[nWords];
       status = usbReadU8( address, nWords, data);
       info("Data format is "+itos(WS_Byte),"UsbFTMLInterface::read");
       for(unsigned int i = 0; i < nWords; i++){
         verbose("wd "+itos(i)+" "+itos(data[i]),"UsbFTMLInterface::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),"UsbFTMLInterface::read");
       for(unsigned int i = 0; i < nWords; i++){
         verbose("wd "+itos(i)+" "+itos(data[i]),"UsbFTMLInterface::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),"UsbFTMLInterface::read");
       for(unsigned int i = 0; i < nWords; i++){
         verbose("wd "+itos(i)+" "+itos(data[i]),"UsbFTMLInterface::read");
         obj.append(data[i]);
       };
       delete data;
     }
     break;    
   default:
     error("Wrong word size.","UsbFTMLInterface::read");
     status=StatusCode::FAILURE;
   }
   return status;
 }

◆ reset()

virtual void UsbFTMLInterface::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 UsbFTMLInterface.h.

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

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

◆ resetMode()

void UsbFTMLInterface::resetMode ( )

inline

Definition at line 494 of file UsbFTMLInterface.h.

References m_usbId, and USB_ResetMode().

Referenced by BOOST_PYTHON_MODULE().

494 {USB_ResetMode(m_usbId);}

USB_ResetMode

LALUSB_API BOOL _cstmcall USB_ResetMode(int id)

UsbFTMLInterface::m_usbId

int m_usbId

Definition: UsbFTMLInterface.h:501

◆ rxBuffer()

int UsbFTMLInterface::rxBuffer ( )

inline

Get accessor to member m_rxBuffer

Returns: the current value of m_rxBuffer

Definition at line 345 of file UsbFTMLInterface.h.

References m_rxBuffer.

Referenced by BOOST_PYTHON_MODULE(), and setBuffer().

                   {
     return m_rxBuffer;
   }

◆ rxTimeOut()

int UsbFTMLInterface::rxTimeOut ( )

inline

Get accessor to member m_rxTimeOut

Returns: the current value of m_rxTimeOut

Definition at line 318 of file UsbFTMLInterface.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 UsbFTMLInterface::serialNum ( )

inline

Get accessor to member m_serialNum

Returns: the current value of m_serialNum

Definition at line 257 of file UsbFTMLInterface.h.

References m_serialNum.

Referenced by BOOST_PYTHON_MODULE(), and setSerialNum().

                          {
     return m_serialNum;
   }

◆ setBuffer()

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

inline

Set accessor to member m_txBuffer

Parameters

txBuffer the new value for m_txBuffer

Definition at line 327 of file UsbFTMLInterface.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 UsbFTMLInterface::setDeviceDesc ( std::string deviceDesc )

inline

Set accessor to member m_deviceDesc

Parameters

deviceDesc the new value for m_deviceDesc

Definition at line 265 of file UsbFTMLInterface.h.

References deviceDesc(), and m_deviceDesc.

Referenced by BOOST_PYTHON_MODULE().

                                             {
     m_deviceDesc = deviceDesc;
   }

◆ setFakeErr()

void UsbFTMLInterface::setFakeErr ( unsigned int fakeErr )

inline

Set accessor to member m_fakeErr

Parameters

fakeErr the new value for m_fakeErr

Definition at line 402 of file UsbFTMLInterface.h.

References fakeErr(), and m_fakeErr.

                                          {
     m_fakeErr = fakeErr;
   }

◆ setInterrupts()

void UsbFTMLInterface::setInterrupts ( bool interrupts )

inline

Set accessor to member m_interrupts

Parameters

interrupts the new value for m_interrupts

Definition at line 418 of file UsbFTMLInterface.h.

References interrupts(), and m_interrupts.

                                        {
     m_interrupts = interrupts;
   }

◆ setLatencyTimer()

void UsbFTMLInterface::setLatencyTimer ( unsigned char latencyTimer )

inline

Set accessor to member m_latencyTimer

Parameters

latTimer the new value for m_latencyTimer

Definition at line 281 of file UsbFTMLInterface.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 UsbFTMLInterface::setNFrames ( long int nFrames )

inline

Set accessor to member m_nFrames

Parameters

nFrames the new value for m_nFrames

Definition at line 353 of file UsbFTMLInterface.h.

References m_nFrames, and nFrames().

                                      {
     m_nFrames = nFrames;
   }

◆ setPrintout()

void UsbFTMLInterface::setPrintout ( bool printout )

inline

Set accessor to member m_printout

Parameters

printout the new value for m_printout

Definition at line 482 of file UsbFTMLInterface.h.

References m_printout, and printout().

                                    {
     m_printout = printout;
   }

◆ setRdBlockMax()

void UsbFTMLInterface::setRdBlockMax ( bool rdBlockMax )

inline

Set accessor to member m_rdBlockMax

Parameters

rdBlockMax the new value for m_rdBlockMax

Definition at line 474 of file UsbFTMLInterface.h.

References m_rdBlockMax, and rdBlockMax().

                                        {
     m_rdBlockMax = rdBlockMax;
   }

◆ setSerialNum()

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

inline

Set accessor to member m_serialNum

Parameters

serialNum the new value for m_serialNum

Definition at line 249 of file UsbFTMLInterface.h.

References m_serialNum, and serialNum().

Referenced by BOOST_PYTHON_MODULE().

                                           {
     m_serialNum = serialNum;
   }

◆ setShowEpromState()

void UsbFTMLInterface::setShowEpromState ( bool showEpromState )

inline

Set accessor to member m_showEpromState

Parameters

showEpromState the new value for m_showEpromState

Definition at line 434 of file UsbFTMLInterface.h.

References m_showEpromState, and showEpromState().

                                                {
     m_showEpromState = showEpromState;
   }

◆ setSynchronousMode()

void UsbFTMLInterface::setSynchronousMode ( )

inline

Definition at line 498 of file UsbFTMLInterface.h.

References m_usbId, and USB_SetSynchronousMode().

Referenced by BOOST_PYTHON_MODULE().

498 {USB_SetSynchronousMode(m_usbId, 100);}

UsbFTMLInterface::m_usbId

int m_usbId

Definition: UsbFTMLInterface.h:501

USB_SetSynchronousMode

LALUSB_API BOOL _cstmcall USB_SetSynchronousMode(int id, int sleep_time)

◆ setTimeOut()

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

inline

Set accessor to member m_txTimeOut

Parameters

txTimeOut the new value for m_txTimeOut

Definition at line 299 of file UsbFTMLInterface.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 UsbFTMLInterface::setUsbId ( int usbId )

inline

Set accessor to member m_usbId

Parameters

usbId the new value for m_usbId

Definition at line 232 of file UsbFTMLInterface.h.

References m_usbId, and usbId().

                             {
     m_usbId = usbId;
   }

◆ setWordCount()

void UsbFTMLInterface::setWordCount ( unsigned long wordCount )

inline

Set accessor to member m_wordCount

Parameters

wordCount the new value for m_wordCount

Definition at line 370 of file UsbFTMLInterface.h.

References m_wordCount, and wordCount().

                                               {
     m_wordCount = wordCount;
   }

◆ setWordSize()

void UsbFTMLInterface::setWordSize ( unsigned long wordSize )

inline

Set accessor to member m_wordSize

Parameters

wordSize the new value for m_wordSize

Definition at line 386 of file UsbFTMLInterface.h.

References m_wordSize, and wordSize().

Referenced by BOOST_PYTHON_MODULE().

                                             {
     m_wordSize = wordSize;
   }

◆ setWrBlockMax()

void UsbFTMLInterface::setWrBlockMax ( bool wrBlockMax )

inline

Set accessor to member m_wrBlockMax

Parameters

wrBlockMax the new value for m_wrBlockMax

Definition at line 458 of file UsbFTMLInterface.h.

References m_wrBlockMax, and wrBlockMax().

                                        {
     m_wrBlockMax = wrBlockMax;
   }

◆ showEpromState()

bool UsbFTMLInterface::showEpromState ( )

inline

Get accessor to member m_showEpromState

Returns: the current value of m_showEpromState

Definition at line 442 of file UsbFTMLInterface.h.

References m_showEpromState.

Referenced by setShowEpromState().

                          {
     return m_showEpromState;
   }  

◆ txBuffer()

int UsbFTMLInterface::txBuffer ( )

inline

Get accessor to member m_txBuffer

Returns: the current value of m_txBuffer

Definition at line 337 of file UsbFTMLInterface.h.

References m_txBuffer.

Referenced by BOOST_PYTHON_MODULE(), and setBuffer().

                   {
     return m_txBuffer;
   }

◆ txTimeOut()

int UsbFTMLInterface::txTimeOut ( )

inline

Get accessor to member m_txTimeOut

Returns: the current value of m_txTimeOut

Definition at line 309 of file UsbFTMLInterface.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 UsbFTMLInterface::update ( )

inlinevirtual

Update the Element configuration from the actual hardware

Implements Interface.

Definition at line 101 of file UsbFTMLInterface.h.

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

Referenced by 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("UsbFTMLInterface "+name()+". Nothing to do.","UsbFTMLInterface::update");
   };

◆ usbId()

int UsbFTMLInterface::usbId ( )

inline

Get accessor to member m_usbId

Returns: the current value of m_usbId

Definition at line 240 of file UsbFTMLInterface.h.

References m_usbId.

Referenced by setUsbId().

                {
     return m_usbId;
   }

◆ usbRead()

StatusCode UsbFTMLInterface::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 245 of file UsbFTMLInterface.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 update().

 {
   StatusCode status;
   verbose("USB Reading :","UsbFTMLInterface::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]),"UsbFTMLInterface::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]),"UsbFTMLInterface::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]),"UsbFTMLInterface::usbRead");
         words.push_back(data[i]);
       };
       delete data;
     }
     break;
   default:
     error("Wrong word size.","UsbFTMLInterface::read");
     status=StatusCode::FAILURE;
   }
   return status;
 }

◆ usbReadU16()

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

Definition at line 397 of file UsbFTMLInterface.cpp.

References Object::error(), StatusCode::FAILURE, itos(), m_usbId, Object::name(), Hierarchy::path(), PrintFrameInfo(), StatusCode::SUCCESS, USB_GetLastError(), USB_INT_FRAME, USB_NoErr, UsbReadML(), 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");
 
   int path  = -1;
   bytecount=UsbReadML(m_usbId, &path, 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(),
             "UsbFTMLInterface::usbReadU16");
     return StatusCode::SUCCESS;
   }
 
   if (bytecount<0){
     rdErr=USB_GetLastError();
     error("USB error number "+itos(rdErr)+" - USB_INT_FRAME="+itos(USB_INT_FRAME),
             " UsbFTMLInterface::usbReadU16");
     if (rdErr==USB_INT_FRAME){
       PrintFrameInfo();
     } 
     return StatusCode::FAILURE;
   }
   
   if (0==bytecount){
     error(" O Byte read from USB interface "+name()+".",
           "UsbFTMLInterface::usbReadU16");
     return StatusCode::FAILURE;
   }
 
   if (nData!=bytecount){
     error(itos(bytecount)+" byte(s) read from USB interface "+name()+
             " out of "+itos(nData)+" bytes expected.",
           "UsbFTMLInterface::usbReadU16");
     return StatusCode::FAILURE;    
   }
 
   return StatusCode::SUCCESS;
 }

◆ usbReadU32()

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

Definition at line 462 of file UsbFTMLInterface.cpp.

References Object::error(), StatusCode::FAILURE, itos(), m_usbId, Object::name(), Hierarchy::path(), PrintFrameInfo(), StatusCode::SUCCESS, USB_GetLastError(), USB_INT_FRAME, USB_NoErr, UsbReadML(), 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];
 
   int path = -1;
   
   bytecount=UsbReadML(m_usbId, &path, 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(),
             "UsbFTMLInterface::usbRead");
     return StatusCode::SUCCESS;
   }
 
   if (bytecount<0){
     rdErr=USB_GetLastError();
     error("USB error number "+itos(rdErr)+" - USB_INT_FRAME="+itos(USB_INT_FRAME),
             " UsbFTMLInterface::usbRead32");
     if (rdErr==USB_INT_FRAME){
       PrintFrameInfo();
     } 
     return StatusCode::FAILURE;
   }
   
   if (0==bytecount){
     error(" O Byte read from USB interface "+name()+".","UsbFTMLInterface::usbRead32");
     return StatusCode::FAILURE;
   }
 
   if (nData!=bytecount){
     error(itos(bytecount)+" byte(s) read from USB interface "+name()+
             " out of "+itos(nData)+" bytes expected.","UsbFTMLInterface::usbRead32");
     return StatusCode::FAILURE;    
   }
   return StatusCode::SUCCESS;
 }

◆ usbReadU8()

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

Read usb (U8 format)

Definition at line 351 of file UsbFTMLInterface.cpp.

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

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

                                                              {
   
   USB_Error rdErr=USB_NoErr;
   long int bytecount=0;
 
   long int nData = (long int)(nWords);
 
   int path = -1;
   
   bytecount=UsbReadML(m_usbId, &path, address, data, nData);
 
   if (nData==bytecount){
     verbose(itos(bytecount)+" bytes read from USB Interface "+name(),
             "UsbFTMLInterface::usbRead8");
     return StatusCode::SUCCESS;
   }
 
   if (bytecount<0){
     rdErr=USB_GetLastError();
     error("USB error number "+itos(rdErr)+" - USB_INT_FRAME="+itos(USB_INT_FRAME),
             " UsbFTMLInterface::usbRead8");
     if (rdErr==USB_INT_FRAME){
       PrintFrameInfo();
     } 
     return StatusCode::FAILURE;
   }
   
   if (0==bytecount){
     error(" O Byte read from USB interface "+name()+".","UsbFTMLInterface::usbRead8");
     return StatusCode::FAILURE;
   }
 
   if (nData!=bytecount){
     error(itos(bytecount)+" byte(s) read from USB interface "+name()+
             " out of "+itos(nData)+" bytes expected.","UsbFTMLInterface::usbRead8");
     return StatusCode::FAILURE;    
   }
 
   return StatusCode::SUCCESS;
 }

◆ usbWrite()

StatusCode UsbFTMLInterface::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 298 of file UsbFTMLInterface.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 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),"UsbFTMLInterface::usbWrite");
         verbose("wd "+itos(i)+" "+itos(data[i]),"UsbFTMLInterface::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),"UsbFTMLInterface::usbWrite");
         verbose("wd "+itos(i)+" "+itos(data[i]),"UsbFTMLInterface::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),"UsbFTMLInterface::usbWrite");
         verbose("wd "+itos(i)+" "+itos(data[i]) ,"UsbFTMLInterface::usbWrite");
       }
       status = usbWriteU32(address, nWords, data);
       delete data;
     }
     break;
   default:
     error("Wrong word size.","read");
     status=StatusCode::FAILURE;
   }
   return status;
 }

◆ usbWriteRead()

StatusCode UsbFTMLInterface::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 648 of file UsbFTMLInterface.cpp.

References Object::error(), StatusCode::FAILURE, itos(), m_usbId, Object::name(), Hierarchy::path(), PrintFrameInfo(), StatusCode::SUCCESS, USB_GetLastError(), USB_INT_FRAME, USB_NoErr, UsbReadML(), UsbWrtML(), 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]);
 
   int path = -1;
   bytecount=UsbWrtML(m_usbId, &path, address, bufWr, nData);
 
   if (bytecount<0){
     wrErr=USB_GetLastError();
     error("USB error number "+itos(wrErr)+" - USB_INT_FRAME="+itos(USB_INT_FRAME),
             " UsbFTMLInterface::usbWriteRead");
     if (wrErr==USB_INT_FRAME){
       PrintFrameInfo();
     } 
     return StatusCode::FAILURE;
   }
 
   if (nData==bytecount){
     verbose(itos(bytecount)+" bytes written on USB Interface "+name(),
             "UsbFTMLInterface::usbWriteRead");
 
     int path = -1;
     bytecount=UsbReadML(m_usbId, &path, address, bufRd, nData);
 
     if (nData==bytecount){
       verbose(itos(bytecount)+" bytes read from USB Interface "+name(),
               "UsbFTMLInterface::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),
               " UsbFTMLInterface::usbWriteRead");
       if (rdErr==USB_INT_FRAME){
         PrintFrameInfo();
       } 
       return StatusCode::FAILURE;
     }
   
     if (0==bytecount){
       error(" O Byte read from USB interface "+name()+".","UsbFTMLInterface::usbRead");
       return StatusCode::FAILURE;
     }
 
     if (nData!=bytecount){
       error(itos(bytecount)+" byte(s) read from USB interface "+name()+
               " out of "+itos(nData)+" bytes expected.","UsbFTMLInterface::usbRead");
       return StatusCode::FAILURE;    
     } 
   }
   
   
   if (0==bytecount){
     error(" O Byte written n USB interface "+name()+".","UsbFTMLInterface::usbWrite");
     return StatusCode::FAILURE;
   }
 
   if (nData!=bytecount){
     error(itos(bytecount)+" byte(s) written USB interface "+name()+
             " out of "+itos(nData)+" bytes to be sent.","UsbFTMLInterface::usbWrite");
     return StatusCode::FAILURE;    
   }
 
   return StatusCode::SUCCESS;    return StatusCode::SUCCESS;  
 }

◆ usbWriteU16()

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

Write usb (U16 format)

Definition at line 562 of file UsbFTMLInterface.cpp.

References Object::error(), StatusCode::FAILURE, itos(), m_usbId, Object::name(), Hierarchy::path(), PrintFrameInfo(), StatusCode::SUCCESS, USB_GetLastError(), USB_INT_FRAME, USB_NoErr, UsbWrtML(), 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);
 
   int path = -1;
   bytecount=UsbWrtML(m_usbId, &path, address, data, nData);
 
   if (bytecount<0){
     wrErr=USB_GetLastError();
     error("USB error number "+itos(wrErr)+" - USB_INT_FRAME="+itos(USB_INT_FRAME),
             "UsbFTMLInterface::usbWrite16");
     if (wrErr==USB_INT_FRAME){
       PrintFrameInfo();
     } 
     return StatusCode::FAILURE;
   }
 
   if (nData==bytecount){
     verbose(itos(bytecount)+" bytes written on USB Interface "+name(),
             "UsbFTMLInterface::usbWrite16");
   }
   
   if (0==bytecount){
     error(" O Byte written on USB interface "+name()+".","UsbFTMLInterface::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.","UsbFTMLInterface::usbWrite16");
     return StatusCode::FAILURE;    
   }
 
   return StatusCode::SUCCESS;  
 }

◆ usbWriteU32()

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

Write usb (U32 format)

Definition at line 605 of file UsbFTMLInterface.cpp.

References Object::error(), StatusCode::FAILURE, itos(), m_usbId, Object::name(), Hierarchy::path(), PrintFrameInfo(), StatusCode::SUCCESS, USB_GetLastError(), USB_INT_FRAME, USB_NoErr, UsbWrtML(), 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);
 
   int path = -1;
   bytecount=UsbWrtML(m_usbId, &path, address, data, nData);
 
   if (bytecount<0){
     wrErr=USB_GetLastError();
     error("USB error number "+itos(wrErr)+" - USB_INT_FRAME="+itos(USB_INT_FRAME),
             "UsbFTMLInterface::usbWrite32");
     if (wrErr==USB_INT_FRAME){
       PrintFrameInfo();
     } 
     return StatusCode::FAILURE;
   }
 
   if (nData==bytecount){
     verbose(itos(bytecount)+" bytes written on USB Interface "+name(),
             "UsbFTMLInterface::usbWrite32");
   }
   
   if (0==bytecount){
     error(" O Byte written on USB interface "+name()+".","UsbFTMLInterface::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.","UsbFTMLInterface::usbWrite32");
     return StatusCode::FAILURE;    
   }
 
   return StatusCode::SUCCESS;  
 }

◆ usbWriteU8()

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

Write usb (U8 format)

Definition at line 519 of file UsbFTMLInterface.cpp.

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

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

                                                              {
   USB_Error wrErr=USB_NoErr;
   long int  bytecount=0;
 
   long int nData=(long int)(nWords);
 
   int path = -1;
   bytecount=UsbWrtML(m_usbId, &path, address, data, nData);
 
   if (bytecount<0){
     wrErr=USB_GetLastError();
     error("USB error number "+itos(wrErr)+" - USB_INT_FRAME="+itos(USB_INT_FRAME),
             "UsbFTMLInterface::usbWrite8");
     if (wrErr==USB_INT_FRAME){
       PrintFrameInfo();
     } 
     return StatusCode::FAILURE;
   }
 
   if (nData==bytecount){
     verbose(itos(bytecount)+" bytes written on USB Interface "+name(),
             "UsbFTMLInterface::usbWrite8");
   }
   
   if (0==bytecount){
     error(" O Byte written on USB interface "+name()+".","UsbFTMLInterface::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.","UsbFTMLInterface::usbWrite8");
     return StatusCode::FAILURE;    
   }
 
   return StatusCode::SUCCESS;  
 }

◆ wordCount()

unsigned long UsbFTMLInterface::wordCount ( )

inline

Get accessor to member m_wordCount

Returns: the current value of m_wordCount

Definition at line 378 of file UsbFTMLInterface.h.

References m_wordCount.

Referenced by setWordCount().

                              {
     return m_wordCount;
   }

◆ wordSize()

unsigned long UsbFTMLInterface::wordSize ( )

inline

Get accessor to member m_wordSize

Returns: the current value of m_wordSize

Definition at line 394 of file UsbFTMLInterface.h.

References m_wordSize.

Referenced by BOOST_PYTHON_MODULE(), and setWordSize().

                             {
     return m_wordSize;
   }  

◆ wrBlockMax()

bool UsbFTMLInterface::wrBlockMax ( )

inline

Get accessor to member m_wrBlockMax

Returns: the current value of m_wrBlockMax

Definition at line 450 of file UsbFTMLInterface.h.

References m_wrBlockMax.

Referenced by setWrBlockMax().

                      {
     return m_wrBlockMax;
   }

◆ write() [1/2]

StatusCode UsbFTMLInterface::write ( IOdata * io )

virtual

Implements Interface.

Definition at line 795 of file UsbFTMLInterface.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),
               "UsbFTMLInterface::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),
                   "UsbFTMLInterface::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),
                   "UsbFTMLInterface::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.","UsbFTMLInterface::read");
     status=StatusCode::FAILURE;
   }
   return status;
 }

◆ write() [2/2]

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

Python interpreter wrapping for usb write

Definition at line 191 of file UsbFTMLInterface.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),"UsbFTMLInterface::write");
         verbose("wd "+itos(i)+" "+itos(data[i]),"UsbFTMLInterface::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),"UsbFTMLInterface::write");
         data[i]=(boost::python::extract<unsigned short>(obj[i]));
         verbose("wd "+itos(i)+" "+itos(data[i]),"UsbFTMLInterface::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),"UsbFTMLInterface::write");
         verbose("wd "+itos(i)+" "+itos(data[i]),"UsbFTMLInterface::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 UsbFTMLInterface::m_deviceDesc

private

Definition at line 503 of file UsbFTMLInterface.h.

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

◆ m_fakeErr

unsigned int UsbFTMLInterface::m_fakeErr

private

Definition at line 512 of file UsbFTMLInterface.h.

Referenced by fakeErr(), and setFakeErr().

◆ m_interrupts

bool UsbFTMLInterface::m_interrupts

private

Definition at line 513 of file UsbFTMLInterface.h.

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

◆ m_latencyTimer

unsigned char UsbFTMLInterface::m_latencyTimer

private

Definition at line 504 of file UsbFTMLInterface.h.

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

◆ m_nFrames

long int UsbFTMLInterface::m_nFrames

private

Definition at line 509 of file UsbFTMLInterface.h.

Referenced by nFrames(), and setNFrames().

◆ m_printout

bool UsbFTMLInterface::m_printout

private

Definition at line 515 of file UsbFTMLInterface.h.

Referenced by printout(), and setPrintout().

◆ m_rdBlockMax

int UsbFTMLInterface::m_rdBlockMax

private

Definition at line 516 of file UsbFTMLInterface.h.

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

◆ m_rxBuffer

int UsbFTMLInterface::m_rxBuffer

private

Definition at line 508 of file UsbFTMLInterface.h.

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

◆ m_rxTimeOut

int UsbFTMLInterface::m_rxTimeOut

private

Definition at line 506 of file UsbFTMLInterface.h.

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

◆ m_serialNum

std::string UsbFTMLInterface::m_serialNum

private

Definition at line 502 of file UsbFTMLInterface.h.

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

◆ m_showEpromState

bool UsbFTMLInterface::m_showEpromState

private

Definition at line 514 of file UsbFTMLInterface.h.

Referenced by setShowEpromState(), and showEpromState().

◆ m_txBuffer

int UsbFTMLInterface::m_txBuffer

private

Definition at line 507 of file UsbFTMLInterface.h.

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

◆ m_txTimeOut

int UsbFTMLInterface::m_txTimeOut

private

Definition at line 505 of file UsbFTMLInterface.h.

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

◆ m_usbId

int UsbFTMLInterface::m_usbId

private

Definition at line 501 of file UsbFTMLInterface.h.

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

◆ m_wordCount

unsigned long UsbFTMLInterface::m_wordCount

private

Definition at line 510 of file UsbFTMLInterface.h.

Referenced by setWordCount(), and wordCount().

◆ m_wordSize

unsigned long UsbFTMLInterface::m_wordSize

private

Definition at line 511 of file UsbFTMLInterface.h.

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

◆ m_wrBlockMax

int UsbFTMLInterface::m_wrBlockMax

private

Definition at line 517 of file UsbFTMLInterface.h.

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

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

/home/eleclhcb/LHCb/lbcat-cmake/CatCaloUpgrade/inc/UsbFTMLInterface.h
/home/eleclhcb/LHCb/lbcat-cmake/CatCaloUpgrade/src/UsbFTMLInterface.cpp

Public Types

Public Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ U16

◆ U32

◆ U8

Member Enumeration Documentation

◆ IOMode

◆ WordSize

Constructor & Destructor Documentation

◆ UsbFTMLInterface()

◆ ~UsbFTMLInterface()

Member Function Documentation

◆ close()

◆ deviceDesc()

◆ fakeErr()

◆ help()

◆ init()

◆ interrupts()

◆ latencyTimer()

◆ nFrames()

◆ printout()

◆ purgeBuffers()

◆ rdBlockMax()

◆ read() [1/2]

◆ read() [2/2]

◆ reset()

◆ resetMode()

◆ rxBuffer()

◆ rxTimeOut()

◆ serialNum()

◆ setBuffer()

◆ setDeviceDesc()

◆ setFakeErr()

◆ setInterrupts()

◆ setLatencyTimer()

◆ setNFrames()

◆ setPrintout()

◆ setRdBlockMax()

◆ setSerialNum()

◆ setShowEpromState()

◆ setSynchronousMode()

◆ setTimeOut()

◆ setUsbId()

◆ setWordCount()

◆ setWordSize()

◆ setWrBlockMax()

◆ showEpromState()

◆ txBuffer()

◆ txTimeOut()

◆ update()

◆ usbId()

◆ usbRead()

◆ usbReadU16()

◆ usbReadU32()

◆ usbReadU8()

◆ usbWrite()

◆ usbWriteRead()

◆ usbWriteU16()

◆ usbWriteU32()

◆ usbWriteU8()

◆ wordCount()

◆ wordSize()

◆ wrBlockMax()

◆ write() [1/2]

◆ write() [2/2]

Member Data Documentation

◆ m_deviceDesc

◆ m_fakeErr

◆ m_interrupts

◆ m_latencyTimer

◆ m_nFrames

◆ m_printout

◆ m_rdBlockMax

◆ m_rxBuffer

◆ m_rxTimeOut

◆ m_serialNum