roclib/src_nxyter/FebBase.cxx (r4864/r4162)

Go to the documentation of this file.

//============================================================================
//============================================================================

#include <string.h>

#include <stdexcept>

#include "roc/defines_i2c.h"
#include "roc/I2cDevice.h"

#include "nxyter/defines_nxyter.h"
#include "nxyter/FebBase.h"

#include "nxyter/Feb1nxGenB.h"
#include "nxyter/Feb1nxGenC.h"
#include "nxyter/Feb1nxGenD.h"
#include "nxyter/Feb2nxGas.h"
#include "nxyter/Feb4nxBT.h"

//----------------------------------------------------------------------------

nxyter::FebBase::FebBase() :
  base::Peripheral(),
  fPort(0),
  fType(0),
  fMainAdc(),
  fMonAdcDevice(),
  fEepromDevice()
{
}


nxyter::FebBase::FebBase(base::Board* board, int port, int type) :
  base::Peripheral(board),
  fPort(port),
  fType(type),
  fMainAdc(board, port, (type/100==4)),
  fMonAdcDevice(board, port, 0),
  fEepromDevice(board, port, 0)
{
  int numnx = type/100;                     // this holds by convention !!
  fNxChip.reserve(numnx);
  fNxOffline.reserve(numnx);
  fMode4nx = (numnx == 4);
  fAdcChannel.reserve(numnx);
}

//----------------------------------------------------------------------------

nxyter::FebBase::~FebBase()
{
  for (int i=0; i<fNxChip.size(); i++) delete fNxChip[i];
}

//----------------------------------------------------------------------------

nxyter::NxChip& nxyter::FebBase::nx(int nxind)
{
  return *(fNxChip.at(nxind));
}

//----------------------------------------------------------------------------

int nxyter::FebBase::initRoc()
{
  int rc = board().put(ROC_NX_FEB4NX, (fMode4nx ? 1 : 0));
  if (rc) return rc;
  for (int i=0; i<numNx(); i++) {
    if (!getNxOffline(i))
       rc = adc().setChannelMux(nx(i).getNxNumber(), fAdcChannel[i]);
    if (rc) return base::Board::operErrBuildInc(rc, 2*(i+1));

    if (getNxOffline(i))
       rc = nx(i).deactivate();
    else
       rc = nx(i).activate();
    if (rc) return base::Board::operErrBuildInc(rc, 2*(i+1)+1);
  }
  return 0;
}


//----------------------------------------------------------------------------

int nxyter::FebBase::getFebState()
{
  for (int i=0; i<numNx(); i++) {
     bool active = nx(i).isactive();
     setNxOffline(i, !active);
  }
  return 0;
}


//----------------------------------------------------------------------------

int nxyter::FebBase::probe() 
{
  int rc = 0;
  
  for (int i=0; i<fNxChip.size(); i++) {
    if (nx(i).i2c().probe()) {              // !=0 return means probe failed !
      setNxOffline(i, true);
      rc |= 1<<i;
    } else {
      setNxOffline(i, false);
    }
  }
  if (adc().probe()) rc |= 1<<5;
  return rc;
}

//----------------------------------------------------------------------------

int nxyter::FebBase::setToDefault(bool ispos0, bool ispos1)
{
  bool pos[4];
  for (int i=0; i<4; i++) pos[i] = ispos0;
  if (fNxChip.size()==2) pos[1] = ispos1;
  if (fNxChip.size()==4) pos[2] = pos[3] = ispos1;

  int rc;
  
  for (int i=0; i<fNxChip.size(); i++) {
    if (getNxOffline(i)) continue;          // skip if offline
    rc = nx(i).i2c().setToDefault(pos[i]);
    if (rc) return base::Board::operErrBuild(rc, i);
  }
  rc = adc().setToDefault();
  if (rc) return base::Board::operErrBuild(rc, 5);
  return 0;
}

//----------------------------------------------------------------------------

void nxyter::FebBase::printNxHeadLine(std::ostream& os, int nxind)
{
  os << std::dec;
  os << "----- nXYTER at port=" << fPort
     << " index=" << nxind
     << " number=" << nx(nxind).getNxNumber()
     << " addr=" << uint32_t(nx(nxind).i2c().getSlaveAddr());
  if (getNxOffline(nxind)) {
    os << " ----- is set OFFLINE -----";
  } else {
    os << " --------------------------";
  }
  os << std::endl;
}

//----------------------------------------------------------------------------

void nxyter::FebBase::printRegisters(std::ostream& os, int domask)
{
  for (int i=0; i<fNxChip.size(); i++) {
    printNxHeadLine(os, i);
    if (!getNxOffline(i)) nx(i).i2c().printRegisters(os, domask);
  }
  os << "----- ADC at port=" << fPort << " --------------------" << std::endl;
  adc().printRegisters(os);
}

//----------------------------------------------------------------------------

void nxyter::FebBase::resetNxI2cBus()
{
  board().operPPP(ROC_NX_I2C_SWITCH, fPort,
                  ROC_NX_I2C_RESET,  0,
                  ROC_NX_I2C_RESET,  1);
}

//----------------------------------------------------------------------------

void nxyter::FebBase::resetNxI2cRegister()
{
  board().operPPP(ROC_NX_I2C_SWITCH,    fPort,
                  ROC_NX_I2C_REGRESET,  0,
                  ROC_NX_I2C_REGRESET,  1);
}

//----------------------------------------------------------------------------

int nxyter::FebBase::setNxTestModes(bool testpuls, bool testtrig, 
                                    int calselect)
{
  for (int i=0; i<fNxChip.size(); i++) {
    int rc = nx(i).i2c().setTestModes(testpuls, testtrig, calselect);
    if (rc) return base::Board::operErrBuild(rc, i);
  }
  return 0;
}

//----------------------------------------------------------------------------

int nxyter::FebBase::setNxRegisterAll(uint8_t reg, uint8_t val, bool veri)
{
   for (int i=0; i<fNxChip.size(); i++) {
      if (getNxOffline(i)) continue;          // skip if offline
      int rc = nx(i).i2c().setRegister(reg, val, veri);
      if (rc) return base::Board::operErrBuild(rc, i);
   }
   return 0;
}

//----------------------------------------------------------------------------
// ! return number of monitor ADC channels, 0 if not supported

int nxyter::FebBase::getNumMonAdc()
{
   if (!monAdcSupport()) return 0;

   return 4;
}

//----------------------------------------------------------------------------

int nxyter::FebBase::getMonAdc(int ch, uint16_t &val)
{
  val = 0;
  if (!monAdcSupport()) return -1;
  if (ch < 0 || ch > 3) return -2;

  uint8_t mask = 1 << (ch+4);
  uint16_t adcval;
  int rc = fMonAdcDevice.getRegister16(mask, adcval);
  val = adcval & 0xfff;                     // strip 4 MSB (hold channel num)
  if (((adcval>>12) & 0x3) != ch) rc = -3;  // check for valid channel id
  return rc;
}

//----------------------------------------------------------------------------
void nxyter::FebBase::addNxChip(int addr, int nxnum, int adcmux)
{
  if (fNxChip.size() >= fNxChip.capacity()) 
    throw std::out_of_range("FATAL ERROR: addNxChip(), extraneous call");

  fNxChip.push_back(new nxyter::NxChip(getBoard(), fPort, addr, nxnum));
  fNxOffline.push_back(false);
  fAdcChannel.push_back(adcmux);
}
  
//----------------------------------------------------------------------------

const char* nxyter::FebBase::typeToString(int type)
{
  switch (type) {
    case kFeb1nx     : return "Feb1nx";
    case kFeb1nxGenB : return "Feb1nxGenB";
    case kFeb1nxGenC : return "Feb1nxGenC";
    case kFeb1nxGenD : return "Feb1nxGenD";
    case kFeb2nx     : return "Feb2nx";
    case kFeb2nxGas  : return "Feb2nxGas";
    case kFeb4nx     : return "Feb4nx";
    case kFeb4nxBT   : return "Feb4nxBT";
  }  
  return "";
}

//----------------------------------------------------------------------------

int nxyter::FebBase::stringToType(const char* str)
{
  if (strcmp(str, "Feb1nx")==0)     return kFeb1nx;
  if (strcmp(str, "Feb1nxGenB")==0) return kFeb1nxGenB;
  if (strcmp(str, "Feb1nxGenC")==0) return kFeb1nxGenC;
  if (strcmp(str, "Feb1nxGenD")==0) return kFeb1nxGenD;
  if (strcmp(str, "Feb2nx")==0)     return kFeb2nx;
  if (strcmp(str, "Feb2nxGas")==0)  return kFeb2nxGas;
  if (strcmp(str, "Feb4nx")==0)     return kFeb4nx;
  if (strcmp(str, "Feb4nxBT")==0)   return kFeb4nxBT;

  return 0;
}

//----------------------------------------------------------------------------

void nxyter::FebBase::discoverFebs(base::Board* board,
                                   int& typeport0, int& typeport1, 
                                   bool liberal)
{
  static const int dim_nxlist = 7;
  int nxaddr[dim_nxlist];
  int nxtype[dim_nxlist];
  
  nxaddr[0] =  8;  nxtype[0] = kFeb1nxGenC;
  nxaddr[1] = 40;  nxtype[1] = kFeb2nxGas;
  nxaddr[2] = 48;  nxtype[2] = kFeb2nxGas;
  nxaddr[3] = 72;  nxtype[3] = kFeb4nxBT;
  nxaddr[4] = 82;  nxtype[4] = kFeb4nxBT;
  nxaddr[5] = 84;  nxtype[5] = kFeb4nxBT;
  nxaddr[6] = 88;  nxtype[6] = kFeb4nxBT;
  
  bool ok_adc[2];
  int  num_adc = 0;
  bool ok_nx[2][dim_nxlist];
  int  numnx_1nxGen[2];
  int  numnx_2nxGas[2];
  int  numnx_4nxBT[2];
  numnx_1nxGen[0] = numnx_1nxGen[1] = 0;
  numnx_2nxGas[0] = numnx_2nxGas[1] = 0;
  numnx_4nxBT[0]  = numnx_4nxBT[1]  = 0;

  // first probe everything possible
  for (int port=0; port<=1; port++) {
    nxyter::MainAdc adc(board, port);
    if ( (ok_adc[port] = (adc.probe() == 0)) ) num_adc++;

    for (int i=0; i<dim_nxlist; i++) {
      nxyter::NxChip nx(board, port, nxaddr[i], 0);
      if ( (ok_nx[port][i] = (nx.i2c().probe() == 0)) ) {
        if (nxtype[i] == kFeb1nxGenC) numnx_1nxGen[port]++;
        if (nxtype[i] == kFeb2nxGas)  numnx_2nxGas[port]++;
        if (nxtype[i] == kFeb4nxBT)   numnx_4nxBT[port]++;
      }
    }
  }
  
  typeport0 = 0;
  typeport1 = 0;
  if (num_adc==0) return;

  int typeport[2];
  typeport[0] = 0;
  typeport[1] = 0;
  
  // in the non-liberal case ask for all
  if (not liberal) {
    if (ok_adc[0]) {
      if (numnx_1nxGen[0]==1) typeport[0] = kFeb1nxGenC;
      if (numnx_2nxGas[0]==2) typeport[0] = kFeb2nxGas;
      if (numnx_4nxBT[0]==4)  typeport[0] = kFeb4nxBT;
    }
    if (ok_adc[1] && typeport[0]!=kFeb4nx) {
      if (numnx_1nxGen[1]==1) typeport[1] = kFeb1nxGenC;
      if (numnx_2nxGas[1]==2) typeport[1] = kFeb2nxGas;
    }

    // in the liberal case one nXYTER is enough (Note that ranges are distinct)
  } else {
    if (ok_adc[0]) {
      if (numnx_1nxGen[0]>0) typeport[0] = kFeb1nxGenC;
      if (numnx_2nxGas[0]>0) typeport[0] = kFeb2nxGas;
      if (numnx_4nxBT[0]>0)  typeport[0] = kFeb4nxBT;
    }
    if (ok_adc[1] && typeport[0]!=kFeb4nx) {
      if (numnx_1nxGen[1]>0) typeport[1] = kFeb1nxGenC;
      if (numnx_2nxGas[1]>0) typeport[1] = kFeb2nxGas;
    }
  }

  // Now check whether a monitor I2C ADC is detected, if yes map
  //    Feb1nxGenC -> Feb1nxGenD

  for (int port=0; port<=1; port++) {
    if (typeport[port]) {
      uint16_t val;
      roc::I2cDevice i2c(board, port, 41);
      int rc = i2c.getRegister16(0x10, val);
      if (rc == 0) {
        if (typeport[port] == kFeb1nxGenC) typeport[port] = kFeb1nxGenD;
      }
    }
  }

  typeport0 = typeport[0];
  typeport1 = typeport[1];  
}

//----------------------------------------------------------------------------

nxyter::FebBase* nxyter::FebBase::newFeb(base::Board* board, int port, int type)
{
   if ((port<0) || (port>1)) return 0;

   switch (type) {
     case kFeb1nxGenB : return new Feb1nxGenB(board, port);
     case kFeb1nxGenC : return new Feb1nxGenC(board, port);
     case kFeb1nxGenD : return new Feb1nxGenD(board, port);
     case kFeb2nxGas  : return new Feb2nxGas(board, port);
     case kFeb4nxBT   : return new Feb4nxBT(board);
   }
   return 0;
}