BNL_UDP Class Reference

#include <BNL_UDP.hh>

Collaboration diagram for BNL_UDP:

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 459 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 63 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 53 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 391 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 370 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 464 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 96 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 280 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 )

Definition at line 283 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 217 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 197 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