UsbFTInterface.h

Go to the documentation of this file.

//$Id: UsbFTInterface.h,v 1.9 2006/10/24 13:28:40 fmachefe Exp $
//-----------------------------------------------------------------------------
//
//  Package    : UsbFTInterface
//
//  Description:
//
//  Author(s)  : F. Machefert -
//  Date       : 18 January 2004
//
//-----------------------------------------------------------------------------

#ifndef USBINTERFACE_H
#define USBINTERFACE_H 1

#include <algorithm>
#include <string>
#include <vector>
#include <list>

#include <boost/python/list.hpp>
#include <boost/python/extract.hpp>

#include "LALUsb.h"
#include "Interface.h"

class UsbFTInterface : public Interface {
public:
  typedef unsigned long  U32;
  typedef unsigned short U16;
  typedef unsigned char  U8;

  enum WordSize
    {
      WS_Byte=1,
      WS_Word,
      WS_DWord
    };

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

  UsbFTInterface( ); 
  virtual ~UsbFTInterface( ){
    close();
  } //< Destructor


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

  virtual StatusCode init();

  void close();

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

  virtual void update () {
    info("UsbFTInterface "+name()+". Nothing to do.","UsbFTInterface::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 usbReadu8( unsigned long int,
//                        unsigned long int,
//                        std::vector<U8> &);

//  StatusCode usbWriteU8(unsigned long int,
//                        std::vector<U8> );

//  StatusCode usbReadU16(unsigned long int,
//                        unsigned long int,
//                        std::vector<U16> &);

//  StatusCode usbWriteU16(unsigned long int,
//                         std::vector<U16> );

  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) {
    m_usbId = usbId;
  }

  int usbId () {
    return m_usbId;
  }
  
  void setSerialNum (std::string serialNum) {
    m_serialNum = serialNum;
  }

  std::string serialNum () {
    return m_serialNum;
  }

  void setDeviceDesc (std::string deviceDesc) {
    m_deviceDesc = deviceDesc;
  }

  std::string deviceDesc () {
    return m_deviceDesc;
  }

  void setLatencyTimer (unsigned char latencyTimer) {
    m_latencyTimer = latencyTimer;
    USB_SetLatencyTimer(m_usbId, m_latencyTimer);
  }

  unsigned char latencyTimer () {
    USB_GetLatencyTimer(m_usbId,&m_latencyTimer);
    return m_latencyTimer;
  }

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

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

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

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

  int txBuffer () {
    return m_txBuffer;
  }

  int rxBuffer () {
    return m_rxBuffer;
  }

  void setNFrames (long int nFrames) {
    m_nFrames = nFrames;
  }

  long int nFrames () {
    return m_nFrames;
  }

  
  void setWordCount (unsigned long wordCount) {
    m_wordCount = wordCount;
  }

  unsigned long wordCount () {
    return m_wordCount;
  }

  void setWordSize (unsigned long wordSize) {
    m_wordSize = wordSize;
  }

  unsigned long wordSize () {
    return m_wordSize;
  }  
  
  void setFakeErr (unsigned int fakeErr) {
    m_fakeErr = fakeErr;
  }

  unsigned int fakeErr () {
    return m_fakeErr;
  }

  void setInterrupts (bool interrupts) {
    m_interrupts = interrupts;
  }

  bool interrupts () {
    return m_interrupts;
  }

  void setShowEpromState (bool showEpromState) {
    m_showEpromState = showEpromState;
  }

  bool showEpromState () {
    return m_showEpromState;
  }  

  bool wrBlockMax () {
    return m_wrBlockMax;
  }

  void setWrBlockMax (bool wrBlockMax) {
    m_wrBlockMax = wrBlockMax;
  }

  bool rdBlockMax () {
    return m_rdBlockMax;
  }

  void setRdBlockMax (bool rdBlockMax) {
    m_rdBlockMax = rdBlockMax;
  }

  void setPrintout (bool printout) {
    m_printout = printout;
  }

  bool printout () {
    return m_printout;
  }

private:
  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;

protected:

};

#endif