BNL_UDP Class Reference

#include <BNL_UDP.hh>

Public Member Functions
	BNL_UDP ()
	~BNL_UDP ()
void	Setup (std::string const &address, uint16_t port_offset=0)
bool	Ready ()
void	SetWriteAck (bool val)
bool	GetWriteAck ()
uint32_t	ReadWithRetry (uint16_t address, uint8_t retry_count=10)
uint32_t	Read (uint16_t address)
void	WriteWithRetry (uint16_t address, uint32_t value, uint8_t retry_count=10)
void	Write (uint16_t address, uint32_t value)
void	Write (uint16_t address, std::vector< uint32_t > const &values)
void	Write (uint16_t address, uint32_t const *values, size_t word_count)
std::string	GetAddress ()
uint64_t	GetRetryCount ()

Private Member Functions
	BNL_UDP (const BNL_UDP &other)
BNL_UDP &	operator= (const BNL_UDP &)
void	FlushSocket (int sock)
void	Clear ()
void	Reset ()
void	ResizeBuffer (size_t size=WIB_RESPONSE_PACKET_BUFFER_SIZE)

Private Attributes
bool	writeAck
std::string	remoteAddress
int16_t	readPort
int16_t	writePort
int16_t	replyPort
bool	connected
int	readSocketFD
int	writeSocketFD
struct sockaddr_in	readAddr
struct sockaddr_in	writeAddr
size_t	buffer_size
uint8_t *	buffer
uint64_t	total_retry_count

Detailed Description

Definition at line 14 of file BNL_UDP.hh.

Constructor & Destructor Documentation

BNL_UDP() [1/2]

BNL_UDP::BNL_UDP ( )

inline

Definition at line 16 of file BNL_UDP.hh.

:readSocketFD(-1),writeSocketFD(-1),buffer_size(0),buffer(NULL),total_retry_count(0) {Clear();};

~BNL_UDP()

BNL_UDP::~BNL_UDP

(

)

Definition at line 474 of file BNL_UDP.cpp.

{
  Clear();
}

BNL_UDP() [2/2]

BNL_UDP::BNL_UDP ( const BNL_UDP & other )

private

Member Function Documentation

Clear()

void BNL_UDP::Clear ( )

private

Definition at line 69 of file BNL_UDP.cpp.

{
  // close sockets
  if (readSocketFD != -1) {
    close(readSocketFD);
    readSocketFD = -1;
  }
  if (writeSocketFD != -1) {
    close(writeSocketFD);
    writeSocketFD = -1;
  }
  // Clear packet buffer
  if (buffer != NULL) {
    delete[] buffer;
    buffer_size = 0;
  }
  writeAck = false;
  connected = false;
 
  // Reset send/recv addr structures
  memset(&readAddr, 0, sizeof(readAddr));
  memset(&writeAddr, 0, sizeof(writeAddr));
}

FlushSocket()

void BNL_UDP::FlushSocket ( int sock )

private

Definition at line 57 of file BNL_UDP.cpp.

{
  // turn on non-blocking
  fcntl(sock, F_SETFL, fcntl(sock, F_GETFL) | O_NONBLOCK);
  int ret;
  do {
    ret = recv(sock, buffer, buffer_size, 0);
  } while (ret != -1);
  fcntl(sock, F_SETFL, fcntl(sock, F_GETFL) & (~O_NONBLOCK));
}

GetAddress()

std::string BNL_UDP::GetAddress ( )

inline

Definition at line 32 of file BNL_UDP.hh.

{return remoteAddress;};

GetRetryCount()

uint64_t BNL_UDP::GetRetryCount ( )

inline

Definition at line 34 of file BNL_UDP.hh.

{return total_retry_count;};

GetWriteAck()

bool BNL_UDP::GetWriteAck ( )

inline

Definition at line 23 of file BNL_UDP.hh.

{return writeAck;};

operator=()

BNL_UDP & BNL_UDP::operator= ( const BNL_UDP & )

private

Read()

uint32_t BNL_UDP::Read

(

uint16_t

address

)

Definition at line 411 of file BNL_UDP.cpp.

{
  // Flush the socket
  FlushSocket(readSocketFD);
 
  // build the send packet
  WIB_packet_t packet;
  packet.key = htonl(WIB_PACKET_KEY);
  packet.reg_addr = htons(address);
  packet.data_MSW = packet.data_LSW = 0;
  packet.trailer = htons(WIB_REQUEST_PACKET_TRAILER);
 
  // send the packet
  ssize_t send_size = sizeof(packet);
  ssize_t sent_size = 0;
  if (send_size != (sent_size = send(readSocketFD, &packet, send_size, 0))) {
    // bad send
    BUException::SEND_FAILED e;
    if (sent_size == -1) {
      e.Append("BNL_UDP::Read(uint16_t)\n");
      e.Append("Errnum: ");
      e.Append(strerror(errno));
    }
    throw e;
  }
 
  // Get the reply packet with the register data in it.
  ssize_t reply_size = recv(readSocketFD, buffer, buffer_size, 0);
 
  if (ssize_t(-1) == reply_size) {
    BUException::BAD_REPLY e;
    std::stringstream ss;
    e.Append("BNL_UDP::Read(uint16_t)\n");
    ss << "Errnum(" << errno << "): " << strerror(errno) << "\n";
    e.Append(ss.str().c_str());
    e.Append(dump_packet((uint8_t*)&packet, send_size).c_str());
    throw e;
  } else if (reply_size < WIB_RPLY_PACKET_SIZE) {
    BUException::BAD_REPLY e;
    std::stringstream ss;
    ss << "Bad Size: " << reply_size << "\n";
    e.Append("BNL_UDP::Read(uint16_t)\n");
    e.Append(ss.str().c_str());
    e.Append(dump_packet(buffer, reply_size).c_str());
    throw e;
  }
  uint16_t reply_address = uint16_t(buffer[0] << 8 | buffer[1]);
  if (reply_address != address) {
    BUException::BAD_REPLY e;
    std::stringstream ss;
    ss << "Bad address: " << uint32_t(address) << " != " << uint32_t(reply_address) << "\n";
    e.Append("BNL_UDP::Read(uint16_t)\n");
    e.Append(ss.str().c_str());
    e.Append(dump_packet(buffer, reply_size).c_str());
    throw e;
  }
 
  //  }
  uint32_t ret = ((uint32_t(buffer[2]) << 24) | (uint32_t(buffer[3]) << 16) | (uint32_t(buffer[4]) << 8) |
                  (uint32_t(buffer[5]) << 0));
  return ret;
}

ReadWithRetry()

uint32_t BNL_UDP::ReadWithRetry	(	uint16_t	address,
		uint8_t	retry_count = 10 )

Definition at line 388 of file BNL_UDP.cpp.

{
  uint32_t val;
  while (retry_count > 1) {
    try {
      // Do the write
      val = Read(address);
      usleep(10);
      // if everything goes well, return
      return val;
    } catch (BUException::BAD_REPLY& e) {
      // eat the exception
    }
    usleep(10);
    total_retry_count++;
    retry_count--;
  }
  // Last chance we don't catch the exception and let it fall down the stack
  val = Read(address);
  usleep(10);
  return val;
}

Ready()

bool BNL_UDP::Ready ( )

inline

Definition at line 20 of file BNL_UDP.hh.

{return connected;};

Reset()

void BNL_UDP::Reset ( )

private

ResizeBuffer()

void BNL_UDP::ResizeBuffer ( size_t size = WIB_RESPONSE_PACKET_BUFFER_SIZE )

private

Definition at line 480 of file BNL_UDP.cpp.

{
  // CHeck if the requested size is larger than the already allocated size
  //   printf("before %p %zu %zd\n",buffer,buffer_size,buffer_size);
  if (buffer_size < size) {
    // We need to re-allocate
    if (buffer != NULL) {
      delete[] buffer;
    }
    buffer = new uint8_t[size];
    buffer_size = size;
  }
  //  printf("after %p %zu %zd\n",buffer,buffer_size,buffer_size);
}

Setup()

void BNL_UDP::Setup	(	std::string const &	address,
		uint16_t	port_offset = 0 )

Definition at line 104 of file BNL_UDP.cpp.

{
  // Reset the network structures
  Clear();
 
  // Allocate the recv buffer
  ResizeBuffer();
 
  // Check port_offset range
  if (port_offset > 128) {
    BUException::BNL_UDP_PORT_OUT_OF_RANGE e;
    throw e;
  }
 
  // Set the ports for this device (FEMBs are iFEMB*0x10 above the base)
  readPort = WIB_RD_BASE_PORT + port_offset;
  writePort = WIB_WR_BASE_PORT + port_offset;
  //  replyPort = WIB_RPLY_BASE_PORT + port_offset;
 
  remoteAddress = address;
  // Get the sockaddr for the address
  struct addrinfo* res;
  if (getaddrinfo(address.c_str(), NULL, NULL, &res)) {
    // Check if we have just one "." character and is less than 5 characters
    if (address.size() <= 5 && 1 == std::count(address.begin(), address.end(), '.')) {
      std::string strCrate = address.substr(0, address.find('.'));
      std::string strSlot = address.substr(address.find('.') + 1);
      if (strCrate.size() != 0 && strSlot.size() != 0) {
        uint8_t crate = strtoul(strCrate.c_str(), NULL, 0);
        uint8_t slot = strtoul(strSlot.c_str(), NULL, 0);
        if ((((crate > 0) && (crate < 7)) || 0xF == crate) && (((slot > 0) && (slot < 7)) || 0xF == slot)) {
          remoteAddress = std::string("192.168.");
          // Add the crate part of the address (200 + crate number)
          if (crate == 0xF) {
            remoteAddress += "200.";
          } else {
            // generate the crate number which is 200 + crate number
            remoteAddress += "20";
            remoteAddress += ('0' + crate);
            remoteAddress += '.';
          }
          if (slot == 0xF) {
            remoteAddress += "50";
          } else {
            // crate last IP octet that is slot number
            remoteAddress += ('0' + slot);
          }
        }
      }
    }
    // try a second time assumin gthis is a crate.slot address, fail if this still doesn't work
    if (getaddrinfo(address.c_str(), NULL, NULL, &res)) {
      BUException::BAD_REMOTE_IP e;
      e.Append("Addr: ");
      e.Append(address.c_str());
      e.Append(" could not be resolved.\n");
      throw e;
    }
  }
  //  readAddr = *((struct sockaddr_in *) res->ai_addr);
  //  printaddress(&readAddr);
 
  // Generate the sockets for read and write
  if ((readSocketFD = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
    BUException::BAD_SOCKET e;
    e.Append("read socket\n");
    throw e;
  }
  if ((writeSocketFD = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
    BUException::BAD_SOCKET e;
    e.Append("write socket\n");
    throw e;
  }
  // Set a timeout for the recv socket so we don't hang on a reply
  struct timeval tv;
  tv.tv_sec = TIMEOUT_SECONDS;
  tv.tv_usec = TIMEOUT_MICROSECONDS;
  setsockopt(readSocketFD, SOL_SOCKET, SO_RCVTIMEO, (const char*)&tv, sizeof(struct timeval));
  setsockopt(writeSocketFD, SOL_SOCKET, SO_RCVTIMEO, (const char*)&tv, sizeof(struct timeval));
 
  // connect the read socket
  readAddr = *((struct sockaddr_in*)res->ai_addr);
  readAddr.sin_port = htons(readPort);
  if (connect(readSocketFD, (struct sockaddr*)&readAddr, sizeof(readAddr)) < 0) {
    BUException::CONNECTION_FAILED e;
    e.Append("read socket connect\n");
    e.Append(strerror(errno));
    throw e;
  }
  // connect the write socket
  writeAddr = *((struct sockaddr_in*)res->ai_addr);
  writeAddr.sin_port = htons(writePort);
  if (connect(writeSocketFD, (struct sockaddr*)&writeAddr, sizeof(writeAddr)) < 0) {
    BUException::CONNECTION_FAILED e;
    e.Append("write socket connect\n");
    e.Append(strerror(errno));
    throw e;
  }
 
  // Allocate the receive buffer to default size
  ResizeBuffer();
}

SetWriteAck()

void BNL_UDP::SetWriteAck ( bool val )

inline

Definition at line 22 of file BNL_UDP.hh.

{writeAck=val;};

Write() [1/3]

void BNL_UDP::Write	(	uint16_t	address,
		std::vector< uint32_t > const &	values )

Definition at line 293 of file BNL_UDP.cpp.

{
  Write(address, values.data(), values.size());
}

Write() [2/3]

void BNL_UDP::Write	(	uint16_t	address,
		uint32_t const *	values,
		size_t	word_count )

//Create a pointer to 16bit words that points to the parts of buffer that are after the first 32bit word (WIB key)

Definition at line 298 of file BNL_UDP.cpp.

{
  for (size_t iWrite = 0; iWrite < word_count; iWrite++) {
    WriteWithRetry(address, values[iWrite]);
    address++;
  }

}

Write() [3/3]

void BNL_UDP::Write	(	uint16_t	address,
		uint32_t	value )

Definition at line 230 of file BNL_UDP.cpp.

{
 
  // Flush this socket
  FlushSocket(writeSocketFD);
 
  // Build the packet to send
  // build the send packet
  WIB_packet_t packet;
  packet.key = htonl(WIB_PACKET_KEY);
  packet.reg_addr = htons(address);
  packet.data_MSW = htons(uint16_t((value >> 16) & 0xFFFF));
  packet.data_LSW = htons(uint16_t((value >> 0) & 0xFFFF));
  packet.trailer = htons(WIB_REQUEST_PACKET_TRAILER);
 
  // send the packet
  ssize_t send_size = sizeof(packet);
  ssize_t sent_size = 0;
  if (send_size != (sent_size = send(writeSocketFD, &packet, send_size, 0))) {
    // bad send
    BUException::SEND_FAILED e;
    if (sent_size == -1) {
      e.Append("BNL_UDP::Write(uint16_t,uint32_t)\n");
      e.Append("Errnum: ");
      e.Append(strerror(errno));
    }
    throw e;
  }
 
  // If configured, capture confirmation packet
  if (writeAck) {
    ssize_t reply_size = recv(writeSocketFD, buffer, buffer_size, 0);
 
    if (-1 == reply_size) {
      BUException::BAD_REPLY e;
      std::stringstream ss;
      e.Append("BNL_UDP::Write(uint16_t,uint32_t)\n");
      ss << "Errnum(" << errno << "): " << strerror(errno) << "\n";
      e.Append(ss.str().c_str());
      e.Append(dump_packet((uint8_t*)&packet, send_size).c_str());
      throw e;
    } else if (reply_size < WIB_RPLY_PACKET_SIZE) {
      BUException::BAD_REPLY e;
      std::stringstream ss;
      ss << "Bad Size: " << reply_size << "\n";
      e.Append("BNL_UDP::Write(uint16_t,uint32_t)\n");
      e.Append(ss.str().c_str());
      e.Append(dump_packet(buffer, reply_size).c_str());
      throw e;
    }
    uint16_t reply_address = uint16_t(buffer[0] << 8 | buffer[1]);
    if (reply_address != address) {
      BUException::BAD_REPLY e;
      std::stringstream ss;
      ss << "Bad address: " << uint32_t(address) << " != " << uint32_t(reply_address) << "\n";
      e.Append("BNL_UDP::Write(uint16_t,uint32_t)\n");
      e.Append(ss.str().c_str());
      e.Append(dump_packet(buffer, reply_size).c_str());
      throw e;
    }
  }
}

WriteWithRetry()

void BNL_UDP::WriteWithRetry	(	uint16_t	address,
		uint32_t	value,
		uint8_t	retry_count = 10 )

Definition at line 208 of file BNL_UDP.cpp.

{
  while (retry_count > 1) {
    try {
      // Do the write
      Write(address, value);
      usleep(10);
      // if everything goes well, return
      return;
    } catch (BUException::BAD_REPLY& e) {
      // eat the exception
    }
    total_retry_count++;
    retry_count--;
    usleep(10);
  }
  // Last chance we don't catch the exception and let it fall down the stack
  // Do the write
  Write(address, value);
  usleep(10);
}

Member Data Documentation

buffer

uint8_t* BNL_UDP::buffer

private

Definition at line 65 of file BNL_UDP.hh.

buffer_size

size_t BNL_UDP::buffer_size

private

Definition at line 64 of file BNL_UDP.hh.

connected

bool BNL_UDP::connected

private

Definition at line 57 of file BNL_UDP.hh.

readAddr

struct sockaddr_in BNL_UDP::readAddr

private

Definition at line 60 of file BNL_UDP.hh.

readPort

int16_t BNL_UDP::readPort

private

Definition at line 52 of file BNL_UDP.hh.

readSocketFD

int BNL_UDP::readSocketFD

private

Definition at line 58 of file BNL_UDP.hh.

remoteAddress

std::string BNL_UDP::remoteAddress

private

Definition at line 51 of file BNL_UDP.hh.

replyPort

int16_t BNL_UDP::replyPort

private

Definition at line 54 of file BNL_UDP.hh.

total_retry_count

uint64_t BNL_UDP::total_retry_count

private

Definition at line 66 of file BNL_UDP.hh.

writeAck

bool BNL_UDP::writeAck

private

Definition at line 48 of file BNL_UDP.hh.

writeAddr

struct sockaddr_in BNL_UDP::writeAddr

private

Definition at line 61 of file BNL_UDP.hh.

writePort

int16_t BNL_UDP::writePort

private

Definition at line 53 of file BNL_UDP.hh.

writeSocketFD

int BNL_UDP::writeSocketFD

private

Definition at line 59 of file BNL_UDP.hh.

---

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

• /github/workspace/dunedaq/sourcecode/wibmod/src/wibmod/WIB1/BNL_UDP.hh
• /github/workspace/dunedaq/sourcecode/wibmod/src/WIB1/BNL_UDP.cpp