dunedaq::sspmodules::EthernetDevice Class Reference

#include <EthernetDevice.hpp>

Inheritance diagram for dunedaq::sspmodules::EthernetDevice:

Collaboration diagram for dunedaq::sspmodules::EthernetDevice:

Public Member Functions
	EthernetDevice (unsigned long ipAddress)
virtual bool	IsOpen ()
virtual void	Close ()
virtual void	DevicePurgeComm ()
virtual void	DevicePurgeData ()
virtual void	DeviceQueueStatus (unsigned int *numWords)
virtual void	DeviceReceive (std::vector< unsigned int > &data, unsigned int size)
virtual void	DeviceRead (unsigned int address, unsigned int *value)
virtual void	DeviceReadMask (unsigned int address, unsigned int mask, unsigned int *value)
virtual void	DeviceWrite (unsigned int address, unsigned int value)
virtual void	DeviceWriteMask (unsigned int address, unsigned int mask, unsigned int value)
virtual void	DeviceSet (unsigned int address, unsigned int mask)
virtual void	DeviceClear (unsigned int address, unsigned int mask)
virtual void	DeviceArrayRead (unsigned int address, unsigned int size, unsigned int *data)
virtual void	DeviceArrayWrite (unsigned int address, unsigned int size, unsigned int *data)
void	SendReceive (dunedaq::sspmodules::CtrlPacket &tx, dunedaq::sspmodules::CtrlPacket &rx, unsigned int txSize, unsigned int rxSizeExpected, unsigned int retryCount=0)
void	SendEthernet (dunedaq::sspmodules::CtrlPacket &tx, unsigned int txSize)
void	ReceiveEthernet (dunedaq::sspmodules::CtrlPacket &rx, unsigned int rxSizeExpected)
void	DevicePurge (boost::asio::ip::tcp::socket &socket)
Public Member Functions inherited from dunedaq::sspmodules::Device
virtual	~Device ()

Private Member Functions
virtual void	Open (bool slowControlOnly)

Private Attributes
bool	isOpen
boost::asio::ip::tcp::socket	fCommSocket
boost::asio::ip::tcp::socket	fDataSocket
boost::asio::ip::address	fIP

Static Private Attributes
static boost::asio::io_service	fIo_service

Friends
class	DeviceManager

Additional Inherited Members
Protected Attributes inherited from dunedaq::sspmodules::Device
bool	fSlowControlOnly

Detailed Description

Definition at line 28 of file EthernetDevice.hpp.

Constructor & Destructor Documentation

EthernetDevice()

dunedaq::sspmodules::EthernetDevice::EthernetDevice ( unsigned long ipAddress )

explicit

Definition at line 21 of file EthernetDevice.cxx.

  :
  isOpen(false)
  , fCommSocket(fIo_service)
  , fDataSocket(fIo_service)
  , fIP(boost::asio::ip::address_v4(ipAddress))
{}

Member Function Documentation

Close()

void dunedaq::sspmodules::EthernetDevice::Close ( )

virtual

Implements dunedaq::sspmodules::Device.

Definition at line 62 of file EthernetDevice.cxx.

{
  isOpen = false;
  // dune::DAQLogger::LogInfo("SSP_EthernetDevice")<<"Device closed"<<std::endl;
}

DeviceArrayRead()

void dunedaq::sspmodules::EthernetDevice::DeviceArrayRead ( unsigned int address, unsigned int size, unsigned int * data )

virtual

Implements dunedaq::sspmodules::Device.

Definition at line 196 of file EthernetDevice.cxx.

{
  unsigned int i = 0;
  dunedaq::sspmodules::CtrlPacket tx;
  dunedaq::sspmodules::CtrlPacket rx;
  unsigned int txSize;
  unsigned int rxSizeExpected;
 
  tx.header.length = sizeof(dunedaq::sspmodules::CtrlHeader);
  tx.header.address = address;
  tx.header.command = dunedaq::sspmodules::cmdArrayRead;
  tx.header.size = size;
  tx.header.status = dunedaq::sspmodules::statusNoError;
  txSize = sizeof(dunedaq::sspmodules::CtrlHeader);
  rxSizeExpected = sizeof(dunedaq::sspmodules::CtrlHeader) + (sizeof(unsigned int) * size);
 
  SendReceive(tx, rx, txSize, rxSizeExpected, 3);
  for (i = 0; i < rx.header.size; i++) {
    data[i] = rx.data[i];
  }
}

DeviceArrayWrite()

void dunedaq::sspmodules::EthernetDevice::DeviceArrayWrite ( unsigned int address, unsigned int size, unsigned int * data )

virtual

Implements dunedaq::sspmodules::Device.

Definition at line 219 of file EthernetDevice.cxx.

{
  unsigned int i = 0;
  dunedaq::sspmodules::CtrlPacket tx;
  dunedaq::sspmodules::CtrlPacket rx;
  unsigned int txSize;
  unsigned int rxSizeExpected;
 
  tx.header.length = sizeof(dunedaq::sspmodules::CtrlHeader) + (sizeof(uint) * size);
  tx.header.address = address;
  tx.header.command = dunedaq::sspmodules::cmdArrayWrite;
  tx.header.size = size;
  tx.header.status = dunedaq::sspmodules::statusNoError;
  txSize = sizeof(dunedaq::sspmodules::CtrlHeader) + (sizeof(unsigned int) * size);
  rxSizeExpected = sizeof(dunedaq::sspmodules::CtrlHeader);
 
  for (i = 0; i < size; i++) {
    tx.data[i] = data[i];
  }
 
  SendReceive(tx, rx, txSize, rxSizeExpected, 3);
}

DeviceClear()

void dunedaq::sspmodules::EthernetDevice::DeviceClear ( unsigned int address, unsigned int mask )

virtual

Implements dunedaq::sspmodules::Device.

Definition at line 190 of file EthernetDevice.cxx.

{
  DeviceWriteMask(address, mask, 0x00000000);
}

DevicePurge()

void dunedaq::sspmodules::EthernetDevice::DevicePurge

(

boost::asio::ip::tcp::socket &

socket

)

Definition at line 298 of file EthernetDevice.cxx.

{
  bool done = false;
  unsigned int bytesQueued = 0;
  unsigned int sleepTime = 0;
 
  // Keep getting data from channel until queue is empty
  do {
    bytesQueued = socket.available();
 
    // Read data from device, up to 256 bytes
    if (bytesQueued != 0) {
      sleepTime = 0;
      unsigned int bytesToGet = std::min((unsigned int)256, bytesQueued);
      std::vector<char> junkBuf(bytesToGet);
      socket.read_some(boost::asio::buffer(junkBuf, bytesToGet));
    } else {      // If queue is empty, wait a bit and check that it hasn't filled up again, then return
      usleep(1000); // 1ms
      sleepTime += 1000;
      bytesQueued = socket.available();
      if (bytesQueued == 0 && sleepTime > 1000000) {
        done = 1;
      }
    }
  } while (!done);
}

DevicePurgeComm()

void dunedaq::sspmodules::EthernetDevice::DevicePurgeComm ( void )

virtual

Implements dunedaq::sspmodules::Device.

Definition at line 69 of file EthernetDevice.cxx.

{
  DevicePurge(fCommSocket);
}

DevicePurgeData()

void dunedaq::sspmodules::EthernetDevice::DevicePurgeData ( void )

virtual

Implements dunedaq::sspmodules::Device.

Definition at line 75 of file EthernetDevice.cxx.

{
  DevicePurge(fDataSocket);
}

DeviceQueueStatus()

void dunedaq::sspmodules::EthernetDevice::DeviceQueueStatus ( unsigned int * numWords )

virtual

Implements dunedaq::sspmodules::Device.

Definition at line 81 of file EthernetDevice.cxx.

{
  unsigned int numBytes = fDataSocket.available();
  (*numWords) = numBytes / sizeof(unsigned int);
}

DeviceRead()

void dunedaq::sspmodules::EthernetDevice::DeviceRead ( unsigned int address, unsigned int * value )

virtual

Implements dunedaq::sspmodules::Device.

Definition at line 102 of file EthernetDevice.cxx.

{
  dunedaq::sspmodules::CtrlPacket tx;
  dunedaq::sspmodules::CtrlPacket rx;
  unsigned int txSize;
  unsigned int rxSizeExpected;
 
  tx.header.length = sizeof(dunedaq::sspmodules::CtrlHeader);
  tx.header.address = address;
  tx.header.command = dunedaq::sspmodules::cmdRead;
  tx.header.size = 1;
  tx.header.status = dunedaq::sspmodules::statusNoError;
  txSize = sizeof(dunedaq::sspmodules::CtrlHeader);
  rxSizeExpected = sizeof(dunedaq::sspmodules::CtrlHeader) + sizeof(unsigned int);
 
  SendReceive(tx, rx, txSize, rxSizeExpected, 3);
  *value = rx.data[0];
}

DeviceReadMask()

void dunedaq::sspmodules::EthernetDevice::DeviceReadMask ( unsigned int address, unsigned int mask, unsigned int * value )

virtual

Implements dunedaq::sspmodules::Device.

Definition at line 122 of file EthernetDevice.cxx.

{
  dunedaq::sspmodules::CtrlPacket tx;
  dunedaq::sspmodules::CtrlPacket rx;
  unsigned int txSize;
  unsigned int rxSizeExpected;
 
  tx.header.length = sizeof(dunedaq::sspmodules::CtrlHeader) + sizeof(uint);
  tx.header.address = address;
  tx.header.command = dunedaq::sspmodules::cmdReadMask;
  tx.header.size = 1;
  tx.header.status = dunedaq::sspmodules::statusNoError;
  tx.data[0] = mask;
  txSize = sizeof(dunedaq::sspmodules::CtrlHeader) + sizeof(unsigned int);
  rxSizeExpected = sizeof(dunedaq::sspmodules::CtrlHeader) + sizeof(unsigned int);
 
  SendReceive(tx, rx, txSize, rxSizeExpected, 3);
  *value = rx.data[0];
}

DeviceReceive()

void dunedaq::sspmodules::EthernetDevice::DeviceReceive ( std::vector< unsigned int > & data, unsigned int size )

virtual

Implements dunedaq::sspmodules::Device.

Definition at line 88 of file EthernetDevice.cxx.

{
  data.resize(size);
  unsigned int dataReturned = fDataSocket.read_some(boost::asio::buffer(data));
  if (dataReturned < size * sizeof(unsigned int)) {
    data.resize(dataReturned / sizeof(unsigned int));
  }
}

DeviceSet()

void dunedaq::sspmodules::EthernetDevice::DeviceSet ( unsigned int address, unsigned int mask )

virtual

Implements dunedaq::sspmodules::Device.

Definition at line 184 of file EthernetDevice.cxx.

{
  DeviceWriteMask(address, mask, 0xFFFFFFFF);
}

DeviceWrite()

void dunedaq::sspmodules::EthernetDevice::DeviceWrite ( unsigned int address, unsigned int value )

virtual

Implements dunedaq::sspmodules::Device.

Definition at line 143 of file EthernetDevice.cxx.

{
  dunedaq::sspmodules::CtrlPacket tx;
  dunedaq::sspmodules::CtrlPacket rx;
  unsigned int txSize;
  unsigned int rxSizeExpected;
 
  tx.header.length = sizeof(dunedaq::sspmodules::CtrlHeader) + sizeof(uint);
  tx.header.address = address;
  tx.header.command = dunedaq::sspmodules::cmdWrite;
  tx.header.size = 1;
  tx.header.status = dunedaq::sspmodules::statusNoError;
  tx.data[0] = value;
  txSize = sizeof(dunedaq::sspmodules::CtrlHeader) + sizeof(unsigned int);
  rxSizeExpected = sizeof(dunedaq::sspmodules::CtrlHeader);
 
  SendReceive(tx, rx, txSize, rxSizeExpected, 3);
}

DeviceWriteMask()

void dunedaq::sspmodules::EthernetDevice::DeviceWriteMask ( unsigned int address, unsigned int mask, unsigned int value )

virtual

Implements dunedaq::sspmodules::Device.

Definition at line 163 of file EthernetDevice.cxx.

{
  dunedaq::sspmodules::CtrlPacket tx;
  dunedaq::sspmodules::CtrlPacket rx;
  unsigned int txSize;
  unsigned int rxSizeExpected;
 
  tx.header.length = sizeof(dunedaq::sspmodules::CtrlHeader) + (sizeof(uint) * 2);
  tx.header.address = address;
  tx.header.command = dunedaq::sspmodules::cmdWriteMask;
  tx.header.size = 1;
  tx.header.status = dunedaq::sspmodules::statusNoError;
  tx.data[0] = mask;
  tx.data[1] = value;
  txSize = sizeof(dunedaq::sspmodules::CtrlHeader) + (sizeof(unsigned int) * 2);
  rxSizeExpected = sizeof(dunedaq::sspmodules::CtrlHeader) + sizeof(unsigned int);
 
  SendReceive(tx, rx, txSize, rxSizeExpected, 3);
}

IsOpen()

virtual bool dunedaq::sspmodules::EthernetDevice::IsOpen ( )

inlinevirtual

Implements dunedaq::sspmodules::Device.

Definition at line 37 of file EthernetDevice.hpp.

                              {
    return isOpen;
  }

Open()

void dunedaq::sspmodules::EthernetDevice::Open ( bool slowControlOnly )

privatevirtual

Implements dunedaq::sspmodules::Device.

Definition at line 30 of file EthernetDevice.cxx.

{
 
  fSlowControlOnly = slowControlOnly;
 
  // dune::DAQLogger::LogInfo("SSP_EthernetDevice")<<"Looking for SSP Ethernet device at "<<fIP.to_string()<<std::endl;
  boost::asio::ip::tcp::resolver resolver(fIo_service);
  boost::asio::ip::tcp::resolver::query commQuery(fIP.to_string(), slowControlOnly ? "55002" : "55001");
  boost::asio::ip::tcp::resolver::iterator commEndpointIterator = resolver.resolve(commQuery);
  boost::asio::connect(fCommSocket, commEndpointIterator);
 
  if (slowControlOnly) {
    // dune::DAQLogger::LogInfo("SSP_EthernetDevice")<<"Connected to SSP Ethernet device at
    // "<<fIP.to_string()<<std::endl;
    return;
  }
 
  boost::asio::ip::tcp::resolver::query dataQuery(fIP.to_string(), "55010");
  boost::asio::ip::tcp::resolver::iterator dataEndpointIterator = resolver.resolve(dataQuery);
 
  boost::asio::connect(fDataSocket, dataEndpointIterator);
 
  // Set limited receive buffer size to avoid taxing switch
  // JTH: Remove this since it was causing event read errors. Could try again
  // with a different value if there are more issues which point to switch problems.
  //  boost::asio::socket_base::receive_buffer_size option(16384);
  //  fDataSocket.set_option(option);
 
  // dune::DAQLogger::LogInfo("SSP_EthernetDevice")<<"Connected to SSP Ethernet device at "<<fIP.to_string()<<std::endl;
}

ReceiveEthernet()

void dunedaq::sspmodules::EthernetDevice::ReceiveEthernet	(	dunedaq::sspmodules::CtrlPacket &	rx,
		unsigned int	rxSizeExpected )

Definition at line 289 of file EthernetDevice.cxx.

{
  unsigned int rxSizeReturned = fCommSocket.read_some(boost::asio::buffer(static_cast<void*>(&rx), rxSizeExpected));
  if (rxSizeReturned != rxSizeExpected) {
    throw(ETCPError(""));
  }
}

SendEthernet()

void dunedaq::sspmodules::EthernetDevice::SendEthernet	(	dunedaq::sspmodules::CtrlPacket &	tx,
		unsigned int	txSize )

Definition at line 280 of file EthernetDevice.cxx.

{
  unsigned int txSizeWritten = fCommSocket.write_some(boost::asio::buffer(static_cast<void*>(&tx), txSize));
  if (txSizeWritten != txSize) {
    throw(ETCPError(""));
  }
}

SendReceive()

void dunedaq::sspmodules::EthernetDevice::SendReceive	(	dunedaq::sspmodules::CtrlPacket &	tx,
		dunedaq::sspmodules::CtrlPacket &	rx,
		unsigned int	txSize,
		unsigned int	rxSizeExpected,
		unsigned int	retryCount = 0 )

Definition at line 247 of file EthernetDevice.cxx.

{
  unsigned int timesTried = 0;
  bool success = false;
 
  while (!success) {
    try {
      SendEthernet(tx, txSize);
      // Insert small delay between send and receive on Linux
      usleep(100);
      ReceiveEthernet(rx, rxSizeExpected);
      usleep(2000);
      success = true;
    } catch (ETCPError&) {
      if (timesTried < retryCount) {
        DevicePurgeComm();
        ++timesTried;
        // dune::DAQLogger::LogWarning("SSP_EthernetDevice")<<"Send/receive failed "<<timesTried<<" times on Ethernet
        // link, retrying..."<<std::endl;
      } else {
        // dune::DAQLogger::LogError("SSP_EthernetDevice")<<"Send/receive failed on Ethernet link, giving
        // up."<<std::endl;
        throw;
      }
    }
  }
}

Friends And Related Symbol Documentation

DeviceManager

friend class DeviceManager

friend

Definition at line 79 of file EthernetDevice.hpp.

Member Data Documentation

fCommSocket

boost::asio::ip::tcp::socket dunedaq::sspmodules::EthernetDevice::fCommSocket

private

Definition at line 85 of file EthernetDevice.hpp.

fDataSocket

boost::asio::ip::tcp::socket dunedaq::sspmodules::EthernetDevice::fDataSocket

private

Definition at line 86 of file EthernetDevice.hpp.

fIo_service

boost::asio::io_service dunedaq::sspmodules::EthernetDevice::fIo_service

staticprivate

Definition at line 83 of file EthernetDevice.hpp.

fIP

boost::asio::ip::address dunedaq::sspmodules::EthernetDevice::fIP

private

Definition at line 88 of file EthernetDevice.hpp.

isOpen

bool dunedaq::sspmodules::EthernetDevice::isOpen

private

Definition at line 81 of file EthernetDevice.hpp.

---

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

• /github/workspace/dunedaq/sourcecode/sspmodules/src/anlBoard/EthernetDevice.hpp
• /github/workspace/dunedaq/sourcecode/sspmodules/src/anlBoard/EthernetDevice.cxx