WIBBase Class Reference

#include <WIBBase.hh>

Inheritance diagram for WIBBase:

Collaboration diagram for WIBBase:

Public Member Functions
	WIBBase (std::string const &address, std::string const &WIBAddressTable, std::string const &FEMBAddressTable)
	~WIBBase ()
std::string	GetAddress ()
uint32_t	Read (uint16_t address)
uint32_t	ReadWithRetry (uint16_t address)
uint32_t	Read (std::string const &address)
uint32_t	ReadWithRetry (std::string const &address)
void	Write (uint16_t address, uint32_t value)
void	WriteWithRetry (uint16_t address, uint32_t value)
void	Write (std::string const &address, uint32_t value)
void	WriteWithRetry (std::string const &address, uint32_t value)
void	Write (uint16_t address, std::vector< uint32_t > const &values)
void	Write (std::string const &address, std::vector< uint32_t > const &values)
void	Write (uint16_t address, uint32_t const *values, size_t word_count)
void	Write (std::string const &address, uint32_t const *values, size_t word_count)
uint32_t	ReadI2C (std::string const &base_address, uint16_t I2C_aaddress, uint8_t byte_count=4)
void	WriteI2C (std::string const &base_address, uint16_t I2C_address, uint32_t data, uint8_t byte_count=4, bool ignore_error=false)
std::vector< std::string >	GetNames (std::string const &regex)
std::vector< std::string >	GetFEMBNames (std::string const &regex)
std::vector< std::string >	GetAddresses (uint16_t lower, uint16_t upper)
std::vector< std::string >	GetFEMBAddresses (uint16_t lower, uint16_t upper)
std::vector< std::string >	GetTableNames (std::string const &regex)
std::vector< Item const * >	GetTagged (std::string const &tag)
std::vector< Item const * >	GetFEMBTagged (std::string const &tag)
uint32_t	ReadFEMB (int iFEMB, uint16_t address)
uint32_t	ReadFEMB (int iFEMB, std::string const &address)
void	WriteFEMB (int iFEMB, uint16_t address, uint32_t value)
void	WriteFEMB (int iFEMB, std::string const &address, uint32_t value)
void	WriteFEMBBits (int iFEMB, uint16_t address, uint32_t pos, uint32_t mask, uint32_t value)
void	EnableADC (uint64_t iFEMB, uint64_t enable)
Item const *	GetItem (std::string const &)
Item const *	GetFEMBItem (int iFEMB, std::string const &)
int	GetSVNVersion ()

Private Member Functions
	WIBBase ()
	WIBBase (const WIBBase &other)
WIBBase &	operator= (const WIBBase &)

Private Attributes
AddressTable *	wib
AddressTable *	FEMB [FEMB_COUNT]
const float	FEMBReadSleepTime
const float	FEMBWriteSleepTime

Static Private Attributes
static const int	Version

Detailed Description

Definition at line 11 of file WIBBase.hh.

Constructor & Destructor Documentation

WIBBase() [1/3]

WIBBase::WIBBase	(	std::string const &	address,
		std::string const &	WIBAddressTable,
		std::string const &	FEMBAddressTable )

Definition at line 5 of file WIBBase.cpp.

  : wib(NULL)
  , FEMBReadSleepTime(0.01)
  , FEMBWriteSleepTime(0.01)
{
  // Make sure all pointers and NULL before any allocation
 
  for (size_t iFEMB = 0; iFEMB < FEMB_COUNT; iFEMB++) {
    FEMB[iFEMB] = NULL;
  }
 
  // Create the wib address table interface
  wib = new AddressTable(WIBAddressTable, address, 0);
  for (size_t iFEMB = 0; iFEMB < FEMB_COUNT; iFEMB++) {
    FEMB[iFEMB] = new AddressTable(FEMBAddressTable, address, (iFEMB + 1) * 0x10);
  }
}

~WIBBase()

WIBBase::~WIBBase

(

)

Definition at line 23 of file WIBBase.cpp.

{
  if (wib != NULL) {
    delete wib;
    wib = NULL;
  }
  for (size_t iFEMB = 0; iFEMB < FEMB_COUNT; iFEMB++) {
    if (FEMB[iFEMB] != NULL) {
      delete FEMB[iFEMB];
      FEMB[iFEMB] = NULL;
    }
  }
}

WIBBase() [2/3]

WIBBase::WIBBase ( )

private

WIBBase() [3/3]

WIBBase::WIBBase ( const WIBBase & other )

private

Member Function Documentation

EnableADC()

void WIBBase::EnableADC	(	uint64_t	iFEMB,
		uint64_t	enable )

Definition at line 268 of file WIBBase.cpp.

{
  if (iFEMB > 4 || iFEMB < 1) {
    BUException::WIB_INDEX_OUT_OF_RANGE e;
    e.Append("In WIBBase::Enable_ADC");
    throw e;
  }
  if (bool(enable))
    FEMB[iFEMB - 1]->Write(0x03, 0x00);
  else
    FEMB[iFEMB - 1]->Write(0x03, 0xFF);
  usleep((useconds_t)FEMBWriteSleepTime * 1e6);
}

GetAddress()

std::string WIBBase::GetAddress

(

)

Definition at line 38 of file WIBBase.cpp.

{
  return wib->GetRemoteAddress();
}

GetAddresses()

std::vector< std::string > WIBBase::GetAddresses ( uint16_t lower, uint16_t upper )

inline

Definition at line 41 of file WIBBase.hh.

                                                                  {
    return wib->GetAddresses(lower,upper);
  }

GetFEMBAddresses()

std::vector< std::string > WIBBase::GetFEMBAddresses ( uint16_t lower, uint16_t upper )

inline

Definition at line 44 of file WIBBase.hh.

                                                                      {
    return FEMB[0]->GetAddresses(lower,upper);
  }

GetFEMBItem()

Item const * WIBBase::GetFEMBItem	(	int	iFEMB,
		std::string const &	str )

Definition at line 131 of file WIBBase.cpp.

{
  if ((iFEMB > 4) || (iFEMB < 1)) {
    BUException::WIB_INDEX_OUT_OF_RANGE e;
    e.Append("In WIBBase::ReadFEMB\n");
    throw e;
  }
  return FEMB[iFEMB - 1]->GetItem(str);
}

GetFEMBNames()

std::vector< std::string > WIBBase::GetFEMBNames ( std::string const & regex )

inline

Definition at line 38 of file WIBBase.hh.

                                                            {
    return FEMB[0]->GetNames(regex);
  }

GetFEMBTagged()

std::vector< Item const * > WIBBase::GetFEMBTagged ( std::string const & tag )

inline

Definition at line 55 of file WIBBase.hh.

                                                               {
    return FEMB[0]->GetTagged(tag);
  }

GetItem()

Item const * WIBBase::GetItem

(

std::string const &

str

)

Definition at line 125 of file WIBBase.cpp.

{
  return wib->GetItem(str);
}

GetNames()

std::vector< std::string > WIBBase::GetNames ( std::string const & regex )

inline

Definition at line 35 of file WIBBase.hh.

                                                        {
    return wib->GetNames(regex);
  }

GetSVNVersion()

int WIBBase::GetSVNVersion ( )

inline

Definition at line 70 of file WIBBase.hh.

{return Version;}

GetTableNames()

std::vector< std::string > WIBBase::GetTableNames ( std::string const & regex )

inline

Definition at line 47 of file WIBBase.hh.

                                                             {
    return wib->GetTables(regex);
  }

GetTagged()

std::vector< Item const * > WIBBase::GetTagged ( std::string const & tag )

inline

Definition at line 51 of file WIBBase.hh.

                                                           {
    return wib->GetTagged(tag);
  }

operator=()

WIBBase & WIBBase::operator= ( const WIBBase & )

private

Read() [1/2]

uint32_t WIBBase::Read

(

std::string const &

address

)

Definition at line 157 of file WIBBase.cpp.

{
  return wib->Read(address);
}

Read() [2/2]

uint32_t WIBBase::Read

(

uint16_t

address

)

Definition at line 147 of file WIBBase.cpp.

{
  return wib->Read(address);
}

ReadFEMB() [1/2]

uint32_t WIBBase::ReadFEMB	(	int	iFEMB,
		std::string const &	address )

Definition at line 215 of file WIBBase.cpp.

{
  if ((iFEMB > 4) || (iFEMB < 1)) {
    BUException::WIB_INDEX_OUT_OF_RANGE e;
    e.Append("In WIBBase::ReadFEMB\n");
    throw e;
  }
  return FEMB[iFEMB - 1]->Read(address);
  usleep((useconds_t)FEMBReadSleepTime * 1e6);
}

ReadFEMB() [2/2]

uint32_t WIBBase::ReadFEMB	(	int	iFEMB,
		uint16_t	address )

Definition at line 204 of file WIBBase.cpp.

{
  if ((iFEMB > 4) || (iFEMB < 1)) {
    BUException::WIB_INDEX_OUT_OF_RANGE e;
    e.Append("In WIBBase::ReadFEMB\n");
    throw e;
  }
  return FEMB[iFEMB - 1]->Read(address);
  usleep((useconds_t)FEMBReadSleepTime * 1e6);
}

ReadI2C()

uint32_t WIBBase::ReadI2C	(	std::string const &	base_address,
		uint16_t	I2C_aaddress,
		uint8_t	byte_count = 4 )

Definition at line 44 of file WIBBase.cpp.

{
  // This is an incredibly inefficient version of this function since it does a dozen or so UDP transactions.
  // This is done to be generic, but it could be hard-coded by assuming address offsets and bit maps and done in one
  // write and one read.
 
  // Set type of read
  WriteWithRetry(base_address + ".RW", 1);
  // Set address
  WriteWithRetry(base_address + ".ADDR", address);
  // Set read size
  WriteWithRetry(base_address + ".BYTE_COUNT", byte_count);
  // Wait for the last transaction to be done
  while (ReadWithRetry(base_address + ".DONE") == 0x0) {
    usleep(1000);
  }
  // Run transaction
  WriteWithRetry(base_address + ".RUN", 0x1);
  // Wait for the last transaction to be done
  while (ReadWithRetry(base_address + ".DONE") == 0x0) {
    usleep(1000);
  }
  if (ReadWithRetry(base_address + ".ERROR")) {
    printf("%s 0x%08X\n", (base_address + ".ERROR").c_str(), ReadWithRetry(base_address + ".ERROR"));
    // Reset the I2C firmware
    WriteWithRetry(base_address + ".RESET", 1);
    char trans_info[] = "rd @ 0xFFFF";
    sprintf(trans_info, "rd @ 0x%04X", address & 0xFFFF);
    BUException::WIB_ERROR e;
    e.Append("I2C Error on ");
    e.Append(base_address.c_str());
    e.Append(trans_info);
    throw e;
  }
  return ReadWithRetry(base_address + ".RD_DATA");
}

ReadWithRetry() [1/2]

uint32_t WIBBase::ReadWithRetry

(

std::string const &

address

)

Definition at line 152 of file WIBBase.cpp.

{
  return wib->ReadWithRetry(address);
}

ReadWithRetry() [2/2]

uint32_t WIBBase::ReadWithRetry

(

uint16_t

address

)

Definition at line 142 of file WIBBase.cpp.

{
  return wib->ReadWithRetry(address);
}

Write() [1/6]

void WIBBase::Write	(	std::string const &	address,
		std::vector< uint32_t > const &	values )

Definition at line 188 of file WIBBase.cpp.

{
  wib->Write(address, values);
}

Write() [2/6]

void WIBBase::Write	(	std::string const &	address,
		uint32_t const *	values,
		size_t	word_count )

Definition at line 198 of file WIBBase.cpp.

{
  wib->Write(address, values, word_count);
}

Write() [3/6]

void WIBBase::Write	(	std::string const &	address,
		uint32_t	value )

Definition at line 178 of file WIBBase.cpp.

{
  wib->Write(address, value);
}

Write() [4/6]

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

Definition at line 183 of file WIBBase.cpp.

{
  wib->Write(address, values);
}

Write() [5/6]

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

Definition at line 193 of file WIBBase.cpp.

{
  wib->Write(address, values, word_count);
}

Write() [6/6]

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

Definition at line 168 of file WIBBase.cpp.

{
  wib->Write(address, value);
}

WriteFEMB() [1/2]

void WIBBase::WriteFEMB	(	int	iFEMB,
		std::string const &	address,
		uint32_t	value )

Definition at line 238 of file WIBBase.cpp.

{
  if ((iFEMB > 4) || (iFEMB < 1)) {
    BUException::WIB_INDEX_OUT_OF_RANGE e;
    e.Append("In WIBBase::WriteFEMB\n");
    throw e;
  }
  FEMB[iFEMB - 1]->WriteWithRetry(address, value);
  usleep((useconds_t)FEMBWriteSleepTime * 1e6);
}

WriteFEMB() [2/2]

void WIBBase::WriteFEMB	(	int	iFEMB,
		uint16_t	address,
		uint32_t	value )

Definition at line 227 of file WIBBase.cpp.

{
  if ((iFEMB > 4) || (iFEMB < 1)) {
    BUException::WIB_INDEX_OUT_OF_RANGE e;
    e.Append("In WIBBase::WriteFEMB\n");
    throw e;
  }
  FEMB[iFEMB - 1]->WriteWithRetry(address, value);
  usleep((useconds_t)FEMBWriteSleepTime * 1e6);
}

WriteFEMBBits()

void WIBBase::WriteFEMBBits	(	int	iFEMB,
		uint16_t	address,
		uint32_t	pos,
		uint32_t	mask,
		uint32_t	value )

Definition at line 250 of file WIBBase.cpp.

{
  if ((iFEMB > 4) || (iFEMB < 1)) {
    BUException::WIB_INDEX_OUT_OF_RANGE e;
    e.Append("In WIBBase::WriteFEMB\n");
    throw e;
  }
 
  uint32_t shiftVal = value & mask;
  uint32_t regMask = (mask << pos);
  uint32_t initVal = FEMB[iFEMB - 1]->Read(address);
  uint32_t newVal = ((initVal & ~(regMask)) | (shiftVal << pos));
 
  FEMB[iFEMB - 1]->WriteWithRetry(address, newVal);
  usleep((useconds_t)FEMBWriteSleepTime * 1e6);
}

WriteI2C()

void WIBBase::WriteI2C	(	std::string const &	base_address,
		uint16_t	I2C_address,
		uint32_t	data,
		uint8_t	byte_count = 4,
		bool	ignore_error = false )

Definition at line 81 of file WIBBase.cpp.

{
  // This is an incredibly inefficient version of this function since it does a dozen or so UDP transactions.
  // This is done to be generic, but it could be hard-coded by assuming address offsets and bit maps and done in one
  // write and one read.
 
  // Set type of read
  WriteWithRetry(base_address + ".RW", 0);
  // Set address
  WriteWithRetry(base_address + ".ADDR", address);
  // Set read size
  WriteWithRetry(base_address + ".BYTE_COUNT", byte_count);
  // Send data to write
  WriteWithRetry(base_address + ".WR_DATA", data);
  // Wait for the last transaction to be done
  while (ReadWithRetry(base_address + ".DONE") == 0x0) {
    usleep(1000);
  }
  // Run transaction
  WriteWithRetry(base_address + ".RUN", 0x1);
 
  // Wait for the last transaction to be done
  while (ReadWithRetry(base_address + ".DONE") == 0x0) {
    usleep(1000);
  }
 
  if (!ignore_error && ReadWithRetry(base_address + ".ERROR")) {
    // Reset the I2C firmware
    WriteWithRetry(base_address + ".RESET", 1);
    char trans_info[] = "wr 0xFFFFFFFF @ 0xFFFF";
    sprintf(trans_info, "wr 0x%08X @ 0x%04X", data, address & 0xFFFF);
    BUException::WIB_ERROR e;
    e.Append("I2C Error on ");
    e.Append(base_address.c_str());
    e.Append(trans_info);
    throw e;
  }
}

WriteWithRetry() [1/2]

void WIBBase::WriteWithRetry	(	std::string const &	address,
		uint32_t	value )

Definition at line 173 of file WIBBase.cpp.

{
  wib->WriteWithRetry(address, value);
}

WriteWithRetry() [2/2]

void WIBBase::WriteWithRetry	(	uint16_t	address,
		uint32_t	value )

Definition at line 163 of file WIBBase.cpp.

{
  wib->WriteWithRetry(address, value);
}

Member Data Documentation

FEMB

AddressTable* WIBBase::FEMB[FEMB_COUNT]

private

Definition at line 78 of file WIBBase.hh.

FEMBReadSleepTime

const float WIBBase::FEMBReadSleepTime

private

Definition at line 80 of file WIBBase.hh.

FEMBWriteSleepTime

const float WIBBase::FEMBWriteSleepTime

private

Definition at line 81 of file WIBBase.hh.

Version

const int WIBBase::Version

staticprivate

Definition at line 79 of file WIBBase.hh.

wib

AddressTable* WIBBase::wib

private

Definition at line 77 of file WIBBase.hh.

---

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

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