dunedaq::sspmodules::DeviceInterface Class Reference

#include <DeviceInterface.hpp>

Collaboration diagram for dunedaq::sspmodules::DeviceInterface:

Public Types
enum	State_t {   kUninitialized , kInitialized , kRunning , kStopping ,   kStopped , kBad }

Public Member Functions
	DeviceInterface ()
	~DeviceInterface ()
void	OpenSlowControl ()
void	ConfigureLEDCalib (const appmodel::SSPLEDCalibModule *conf)
void	ReadEventFromDevice (EventPacket &event)
void	SetRegister (unsigned int address, unsigned int value, unsigned int mask=0xFFFFFFFF)
void	SetRegisterArray (unsigned int address, std::vector< unsigned int > value)
void	SetRegisterArray (unsigned int address, unsigned int *value, unsigned int size)
void	ReadRegister (unsigned int address, unsigned int &value, unsigned int mask=0xFFFFFFFF)
void	ReadRegisterArray (unsigned int address, std::vector< unsigned int > &value, unsigned int size)
void	ReadRegisterArray (unsigned int address, unsigned int *value, unsigned int size)
void	SetRegisterByName (std::string name, unsigned int value)
void	SetRegisterElementByName (std::string name, unsigned int index, unsigned int value)
void	SetRegisterArrayByName (std::string name, unsigned int value)
void	SetRegisterArrayByName (std::string name, std::vector< unsigned int > values)
void	ReadRegisterByName (std::string name, unsigned int &value)
void	ReadRegisterElementByName (std::string name, unsigned int index, unsigned int &value)
void	ReadRegisterArrayByName (std::string name, std::vector< unsigned int > &values)
void	SetHardwareClockRateInMHz (unsigned int rate)
void	SetDummyPeriod (int period)
void	SetUseExternalTimestamp (bool val)
void	SetPartitionNumber (unsigned int val)
void	SetTimingAddress (unsigned int val)
void	PrintHardwareState ()
std::string	GetIdentifier ()
bool	exception () const

Private Member Functions
void	set_exception (bool exception)

Private Attributes
Device *	fDevice
unsigned long	fDeviceId
State_t	fState
bool	fUseExternalTimestamp
unsigned int	fHardwareClockRateInMHz
int	fDummyPeriod
bool	fSlowControlOnly
unsigned int	fPartitionNumber
unsigned int	fTimingAddress
std::atomic< bool >	exception_

Detailed Description

Definition at line 36 of file DeviceInterface.hpp.

Member Enumeration Documentation

State_t

enum dunedaq::sspmodules::DeviceInterface::State_t

Enumerator
kUninitialized
kInitialized
kRunning
kStopping
kStopped
kBad

Definition at line 40 of file DeviceInterface.hpp.

{kUninitialized,kInitialized,kRunning,kStopping,kStopped,kBad};

Constructor & Destructor Documentation

DeviceInterface()

dunedaq::sspmodules::DeviceInterface::DeviceInterface ( )

explicit

Definition at line 36 of file DeviceInterface.cxx.

  : fDeviceId(0)
  , fState(dunedaq::sspmodules::DeviceInterface::kUninitialized)
  , fUseExternalTimestamp(true)
  , fHardwareClockRateInMHz(128)
  , fDummyPeriod(-1)
  , fSlowControlOnly(false)
  , fPartitionNumber(0)
  , fTimingAddress(0)
  , exception_(false)
{
}

~DeviceInterface()

dunedaq::sspmodules::DeviceInterface::~DeviceInterface ( )

inline

Definition at line 46 of file DeviceInterface.hpp.

{ }

Member Function Documentation

ConfigureLEDCalib()

void dunedaq::sspmodules::DeviceInterface::ConfigureLEDCalib

(

const appmodel::SSPLEDCalibModule *

conf

)

Definition at line 261 of file DeviceInterface.cxx.

{
 
  TLOG_DEBUG(TLVL_ENTER_EXIT_METHODS) << "SSP LED Calib Device Interface Configure called.";
 
  std::stringstream ss;
  fDeviceId = inet_network(conf->get_board_ip().c_str()); // inet_network("10.73.137.56");
 
  // Ask device manager for a pointer to the specified device
  dunedaq::sspmodules::DeviceManager& devman = dunedaq::sspmodules::DeviceManager::Get();
  dunedaq::sspmodules::Device* device = 0;
 
 
  device = devman.OpenDevice(fDeviceId);
 
  if (!device) {
    TLOG_DEBUG(TLVL_WORK_STEPS) << "Unable to get handle to device; giving up!" << std::endl;
    throw(ENoSuchDevice());
  }
 
  fDevice = device;
 
  // Reset timing endpoint
  dunedaq::sspmodules::RegMap& duneReg = dunedaq::sspmodules::RegMap::Get();
 
  unsigned int pdts_status = 0;
  unsigned int pdts_control = 0;
  unsigned int dsp_clock_control = 0;
 
  fDevice->DeviceRead(duneReg.pdts_status, &pdts_status);
  TLOG_DEBUG(TLVL_FULL_DEBUG) << "The pdts_status read back as 0x" << std::hex << pdts_status << std::dec << std::endl;
  fDevice->DeviceRead(duneReg.pdts_control, &pdts_control);
  TLOG_DEBUG(TLVL_FULL_DEBUG) << "The pdts_control read back as 0x" << std::hex << pdts_control << std::dec << std::endl;
  fDevice->DeviceRead(duneReg.dsp_clock_control, &dsp_clock_control);
  TLOG_DEBUG(TLVL_FULL_DEBUG) << "The dsp_clock_control read back as 0x" << std::hex << dsp_clock_control << std::dec
                              << std::endl;
 
  unsigned int presentTimingAddress = (pdts_control >> 16) & 0xFF;
  unsigned int presentTimingPartition = pdts_control & 0x3;
 
  TLOG_DEBUG(TLVL_WORK_STEPS) << "SSP HW presently on partition " << presentTimingPartition << ", address 0x" << std::hex
                              << presentTimingAddress << " with endpoint status 0x" << (pdts_status & 0xF)
                              << " and dsp_clock_control at 0x" << dsp_clock_control << std::dec << std::endl;
 
  //if ((pdts_status & 0xF) >= 0x6 && (pdts_status & 0xF) <= 0x8 && presentTimingAddress == fTimingAddress &&
  //    presentTimingPartition == fPartitionNumber && dsp_clock_control == 0x31) {
  if ((pdts_status & 0xF) >= 0x6 && (pdts_status & 0xF) <= 0x8 && presentTimingAddress == fTimingAddress &&
      presentTimingPartition == fPartitionNumber && (dsp_clock_control & 0xF) == 0x1) { //NOTE THAT THIS WAS CHANGED SO THAT IF THE DSP_CLOCK_STATUS LOWEST BIT IS STILL HIGH 0x1
    //THEN THE CLOCK ALREADY IS ASSUMED TO BE GOOD, AND WE DON'T TRY TO RESYNCH WITH THE PDTS
 
    TLOG_DEBUG(TLVL_WORK_STEPS) << "Clock already looks ok... skipping endpoint reset." << std::endl;
  } else {
 
    TLOG_DEBUG(TLVL_WORK_STEPS) << "Syncing SSP LED Calib to PDTS (partition " << fPartitionNumber << ", endpoint address 0x"
                                << std::hex << fTimingAddress << std::dec << ")" << std::endl;
 
    unsigned int nTries = 0;
 
    while (nTries < 5) {
      fDevice->DeviceWrite(duneReg.dsp_clock_control, 0x30);
      TLOG_DEBUG(TLVL_FULL_DEBUG) << "The dsp_clock_control was set to 0x" << std::hex << 0x30 << std::dec
                                  << std::endl; // setting the lowest bit to 0 sets the DSP clock to internal.
      fDevice->DeviceWrite(duneReg.pdts_control, 0x80000000 + fPartitionNumber + fTimingAddress * 0x10000);
      TLOG_DEBUG(TLVL_FULL_DEBUG)
        << "The pdts_control value was set to 0x" << std::hex << 0x80000000 + fPartitionNumber + fTimingAddress * 0x10000
        << std::dec << std::endl; // setting the highest bit (0x80000000) to 1 puts the SSP in Reset mode for the PDTS.
 
      fDevice->DeviceRead(duneReg.pdts_status, &pdts_status);
      TLOG_DEBUG(TLVL_FULL_DEBUG) << "The pdts_status read back as 0x" << std::hex << pdts_status << std::dec
                                  << std::endl;
      fDevice->DeviceRead(duneReg.pdts_control, &pdts_control);
      TLOG_DEBUG(TLVL_FULL_DEBUG) << "The pdts_control read back as 0x" << std::hex << pdts_control << std::dec
                                  << std::endl;
      fDevice->DeviceRead(duneReg.dsp_clock_control, &dsp_clock_control);
      TLOG_DEBUG(TLVL_FULL_DEBUG) << "The dsp_clock_control read back as 0x" << std::hex << dsp_clock_control << std::dec
                                  << std::endl;
 
      fDevice->DeviceWrite(duneReg.pdts_control, 0x00000000 + fPartitionNumber + fTimingAddress * 0x10000);
      TLOG_DEBUG(TLVL_FULL_DEBUG) << "The pdts_status value was set to 0x" << std::hex
                                  << 0x00000000 + fPartitionNumber + fTimingAddress * 0x10000 << std::dec << std::endl;
      usleep(2000000); // setting the highest bit (0x80000000) to zero puts the SSP in run mode for the PDTS.
      fDevice->DeviceWrite(duneReg.dsp_clock_control,
                           0x31); // setting the lowest bit to 1 sets the DSP clock to external.
      TLOG_DEBUG(TLVL_FULL_DEBUG) << "The dsp_clock_control was set to 0x" << std::hex << 0x31 << std::dec << std::endl;
      usleep(2000000);
      fDevice->DeviceRead(duneReg.pdts_status, &pdts_status);
      TLOG_DEBUG(TLVL_FULL_DEBUG) << "The pdts_status read back as 0x" << std::hex << pdts_status << std::dec
                                  << std::endl;
      if ((pdts_status & 0xF) >= 0x6 && (pdts_status & 0xF) <= 0x8)
        break;
      TLOG_DEBUG(TLVL_WORK_STEPS) << "Timing endpoint sync failed (try " << nTries << ")" << std::endl;
      ++nTries;
    }
 
    if ((pdts_status & 0xF) >= 0x6 && (pdts_status & 0xF) <= 0x8) {
      TLOG_DEBUG(TLVL_FULL_DEBUG) << "The pdts_status value is 0x" << std::hex << pdts_status
                                  << " and the 0xF bit masked value is 0x" << (pdts_status & 0xF) << std::dec
                                  << std::endl;
      TLOG_DEBUG(TLVL_WORK_STEPS) << "Timing endpoint synced!" << std::endl;
    } else {
      TLOG_DEBUG(TLVL_FULL_DEBUG) << "The pdts_status value is 0x" << std::hex << pdts_status
                                  << " and the 0xF bit masked value is 0x" << (pdts_status & 0xF) << std::dec
                                  << std::endl;
      TLOG_DEBUG(TLVL_WORK_STEPS) << "Giving up on endpoint sync after 5 tries. Value of pdts_status register was 0x"
                                  << std::hex << pdts_status << std::dec << std::endl;
    }
  }
 
  TLOG_DEBUG(TLVL_WORK_STEPS) << "Woke up from 2 seconds of sleep and Waiting for endpoint to reach status 0x8..."
                              << std::endl;
  // Wait until pdts_status reaches exactly 0x8 before resolving.
  if ((pdts_status & 0xF) != 0x8) {
    TLOG_DEBUG(TLVL_WORK_STEPS) << "Waiting for endpoint to reach status 0x8..." << std::endl;
    TLOG_DEBUG(TLVL_FULL_DEBUG) << "The pdts_status value is 0x" << std::hex << pdts_status
                                << " and the 0xF bit masked value is 0x" << (pdts_status & 0xF) << std::dec << std::endl;
  }
  int nTries = 0;
  while ((pdts_status & 0xF) != 0x8) {
    if (nTries == 2) {
      TLOG_DEBUG(TLVL_WORK_STEPS) << "Wrong PDTS status!" << std::endl;
      //ers::fatal( DeviceInterfacePDTSStatus(ERS_HERE) );
      throw DeviceInterfacePDTSStatus(ERS_HERE);
    }
    usleep(2000000);
    TLOG_DEBUG(TLVL_WORK_STEPS) << "Woke up from 2 seconds of sleep and Waiting for endpoint to reach status 0x8..."
                                << std::endl;
    fDevice->DeviceRead(duneReg.pdts_status, &pdts_status);
    TLOG_DEBUG(TLVL_FULL_DEBUG) << "The pdts_status value is 0x" << std::hex << pdts_status
                                << " and the 0xF bit masked value is 0x" << (pdts_status & 0xF) << std::dec << std::endl;
    nTries++;
  }
 
  TLOG_DEBUG(TLVL_WORK_STEPS) << "Endpoint is in running state, continuing with configuration!" << std::endl;
  TLOG_DEBUG(TLVL_ENTER_EXIT_METHODS) << "SSP LED Calib Device Interface Configured complete.";
} // NOLINT(readability/fn_size)

exception()

bool dunedaq::sspmodules::DeviceInterface::exception ( ) const

inline

Definition at line 118 of file DeviceInterface.hpp.

{ return exception_.load(); }

GetIdentifier()

std::string dunedaq::sspmodules::DeviceInterface::GetIdentifier

(

)

Definition at line 398 of file DeviceInterface.cxx.

{
  std::string ident;
  boost::asio::ip::address ip = boost::asio::ip::address_v4(fDeviceId);
  std::string ipString = ip.to_string();
  ident += "(";
  ident += ipString;
  ident += "):";
  return ident;
}

OpenSlowControl()

void dunedaq::sspmodules::DeviceInterface::OpenSlowControl

(

)

Definition at line 50 of file DeviceInterface.cxx.

{
 
  TLOG_DEBUG(TLVL_FULL_DEBUG) << "SSP Device Interface OpenSlowControl called.";
  // Ask device manager for a pointer to the specified device
  dunedaq::sspmodules::DeviceManager& devman = dunedaq::sspmodules::DeviceManager::Get();
  dunedaq::sspmodules::Device* device = 0;
 
  device = devman.OpenDevice(fDeviceId, true); // slow control only
 
  if (!device) {
    TLOG_DEBUG(TLVL_WORK_STEPS) << "Unable to get handle to device; giving up!" << std::endl;
    throw(ENoSuchDevice());
  }
 
  fDevice = device;
  fSlowControlOnly = true;
  TLOG_DEBUG(TLVL_ENTER_EXIT_METHODS) << "SSP Device Interface OpenSlowControl completed.";
}

PrintHardwareState()

void dunedaq::sspmodules::DeviceInterface::PrintHardwareState

(

)

Definition at line 409 of file DeviceInterface.cxx.

{
 
  TLOG_DEBUG(TLVL_WORK_STEPS) << "===SSP DIAGNOSTIC REGISTERS===" << std::endl;
 
  dunedaq::sspmodules::RegMap& duneReg = dunedaq::sspmodules::RegMap::Get();
  unsigned int val;
 
  fDevice->DeviceRead(duneReg.dp_clock_status, &val);
  TLOG_DEBUG(TLVL_WORK_STEPS) << "dsp_clock_status: 0x" << std::hex << val << std::endl;
  fDevice->DeviceRead(duneReg.live_timestamp_msb, &val);
  TLOG_DEBUG(TLVL_WORK_STEPS) << "live_timestamp_msb: " << val << std::endl;
  fDevice->DeviceRead(duneReg.live_timestamp_lsb, &val);
  TLOG_DEBUG(TLVL_WORK_STEPS) << "live_timestamp_lsb: " << val << std::endl;
  fDevice->DeviceRead(duneReg.sync_delay, &val);
  TLOG_DEBUG(TLVL_WORK_STEPS) << "sync_delay: " << val << std::endl;
  fDevice->DeviceRead(duneReg.sync_count, &val);
  TLOG_DEBUG(TLVL_WORK_STEPS) << "sync_count: " << val << std::dec << std::endl;
}

ReadEventFromDevice()

void dunedaq::sspmodules::DeviceInterface::ReadEventFromDevice

(

EventPacket &

event

)

ReadRegister()

void dunedaq::sspmodules::DeviceInterface::ReadRegister	(	unsigned int	address,
		unsigned int &	value,
		unsigned int	mask = 0xFFFFFFFF )

Definition at line 172 of file DeviceInterface.cxx.

{
 
  if (mask == 0xFFFFFFFF) {
    fDevice->DeviceRead(address, &value);
  } else {
    fDevice->DeviceReadMask(address, mask, &value);
  }
}

ReadRegisterArray() [1/2]

void dunedaq::sspmodules::DeviceInterface::ReadRegisterArray	(	unsigned int	address,
		std::vector< unsigned int > &	value,
		unsigned int	size )

Definition at line 183 of file DeviceInterface.cxx.

{
 
  value.resize(size);
  this->ReadRegisterArray(address, &(value[0]), size);
}

ReadRegisterArray() [2/2]

void dunedaq::sspmodules::DeviceInterface::ReadRegisterArray	(	unsigned int	address,
		unsigned int *	value,
		unsigned int	size )

Definition at line 193 of file DeviceInterface.cxx.

{
 
  fDevice->DeviceArrayRead(address, size, value);
}

ReadRegisterArrayByName()

void dunedaq::sspmodules::DeviceInterface::ReadRegisterArrayByName	(	std::string	name,
		std::vector< unsigned int > &	values )

Definition at line 254 of file DeviceInterface.cxx.

{
  dunedaq::sspmodules::RegMap::Register reg = (dunedaq::sspmodules::RegMap::Get())[name];
  this->ReadRegisterArray(reg[0], values, reg.Size());
}

ReadRegisterByName()

void dunedaq::sspmodules::DeviceInterface::ReadRegisterByName	(	std::string	name,
		unsigned int &	value )

Definition at line 236 of file DeviceInterface.cxx.

{
  dunedaq::sspmodules::RegMap::Register reg = (dunedaq::sspmodules::RegMap::Get())[name];
 
  this->ReadRegister(reg, value, reg.ReadMask());
}

ReadRegisterElementByName()

void dunedaq::sspmodules::DeviceInterface::ReadRegisterElementByName	(	std::string	name,
		unsigned int	index,
		unsigned int &	value )

Definition at line 244 of file DeviceInterface.cxx.

{
  dunedaq::sspmodules::RegMap::Register reg = (dunedaq::sspmodules::RegMap::Get())[name][index];
 
  this->ReadRegister(reg, value, reg.ReadMask());
}

set_exception()

void dunedaq::sspmodules::DeviceInterface::set_exception ( bool exception )

inlineprivate

Definition at line 133 of file DeviceInterface.hpp.

{ exception_.store( exception ); }

SetDummyPeriod()

void dunedaq::sspmodules::DeviceInterface::SetDummyPeriod ( int period )

inline

Definition at line 106 of file DeviceInterface.hpp.

{fDummyPeriod=period;}

SetHardwareClockRateInMHz()

void dunedaq::sspmodules::DeviceInterface::SetHardwareClockRateInMHz ( unsigned int rate )

inline

Definition at line 104 of file DeviceInterface.hpp.

{fHardwareClockRateInMHz = rate;}

SetPartitionNumber()

void dunedaq::sspmodules::DeviceInterface::SetPartitionNumber ( unsigned int val )

inline

Definition at line 110 of file DeviceInterface.hpp.

{fPartitionNumber=val;}

SetRegister()

void dunedaq::sspmodules::DeviceInterface::SetRegister	(	unsigned int	address,
		unsigned int	value,
		unsigned int	mask = 0xFFFFFFFF )

Definition at line 147 of file DeviceInterface.cxx.

{
 
  if (mask == 0xFFFFFFFF) {
    fDevice->DeviceWrite(address, value);
  } else {
    fDevice->DeviceWriteMask(address, mask, value);
  }
}

SetRegisterArray() [1/2]

void dunedaq::sspmodules::DeviceInterface::SetRegisterArray	(	unsigned int	address,
		std::vector< unsigned int >	value )

Definition at line 158 of file DeviceInterface.cxx.

{
 
  this->SetRegisterArray(address, &(value[0]), value.size());
}

SetRegisterArray() [2/2]

void dunedaq::sspmodules::DeviceInterface::SetRegisterArray	(	unsigned int	address,
		unsigned int *	value,
		unsigned int	size )

Definition at line 165 of file DeviceInterface.cxx.

{
 
  fDevice->DeviceArrayWrite(address, size, value);
}

SetRegisterArrayByName() [1/2]

void dunedaq::sspmodules::DeviceInterface::SetRegisterArrayByName	(	std::string	name,
		std::vector< unsigned int >	values )

Definition at line 224 of file DeviceInterface.cxx.

{
  dunedaq::sspmodules::RegMap::Register reg = (dunedaq::sspmodules::RegMap::Get())[name];
  if (reg.Size() != values.size()) {
    TLOG_DEBUG(TLVL_WORK_STEPS) << "Request to set named register array " << name << ", length " << reg.Size()
                                << "with vector of " << values.size() << " values!" << std::endl;
    throw(std::invalid_argument(""));
  }
  this->SetRegisterArray(reg[0], values);
}

SetRegisterArrayByName() [2/2]

void dunedaq::sspmodules::DeviceInterface::SetRegisterArrayByName	(	std::string	name,
		unsigned int	value )

Definition at line 215 of file DeviceInterface.cxx.

{
  unsigned int regSize = (dunedaq::sspmodules::RegMap::Get())[name].Size();
  std::vector<unsigned int> arrayContents(regSize, value);
 
  this->SetRegisterArrayByName(name, arrayContents);
}

SetRegisterByName()

void dunedaq::sspmodules::DeviceInterface::SetRegisterByName	(	std::string	name,
		unsigned int	value )

Definition at line 199 of file DeviceInterface.cxx.

{
  dunedaq::sspmodules::RegMap::Register reg = (dunedaq::sspmodules::RegMap::Get())[name];
 
  this->SetRegister(reg, value, reg.WriteMask());
}

SetRegisterElementByName()

void dunedaq::sspmodules::DeviceInterface::SetRegisterElementByName	(	std::string	name,
		unsigned int	index,
		unsigned int	value )

Definition at line 207 of file DeviceInterface.cxx.

{
  dunedaq::sspmodules::RegMap::Register reg = (dunedaq::sspmodules::RegMap::Get())[name][index];
 
  this->SetRegister(reg, value, reg.WriteMask());
}

SetTimingAddress()

void dunedaq::sspmodules::DeviceInterface::SetTimingAddress ( unsigned int val )

inline

Definition at line 112 of file DeviceInterface.hpp.

{fTimingAddress=val;}

SetUseExternalTimestamp()

void dunedaq::sspmodules::DeviceInterface::SetUseExternalTimestamp ( bool val )

inline

Definition at line 108 of file DeviceInterface.hpp.

{fUseExternalTimestamp = val;}

Member Data Documentation

exception_

std::atomic<bool> dunedaq::sspmodules::DeviceInterface::exception_

private

Definition at line 148 of file DeviceInterface.hpp.

fDevice

Device* dunedaq::sspmodules::DeviceInterface::fDevice

private

Definition at line 124 of file DeviceInterface.hpp.

fDeviceId

unsigned long dunedaq::sspmodules::DeviceInterface::fDeviceId

private

Definition at line 127 of file DeviceInterface.hpp.

fDummyPeriod

int dunedaq::sspmodules::DeviceInterface::fDummyPeriod

private

Definition at line 139 of file DeviceInterface.hpp.

fHardwareClockRateInMHz

unsigned int dunedaq::sspmodules::DeviceInterface::fHardwareClockRateInMHz

private

Definition at line 137 of file DeviceInterface.hpp.

fPartitionNumber

unsigned int dunedaq::sspmodules::DeviceInterface::fPartitionNumber

private

Definition at line 143 of file DeviceInterface.hpp.

fSlowControlOnly

bool dunedaq::sspmodules::DeviceInterface::fSlowControlOnly

private

Definition at line 141 of file DeviceInterface.hpp.

fState

State_t dunedaq::sspmodules::DeviceInterface::fState

private

Definition at line 131 of file DeviceInterface.hpp.

fTimingAddress

unsigned int dunedaq::sspmodules::DeviceInterface::fTimingAddress

private

Definition at line 145 of file DeviceInterface.hpp.

fUseExternalTimestamp

bool dunedaq::sspmodules::DeviceInterface::fUseExternalTimestamp

private

Definition at line 135 of file DeviceInterface.hpp.

---

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

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