roclib/src_nxyter/NxContext.cxx (r4864/r4110)

Go to the documentation of this file.

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

#include "nxyter/NxContext.h"

#include <stdexcept>
#include <iomanip>

#include "nxyter/NxI2c.h"

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

nxyter::NxContext::NxContext()
{
  for (int i=0; i<dimRegMain; i++) fRegMain[i] = 0;
  for (int i=0; i<dimRegTrim; i++) fRegTrim[i] = 0;
}

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

nxyter::NxContext::~NxContext()
{
}

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

void nxyter::NxContext::setRegister(int reg, uint8_t val)
{
  if (reg<0 || reg>=dimRegMain) 
    throw std::out_of_range("NxContext::setRegister(): reg out of range");
  fRegMain[reg] = val;
}

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

uint8_t nxyter::NxContext::getRegister(int reg) const
{
  if (reg<0 || reg>=dimRegMain) 
    throw std::out_of_range("NxContext::getRegister(): reg out of range");
  return fRegMain[reg];
}

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

void nxyter::NxContext::setTrimRegister(int channel, uint8_t val)
{
  if (channel<0 || channel>=dimRegTrim) 
    throw std::out_of_range("NxContext::setTrimRegister():channel out of range");
  fRegTrim[channel] = val & 0x3f;               // only 6 bits !!
}

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

uint8_t nxyter::NxContext::getTrimRegister(int channel) const
{
  if (channel<0 || channel>=dimRegTrim) 
    throw std::out_of_range("NxContext::getTrimRegister(): channel out of range");
  return fRegTrim[channel];
}

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

void nxyter::NxContext::setChannelMaskBit(int channel, bool isoff)
{
  if (channel<0 || channel>=128) 
    throw std::out_of_range("NxContext::setChannelMaskBit(): channel out of range");

  int reg = (channel>>3) & 0x1f;
  uint8_t mask = 1<<(channel&0x7);
  if (isoff) {
    fRegMain[reg] |=  mask;
  } else {
    fRegMain[reg] &= ~mask;
  }
}

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

void nxyter::NxContext::setChannelMaskBit(int chbeg, int chend, bool isoff,
                                          int chstep)
{
  if (chstep <= 0) return;
  for (int ch=chbeg; ch<=chend; ch+=chstep) setChannelMaskBit(ch, isoff);
}

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

bool nxyter::NxContext::getChannelMaskBit(int channel) const
{
  if (channel<0 || channel>=128) 
    throw std::out_of_range("NxContext::getChannelMaskBit(): channel out of range");

  int reg = (channel>>3) & 0x1f;
  uint8_t mask = 1<<(channel&0x7);
  
  return fRegMain[reg] & mask;
}

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

void nxyter::NxContext::setThresholdTrim(int channel, uint8_t val)
{
  if (channel<0 || channel>=dimRegTrim) 
    throw std::out_of_range("NxContext::setThresholdTrim(): channel out of range");

  fRegTrim[channel] &= ~0x1f;               // erease lower 5 bit
  fRegTrim[channel] |= val & 0x1f;          // fill in lower 5 bit
}

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

void nxyter::NxContext::setThresholdTrim(int chbeg, int chend, uint8_t val,
                                         int chstep)
{
  if (chstep <= 0) return;
  for (int ch=chbeg; ch<=chend; ch+=chstep) setThresholdTrim(ch, val);
}

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

uint8_t nxyter::NxContext::getThresholdTrim(int channel) const
{
  if (channel<0 || channel>=dimRegTrim) 
    throw std::out_of_range("NxContext::getThresholdTrim(): channel out of range");

  return fRegTrim[channel] & 0x1f;          // return lower 5 bit
}

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

void nxyter::NxContext::setPowerOffMaskBit(int channel, bool isoff)
{
  if (channel<0 || channel>=dimRegTrim) 
    throw std::out_of_range("NxContext::setPowerOffMaskBit(): channel out of range");

  if (isoff) {
    fRegTrim[channel] |=  0x20;
  } else {
    fRegTrim[channel] &= ~0x20;                     // erease bit 6
  }
}

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

void nxyter::NxContext::setPowerOffMaskBit(int chbeg, int chend, bool isoff,
                                           int chstep)
{
  if (chstep <= 0) return;
  for (int ch=chbeg; ch<=chend; ch+=chstep) setPowerOffMaskBit(ch, isoff);
}

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

bool nxyter::NxContext::getPowerOffMaskBit(int channel) const
{
  if (channel<0 || channel>=dimRegTrim) 
    throw std::out_of_range("NxContext::getPowerOffMaskBit(): channel out of range");

  return fRegTrim[channel] & 0x20;
}


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

bool nxyter::NxContext::getConfigurationBit(int n)
{
   if ((n<0) || (n>=12)) return false;
   if (n<8) return (fRegMain[32] & (1 << n)) != 0;
   return (fRegMain[33] & (1<<(n-8))) != 0;
}

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

void nxyter::NxContext::setConfigurationBit(int n, bool on)
{
   if ((n<0) || (n>=12)) return;
   if (n<8)
      fRegMain[32] = on ? (fRegMain[32] | (1 << n)) : (fRegMain[32] & ~(1 << n));
   else
      fRegMain[33] = on ? (fRegMain[33] | (1 << (n-8))) : (fRegMain[33] & ~(1 << (n-8)));
}

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

void nxyter::NxContext::setToDefault(bool ispos, int maskon, int poweron)
{
  // real clean...
  for (int i=0; i<dimRegMain; i++) fRegMain[i] = 0;
  for (int i=0; i<dimRegTrim; i++) fRegTrim[i] = 0;

  for (int i=0; i<128; i++) {
    setChannelMaskBit(i, i>=maskon);        // mask=1  means channel off
    setPowerOffMaskBit(i, i>=poweron);      // isoff=1 means channel power off
    setThresholdTrim(i, 16);
  }
  setPowerOffMaskBit(128, false);
  setThresholdTrim(128, 16);

  // taken from nxyter::I2Cbus::testsetup()
  setRegister(kNxRegVcg,     160);
  setRegister(kNxRegIcgfoll, 255);
  setRegister(kNxRegVth,      35);
  setRegister(kNxRegVbfb,     30);
  setRegister(kNxRegVbiasF,   95);
  setRegister(kNxRegVbiasS,   87);
  setRegister(kNxRegVbiasS2, 100);
  setRegister(kNxRegVcm,     137);
  setRegister(kNxRegcal,     255);
  setRegister(kNxRegiCOMP,    69);
  setRegister(kNxRegiDUR,     15);
  setRegister(kNxRegiINV,     54);
  setRegister(kNxRegiPDH,     92);
  setRegister(kNxRegiTWC,     69);
  setRegister(kNxRegConfig0,   0);
  setRegister(kNxRegConfig1,  kNxC1ReadClockSelect | 0x3);
  
  // now handle what is different for positive polarity
  // 1. Front end polarity bit set
  // 2. test puls polarity bit set
  // 3. VBiasF default 65 rather than 95
  if (ispos) {
    uint8_t val = getRegister(kNxRegConfig1);
    setRegister(kNxRegConfig1, val | kNxC1FrontEndPolarity);
    setRegister(kNxRegConfig0, kNxC0TestPulsPolarity);
    setRegister(kNxRegVbiasF,   65);
  }
}

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

bool nxyter::NxContext::equal(const NxContext& rhs, int domask) const
{
  if (domask & kDoMask) {
    for (int i=0; i<16; i++) {
      if (fRegMain[i] != rhs.fRegMain[i]) return false;
    }
  }
  if (domask & kDoCore) {
    for (int i=16; i<dimRegMain; i++) {
      if (i==30 || i==31) continue;         // skip unimplemented regs
      if (i>=34 && i<=37) continue;         // skip error counters 
      if (i>=40 && i<=42) continue;         // skip unimplemented regs and reg42
      if (fRegMain[i] != rhs.fRegMain[i]) return false;
    }
  }
  if (domask & kDoTrim) {
    for (int i=0; i<dimRegTrim; i++) {
      if (fRegTrim[i] != rhs.fRegTrim[i]) return false;
    }
  }
  return true;
}

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

void nxyter::NxContext::print(std::ostream& os, int domask) const
{
  // print registers
  for (int i=0; i<46; i++) {
    if ((domask & kDoMask)==0 && i<16) continue;
    if ((domask & kDoCore)==0 && i>=16) continue;
    
    if (i>=34 && i<=37) continue;
    if (i==42) continue;
    const char* regname = nxyter::NxI2c::registerName(i);
    if ((regname==0) || (*regname==0)) continue;

    char sbuf[200];
    snprintf(sbuf, sizeof(sbuf),
             "Reg(%2d) %14s: 0x%02x %3u",
              i, regname, (unsigned) fRegMain[i], (unsigned) fRegMain[i]);
    os << sbuf;

    if (i<16) {                             // mask registers
      os << " :  ch :" << std::setw(3) << (8*i)+7 << "-" << std::setw(3) << (8*i) << ":";
      for (int j=7; j>=0; j--) os << ((fRegMain[i] & (1<<j)) ? " d" : " o");
      if (i==0) os << "   o=active";
      if (i==1) os << "   d=inactive";
    }
    
    if (i==32 || i==33) {
      for (int j=0; j<8; j++) {
        if (j!=0) os << "                                ";

        os << "bit(" << j << ") = " << ((fRegMain[i]&(1<<j)) ? 1 : 0) << " : "
           << nxyter::NxI2c::configurationBitName(8*(i-32)+j);
        if (i==32 && j!=7) os << std::endl;
        if (i==33 && j!=3) os << std::endl;  
        if (i==33 && j==3) break;
      }
    }

    if ((i==38) || (i==39) || (i>=43))          // delay regs
       os << " : delay=" << std::setw(3) << nxyter::NxI2c::settingToDelay(fRegMain[i]);

    os << std::endl;
  }

  if ((domask & kDoTrim)==0) return;

  for (int i=0; i<129; i++) {
    if (i%8 == 0)
      os << "Reg(42) TrimDAQ-Power : ch " << std::setw(3) << i << ":";
    os << "  " << (getPowerOffMaskBit(i) ? "d" : "u");
    os << " " << std::setw(2) << getThresholdTrim(i);
    if (i%8 == 7) os << std::endl;
  }
  os << std::endl; 
}

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

bool nxyter::NxContext::fillCmdFile(FILE* f, int nx)
{
   fprintf(f,"//Actual nXYTER registers\n");

   // bias registers
   for (int reg=16;reg<30;reg++)
      fprintf(f,"setnx %d,%d,%d \n", nx, reg, getRegister(reg));

   for (int reg=32;reg<34;reg++)
      fprintf(f,"setnx %d,%d,%d \n", nx, reg, getRegister(reg));

   for (int reg=38;reg<40;reg++)
      fprintf(f,"setnx %d,%d,%d \n", nx, reg, getRegister(reg));

   for (int reg=43;reg<46;reg++)
      fprintf(f,"setnx %d,%d,%d \n", nx, reg, getRegister(reg));


   // mask values
   int nbeg = 0, nch = 1;
   bool begoff = getChannelMaskBit(0);

   while (nch<=128) {
      bool isoff = nch < 128 ? getChannelMaskBit(nch) : begoff;

      if ((isoff!=begoff) || (nch == 128)) {
         fprintf(f,"setnxmask %d,%d,%d,%d,1 \n", nx, begoff ? 1 : 0, nbeg, nch-1);
         nbeg = nch;
         begoff = isoff;
      }
      nch++;
   }

   // trimmer values
   nbeg = 0; nch = 1;
   int begtrim = getThresholdTrim(0);

   while (nch<=129) {
      int trim = nch < 129 ? getThresholdTrim(nch) : begtrim;

      if ((trim!=begtrim) || (nch == 129)) {
         fprintf(f,"setnxtrim %d,%d,%d,%d,1 \n", nx, begtrim, nbeg, nch-1);
         nbeg = nch;
         begtrim = trim;
      }
      nch++;
   }

   // power down bits
   nbeg = 0; nch = 1;
   begoff = getPowerOffMaskBit(0);

   while (nch<=129) {
      bool isoff = nch < 129 ? getPowerOffMaskBit(nch) : begoff;

      if ((isoff!=begoff) || (nch == 129)) {
         fprintf(f,"setnxpower %d,%d,%d,%d,1 \n", nx, begoff ? 1 : 0, nbeg, nch-1);
         nbeg = nch;
         begoff = isoff;
      }
      nch++;
   }


   return true;
}


//----------------------------------------------------------------------------
// allocate storage for 'static const', rootcint needs it
const int nxyter::NxContext::dimRegMain;
const int nxyter::NxContext::dimRegTrim;