WIB.cpp

Go to the documentation of this file.

#include "wibmod/WIB1/WIB.hh"
#include "wibmod/WIB1/BNL_UDP_Exception.hh"
#include "wibmod/WIB1/WIBException.hh"
#include <iostream>
#include <stdio.h> //snprintf
 
WIB::WIB(std::string const& address,
         std::string const& WIBAddressTable,
         std::string const& FEMBAddressTable,
         bool fullStart)
  : 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() {}
 
void
WIB::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;
}
 
void
WIB::EnableDAQLink(uint8_t iDAQLink)
{
  // 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);
}
 
void
WIB::EnableDAQLink_Lite(uint8_t iDAQLink, uint8_t enable)
{
  // 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);
}
 
/*void WIB::DisableDAQLink_Lite(uint8_t iDAQLink, uint8_t enable){
  //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(DAQMode == RCE) stream = 0xF;
  else stream = 0xFF;
 
  if(enable){
    Write(base+"ENABLE_CDA_STREAM",stream);
 
    Write(base+"ENABLE",enable);
  }
  else{
    Write(base+"ENABLE_CDA_STREAM",0);
    Write(base+"ENABLE",0);
  }
}*/
 
void
WIB::InitializeWIB()
{
  // run resets
  Write("SYSTEM.RESET", 0xFF);
  // Set clock settings
  Write("POWER.ENABLE.MASTER_BIAS", 0x1); // Turn on DC/DC converter
}
 
// void WIB::ResetWIB(bool cntrlRegister=true, bool global=false, bool daq_path=false, bool udp=false){
void
WIB::ResetWIB(bool reset_udp)
{
 
  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);
}
 
void
WIB::ResetWIBAndCfgDTS(uint8_t localClock, uint8_t PDTS_TGRP, uint8_t PDTSsource, uint32_t PDTSAlignment_timeout)
{
  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);
}
 
void
WIB::CheckedResetWIBAndCfgDTS(uint8_t localClock, uint8_t PDTS_TGRP, uint8_t PDTSsource, uint32_t PDTSAlignment_timeout)
{
  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);
}
 
void
WIB::StartStreamToDAQ(bool link1_enabled, bool link2_enabled, bool link3_enabled, bool link4_enabled)
{
  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);
}
 
void
WIB::FEMBPower(uint8_t iFEMB, bool turnOn)
{
  std::string reg = "POWER.ENABLE.FEMB";
  reg.push_back(GetFEMBChar(iFEMB));
  if (turnOn) {
    Write(reg, 0x1F);
  } else {
    Write(reg, 0x0);
  }
}
 
// void WIB::PowerOnFEMB(uint8_t iFEMB){
//   //Turn on power
//   std::string reg = "POWER.ENABLE.FEMB";
//   reg.push_back(GetFEMBChar(iFEMB));
//
//
//   const int REG_COUNT = 6;
//   uint8_t mon_reg_val = 0x1+REG_COUNT*(iFEMB-1); // starts at 0x1 and there are 6 per FEMB
//
//   for(uint8_t iReg=0;iReg < REG_COUNT;iReg++){
//     //Go measure the reg value
//     //    int iTries = 0;
//     //    const int NUM_TRIES = 100;
//     //Set the value to be read
//     Write("POWER.MON_CONTROL.ADDRESS",mon_reg_val+iReg);
//     //Wait till the output is valid
//      uint32_t reg_val = Read("POWER.MON_VALUE.MEASUREMENT");
//      printf("Reg %u 0x%04X 0x%04X\n",iReg,reg_val >> 16,reg_val&0xFFFF);
//      //    }
//  }
//
//}
//
void
WIB::EnableFEMBCNC()
{
  // Enable the clock and control stream to the FEMBs
  Write("FEMB_CNC.CNC_CLOCK_SELECT", 1);
  Write("FEMB_CNC.CNC_COMMAND_SELECT", 1);
}
void
WIB::DisableFEMBCNC()
{
  // Enable the clock and control stream to the FEMBs
  Write("FEMB_CNC.CNC_CLOCK_SELECT", 0);
  Write("FEMB_CNC.CNC_COMMAND_SELECT", 0);
}
 
bool
WIB::CheckDAQLinkInRange(uint8_t iDAQLink)
{
  if (!((iDAQLink > 0) && (iDAQLink <= DAQLinkCount))) {
    BUException::WIB_INDEX_OUT_OF_RANGE e;
    e.Append("DAQ Link\n");
    throw e;
  }
  return true;
}
 
char
WIB::GetDAQLinkChar(uint8_t iDAQLink)
{
  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;
}
 
bool
WIB::CheckFEMBInRange(uint8_t iFEMB)
{
  if (!((iFEMB > 0) && (iFEMB <= FEMBCount))) {
    BUException::WIB_INDEX_OUT_OF_RANGE e;
    e.Append("FEMB\n");
    throw e;
  }
  return true;
}
 
char
WIB::GetFEMBChar(uint8_t iFEMB)
{
  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;
}
 
bool
WIB::CheckFEMBStreamInRange(uint8_t iStream)
{
  if (!((iStream > 0) && (iStream <= FEMBStreamCount))) {
    BUException::WIB_INDEX_OUT_OF_RANGE e;
    e.Append("FEMB Stream");
    throw e;
  }
  return true;
}
 
bool
WIB::CheckFEMBCDInRange(uint8_t iCDA)
{
  if (!((iCDA > 0) && (iCDA <= FEMBCDACount))) {
    BUException::WIB_INDEX_OUT_OF_RANGE e;
    e.Append("FEMB CDA");
    throw e;
  }
  return true;
}
 
char
WIB::GetFEMBCDChar(uint8_t iCD)
{
  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;
}
 
void
WIB::SourceFEMB(uint64_t iFEMB, uint64_t real)
{
  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);
}