roclib/src_nxyter/QuickDaq.cxx (r4864/r4196)

Go to the documentation of this file.

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

#include "nxyter/QuickDaq.h"

#include <sys/time.h>
#include <time.h>

#include <iostream>
#include <stdexcept>

#include "roc/UdpBoard.h"


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

nxyter::QuickDaq::QuickDaq(base::Board* board) :
  fBoard(board),
  fRocNx(board),
  fState(kDaqStopped),
  fStopCode(kDaqStopPending),
  fDaqLowWater(250),                        // 250 kB low water
  fDaqHighWater(500),                       // 500 kB high water
  fDaqFlushTimer(100),                      // 100 msec flush timer
  fDaqStaStoTimeout(1.),                    // 1 sec start/stop timeout
  fNextNxMaskActive(false), fNextNxMask(0),
  fStartTime(0.), fStopTime(0.),
  fStartMsgTime(0.), fStopMsgTime(0.),
  fMaxMsg(0.), fMaxTime(0.),
  fIter(board),
  fMsgTime(0.), fNowTime(0.)
{
  fFebs[0] = 0;
  fFebs[1] = 0;
}

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

nxyter::QuickDaq::QuickDaq(nxyter::FebBase* feb0, nxyter::FebBase* feb1) :
  fBoard(feb0 ? feb0->getBoard() : (feb1 ? feb1->getBoard() : 0)),
  fRocNx(fBoard),
  fState(kDaqStopped),
  fStopCode(kDaqStopPending),
  fDaqLowWater(250),                        // 250 kB low water
  fDaqHighWater(500),                       // 500 kB high water
  fDaqFlushTimer(100),                      // 100 msec flush timer
  fDaqStaStoTimeout(1.),                    // 1 sec start/stop timeout
  fNextNxMaskActive(false), fNextNxMask(0),
  fStartTime(0.), fStopTime(0.),
  fStartMsgTime(0.), fStopMsgTime(0.),
  fMaxMsg(0.), fMaxTime(0.),
  fIter(fBoard),
  fMsgTime(0.),
  fNowTime(0.)
{
  if (!fBoard)
    throw std::runtime_error("not any FEB specified");

  if (feb0 && feb1 && (feb0->getBoard() != feb1->getBoard()))
    throw std::runtime_error("FEB not hosted by same board");

   fFebs[0] = feb0;
   fFebs[1] = feb1;
}

//----------------------------------------------------------------------------
nxyter::QuickDaq::~QuickDaq()
{
  // if still running, stop it
  if (fState == kDaqRunning) {
    stopRun(true);
  }
}

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

int nxyter::QuickDaq::setNxTestModes(bool testpuls, bool testtrig, 
                                     int calselect)
{
  for (int i=0; i<2; i++) {
    if (fFebs[i]) {
      int rc = fFebs[i]->setNxTestModes(testpuls, testtrig, calselect);
      if (rc) return base::Board::operErrBuildInc(rc, 10*i);
    }
  }
  return 0;
}

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

int nxyter::QuickDaq::setNxRegisterAll(uint8_t reg, uint8_t val, bool veri)
{
  for (int i=0; i<2; i++) {
    if (fFebs[i]) {
      int rc = fFebs[i]->setNxRegisterAll(reg, val, veri);
      if (rc) return base::Board::operErrBuildInc(rc, 10*i);
    }
  }
  return 0;
}

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

void nxyter::QuickDaq::nextRunNxMask(int nxmask)
{
  fNextNxMaskActive = true;
  fNextNxMask = nxmask;
}

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

int nxyter::QuickDaq::startRun(int maxmsg, double maxtime, bool noinit)
{
  fMaxMsg  = double(maxmsg);
  fMaxTime = maxtime;
  fStats.clear();

  stopRun(true);

  if (!fBoard->stopDaq()) {
     fBoard->Debug(-1, "Cannot StopDaq - break QuickDaq");
     return 1;
  }

  if (noinit == false) {
    fRocNx.setNxActive(0);
    for (int i=0; i<2; i++) {
      if (fFebs[i]) fFebs[i]->initRoc();
    }
    if (fNextNxMaskActive) {
      uint32_t rocnxmask;
      fRocNx.getNxActive(rocnxmask);
      fRocNx.setNxActive(rocnxmask & fNextNxMask);
    }
  }


  // set timeout to flush data from internal buffer of driver
  // should reduce time for transfer of last data before stop daq
  roc::UdpBoard* udp = dynamic_cast<roc::UdpBoard*> (fBoard);
  roc::Board* rocbrd = dynamic_cast<roc::Board*> (fBoard);

  if (udp) {
     udp->setRocLowHighWater(fDaqLowWater, fDaqHighWater);
     udp->setRocBufferFlushTimer(fDaqFlushTimer);
     udp->setFlushTimeout(fDaqFlushTimer>10 ? fDaqFlushTimer/1000. : 0.01);
  } else
     fBoard->setFlushTimeout(0.01);

  if (rocbrd)
     if (rocbrd->uploadStartDaqCmdList(!noinit)) {
        rocbrd->Debug(-1, "Cannot init startdaq sequence - break QuickDaq");
        return 1;
     }

  if (!fBoard->startDaq()) {
     fBoard->Debug(-1, "Cannot StartDaq - break QuickDaq");
     return 1;
  }

  fState = kDaqStarting;
  fStopCode = kDaqStopPending;
  fStartTime = now();

  if (fBoard->isFile()) {
     fState = kDaqRunning;
     fStartMsgTime = now();
  }

  // now reset all 'next run' conditions
  fNextNxMaskActive = false;
  fNextNxMask = 0;

  return 0;
}

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

int nxyter::QuickDaq::stopRun(bool hardstop)
{
  if (fState == kDaqStarting || fState == kDaqRunning) {
    fBoard->suspendDaq();                     // FIXME ret codes
    fState = kDaqStopping;
    if (fStopCode == kDaqStopPending) fStopCode = kDaqStopByStop;
    fStopTime = now();
  }
  
  if (hardstop) {
    // for a hard stop, make an effort to drain the buffers
    // this is needed when used with KNUT
    // FIXME: do we need this with DABC transport ?
    while ((fState == kDaqStopping) && (now() < fStopTime+0.1)) {
      bool valid = fIter.next(0.05);
      if (!valid) break;
    }
  }
  
  return 0;
}

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

void nxyter::QuickDaq::interruptRun()
{
  // Note: this will typically called from a SIGINT signal handler
  //       thus simply set a flag, but no other calls...
  if (fState != kDaqStopped) fStopCode = kDaqStopByInterrupt;
}

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

bool nxyter::QuickDaq::testRun(double timeout)
{
  double timein = 0.;

  while(true) {

    fNowTime = now();
    if (timein == 0.) timein = fNowTime;
    
    // if daq stopped, quit
    if (fState == kDaqStopped) return false;

    // if interrupted, cleanup and quit
    if (fStopCode == kDaqStopByInterrupt) {
      stopRun(true);
      return false;
    }

    // daq not starting, bail out
    if (fState==kDaqStarting && fNowTime>=fStartTime+fDaqStaStoTimeout) {
       std::cout << "+++ daq not starting, bail out" << std::endl;
       fStopCode = kDaqStopByTimeout;
       stopRun(true);
       return false;
    }

    // daq not stopping, bail out
    if (fState==kDaqStopping && fNowTime>=fStopTime+fDaqStaStoTimeout) {
       std::cout << "+++ daq not stopping, bail out" << std::endl;
       fStopCode = kDaqStopByTimeout;
       stopRun(true);
       return false;
    }
    
    // check for message limit
    if (fMaxMsg > 0. &&
        fStats[nxyter::QuickDaqStats::kNMessage] >= fMaxMsg) {
      if (fStopCode == kDaqStopPending) fStopCode = kDaqStopByCount;
      stopRun(true);
      return false;
    }

    // check for time limit
    if (fState==kDaqRunning) {
      if ((fMaxTime > 0.) && (fNowTime >= fStartMsgTime+fMaxTime)) {
        stopRun();
        if (fStopCode == kDaqStopPending) fStopCode = kDaqStopByTime;
      }
    }
    
    bool valid = fIter.next(0.02);

    if (valid) {

      roc::Message& msg = fIter.msg();
      fStats.increment(msg);
      
      if (msg.isStartDaqMsg()) {
        fState = kDaqRunning;
        fStartMsgTime = now();
      } else if (msg.isStopDaqMsg()) {
        fState = kDaqStopped;
        fStopMsgTime = now();
      } 
      
      fMsgTime = fIter.getMsgFullTimeD() * 1.e-9;

    } else {

      if (fBoard->isFile()) {
         fState = kDaqStopped;
         fStopMsgTime = now();
         return true;
      }
    }

    double time = now();
    bool tmo = (timeout > 0. && time-timein > timeout);
    fNowTime = time;

    if (valid || tmo) return true;
  }
}

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

double nxyter::QuickDaq::now()
{
  struct timeval tv;
  gettimeofday(&tv, 0);
  return double(tv.tv_sec) + 1.e-6*double(tv.tv_usec);
}

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