SSPLEDCalibWrapper.cpp

Go to the documentation of this file.

#ifndef SSPMODULES_SRC_SSPLEDCALIBWRAPPER_CPP_
#define SSPMODULES_SRC_SSPLEDCALIBWRAPPER_CPP_
 
// From Module
#include "SSPLEDCalibWrapper.hpp"
#define TRACE_NAME "SSPLEDCalibWrapper" // NOLINT
 
enum
{
  TLVL_ENTER_EXIT_METHODS = 5,
  TLVL_WORK_STEPS = 10,
  TLVL_BOOKKEEPING = 15,
  TLVL_FULL_DEBUG = 63
};
 
namespace dunedaq {
namespace sspmodules {
 
SSPLEDCalibWrapper::SSPLEDCalibWrapper()
  : m_device_interface(0)
  , m_run_marker{ false }
{
}
 
SSPLEDCalibWrapper::~SSPLEDCalibWrapper() {}
 
void
SSPLEDCalibWrapper::init(const appmodel::SSPLEDCalibModule* conf)
{
  TLOG_DEBUG(TLVL_ENTER_EXIT_METHODS) << "SSPLEDCalibWrapper::init called." << std::endl;
 
  m_number_channels = conf->get_number_channels();
  m_channel_mask = conf->get_channel_mask();
  m_burst_count = conf->get_burst_count();
  m_double_pulse_delay_ticks = conf->get_double_pulse_delay_ticks();
  m_pulse1_width_ticks = conf->get_pulse1_width_ticks();
  m_pulse2_width_ticks = conf->get_pulse2_width_ticks();
  m_pulse_bias_percent_270nm = conf->get_pulse_bias_percent_270nm();
  m_pulse_bias_percent_367nm = conf->get_pulse_bias_percent_367nm();
 
  m_board_id = conf->get_board_id();
  m_module_id = conf->get_module_id();
  m_instance_name_for_metrics = "SSP LED Calib " + std::to_string(m_board_id);
  m_partition_number = conf->get_partition_number(); // this should be 0-3
 
  m_timing_address = conf->get_timing_address(); // 0x20 is default for 101, 0x2B for 304, and 0x36 for 603
  if (m_timing_address > 0xff) {
    std::stringstream ss;
    ss << "Error: Incorrect timing address set (" << m_timing_address << ")!" << std::endl;
    TLOG() << ss.str();
    throw ConfigurationError(ERS_HERE, ss.str());
  }
 
  TLOG_DEBUG(TLVL_WORK_STEPS) << "Board ID is listed as: " << m_board_id << std::endl
                              << "Partition Number is: " << m_partition_number << std::endl
                              << "Timing Address is: " << m_timing_address << std::endl
                              << "Module ID is: " << m_module_id << std::endl;
 
  try {
    m_device_interface = new dunedaq::sspmodules::DeviceInterface();
    m_device_interface->SetPartitionNumber(m_partition_number);
    m_device_interface->SetTimingAddress(m_timing_address);
  } catch (const std::exception& e) {
    throw FailedLEDCalibrationInit(ERS_HERE, e);
  }
 
  TLOG_DEBUG(TLVL_ENTER_EXIT_METHODS) << "SSPLEDCalibWrapper::init complete.";
}
 
void
SSPLEDCalibWrapper::conf(const appmodel::SSPLEDCalibModule* conf)
{
  TLOG_DEBUG(TLVL_ENTER_EXIT_METHODS) << "SSPLEDCalibWrapper::conf called." << std::endl;
 
  try {
    m_device_interface->ConfigureLEDCalib(
      conf); // This sets up the ethernet interface and make sure that the pdts is synched
    m_device_interface->SetRegisterByName("module_id", m_module_id);
    // m_device_interface->SetRegisterByName("eventDataInterfaceSelect", m_cfg.interface_type);
  } catch (const std::exception& e) {
    throw FailedLEDCalibrationConf(ERS_HERE, e);
  }
 
  if (conf->get_pulse_mode() == "single") {
    m_single_pulse = true;
    TLOG(TLVL_FULL_DEBUG) << "SSPLEDCalibWrapper: I think that you want SSP LED Calib module to be in single pulse..."
                          << std::endl;
  } else if (conf->get_pulse_mode() == "burst") {
    m_burst_mode = true;
    TLOG(TLVL_FULL_DEBUG) << "SSPLEDCalibWrapper: I think that you want SSP LED Calib module to be in BURST MODE..."
                          << std::endl;
  }
 
  if ((m_single_pulse && m_burst_mode)) {
    std::stringstream ss;
    ss << "ERROR: SOMEHOW ENDED UP WITH SEVERAL PULSE MODES SET ON!!!!" << std::endl;
    TLOG() << ss.str();
    throw ConfigurationError(ERS_HERE, ss.str());
  }
 
  if (m_burst_mode) {
    TLOG(TLVL_FULL_DEBUG) << "SSPLEDCalibWrapper: Configuring for BURST MODE..." << std::endl;
    this->configure_burst_mode();
  } else if (m_single_pulse) {
    TLOG(TLVL_FULL_DEBUG) << "SSPLEDCalibWrapper: Configuring for single pulse mode..." << std::endl;
    this->configure_single_pulse();
  } else {
    std::stringstream ss;
    ss << "ERROR: SOMEHOW ENDED UP WITH NO PULSE MODES SET ON!!!!" << std::endl;
    TLOG() << ss.str();
    throw ConfigurationError(ERS_HERE, ss.str());
  }
 
  // if there are "literal" entries in the configuration they are explicit writes to the specified register with given
  // value these literal entries are paresed and applied last after any other parameters so this method call needs to be
  // after the other configuration calls
  this->manual_configure_device(conf->get_hardware_configuration());
 
  TLOG_DEBUG(TLVL_ENTER_EXIT_METHODS) << "SSPLEDCalibWrapper::conf complete.";
}
 
void
SSPLEDCalibWrapper::start(const data_t& /*args*/)
{
  TLOG_DEBUG(TLVL_ENTER_EXIT_METHODS) << "Start pulsing SSPLEDCalibWrapper of card " << m_board_id << "...";
 
  if (m_run_marker.load()) {
    TLOG_DEBUG(TLVL_ENTER_EXIT_METHODS) << "Run Marker says that SSPLEDCalibWrapper card " << m_board_id
                                        << " is already pulsing...";
    return;
  }
 
  unsigned int base_bias_regAddress = 0x40000340;
  unsigned int base_timing_regAddress = 0x800003C0;
 
  if (m_number_channels == 5) {
    base_bias_regAddress = 0x4000035C;
    base_timing_regAddress = 0x800003DC;
    TLOG_DEBUG(TLVL_ENTER_EXIT_METHODS) << "Configuring board with 5 channels...";
  } else if (m_number_channels == 12) {
    TLOG_DEBUG(TLVL_ENTER_EXIT_METHODS) << "Configuring board with 12 channels...";
  } else {
    std::stringstream ss;
    ss << "ERROR: SOMEHOW ENDED UP WITHOUT NUMBER OF CHANNELS SET!!!!" << std::endl;
    TLOG() << ss.str();
    throw ConfigurationError(ERS_HERE, ss.str());
  }
 
  unsigned int pulse_bias_setting_270nm = (m_pulse_bias_percent_270nm);
  unsigned int pulse_bias_setting_367nm = (m_pulse_bias_percent_367nm / 2);
 
  for (unsigned int counter = 0; counter < m_number_channels; counter++) {
    unsigned int bias_regAddress = base_bias_regAddress + 0x4 * (counter); // 0x40000340 - 0x4000036C
    unsigned int bias_regVal = 0x00040000;
    unsigned int timing_regAddress = base_timing_regAddress + 0x4 * (counter); // 0x80003C0 - 0x800003EC
    unsigned int timing_regVal = 0x0; // the highest byte sets 8 (pdts trigger) + 1 (953.5 Hz) for burst mode, but 8
                                      // (pdts trigger) + 7 (single shot) for single
    if (m_single_pulse) {
      timing_regVal = 0xF0000000;
    } else if (m_burst_mode) {
      timing_regVal = 0x90000000;
    }
 
    TLOG(TLVL_FULL_DEBUG) << "Channel map is 0x" << std::hex << m_channel_mask << " and the comparison is 0x"
                          << (1 << counter) << std::endl;
    if ((m_channel_mask & ((unsigned int)1 << counter)) == ((unsigned int)1 << counter)) {
      if (counter < 6) {
        bias_regVal = bias_regVal + pulse_bias_setting_270nm;
      } else {
        bias_regVal = bias_regVal + pulse_bias_setting_367nm;
      }
      timing_regVal = timing_regVal + m_pulse1_width_ticks;
      timing_regVal = timing_regVal + (m_pulse2_width_ticks << 8);
      timing_regVal = timing_regVal + (m_double_pulse_delay_ticks << 16);
      TLOG(TLVL_FULL_DEBUG) << "Will turn on " << std::dec << counter << " channel at bias register 0x" << std::hex
                            << bias_regAddress << " with bias value 0x" << bias_regVal << std::endl;
      TLOG(TLVL_FULL_DEBUG) << " and set the width regsiter 0x" << std::hex << timing_regAddress << " to value of 0x"
                            << timing_regVal << std::dec << std::endl;
      m_device_interface->SetRegister(bias_regAddress, bias_regVal); // BIAS_DAC_CONFIG_N
      if ((counter == 7) && !((m_channel_mask & ((unsigned int)1 << counter)) == ((unsigned int)1 << (counter - 1)))) {
        // this is a really convoluted situation where for the very specific 12 channel board that arrived at CERN in
        // June 2022 the bias for channel 7 was not working and so the bias is taken from channel 6 which means that if
        // channel 7 is to be turned on while channel 6 is masked off you still have to bias channel 6 in order for the
        // led on channel 7 to emmit light
        m_device_interface->SetRegister((bias_regAddress - 0x4), bias_regVal); // BIAS_DAC_CONFIG_N
      }
 
      m_device_interface->SetRegister(timing_regAddress, timing_regVal); // cal_CONFIG_N
    } else {
      TLOG(TLVL_FULL_DEBUG) << "Will turn off channel " << std::dec << counter << " at timing register 0x" << std::hex
                            << timing_regAddress << std::dec << std::endl;
      m_device_interface->SetRegister(bias_regAddress, 0x0);   // BIAS_DAC_CONFIG_N
      m_device_interface->SetRegister(timing_regAddress, 0x0); // cal_CONFIG_N
    }
  }
 
  m_device_interface->SetRegister(0x40000300, 0x1); // writing 0x1 to this register applies the bias voltage settings
 
  m_run_marker = true;
  TLOG_DEBUG(TLVL_ENTER_EXIT_METHODS) << "Start pulsing SSPLEDCalibWrapper of card " << m_board_id << " complete.";
}
 
void
SSPLEDCalibWrapper::stop(const data_t& /*args*/)
{
 
  TLOG_DEBUG(TLVL_ENTER_EXIT_METHODS) << "Stop pulsing SSPLEDCalibWrapper of card " << m_board_id << "...";
  if (!m_run_marker.load()) {
    TLOG_DEBUG(TLVL_ENTER_EXIT_METHODS) << "The run_marker says that SSPLEDCalibWrapper card " << m_board_id
                                        << " is already stopped, but stopping anyways...";
  }
 
  for (unsigned int counter = 0; counter < 12; counter++) { // switch this to 12 for a 12 channel SSP
    unsigned int bias_regAddress = 0x40000340 + 0x4 * (counter);
    unsigned int timing_regAddress = 0x800003c0 + 0x4 * (counter);
    m_device_interface->SetRegister(bias_regAddress, 0x00000000);   // BIAS_DAC_CONFIG_N
    m_device_interface->SetRegister(timing_regAddress, 0x00000000); // cal_CONFIG_N
  }
 
  m_device_interface->SetRegister(0x40000300, 0x1); // writing 0x1 to this register applies the bias voltage settings
 
  m_run_marker = false;
  TLOG_DEBUG(TLVL_ENTER_EXIT_METHODS) << "Stop pulsing SSPLEDCalibWrapper of card " << m_board_id << " complete.";
}
 
void
SSPLEDCalibWrapper::configure_single_pulse()
{
  TLOG_DEBUG(TLVL_ENTER_EXIT_METHODS) << "SSPLEDCalibWrapper::ConfigureSinglePulse called.";
 
  m_device_interface->SetRegister(0x80000464, 0x000002E7); // pdts_cmd_control_1
  m_device_interface->SetRegister(0x80000940, 0x00030036); // pdts_cmd_delay_0
  m_device_interface->SetRegister(0x80000944, 0x00030036); // pdts_cmd_delay_1
  m_device_interface->SetRegister(0x80000948, 0x00030036); // pdts_cmd_delay_2
  m_device_interface->SetRegister(0x8000094C, 0x00030036); // pdts_cmd_delay_3
  m_device_interface->SetRegister(0x80000950, 0x00030036); // pdts_cmd_delay_4
  m_device_interface->SetRegister(0x80000954, 0x00030036); // pdts_cmd_delay_5
  m_device_interface->SetRegister(0x80000958, 0x00030036); // pdts_cmd_delay_6
  m_device_interface->SetRegister(0x8000095C, 0x00030036); // pdts_cmd_delay_7
  m_device_interface->SetRegister(0x80000960, 0x00030036); // pdts_cmd_delay_8
  m_device_interface->SetRegister(0x80000964, 0x00030036); // pdts_cmd_delay_9
  m_device_interface->SetRegister(0x80000968, 0x00030036); // pdts_cmd_delay_10
  m_device_interface->SetRegister(0x8000096C, 0x00030036); // pdts_cmd_delay_11
  m_device_interface->SetRegister(0x80000970, 0x00030036); // pdts_cmd_delay_12
  m_device_interface->SetRegister(0x80000974, 0x00030036); // pdts_cmd_delay_13
  m_device_interface->SetRegister(0x80000978, 0x00030036); // pdts_cmd_delay_14
  m_device_interface->SetRegister(0x8000097C, 0x00030036); // pdts_cmd_delay_15
  m_device_interface->SetRegister(0x80000468, 0x80000000); // pdts_cmd_control_2
  m_device_interface->SetRegister(0x80000520, 0x00000011); // pulser_mode_control
  m_device_interface->SetRegister(0x80000448, 0x00000001); // cal_count
 
  TLOG_DEBUG(TLVL_ENTER_EXIT_METHODS) << "SSPLEDCalibWrapper::ConfigureSinglePulse completed.";
}
 
void
SSPLEDCalibWrapper::configure_burst_mode()
{
  TLOG_DEBUG(TLVL_ENTER_EXIT_METHODS) << "SSPLEDCalibWrapper::ConfigureBurstMode called.";
 
  m_device_interface->SetRegister(0x80000464, 0x000002E7);    // pdts_cmd_control_1
  m_device_interface->SetRegister(0x80000940, 0x00030036);    // pdts_cmd_delay_0
  m_device_interface->SetRegister(0x80000944, 0x00030036);    // pdts_cmd_delay_1
  m_device_interface->SetRegister(0x80000948, 0x00030036);    // pdts_cmd_delay_2
  m_device_interface->SetRegister(0x8000094C, 0x00030036);    // pdts_cmd_delay_3
  m_device_interface->SetRegister(0x80000950, 0x00030036);    // pdts_cmd_delay_4
  m_device_interface->SetRegister(0x80000954, 0x00030036);    // pdts_cmd_delay_5
  m_device_interface->SetRegister(0x80000958, 0x00030036);    // pdts_cmd_delay_6
  m_device_interface->SetRegister(0x8000095C, 0x00030036);    // pdts_cmd_delay_7
  m_device_interface->SetRegister(0x80000960, 0x00030036);    // pdts_cmd_delay_8
  m_device_interface->SetRegister(0x80000964, 0x00030036);    // pdts_cmd_delay_9
  m_device_interface->SetRegister(0x80000968, 0x00030036);    // pdts_cmd_delay_10
  m_device_interface->SetRegister(0x8000096C, 0x00030036);    // pdts_cmd_delay_11
  m_device_interface->SetRegister(0x80000970, 0x00030036);    // pdts_cmd_delay_12
  m_device_interface->SetRegister(0x80000974, 0x00030036);    // pdts_cmd_delay_13
  m_device_interface->SetRegister(0x80000978, 0x00030036);    // pdts_cmd_delay_14
  m_device_interface->SetRegister(0x8000097C, 0x00030036);    // pdts_cmd_delay_15
  m_device_interface->SetRegister(0x80000468, 0x80000000);    // pdts_cmd_control_2
  m_device_interface->SetRegister(0x80000520, 0x00000011);    // pulser_mode_control
  m_device_interface->SetRegister(0x80000448, m_burst_count); // cal_count
 
  TLOG_DEBUG(TLVL_ENTER_EXIT_METHODS) << "SSPLEDCalibWrapper::ConfigureBurstMode completed.";
}
 
void
SSPLEDCalibWrapper::manual_configure_device(const std::vector<const appmodel::SSPRegister*>& hw_conf)
{
  TLOG_DEBUG(TLVL_ENTER_EXIT_METHODS) << "SSPLEDCalibWrapper::ConfigureDevice called.";
  TLOG(TLVL_FULL_DEBUG) << "SSPLEDCalibWrapper: Processing the Hardware Configuration list..." << std::endl;
  for (auto regValuesIter : hw_conf) {
    std::string m_name = regValuesIter->get_name();
    unsigned int regAddr = regValuesIter->get_address();
    unsigned int regVal = regValuesIter->get_value();
    unsigned int regMask = regValuesIter->get_mask();
    m_device_interface->SetRegister(regAddr, regVal, regMask);
  }
  TLOG_DEBUG(TLVL_ENTER_EXIT_METHODS) << "SSPLEDCalibWrapper::ConfigureDevice complete.";
} // NOLINT(readability/fn_size)
 
void
SSPLEDCalibWrapper::validate_config(const data_t& /*args*/)
{
  TLOG_DEBUG(TLVL_ENTER_EXIT_METHODS) << "SSPLEDCalibWrapper::validate_config called.";
 
  if (!((m_number_channels == 5) || (m_number_channels == 12))) {
    std::stringstream ss;
    ss << "ERROR: Incorrect number_channels value " << m_number_channels << " is not equal to 5 or 12!!!" << std::endl;
    TLOG() << ss.str();
    throw ConfigurationError(ERS_HERE, ss.str());
  }
 
  if (m_channel_mask > 4095) {
    std::stringstream ss;
    ss << "ERROR: Incorrect channel_maks value " << m_channel_mask << " is higher than the limit of 4095!!!"
       << std::endl;
    TLOG() << ss.str();
    throw ConfigurationError(ERS_HERE, ss.str());
  }
 
  if (!(m_single_pulse || m_burst_mode)) {
    std::stringstream ss;
    ss << "ERROR: Incorrect pulse_mode value. Neither single or burst." << std::endl;
    TLOG() << ss.str();
    throw ConfigurationError(ERS_HERE, ss.str());
  }
 
  if (m_double_pulse_delay_ticks > 4095) {
    std::stringstream ss;
    ss << "ERROR: Strange!! double_pulse_delay_ticks value is " << m_double_pulse_delay_ticks
       << ", which is greater than the limit of 4095" << std::endl;
    TLOG() << ss.str();
    // throw ConfigurationError(ERS_HERE, ss.str());
  }
 
  if (m_burst_count > 10000) {
    std::stringstream ss;
    ss << "ERROR: Strange!! burst_count value is " << m_burst_count
       << ", which is more time than in a drift readout window" << std::endl;
    TLOG() << ss.str();
    // throw ConfigurationError(ERS_HERE, ss.str());
  }
 
  if (m_pulse1_width_ticks > 255) {
    std::stringstream ss;
    ss << "ERROR: Incorrect pulse1_width_ticks value is " << m_pulse1_width_ticks
       << ", which is greater than the limit of 255!!!" << std::endl;
    TLOG() << ss.str();
    throw ConfigurationError(ERS_HERE, ss.str());
  }
 
  if (m_pulse2_width_ticks > 255) {
    std::stringstream ss;
    ss << "ERROR: Incorrect pulse2_width_ticks value is " << m_pulse2_width_ticks
       << ", which is greater than the limit of 255!!!" << std::endl;
    TLOG() << ss.str();
    throw ConfigurationError(ERS_HERE, ss.str());
  }
 
  if (m_pulse_bias_percent_270nm > 4095) {
    std::stringstream ss;
    ss << "ERROR: Incorrect pulse_bias_percent_270nm value is " << m_pulse_bias_percent_270nm
       << ", which is greater than 100 percent!!!" << std::endl;
    TLOG() << ss.str();
    throw ConfigurationError(ERS_HERE, ss.str());
  }
 
  if (m_pulse_bias_percent_367nm > 4095) {
    std::stringstream ss;
    ss << "ERROR: Incorrect pulse_bias_percent_367nm value is " << m_pulse_bias_percent_367nm
       << ", which is greater than 100 percent!!!" << std::endl;
    TLOG() << ss.str();
    throw ConfigurationError(ERS_HERE, ss.str());
  }
 
  TLOG_DEBUG(TLVL_ENTER_EXIT_METHODS) << "SSPLEDCalibWrapper::validate_config complete.";
}
 
} // namespace sspmodules
} // namespace dunedaq
 
#endif // SSPMODULES_SRC_SSPLEDCALIBWRAPPER_CPP_