WIB Class Reference

#include <WIB.hh>

Inheritance diagram for WIB:

Collaboration diagram for WIB:

Public Types
enum	WIB_DAQ_t { UNKNOWN , RCE , FELIX }

Public Member Functions
	WIB (std::string const &address, std::string const &WIBAddressTable="WIB.adt", std::string const &FEMBAddressTable="FEMB.adt", bool fullStart=true)
	~WIB ()
void	FullStart ()
void	InitializeWIB ()
void	ResetWIB (bool reset_udp=false)
void	InitializeDTS (uint8_t PDTSsource=0, uint8_t clockSource=0, uint32_t PDTSAlignment_timeout=0)
void	EnableDAQLink (uint8_t iDAQLink)
void	EnableDAQLink_Lite (uint8_t iDAQLink, uint8_t enable)
void	StartSyncDTS ()
void	ResetWIBAndCfgDTS (uint8_t localClock, uint8_t PDTS_TGRP, uint8_t PDTSsource=0, uint32_t PDTSAlignment_timeout=0)
void	CheckedResetWIBAndCfgDTS (uint8_t localClock, uint8_t PDTS_TGRP, uint8_t PDTSsource=0, uint32_t PDTSAlignment_timeout=0)
void	StartStreamToDAQ (bool l1=true, bool l2=true, bool l3=false, bool l4=false)
void	PDTSInRunningState ()
void	EnableFEMBCNC ()
void	DisableFEMBCNC ()
void	FEMBPower (uint8_t iFEMB, bool turnOn)
void	SourceFEMB (uint64_t iDAQLink, uint64_t real)
void	StartEventBuilder (uint8_t mask=0xF)
void	StopEventBuilder (uint8_t mask=0xF)
void	WriteQSFP (uint16_t address, uint32_t value, uint8_t byte_count)
uint32_t	ReadQSFP (uint16_t address, uint8_t byte_count)
void	WriteDTS_CDS (uint16_t address, uint32_t value, uint8_t byte_count=4, bool ignore_error=false)
uint32_t	ReadDTS_CDS (uint16_t address, uint8_t byte_count=4)
float	ConfigureDTSCDS (uint8_t source=0)
void	WriteDTS_SI5344 (uint16_t address, uint32_t value, uint8_t byte_count=4)
uint32_t	ReadDTS_SI5344 (uint16_t address, uint8_t byte_count=4)
void	SetDTS_SI5344Page (uint8_t page)
uint8_t	GetDTS_SI5344Page ()
uint8_t	GetDTS_SI5344AddressPage (uint16_t address)
void	LoadConfigDTS_SI5344 (std::string const &fileName)
void	ResetSi5344 ()
void	SelectSI5344 (uint64_t input, bool enable)
void	SelectSI5342 (uint64_t input, bool enable)
void	WriteDAQ_SI5342 (uint16_t address, uint32_t value, uint8_t byte_count=4)
uint32_t	ReadDAQ_SI5342 (uint16_t address, uint8_t byte_count=4)
void	SetDAQ_SI5342Page (uint8_t page)
uint8_t	GetDAQ_SI5342Page ()
uint8_t	GetDAQ_SI5342AddressPage (uint16_t address)
void	LoadConfigDAQ_SI5342 (std::string const &fileName)
void	ResetSi5342 ()
std::vector< uint32_t >	CaptureHistory (std::string const &address)
std::vector< uint128_t >	CaptureHistory (std::string const &address, size_t wordCount)
uint32_t	ReadLocalFlash (uint16_t address)
std::vector< uint32_t >	ReadLocalFlash (uint16_t address, size_t n)
void	WriteLocalFlash (uint16_t address, uint32_t data)
void	WriteLocalFlash (uint16_t address, std::vector< uint32_t > const &data)
void	FlashCheckBusy ()
void	ReadFlash (std::string const &fileName, uint8_t update_percentage=101)
void	WriteFlash (std::vector< uint32_t > data, uint8_t update_percentage=101)
void	ProgramFlash (std::string const &fileName, uint8_t update_percentage=101)
void	EraseFlash (bool print_updates=false)
void	CheckFlash (std::vector< uint32_t > data, uint8_t update_percentage=101)
std::vector< data_8b10b_t >	ReadOutCDLinkSpyBuffer ()
std::vector< data_8b10b_t >	ReadDAQLinkSpyBuffer (uint8_t iDAQLink, uint8_t trigger_mode=0)
void	SetupFEMBExtClock (uint8_t iFEMB)
	Setup FEMB External Clock.
void	WriteFEMBPhase (uint8_t iFEMB, uint16_t clk_phase_data)
bool	TryFEMBPhases (uint8_t iFEMB, std::vector< uint16_t > phases)
bool	HuntFEMBPhase (uint8_t iFEMB, uint16_t clk_phase_data_start)
void	ConfigFEMB (uint8_t iFEMB, std::vector< uint32_t > fe_config, std::vector< uint16_t > clk_phases, uint8_t pls_mode=0, uint8_t pls_dac_val=0, uint8_t start_frame_mode_sel=1, uint8_t start_frame_swap=1)
	Setup FEMB in real or pulser data mode.
void	ConfigFEMBFakeData (uint8_t iFEMB, uint8_t fake_mode, uint32_t fake_word, uint8_t femb_number, std::vector< uint32_t > fake_samples, uint8_t start_frame_mode_sel=1, uint8_t start_frame_swap=1)
	Setup FEMB in fake data mode.
void	ConfigFEMBMode (uint8_t iFEMB, uint32_t pls_cs, uint32_t dac_sel, uint32_t fpga_dac, uint32_t asic_dac, uint32_t mon_cs)
uint16_t	SetupFEMBASICs (uint8_t iFEMB, uint8_t gain, uint8_t shape, uint8_t highBaseline, bool highLeakage, bool leakagex10, bool acCoupling, bool buffer, bool useExtClock, uint8_t internalDACControl, uint8_t internalDACValue)
	Setup FEMB ASICs.
void	SetupFPGAPulser (uint8_t iFEMB, uint8_t dac_val)
void	SetupInternalPulser (uint8_t iFEMB)
uint16_t	SetupASICPulserBits (uint8_t iFEMB)
uint16_t	SetupFEMBASICs (uint8_t iFEMB, std::vector< uint32_t > registerList)
	Setup FEMB ASICs.
void	ConfigWIBFakeData (bool enableFakeFEMB1, bool enableFakeFEMB2, bool enableFakeFEMB3, bool enableFakeFEMB4, bool counter)
void	SetFEMBFakeCOLDATAMode (uint8_t iFEMB, uint8_t iCD, bool mode=0)
uint8_t	GetFEMBFakeCOLDATAMode (uint8_t iFEMB, uint8_t iCD)
void	SetFEMBStreamSource (uint8_t iFEMB, uint8_t iStream, bool real=true)
uint8_t	GetFEMBStreamSource (uint8_t iFEMB, uint8_t iStream)
void	SetEventBuilderDebugMode (uint8_t mask=0xF)
uint8_t	GetEventBuilderDebugMode ()
char	GetFEMBChar (uint8_t iFEMB)
char	GetDAQLinkChar (uint8_t iDAQLink)
char	GetFEMBCDChar (uint8_t iCD)
bool	CheckDAQLinkInRange (uint8_t iDAQLink)
bool	CheckFEMBInRange (uint8_t iFEMB)
bool	CheckFEMBStreamInRange (uint8_t iStream)
bool	CheckFEMBCDInRange (uint8_t iCD)
uint8_t	GetFEMBCount ()
WIB_DAQ_t	GetDAQMode ()
void	SetContinueOnFEMBRegReadError (bool enable)
void	SetContinueOnFEMBSPIError (bool enable)
void	SetContinueOnFEMBSyncError (bool enable)
void	SetContinueIfListOfFEMBClockPhasesDontSync (bool enable)
Public Member Functions inherited from WIBBase
	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 ()

Public Attributes
bool	started

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

Private Attributes
WIB_DAQ_t	DAQMode
uint8_t	FEMBCount
uint8_t	FEMBStreamCount
uint8_t	FEMBCDACount
uint8_t	DAQLinkCount
bool	ContinueOnFEMBRegReadError
bool	ContinueOnFEMBSPIError
bool	ContinueOnFEMBSyncError
bool	ContinueIfListOfFEMBClockPhasesDontSync

Detailed Description

Definition at line 26 of file WIB.hh.

Member Enumeration Documentation

WIB_DAQ_t

enum WIB::WIB_DAQ_t

Enumerator
UNKNOWN
RCE
FELIX

Definition at line 208 of file WIB.hh.

{UNKNOWN,RCE,FELIX};

Constructor & Destructor Documentation

WIB() [1/3]

WIB::WIB	(	std::string const &	address,
		std::string const &	WIBAddressTable = "WIB.adt",
		std::string const &	FEMBAddressTable = "FEMB.adt",
		bool	fullStart = true )

Definition at line 7 of file WIB.cpp.

  : WIBBase(address, WIBAddressTable, FEMBAddressTable)
  , DAQMode(UNKNOWN)
  , FEMBStreamCount(4)
  , FEMBCDACount(2)
  , ContinueOnFEMBRegReadError(false)
  , ContinueOnFEMBSPIError(false)
  , ContinueOnFEMBSyncError(true)
  , ContinueIfListOfFEMBClockPhasesDontSync(true)
{
 
  if (fullStart) {
    // Figure out what kind of WIB firmware we are dealing with
    FEMBCount = Read("SYSTEM.FEMB_COUNT");
    DAQLinkCount = Read("SYSTEM.DAQ_LINK_COUNT");
    // Hardcoded lookup for RCE and FELIX
    if ((FEMBCount == 4) && (DAQLinkCount == 4)) {
      DAQMode = RCE;
    } else if ((FEMBCount == 4) && (DAQLinkCount == 2)) {
      DAQMode = FELIX;
    }
    // TODO check FEMBStreamCount and FEMCDACount from registers on the WIB
    // TODO create those registers
    Write("POWER.ENABLE.MASTER_BIAS", 1);
    started = true;
  }
}

~WIB()

WIB::~WIB

(

)

Definition at line 38 of file WIB.cpp.

{}

WIB() [2/3]

WIB::WIB ( )

private

WIB() [3/3]

WIB::WIB ( const WIB & other )

private

Member Function Documentation

CaptureHistory() [1/2]

std::vector< uint32_t > WIB::CaptureHistory

(

std::string const &

address

)

Definition at line 4 of file WIB_History.cpp.

{
  std::vector<uint32_t> ret;
  uint32_t val;
  while ((val = Read(address)) & 0x1) {
    ret.push_back(val);
  }
  return ret;
}

CaptureHistory() [2/2]

std::vector< uint128_t > WIB::CaptureHistory	(	std::string const &	address,
		size_t	wordCount )

Definition at line 15 of file WIB_History.cpp.

{
  std::vector<uint128_t> ret;
  bool capture = true;
  uint16_t addr = GetItem(address)->address;
  while (capture) {
    uint128_t val = 0;
    // Read address last since it causes the incr.
    for (size_t offset = wordCount; offset > 0; offset--) {
      val |= uint128_t(Read(addr + (offset - 1)) << 32 * (offset - 1));
    }
    ret.push_back(val);
    if (!(val & 0x1)) {
      break;
    }
  }
  return ret;
}

CheckDAQLinkInRange()

bool WIB::CheckDAQLinkInRange

(

uint8_t

iDAQLink

)

Definition at line 521 of file WIB.cpp.

{
  if (!((iDAQLink > 0) && (iDAQLink <= DAQLinkCount))) {
    BUException::WIB_INDEX_OUT_OF_RANGE e;
    e.Append("DAQ Link\n");
    throw e;
  }
  return true;
}

CheckedResetWIBAndCfgDTS()

void WIB::CheckedResetWIBAndCfgDTS	(	uint8_t	localClock,
		uint8_t	PDTS_TGRP,
		uint8_t	PDTSsource = 0,
		uint32_t	PDTSAlignment_timeout = 0 )

Definition at line 289 of file WIB.cpp.

{
  if (DAQMode == UNKNOWN) {
    BUException::WIB_DAQMODE_UNKNOWN e;
    throw e;
  }
  if (localClock > 1) {
    BUException::WIB_BAD_ARGS e;
    e.Append("localClock > 1; must be 0 (for DTS) or 1 (for local clock)\n");
    throw e;
  }
  if (PDTSsource > 1) {
    BUException::WIB_BAD_ARGS e;
    e.Append("PDTSsource > 1; must be 0 (for backplane) or 1 (for front panel)\n");
    throw e;
  }
  if (16 <= PDTS_TGRP) {
    BUException::WIB_BAD_ARGS e;
    e.Append("PDTS TGRP > 15; must be 0 to 15\n");
    throw e;
  }
 
  bool reset_check = false;
  // Check if we are already in a good state
  if (localClock > 0) {
    printf("Checking if locked on local clock\n");
    reset_check = ((Read("DTS.CONVERT_CONTROL.EN_FAKE") != 1) || (Read("DTS.CCONVERT_CONTROL.LOCAL_TIMESTAMP") != 1) ||
                   (Read("FEMB_CNC.CNC_CLOCK_SELECT") != 1)
                   //                  || (Read("FEMB_CNC.ENABLE_DTS_CMDS") != 1)
                   || (Read("DTS.SI5344.INPUT_SELECT") != 1) || (Read("DTS.SI5344.ENABLE") != 1));
    if (!reset_check) {
      printf("Already in a good state\n");
    } else {
      printf("Need to reset for local clocking\n");
    }
  } else {
    printf("Checking if locked on PDTS\n");
    reset_check = ((Read("DTS.PDTS_TGRP") != PDTS_TGRP) || (Read("FEMB_CNC.CNC_CLOCK_SELECT") != 1) ||
                   (Read("DTS.PDTS_ENABLE") != 1) || (Read("DTS.CDS.LOL") != 0) || (Read("DTS.CDS.LOS") != 0) ||
                   (ReadWithRetry("DTS.SI5344.INPUT_SELECT") != 0) || (ReadWithRetry("DTS.SI5344.LOS") != 0) ||
                   (ReadWithRetry("DTS.SI5344.LOL") != 0) || (ReadWithRetry("DTS.SI5344.ENABLE") != 1) ||
                   (ReadWithRetry("DTS.PDTS_STATE") != 0x8));
    if (!reset_check) {
      printf("Already in a good state\n");
    } else {
      printf("Need to reset for PDTS\n");
    }
  }
 
  // Check the SI5342 if we're attached to FELIX
  if (DAQMode == FELIX) {
 
    if ((Read("DAQ.SI5342.ENABLE") == 0) || (Read("DAQ.SI5342.INPUT_SELECT") != 1) || (Read("DAQ.SI5342.LOL") == 1) ||
        (Read("DAQ.SI5342.LOS_XAXB") == 1) || (Read("DAQ.SI5342.LOS_2") == 1)) {
      printf("Need to reset for SI5342\n");
      reset_check = true;
    } else {
      printf("SI5342 in good state\n");
    }
  }
 
  if (reset_check) {
    // get this register so we can leave it in the state it started in
    uint32_t slow_control_dnd = Read("SYSTEM.SLOW_CONTROL_DND");
 
    ResetWIB();
    Write("SYSTEM.SLOW_CONTROL_DND", 1);
 
    for (size_t iFEMB = 1; iFEMB <= 4; iFEMB++) {
      FEMBPower(iFEMB, 0);
    }
 
    // make sure everything DTS is off
    Write("DTS.CONVERT_CONTROL.HALT", 1);
    Write("DTS.CONVERT_CONTROL.ENABLE", 0);
    Write("DTS.CONVERT_CONTROL.START_SYNC", 0);
    sleep(1);
 
    if (localClock > 0) {
      printf("Configuring local clock\n");
      // Configure the SI5344 to use the local oscillator instead of the PDTS
      LoadConfigDTS_SI5344("default");
      sleep(1);
      SelectSI5344(1, 1);
      sleep(1);
      Write("DTS.CONVERT_CONTROL.EN_FAKE", 1);
      Write("DTS.CONVERT_CONTROL.LOCAL_TIMESTAMP", 1);
      Write("FEMB_CNC.CNC_CLOCK_SELECT", 1);
      //      Write("FEMB_CNC.ENABLE_DTS_CMDS",1);
      sleep(1);
    } else {
      // Configure the clocking for the PDTS (assumes the PDTS is sending idle or something)
      printf("Configuring DTS\n");
      Write("DTS.PDTS_TGRP", PDTS_TGRP);
      printf("Using timing group 0x%X\n", PDTS_TGRP);
      InitializeDTS(PDTSsource, 0, PDTSAlignment_timeout);
      sleep(1);
      Write("FEMB_CNC.CNC_CLOCK_SELECT", 1);
      sleep(1);
      // We are ready for the PDTS, start searching
      Write("DTS.PDTS_ENABLE", 1);
      sleep(1);
    }
 
    Write("SYSTEM.SLOW_CONTROL_DND", slow_control_dnd);
  }
  // Now we have the 128MHz clock
  std::cout << "Resetting DAQ Links" << std::endl;
  size_t nLinks = 4;
  if (DAQMode == FELIX) {
    nLinks = 2;
  }
  for (size_t iLink = 1; iLink <= nLinks; ++iLink) {
    std::cout << iLink << std::endl;
    EnableDAQLink_Lite(iLink, 0);
  }
 
  Write("FEMB1.DAQ.ENABLE", 0);
  Write("FEMB2.DAQ.ENABLE", 0);
  Write("FEMB3.DAQ.ENABLE", 0);
  Write("FEMB4.DAQ.ENABLE", 0);
}

CheckFEMBCDInRange()

bool WIB::CheckFEMBCDInRange

(

uint8_t

iCD

)

Definition at line 616 of file WIB.cpp.

{
  if (!((iCDA > 0) && (iCDA <= FEMBCDACount))) {
    BUException::WIB_INDEX_OUT_OF_RANGE e;
    e.Append("FEMB CDA");
    throw e;
  }
  return true;
}

CheckFEMBInRange()

bool WIB::CheckFEMBInRange

(

uint8_t

iFEMB

)

Definition at line 563 of file WIB.cpp.

{
  if (!((iFEMB > 0) && (iFEMB <= FEMBCount))) {
    BUException::WIB_INDEX_OUT_OF_RANGE e;
    e.Append("FEMB\n");
    throw e;
  }
  return true;
}

CheckFEMBStreamInRange()

bool WIB::CheckFEMBStreamInRange

(

uint8_t

iStream

)

Definition at line 605 of file WIB.cpp.

{
  if (!((iStream > 0) && (iStream <= FEMBStreamCount))) {
    BUException::WIB_INDEX_OUT_OF_RANGE e;
    e.Append("FEMB Stream");
    throw e;
  }
  return true;
}

CheckFlash()

void WIB::CheckFlash	(	std::vector< uint32_t >	data,
		uint8_t	update_percentage = 101 )

Definition at line 301 of file WIB_Flash.cpp.

{
  bool print_updates = false;
  if (update_percentage < 100) {
    print_updates = true;
  }
  size_t update_delta = (update_percentage * float(16 * 1024 * 1024 / 4)) / 100;
  size_t next_update = update_delta;
 
  if (print_updates) {
    fprintf(stderr, "   Checking flash\n");
    fprintf(stderr, "   [");
    for (size_t i = 0; i < 100.0 / update_percentage; i++) {
      fprintf(stderr, "=");
    }
    fprintf(stderr, "]\n   [");
  }
  // program flash in groups of 64 32bit words (256 bytes)
  uint32_t flashAddress = 0;
  uint32_t blockRegMapAddress = GetItem("FLASH.DATA00")->address;
 
  for (size_t currentBlockStartIndex = 0; currentBlockStartIndex < 16 * 1024 * 1024 / 4;) {
    FlashCheckBusy();
 
    // Find size of this block to write (usually just 64 (256bytes)), but the last one might be smaller.
    size_t blockSize = std::min(size_t(64), flashData.size() - currentBlockStartIndex);
    // Set adddress
    WriteWithRetry("FLASH.ADDRESS", flashAddress);
    // set block size (in bytes and is 1 less than value; 0 means 1 byte, 255 means 256 bytes)
    WriteWithRetry("FLASH.BYTE_COUNT", (blockSize * sizeof(uint32_t)) - 1);
    // Start read
    WriteWithRetry("FLASH.RUN_COMMAND", 0x5);
 
    FlashCheckBusy();
 
    // Check the data.
    for (size_t iBlockWord = 0; iBlockWord < blockSize; iBlockWord++) {
      // flashData:     Address in WIB register map of this 32bit word
      // ReadWithRetry: Data from the flash for this word
      uint32_t dataRead;
      if ((dataRead = ReadWithRetry(blockRegMapAddress + iBlockWord)) !=
          flashData[currentBlockStartIndex + iBlockWord]) {
        BUException::WIB_FLASH_ERROR e;
        char errorbuffer[] = "Error on index 0xXXXXXXXX: 0xXXXXXXXX != 0xXXXXXXXX";
        snprintf(errorbuffer,
                 strlen(errorbuffer),
                 "Error on index 0x%08X: 0x%08X != 0x%08X",
                 flashAddress,
                 dataRead,
                 flashData[currentBlockStartIndex + iBlockWord]);
        e.Append(errorbuffer);
        throw e;
      }
    }
    currentBlockStartIndex += blockSize;
    flashAddress += blockSize * sizeof(uint32_t);
 
    if (print_updates && (currentBlockStartIndex > next_update)) {
      fprintf(stderr, "=");
      next_update += update_delta;
    }
  }
  if (print_updates) {
    printf("]\n");
    printf("   Check passed\n");
  }
}

ConfigFEMB()

void WIB::ConfigFEMB	(	uint8_t	iFEMB,
		std::vector< uint32_t >	fe_config,
		std::vector< uint16_t >	clk_phases,
		uint8_t	pls_mode = 0,
		uint8_t	pls_dac_val = 0,
		uint8_t	start_frame_mode_sel = 1,
		uint8_t	start_frame_swap = 1 )

Setup FEMB in real or pulser data mode.

Sets up iFEMB (index from 1) fe_config: list of options to configure the FE ASICs: Gain: 0,1,2,3 for 4.7, 7.8, 14, 25 mV/fC, respectively Shaping Time: 0,1,2,3 for 0.5, 1, 2, 3 us, respectively High Baseline: 0 for 200 mV, 1 for 900 mV, 2 for 200 mV on collection and 900 mV on induction High Leakage: 0 for 100 pA, 1 for 500 pA Leakage x 10: if 1, multiply leakage times 10 AC Coupling : 0 for DC coupling, 1 for AC coupling (between FE and ADC) Buffer: 0 for disable and bypass, 1 for use (between FE and ADC) Use External Clock: 0 ADC use internal clock, 1 ADC use FPGA clocking (almost always want 1) clk_phases: a list of 16 bit values to try for the ADC clock phases. Tries these values until the sync check bits are all 0, and hunts for good values if these all fail. The most significant byte is ADC_ASIC_CLK_PHASE_SELECT (register 6) while the least significant byte is ADC_ASIC_CLK_PHASE_SELECT (register 15) pls_mode: pulser mode select: 0 off, 1 FE ASIC internal pulser, 2 FPGA pulser pls_dac_val: pulser DAC value (amplitude) 6-bits in ASIC test pulse mode, 5-bits in FPGA test pulse mode start_frame_mode_sel: 1 to make data frame start the way BU WIB firmware expects start_frame_swap: 1 to reverse the start bits

Definition at line 38 of file WIB_FEMB.cpp.

{
 
  if (iFEMB < 1 || iFEMB > 4) {
    BUException::WIB_BAD_ARGS e;
    std::stringstream expstr;
    expstr << "ConfigFEMB: iFEMB should be between 1 and 4: " << int(iFEMB);
    e.Append(expstr.str().c_str());
    throw e;
  }
  if (pls_mode > 2) {
    BUException::WIB_BAD_ARGS e;
    std::stringstream expstr;
    expstr << "ConfigFEMB: pls_dac_mode is allowed to be 0 (off), 1 (FPGA), 2 (internal), but is: " << int(pls_mode);
    e.Append(expstr.str().c_str());
    throw e;
  }
  if (start_frame_mode_sel > 1 || start_frame_swap > 1) {
    BUException::WIB_BAD_ARGS e;
    std::stringstream expstr;
    expstr << "ConfigFEMB: start_frame_mode_sel and start_frame_swap must be 0 or 1";
    e.Append(expstr.str().c_str());
    throw e;
  }
 
  if (fe_config.size() != 8) {
 
    BUException::WIB_BAD_ARGS e;
    std::stringstream expstr;
    expstr << "Error: Expecting 9 Front End configuration options:" << std::endl
           << "\t0: Gain" << std::endl
           << "\t1: Shaping Time" << std::endl
           << "\t2: High Baseline" << std::endl
           << "\t3: High Leakage" << std::endl
           << "\t4: Leakage x 10" << std::endl
           << "\t5: AC Coupling" << std::endl
           << "\t6: Buffer" << std::endl
           << "\t7: Use External Clock" << std::endl;
    e.Append(expstr.str().c_str());
    throw e;
  } else {
    std::cout << "Front End configuration options:" << std::endl
              << "\t0:" << std::setw(22) << std::setfill(' ') << "Gain " << fe_config[0] << std::endl
              << "\t1:" << std::setw(22) << std::setfill(' ') << "Shaping Time " << fe_config[1] << std::endl
              << "\t2:" << std::setw(22) << std::setfill(' ') << "High Baseline " << fe_config[2] << std::endl
              << "\t3:" << std::setw(22) << std::setfill(' ') << "High Leakage " << fe_config[3] << std::endl
              << "\t4:" << std::setw(22) << std::setfill(' ') << "Leakage x 10 " << fe_config[4] << std::endl
              << "\t5:" << std::setw(22) << std::setfill(' ') << "AC Coupling " << fe_config[5] << std::endl
              << "\t6:" << std::setw(22) << std::setfill(' ') << "Buffer " << fe_config[6] << std::endl
              << "\t8:" << std::setw(22) << std::setfill(' ') << "Use External Clock " << fe_config[7] << std::endl;
  }
 
  std::cout << "Pulser Mode: " << int(pls_mode) << " and DAC Value: " << int(pls_dac_val) << std::endl;
 
  // get this register so we can leave it in the state it started in
  uint32_t slow_control_dnd = Read("SYSTEM.SLOW_CONTROL_DND");
  Write("SYSTEM.SLOW_CONTROL_DND", 1);
 
  if (ReadFEMB(iFEMB, "VERSION_ID") == ReadFEMB(iFEMB, "SYS_RESET")) { // can't read register if equal
    if (ContinueOnFEMBRegReadError) {
      std::cout << "Error: Can't read registers from FEMB " << int(iFEMB) << std::endl;
      return;
    }
    BUException::FEMB_REG_READ_ERROR e;
    std::stringstream expstr;
    expstr << " for FEMB: " << int(iFEMB);
    e.Append(expstr.str().c_str());
    throw e;
  }
 
  WriteFEMB(iFEMB, "REG_RESET", 1);
  sleep(1);
 
  WriteFEMB(iFEMB, "START_FRAME_MODE_SELECT", start_frame_mode_sel);
  sleep(1);
  WriteFEMB(iFEMB, "START_FRAME_SWAP", start_frame_swap);
 
  if (fe_config[7]) { // use external clock
    SetupFEMBExtClock(iFEMB);
  }
  sleep(0.05);
 
  WriteFEMB(iFEMB, "TIME_STAMP_RESET", 1);
  WriteFEMB(iFEMB, "TIME_STAMP_RESET", 1);
 
  // These are all Jack's WIB addresses, need to figure out Dan's addresses for functionality
  // Write(1, 0);
  // Write(1, 0);
  // Write(1, 2);
  // Write(1, 2);
  // Write(1, 0);
  // Write(1, 0);
  //
  // Write(18, 0x8000);
  // Write(18, 0x8000);
 
  // Reset SPI
  //
  sleep(0.005);
  WriteFEMB(iFEMB, "ADC_ASIC_RESET", 0x1);
  sleep(0.005);
  WriteFEMB(iFEMB, "ADC_ASIC_RESET", 0x1);
  sleep(0.005);
  WriteFEMB(iFEMB, "FE_ASIC_RESET", 0x1);
  sleep(0.005);
  WriteFEMB(iFEMB, "FE_ASIC_RESET", 0x1);
  sleep(0.005);
 
  // Set ADC latch_loc
  uint32_t REG_LATCHLOC1_4_data = 0x04040404;
  uint32_t REG_LATCHLOC5_8_data = 0x04040404;
 
  WriteFEMB(iFEMB, "ADC_LATCH_LOC_0TO3", REG_LATCHLOC1_4_data);
  WriteFEMB(iFEMB, "ADC_LATCH_LOC_4TO7", REG_LATCHLOC5_8_data);
 
  // Setup pulser
  uint8_t internal_daq_value = 0;
  if (pls_mode == 1) // internal, FE ASIC, 6 bits
  {
    if (pls_dac_val >= 63) {
      BUException::WIB_BAD_ARGS e;
      std::stringstream expstr;
      expstr << "ConfigFEMB: pls_dac_val is 6 bits for internal DAC, must be 0-63, but is: " << int(pls_dac_val);
      e.Append(expstr.str().c_str());
      throw e;
    }
    internal_daq_value = pls_dac_val;
    SetupInternalPulser(iFEMB);
  } else if (pls_mode == 2) // external, FPGA, 5 bits
  {
    if (pls_dac_val >= 32) {
      BUException::WIB_BAD_ARGS e;
      std::stringstream expstr;
      expstr << "ConfigFEMB: pls_dac_val is 5 bits for FPGA DAC, must be 0-31, but is: " << int(pls_dac_val);
      e.Append(expstr.str().c_str());
      throw e;
    }
    SetupFPGAPulser(iFEMB, pls_dac_val);
  }
 
  // Setup ASICs
  SetupFEMBASICs(iFEMB,
                 fe_config[0],
                 fe_config[1],
                 fe_config[2],
                 fe_config[3],
                 fe_config[4],
                 fe_config[5],
                 fe_config[6],
                 fe_config[7],
                 pls_mode,
                 internal_daq_value);
  std::cout << "FEMB " << int(iFEMB) << " Successful SPI config" << std::endl;
 
  // Try to sync ADCs
  if (clk_phases.size() == 0) {
    clk_phases.push_back(0xFFFF);
  }
  if (!TryFEMBPhases(iFEMB, clk_phases)) {
    if (ContinueIfListOfFEMBClockPhasesDontSync) {
      std::cout << "Warning: FEMB " << int(iFEMB)
                << " ADC FIFO not synced from expected phases, trying to hunt for phases" << std::endl;
      if (!HuntFEMBPhase(iFEMB, clk_phases.at(0))) {
        if (ContinueOnFEMBSyncError) {
          std::cout << "Error: FEMB " << int(iFEMB) << " ADC FIFO could not be synced even after hunting" << std::endl;
        } else {
          uint16_t adc_fifo_sync = (ReadFEMB(iFEMB, 6) & 0xFFFF0000) >> 16;
          BUException::FEMB_ADC_SYNC_ERROR e;
          std::stringstream expstr;
          expstr << " after hunting. ";
          expstr << " FEMB: " << int(iFEMB);
          expstr << " sync: " << std::bitset<16>(adc_fifo_sync);
          expstr << " phases: ";
          expstr << std::hex << std::setfill('0') << std::setw(2) << ReadFEMB(iFEMB, "ADC_ASIC_CLK_PHASE_SELECT");
          expstr << std::hex << std::setfill('0') << std::setw(2) << ReadFEMB(iFEMB, "ADC_ASIC_CLK_PHASE_SELECT_2");
          e.Append(expstr.str().c_str());
          throw e;
        }
      } // if ! HuntFEMBPhase
    } // if ContinueIfListOfFEMBClockPhasesDontSync
    else // ContinueIfListOfFEMBClockPhasesDontSync
    {
      uint16_t adc_fifo_sync = (ReadFEMB(iFEMB, 6) & 0xFFFF0000) >> 16;
      BUException::FEMB_ADC_SYNC_ERROR e;
      std::stringstream expstr;
      expstr << " after trying all in list. ";
      expstr << " FEMB: " << int(iFEMB);
      expstr << " sync: " << std::bitset<16>(adc_fifo_sync);
      expstr << " phases tried: " << std::endl;
      for (size_t iclk_phase = 0; iclk_phase < clk_phases.size(); iclk_phase++) {
        expstr << "    " << std::hex << std::setfill('0') << std::setw(4) << clk_phases[iclk_phase] << std::endl;
      }
      e.Append(expstr.str().c_str());
      throw e;
    } // else ContinueIfListOfFEMBClockPhasesDontSync
  } // if ! TryFEMBPhases
  uint16_t adc_fifo_sync = (ReadFEMB(iFEMB, 6) & 0xFFFF0000) >> 16;
  std::cout << "FEMB " << int(iFEMB) << " Final ADC FIFO sync: " << std::bitset<16>(adc_fifo_sync) << std::endl;
  std::cout << "FEMB " << int(iFEMB) << " Final Clock Phases: " << std::hex << std::setfill('0') << std::setw(2)
            << ReadFEMB(iFEMB, "ADC_ASIC_CLK_PHASE_SELECT") << std::hex << std::setfill('0') << std::setw(2)
            << ReadFEMB(iFEMB, "ADC_ASIC_CLK_PHASE_SELECT_2") << std::endl;
 
  // time stamp reset
  WriteFEMB(iFEMB, "TIME_STAMP_RESET", 1);
  WriteFEMB(iFEMB, "TIME_STAMP_RESET", 1);
 
  // These are all Jack's WIB addresses, need to figure out Dan's addresses for functionality
  // Write(1, 0);
  // Write(1, 0);
  // Write(1, 2);
  // Write(1, 2);
  // Write(1, 0);
  // Write(1, 0);
  //
  // Write(18, 0x8000);
  // Write(18, 0x8000);
 
  Write("SYSTEM.SLOW_CONTROL_DND", slow_control_dnd);
}

ConfigFEMBFakeData()

void WIB::ConfigFEMBFakeData	(	uint8_t	iFEMB,
		uint8_t	fake_mode,
		uint32_t	fake_word,
		uint8_t	femb_number,
		std::vector< uint32_t >	fake_samples,
		uint8_t	start_frame_mode_sel = 1,
		uint8_t	start_frame_swap = 1 )

Setup FEMB in fake data mode.

Sets up iFEMB (index from 1) in fake data mode fake_mode: 0 for real data, 1 for fake word, 2 for fake waveform, 3 for channel indicator (FEMB, chip, channel), 4 for channel indicator (counter, chip, channel) fake_word: 12 bit wrd to use when in fake word mode femb_number: femb number to use in fake_mode 3 fake_samples: vector of samples to use in fake_mode 2

Sets up iFEMB (index from 1) in fake data mode fake_mode: 0 for real data, 1 for fake word, 2 for fake waveform, 3 for channel indicator (FEMB, chip, channel), 4 for channel indicator (counter, chip, channel) fake_word: 12 bit wrd to use when in fake word mode femb_number: femb number to use in fake_mode 3, 4 bits fake_samples: vector of samples to use in fake_mode 2

Definition at line 278 of file WIB_FEMB.cpp.

{
 
  if (iFEMB < 1 || iFEMB > 4) {
    BUException::WIB_BAD_ARGS e;
    std::stringstream expstr;
    expstr << "ConfigFEMBFakeData: iFEMB should be between 1 and 4: " << int(iFEMB);
    e.Append(expstr.str().c_str());
    throw e;
  }
  if (start_frame_mode_sel > 1 || start_frame_swap > 1) {
    BUException::WIB_BAD_ARGS e;
    std::stringstream expstr;
    expstr << "ConfigFEMBFakeData: start_frame_mode_sel and start_frame_swap must be 0 or 1";
    e.Append(expstr.str().c_str());
    throw e;
  }
  if (fake_mode == 1 && fake_word > 0xFFF) {
    BUException::WIB_BAD_ARGS e;
    std::stringstream expstr;
    expstr << "ConfigFEMBFakeData: fake_word must be only 12 bits i.e. <= 4095, is: " << fake_word;
    e.Append(expstr.str().c_str());
    throw e;
  }
  if (fake_mode == 2 && fake_samples.size() != 256) {
    BUException::WIB_BAD_ARGS e;
    std::stringstream expstr;
    expstr << "ConfigFEMBFakeData: femb_samples must be 255 long, is: " << fake_samples.size();
    e.Append(expstr.str().c_str());
    throw e;
  }
  if (fake_mode == 3 && femb_number > 0xF) {
    BUException::WIB_BAD_ARGS e;
    std::stringstream expstr;
    expstr << "ConfigFEMBFakeData: femb_number must be only 4 bits i.e. <= 15, is: " << int(femb_number);
    e.Append(expstr.str().c_str());
    throw e;
  }
 
  // get this register so we can leave it in the state it started in
  uint32_t slow_control_dnd = Read("SYSTEM.SLOW_CONTROL_DND");
  Write("SYSTEM.SLOW_CONTROL_DND", 1);
 
  WriteFEMB(iFEMB, "REG_RESET", 1);
  sleep(1);
 
  WriteFEMB(iFEMB, "STREAM_AND_ADC_DATA_EN", 0);
  sleep(1);
 
  WriteFEMB(iFEMB, "START_FRAME_MODE_SELECT", start_frame_mode_sel);
  sleep(1);
  WriteFEMB(iFEMB, "START_FRAME_SWAP", start_frame_swap);
  sleep(0.05);
 
  // time stamp reset
  WriteFEMB(iFEMB, "TIME_STAMP_RESET", 1);
  WriteFEMB(iFEMB, "TIME_STAMP_RESET", 1);
 
  // Now do the Fake data mode setup
  if (fake_mode == 1) {
    WriteFEMB(iFEMB, "DATA_TEST_PATTERN", fake_word);
  }
  if (fake_mode == 2) {
    // Put waveform in FEMB registers
    for (size_t iSample = 0; iSample < 256; iSample++) {
      WriteFEMB(iFEMB, 0x300 + iSample, fake_samples.at(iSample));
      sleep(0.005);
    }
  }
  if (fake_mode == 3) {
    WriteFEMB(iFEMB, "FEMB_NUMBER", femb_number);
  }
  WriteFEMB(iFEMB, "FEMB_TST_SEL", fake_mode);
 
  // time stamp reset
  WriteFEMB(iFEMB, "TIME_STAMP_RESET", 1);
  WriteFEMB(iFEMB, "TIME_STAMP_RESET", 1);
 
  WriteFEMB(iFEMB, "STREAM_AND_ADC_DATA_EN", 9);
 
  Write("SYSTEM.SLOW_CONTROL_DND", slow_control_dnd);
}

ConfigFEMBMode()

void WIB::ConfigFEMBMode	(	uint8_t	iFEMB,
		uint32_t	pls_cs,
		uint32_t	dac_sel,
		uint32_t	fpga_dac,
		uint32_t	asic_dac,
		uint32_t	mon_cs = 0 )

Definition at line 1139 of file WIB_FEMB.cpp.

{
  uint32_t tp_sel;
  if (mon_cs == 0) {
    tp_sel = ((asic_dac & 0x01) << 1) + (fpga_dac & 0x01) + ((dac_sel & 0x1) << 8);
  } else {
    tp_sel = 0x402;
  }
  WriteFEMB(iFEMB, 16, tp_sel & 0x0000FFFF);
  WriteFEMB(iFEMB, 18, 0x11);
  uint32_t pls_cs_value = 0x00;
  if (pls_cs == 0)
    pls_cs_value = 0x11; // disable all
  else if (pls_cs == 1)
    pls_cs_value = 0x10; // internal pls
  else if (pls_cs == 2)
    pls_cs_value = 0x01; // external pls
 
  WriteFEMB(iFEMB, 18, pls_cs_value);
}

ConfigureDTSCDS()

float WIB::ConfigureDTSCDS

(

uint8_t

source = 0

)

Definition at line 48 of file WIB_CDS.cpp.

{
  if (source > 1) {
    BUException::WIB_BAD_ARGS e;
    e.Append("Bad DTS CDS clock source");
    throw e;
  }
 
  // Set timing system source (FP:0 BP:1)
  WriteWithRetry("DTS.CDS.INPUT_SELECT", source);
 
  // Reset the I2C firmware
  WriteWithRetry("DTS.CDS.I2C.RESET", 1);
  // Reset the CDS chip (ADN2814)
  WriteDTS_CDS(0x9, 0x20, 1);
  usleep(500000);
 
  // Reset the I2C firmware
  WriteWithRetry("DTS.CDS.I2C.RESET", 1);
  // Un reset
  WriteDTS_CDS(0x9, 0x00, 1, true);
  // Reset the I2C firmware
  WriteWithRetry("DTS.CDS.I2C.RESET", 1);
  usleep(1000000);
 
  // read bits 8 downto 1 from reg 3
  uint16_t dataRateLookup = uint16_t(ReadDTS_CDS(0x3, 1)) << 1;
  // Read bit 0 from reg 4
  dataRateLookup |= uint16_t(ReadDTS_CDS(0x4, 1)) & 0x1;
  if (dataRateLookup >= COURSE_DATARATE_SIZE) {
    return -1;
  }
  return courseDataRates[dataRateLookup];
}

ConfigWIBFakeData()

void WIB::ConfigWIBFakeData	(	bool	enableFakeFEMB1,
		bool	enableFakeFEMB2,
		bool	enableFakeFEMB3,
		bool	enableFakeFEMB4,
		bool	counter )

Definition at line 5 of file WIB_FAKE_CD.cpp.

{ // counter==true: counter instead of COLDATA frame, else samples in COLDATA frame
 
  if (DAQMode == FELIX) {
    // Don't allow fake mode on only half of a FELIX link
    if ((enableFakeFEMB1 ^ enableFakeFEMB2) || (enableFakeFEMB3 ^ enableFakeFEMB4)) {
      BUException::WIB_FAKE_DATA_ON_HALF_FELIX_LINK e;
      throw e;
    }
  }
 
  // Setup the FEMBs/Links
  for (size_t iFEMB = 1; iFEMB <= FEMBCount; iFEMB++) {
    for (size_t iCDA = 1; iCDA <= FEMBCDACount; iCDA++) {
      SetFEMBFakeCOLDATAMode(iFEMB, iCDA, counter);
    }
  }
 
  for (size_t iStream = 1; iStream <= FEMBStreamCount; iStream++) {
    SetFEMBStreamSource(1, iStream, !enableFakeFEMB1);
    SetFEMBStreamSource(2, iStream, !enableFakeFEMB2);
    SetFEMBStreamSource(3, iStream, !enableFakeFEMB3);
    SetFEMBStreamSource(4, iStream, !enableFakeFEMB4);
  }
 
  uint64_t enableWord1 = 0;
  uint64_t enableWord2 = 0;
  uint64_t enableWord3 = 0;
  uint64_t enableWord4 = 0;
  if (enableFakeFEMB1)
    enableWord1 = 0xF;
  if (enableFakeFEMB2)
    enableWord2 = 0xF;
  if (enableFakeFEMB3)
    enableWord3 = 0xF;
  if (enableFakeFEMB4)
    enableWord4 = 0xF;
  SourceFEMB(1, enableWord1);
  SourceFEMB(2, enableWord2);
  SourceFEMB(3, enableWord3);
  SourceFEMB(4, enableWord4);
}

DisableFEMBCNC()

void WIB::DisableFEMBCNC

(

)

Definition at line 513 of file WIB.cpp.

{
  // Enable the clock and control stream to the FEMBs
  Write("FEMB_CNC.CNC_CLOCK_SELECT", 0);
  Write("FEMB_CNC.CNC_COMMAND_SELECT", 0);
}

EnableDAQLink()

void WIB::EnableDAQLink

(

uint8_t

iDAQLink

)

Definition at line 59 of file WIB.cpp.

{
  // CHeck if we know how to dael with this firmware
  if (!((DAQMode == RCE) || (DAQMode == FELIX))) {
    // Not RCE or FELIX firmware, return
    BUException::WIB_FEATURE_NOT_SUPPORTED e;
    e.Append("Automatic DAQLink configuration not supported with this firmware.\n");
    throw e;
  }
 
  // Build the base string for this DAQLINK
  std::string base("DAQ_LINK_");
  base.push_back(GetDAQLinkChar(iDAQLink));
  base.append(".CONTROL.");
  printf("%s\n", base.c_str());
 
  // set the CD stream enable mask from that
  uint32_t enable_mask = 0;
  for (size_t iStream = 0; iStream < (4 * FEMBCount / DAQLinkCount); iStream++) {
    enable_mask <<= 0x1;
  }
 
  Write(base + "ENABLE_CDA_STREAM", enable_mask);
 
  Write(base + "ENABLE", 0x1);
}

EnableDAQLink_Lite()

void WIB::EnableDAQLink_Lite	(	uint8_t	iDAQLink,
		uint8_t	enable )

Definition at line 87 of file WIB.cpp.

{
  // CHeck if we know how to dael with this firmware
  if (!((DAQMode == RCE) || (DAQMode == FELIX))) {
    // Not RCE or FELIX firmware, return
    BUException::WIB_FEATURE_NOT_SUPPORTED e;
    e.Append("Automatic DAQLink configuration not supported with this firmware.\n");
    throw e;
  }
 
  // Build the base string for this DAQLINK
  std::string base("DAQ_LINK_");
  base.push_back(GetDAQLinkChar(iDAQLink));
  base.append(".CONTROL.");
 
  uint8_t stream = 0;
  if (enable) {
    if (DAQMode == RCE)
      stream = 0xF;
    else
      stream = 0xFF;
  }
 
  Write(base + "ENABLE_CDA_STREAM", stream);
  Write(base + "ENABLE", enable);
}

EnableFEMBCNC()

void WIB::EnableFEMBCNC

(

)

Definition at line 506 of file WIB.cpp.

{
  // Enable the clock and control stream to the FEMBs
  Write("FEMB_CNC.CNC_CLOCK_SELECT", 1);
  Write("FEMB_CNC.CNC_COMMAND_SELECT", 1);
}

EraseFlash()

void WIB::EraseFlash

(

bool

print_updates = false

)

Definition at line 195 of file WIB_Flash.cpp.

{
  if (print_updates) {
    fprintf(stderr, "   Erase flash\n");
  }
  WriteWithRetry("FLASH.RUN_COMMAND", 0x7);
  size_t iTimeout = FLASH_TIMEOUT;
  while (ReadWithRetry("FLASH.BUSY") && (iTimeout != 0)) {
    iTimeout--;
    usleep(100000);
  }
  if (iTimeout == 0) {
    BUException::WIB_FLASH_TIMEOUT e;
    // throw an exception
    e.Append("Program (erase): FLASH.BUSY");
    throw e;
    // throw an exception
  }
}

FEMBPower()

void WIB::FEMBPower	(	uint8_t	iFEMB,
		bool	turnOn )

Definition at line 462 of file WIB.cpp.

{
  std::string reg = "POWER.ENABLE.FEMB";
  reg.push_back(GetFEMBChar(iFEMB));
  if (turnOn) {
    Write(reg, 0x1F);
  } else {
    Write(reg, 0x0);
  }
}

FlashCheckBusy()

void WIB::FlashCheckBusy

(

)

Definition at line 370 of file WIB_Flash.cpp.

{
  size_t iTimeout = FLASH_TIMEOUT;
  while (ReadWithRetry("FLASH.BUSY") && (iTimeout != 0)) {
    iTimeout--;
    usleep(10000);
  }
  if (iTimeout == 0) {
    BUException::WIB_FLASH_TIMEOUT e;
    // throw an exception
    e.Append("Read: FLASH.BUSY");
    throw e;
  }
}

FullStart()

void WIB::FullStart

(

)

Definition at line 41 of file WIB.cpp.

{
  // Figure out what kind of WIB firmware we are dealing with
  FEMBCount = Read("SYSTEM.FEMB_COUNT");
  DAQLinkCount = Read("SYSTEM.DAQ_LINK_COUNT");
  // Hardcoded lookup for RCE and FELIX
  if ((FEMBCount == 4) && (DAQLinkCount == 4)) {
    DAQMode = RCE;
  } else if ((FEMBCount == 4) && (DAQLinkCount == 2)) {
    DAQMode = FELIX;
  }
  // TODO check FEMBStreamCount and FEMCDACount from registers on the WIB
  // TODO create those registers
  Write("POWER.ENABLE.MASTER_BIAS", 1);
  started = true;
}

GetDAQ_SI5342AddressPage()

uint8_t WIB::GetDAQ_SI5342AddressPage

(

uint16_t

address

)

Definition at line 40 of file WIB_SI5342.cpp.

{
  return uint8_t((address >> 8) & 0xFF);
}

GetDAQ_SI5342Page()

uint8_t WIB::GetDAQ_SI5342Page

(

)

Definition at line 34 of file WIB_SI5342.cpp.

{
  return uint8_t(ReadDAQ_SI5342(0x1, 1) & 0xFF);
}

GetDAQLinkChar()

char WIB::GetDAQLinkChar

(

uint8_t

iDAQLink

)

Definition at line 532 of file WIB.cpp.

{
  char c = '0';
  // Check if the link is in range given DAQLinkCount (throws)
  CheckDAQLinkInRange(iDAQLink);
  // Convert the numeric daq link number to a char
  switch (iDAQLink) {
    case 1:
      c = '1';
      break;
    case 2:
      c = '2';
      break;
    case 3:
      c = '3';
      break;
    case 4:
      c = '4';
      break;
    default:
      BUException::WIB_INDEX_OUT_OF_RANGE e;
      e.Append("DAQ Link\n");
      char estr[] = "0";
      estr[0] = c;
      e.Append(estr);
      throw e;
  }
  return c;
}

GetDAQMode()

WIB_DAQ_t WIB::GetDAQMode ( )

inline

Definition at line 219 of file WIB.hh.

{return DAQMode;}

GetDTS_SI5344AddressPage()

uint8_t WIB::GetDTS_SI5344AddressPage

(

uint16_t

address

)

Definition at line 40 of file WIB_SI5344.cpp.

{
  return uint8_t((address >> 8) & 0xFF);
}

GetDTS_SI5344Page()

uint8_t WIB::GetDTS_SI5344Page

(

)

Definition at line 34 of file WIB_SI5344.cpp.

{
  return uint8_t(ReadDTS_SI5344(0x1, 1) & 0xFF);
}

GetEventBuilderDebugMode()

uint8_t WIB::GetEventBuilderDebugMode

(

)

GetFEMBCDChar()

char WIB::GetFEMBCDChar

(

uint8_t

iCD

)

Definition at line 627 of file WIB.cpp.

{
  char c = '0';
  // Check if the link is in range given FEMBCount (throws)
  CheckFEMBCDInRange(iCD);
  // Convert the numeric daq link number to a char
  switch (iCD) {
    case 1:
      c = '1';
      break;
    case 2:
      c = '2';
      break;
    default:
      BUException::WIB_INDEX_OUT_OF_RANGE e;
      e.Append("FEMB CDA\n");
      char estr[] = "0";
      estr[0] = c;
      e.Append(estr);
      throw e;
  }
  return c;
}

GetFEMBChar()

char WIB::GetFEMBChar

(

uint8_t

iFEMB

)

Definition at line 574 of file WIB.cpp.

{
  char c = '0';
  // Check if the link is in range given FEMBCount (throws)
  CheckFEMBInRange(iFEMB);
  // Convert the numeric daq link number to a char
  switch (iFEMB) {
    case 1:
      c = '1';
      break;
    case 2:
      c = '2';
      break;
    case 3:
      c = '3';
      break;
    case 4:
      c = '4';
      break;
    default:
      BUException::WIB_INDEX_OUT_OF_RANGE e;
      e.Append("FEMB\n");
      char estr[] = "0";
      estr[0] = c;
      e.Append(estr);
      throw e;
  }
  return c;
}

GetFEMBCount()

uint8_t WIB::GetFEMBCount ( )

inline

Definition at line 218 of file WIB.hh.

{return FEMBCount;}

GetFEMBFakeCOLDATAMode()

uint8_t WIB::GetFEMBFakeCOLDATAMode	(	uint8_t	iFEMB,
		uint8_t	iCD )

Definition at line 92 of file WIB_FAKE_CD.cpp.

{
  std::string base("FEMB0.DAQ.FAKE_CD.CD0.");
  base[4] = GetFEMBChar(iFEMB);
  base[20] = GetFEMBCDChar(iCD);
 
  return Read(base + "FAKE_MODE");
}

GetFEMBStreamSource()

uint8_t WIB::GetFEMBStreamSource	(	uint8_t	iFEMB,
		uint8_t	iStream )

Definition at line 53 of file WIB_FAKE_CD.cpp.

{
  CheckFEMBStreamInRange(iStream);
  std::string base = "FEMB0.DAQ.FAKE_CD.RX_DATA_SOURCE";
  base[4] = GetFEMBChar(iFEMB);
  // Read the current settings
  uint32_t data = Read(base);
  return (data >> (iStream - 1)) & 0x1;
}

HuntFEMBPhase()

bool WIB::HuntFEMBPhase	(	uint8_t	iFEMB,
		uint16_t	clk_phase_data_start )

Definition at line 1081 of file WIB_FEMB.cpp.

{
  uint32_t clk_phase_data0 = (clk_phase_data_start >> 8) & 0xFF;
  uint32_t clk_phase_data1 = clk_phase_data_start & 0xFF;
  uint32_t adc_fifo_sync = 1;
 
  uint32_t a_cs[8] = { 0xc000, 0x3000, 0x0c00, 0x0300, 0x00c0, 0x0030, 0x000c, 0x0003 };
 
  uint32_t a_mark[8] = { 0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01 };
 
  uint32_t a_cnt[8] = { 0, 0, 0, 0, 0, 0, 0, 0 };
 
  while (adc_fifo_sync) {
    sleep(0.001);
    adc_fifo_sync = (ReadFEMB(iFEMB, 6) & 0xFFFF0000) >> 16;
    sleep(0.001);
    adc_fifo_sync = (ReadFEMB(iFEMB, 6) & 0xFFFF0000) >> 16;
    sleep(0.001);
 
    std::cout << "FEMB " << int(iFEMB) << " ADC FIFO sync: " << std::bitset<16>(adc_fifo_sync) << std::endl;
 
    if (adc_fifo_sync == 0) {
      std::cout << "FEMB " << int(iFEMB) << " Successful SPI config and ADC FIFO synced" << std::endl;
      // std::cout << "  ADC_ASIC_CLK_PHASE_SELECT:   " << std::hex << std::setw(2) << std::setfill('0') <<
      // clk_phase_data0 << std::endl; std::cout << "  ADC_ASIC_CLK_PHASE_SELECT_2: " << std::hex << std::setw(2) <<
      // std::setfill('0') << clk_phase_data1 << std::endl;
      std::cout << "  phase:   " << std::hex << std::setw(2) << std::setfill('0') << clk_phase_data0;
      std::cout << std::hex << std::setw(2) << std::setfill('0') << clk_phase_data1 << std::endl;
      return true;
    } else {
      std::cout << "ERROR: sync not zero: " << std::bitset<16>(adc_fifo_sync) << std::endl;
      for (int i = 0; i < 8; ++i) {
        uint32_t a = adc_fifo_sync & a_cs[i];
        uint32_t a_mark_xor = 0;
        if (a != 0) {
          a_cnt[i]++;
          a_mark_xor = a_mark[i] ^ 0xFF;
          if (a_cnt[i] == 1 || a_cnt[i] == 3) {
            clk_phase_data0 = ((clk_phase_data0 & a_mark[i]) ^ a_mark[i]) + (clk_phase_data0 & a_mark_xor);
          } else if (a_cnt[i] == 2 || a_cnt[i] == 4) {
            clk_phase_data1 = ((clk_phase_data1 & a_mark[i]) ^ a_mark[i]) + (clk_phase_data1 & a_mark_xor);
          } else if (a_cnt[i] >= 5) {
            return false;
          }
        } else {
          continue;
        }
      }
      uint16_t clk_phase_to_write = 0;
      clk_phase_to_write |= (clk_phase_data0 & 0xFF) << 8;
      clk_phase_to_write |= clk_phase_data1;
      WriteFEMBPhase(iFEMB, clk_phase_to_write);
    }
  }
  return false;
}

InitializeDTS()

void WIB::InitializeDTS	(	uint8_t	PDTSsource = 0,
		uint8_t	clockSource = 0,
		uint32_t	PDTSAlignment_timeout = 0 )

Definition at line 12 of file WIB_DTS.cpp.

{
  // Disable the PDTS
  WriteWithRetry("DTS.PDTS_ENABLE", 0x0);
 
  // Disable SI5344 outputs (fixed by SI5344 config)
  WriteWithRetry("DTS.SI5344.ENABLE", 0);
  // Disable SI5344 (fixed by SI5344 config)
  WriteWithRetry("DTS.SI5344.RESET", 1);
 
  // Reset the I2C firmware
  WriteWithRetry("DTS.CDS.I2C.RESET", 1);
 
  if (0 == clockSource) {
    printf("Using PDTS for DUNE timing.\n\nConfiguring clock and data separator\n");
    // Bring up the CDS
    float frequency = 0;
    try {
      frequency = ConfigureDTSCDS(PDTSsource);
    } catch (BUException::exBase& e) {
      frequency = 0;
      e.Append("Failed to communicate with the DTS CDS via I2C\n");
      throw;
    }
    uint32_t LOL = Read("DTS.CDS.LOL");
    uint32_t LOS = Read("DTS.CDS.LOS");
    printf("CDS frequency %f\n", frequency);
    printf("CDS LOL=%d LOS=%d\n", LOL, LOS);
 
    // Check for the correct frequency, not in LOS, and not in LOL
    //     if( (2.4136e+08 == frequency) &&
    if (LOL || LOS) {
      BUException::WIB_DTS_ERROR e;
      e.Append("Failed to configure CDS chip\n");
      throw e;
    }
  } else {
    printf("Using local OSC for DUNE timing\n");
  }
  // CDS is up
 
  printf("\nConfiguring SI5344.\n");
 
  // Set the SI5344 source
  WriteWithRetry("DTS.SI5344.INPUT_SELECT", clockSource);
  // Configure Si5344 with default config file
  // Do the I2C configuration
  try {
    LoadConfigDTS_SI5344("");
  } catch (BUException::exBase& e) {
    // Disable SI5344 outputs
    WriteWithRetry("DTS.SI5344.ENABLE", 0);
    // Disable SI5344
    WriteWithRetry("DTS.SI5344.RESET", 1);
 
    e.Append("Error in LoadConfigDTS_SI5344\n");
    throw;
  }
 
  usleep(100000);
 
  // Check that SI5344 is locked on
  if (ReadWithRetry("DTS.SI5344.LOS") || ReadWithRetry("DTS.SI5344.LOL")) {
    // Disable SI5344 outputs
    WriteWithRetry("DTS.SI5344.ENABLE", 0);
    // Disable SI5344
    WriteWithRetry("DTS.SI5344.RESET", 1);
 
    // Throw
    BUException::WIB_DTS_ERROR e;
    e.Append("Failed to configure the SI5344 chip correctly\n");
    throw e;
  }
 
  // Enable the clock for FPGA
  WriteWithRetry("DTS.SI5344.ENABLE", 1);
  usleep(100000);
 
  char const* const PDTSStates[] = { "W_RST", "W_LINK", "W_FREQ", "W_ADJUST", "W_ALIGN", "W_LOCK", "W_PHASE", "W_RDY",
                                     "RUN",   "0x9",    "0xA",    "0xB",      "ERR_R",   "ERR_T",  "ERR_P",   "0xF" };
 
  if (0 == clockSource) {
    printf("\nSetup PDTS.\n");
    bool timeout_exists = true;
    if (PDTSAlignment_timeout == 0)
      timeout_exists = false;
 
    auto start_time = std::chrono::high_resolution_clock::now();
    bool timed_out = false;
 
    while ((timeout_exists == false) || timed_out == false) {
      // Using PDTS, set that up.
      usleep(500000);
      WriteWithRetry("DTS.PDTS_ENABLE", 1);
      usleep(500000); // needed in new PDTS system to get to a good state before giving up and trying a new phase.
 
      // See if we've locked
      uint32_t pdts_state = ReadWithRetry("DTS.PDTS_STATE");
      printf("PDTS state: %s (0x%01X)\n", PDTSStates[pdts_state & 0xF], pdts_state);
      if ((pdts_state < 0x6) || (pdts_state > 0x8)) {
        WriteWithRetry("DTS.PDTS_ENABLE", 0);
        // dynamic post-amble
        Write("DTS.SI5344.I2C.RESET", 1);
        SetDTS_SI5344Page(0x0);
        Write("DTS.SI5344.I2C.RESET", 1);
        WriteDTS_SI5344(0x1C, 0x1, 1);
      } else if (0x6 == pdts_state) {
        ers::info(dunedaq::wibmod::WaitingForAlignment(ERS_HERE));
      } else if (0x7 == pdts_state) {
        ers::info(dunedaq::wibmod::WaitingForTimestamp(ERS_HERE));
      } else {
        return; // 0x8 == pdts_state
      }
      auto now = std::chrono::high_resolution_clock::now();
      auto duration = now - start_time;
      if (duration.count() > PDTSAlignment_timeout)
        timed_out = true;
    }
    // If we get here something went wrong
    Write("DTS.SI5344.I2C.RESET", 1);
    SetDTS_SI5344Page(0x0);
    Write("DTS.SI5344.I2C.RESET", 1);
    WriteDTS_SI5344(0x1C, 0x1, 1);
 
    BUException::WIB_DTS_ERROR e;
    e.Append("Failed to configure the PDTS correctly within timeout\n");
    throw e;
  }
}

InitializeWIB()

void WIB::InitializeWIB

(

)

Definition at line 144 of file WIB.cpp.

{
  // run resets
  Write("SYSTEM.RESET", 0xFF);
  // Set clock settings
  Write("POWER.ENABLE.MASTER_BIAS", 0x1); // Turn on DC/DC converter
}

LoadConfigDAQ_SI5342()

void WIB::LoadConfigDAQ_SI5342

(

std::string const &

fileName

)

Definition at line 46 of file WIB_SI5342.cpp.

{
  std::ifstream confFile(fileName.c_str());
  BUException::WIB_BAD_ARGS badFile;
 
  if (confFile.fail()) {
    // Failed to topen filename, add it to the exception
    badFile.Append("Bad SI5342 config file name:");
    badFile.Append(fileName.c_str());
 
    // Try the default
    if (getenv("WIBMOD_SHARE") != NULL) {
      std::string envBasedFileName = getenv("WIBMOD_SHARE");
      envBasedFileName += "/config/WIB1/config/";
      envBasedFileName += SI5342_CONFIG_FILENAME;
      confFile.open(envBasedFileName.c_str());
      if (confFile.fail()) {
        badFile.Append("Bad env based filename:");
        badFile.Append(envBasedFileName.c_str());
      }
    }
  }
 
  if (confFile.fail()) {
    // We are still failing to open our file
    throw badFile;
  }
 
  // Make sure the chip isn't in reset
  if (Read("DAQ.SI5342.RESET") != 0) {
    Write("DAQ.SI5342.RESET", 0x0);
    usleep(50000);
  }
 
  // Reset the I2C firmware
  Write("DAQ.SI5342.I2C.RESET", 1);
 
  std::vector<std::pair<uint16_t, uint8_t>> writes;
  while (!confFile.eof()) {
    std::string line;
    std::getline(confFile, line);
    if (line.size() == 0) {
      continue;
    } else if (line[0] == '#') {
      continue;
    } else if (line[0] == 'A') {
      continue;
    } else {
      if (line.find(',') == std::string::npos) {
        printf("Skipping bad line: \"%s\"\n", line.c_str());
        continue;
      }
      uint16_t address = strtoul(line.substr(0, line.find(',')).c_str(), NULL, 16);
      uint8_t data = strtoul(line.substr(line.find(',') + 1).c_str(), NULL, 16);
      writes.push_back(std::pair<uint16_t, uint8_t>(address, data));
    }
  }
 
  // Disable the SI5342 output
  Write("DAQ.SI5342.ENABLE", 0x0);
 
  uint8_t page = GetDAQ_SI5342Page();
  unsigned int percentDone = 0;
 
  printf("\n[==================================================]\n");
  fprintf(stderr, " ");
  for (size_t iWrite = 0; iWrite < writes.size(); iWrite++) {
 
    if (page != GetDAQ_SI5342AddressPage(writes[iWrite].first)) {
      page = GetDAQ_SI5342AddressPage(writes[iWrite].first);
      SetDAQ_SI5342Page(page);
      usleep(100000);
    }
 
    if (iWrite == 3) {
      usleep(300000);
    }
 
    uint8_t address = writes[iWrite].first & 0xFF;
    uint32_t data = (writes[iWrite].second) & 0xFF;
    uint8_t iData = 1;
 
    for (size_t iTries = 10; iTries > 0; iTries--) {
      try {
        WriteDAQ_SI5342(address, data, iData);
      } catch (BUException::WIB_ERROR& e) {
        // Reset the I2C firmware
        Write("DAQ.SI5342.I2C.RESET", 1);
        if (iTries == 1) {
          e.Append("\nTried 3 times\n");
          throw;
        }
      }
    }
    if ((100 * iWrite) / writes.size() > percentDone) {
      fprintf(stderr, "#");
      percentDone += 2;
    }
  }
  printf("\n");
}

LoadConfigDTS_SI5344()

void WIB::LoadConfigDTS_SI5344

(

std::string const &

fileName

)

Definition at line 46 of file WIB_SI5344.cpp.

{
  std::ifstream confFile(fileName.c_str());
  BUException::WIB_BAD_ARGS badFile;
 
  if (confFile.fail()) {
    // Failed to topen filename, add it to the exception
    badFile.Append("Bad SI5344 config file name:");
    badFile.Append(fileName.c_str());
 
    // Try the default
    if (getenv("WIBMOD_SHARE") != NULL) {
      std::string envBasedFileName = getenv("WIBMOD_SHARE");
      envBasedFileName += "/config/WIB1/config/";
      envBasedFileName += SI5344_CONFIG_FILENAME;
      confFile.open(envBasedFileName.c_str());
      if (confFile.fail()) {
        badFile.Append("Bad env based filename:");
        badFile.Append(envBasedFileName.c_str());
      }
    }
  }
 
  if (confFile.fail()) {
    // We are still failing to open our file
    throw badFile;
  }
 
  // Make sure the chip isn't in reset
  if (Read("DTS.SI5344.RESET") != 0) {
    Write("DTS.SI5344.RESET", 0x0);
    usleep(50000);
  }
 
  // Reset the I2C firmware
  Write("DTS.SI5344.I2C.RESET", 1);
 
  std::vector<std::pair<uint16_t, uint8_t>> writes;
  while (!confFile.eof()) {
    std::string line;
    std::getline(confFile, line);
    if (line.size() == 0) {
      continue;
    } else if (line[0] == '#') {
      continue;
    } else if (line[0] == 'A') {
      continue;
    } else {
      if (line.find(',') == std::string::npos) {
        printf("Skipping bad line: \"%s\"\n", line.c_str());
        continue;
      }
      uint16_t address = strtoul(line.substr(0, line.find(',')).c_str(), NULL, 16);
      uint8_t data = strtoul(line.substr(line.find(',') + 1).c_str(), NULL, 16);
      writes.push_back(std::pair<uint16_t, uint8_t>(address, data));
    }
  }
 
  // Disable the SI5344 output
  Write("DTS.SI5344.ENABLE", 0x0);
 
  uint8_t page = GetDTS_SI5344Page();
  unsigned int percentDone = 0;
 
  printf("\n[==================================================]\n");
  fprintf(stderr, " ");
  for (size_t iWrite = 0; iWrite < writes.size(); iWrite++) {
 
    if (page != GetDTS_SI5344AddressPage(writes[iWrite].first)) {
      page = GetDTS_SI5344AddressPage(writes[iWrite].first);
      SetDTS_SI5344Page(page);
      usleep(100000);
    }
 
    if (iWrite == 3) {
      usleep(300000);
    }
 
    uint8_t address = writes[iWrite].first & 0xFF;
    uint32_t data = (writes[iWrite].second) & 0xFF;
    uint8_t iData = 1;
 
    for (size_t iTries = 10; iTries > 0; iTries--) {
      try {
        WriteDTS_SI5344(address, data, iData);
      } catch (BUException::WIB_ERROR& e) {
        // Reset the I2C firmware
        Write("DTS.SI5344.I2C.RESET", 1);
        if (iTries == 1) {
          e.Append("\nTried 10 times\n");
          throw;
        }
      }
    }
    if ((100 * iWrite) / writes.size() > percentDone) {
      fprintf(stderr, "#");
      percentDone += 2;
    }
  }
  printf("\n");
}

operator=()

WIB & WIB::operator= ( const WIB & )

private

PDTSInRunningState()

void WIB::PDTSInRunningState

(

)

Definition at line 151 of file WIB_DTS.cpp.

{
  if (Read("DTS.PDTS_STATE") != 0x8) {
    BUException::WIB_DTS_ERROR e;
    e.Append("WIB is not in PDTS state RUN(0x8)\n");
    throw e;
  }
}

ProgramFlash()

void WIB::ProgramFlash	(	std::string const &	fileName,
		uint8_t	update_percentage = 101 )

Definition at line 216 of file WIB_Flash.cpp.

{
  WriteWithRetry("SYSTEM.SLOW_CONTROL_DND", 1);
 
  bool print_updates = false;
  if (update_percentage < 100) {
    print_updates = true;
  }
 
  // Load data and validate
  if (print_updates) {
    fprintf(stderr, "   Reading file: %s\n", fileName.c_str());
  }
  //  std::vector<uint32_t> flashData = firmwareFromDumpFile(fileName);
  std::vector<uint32_t> flashData = firmwareFromIntelHexFile(fileName);
 
  // erase flash
  EraseFlash(print_updates);
 
  // Load data into flash.
  WriteFlash(flashData, update_percentage);
 
  // Validate flash
  CheckFlash(flashData, update_percentage);
  WriteWithRetry("SYSTEM.SLOW_CONTROL_DND", 0);
}

ReadDAQ_SI5342()

uint32_t WIB::ReadDAQ_SI5342	(	uint16_t	address,
		uint8_t	byte_count = 4 )

Definition at line 14 of file WIB_SI5342.cpp.

{
  return ReadI2C("DAQ.SI5342.I2C", address, byte_count);
}

ReadDAQLinkSpyBuffer()

std::vector< data_8b10b_t > WIB::ReadDAQLinkSpyBuffer	(	uint8_t	iDAQLink,
		uint8_t	trigger_mode = 0 )

Definition at line 22 of file WIB_spybuffer.cpp.

{
  // TODO read DAQ link count
  std::string base("DAQ_LINK_");
  base.push_back(GetDAQLinkChar(iDAQLink));
  base.append(".SPY_BUFFER.");
 
  // Check if there is an active capture
  if (ReadWithRetry(base + "CAPTURING_DATA")) {
    BUException::WIB_BUSY e;
    e.Append(base);
    e.Append(" is busy\n");
    throw e;
  }
  // The spy buffer isn't busy, so let's make sure the fifo is empty
  while (!ReadWithRetry(base + "EMPTY")) {
    // Read out a workd from the fifo
    WriteWithRetry(base + "DATA", 0x0);
  }
 
  // write trigger mode
  WriteWithRetry(base + "TRIGGER_MODE", trigger_mode & 0x1);
 
  // Start the capture
  Write(base + "START", 0x1);
 
  // Wait for capture to finish
  while (ReadWithRetry(base + "CAPTURING_DATA")) {
  }
 
  // Read out the data
  std::vector<data_8b10b_t> ret;
 
  while (!ReadWithRetry(base + "EMPTY")) {
    // read out the k-chars
    uint32_t k_data = ReadWithRetry(base + "K_DATA");
    // read out the data
    uint32_t data = ReadWithRetry(base + "DATA");
 
    //    printf("0x%08X 0x%08X\n",k_data,data);
 
    for (size_t iWord = 0; iWord < 4; iWord++) {
      ret.push_back(data_8b10b_t((k_data >> iWord) & 0x1, (data >> (iWord * 8) & 0xFF)));
    }
    // mark word as read
    Write(base + "DATA", 0x0);
  }
  return ret;
}

ReadDTS_CDS()

uint32_t WIB::ReadDTS_CDS	(	uint16_t	address,
		uint8_t	byte_count = 4 )

Definition at line 42 of file WIB_CDS.cpp.

{
  return ReadI2C("DTS.CDS.I2C", address, byte_count);
}

ReadDTS_SI5344()

uint32_t WIB::ReadDTS_SI5344	(	uint16_t	address,
		uint8_t	byte_count = 4 )

Definition at line 14 of file WIB_SI5344.cpp.

{
  return ReadI2C("DTS.SI5344.I2C", address, byte_count);
}

ReadFlash()

void WIB::ReadFlash	(	std::string const &	fileName,
		uint8_t	update_percentage = 101 )

Definition at line 129 of file WIB_Flash.cpp.

{
  bool print_updates = false;
  if (update_percentage < 100) {
    print_updates = true;
  }
  size_t update_delta = (update_percentage * float(16 * 1024 * 1024 / 4)) / 100;
  size_t next_update = update_delta;
 
  FILE* outFile = fopen(fileName.c_str(), "w");
  if (outFile == NULL) {
    BUException::WIB_BAD_ARGS e;
    e.Append("Failed to create: ");
    e.Append(fileName);
    throw e;
  }
 
  if (print_updates) {
    fprintf(stderr, "   Reading flash\n");
    fprintf(stderr, "   [");
    for (size_t i = 0; i < 100.0 / update_percentage; i++) {
      fprintf(stderr, "=");
    }
    fprintf(stderr, "]\n   [");
  }
  // program flash in groups of 64 32bit words (256 bytes)
  uint32_t address = 0;
 
  uint32_t blockRegMapAddress = GetItem("FLASH.DATA00")->address;
  size_t blockSize = 64;
  // set block size
  WriteWithRetry("FLASH.BYTE_COUNT", 255);
 
  for (size_t iWord = 0; iWord < 16 * 1024 * 1024 / 4;) {
    FlashCheckBusy();
 
    // Set adddress
    WriteWithRetry("FLASH.ADDRESS", address);
    // Start read
    WriteWithRetry("FLASH.RUN_COMMAND", 0x5);
 
    FlashCheckBusy();
 
    // Readout the data
    for (size_t iWordRead = 0; iWordRead < blockSize; iWordRead++) {
      fprintf(outFile, "0x%06X 0x%08X\n", uint32_t(iWord), ReadWithRetry(blockRegMapAddress + iWordRead));
      iWord++;
    }
 
    //    iWord+= blockSize;
    address += blockSize * 4;
 
    if (print_updates && (iWord > next_update)) {
      //      printf("   % 3f%% done\n",float(iWord)/float(flashData.size()));
      fprintf(stderr, "=");
      next_update += update_delta;
    }
  }
  if (print_updates) {
    printf("]\n");
    printf("   done\n");
  }
  fclose(outFile);
}

ReadLocalFlash() [1/2]

uint32_t WIB::ReadLocalFlash

(

uint16_t

address

)

Definition at line 5 of file WIB_localFlash.cpp.

{
  // load the address
  Write("SYSTEM.FLASH.ADDRESS", address);
  // start the read transaction
  Write("SYSTEM.FLASH.RW", 1);
  Write("SYSTEM.FLASH.RUN", 1);
 
  // Wait for transaction to finish
  while (Read("SYSTEM.FLASH.DONE") == 0) {
    printf("busy\n");
    // sleep for 1ms
    usleep(1000);
  }
 
  return Read("SYSTEM.FLASH.RD_DATA");
}

ReadLocalFlash() [2/2]

std::vector< uint32_t > WIB::ReadLocalFlash	(	uint16_t	address,
		size_t	n )

Definition at line 24 of file WIB_localFlash.cpp.

{
  std::vector<uint32_t> readData;
  size_t current_address = address;
  size_t end_address = current_address + n;
  for (; current_address < end_address; current_address++) {
    readData.push_back(ReadLocalFlash(current_address));
  }
  return readData;
}

ReadOutCDLinkSpyBuffer()

std::vector< data_8b10b_t > WIB::ReadOutCDLinkSpyBuffer

(

)

Definition at line 5 of file WIB_spybuffer.cpp.

{
  if (Read("FEMB_SPY.FIFO_EMPTY")) {
    BUException::WIB_ERROR e;
    e.Append("CD Spy fifo is empty!");
    throw e;
  }
 
  std::vector<data_8b10b_t> data;
  while (!Read("FEMB_SPY.FIFO_EMPTY")) {
    uint32_t val = Read("FEMB_SPY.DATA");
    data.push_back(data_8b10b_t((val >> 8) & 0x1, uint8_t(val & 0xff)));
  }
  return data;
}

ReadQSFP()

uint32_t WIB::ReadQSFP	(	uint16_t	address,
		uint8_t	byte_count )

Definition at line 12 of file WIB_QSFP.cpp.

{
  return ReadI2C("DAQ.QSFP.I2C", address, byte_count);
}

ResetSi5342()

void WIB::ResetSi5342

(

)

Definition at line 20 of file WIB_SI5342.cpp.

{
  Write("DAQ.SI5342.RESET", 0x1);
  Write("DAQ.SI5342.RESET", 0x0);
  usleep(100000);
}

ResetSi5344()

void WIB::ResetSi5344

(

)

Definition at line 20 of file WIB_SI5344.cpp.

{
  Write("DTS.SI5344.RESET", 0x1);
  Write("DTS.SI5344.RESET", 0x0);
  usleep(100000);
}

ResetWIB()

void WIB::ResetWIB

(

bool

reset_udp = false

)

Definition at line 154 of file WIB.cpp.

{
 
  if (reset_udp) {
    // Resetting the UDP will stop the reply packet which will cause an error.
    try {
      Write("SYSTEM.RESET.UDP_RESET", 1);
    } catch (BUException::BAD_REPLY& e) {
      // do nothing
    }
    // Since we don't know this happened since we lack a udp response, do it again.
    // This could be extended to read register REG
    usleep(10000);
    try {
      Write("SYSTEM.RESET.UDP_RESET", 1);
    } catch (BUException::BAD_REPLY& e) {
      // do nothing
    }
    usleep(10000);
  }
 
  // Reset the control register
  WriteWithRetry("SYSTEM.RESET.CONTROL_REGISTER_RESET", 1);
  usleep(1000);
 
  // If this is felix, make sure we configure the SI5342
  if (DAQMode == FELIX) {
    Write("DAQ.SI5342.RESET", 1);
    usleep(10000);
    Write("DAQ.SI5342.RESET", 0);
    usleep(10000);
    printf("Configuring SI5342 for FELIX\n");
    LoadConfigDAQ_SI5342("default"); // use the default config file for the SI5342
    usleep(10000);                   // Wait for
    SelectSI5342(1,                  // Set input to be local oscillator for FELIX clock
                 1);                 // enable the output of the SI5342
  }
 
  // Reset the Eventbuilder PLL
  Write("SYSTEM.RESET.EB_PLL_RESET", 1);
  usleep(10000);
 
  // Reset the DAQ path
  Write("SYSTEM.RESET.DAQ_PATH_RESET", 1);
 
  usleep(10000);
 
  // Set clock settings
  Write("DTS.CMD_COUNT_RESET", 0xFFFFFFFF);
  Write("DTS.CMD_COUNT_RESET", 0);
 
  // Halt signals
  Write("DTS.CONVERT_CONTROL.HALT", 1);
  Write("DTS.CONVERT_CONTROL.ENABLE", 0);
 
  // Make sure DC/DC is on
  Write("POWER.ENABLE.MASTER_BIAS", 1);
}

ResetWIBAndCfgDTS()

void WIB::ResetWIBAndCfgDTS	(	uint8_t	localClock,
		uint8_t	PDTS_TGRP,
		uint8_t	PDTSsource = 0,
		uint32_t	PDTSAlignment_timeout = 0 )

Definition at line 214 of file WIB.cpp.

{
  if (DAQMode == UNKNOWN) {
    BUException::WIB_DAQMODE_UNKNOWN e;
    throw e;
  }
  if (localClock > 1) {
    BUException::WIB_BAD_ARGS e;
    e.Append("localClock > 1; must be 0 (for DTS) or 1 (for local clock)\n");
    throw e;
  }
  if (PDTSsource > 1) {
    BUException::WIB_BAD_ARGS e;
    e.Append("PDTSsource > 1; must be 0 (for backplane) or 1 (for front panel)\n");
    throw e;
  }
  if (16 <= PDTS_TGRP) {
    BUException::WIB_BAD_ARGS e;
    e.Append("PDTS TGRP > 15; must be 0 to 15\n");
    throw e;
  }
 
  // get this register so we can leave it in the state it started in
  uint32_t slow_control_dnd = Read("SYSTEM.SLOW_CONTROL_DND");
 
  ResetWIB();
  Write("SYSTEM.SLOW_CONTROL_DND", 1);
  sleep(1);
 
  for (size_t iFEMB = 1; iFEMB <= 4; iFEMB++) {
    FEMBPower(iFEMB, 0);
  }
 
  // make sure everything DTS is off
  Write("DTS.CONVERT_CONTROL.HALT", 1);
  Write("DTS.CONVERT_CONTROL.ENABLE", 0);
  Write("DTS.CONVERT_CONTROL.START_SYNC", 0);
  sleep(1);
 
  if (localClock > 0) {
    printf("Configuring local clock\n");
    // Configure the SI5344 to use the local oscillator instead of the PDTS
    LoadConfigDTS_SI5344("default");
    sleep(1);
    SelectSI5344(1, 1);
    sleep(1);
    Write("DTS.CONVERT_CONTROL.EN_FAKE", 1);
    Write("DTS.CONVERT_CONTROL.LOCAL_TIMESTAMP", 1);
    Write("FEMB_CNC.CNC_CLOCK_SELECT", 1);
    //    Write("FEMB_CNC.ENABLE_DTS_CMDS",1);
    sleep(1);
  } else {
    // Configure the clocking for the PDTS (assumes the PDTS is sending idle or something)
    printf("Configuring DTS\n");
    Write("DTS.PDTS_TGRP", PDTS_TGRP);
    printf("Using timing group 0x%X\n", PDTS_TGRP);
    InitializeDTS(PDTSsource, 0, PDTSAlignment_timeout);
    sleep(1);
    Write("FEMB_CNC.CNC_CLOCK_SELECT", 1);
    sleep(1);
    // We are ready for the PDTS, start searching
    Write("DTS.PDTS_ENABLE", 1);
    sleep(1);
  }
 
  // Now we have the 128MHz clock
  Write("FEMB1.DAQ.ENABLE", 0);
  Write("FEMB2.DAQ.ENABLE", 0);
  Write("FEMB3.DAQ.ENABLE", 0);
  Write("FEMB4.DAQ.ENABLE", 0);
 
  Write("SYSTEM.SLOW_CONTROL_DND", slow_control_dnd);
}

SelectSI5342()

void WIB::SelectSI5342	(	uint64_t	input,
		bool	enable )

Definition at line 149 of file WIB_SI5342.cpp.

{
  Write("DAQ.SI5342.INPUT_SELECT", input);
  Write("DAQ.SI5342.ENABLE", uint64_t(enable));
}

SelectSI5344()

void WIB::SelectSI5344	(	uint64_t	input,
		bool	enable )

Definition at line 149 of file WIB_SI5344.cpp.

{
  Write("DTS.SI5344.INPUT_SELECT", input);
  Write("DTS.SI5344.ENABLE", uint64_t(enable));
}

SetContinueIfListOfFEMBClockPhasesDontSync()

void WIB::SetContinueIfListOfFEMBClockPhasesDontSync

(

bool

enable

)

Definition at line 1184 of file WIB_FEMB.cpp.

{
  ContinueIfListOfFEMBClockPhasesDontSync = enable;
}

SetContinueOnFEMBRegReadError()

void WIB::SetContinueOnFEMBRegReadError

(

bool

enable

)

Definition at line 1166 of file WIB_FEMB.cpp.

{
  ContinueOnFEMBRegReadError = enable;
}

SetContinueOnFEMBSPIError()

void WIB::SetContinueOnFEMBSPIError

(

bool

enable

)

Definition at line 1172 of file WIB_FEMB.cpp.

{
  ContinueOnFEMBSPIError = enable;
}

SetContinueOnFEMBSyncError()

void WIB::SetContinueOnFEMBSyncError

(

bool

enable

)

Definition at line 1178 of file WIB_FEMB.cpp.

{
  ContinueOnFEMBSyncError = enable;
}

SetDAQ_SI5342Page()

void WIB::SetDAQ_SI5342Page

(

uint8_t

page

)

Definition at line 28 of file WIB_SI5342.cpp.

{
  WriteDAQ_SI5342(0x1, page, 1);
}

SetDTS_SI5344Page()

void WIB::SetDTS_SI5344Page

(

uint8_t

page

)

Definition at line 28 of file WIB_SI5344.cpp.

{
  WriteDTS_SI5344(0x1, page, 1);
}

SetEventBuilderDebugMode()

void WIB::SetEventBuilderDebugMode

(

uint8_t

mask = 0xF

)

SetFEMBFakeCOLDATAMode()

void WIB::SetFEMBFakeCOLDATAMode	(	uint8_t	iFEMB,
		uint8_t	iCD,
		bool	mode = 0 )

Definition at line 81 of file WIB_FAKE_CD.cpp.

{
  std::string base("FEMB0.DAQ.FAKE_CD.CD0.");
  base[4] = GetFEMBChar(iFEMB);
  base[20] = GetFEMBCDChar(iCD);
 
  // Set this COLDATA ASIC
  Write(base + "FAKE_MODE", uint32_t(mode));
}

SetFEMBStreamSource()

void WIB::SetFEMBStreamSource	(	uint8_t	iFEMB,
		uint8_t	iStream,
		bool	real = true )

Definition at line 63 of file WIB_FAKE_CD.cpp.

{
  CheckFEMBStreamInRange(iStream);
  std::string base = "FEMB0.DAQ.FAKE_CD.RX_DATA_SOURCE";
  base[4] = GetFEMBChar(iFEMB);
  // Read the current settings
  uint32_t data = Read(base);
  // update the mask
  iStream--; // iStream is 1-4, but we want bits 0 to 3
  if (real) {
    data &= ~(0x1 << iStream);
  } else {
    data |= 0x1 << iStream;
  }
  Write(base, data);
}

SetupASICPulserBits()

uint16_t WIB::SetupASICPulserBits

(

uint8_t

iFEMB

)

Definition at line 837 of file WIB_FEMB.cpp.

{
 
  const uint32_t REG_SPI_BASE_WRITE = 0x200; // 512
  const uint32_t REG_SPI_BASE_READ = 0x250;  // 592
  uint16_t adc_sync_status = 0xFFFF;
 
  size_t nASICs = 8;
  unsigned nTries = 3;
  for (unsigned iSPIWrite = 0; iSPIWrite < nTries; iSPIWrite++) {
    WriteFEMB(iFEMB, "STREAM_AND_ADC_DATA_EN", 0); // Turn off STREAM_EN and ADC_DATA_EN
    sleep(0.1);
 
    std::cout << "ASIC SPI Write Registers..." << std::endl;
 
    uint8_t value = 0x2;
    uint8_t mask = 0x3;
    uint8_t pos = 24;
    std::vector<uint32_t> vals(nASICs);
    for (size_t iASIC = 0; iASIC < nASICs; iASIC++) {
      uint32_t address = (REG_SPI_BASE_WRITE + 9 * iASIC + 8);
      std::cout << "Writing address " << std::hex << std::setfill('0') << std::setw(8) << address << std::endl;
      // WriteFEMBBits(iFEMB, address, pos, mask, value);
 
      // Bit-wise calculation of register val
      uint32_t shiftVal = value & mask;
      uint32_t regMask = (mask << pos);
      uint32_t initVal = ReadFEMB(iFEMB, address);
      uint32_t newVal = ((initVal & ~(regMask)) | (shiftVal << pos));
      vals[iASIC] = newVal;
      WriteFEMB(iFEMB, address, newVal);
 
      sleep(0.01);
    }
 
    // run the SPI programming
    sleep(0.1);
    WriteFEMB(iFEMB, "WRITE_ASIC_SPI", 1);
    sleep(0.1);
 
    if (iSPIWrite == nTries - 1) {
      // Now check readback
      bool spi_mismatch = false;
      for (unsigned iSPIRead = 0; iSPIRead < 2; iSPIRead++) {
        std::cout << "ASIC SPI Readback..." << std::endl;
        std::vector<uint32_t> regsReadback(nASICs);
        for (size_t iASIC = 0; iASIC < nASICs; iASIC++) {
          uint32_t regReadback = ReadFEMB(iFEMB, (REG_SPI_BASE_READ + 9 * iASIC + 8));
          regsReadback[iASIC] = regReadback;
          sleep(0.01);
        }
 
        std::cout << "ASIC SPI register number, write val, read val:" << std::endl;
        spi_mismatch = false;
        for (size_t iASIC = 0; iASIC < nASICs; iASIC++) {
          std::cout << std::dec << std::setfill(' ') << std::setw(3) << iASIC << "  " << std::hex << std::setfill('0')
                    << std::setw(8) << vals[iASIC] << "  " << std::hex << std::setfill('0') << std::setw(8)
                    << regsReadback[iASIC] << std::endl;
          if (vals[iASIC] != regsReadback[iASIC]) {
            spi_mismatch = true;
            size_t asicFailNum = 0;
            if (iASIC > 0)
              asicFailNum = (iASIC - 1);
            std::cout << "FE-ADC ASIC " << asicFailNum << " SPI faled" << std::endl;
          } // if regs don't match
        } // for iReg
        if (!spi_mismatch)
          break;
      } // for iSPIRead
      if (spi_mismatch) {
        BUException::WIB_ERROR e;
        e.Append("SPI programming failure");
        throw e;
      } // if spi_mismatch
    } // if iSPIWrite == 1
    sleep(0.1);
 
    WriteFEMB(iFEMB, "STREAM_AND_ADC_DATA_EN", 9); // STREAM_EN and ADC_DATA_EN
    sleep(0.05);
    WriteFEMB(iFEMB, "STREAM_AND_ADC_DATA_EN", 9); // STREAM_EN and ADC_DATA_EN
    sleep(0.1);
 
    adc_sync_status = (uint16_t)ReadFEMB(iFEMB, "ADC_ASIC_SYNC_STATUS");
 
    // The real sync check can happen here in Shanshan's code
 
  } // for iSPIWrite
 
  return adc_sync_status;
}

SetupFEMBASICs() [1/2]

uint16_t WIB::SetupFEMBASICs	(	uint8_t	iFEMB,
		std::vector< uint32_t >	registerList )

Setup FEMB ASICs.

Sets up iFEMB (index from 1) ASICs

registerList is a list of 71 32bit registers to program the FE and ADC ASICs

returns adc sync status 16 bits, one for each serial link between ADC and FPGA. There are 2 per ADC

Definition at line 551 of file WIB_FEMB.cpp.

{
 
  const size_t REG_SPI_BASE = 512;
  const size_t NREGS = 71;
 
  if (registerList.size() != NREGS) {
    BUException::FEMB_FIRMWARE_VERSION_MISMATCH e;
    std::stringstream expstr;
    expstr << "SetupFEMBASICs expects : " << NREGS << " argument is: " << registerList.size();
    e.Append(expstr.str().c_str());
    throw e;
  }
 
  // turn off HS data before register writes
  WriteFEMB(iFEMB, "STREAM_EN", 0);
  sleep(2);
 
  for (size_t iReg = 0; iReg < NREGS; iReg++) {
    WriteFEMB(iFEMB, REG_SPI_BASE + iReg, registerList[iReg]);
  }

  // run the SPI programming
 
  WriteFEMB(iFEMB, "ADC_ASIC_RESET", 1);
  sleep(0.01);
  WriteFEMB(iFEMB, "FE_ASIC_RESET", 1);
  sleep(0.01);
  WriteFEMB(iFEMB, "WRITE_ADC_ASIC_SPI", 1);
  sleep(0.01);
  WriteFEMB(iFEMB, "WRITE_ADC_ASIC_SPI", 1);
  sleep(0.01);
  WriteFEMB(iFEMB, "WRITE_FE_ASIC_SPI", 1);
  sleep(0.01);
  WriteFEMB(iFEMB, "WRITE_FE_ASIC_SPI", 1);
  sleep(0.01);
 
  uint16_t adc_sync_status = (uint16_t)ReadFEMB(iFEMB, "ADC_ASIC_SYNC_STATUS");
 
  // turn HS link back on
  sleep(2);
  WriteFEMB(iFEMB, "STREAM_EN", 1);
 
  return adc_sync_status;
}

SetupFEMBASICs() [2/2]

uint16_t WIB::SetupFEMBASICs	(	uint8_t	iFEMB,
		uint8_t	gain,
		uint8_t	shape,
		uint8_t	highBaseline,
		bool	highLeakage,
		bool	leakagex10,
		bool	acCoupling,
		bool	buffer,
		bool	useExtClock,
		uint8_t	internalDACControl,
		uint8_t	internalDACValue )

Setup FEMB ASICs.

Sets up iFEMB (index from 1) ASICs

gain: 0,1,2,3 for 4.7, 7.8, 14, 25 mV/fC, respectively shaping time: 0,1,2,3 for 0.5, 1, 2, 3 us, respectively highBaseline is 900mV for 1, 200mV for 0, and appropriately for each plane for 2 highLeakage is 500pA for true, 100pA for false leakagex10 multiplies leakage x10 if true acCoupling: FE is AC coupled to ADC if true, DC if false buffer: FE to ADC buffer on if true, off and bypassed if false useExtClock: ADC uses external (FPGA) clock if true, internal if false internalDACControl: 0 for disabled, 1 for internal FE ASIC pulser, 2 for external FPGA pulser internalDACValue: 6 bit value for amplitude to use with internal pulser

returns adc sync status 16 bits, one for each serial link between ADC and FPGA. There are 2 per ADC

Definition at line 619 of file WIB_FEMB.cpp.

{
 
  (void)buffer; // to make compiler not complain about unused arguments
 
  if (gain > 3) {
    BUException::WIB_BAD_ARGS e;
    std::stringstream expstr;
    expstr << "gain should be between 0 and 3, but is: " << int(gain);
    e.Append(expstr.str().c_str());
    throw e;
  }
  if (shape > 3) {
    BUException::WIB_BAD_ARGS e;
    std::stringstream expstr;
    expstr << "shape should be between 0 and 3, but is: " << int(shape);
    e.Append(expstr.str().c_str());
    throw e;
  }
 
  const size_t REG_SPI_BASE_WRITE = 0x200; // 512
  const size_t REG_SPI_BASE_READ = 0x250;  // 592
  // 0x48 registers total, 72 in hex
 
  bool bypassOutputBuffer = true; // if false might blow up protoDUNE
  bool useOutputMonitor = false;  // if true might blow up protoDUNE
  bool useCh16HighPassFilter = false;
  bool monitorBandgapNotTemp = false;
  bool monitorTempBandgapNotSignal = false;
  bool useTestCapacitance = (bool)internalDACControl;
 
  // Flip bits of gain
  if (gain == 0x1)
    gain = 0x2;
  else if (gain == 0x2)
    gain = 0x1;
 
  // Shape
  if (shape == 0x0)
    shape = 0x2; // 0.5 us
  else if (shape == 0x1)
    shape = 0x0; // 1 us
  else if (shape == 0x2)
    shape = 0x3; // 2 us
  else if (shape == 0x3)
    shape = 0x1; // 3 us
 
  FE_ASIC_reg_mapping fe_map;
  if (highBaseline > 1) {
    // Set them all to high baseline
    fe_map.set_board(useTestCapacitance,
                     0,
                     gain,
                     shape,
                     useOutputMonitor,
                     !bypassOutputBuffer,
                     !highLeakage,
                     monitorBandgapNotTemp,
                     monitorTempBandgapNotSignal,
                     useCh16HighPassFilter,
                     leakagex10,
                     acCoupling,
                     internalDACControl,
                     internalDACValue);
    // Now just set collection channels to low baseline
    fe_map.set_collection_baseline(1);
  } else {
    fe_map.set_board(useTestCapacitance,
                     ~highBaseline,
                     gain,
                     shape,
                     useOutputMonitor,
                     !bypassOutputBuffer,
                     !highLeakage,
                     monitorBandgapNotTemp,
                     monitorTempBandgapNotSignal,
                     useCh16HighPassFilter,
                     leakagex10,
                     acCoupling,
                     internalDACControl,
                     internalDACValue);
  }
  ADC_ASIC_reg_mapping adc_map;
  uint8_t offsetCurrentValue = 0;
  bool pcsr = 0;
  bool pdsr = 0;
  bool adcSleep = 0;
  bool useADCTestInput = 0;
  bool f4 = 0;
  bool f5 = 0;
  bool lsbCurrentStearingPartialNotFull = 0;
  bool clk0 = 0;
  if (useExtClock)
    clk0 = 1;
  bool clk1 = 0;
  bool freq = 0;
  bool enableOffsetCurrent = 0;
  bool f0 = 0;
  bool f1 = 0;
  bool f2 = 0;
  bool f3 = 0;
  adc_map.set_board(offsetCurrentValue,
                    pcsr,
                    pdsr,
                    adcSleep,
                    useADCTestInput,
                    f4,
                    f5,
                    lsbCurrentStearingPartialNotFull,
                    0,
                    0,
                    0,
                    0,
                    0,
                    clk0,
                    clk1,
                    freq,
                    enableOffsetCurrent,
                    f0,
                    f1,
                    f2,
                    f3);
  ASIC_reg_mapping map;
  map.set_board(fe_map, adc_map);
  map.get_regs();
  const std::vector<uint32_t> regs = map.get_regs();
  const size_t nRegs = regs.size();
 
  uint16_t adc_sync_status = 0xFFFF;
 
  for (unsigned iSPIWrite = 0; iSPIWrite < 2; iSPIWrite++) {
    WriteFEMB(iFEMB, "STREAM_AND_ADC_DATA_EN", 0); // Turn off STREAM_EN and ADC_DATA_EN
    sleep(0.1);
 
    std::cout << "ASIC SPI Write Registers..." << std::endl;
    for (size_t iReg = 0; iReg < nRegs; iReg++) {
      WriteFEMB(iFEMB, REG_SPI_BASE_WRITE + iReg, regs[iReg]);
      sleep(0.01);
    }
 
    // run the SPI programming
    sleep(0.1);
    WriteFEMB(iFEMB, "WRITE_ASIC_SPI", 1);
    sleep(0.1);
 
    if (iSPIWrite == 1) {
      // Now check readback
      bool spi_mismatch = false;
      for (unsigned iSPIRead = 0; iSPIRead < 2; iSPIRead++) {
        std::cout << "ASIC SPI Readback..." << std::endl;
        std::vector<uint32_t> regsReadback(nRegs);
        for (size_t iReg = 0; iReg < nRegs; iReg++) {
          uint32_t regReadback = ReadFEMB(iFEMB, REG_SPI_BASE_READ + iReg);
          regsReadback[iReg] = regReadback;
          sleep(0.01);
        }
 
        bool verbose = false;
        if (verbose)
          std::cout << "ASIC SPI register number, write val, read val:" << std::endl;
        spi_mismatch = false;
        for (size_t iReg = 0; iReg < nRegs; iReg++) {
          if (verbose) {
            std::cout << std::dec << std::setfill(' ') << std::setw(3) << iReg << "  " << std::hex << std::setfill('0')
                      << std::setw(8) << regs[iReg] << "  " << std::hex << std::setfill('0') << std::setw(8)
                      << regsReadback[iReg] << std::endl;
          } // if verbose
          if (regs[iReg] != regsReadback[iReg]) {
            spi_mismatch = true;
            size_t asicFailNum = 0;
            if (iReg > 0)
              asicFailNum = (iReg - 1) / 9;
            std::cout << "FE-ADC ASIC " << asicFailNum << " SPI faled" << std::endl;
          } // if regs don't match
        } // for iReg
        if (!spi_mismatch)
          break;
      } // for iSPIRead
      if (spi_mismatch) {
        if (ContinueOnFEMBSPIError) {
          std::cout << "FEMB ASIC SPI readback mismatch--problems communicating with ASICs for FEMB: " << int(iFEMB)
                    << std::endl;
        } else {
          BUException::FEMB_SPI_READBACK_MISMATCH e;
          std::stringstream expstr;
          expstr << " for FEMB: " << int(iFEMB);
          e.Append(expstr.str().c_str());
          throw e;
        }
      } // if spi_mismatch
    } // if iSPIWrite == 1
    sleep(0.1);
 
    WriteFEMB(iFEMB, "STREAM_AND_ADC_DATA_EN", 9); // STREAM_EN and ADC_DATA_EN
    sleep(0.05);
    WriteFEMB(iFEMB, "STREAM_AND_ADC_DATA_EN", 9); // STREAM_EN and ADC_DATA_EN
    sleep(0.1);
 
    adc_sync_status = (uint16_t)ReadFEMB(iFEMB, "ADC_ASIC_SYNC_STATUS");
 
    // The real sync check can happen here in Shanshan's code
 
  } // for iSPIWrite
 
  return adc_sync_status;
}

SetupFEMBExtClock()

void WIB::SetupFEMBExtClock

(

uint8_t

iFEMB

)

Setup FEMB External Clock.

Sets up iFEMB (index from 1) external clock parameters

Definition at line 372 of file WIB_FEMB.cpp.

{
 
  // EXTERNAL CLOCK VARIABLES
  uint32_t clk_period = 5; // ns
  uint32_t clk_dis = 0;    // 0 --> enable, 1 disable
  uint32_t d14_rst_oft = 0 / clk_period;
  uint32_t d14_rst_wdt = (45 / clk_period);
  uint32_t d14_rst_inv = 1;
  uint32_t d14_read_oft = 480 / clk_period;
  uint32_t d14_read_wdt = 20 / clk_period;
  uint32_t d14_read_inv = 1;
  uint32_t d14_idxm_oft = 230 / clk_period;
  uint32_t d14_idxm_wdt = 270 / clk_period;
  uint32_t d14_idxm_inv = 0;
  uint32_t d14_idxl_oft = 480 / clk_period;
  uint32_t d14_idxl_wdt = 20 / clk_period;
  uint32_t d14_idxl_inv = 0;
  uint32_t d14_idl0_oft = 50 / clk_period;
  uint32_t d14_idl0_wdt = (190 / clk_period) - 1;
  uint32_t d14_idl1_oft = 480 / clk_period;
  uint32_t d14_idl1_wdt = 20 / clk_period;
  uint32_t d14_idl_inv = 0;
 
  uint32_t d58_rst_oft = 0 / clk_period;
  uint32_t d58_rst_wdt = (45 / clk_period);
  uint32_t d58_rst_inv = 1;
  uint32_t d58_read_oft = 480 / clk_period;
  uint32_t d58_read_wdt = 20 / clk_period;
  uint32_t d58_read_inv = 1;
  uint32_t d58_idxm_oft = 230 / clk_period;
  uint32_t d58_idxm_wdt = 270 / clk_period;
  uint32_t d58_idxm_inv = 0;
  uint32_t d58_idxl_oft = 480 / clk_period;
  uint32_t d58_idxl_wdt = 20 / clk_period;
  uint32_t d58_idxl_inv = 0;
  uint32_t d58_idl0_oft = 50 / clk_period;
  uint32_t d58_idl0_wdt = (190 / clk_period) - 1;
  uint32_t d58_idl1_oft = 480 / clk_period;
  uint32_t d58_idl1_wdt = 20 / clk_period;
  uint32_t d58_idl_inv = 0;
 
  // external clock phase -- Version 320
  /*uint32_t d14_read_step = 7;
  uint32_t d14_read_ud   = 0;
  uint32_t d14_idxm_step = 3;
  uint32_t d14_idxm_ud   = 0;
  uint32_t d14_idxl_step = 1;
  uint32_t d14_idxl_ud   = 1;
  uint32_t d14_idl0_step = 5;
  uint32_t d14_idl0_ud   = 0;
  uint32_t d14_idl1_step = 2;
  uint32_t d14_idl1_ud   = 0;
  uint32_t d14_phase_en  = 1;
 
  uint32_t d58_read_step = 1;
  uint32_t d58_read_ud   = 1;
  uint32_t d58_idxm_step = 0;
  uint32_t d58_idxm_ud   = 0;
  uint32_t d58_idxl_step = 5;
  uint32_t d58_idxl_ud   = 1;
  uint32_t d58_idl0_step = 6;
  uint32_t d58_idl0_ud   = 0;
  uint32_t d58_idl1_step = 5;
  uint32_t d58_idl1_ud   = 0;
  uint32_t d58_phase_en  = 1;*/
  // Version 323
  uint32_t d14_read_step = 11;
  uint32_t d14_read_ud = 0;
  uint32_t d14_idxm_step = 9;
  uint32_t d14_idxm_ud = 0;
  uint32_t d14_idxl_step = 7;
  uint32_t d14_idxl_ud = 0;
  uint32_t d14_idl0_step = 12;
  uint32_t d14_idl0_ud = 0;
  uint32_t d14_idl1_step = 10;
  uint32_t d14_idl1_ud = 0;
  uint32_t d14_phase_en = 1;
 
  uint32_t d58_read_step = 0;
  uint32_t d58_read_ud = 0;
  uint32_t d58_idxm_step = 5;
  uint32_t d58_idxm_ud = 0;
  uint32_t d58_idxl_step = 4;
  uint32_t d58_idxl_ud = 1;
  uint32_t d58_idl0_step = 3;
  uint32_t d58_idl0_ud = 0;
  uint32_t d58_idl1_step = 4;
  uint32_t d58_idl1_ud = 0;
  uint32_t d58_phase_en = 1;
 
  // END EXTERNAL CLOCK VARIABLES
 
  // config timing
  uint32_t d14_inv =
    (d14_rst_inv << 0) + (d14_read_inv << 1) + (d14_idxm_inv << 2) + (d14_idxl_inv << 3) + (d14_idl_inv << 4);
  uint32_t d58_inv =
    (d58_rst_inv << 0) + (d58_read_inv << 1) + (d58_idxm_inv << 2) + (d58_idxl_inv << 3) + (d58_idl_inv << 4);
  uint32_t d_inv = d58_inv + (d14_inv << 5);
 
  uint32_t addr_data;
 
  addr_data = clk_dis + (d_inv << 16);
  WriteFEMB(iFEMB, 21, addr_data);
 
  addr_data = d58_rst_oft + (d14_rst_oft << 16);
  WriteFEMB(iFEMB, 22, addr_data);
 
  addr_data = d58_rst_wdt + (d14_rst_wdt << 16);
  WriteFEMB(iFEMB, 23, addr_data);
 
  addr_data = d58_read_oft + (d14_read_oft << 16);
  WriteFEMB(iFEMB, 24, addr_data);
 
  addr_data = d58_read_wdt + (d14_read_wdt << 16);
  WriteFEMB(iFEMB, 25, addr_data);
 
  addr_data = d58_idxm_oft + (d14_idxm_oft << 16);
  WriteFEMB(iFEMB, 26, addr_data);
 
  addr_data = d58_idxm_wdt + (d14_idxm_wdt << 16);
  WriteFEMB(iFEMB, 27, addr_data);
 
  addr_data = d58_idxl_oft + (d14_idxl_oft << 16);
  WriteFEMB(iFEMB, 28, addr_data);
 
  addr_data = d58_idxl_wdt + (d14_idxl_wdt << 16);
  WriteFEMB(iFEMB, 29, addr_data);
 
  addr_data = d58_idl0_oft + (d14_idl0_oft << 16);
  WriteFEMB(iFEMB, 30, addr_data);
 
  addr_data = d58_idl0_wdt + (d14_idl0_wdt << 16);
  WriteFEMB(iFEMB, 31, addr_data);
 
  addr_data = d58_idl1_oft + (d14_idl1_oft << 16);
  WriteFEMB(iFEMB, 32, addr_data);
 
  addr_data = d58_idl1_wdt + (d14_idl1_wdt << 16);
  WriteFEMB(iFEMB, 33, addr_data);
 
  // config phase
  for (size_t i = 0; i < 4; i++) {
    addr_data = d14_read_step + (d14_idxm_step << 16);
    WriteFEMB(iFEMB, 35, addr_data);
 
    addr_data = d14_idxl_step + (d14_idl0_step << 16);
    WriteFEMB(iFEMB, 36, addr_data);
 
    d14_phase_en = d14_phase_en ^ 1;
    uint32_t d14_ud = d14_read_ud + (d14_idxm_ud << 1) + (d14_idxl_ud << 2) + (d14_idl0_ud << 3) + (d14_idl1_ud << 4) +
                      (d14_phase_en << 15);
    addr_data = d14_idl1_step + (d14_ud << 16);
    WriteFEMB(iFEMB, 37, addr_data);
 
    addr_data = d58_read_step + (d58_idxm_step << 16);
    WriteFEMB(iFEMB, 38, addr_data);
 
    addr_data = d58_idxl_step + (d58_idl0_step << 16);
    WriteFEMB(iFEMB, 39, addr_data);
 
    d58_phase_en = d58_phase_en ^ 1;
    uint32_t d58_ud = d58_read_ud + (d58_idxm_ud << 1) + (d58_idxl_ud << 2) + (d58_idl0_ud << 3) + (d58_idl1_ud << 4) +
                      (d58_phase_en << 15);
    addr_data = d58_idl1_step + (d58_ud << 16);
    WriteFEMB(iFEMB, 40, addr_data);
  }
  sleep(0.05);
}

SetupFPGAPulser()

void WIB::SetupFPGAPulser	(	uint8_t	iFEMB,
		uint8_t	dac_val )

Definition at line 929 of file WIB_FEMB.cpp.

{
  std::cout << "FEMB " << int(iFEMB) << " Configuring FPGA pulser with DAC value: " << int(dac_val) << std::endl;
 
  WriteFEMB(iFEMB, "ASIC_TP_EN", 0);
  WriteFEMB(iFEMB, "FPGA_TP_EN", 1);
 
  WriteFEMB(iFEMB, "DAC_SELECT", 1);
  WriteFEMB(iFEMB, "TEST_PULSE_AMPLITUDE", dac_val);
  WriteFEMB(iFEMB, "TEST_PULSE_DELAY", 219);
  WriteFEMB(iFEMB, "TEST_PULSE_PERIOD", 497);
 
  WriteFEMB(iFEMB, "INT_TP_EN", 0);
  WriteFEMB(iFEMB, "EXT_TP_EN", 1);
}

SetupInternalPulser()

void WIB::SetupInternalPulser

(

uint8_t

iFEMB

)

Definition at line 946 of file WIB_FEMB.cpp.

{
  std::cout << "FEMB " << int(iFEMB) << " Configuring internal pulser" << std::endl;
 
  WriteFEMB(iFEMB, "DAC_SELECT", 0);
  WriteFEMB(iFEMB, "TEST_PULSE_AMPLITUDE", 0);
  WriteFEMB(iFEMB, "TEST_PULSE_DELAY", 219);
  WriteFEMB(iFEMB, "TEST_PULSE_PERIOD", 497);
 
  WriteFEMB(iFEMB, "INT_TP_EN", 0);
  WriteFEMB(iFEMB, "EXT_TP_EN", 1);
 
  WriteFEMB(iFEMB, "FPGA_TP_EN", 0);
  WriteFEMB(iFEMB, "ASIC_TP_EN", 1);
}

SourceFEMB()

void WIB::SourceFEMB	(	uint64_t	iDAQLink,
		uint64_t	real )

Definition at line 652 of file WIB.cpp.

{
  if (iFEMB < 1) {
    printf("FEMB index out of range < 1\n");
    return;
  }
 
  /*  if(DAQMode == RCE && iFEMB > 4){
      printf("FEMB index out of range > 4 (RCE) \n");
      return;}
    if(DAQMode == FELIX && iFEMB > 2){
      printf("FEMB index out of range > 2 (FELIX) \n");
      return;}
    */
  std::string address("FEMB");
  address.push_back(GetFEMBChar(iFEMB));
  address.append(".DAQ.FAKE_CD.FAKE_SOURCE");
  Write(address, real);
}

StartEventBuilder()

void WIB::StartEventBuilder

(

uint8_t

mask = 0xF

)

StartStreamToDAQ()

void WIB::StartStreamToDAQ	(	bool	l1 = true,
		bool	l2 = true,
		bool	l3 = false,
		bool	l4 = false )

Definition at line 413 of file WIB.cpp.

{
  if (DAQMode == UNKNOWN) {
    BUException::WIB_DAQMODE_UNKNOWN e;
    throw e;
  }
  WriteWithRetry("DTS.CONVERT_CONTROL.HALT", 1);
  WriteWithRetry("DTS.CONVERT_CONTROL.ENABLE", 0);
 
  // get this register so we can leave it in the state it started in
  uint32_t slow_control_dnd = Read("SYSTEM.SLOW_CONTROL_DND");
  Write("SYSTEM.SLOW_CONTROL_DND", 1);
 
  sleep(1);
  Write("FEMB_CNC.FEMB_STOP", 1);
  sleep(1);
  Write("SYSTEM.RESET.DAQ_PATH_RESET", 1);
  sleep(1);
 
  // Enable DAQ links
  if (DAQMode == FELIX) {
    if (link1_enabled)
      EnableDAQLink_Lite(1, 1);
    if (link2_enabled)
      EnableDAQLink_Lite(2, 1);
  } else {
    if (link3_enabled)
      EnableDAQLink_Lite(3, 1);
    if (link4_enabled)
      EnableDAQLink_Lite(4, 1);
  }
 
  // Enable the FEMB to align to idle and wait for convert
  Write("FEMB1.DAQ.ENABLE", 0xF);
  Write("FEMB2.DAQ.ENABLE", 0xF);
  Write("FEMB3.DAQ.ENABLE", 0xF);
  Write("FEMB4.DAQ.ENABLE", 0xF);
 
  // Start sending characters from the FEMB
  Write("FEMB_CNC.ENABLE_DTS_CMDS", 1);
  StartSyncDTS();
  //  Write("FEMB_CNC.TIMESTAMP_RESET",1);
  // Write("FEMB_CNC.FEMB_START",1);
  //  Write("SYSTEM.RESET.FEMB_COUNTER_RESET",1);
 
  Write("SYSTEM.SLOW_CONTROL_DND", slow_control_dnd);
}

StartSyncDTS()

void WIB::StartSyncDTS

(

)

Definition at line 143 of file WIB_DTS.cpp.

{
  WriteWithRetry("DTS.CONVERT_CONTROL.HALT", 0);
  WriteWithRetry("DTS.CONVERT_CONTROL.ENABLE", 1);
  WriteWithRetry("DTS.CONVERT_CONTROL.START_SYNC", 1);
}

StopEventBuilder()

void WIB::StopEventBuilder

(

uint8_t

mask = 0xF

)

TryFEMBPhases()

bool WIB::TryFEMBPhases	(	uint8_t	iFEMB,
		std::vector< uint16_t >	phases )

Definition at line 1049 of file WIB_FEMB.cpp.

{
 
  size_t nPhases = phases.size();
  std::cout << "Searching " << nPhases << " sets of phases:" << std::endl;
  for (size_t ip = 0; ip < nPhases; ++ip) {
    uint16_t phase = phases.at(ip);
    std::cout << "Set " << ip << std::endl;
    std::cout << "\t Phase: " << std::hex << std::setw(4) << phase << std::endl;
 
    WriteFEMBPhase(iFEMB, phase);
    // If it made it this far, it found the correct readback val
    sleep(0.001);
    uint32_t adc_fifo_sync = (ReadFEMB(iFEMB, 6) & 0xFFFF0000) >> 16;
    sleep(0.001);
    adc_fifo_sync = (ReadFEMB(iFEMB, 6) & 0xFFFF0000) >> 16;
    sleep(0.001);
 
    std::cout << "FEMB " << int(iFEMB) << " ADC FIFO sync: " << std::bitset<16>(adc_fifo_sync) << std::endl;
 
    if (adc_fifo_sync == 0) {
      std::cout << "FEMB " << int(iFEMB) << " ADC FIFO synced" << std::endl;
      std::cout << "  phase:   " << std::hex << std::setw(4) << std::setfill('0') << (uint32_t)phase << std::endl;
      return true;
    }
  }
 
  // std::cout << "Could not find successful phase" << std::endl;
  return false;
}

WriteDAQ_SI5342()

void WIB::WriteDAQ_SI5342	(	uint16_t	address,
		uint32_t	value,
		uint8_t	byte_count = 4 )

Definition at line 9 of file WIB_SI5342.cpp.

{
  WriteI2C("DAQ.SI5342.I2C", address, value, byte_count);
}

WriteDTS_CDS()

void WIB::WriteDTS_CDS	(	uint16_t	address,
		uint32_t	value,
		uint8_t	byte_count = 4,
		bool	ignore_error = false )

Definition at line 37 of file WIB_CDS.cpp.

{
  WriteI2C("DTS.CDS.I2C", address, value, byte_count, ignore_error);
}

WriteDTS_SI5344()

void WIB::WriteDTS_SI5344	(	uint16_t	address,
		uint32_t	value,
		uint8_t	byte_count = 4 )

Definition at line 9 of file WIB_SI5344.cpp.

{
  WriteI2C("DTS.SI5344.I2C", address, value, byte_count);
}

WriteFEMBPhase()

void WIB::WriteFEMBPhase	(	uint8_t	iFEMB,
		uint16_t	clk_phase_data )

Definition at line 963 of file WIB_FEMB.cpp.

{
 
  uint32_t clk_phase_data0 = (clk_phase_data >> 8) & 0xFF;
  uint32_t clk_phase_data1 = clk_phase_data & 0xFF;
 
  uint32_t data;
  uint32_t read_back;
  int count = 0;
  sleep(0.001);
  for (int i = 0; i < 10; ++i) {
 
    data = (~(clk_phase_data0)) & 0xFF;
    WriteFEMB(iFEMB, 6, data);
    sleep(0.001);
    read_back = ReadFEMB(iFEMB, 6);
    sleep(0.001);
    if ((read_back & 0xFF) == ((~(clk_phase_data0)) & 0xFF)) {
      break;
    } else {
      count++;
    }
  }
  if (count >= 10) {
    std::cout << "readback val for 0 is different from written data " << std::endl;
    // Put in system exit?
  }
  count = 0;
  for (int i = 0; i < 10; ++i) {
 
    data = (~(clk_phase_data1)) & 0xFF;
    WriteFEMB(iFEMB, 15, data);
    sleep(0.001);
    read_back = ReadFEMB(iFEMB, 15);
    sleep(0.001);
    if ((read_back & 0xFF) == ((~(clk_phase_data1)) & 0xFF)) {
      break;
    } else {
      count++;
    }
  }
  if (count >= 10) {
    std::cout << "readback val for 1 is different from written data " << std::endl;
    // Put in system exit?
  }
  count = 0;
  for (int i = 0; i < 10; ++i) {
 
    data = clk_phase_data0;
    WriteFEMB(iFEMB, 6, data);
    sleep(0.001);
 
    read_back = ReadFEMB(iFEMB, 6);
    sleep(0.001);
    if ((read_back & 0xFF) == ((clk_phase_data0) & 0xFF)) {
      break;
    } else {
      count++;
    }
  }
  if (count >= 10) {
    std::cout << "readback val for 2 is different from written data " << std::endl;
    // Put in system exit?
  }
  count = 0;
  for (int i = 0; i < 10; ++i) {
 
    data = clk_phase_data1;
    WriteFEMB(iFEMB, 15, data);
    sleep(0.001);
 
    read_back = ReadFEMB(iFEMB, 6);
    sleep(0.001);
    if ((read_back & 0xFF) == ((clk_phase_data1) & 0xFF)) {
      break;
    } else {
      count++;
    }
  }
  if (count >= 10) {
    std::cout << "readback val for 3 is different from written data " << std::endl;
    // Put in system exit?
  }
}

WriteFlash()

void WIB::WriteFlash	(	std::vector< uint32_t >	data,
		uint8_t	update_percentage = 101 )

Definition at line 244 of file WIB_Flash.cpp.

{
  // Setup display if needed
  bool print_updates = false;
  if (update_percentage < 100) {
    print_updates = true;
  }
  size_t update_delta = (update_percentage * float(flashData.size())) / 100;
  size_t next_update = update_delta;
  if (print_updates) {
    fprintf(stderr, "   Programming flash\n");
    fprintf(stderr, "   [");
    for (size_t i = 0; i < 100.0 / update_percentage; i++) {
      fprintf(stderr, "=");
    }
    fprintf(stderr, "]\n   [");
  }
 
  // program flash in groups of 64 32bit words (256 bytes)
  uint32_t blockRegMapAddress = GetItem("FLASH.DATA00")->address; // Address of first of 64 32bit words
  uint32_t flashAddress = 0;                                      // Address in flash that we are writing to.
 
  for (size_t currentBlockStartIndex = 0; currentBlockStartIndex < flashData.size();) {
    FlashCheckBusy();
 
    // Find size of this block to write (usually just 64 (256bytes)), but the last one might be smaller.
    size_t blockSize = std::min(size_t(64), flashData.size() - currentBlockStartIndex);
    // Set adddress
    WriteWithRetry("FLASH.ADDRESS", flashAddress);
    // set block size (in bytes and is 1 less than value; 0 means 1 byte, 255 means 256 bytes)
    WriteWithRetry("FLASH.BYTE_COUNT", (blockSize * sizeof(uint32_t)) - 1);
 
    // Write block of data
    for (size_t iBlockWord = 0; iBlockWord < blockSize; iBlockWord++) {
      // arg1: Address in WIB register map of this 32bit word
      // arg2: Data for this 32bit word reg map address in data vector
      WriteWithRetry(blockRegMapAddress + iBlockWord, flashData[currentBlockStartIndex + iBlockWord]);
    }
    // Do the block write
    WriteWithRetry("FLASH.RUN_COMMAND", 0x1);
    currentBlockStartIndex += blockSize;
    flashAddress += blockSize * sizeof(uint32_t);
 
    // Update the screen if needed
    if (print_updates && (currentBlockStartIndex > next_update)) {
      fprintf(stderr, "=");
      next_update += update_delta;
    }
  }
  // Update the screen if needed
  if (print_updates) {
    fprintf(stderr, "]\n");
    fprintf(stderr, "   done\n");
  }
}

WriteLocalFlash() [1/2]

void WIB::WriteLocalFlash	(	uint16_t	address,
		std::vector< uint32_t > const &	data )

Definition at line 54 of file WIB_localFlash.cpp.

{
  for (size_t iWord = 0; iWord < data.size(); iWord++) {
    WriteLocalFlash(address, data[iWord]);
    address++;
  }
}

WriteLocalFlash() [2/2]

void WIB::WriteLocalFlash	(	uint16_t	address,
		uint32_t	data )

Definition at line 36 of file WIB_localFlash.cpp.

{
  // load the address
  Write("SYSTEM.FLASH.ADDRESS", address);
  // load the data to write
  Write("SYSTEM.FLASH.WR_DATA", data);
 
  // start the read transaction
  Write("SYSTEM.FLASH.RW", 0);
  Write("SYSTEM.FLASH.RUN", 1);
  // Wait for finish
  while (Read("SYSTEM.FLASH.DONE") == 0) {
    // sleep for 1ms
    usleep(1000);
  }
}

WriteQSFP()

void WIB::WriteQSFP	(	uint16_t	address,
		uint32_t	value,
		uint8_t	byte_count )

Definition at line 7 of file WIB_QSFP.cpp.

{
  WriteI2C("DAQ.QSFP.I2C", address, value, byte_count);
}

Member Data Documentation

ContinueIfListOfFEMBClockPhasesDontSync

bool WIB::ContinueIfListOfFEMBClockPhasesDontSync

private

Definition at line 240 of file WIB.hh.

ContinueOnFEMBRegReadError

bool WIB::ContinueOnFEMBRegReadError

private

Definition at line 237 of file WIB.hh.

ContinueOnFEMBSPIError

bool WIB::ContinueOnFEMBSPIError

private

Definition at line 238 of file WIB.hh.

ContinueOnFEMBSyncError

bool WIB::ContinueOnFEMBSyncError

private

Definition at line 239 of file WIB.hh.

DAQLinkCount

uint8_t WIB::DAQLinkCount

private

Definition at line 235 of file WIB.hh.

DAQMode

WIB_DAQ_t WIB::DAQMode

private

Definition at line 231 of file WIB.hh.

FEMBCDACount

uint8_t WIB::FEMBCDACount

private

Definition at line 234 of file WIB.hh.

FEMBCount

uint8_t WIB::FEMBCount

private

Definition at line 232 of file WIB.hh.

FEMBStreamCount

uint8_t WIB::FEMBStreamCount

private

Definition at line 233 of file WIB.hh.

started

bool WIB::started

Definition at line 33 of file WIB.hh.

---

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

• /github/workspace/dunedaq/sourcecode/wibmod/src/wibmod/WIB1/WIB.hh
• /github/workspace/dunedaq/sourcecode/wibmod/src/WIB1/WIB.cpp
• /github/workspace/dunedaq/sourcecode/wibmod/src/WIB1/WIB_CDS.cpp
• /github/workspace/dunedaq/sourcecode/wibmod/src/WIB1/WIB_DTS.cpp
• /github/workspace/dunedaq/sourcecode/wibmod/src/WIB1/WIB_FAKE_CD.cpp
• /github/workspace/dunedaq/sourcecode/wibmod/src/WIB1/WIB_FEMB.cpp
• /github/workspace/dunedaq/sourcecode/wibmod/src/WIB1/WIB_Flash.cpp
• /github/workspace/dunedaq/sourcecode/wibmod/src/WIB1/WIB_History.cpp
• /github/workspace/dunedaq/sourcecode/wibmod/src/WIB1/WIB_localFlash.cpp
• /github/workspace/dunedaq/sourcecode/wibmod/src/WIB1/WIB_QSFP.cpp
• /github/workspace/dunedaq/sourcecode/wibmod/src/WIB1/WIB_SI5342.cpp
• /github/workspace/dunedaq/sourcecode/wibmod/src/WIB1/WIB_SI5344.cpp
• /github/workspace/dunedaq/sourcecode/wibmod/src/WIB1/WIB_spybuffer.cpp