utilities/UtilityApp.cxx (r4864/r4198)

Go to the documentation of this file.

//===========================================================================
/* \file UtilityApp.cxx
 * \author W.F.J.Mueller/GSI, restructured, significant additional functionality
 * \author Stefan Mueller-Klieser/KIP, Sergei Linev/GSI: original UtilityApp
 * \author Volker Kleipa/GSI, Anton Lymanets/GSI: original TestApp
 * \author Iurii Sorokin/GSI: added autotrim and idsigch commands
 * \author Tomas Balog/GSI: added autosettrh
 */
//============================================================================

#include <ctype.h>
#include <errno.h>
#include <signal.h>
#include <sys/time.h>
#include <time.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>

// just to have round(), which is not in cmath !!
#include <math.h>

#include <cmath>
#include <cstdlib>

#include <algorithm>
#include <iostream>
#include <string>
#include <vector>
#include <map>
#include <fstream>
#include <memory>

#include <readline/readline.h>
#include <readline/history.h>

#include "boost/format.hpp"

#include "roc/defines_roc.h"
#include "base/defines_gpio.h"
#include "nxyter/defines_nxyter.h"
#include "roc/defines_udp.h"
#include "roc/defines_optic.h"

#include "base/Board.h"
#include "sp605/Board.h"
#include "roc/Board.h"
#include "base/Gpio.h"
#include "roc/I2cDevice.h"
#include "roc/UdpBoard.h"
#include "nxyter/RocNx.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"
#include "nxyter/NxI2c.h"
#include "nxyter/NxContext.h"
#include "nxyter/FebUtil.h"
#include "nxyter/QuickDaq.h"
#include "nxyter/DistFunc.h"
#include "nxyter/DistFuncArray.h"
#include "nxyter/NxDataSummary.h"
#include "feet/RocFeet.h"

base::Board*      gBaseBoard = 0;
roc::Board*       gRocBoard = 0;
sp605::Board*     gSP605Board = 0;
base::Gpio*       gGpio  = 0;
nxyter::RocNx*    gRocNx = 0;
nxyter::FebBase*  gFeb   = 0;
nxyter::QuickDaq* gQdaq  = 0;
nxyter::FebUtil*  gUtil  = 0;

std::string gBoardName;

int gIntCount = 0;

std::vector<std::string> argspos;
std::vector<std::string> argsopt;

enum ArgNeedConstants {
   kNeedBoard    = (1<<0),
   kNeedRocBoard = (1<<1),
   kNeedFeb      = (1<<2),
   kNeedDaq      = (1<<3),
};

//----------------------------------------------------------------------------
//++ the command table +++++++++++++++++++++++++++++++++++++++++++++++++++++++

int cmd_autoped();
int cmd_autosettrh();
int cmd_autotrim();
int cmd_autovbiass();
int cmd_board();
int cmd_discover();
int cmd_dlm();
int cmd_feb();
int cmd_firepulser();
int cmd_getadcdirect();
int cmd_geti2c();
int cmd_puti2c();
int cmd_getnx();
int cmd_getroc();
int cmd_help();
int cmd_ident();
int cmd_idsigch();
int cmd_initfeb();
int cmd_printadc();
int cmd_printdata();
int cmd_printdatadbg();
int cmd_printfeb();
int cmd_printgpio();
int cmd_printid();
int cmd_printmon();
int cmd_printnx();
int cmd_printroc();
int cmd_printrocmap();
int cmd_printstatus();
int cmd_putroc();
int cmd_quit();
int cmd_resetnxi2cbus();
int cmd_resetnxi2creg();
int cmd_resetrocnxts();
int cmd_restartbrd();
int cmd_saverocconf();
int cmd_scanadclat();
int cmd_scanmonadc();
int cmd_scanvbiasf();
int cmd_scanvbiass();
int cmd_setadc();
int cmd_setadcclock();
int cmd_setadcdef();
int cmd_setadcpatt();
int cmd_setaux();
int cmd_setdebug();
int cmd_setfebdef();
int cmd_seti2c();
int cmd_setlhwater();
int cmd_setnx();
int cmd_setnxaddr();
int cmd_setnxdef();
int cmd_setnxmask();
int cmd_setnxmode();
int cmd_setnxoff();
int cmd_setnxpower();
int cmd_setnxtrim();
int cmd_setbrddef();
int cmd_setrocdef();
int cmd_setsyncm();
int cmd_setsyncs();
int cmd_settrace();
int cmd_testadccntl();
int cmd_testadcdata();
int cmd_testfebcntl();
int cmd_testnxcntl();
int cmd_testnxdata();
int cmd_testnxregs();
int cmd_testrocaux();
int cmd_testrocsync();


typedef struct
{
  const char* name;                         
  int       (*func)();                      
  const char* shelp;                        
  const char* lhelp;                        
} cmditem_t;


// this is list of the currently-active commands
std::vector<cmditem_t*> cmdlist;


cmditem_t cmdlist_base[] = {
   { name:    "help|h",
     func: cmd_help,
     shelp:"[-g -v|command] : help on rocutil and its commands",
     lhelp:"  -g      gives general help on using rocutil\n"
           "  -v      gives full help test for all commands\n"
           "  -a      gives list of command abbreviations\n"
           "  command gives help text for the given command"
   },
   { name:    "board|b",
     func: cmd_board,
     shelp:"brdname : connect to board",
     lhelp:"  brdname  address of the board to connect\n"
           "    Note: connection mode (DAQ, Control, or Observer) could be specified as\n"
           "          optional argument like cbmtest03?Control. Default is DAQ mode\n"
           "    Example of valid addresses: \n"
           "        board=cbmtest08   -  udp connection to ROC board with address cbmtest08\n"
           "        board=140.181.115.234?Control  - udp connection to ROC board with specified IP in control mode\n"
           "        board=abb1  - optic connection to ROC board, connected via second SFP\n"
           "        board=optic://abb13/sp605 - optic connection to SP605 board, connected via second SFP on ABB and forth SFP on DCB"
   },
   { name:    "quit|q",
     func: cmd_quit,
     shelp:"exit program",
     lhelp:""
   },
   { name: 0,
     func: 0,
     shelp:0,
     lhelp:0
   }
};

cmditem_t cmdlist_board[] = {
   { name:    "getroc|get",
     func: cmd_getroc,
     shelp:"aname : direct get() from board control space !! EXPERT ONLY !!",
     lhelp:"  aname   symbolic name of the board control space resource"
   },
   { name:    "putroc|put",
     func: cmd_putroc,
     shelp:"aname,val : direct put() to board control space !! EXPERT ONLY !!",
     lhelp:"  aname   symbolic name of the board control space resource\n"
           "  val     value to be written"
   },
   { name:    "ident|id",
     func: cmd_ident,
     shelp:" : print connection data and current time",
     lhelp:""
   },
   { name:    "printrocmap|printmap",
     func: cmd_printrocmap,
     shelp:"[-n] : print board control space address map !! FOR EXPERTS !!",
     lhelp:"  -n      sort by name (default is sort by address)"
   },
   { name:    "restartbrd",
     func: cmd_restartbrd,
     shelp:"restart board  !! THINK BEFORE !!",
     lhelp:"  Note: this command will disconnect the board/feb !!!\n"
           "        restart rocutil and used 'setbrddef' to initialize board"
   },
   { name:    "setbrddef",
     func: cmd_setbrddef,
     shelp:" : set board registers to default values",
     lhelp:""
   },
   { name:    "geti2c",
     func: cmd_geti2c,
     shelp:"[-l -w] addr,reg : read from I2C selected device",
     lhelp:"  -l      scope loop (repeat until ^C)\n"
           "  -w      16 bit access (default is 8 bit)\n"
           "  addr    I2C slave address (0:127)\n"
           "  reg     device register number (0:255)"
   },
   { name:    "puti2c",
     func: cmd_puti2c,
     shelp:"addr,reg,value : write I2C register",
     lhelp:"  addr    I2C slave address (0:127)\n"
           "  reg     device register number (0:255)"
           "  value   register value (0:255)"
   },
   { name:    "printdata|pd",
     func: cmd_printdata,
     shelp:"[-m -r -h -t -s -d -n -ia][nmsg,time,npuls,pper,pdly] : print data",
     lhelp:"  -m      print messages (default if no -s -d given)\n"
           "  -r      print messages in raw format (def is human readable)\n"
           "  -h      print hex dump of message\n"
           "  -t      print wall clock timestamp in front of message\n"
           "  -s      print statistics\n"
           "  -d      print nx distribution parameters\n"
           "  -n      no ROC initialization, use ROC config as is\n"
           " -ia      init nx/roc timestamp system after DAQ start\n"
           "  nmsg    number of messages to print (def=100, see Note below)\n"
           "  time    maximal time to look for data (def=10., see Note below)\n"
           "  npuls   if >0 fire pulser, send np pulses (0:32767, def=0)\n"
           "  pper    pulser period in units of 4ns (2:2^24, def=100000)\n"
           "  pwth    pulser period in units of 4ns (-2^24:2^24, def=32)\n"
           "  pdly    pulser delay in units of 4ns (1:65535, def=1000)\n"
           "    Note: if neither nmsg nor time is specified, the defaults of\n"
           "          nmsg=100 and time=10. are used. If only one of the two\n"
           "          is specified, the other is unlimited\n"
           "  Note 2: One could use pd for printout of messages from lmd file.\n"
           "          One can do \"rocutil b=file.lmd pd\". In this case all \n"
           "          messages will be printout if other not specified."
   },
   { name: 0,
     func: 0,
     shelp:0,
     lhelp:0
   }
};


cmditem_t cmdlist_sp605[] = {
   { name:    "set605def",
     func: cmd_setrocdef,
     shelp:" : set SP605 registers to default values",
     lhelp:"    Note: use after board boot"
   },
   { name: 0,
     func: 0,
     shelp:0,
     lhelp:0
   }
};

cmditem_t cmdlist_nxyter[] = {
   { name:    "feb|f",
     func: cmd_feb,
     shelp:"[port,type] : configure feb",
     lhelp:"  port    port number, default is first available\n"
           "  type    feb type either Feb1nxGen[BCD], Feb2nxGas,\n"
           "          Feb4nxBT, if omitted the discoverFebs() autodetect\n"
           "          heuristics is used\n"
           "    Note: Feb1nxGenB MUST be configured manually, the autodetect\n"
           "          will recognize them as errorously as Feb1nxGenC !!"
   },
   { name:    "getnx|gx",
     func: cmd_getnx,
     shelp:"nx,reg : read nXYTER register reg",
     lhelp:"  nx      nXYTER index ('*' for all or specific index)\n"
           "  reg     nXYTER register number"
   },
   { name:    "initfeb|if",
     func: cmd_initfeb,
     shelp:" : set nx on/off flags to ROC",
     lhelp:""
   },
   { name:    "printadc|pa",
     func: cmd_printadc,
     shelp:"prints device registers the MainAdc of a FEB",
     lhelp:""
   },
   { name:    "printfeb|pf",
     func: cmd_printfeb,
     shelp:"[-m -c -t -a] : prints all device registers of a FEB",
     lhelp:"  -m      print only nXYTER mask part\n"
           "  -c      print only nXYTER core part (default unless -m -c -t -a)\n"
           "  -t      print only nXYTER trim part\n"
           "  -a      print all parts\n"
   },
   { name:    "printnx|px",
     func: cmd_printnx,
     shelp:"[-m -c -t -a][nx] : print device registers one nXYTER of a FEB",
     lhelp:"  -m      print only mask part\n"
           "  -c      print only core part (default unless -m -c -t -a given)\n"
           "  -t      print only trim part\n"
           "  -a      print all parts\n"
           "  nx      nXYTER index ('*' for all or specific index)"
   },
   { name:    "resetnxi2cbus",
     func: cmd_resetnxi2cbus,
     shelp:"reset I2C bus state machine in all nXYTER",
     lhelp:""
   },
   { name:    "resetnxi2creg",
     func: cmd_resetnxi2creg,
     shelp:"reset all I2C registers to power-up defauls in all nXYTER",
     lhelp:""
   },
   { name:    "setadc",
     func: cmd_setadc,
     shelp:"reg,val : set ADC register reg to val",
     lhelp:"  reg     ADC register number\n"
           "  val     new value\n"
   },
   { name:    "setnx|sx",
     func: cmd_setnx,
     shelp:"nx,reg,val : set for nXYTER nx the register reg to val",
     lhelp:"  nx      nXYTER index ('*' for all or specific index)\n"
           "  reg     nXYTER register number\n"
           "  val     new value\n"
   },
   { name:    "setnxaddr",
     func: cmd_setnxaddr,
     shelp:"nx,addr : set I2C slave address for nXYTER",
     lhelp:"  nx      nXYTER index\n"
           "  addr    nXYTER I2C slave address"
   },
   { name:    "setnxdef|sxd",
     func: cmd_setnxdef,
     shelp:"[nx,pos] : set nXYTER registers to default values",
     lhelp:"  nx      nXYTER index ('*' for all or specific index, def=*)\n"
           "  pos     if 1 than nXYTER is setup for positive signals\n"
   },
   { name:    "setnxmask|sxm",
     func: cmd_setnxmask,
     shelp:"nx,[val,ibeg,iend,istep] : set channel-off mask to val in range",
     lhelp:"  nx      nXYTER index ('*' for all or specific index)\n"
           "  val     channel-off bit, 1 means off (0:1, def=0)\n"
           "  ibeg    first channel number (0:127, def=0)\n"
           "  iend    last channel number (0:127, def=127)\n"
           "  istep   cha. num. increment, touch ibeg+n*istep (1:64, def=1)"
   },
   { name:    "setnxmode|sxmo",
     func: cmd_setnxmode,
     shelp:"nx,[tpul,ttri,csel] : set test pulser and test trigger modes",
     lhelp:"  nx      nXYTER index ('*' for all or specific index)\n"
           "  tpul    test pulser mode flag (0:1, def=0)\n"
           "  ttri    test trigger mode flag (0:1, def=0)\n"
           "  csel    calibration group select (0:3, def=3)\n"
           "    Note: the csel default is 3 to have test channel 128 active"
   },
   { name:    "setfebdef|sfd",
     func: cmd_setfebdef,
     shelp:"[pos0,pos1] : set ADC and nXYTER registers to default values",
     lhelp:"  pos0    if 1 setup 1st half of nXYTER for positive signals\n"
           "  pos1    if 1 setup 2nd half of nXYTER for positive signals"
   },
   { name:    "firepulser|fp",
     func: cmd_firepulser,
     shelp:"[-a -s][per,wth,num,dly] : fire test pulse train",
     lhelp:"  -a      setup AUX2, enable ext&alt, or if -s disable ext\n"
           "  -s      stop pulse train\n"
           "  per     period in units of 4ns (2:2^24, def=100000)\n"
           "  wth     width in units of 4ns (-2^24:+2^24, def=350)\n"
           "  num     number of pulses (0:32768, def=0)\n"
           "  dly     delay after reset in units of 4ns (0:65535, def=0)\n"
           "    Note: number=0 causes permanent pulse activity\n"
           "          to terminate this do 'firepulser -s'\n"
           "    Note: 'firepulser' will cause continuous 2.5 kHz pulsing"
   },
   { name: 0,
     func: 0,
     shelp:0,
     lhelp:0
   }
};

cmditem_t cmdlist_gpio[] = {
   { name:    "setaux|sa",
     func: cmd_setaux,
     shelp:"ch,[re,fe,thr,ext,alt] : setup aux channel",
     lhelp:"  ch      channel number (0:3)\n"
           "  re      rising edge enable flag (0:1, def=0)\n"
           "  fe      falling edge enable flag (0:1, def=0)\n"
           "  thr     throttled option (0:1, def=1)\n"
           "  ext     enable TP_in(2) Thr_In(3) (0:1, def=0)\n"
           "  alt     use alt. input TP_busy(1),TP_gen(2),Thr_out(3) (0:1,def=0)"
   },
   { name:    "setsyncm|ssm",
     func: cmd_setsyncm,
     shelp:"scale[,baud]: set sync message sender",
     lhelp:"  scale   rate scale-down (0:21)\n"
           "  baud    baud rate in MHz (def=62.5)"
   },
   { name:    "setsyncs|sss",
     func: cmd_setsyncs,
     shelp:"ch,en[,thr,baud,loop] : setup sync message receiver channel",
     lhelp:"  ch      channel number (0:1)\n"
           "  en      enable flag (0:1)\n"
           "  thr     throttled option (0:1, def=0)\n"
           "  baud    baud rate in MHz (def=62.5)\n"
           "  loop    enable syncm->syncs internal loop back (0:1, def=0)"
   },
   { name:    "printgpio|pg",
     func: cmd_printgpio,
     shelp:"lists gpio options",
     lhelp:""
   },
   { name: 0,
     func: 0,
     shelp:0,
     lhelp:0
   }
};



cmditem_t cmdlist_roc[] = {
  { name:    "autoped",
    func: cmd_autoped,
    shelp:"[tmeas,tped] : auto-pedestal sequencer [EXPERIMENTAL!!]",
    lhelp:"  tmeas   length of measurement time interval (def=30.)\n"
          "  tped    length of pedestal time intervalta (def=0.1)\n"
  },
  { name:    "autosettrh|ath", 
    func: cmd_autosettrh,
    shelp:"time, min, nch, nnx",
    lhelp:"  time    sets the time of DAq for setup (real time is 8x higher)\n"
          "  min     crutial minimal value of working channels\n"
          "  nch     maximum rate of noise per channel\n"
          "  nnx     maximum rate of per chip\n"
  },
  { name:    "autotrim|att",
    func: cmd_autotrim,
    shelp:"[-k -t -q] nx,rate[,time,vth_min,vth_max,target] : trim n-XYTER thresholds",
    lhelp:"  -k      keep vth at target efficiency after execution\n"
          "  -m      only measure the signal rate, without changing vth or trim register\n"
          "  -t      use actual vth, do not adjust it. Only adjust trim\n"
          "  -q      quiet mode\n"
          "  rate    expected pulse rate {Hz}\n"
          "  time    duration of one measurement {s} (def=4.)\n"
          "  target  detection efficiency to adjust the thresholds to (def=0.5)\n"
          "  vth_min low limit of n-XYTER threshold (def=20)\n"
          "  vth_max high limit of n-XYTER threshold (def=255)\n"
          "    Hint: One can test autotrim with n-XYTER internal pulser:\n"
          "             rocutil> sxmo * tpul=1\n"
          "             rocutil> fp -a\n"
          "             rocutil> setnxmask=0,val=1\n"
          "             rocutil> setnxmask=0,val=0,ibeg=3,istep=4\n"
          "             rocutil> autotrim * rate=2500\n"
  },
  { name:    "autovbiass",
    func: cmd_autovbiass,
    shelp:"[-v] nx,[base,npuls] : VBiasS autotrim",
    lhelp:"  -v      show data for each channel\n"
          "  nx      nXYTER index ('*' for all or specific index)\n"
          "  base    target value for median baseline(0:4095, def=2000)\n"
          "  npuls   number of pulses to accumulate (1:10000, def=200)"
  },
  { name:    "discover",
    func: cmd_discover, 
    shelp:"[-v] : discover (probe for) nXYTER and FEBs", 
    lhelp:"  -v      gives a verbose listing of all return codes\n"
          "    Note: probes all even I2C addresses on both ports for nXYTER\n"
          "          and uses discoverFebs() heuristics to identify FEBs"
  },
  { name:    "dlm",
    func: cmd_dlm,
    shelp:"[num] : issue DLM message, default 1",
    lhelp:"  num     number of DLM message\n"
          "          num=1 used for time synchronisation\n"
  },
  { name:    "getadcdirect",
    func: cmd_getadcdirect,
    shelp:"[-d] : peak at adc data directly",
    lhelp:"  -d      use decimal output, default is hex"
  },
  { name:    "idsigch|isc",
    func: cmd_idsigch,
    shelp:" [-m -q] nx [amp, vth, rate, time] : identify channels with signal !! UNDER DEVELOPMENT !!",
    lhelp:"  -m      mask channels with no signal\n"
          "  -q      quite mode, print only error messages\n"
          // "  -v      allow \n"
          "  -t      do not reqire any separation between signal and noise,\n"
          "          simply apply the threshold, suppresses -v\n"
          "  amp     minimal amplitude (def=50)\n"
          "  vth     work with the specified vth, set to initial value\n"
          "          when finish. 0 -- don't change vth. (def=0)\n"
          "  rate    require a minimal signal rate. (def=1./time)\n"
          "  time    measurement time in seconds (def=4.)"
  },
  { name:    "printdatadbg|pdd",
    func: cmd_printdatadbg,
    shelp:"[-c -ib -ia][nmsg,time] : print data from debug port !! EXPERT !!",
    lhelp:"  -c      clear FIFO's before accessing data\n"
          "  -ib     init nx/roc timestamp system before FIFO clear\n"
          "  -ia     init nx/roc timestamp system after FIFO clear\n"
          "  nmsg    number of messages to print (def=100)\n"
          "  time    maximal time to look for data (def=1.)"
  },
  { name:    "printid|pi",
    func: cmd_printid,
    shelp:"Prints all system id's and versions specifications",
    lhelp:""
  },
  { name:    "printmon|pm",
    func: cmd_printmon,
    shelp:"print monitoring ADC readings",
    lhelp:""
  },
  { name:    "printroc|pr",
    func: cmd_printroc,
    shelp:"lists ROC register settings",
    lhelp:""
  },
  { name:    "printstatus|ps",
    func: cmd_printstatus,
    shelp:"brief status summary of ROC and FEBs",
    lhelp:""
  },
  { name:    "restartroc",
    func: cmd_restartbrd,
    shelp:"restart ROC (FPGA reconfigure and PPC reboot) !! THINK BEFORE !!",
    lhelp:"  Note: this command will disconnect the board/feb !!!\n"
          "        restart rocutil and used 'setrocdef' to initialize ROC"
  },
  { name:    "saverocconf",
    func: cmd_saverocconf,
    shelp:"will write the current ROC setting to the SDcard",
    lhelp:"    Note: This will change the startup default of the ROC"
  },
  { name:    "scanadclat",
    func: cmd_scanadclat,
    shelp:"[-v -d] nx[,ch,lbeg,lend,dbeg,dend,npuls,ch2] : ADC latency scan",
    lhelp:"  -v      show data for each scan point\n"
          "  -d      full delay scan, default is full latency scan\n"
          "  nx      nXYTER index\n"
          "  ch      channel to be used (0:127, def=0)\n"
          "  lbeg    start value for ADC latency (0:127, def=61)\n"
          "  lend    end value for ADC latency (0:127, def=68)\n"
          "  dbeg    start value for ADC clock delay (0:31, def=0)\n"
          "  dend    end value for ADC clock delay (0:31, def=31)\n"
          "  npuls   number of pulses to accumulate (1:10000, def=100)\n"
          "  ch2     second channel to be activated (0:127, def=<none>)\n"
          "    Note: For a latency scan (no -d) 8 delay settings are\n"
          "          inspected in the range dbeg:dend, step size is adjusted.\n"
          "          For a delay scan (-d) 8 latency settings are inspected\n"
          "          in the range lbeg:lend, step size is adjusted to 1,2,4\n"
          "          or lend is reduced\n"
  },
  { name:    "scanmonadc",
    func: cmd_scanmonadc,
    shelp:"nx,reg[,vbeg,vend,vstep] : parameter scan for monitor ADCs",
    lhelp:"  nx      nXYTER index ('*' for all or specific index)\n"
          "  reg     nXYTER register number to be varied\n"
          "  vbeg    start value for scan (0:255, def=0)\n"
          "  vend    end value for scan (0:255, def=255)\n"
          "  vstep   step size of scan (1:255, def=1)\n"
  },
  { name:    "scanvbiasf",
    func: cmd_scanvbiasf,
    shelp:"[-v] nx[,vbeg,vend,vstep,npuls] : VBiasF scan",
    lhelp:"  -v      show data for each channel\n"
          "  nx      nXYTER index ('*' for all or specific index)\n"
          "  vbeg    start value for VBiasF scan (0:255, def=0)\n"
          "  vend    end value for VBiasF scan (0:255, def=255)\n"
          "  vstep   step size of scan (1:255, def=1)\n"
          "  npuls   number of pulses to accumulate (1:10000, def=100)"
  },
  { name:    "scanvbiass",
    func: cmd_scanvbiass,
    shelp:"[-v] nx[,vbeg,vend,vstep,npuls] : VBiasS scan",
    lhelp:"  -v      show data for each channel\n"
          "  nx      nXYTER index ('*' for all or specific index)\n"
          "  vbeg    start value for VBiasS scan (0:255, def=0)\n"
          "  vend    end value for VBiasS scan (0:255, def=255)\n"
          "  vstep   step size of scan (1:255, def=1)\n"
          "  npuls   number of pulses to accumulate (1:10000, def=100)"
  },
  { name:    "setadcclock",
    func: cmd_setadcclock,
    shelp:"dly : set main clock delay",
    lhelp:"  dly     delay in 2ns units (0:31)"
  },
  { name:    "setadcdef|sad",
    func: cmd_setadcdef,
    shelp:"set ADC registers to default values",
    lhelp:""
  },
  { name:    "setadcpatt",
    func: cmd_setadcpatt,
    shelp:"[tm0,tm1,tm2,tm3,upatt] : set main adc test pattern mode",
    lhelp:"  tm*     adc channel i (0,1,2,3) test pattern mode\n"
          "  upatt   user data pattern (12 bit used, default='keep old')\n"
          "    Note: modes are: 0=none(ADC data); 1=0x800; 2=0xfff;\n"
          "          3=0x000; 4=0xaaa,0x555; 5=PNlong; 6=PNshort;\n"
          "          7=0xfff,0x000; 8=upatt; 9=0xaaa; 10=0x03f;\n"
          "          11=0x800; 12=0xa33;"
  },
  { name:    "setdebug",
    func: cmd_setdebug, 
    shelp:"lvl : set debug level",
    lhelp:"  lvl     0 only errors, >0 also debug infos"
  },
  { name:    "seti2c",
    func: cmd_seti2c,
    shelp:"[-l -v] addr,reg,val : write into I2C selected device",
    lhelp:"  -l      scope loop (repeat until ^C)\n"
          "  -v      do readback verification\n"
          "  addr    I2C slave address (0:127)\n"
          "  reg     device register number (0:255)\n"
          "  val     value to be written (0:255)"
  },
  { name:    "setlhwater|lhw",
    func: cmd_setlhwater,
    shelp:"low,high : low/high water",
    lhelp:"  low     low limit of PowerPC buffer in KB, min 8K\n"
          "  high    high limit of PowerPC buffer in KB, max 128M\n"
  },
  { name:    "setnxoff", 
    func: cmd_setnxoff, 
    shelp:"nx,val : set 'offline' flag for nXYTER",
    lhelp:"  nx      nXYTER index\n"
          "  val     nXYTER offline flag, 1 means off (0:1)"
  },
  { name:    "setnxpower|sxp",
    func: cmd_setnxpower,
    shelp:"nx,[val,ibeg,iend,istep] : set the power-down bit to val in range",
    lhelp:"  nx      nXYTER index ('*' for all or specific index)\n"
          "  val     power down bit, 1 means off (0:1, def=0)\n"
          "  ibeg    first channel number (0:128, def=0)\n"
          "  iend    last channel number (0:128, def=127)\n"
          "  istep   cha. num. increment, touch ibeg+n*istep (1:64, def=1)\n"
          "    Note: channel range is 0:128, channel 128 is the test channel\n"
          "    Note: the default for iend is 127, sparing the test channel" 
  },
  { name:    "setnxtrim|sxt",
    func: cmd_setnxtrim,
    shelp:"nx,[val,ibeg,iend,istep] : set the trim to val in range",
    lhelp:"  nx      nXYTER index ('*' for all or specific index)\n"
          "  val     trim value (0:31, def=16)\n"
          "  ibeg    first channel number (0:128, def=0)\n"
          "  iend    last channel number (0:128, def=127)\n"
          "  istep   cha. num. increment, touch ibeg+n*istep (1:64, def=1)\n"
          "    Note: channel range is 0:128, channel 128 is the test channel\n"
          "    Note: the default for iend is 127, sparing the test channel" 
  },
  { name:    "setrocdef|srd",
    func: cmd_setrocdef,
    shelp:" : set ROC registers to default values",
    lhelp:"    Note: use after ROC boot, replaces old SDcard config file"
  },
  { name:    "settrace|st",
    func: cmd_settrace,
    shelp:"[lvl] : set get/put/opergen trace level",
    lhelp:"  lvl     0 none; 1 only comm err; 2 only err; 3 all (def=1)"
  },
  { name:    "testadccntl",
    func: cmd_testadccntl,
    shelp:"[time] : test ADC control interface (SPI) for some time",
    lhelp:"  time    length of test in sec (def=10.)"
  },
  { name:    "testadcdata",
    func: cmd_testadcdata,
    shelp:"[time] : test ADC data interface for some time",
    lhelp:"  time    length of test in sec (def=10.)"
  },
  { name:    "testfebcntl",
    func: cmd_testfebcntl,
    shelp:"[time] : test ADC(not yet!) and all nXYTER control interfaces",
    lhelp:"  time    length of test in sec (def=10.)\n"
                  "    Note: does a random pattern test on many regsisters of all\n"
                  "          nXYTERs of the FEB and some ADC registers. See also\n"
                  "          'testnxcntl' and 'testadccntl'"
  },
  { name:    "testnxcntl",
    func: cmd_testnxcntl,
    shelp:"nx[,time] : test nXYTER control interface (I2C) for some time",
    lhelp:"  nx      nXYTER index ('*' for all or specific index)\n"
          "  time    length of test in sec (def=10.)\n"
          "    Note: calls the NxI2c::probe() method continuously.\n"
          "          To check all nXYTERs of a FEB together use 'testfebcntl'\n"
          "          To check a I2C address use 'seti2c -l' or 'geti2c -l'"
  },
  { name:    "testnxdata",
    func: cmd_testnxdata,
    shelp:"[-p -r -s][time] : test whether FEB responds to test triggers",
    lhelp:"  -p      print messages\n"
          "  -r      use raw format (default is human readable)\n"
          "  -s      print statistics\n"
          "  time    length of test in sec (def=10.)\n"
          "    Note: will put FEB into default settings !!!"
  },
  { name:    "testnxregs",
    func: cmd_testnxregs,
    shelp:"nx : test nXYTER registers",
    lhelp:"  nx      nXYTER index ('*' for all or specific index)\n"
          "    Note: Writes and read-checks patterns in all registers"
  },
  { name:    "testrocaux",
    func: cmd_testrocaux,
    shelp:"[-v -n] [ch,scale,time] : test ROC aux for some time",
    lhelp:"  -v      verbose, show first aux's, trends, stats\n"
          "  -n      no ROC initialization, use ROC config as is\n"
          "  ch      aux channel (0:3, def=2)\n"
          "  scale   aux scale (0:11, def=0)\n"
          "  time    length of test in sec (def=10.)\n"
          "    Note: expects to receive periodic aux pulses from SysGlue\n"
          "          with given frequency scale"
  },
  { name:    "testrocsync",
    func: cmd_testrocsync,
    shelp:"[-v -n] [ch,scale,time] : test ROC sync for some time",
    lhelp:"  -v      verbose, show first sync's, trends, stats\n"
          "  -n      no ROC initialization, use ROC config as is\n"
          "  ch      sync channel (0:1, def=0)\n"
          "  scale   sync scale down (0:21, def=5)\n"
          "  time    length of test in sec (def=10.)\n"
          "    Note: expects to receive periodic sync markers with the given\n"
          "          scale down, either via loop-back or external"
  }, 
  { name:    "resetrocnxts",
    func: cmd_resetrocnxts,
    shelp:"resetrocnxts : reset timing of nx time stamp",
    lhelp:"  Note: should probably not used for optic"
  }, // terminator must be at end !
  { name: 0, 
    func: 0, 
    shelp:0, 
    lhelp:0
  }
};

void add_cmdlist(cmditem_t* lst)
{
   for (cmditem_t* item = lst; item->name; item++)
      cmdlist.push_back(item);
}


void reset_cmdlist()
{
   cmdlist.clear();

   add_cmdlist(cmdlist_base);
}

//----------------------------------------------------------------------------
//++ some helper functions needed throughout the program +++++++++++++++++++++

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

int check_feb(bool needfeb=true)
{
  if (needfeb && gFeb==0) {
    std::cerr << "rocutil-E: command requires connected FEB, use 'feb'" << std::endl;
    return 1;
  }
  return 0;
}

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

int check_daq(bool needdaq)
{
   if (needdaq && (gQdaq==0)) {
      std::cerr << "rocutil-E: command requires active DAQ, use 'board=addr?DAQ'"<< std::endl;
      return 1;
   }
   return 0;
}

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

int args_check(int needs) 
{
   if (argspos.size() || argsopt.size()) {
      std::cerr << "rocutil-E: leftover arguments '";
      int cnt=0;
      for (int i=0; i<argspos.size(); i++) {
         if (cnt != 0) std::cerr << ",";
         std::cerr << argspos[i];
         cnt++;
      }
      for (int i=0; i<argsopt.size(); i++) {
         if (cnt != 0) std::cerr << ",";
         std::cerr << argsopt[i];
         cnt++;
      }
      std::cerr << "'" << std::endl;
      return 1;
   }

   if (needs & kNeedFeb) needs |= kNeedBoard; // needFeb implies needBoard
   if (needs & kNeedDaq) needs |= kNeedBoard; // needDaq implies needBoard

   if (((needs & kNeedBoard) != 0) && (gBaseBoard==0)) {
      std::cerr << "rocutil-E: command requires connected board, use 'board'" << std::endl;
      return 1;
   }

   if (((needs & kNeedRocBoard)!=0) && (gRocBoard==0)) {
      std::cerr << "rocutil-E: command requires connected ROC, use 'board'" << std::endl;
      return 1;
   }

   if (check_feb((needs & kNeedFeb)!=0)) return 1;
   if (check_daq((needs & kNeedDaq)!=0)) return 1;

   return 0;
}

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

void trim_whitespace(std::string& str) 
{
  // trim leading white space
  size_t pos_nwhitebeg = str.find_first_not_of(" \t");
  str.erase(0, pos_nwhitebeg);

  // trim trailing white space
  size_t pos_nwhiteend = str.find_last_not_of(" \t");
  str.erase(pos_nwhiteend+1);
}

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

bool cmd_full_short(const char* cmd, std::string& cmdfull, std::string& cmdshort)
{
  bool hasshort = false;
  cmdfull = cmd;
  cmdshort.erase();
  size_t pos_delcmd = cmdfull.find("|");
  if (pos_delcmd != std::string::npos) {
    cmdshort = cmdfull;
    cmdfull.erase(pos_delcmd);
    cmdshort.erase(0, pos_delcmd+1);
    hasshort = true;
  }
  return hasshort;
}

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

std::string get_timestamp(const char* fields="dtm") 
{
  char buf[100];
  std::string str;
  struct timeval tv;
  struct tm tm_now;
  gettimeofday(&tv, 0);
  localtime_r(&tv.tv_sec, &tm_now);

  if (strchr(fields, 'd')) {
    strftime(buf, sizeof(buf), "%F", &tm_now);
    str += buf;
  }
  if (strchr(fields, 't')) {
    if (strchr(fields, 'd')) str += " ";
    strftime(buf, sizeof(buf), "%T", &tm_now);
    str += buf;
  }
  if (strchr(fields, 'm')) {
    snprintf(buf, sizeof(buf), ".%03d", int(tv.tv_usec/1000));
    str += buf;
  }
  return str;
}

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

int print_opererr(const char* text, int rc)
{
  static boost::format fmt(": rc = %|4|,%|2| -> ");
  if (rc) {
    std::cout << "rocutil-E: " << text << " : " 
         << base::Board::operErrToString(rc) << std::endl;
  }
  return rc;
}

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

void print_loop_stats(const char* text, int ecnt)
{
  std::cout << "rocutil-I: " << text << " ";
  std::cout << ( (ecnt)?"FAILED":"PASSED" );
  std::cout << " after " << std::dec << gUtil->getLoopCount()
       << " test loops";
  double dtime = gUtil->now() - gUtil->getStartLoopTime();
  if (dtime > 0) {
    static boost::format fmt(" in %4.2f sec");
    std::cout << fmt % dtime;
  }
  if (ecnt) std::cout << " with " << ecnt << " errors";
  std::cout << std::endl;
}

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

void print_daq_stats(const char* text, uint64_t cnt, int ecnt)
{
  std::cout << "rocutil-I: " << text << " ";
  std::cout << ( (ecnt)?"FAILED":"PASSED" );
  std::cout << " after " << std::dec << cnt
       << " messages";
  double dtime = gQdaq->getStopTime() - gQdaq->getStartTime();
  if (dtime > 0) {
    static boost::format fmt(" in %4.2f sec");
    std::cout << fmt % dtime;
  }
  if (ecnt) std::cout << " with " << ecnt << " errors";
  std::cout << std::endl;
}

//----------------------------------------------------------------------------
//++ helper functions for command argument handling ++++++++++++++++++++++++++

int get_arg(std::string& arg, const char* aname, bool& defaulting)
{
  defaulting = false;
  if (argspos.size()) {                     // use positionals if available
    arg = argspos.front();
    argspos.erase(argspos.begin());
    return 0;

  } else if (aname && aname[0]) {           // optional arg "name=" given
    for (int i=0; i<argsopt.size(); i++) {
      size_t pos = argsopt[i].find(aname);
      if (pos == 0) {                       // if match
        arg = argsopt[i];                   // take it
        arg.erase(0, strlen(aname));        // drop "name=" prefix
        argsopt.erase(argsopt.begin()+i);   // and delete from argsopt list
        return 0;
      }
    }
    defaulting = true;
    return 0;                               // ok defaulting for optional arg
  }
  std::cerr << "rocutil-E: Argument missing" << std::endl;
  return 1;
}

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


int get_arg(std::string& arg, const char* aname=0)
{
  bool defaulting;
  return get_arg(arg, aname, defaulting);
}

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

int get_arg(int32_t& arg, const char* aname=0, 
            int32_t min=(1<<31), int32_t max=~(1<<31))
{
  std::string str;
  bool defaulting;
  if (get_arg(str, aname, defaulting)) return 1;
  if (defaulting) return 0;
  trim_whitespace(str);

  if (str.size()!=0) {                      // if non-empty argument
    const char* cstr = str.c_str();
    char* eptr;
    int base=0;
    
    if (cstr[0]=='b' || cstr[0]=='B') {
      cstr += 1;
      base  = 2;
    }
    
    errno = 0;
    int res = strtol(cstr, &eptr, base);
    if (errno || (eptr && eptr[0]!=0)) {
      std::cerr << "rocutil-E: conversion error in '" << str << "'" << std::endl;
      return 1;
    } else {
      arg = res;
    }

  } else {                                  // for empty arg assume 0
    arg = 0;
  }

  if (arg < min || arg > max) {
    std::cerr << "rocutil-E: value " << arg << " is out of range " 
         << min << ",...," << max << std::endl;
    return 1;
  }

  return 0;
}

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

int get_arg(double& arg, const char* aname=0)
{
  std::string str;
  bool defaulting;
  if (get_arg(str, aname, defaulting)) return 1;
  if (defaulting) return 0;
  trim_whitespace(str);

  if (str.size()!=0) {                      // if non-empty argument
    const char* cstr = str.c_str();
    char* eptr;
    
    errno = 0;
    double res = strtod(cstr, &eptr);
    if (errno || (eptr && eptr[0]!=0)) {
      std::cerr << "rocutil-E: conversion error in '" << str << "'" << std::endl;
      return 1;
    } else {
      arg = res;
    }

  } else {                                  // for empty arg assume 0
    arg = 0.;
  }

  return 0;
}

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

int get_arg(bool& arg, const char* aname=0)
{
  int32_t inp = -1;
  if (get_arg(inp, aname, 0, 1)) return 1;
  if (inp != -1) arg = (inp != 0);          // if not defaulting
  return 0;
}

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

int get_nxind(int32_t& nx, const char* aname=0)
{
  if (get_arg(nx, aname)) return 1;
  if (check_feb()) return 1;
  
  if (nx<0 || nx>=gFeb->numNx()) {
    std::cout << "nXYTER index '" << nx << "' out of range, use 0,..," 
         << gFeb->numNx()-1 << std::endl;
    return 1;
  }
  return 0;
}

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

int get_nxrange(int32_t& nxbeg, int32_t& nxend, const char* aname=0)
{
  std::string str;
  bool defaulting;

  if (check_feb()) return 1;
  if (get_arg(str, aname, defaulting)) return 1;
  if (defaulting || str == "*") {
    nxbeg = 0;
    nxend = gFeb->numNx()-1;
    return 0;
  }

  trim_whitespace(str);

  int32_t nx = 0;
  if (str.size()!=0) {                      // if non-empty argument
    const char* cstr = str.c_str();
    char* eptr;    
    errno = 0;
    nx = strtol(cstr, &eptr, 0);
    if (errno || (eptr && eptr[0]!=0)) {
      std::cerr << "rocutil-E: conversion error in '" << str << "'" << std::endl;
      return 1;
    } 
  }

  if (nx<0 || nx>=gFeb->numNx()) {
    std::cout << "nXYTER index '" << nx << "' out of range, use 0,..," 
         << gFeb->numNx()-1 << std::endl;
    return 1;
  }
  nxbeg = nx;
  nxend = nx;
  return 0;
}

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

bool get_opt(const std::string& opt)
{
   for (std::vector<std::string>::iterator it=argsopt.begin(); it!=argsopt.end(); it++) {
      if (*it == opt) {
         argsopt.erase(it);
         return true;
      }
   }
   return false;
}

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

bool check_nxoffline(int nxind, int nxbeg, int nxend)
{
  if (nxbeg == nxend) return false;         // force false for single access
  return gFeb->getNxOffline(nxind);         // use offline flag for range
}

//----------------------------------------------------------------------------
//++ command action routines +++++++++++++++++++++++++++++++++++++++++++++++++

int cmd_help()
{
  bool verbose = get_opt("-v");
  bool genhelp = get_opt("-g");
  bool listabr = get_opt("-a");
  std::string cmd;

  get_arg(cmd, "command=");
  
  if (cmd.size()) verbose = true;
  bool cmdok = false;
  
  if (genhelp) {
    std::cout 
      << "rocutil is a general purpose utility for all kinds of operations\n"
      << "on ROCs and FEBs. It can handle one ROC and one FEB at a time.\n"
      << "Commands can be specified on the shell command line or at a prompt.\n"
      << "\n"
      << "Command syntax is simple, a command name followed by a comma or\n"
      << "white space separated list of arguments.\n"
      << "The delimiter between command name and arguments can be '=' or\n"
      << "white space. The '=' is more convenient at the shell command line\n"
      << "white space after a command prompt.\n"
      << "A shell command line might look like\n"
      << "   rocutil board=cbmtest42 feb=0,Feb1nx setfebdef\n"
      << "\n"
      << "If no command is given on the command line or the last is '-'\n"
      << "rocutil will enter command prompt mode with a 'rocutil>' prompt.\n"
      << "The prompt mode supports command editing and history recall,\n"
      << "the command history is stored across program invocations in the\n"
      << "file ./.rocutil_history in the current working directory.\n"
      << "\n"
      << "Integer numerical arguments can be entered in four radix:\n"
      << "   decimal      like   123\n"
      << "   hexadecimal  like 0x123\n"
      << "   octal        like  0123    !Note: leading zero means octal!\n"
      << "   binary       like b1011    is 11 (dec) 0xB (hex) 013 (oct)\n"
      << "\n"
      << "Optional arguments can be given in the form 'name=value'. They are\n"
      << "put in [...] in the help text and always have a default value. The\n"
      << "two command lines:\n"
      << "   setnxmode 0 ttri=1 csel=2\n"
      << "   setnxmode 0,0,1,2\n"
      << "are equivalent. Command options have the UNIX style '-v' form and\n"
      << "can be placed anywhere in the argument list. The two commands\n"
      << "   seti2c=-l,-v,0,8,0xaa\n"
      << "   seti2c -l -v 0 8 b10101010\n"
      << "are again equivalent.\n"
      << "\n"
      << "It is convenient to leave setup configuration commands at the shell\n"
      << "command and do the rest at the prompt, like:\n"
      << "   rocutil board=cbmtest42 feb=0,Feb1nx -\n"
      << "   rocutil> setfebdef\n"
      << "   rocutil> setnxmask 0 1 4\n"
      << "   rocutil> setnxmode 0 tpul=1 csel=2\n"
      << "   rocutil> printfeb\n"
      << "\n"
      << "Command files can be executed with a command like\n"
      << "   @filename\n"
      << "\n"
      << "Command lines can have comments in two forms:\n"
      << "   1. everything after '//' is discarted\n"
      << "   2. a line starting with '/*' is copied to stdout\n"
      << "\n"
      << "Finally, some commands have abreviated names, see 'help -s' for a"
      << "list of abbreviations. The full help text 'help <cmd>' will also"
      << "indicate when an abbreviation is defined."
      << "\n"
      << std::flush;
    return 0;
  }

  if (listabr) {
    std::map<std::string, std::string> map_short2full;
    typedef std::map<std::string,std::string>::iterator map_iter_t;

    for (unsigned i=0; i<cmdlist.size(); i++) {
      std::string cmdfull;
      std::string cmdshort;
      cmd_full_short(cmdlist[i]->name, cmdfull, cmdshort);
      if (cmdshort.size()==0) continue;

      map_iter_t it = map_short2full.find(cmdshort);
      
      if (it != map_short2full.end()) {
        std::cout << "rocutil-E: duplicate command abbreviation: "
             << cmdshort << " -> '" << (*it).second
             << "' and '" << cmdfull << "'"
             << std::endl;
      } else {
        map_short2full[cmdshort] = cmdfull;
      }
    }
    
    for (map_iter_t it = map_short2full.begin(); 
         it != map_short2full.end(); it++) {
      static boost::format fmt("%|-4| -> %s");
      std::cout << fmt % (*it).first % (*it).second << std::endl;
    }

    return 0;
  }

  for (unsigned i=0; i<cmdlist.size(); i++) {
    std::string cmdfull;
    std::string cmdshort;
    cmd_full_short(cmdlist[i]->name, cmdfull, cmdshort);

    static boost::format fmt("%|-12| %s");
    if (cmd.size() == 0 || cmd == cmdfull || cmd == cmdshort) {
      cmdok = true;
      std::cout << fmt % cmdfull % cmdlist[i]->shelp << std::endl;
      if (verbose && cmdlist[i]->lhelp[0]) {
        size_t pos_cur = 0;
        while(pos_cur != std::string::npos) {
          std::string lhelp(cmdlist[i]->lhelp);
          std::cout << "             ";
          size_t pos_eol = lhelp.find("\n", pos_cur);
          if (pos_eol != std::string::npos) {
            std::cout << lhelp.substr(pos_cur, pos_eol-pos_cur);
            pos_cur = pos_eol+1;
            if (pos_cur >= lhelp.size()) pos_cur = std::string::npos;
          } else {
            std::cout << lhelp.substr(pos_cur);
            pos_cur = std::string::npos;
          }
          std::cout << std::endl;
        }
        if (cmdshort.size()) {
          std::cout << "            " 
               << cmdfull << " can be abreviated as " 
               << cmdshort << std::endl;
        }
      }
    }
  }

  if (cmd.size() == 0) {
    std::cout 
      << "\n"
      << "For command syntax and general help use 'help -g'\n"
      << "For detailed help on a command cmd use  'help cmd'\n"
      << "For a full long listing of all command  'help -v'\n"
      << "For list of command abbreviations see   'help -a'\n"
      << std::flush;
  }

  if (cmd.size() && (!cmdok)) {
    std::cout << "rocutil-E: Command '" << cmd << "' not found." << std::endl;
    std::cout << "rocutil-I: Use 'help', 'help -g', 'help -s' or 'help -v'." << std::endl;
  }

  return 0;
}

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

int cmd_quit()
{
  return -1;
}

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

int cmd_board()
{
  if (gBaseBoard) {
    std::cerr << "rocutil-E: Already connected to a board, command ignored" << std::endl;
    return 0;
  }

  std::string brdname;
  if (get_arg(brdname)) return 1;
  if (args_check(0)) return 1;

  gBaseBoard = base::Board::Connect(brdname.c_str(), base::roleDAQ);

  if (gBaseBoard==0) {
     std::cerr << "rocutil-E: Fail connect to the board " << brdname << std::endl;
     return 1;
  }

  gBoardName = brdname;

  reset_cmdlist();
  add_cmdlist(cmdlist_board);

  gRocBoard = dynamic_cast<roc::Board*> (gBaseBoard);
  gSP605Board = dynamic_cast<sp605::Board*>(gBaseBoard);

  if (gBaseBoard!=0) {
     gUtil = new nxyter::FebUtil(0);           // to have loops for roc-only tests
  }

  uint32_t fee_kind = gBaseBoard->getFrontendKind();

  bool isnxyter = (fee_kind == base::kind_nXYTER) || (fee_kind == base::kind_newNX);
  bool isfeet = (fee_kind == base::kind_FEET) || (fee_kind == base::kind_oldFEET);

  if (gBaseBoard->getRole() == base::roleDAQ) {
     gQdaq = new nxyter::QuickDaq(gBaseBoard);
  }

  if (isnxyter)
     add_cmdlist(cmdlist_nxyter);

  if (gRocBoard!=0) {
     // this is all about readout controller with nXYTER frontend

     add_cmdlist(cmdlist_gpio);
     add_cmdlist(cmdlist_roc);

     roc::I2cDevice::addAddrMap(gRocBoard);
     base::Gpio::addAddrMap(gRocBoard);
     gGpio = new base::Gpio(gRocBoard);

     if (isnxyter) {
        gRocNx = new nxyter::RocNx(gRocBoard);
        nxyter::RocNx::addAddrMap(gRocBoard, fee_kind);
        nxyter::MainAdc::addAddrMap(gRocBoard);
     }

     if (isfeet)
        feet::RocFeet::addAddrMap(gRocBoard, fee_kind);

     // now to a few sanity checks
     if (!gRocBoard->isFile()) {
        uint32_t hw_vers;
        uint32_t lts_delay(1);
        int rc;
        rc = gRocBoard->get(ROC_HWV, hw_vers);
        print_opererr("Board::get(HARDWARE_VERSION)", rc);

        if (fee_kind == base::kind_nXYTER) {
           rc = gRocBoard->get(ROC_NX_DELAY_LTS, lts_delay);
           print_opererr("Board::get(DELAY_LTS)", rc);
        }

        if (hw_vers < 0x01070213)
           std::cout << "rocutil-W: Detected outdated firmware version. This version of\n"
                     << "           rocutil expects HARDWARE_VERSION 01070213 or higher"  << std::endl;

        if (lts_delay == 0)
           std::cout << "rocutil-W: Detected uninitialized ROC registers. Use 'setrocdef'." << std::endl;
     }
  } else

  if (gSP605Board!=0) {
     add_cmdlist(cmdlist_gpio);
     add_cmdlist(cmdlist_sp605);

     roc::I2cDevice::addAddrMap(gBaseBoard);
     base::Gpio::addAddrMap(gBaseBoard);

     gGpio = new base::Gpio(gBaseBoard);

     if (isnxyter) {
        gRocNx = new nxyter::RocNx(gBaseBoard);
        nxyter::RocNx::addAddrMap(gBaseBoard, fee_kind);
        nxyter::MainAdc::addAddrMap(gBaseBoard);
     }
  }

  return 0;
}

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

int cmd_setdebug()
{
  int32_t lvl;
  if (get_arg(lvl)) return 1;
  if (args_check(kNeedRocBoard)) return 1;

  gRocBoard->setVerbosity(lvl);
  return 0;
}

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

int cmd_settrace()
{
  int32_t lvl=1;
  if (get_arg(lvl, "lvl=")) return 1;
  if (args_check(kNeedBoard)) return 1;

  gBaseBoard->setOperTrace(lvl);
  return 0;
}

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

int cmd_ident()
{
  if (gBaseBoard)
    std::cout << "--- Connected to " << gBoardName;
  else
    std::cout << "--- Not yet connected";

  std::cout << " at " << get_timestamp("dtm") << std::endl;
  return 0;
}

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

int cmd_initfeb()
{
   if (gFeb==0) {
      std::cout << " Feb not created" << std::endl;
   } else {
      gFeb->initRoc();
      std::cout << "set nxyter on/off flags to ROC" << std::endl;
   }

   return 0;
}


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

int cmd_discover()
{
  bool opt_verb = get_opt("-v");
  if (args_check(kNeedRocBoard)) return 1;
  nxyter::FebUtil::probe(gRocBoard, opt_verb);
  return 0;
}

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

int cmd_dlm()
{
   int num = 1;
   if (get_arg(num, "num=")) return 1;
   if (gRocBoard==0) return 1;

   gRocBoard->invokeDLM(num);

   std::cout << "Invoke DLM = " << num << std::endl;

   return 0;
}

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

int cmd_feb()
{
  int32_t port = -1;
  std::string type("auto");
  if (get_arg(port, "port=")) return 1;
  if (get_arg(type, "type=")) return 1;
  if (args_check(kNeedBoard)) return 1;

  delete gFeb;   gFeb  = 0;
  delete gQdaq;  gQdaq = 0;
  delete gUtil;  gUtil = 0;

  int ftyp=-1;

  if (type != "auto") {
    if      (type == "Feb1nxGenB") ftyp = nxyter::FebBase::kFeb1nxGenB;
    else if (type == "Feb1nxGenC") ftyp = nxyter::FebBase::kFeb1nxGenC;
    else if (type == "Feb1nxGenD") ftyp = nxyter::FebBase::kFeb1nxGenD;
    else if (type == "Feb2nxGas")  ftyp = nxyter::FebBase::kFeb2nxGas;
    else if (type == "Feb4nxBT")   ftyp = nxyter::FebBase::kFeb4nxBT;
    else {
      std::cout << "Unknown type, use Feb1nxGen[BCD], Feb2nxGas, Feb4nxBT" << std::endl;
      return 1;
    }    
  }

  if (port==-1 || type=="auto") {
    int ftyp0, ftyp1;
    nxyter::FebBase::discoverFebs(gRocBoard, ftyp0, ftyp1, true);
    if (port==-1) {
      if (ftyp0 != 0) {
        port = 0;
        ftyp = ftyp0;
      } else if (ftyp1 != 0) {
        port = 1;
        ftyp = ftyp1;
      } else {
        std::cout << "No FEB detected, use 'discover'" << std::endl;
        return 1;
      }
    }
    if (ftyp == -1) {
      ftyp = (port==0) ? ftyp0 : ftyp1;
      if (ftyp==0) {
        std::cout << "No FEB detected on port " << port << ", use 'discover'" << std::endl;
        return 1;
      }
    }
    std::cout << "rocutil-I: connect on port " << port
              << " " << nxyter::FebBase::typeToString(ftyp) << std::endl;
  }

  gFeb = nxyter::FebBase::newFeb(gBaseBoard, port, ftyp);

  if (!gFeb)
    std::cout << "Internal error, no FEB attached" << std::endl;
  
  if (gBaseBoard && (gBaseBoard->getRole() == base::roleDAQ))
     gQdaq = new nxyter::QuickDaq(gFeb);

  gUtil = new nxyter::FebUtil(gFeb, gQdaq);

  return 0;
}

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

int cmd_setnxaddr()
{
  int32_t nxind;
  int32_t addr;
  if (get_nxind(nxind)) return 1;
  if (get_arg(addr, 0, 0, 255)) return 1;
  if (args_check(kNeedFeb)) return 1;

  gFeb->nx(nxind).i2c().setSlaveAddr(uint8_t(addr));
  return 0;
}

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

int cmd_setnxoff()
{
  int32_t nxind;
  bool val;
  if (get_nxind(nxind)) return 1;
  if (get_arg(val)) return 1;
  if (args_check(kNeedFeb)) return 1;

  gFeb->setNxOffline(nxind, val);
  return 0;
}

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

int cmd_printroc()
{
  uint32_t alist[] = {ROC_TYPE,
                      ROC_HWV,
                      ROC_ROCID,
                      base::GPIO_CONFIG,
                      base::GPIO_SYNCM_SCALEDOWN,
                      base::GPIO_SYNCM_BAUD1,
                      base::GPIO_SYNCM_BAUD2,
                      base::GPIO_SYNCS0_BAUD1,
                      base::GPIO_SYNCS0_BAUD2,
                      ROC_NX_HWV,
                      ROC_NX_NXACTIVE,
                      ROC_NX_FEB4NX,
                      ROC_NX_PARITY_CHECK,
                      ROC_NX_ADC_PORT_SELECT1,
                      ROC_NX_ADC_PORT_SELECT2,
                      ROC_NX_ADC_PORT_SELECT3,
                      ROC_NX_ADC_PORT_SELECT4,
                      ROC_NX_SR_INIT,
                      ROC_NX_BUFG_SELECT,
                      ROC_NX_SR_INIT2,
                      ROC_NX_BUFG_SELECT2,
                      ROC_NX_ADC_LATENCY1,
                      ROC_NX_ADC_LATENCY2,
                      ROC_NX_ADC_LATENCY3,
                      ROC_NX_ADC_LATENCY4,
                      ROC_NX_DELAY_LTS,
                      ROC_NX_DELAY_NX0,
                      ROC_NX_DELAY_NX1,
                      ROC_NX_DELAY_NX2,
                      ROC_NX_DELAY_NX3,
                      ROC_NX_DEBUG_MODE,
                      ROC_ETH_HWV,
                      ROC_ETH_SWV,
                      ROC_ETH_IP_ADDRESS,
                      ROC_ETH_MAC_ADDRESS_UPPER,
                      ROC_ETH_MAC_ADDRESS_LOWER,
                      ROC_ETH_BUFFER_FLUSH_TIMER,
                      ROC_ETH_LOWWATER,
                      ROC_ETH_HIGHWATER,
                      ROC_ETH_NUMBUFALLOC,
                      ROC_ETH_LOST_ETHER_FRAMES,
                      ROC_ETH_TEMAC_REG0
  };

  if (args_check(kNeedRocBoard)) return 1;

  for (int i=0; i<sizeof(alist)/sizeof(alist[0]); i++) {

     // do not try to read Ethernet-specific registers in Optic case
     if ((alist[i]==ROC_ETH_SWV) &&
         (gRocBoard->getTransportKind() != roc::kind_UDP)) break;
         
     // do not try to read nXYTER-specific registers in FEET case
    if ((alist[i]==ROC_NX_HWV) &&
        (gRocBoard->getRocFrontendKind() != base::kind_nXYTER)) break;

    const char* sname = gRocBoard->findRegNameByAddress(alist[i]);

    if (sname==0) {
       std::cout << alist[i] << " not available on ROC" << std::endl;
       continue;
    }

    static boost::format fmt_pref("get(%-24s [0x%08x]) -> ");
    std::cout << fmt_pref % sname % alist[i];

    uint32_t value;
    int rc = gRocBoard->get(alist[i], value);
    if (rc==0) {
      static boost::format fmt_data("0x%08x %10d");
      std::cout << fmt_data % value % value << std::endl;
    } else {
      std::cout << base::Board::operErrToString(rc) << std::endl;
    }
  }
                      
  return 0;
}

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

int cmd_printid()
{  
  if (args_check(kNeedRocBoard)) return 1;                      

  int rc;
  uint32_t value;

  rc = gRocBoard->get(ROC_TYPE, value);
  if (rc==0) std::cout << "ROC type:             " 
                  << gRocBoard->versionToString(value) << std::endl;
  rc = gRocBoard->get(ROC_HWV, value);
  if (rc==0) std::cout << "ROC hardware version: " 
                  << gRocBoard->versionToString(value) << std::endl;
  if (gRocBoard->getTransportKind() == roc::kind_UDP) {
    rc = gRocBoard->get(ROC_ETH_HWV, value);
    if (rc==0) std::cout << "Eth hardware version: " 
                    << gRocBoard->versionToString(value) << std::endl;
    rc = gRocBoard->get(ROC_ETH_SWV, value);
    if (rc==0) std::cout << "Eth software version: " 
                    << gRocBoard->versionToString(value) << std::endl;
  }
  if (gRocBoard->getTransportKind() == roc::kind_ABB) {
    rc = gRocBoard->get(ROC_OPTICS_HWV, value);
    if (rc==0) std::cout << "Opt hardware version: " 
                    << gRocBoard->versionToString(value) << std::endl;
  }
  rc = gRocBoard->get(ROC_NX_HWV, value);
  if (rc==0) std::cout << "Nx  hardware version: " 
                  << gRocBoard->versionToString(value) << std::endl;

  return 0;
}

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

int cmd_printfeb()
{
  bool opt_m = get_opt("-m");
  bool opt_c = get_opt("-c");
  bool opt_t = get_opt("-t");
  bool opt_a = get_opt("-a");
  if (args_check(kNeedFeb)) return 1;

  if (!(opt_m | opt_c | opt_t | opt_a)) opt_c = true;
  int domask = 0;
  if (opt_m | opt_a) domask |= nxyter::kDoMask;
  if (opt_c | opt_a) domask |= nxyter::kDoCore;
  if (opt_t | opt_a) domask |= nxyter::kDoTrim;

  gFeb->printRegisters(std::cout, domask);
  return 0;
}

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

int cmd_printadc()
{
  if (args_check(kNeedFeb)) return 1;
  gFeb->adc().printRegisters(std::cout);
  return 0;
}

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

int cmd_printnx()
{
  bool opt_m = get_opt("-m");
  bool opt_c = get_opt("-c");
  bool opt_t = get_opt("-t");
  bool opt_a = get_opt("-a");
  int nxbeg=0;
  int nxend=0;
  if (get_nxrange(nxbeg, nxend, "nx=")) return 1;
  if (args_check(kNeedFeb)) return 1;

  if (!(opt_m | opt_c | opt_t | opt_a)) opt_c = true;
  int domask = 0;
  if (opt_m | opt_a) domask |= nxyter::kDoMask;
  if (opt_c | opt_a) domask |= nxyter::kDoCore;
  if (opt_t | opt_a) domask |= nxyter::kDoTrim;

  for (int i=nxbeg; i<=nxend; i++) {
    gFeb->printNxHeadLine(std::cout, i);    
    if (!gFeb->getNxOffline(i)) gFeb->nx(i).i2c().printRegisters(std::cout, domask);
  }
  return 0;
}

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

int cmd_printmon()
{
  if (args_check(kNeedFeb)) return 1;

  if (!gFeb->monAdcSupport()) {
    std::cout << "no monitoring ADC support for this FEB type" << std::endl;
    return 0;
  }

  uint16_t val[4];
    for (int ch=0; ch<4; ch++) {
    int rc = gFeb->getMonAdc(ch, val[ch]);
    print_opererr("FebBase::getMonAdc", rc);
  }

  for (int ch=0; ch<4; ch++) {
    static boost::format fmt("%|4|");
    std::cout << " " << fmt % uint32_t(val[ch]);
  }
  std::cout << std::endl;
  
  return 0;
}

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

int cmd_setbrddef()
{
  if (args_check(kNeedBoard)) return 1;

  int rc = gBaseBoard->setToDefault();
  print_opererr("Board::setToDefault", rc);

  return 0;
}

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

int cmd_setrocdef()
{
  if (args_check(kNeedBoard)) return 1;

  int rc = gBaseBoard->setToDefault();
  print_opererr("Board::setToDefault", rc);

  if (gRocNx) {
     rc = gRocNx->setToDefault();
     print_opererr("RocNx::setToDefault", rc);
  }

  return 0;
}

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

int cmd_setsyncm()
{
   int32_t scale;
   double baud = 62.5;
   if (get_arg(scale, 0, 0, 21)) return 1;
   if (get_arg(baud, "baud=")) return 1;
   if (args_check(kNeedBoard)) return 1;
   if (gGpio == 0) { std::cerr << "No Gpio instance" << std::endl; return 1; }

   int ratediv = int(std::floor((500./baud)+0.5));
   if (ratediv > 511 || std::abs(baud - 500./double(ratediv)) > 0.01) {
      std::cout << "rocutil-E: baud rate not supported" << std::endl;
      return 1;
   }

   int rc;
   rc = gGpio->setSyncScale(scale);
   print_opererr("Gpio::setSyncScale", rc);
   rc = gGpio->setSyncBaud(1, ratediv);
   print_opererr("Gpio::setSyncBaud", rc);

   return 0;
}

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

int cmd_setsyncs()
{
  int32_t ch;
  bool enable;
  bool throttled = false;
  double baud = 62.5;
  int32_t loop = 0;
  if (get_arg(ch, 0, 0, 1)) return 1;
  if (get_arg(enable)) return 1;
  if (get_arg(throttled, "thr=")) return 1;
  if (get_arg(baud, "baud=")) return 1;
  if (get_arg(loop, "loop=", 0, 1)) return 1;
  if (args_check(kNeedBoard)) return 1;
  if (gGpio == 0) { std::cerr << "No Gpio instance" << std::endl; return 1; }

  int ratediv = int(std::floor((500./baud)+0.5));
  if (ratediv > 511 || std::abs(baud - 500./double(ratediv)) > 0.01) {
    std::cout << "rocutil-E: baud rate not supported" << std::endl;
    return 1;
  }

  int rc;
  rc = gGpio->setConfig(2+ch, enable, enable, throttled, loop, false);
  print_opererr("Gpio::setConfig", rc);
  rc = gGpio->setSyncBaud(2+ch, ratediv);
  print_opererr("Gpio::setSyncBaud", rc);

  return 0;
}

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

int cmd_setaux()
{
  int32_t ch;
  bool riseedge = false;
  bool falledge = false;
  bool throttled = true;
  bool extrafunc = false;
  bool altin = false;
  if (get_arg(ch, 0, 0, 3)) return 1;
  if (get_arg(riseedge, "re=")) return 1;
  if (get_arg(falledge, "fe=")) return 1;
  if (get_arg(throttled, "thr=")) return 1;
  if (get_arg(extrafunc, "ext=")) return 1;
  if (get_arg(altin, "alt=")) return 1;
  if (args_check(kNeedBoard)) return 1;
  if (gGpio == 0) { std::cerr << "No Gpio instance" << std::endl; return 1; }

  int rc = gGpio->setConfig(4+ch, riseedge, falledge, throttled, 
                            extrafunc,altin);
  print_opererr("Gpio::setConfig", rc);
  return 0;
}

//----------------------------------------------------------------------------
int cmd_setlhwater()
{
   int32_t low(0), high(0);

   roc::UdpBoard* udp = dynamic_cast<roc::UdpBoard*> (gRocBoard);
   if (udp==0) return 1;

   if (get_arg(low,  "low=")) return 1;
   if (get_arg(high, "high=")) return 1;

   if ((low<8) || (high>128*1024) || (low>=high-8)) return 1;

   if (!udp->setRocLowHighWater(low, high)) return 1;

   return 0;
}


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

int cmd_printgpio()
{
  if (args_check(kNeedBoard)) return 1;
  if (gGpio == 0) { std::cerr << "No Gpio instance" << std::endl; return 1; }

  const char* names[8] = {"",
                          "sync-m  ",
                          "sync-0  ",
                          "sync-1  ",
                          "aux-0   ",
                          "aux-1   ",
                          "aux-2   ",
                          "aux-3   "
  };
  const char* namext[8] = {"",              // -
                           "",              // sync m
                           "loop-back",     // sync 0
                           "loop-back",     // sync 1
                           " <unused>",     // aux 0
                           " <unused>",     // aux 1
                           "TP-source",     // aux 2
                           "THR-input"      // aux 3
  };
  const char* namalt[8] = {"",              // -
                           "",              // sync m
                           "",              // sync 0
                           "",              // sync 1
                           " <unused>",     // aux 0
                           "  TP-busy",     // aux 1
                           "   TP-gen",     // aux 2
                           " THR-loop"      // aux 3
  };

  uint32_t mask;
  int rc = gGpio->getConfig(mask);
  print_opererr("Gpio::getConfig", rc);
  if (rc) return 0;  

  bool riseedge;
  bool falledge;
  bool throttled;
  bool extrafunc;
  bool altin;

  for (int i=1; i<4; i++) {                 // sync channels
    uint32_t bauds;
    uint32_t baud1;
    uint32_t baud2;
    rc = gGpio->getSyncBaud(i, bauds, baud1, baud2);
    print_opererr("Gpio::getSyncBaud", rc);
    
    double baud = 500. / (double(baud1+baud2));

    std::cout << names[i] << " :  baud(";
    static boost::format fmt_3d("%3d");
    std::cout << fmt_3d % bauds;
    std::cout << "," << fmt_3d % baud1;
    std::cout << "," << fmt_3d % baud2;
    static boost::format fmt_4p1f("%4.1f");
    std::cout << ")= " << fmt_4p1f % baud;
    std::cout << " MHz";

    if (i==1) {
      uint32_t scale;
      rc = gGpio->getSyncScale(scale);
      print_opererr("Gpio::getSyncScale", rc);
      std::cout << "  scale=" << fmt_3d % scale;
      std::cout << " 1:" << std::dec << (1<<scale);
    } else {
      gGpio->unpackConfig(mask, i, riseedge, falledge, throttled, 
                          extrafunc, altin);
      std::cout << "  enable=" << riseedge
                << "  throttled=" << throttled
                << "  " << namext[i] << "=" << extrafunc;
    }
    std::cout << std::endl;
  }

  for (int i=4; i<=7; i++) {                // aux channels
    gGpio->unpackConfig(mask, i, riseedge, falledge, throttled, 
                        extrafunc, altin);
    std::cout << names[i] << " :  rise=" <<  riseedge
              << "  fall=" << falledge
              << "  throttled=" << throttled
              << "  " << namext[i] << "=" << extrafunc
              << "  " << namalt[i] << "=" << altin;
    std::cout << std::endl;
  }

  return 0;
}

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

int cmd_printstatus()
{
  if (args_check(kNeedRocBoard)) return 1;
  if (gGpio == 0) { std::cerr << "No Gpio instance" << std::endl; return 1; }


  int rc;
  uint32_t mask;
  rc = gGpio->getConfig(mask);
  print_opererr("Gpio::getConfig", rc);
  if (rc) return 0;

  bool riseedge;
  bool falledge;
  bool throttled;
  bool extrafunc;
  bool altin;

  for (int i=0; i<=1; i++) {
    gGpio->unpackConfig(mask, i+2, riseedge, falledge, throttled, 
                        extrafunc, altin);
    if (riseedge | falledge) {
      std::cout << "SYN " << std::dec << i << ":"
           << " enabled";
      if (extrafunc) {
        std::cout << " in loop-back mode";
        uint32_t scale;
        rc = gGpio->getSyncScale(scale);
        print_opererr("Gpio::getSyncScale", rc);
        std::cout << "; syncm scale = " << scale;
      }
      std::cout << std::endl;
    }
  }

  for (int i=0; i<=3; i++) {
    gGpio->unpackConfig(mask, i+4, riseedge, falledge, throttled, 
                        extrafunc, altin);
    if (riseedge | falledge | extrafunc) {
      std::cout << "AUX " << std::dec << i << ":"
           << " re=" << riseedge
           << " fe=" << falledge
           << " thr=" << throttled
           << " ext=" << extrafunc
           << " alt=" << altin
           << "  ";
      if (i==3) {
        if (extrafunc) {
          std::cout << "THR active";
          if (altin) std::cout << " as auto throttle";
        }
      }
      std::cout << std::endl;
     }
 }

  if (gFeb) {                               // FEB connected
    static boost::format fmt_3d("%3d");
    static boost::format fmt_02x("%02x");
    for (int nx=0; nx<gFeb->numNx(); nx++) {
      std::cout << "NX  " << gFeb->getPortNumber()
           << "," << nx
           << "," << gFeb->nx(nx).getNxNumber()
           << ":";

      if (gFeb->getNxOffline(nx)) {
        std::cout << " is offline" << std::endl;
        continue;
      }

      nxyter::NxContext cntx;
      rc = gFeb->nx(nx).i2c().getContext(cntx, nxyter::kDoCore);  // core only
      if (rc) {
        std::cout << "!! ERROR: NX NOT REACHABLE:"
             << base::Board::operErrToString(rc)
             << " <===" << std::endl;
        continue;
      }

      uint8_t vth    = cntx.getRegister(nxyter::kNxRegVth);
      uint8_t vbiasf = cntx.getRegister(nxyter::kNxRegVbiasF);
      uint8_t vbiass = cntx.getRegister(nxyter::kNxRegVbiasS);

      std::cout << " Vth="    << fmt_3d % int(vth);
      std::cout << " VbiasF=" << fmt_3d % int(vbiasf);
      std::cout << " VbiasS=" << fmt_3d % int(vbiass);

      int n128 = 0;
      for (int i=nxyter::kNxRegVcg; i<=nxyter::kNxRegiTWC; i++) {
        if (cntx.getRegister(i) == 128) n128 += 1;
      }
      if (n128 >= (nxyter::kNxRegiTWC-nxyter::kNxRegVcg)-2) {
        std::cout << "!! ERROR: NX in RESET STATE <===";
      } else {
        uint8_t conf0 = cntx.getRegister(nxyter::kNxRegConfig0);
        uint8_t conf1 = cntx.getRegister(nxyter::kNxRegConfig1);
        
        std::cout << " conf=" << fmt_02x % uint32_t(conf0);
        std::cout << "," << fmt_02x % uint32_t(conf1);
        std::cout << " tpul=" << ((conf0&nxyter::kNxC0TestPulsEnable)   ? "1" : "0");
        std::cout << " ttri=" << ((conf0&nxyter::kNxC0TestTrigEnable)   ? "1" : "0");
        std::cout << " pos="  << ((conf0&nxyter::kNxC1FrontEndPolarity) ? "1" : "0");
      }

      std::cout << std::endl;
    }
  }

  return 0;
}

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

int cmd_firepulser()
{
  bool opt_s  = get_opt("-s");
  bool opt_a  = get_opt("-a");
  int32_t period(100000);
  int32_t width(350);
  int32_t number(0);
  int32_t delay(0);
  if (get_arg(period, "per=",  2, 0x00ffffff)) return 1;
  if (get_arg(width,  "wth=",  -0x00ffffff, 0x00ffffff)) return 1;
  if (get_arg(number, "num=",  0, 0x00008fff)) return 1;
  if (get_arg(delay,  "dly=",   0, 0x0000ffff)) return 1;
  if (args_check(kNeedBoard)) return 1;

  if (gRocNx==0) {
     std::cout << "RocNx instance is required" << std::endl;
     return 1;
  }

  if (gGpio==0) {
     std::cout << "Gpio instance is required" << std::endl;
     return 1;
  }

  int rc;

  if (opt_a) {                              // setup AUX2
    uint32_t mask;
    rc = gGpio->getConfig(mask);
    print_opererr("Gpio::getConfig", rc);
    bool riseedge, falledge, throttled, extrafunc, altin;
    base::Gpio::unpackConfig(mask, 6,
                       riseedge, falledge, throttled, extrafunc, altin);

    if (opt_s) {
      extrafunc = false;
    } else {
      extrafunc = true;
      altin = true;
    }
    
    base::Gpio::packConfig(mask, 6, riseedge, falledge, throttled, extrafunc, altin);
    rc = gGpio->setConfig(mask);
    print_opererr("Gpio::setConfig", rc);
  }

  if (delay == 0) {
    if (opt_s) {                            // stop pulser
      period = 0;
      width  = 0;
      number = 0;
    }
    rc = gRocNx->fireTestPulse(period, width, number);
  } else {
    rc = gRocNx->fireTestPulse(delay, period, width, number);
  }
  print_opererr("RocNx::fireTestPulse", rc);
  return 0;
}

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

int cmd_setfebdef()
{
  bool ispos0(false), ispos1(false);
  if (get_arg(ispos0, "pos0=")) return 1;
  if (get_arg(ispos1, "pos1=")) return 1;
  if (args_check(kNeedFeb)) return 1;
  int rc = gFeb->setToDefault(ispos0, ispos1);
  print_opererr("FebBase::setToDefault", rc);
  printf("Note: Vbfb default value is changed now from 6 to 30!\n");
  return 0;
}

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

int cmd_setnxdef()
{
   int32_t nxbeg(0), nxend(0);
   bool ispos(false);
   if (get_nxrange(nxbeg, nxend, "nx=")) return 1;
   if (get_arg(ispos, "pos=")) return 1;
   if (args_check(kNeedFeb)) return 1;
   for (int i=nxbeg; i<=nxend; i++) {
      if (check_nxoffline(i, nxbeg, nxend)) continue; // skip of offline
      int rc = gFeb->nx(i).i2c().setToDefault(ispos);
      print_opererr("NxI2c::setToDefault", rc);
   }
   return 0;
}

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

int cmd_setnx()
{
  int32_t nxbeg=0;
  int32_t nxend=0;
  int32_t reg;
  int32_t val;
  if (get_nxrange(nxbeg, nxend)) return 1;
  if (get_arg(reg, 0, 0, 255)) return 1;
  if (get_arg(val, 0, 0, 255)) return 1;
  if (args_check(kNeedFeb)) return 1;

  if (reg == nxyter::kNxRegTrimDAQPower) {
    std::cout << "rocutil-E: use 'setnxtrim' and 'setnxpower' for Reg 42" << std::endl;
    return 1;
  }

  if ((reg == nxyter::kNxRegdelayTestPuls) ||
      (reg == nxyter::kNxRegdelayTestTrig) ||
      (reg == nxyter::kNxRegdelayClock1) ||
      (reg == nxyter::kNxRegdelayClock2) ||
      (reg == nxyter::kNxRegdelayClock3)) {
    int32_t del = val;
    val = nxyter::NxI2c::delayToSetting(del);
    std::cout << "rocutil-I: map delay " << del
              << " to register value " << val << std::endl;
  }

  for (int i=nxbeg; i<=nxend; i++) {
    if (check_nxoffline(i, nxbeg, nxend)) continue; // skip of offline
    int rc = gFeb->nx(i).i2c().setRegister(uint8_t(reg), uint8_t(val), true);
    print_opererr("NxI2c::setRegister", rc);
  }
  
  return 0;
}

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

int cmd_getnx()
{
  int32_t nxbeg=0;
  int32_t nxend=0;
  int32_t reg;
  if (get_nxrange(nxbeg, nxend)) return 1;
  if (get_arg(reg, 0, 0, 255)) return 1;
  if (args_check(kNeedFeb)) return 1;

  if (reg == nxyter::kNxRegTrimDAQPower) {
    std::cout << "rocutil-E: use 'printnx' to see Reg 42" << std::endl;
    return 1;
  }

  for (int i=nxbeg; i<=nxend; i++) {
    if (check_nxoffline(i, nxbeg, nxend)) { // skip of offline
      std::cout << "nxind=" << i << " is is set OFFLINE" << std::endl;
      continue; 
    }
    
    uint8_t val;
    int rc = gFeb->nx(i).i2c().getRegister(uint8_t(reg), val);
    if (print_opererr("NxI2c::getRegister", rc)) return 0;

    static boost::format fmt("nxind=%|1| (%|1|,%|3|) "
                      "Reg(%|2|) %|-14|: 0x%|02x| %|3|");

    const char* name = nxyter::NxI2c::registerName(reg);
    if (name[0] == 0) name = "..not in nX..";
    
    std::cout << fmt % i % gFeb->getPortNumber() % 
      uint32_t(gFeb->nx(i).i2c().getSlaveAddr()) % reg %
      name % uint32_t(val)% uint32_t(val);
    
    std::cout << " : ";
    for (int i=7; i>=0; i--) std::cout << ((val & (1<<i)) ? " 1" : " 0");
    
    if (reg == nxyter::kNxRegdelayTestPuls ||
        reg == nxyter::kNxRegdelayTestTrig ||
        reg == nxyter::kNxRegdelayClock1 ||
        reg == nxyter::kNxRegdelayClock2 ||
        reg == nxyter::kNxRegdelayClock3) {
      static boost::format fmt_del(" : delay=%|3|");
      std::cout << fmt_del % uint16_t(nxyter::NxI2c::settingToDelay(val));
    }
    std::cout << std::endl;
  }
  
  return 0;
}

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

int cmd_setnxmode()
{
  int32_t nxbeg=0;
  int32_t nxend=0;
  bool testpuls=false;
  bool testtrig=false;
  int32_t calselect=3;
  if (get_nxrange(nxbeg, nxend)) return 1;
  if (get_arg(testpuls, "tpul=")) return 1;
  if (get_arg(testtrig, "ttri=")) return 1;
  if (get_arg(calselect, "csel=", 0, 3)) return 1;
  if (args_check(kNeedFeb)) return 1;

  for (int i=nxbeg; i<=nxend; i++) {
    if (check_nxoffline(i, nxbeg, nxend)) continue; // skip of offline
    int rc;
    rc = gFeb->nx(i).i2c().setTestModes(testpuls, testtrig, calselect);
    print_opererr("NxI2c::setTestModes", rc);
  }
  return 0;
}

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

int cmd_setnxmask()
{
  int32_t nxbeg=0;
  int32_t nxend=0;
  bool val=false;
  int32_t ibeg=0;
  int32_t iend=127;
  int32_t istep=1;
  if (get_nxrange(nxbeg, nxend)) return 1;
  if (get_arg(val, "val=")) return 1;
  if (get_arg(ibeg, "ibeg=", 0, 127)) return 1;
  if (get_arg(iend, "iend=", 0, 127)) return 1;
  if (get_arg(istep, "istep=", 1, 64)) return 1;
  if (args_check(kNeedFeb)) return 1;

  for (int i=nxbeg; i<=nxend; i++) {
    if (check_nxoffline(i, nxbeg, nxend)) continue; // skip of offline
    int rc;
    nxyter::NxContext cntx;
    rc = gFeb->nx(i).i2c().getContext(cntx, nxyter::kDoMask);  // mask only
    print_opererr("NxI2c::getContext", rc);
    
    cntx.setChannelMaskBit(ibeg, iend, val, istep);
    
    rc = gFeb->nx(i).i2c().setContext(cntx, nxyter::kDoMask);  // mask only
    print_opererr("NxI2c::setContext", rc);
  }
  return 0;
}

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

int cmd_setnxtrim()
{
  int32_t nxbeg=0;
  int32_t nxend=0;
  int32_t val=16;
  int32_t ibeg=0;
  int32_t iend=127;
  int32_t istep=1;
  if (get_nxrange(nxbeg, nxend)) return 1;
  if (get_arg(val, "val=", 0,  31)) return 1;
  if (get_arg(ibeg, "ibeg=", 0, 128)) return 1;
  if (get_arg(iend, "iend=", 0, 128)) return 1;
  if (get_arg(istep, "istep=", 1, 64)) return 1;
  if (args_check(kNeedFeb)) return 1;

  for (int i=nxbeg; i<=nxend; i++) {
    if (check_nxoffline(i, nxbeg, nxend)) continue; // skip of offline
    int rc;
    nxyter::NxContext cntx;
    rc = gFeb->nx(i).i2c().getContext(cntx, nxyter::kDoTrim); // trim only
    print_opererr("NxI2c::getContext", rc);
    
    cntx.setThresholdTrim(ibeg, iend, uint8_t(val), istep);
    
    rc = gFeb->nx(i).i2c().setContext(cntx, nxyter::kDoTrim); // trim only 
    print_opererr("NxI2c::setContext", rc);
  }
  return 0;
}

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

int cmd_setnxpower()
{
  int32_t nxbeg=0;
  int32_t nxend=0;
  bool val=false;
  int32_t ibeg=0;
  int32_t iend=127;
  int32_t istep=1;
  if (get_nxrange(nxbeg, nxend)) return 1;
  if (get_arg(val, "val=")) return 1;
  if (get_arg(ibeg, "ibeg=", 0, 128)) return 1;
  if (get_arg(iend, "iend=", 0, 128)) return 1;
  if (get_arg(istep, "istep=", 1, 64)) return 1;
  if (args_check(kNeedFeb)) return 1;

  for (int i=nxbeg; i<=nxend; i++) {
    if (check_nxoffline(i, nxbeg, nxend)) continue; // skip of offline
    int rc;
    nxyter::NxContext cntx;
    rc = gFeb->nx(i).i2c().getContext(cntx, nxyter::kDoTrim);  // trim only
    print_opererr("NxI2c::getContext", rc);
    
    cntx.setPowerOffMaskBit(ibeg, iend, val, istep);
    
    rc = gFeb->nx(i).i2c().setContext(cntx, nxyter::kDoTrim);  // trim only
    print_opererr("NxI2c::setContext", rc);
  }
  
  return 0;
}

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

int cmd_resetnxi2cbus()
{
  if (args_check(kNeedFeb)) return 1;
  gFeb->resetNxI2cBus();
  return 0;
}

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

int cmd_resetnxi2creg()
{
  if (args_check(kNeedFeb)) return 1;
  gFeb->resetNxI2cRegister();
  return 0;
}

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

int cmd_seti2c()
{
  bool loop = get_opt("-l");
  bool veri = get_opt("-v");
  int32_t addr;
  int32_t reg;
  int32_t val;
  int32_t ecnt = 0;

  if (get_arg(addr, 0, 0, 127)) return 1;
  if (get_arg(reg, 0, 0, 255)) return 1;
  if (get_arg(val, 0, 0, 255)) return 1;
  if (args_check(kNeedFeb)) return 1;

  roc::I2cDevice i2c(gRocBoard, gFeb->getPortNumber(), addr);
  gUtil->startLoop(0.);
  while(gUtil->testLoop()) {
    int rc = i2c.setRegister(reg, val, veri);
    if (rc) {
      std::cout << std::dec << ecnt << " : " << base::Board::operErrToString(rc) << std::endl;
      ecnt++;
    }
    if (!loop) break;
  }

  if (loop) print_loop_stats("seti2c", ecnt);

  return 0;
}

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

int cmd_geti2c()
{
  bool loop = get_opt("-l");
  bool wide = get_opt("-w");
  int32_t addr;
  int32_t reg;
  uint8_t  val8;
  uint16_t val;
  uint16_t valold = 0;
  uint64_t count = 0;
  int ecnt = 0;

  if (get_arg(addr, 0, 0, 127)) return 1;
  if (get_arg(reg, 0, 0, 255)) return 1;
  if (args_check(kNeedBoard)) return 1;
  if (gRocBoard)
     if (args_check(kNeedFeb)) return 1;
  
  if (gUtil==0) {
     printf("No utility instance available - break\n");
     return 1;
  }

  roc::I2cDevice i2c(gBaseBoard, gFeb ? gFeb->getPortNumber() : 0, addr);
  
  gUtil->startLoop(0.);

  while(gUtil->testLoop()) {
    int rc;

    if (wide) {
      rc = i2c.getRegister16(reg, val);
    } else {
      rc = i2c.getRegister(reg, val8);
      val = uint16_t(val8);
    }
    if (rc) std::cout << base::Board::operErrToString(rc) << std::endl;
    if (count==0) {
      static boost::format fmt("addr=%|3|,reg=%|3| -> read %|5|  0x%04x");
      std::cout << fmt % addr % reg % uint32_t(val) % uint32_t(val);
      if (wide) {
        static boost::format fmt("   (%|2|,%|4|)");
        std::cout << fmt % uint32_t((val>>12)&0xf) % uint32_t(val&0xfff);
      }
      std::cout << std::endl;
      valold = val;
    } else if (val != valold) {
      ecnt++;
      static boost::format fmt("   loop %|8| -> read %|5|  0x%04x");
      std::cout << fmt % count % uint32_t(val) % uint32_t(val) << std::endl;
      valold = val;
    }
    count++;
    if (!loop) break;
  }

  if (loop) print_loop_stats("geti2c", ecnt);

  return 0;
}

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

int cmd_puti2c()
{
  int32_t addr;
  int32_t reg;
  int32_t val;

  if (get_arg(addr, 0, 0, 127)) return 1;
  if (get_arg(reg, 0, 0, 255)) return 1;
  if (get_arg(val, 0, 0, 255)) return 1;
  if (args_check(kNeedBoard)) return 1;
  if (gRocBoard)
     if (args_check(kNeedFeb)) return 1;

  if (gUtil==0) {
     printf("No utility instance available - break\n");
     return 1;
  }

  roc::I2cDevice i2c(gBaseBoard, gFeb ? gFeb->getPortNumber() : 0, addr);

  int rc = i2c.setRegister(reg, val);
  if (rc) std::cout << base::Board::operErrToString(rc) << std::endl;
  static boost::format fmt("addr=%|3|,reg=%|3| -> write %|5|  0x%04x");
  std::cout << fmt % addr % reg % uint32_t(val) % uint32_t(val) << std::endl;

  return 0;
}
    

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

int cmd_setadcdef()
{
  if (args_check(kNeedFeb)) return 1;
  int rc = gFeb->adc().setToDefault();
  print_opererr("MainAdc::setToDefault", rc);
  return 0;
}

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

int cmd_setadc()
{
  int32_t reg;
  int32_t val;
  if (get_arg(reg, 0, 0, 255)) return 1;
  if (get_arg(val, 0, 0, 255)) return 1;
  if (args_check(kNeedFeb)) return 1;
  int rc = gFeb->adc().setRegister(uint8_t(reg), uint8_t(val), true);
  print_opererr("MainAdc::setRegister", rc);
  return 0;
}

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

int cmd_setadcpatt()
{
  int32_t tm0(0), tm1(0), tm2(0), tm3(0), upatt(-1);
  if (get_arg(tm0, "tm0=", 0, 12)) return 1;
  if (get_arg(tm1, "tm1=", 0, 12)) return 1;
  if (get_arg(tm2, "tm2=", 0, 12)) return 1;
  if (get_arg(tm3, "tm3=", 0, 12)) return 1;
  if (get_arg(upatt, "upatt=")) return 1;
  if (args_check(kNeedFeb)) return 1;
  int rc;
             rc = gFeb->adc().setTestMode(0, uint8_t(tm0));
  if (rc==0) rc = gFeb->adc().setTestMode(1, uint8_t(tm1));
  if (rc==0) rc = gFeb->adc().setTestMode(2, uint8_t(tm2));
  if (rc==0) rc = gFeb->adc().setTestMode(3, uint8_t(tm3));
  if (rc==0 && upatt != -1) gFeb->adc().setUserPattern(uint16_t(upatt));
  print_opererr("MainAdc::setTestMode/setUserPattern", rc);
  return 0;
}

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

int cmd_setadcclock()
{
  int32_t dly;
  if (get_arg(dly, 0, 0, 31)) return 1;
  if (args_check(kNeedFeb)) return 1;
  gFeb->adc().setClockDelay(dly);
  return 0;
}

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

int cmd_getadcdirect()
{
  bool opt_d = get_opt("-d");
  if (args_check(kNeedFeb)) return 1;

  for (int ch=0; ch<4; ch++) {
    std::cout << " " << std::dec << ch << " : ";
    int imax = (opt_d) ? 14 : 18;
    int rcsum = 0;
    for (int i=0; i<imax; i++) {
      uint32_t val;
      int rc = gFeb->adc().getAdcDirect(ch, val);
      if (rc) rcsum = rc;
      if (opt_d) {
        static boost::format fmt(" %|4|");
        std::cout << fmt % val;
      } else {
        static boost::format fmt(" %03x");
        std::cout << fmt % val;      
      }
    }
    std::cout << std::endl;
    print_opererr("MainAdc::getAdcDirect", rcsum);
  }
  return 0;
}

//----------------------------------------------------------------------------
void print_40f_41f(float val)
{
  static boost::format fmt_40f("%4.0f");
  static boost::format fmt_41f("%4.1f");
  if (val < 99.9) {
    std::cout <<  " " << fmt_41f % val;
  } else {
    std::cout <<  " " << fmt_40f % val;
  }
}

//----------------------------------------------------------------------------
void print_dfa_ent_med_w50(int vb, int ncha, nxyter::DistFunc& df_ent,
                           nxyter::DistFunc& df_med, nxyter::DistFunc& df_w50,
                           bool mode_ent, bool phead)
{
  if (phead) {
    if (mode_ent) {
      std::cout << "                           #hits             :  ADC median    :ADC Width 25-75" << std::endl;
      std::cout << "val #ch :  min   3%  10%  med  90%  97%  max :  10%  med  90% :  med  w50  w80" << std::endl;
    } else {
      std::cout << "               #hits     :         ADC median value           :ADC Width 25-75" << std::endl;
      std::cout << "val #ch :   5%  med  95% :  min   3%  10%  med  90%  97%  max :  med  w50  w80" << std::endl;
    }
  }

  static boost::format fmt_3d("%3d");
  static boost::format fmt_40f("%4.0f");
  static boost::format fmt_41f("%4.1f");
  float p4of128 = 4./128.;
  
  std::cout << fmt_3d % vb;
  std::cout << " " << fmt_3d  % ncha;
  if (mode_ent) {
    std::cout << " : " << fmt_40f % df_ent.getMin();
    std::cout << " "   << fmt_40f % df_ent(p4of128);
    std::cout << " "   << fmt_40f % df_ent(.10);
    std::cout << " "   << fmt_40f % df_ent.getMedian();
    std::cout << " "   << fmt_40f % df_ent(.90);
    std::cout << " "   << fmt_40f % df_ent(1.-p4of128);
    std::cout << " "   << fmt_40f % df_ent.getMax();
    std::cout << " : " << fmt_40f % df_med(0.10);
    std::cout << " "   << fmt_40f % df_med.getMedian();
    std::cout << " "   << fmt_40f % df_med(0.90);
  } else {
    std::cout << " : " << fmt_40f % df_ent(0.05);
    std::cout << " "   << fmt_40f % df_ent.getMedian();
    std::cout << " "   << fmt_40f % df_ent(0.95);
    std::cout << " : " << fmt_40f % df_med.getMin();
    std::cout << " "   << fmt_40f % df_med(p4of128);
    std::cout << " "   << fmt_40f % df_med(.10);
    std::cout << " "   << fmt_40f % df_med.getMedian();
    std::cout << " "   << fmt_40f % df_med(.90);
    std::cout << " "   << fmt_40f % df_med(1.-p4of128);
    std::cout << " "   << fmt_40f % df_med.getMax();
  }
  std::cout << " :";
  print_40f_41f(df_w50.getMedian());
  print_40f_41f(df_w50.getWidth(.25));
  print_40f_41f(df_w50.getWidth(.40));
  std::cout << std::endl;
}

//----------------------------------------------------------------------------
void get_vbiass_data(int nxind, int vb, float& med, int npuls,
                     bool opt_v, bool phead)
{
  int ncha = 0;
  nxyter::DistFunc df_ent(128);
  nxyter::DistFunc df_med(128);
  nxyter::DistFunc df_w50(128);

  int rc;
  rc = gFeb->nx(nxind).i2c().setRegister(nxyter::kNxRegVbiasS, vb, true);
  print_opererr("setRegister(kNxRegVbiasS,...)", rc);
  nxyter::NxDataSummary nds;
  gUtil->acquireTestTriggerData(nxind, npuls, nds);
  if (opt_v) {
    nds.print(std::cout, gFeb->nx(nxind).getNxNumber());
    gQdaq->stats().print(std::cout);
  }

  for (int ch=0; ch<128; ch++) {
    if (nds.numEntries(ch)==0) continue;
    ncha += 1;
    df_ent.addEntry(nds.numEntries(ch));
    df_med.addEntry(nds.getMedian(ch));
    df_w50.addEntry(nds.getWidth50(ch));
  }

  print_dfa_ent_med_w50(vb, ncha, df_ent, df_med, df_w50, false, phead);

  med = df_med.getMedian();

}

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

int cmd_scanmonadc()
{
  int32_t nxbeg=0;
  int32_t nxend=0;
  int32_t reg;
  int32_t vbeg=0;
  int32_t vend=255;
  int32_t vstep=1;
  int32_t npuls=100;
  if (get_nxrange(nxbeg, nxend)) return 1;
  if (get_arg(reg, 0, 0, 255)) return 1;
  if (get_arg(vbeg,  "vbeg=",  0, 255)) return 1;
  if (get_arg(vend,  "vend=",  0, 255)) return 1;
  if (get_arg(vstep, "vstep=", 1, 255)) return 1;
  if (args_check(kNeedFeb)) return 1;

  int rc;
  nxyter::NxContext save_cntx;
  
  gUtil->startLoop(0.);
  for (int nxind=nxbeg; nxind<=nxend; nxind++) {
    if (!gUtil->testLoop()) break;
    gFeb->printNxHeadLine(std::cout, nxind);
    if (check_nxoffline(nxind, nxbeg, nxend)) continue; // skip of offline

    rc = gFeb->nx(nxind).i2c().getContext(save_cntx, nxyter::kDoCore);
    print_opererr("NxI2c::getContext {save}", rc);
    
    std::cout << "val : adc0 adc1 adc2 adc3" << std::endl;

    for (int vb=vbeg; vb<=vend; vb+=vstep) {
      if (!gUtil->testLoop()) break;
      rc = gFeb->nx(nxind).i2c().setRegister(uint8_t(reg), uint8_t(vb), true);
      print_opererr("NxI2c::setRegister", rc);
      uint16_t val[4];
      for (int ch=0; ch<4; ch++) {
        rc = gFeb->getMonAdc(ch, val[ch]);
        print_opererr("FebBase::getMonAdc", rc);
      }
      static boost::format fmt_3("%|3|");
      static boost::format fmt_4("%|4|");
      std::cout << fmt_3 % vb << " :";
      for (int ch=0; ch<4; ch++) std::cout << " " << fmt_4 % val[ch];
      std::cout << std::endl;
    }

    rc = gFeb->nx(nxind).i2c().setContext(save_cntx, nxyter::kDoCore);
    print_opererr("NxI2c::setContext {restore}", rc);
  
  }

  return 0;
}

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

int cmd_scanvbiass()
{
  bool opt_v = get_opt("-v");
  int32_t nxbeg=0;
  int32_t nxend=0;
  int32_t vbeg=0;
  int32_t vend=255;
  int32_t vstep=1;
  int32_t npuls=100;
  if (get_nxrange(nxbeg, nxend)) return 1;
  if (get_arg(vbeg,  "vbeg=",  0, 255)) return 1;
  if (get_arg(vend,  "vend=",  0, 255)) return 1;
  if (get_arg(vstep, "vstep=", 1, 255)) return 1;
  if (get_arg(npuls, "npuls=", 1, 10000)) return 1;
  if (args_check(kNeedFeb|kNeedDaq)) return 1;

  int rc;
  nxyter::NxContext save_cntx;
  
  gUtil->startLoop(0.);
  for (int nxind=nxbeg; nxind<=nxend; nxind++) {
    if (!gUtil->testLoop()) break;
    gFeb->printNxHeadLine(std::cout, nxind);
    if (check_nxoffline(nxind, nxbeg, nxend)) continue; // skip of offline

    rc = gFeb->nx(nxind).i2c().getContext(save_cntx, nxyter::kDoCore);
    print_opererr("NxI2c::getContext {save}", rc);

    rc = gFeb->nx(nxind).i2c().setTestModes(false, true, 0);
    print_opererr("NxI2c::setTestModes", rc);
    
    
    for (int vb=vbeg; vb<=vend; vb+=vstep) {
      if (!gUtil->testLoop()) break;
      float med;
      get_vbiass_data(nxind, vb, med, npuls, opt_v, vb==vbeg);
    }

    rc = gFeb->nx(nxind).i2c().setContext(save_cntx, nxyter::kDoCore);
    print_opererr("NxI2c::setContext {restore}", rc);
  
  }

  return 0;
}

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

int cmd_autovbiass()
{
  bool opt_v = get_opt("-v");
  int32_t nxbeg=0;
  int32_t nxend=0;
  int32_t base=2000;
  int32_t npuls=200;
  if (get_nxrange(nxbeg, nxend)) return 1;
  if (get_arg(base, "base=", 0, 4095)) return 1;
  if (get_arg(npuls, "npuls=", 1, 10000)) return 1;
  if (args_check(kNeedFeb|kNeedDaq)) return 1;

  int rc;
  nxyter::NxContext save_cntx;
  
  gUtil->startLoop(0.);
  for (int nxind=nxbeg; nxind<=nxend; nxind++) {
    if (!gUtil->testLoop()) break;
    gFeb->printNxHeadLine(std::cout, nxind);
    if (check_nxoffline(nxind, nxbeg, nxend)) continue; // skip of offline

    rc = gFeb->nx(nxind).i2c().getContext(save_cntx, nxyter::kDoCore);
    print_opererr("NxI2c::getContext {save}", rc);

    rc = gFeb->nx(nxind).i2c().setTestModes(false, true, 0);
    print_opererr("NxI2c::setTestModes", rc);
    
    int vb_beg =   0;
    int vb_end = 255;
    int vb_mid =   0;
    float med_beg;
    float med_end;
    float med_mid;
    bool nxabort = false;
    
    get_vbiass_data(nxind, vb_beg, med_beg, npuls, opt_v, true);
    get_vbiass_data(nxind, vb_end, med_end, npuls, opt_v, false);
 
    if (float(base) < std::min(med_beg, med_end) ||
        float(base) > std::max(med_beg, med_end)) {
      std::cout << "!! ABORT autovbiass: baseline target of " << std::dec << base
           << " is outside the range possible\n"
           << "   with VBiasS between 0 and 255, see two lines above" << std::endl;
      nxabort = true;
    }

    bool posgain = (med_end > med_beg);     // vb->med gain is positive

    while (!nxabort && vb_end-vb_beg >=2) {
      if (!gUtil->testLoop()) break;
      vb_mid = (vb_end+vb_beg)/2;
      get_vbiass_data(nxind, vb_mid, med_mid, npuls, opt_v, false);

      // allow some tolerance
      float tol = 300.;
      if (med_mid < std::min(med_beg, med_end)-tol ||
          med_mid > std::max(med_beg, med_end)+tol) {
        nxabort = true;
        std::cout << "!! ABORT autovbiass: ADC median for vb=" 
             << std::dec << vb_mid << " outside the previous bounds\n"
             << "   determined for vb_beg=" << vb_beg
             << " and vb_end=" << vb_end << ", values see above." << std::endl;
        break;
      }

      bool keepend;                         // keep vb_end, vb_beg <- vb_mid
      bool unsteady = false;                // if mid ouside [beg,end]
      if (posgain) {
        keepend = base >= med_mid;
      } else {
        keepend = base <= med_mid;
      }

      if (keepend) {                        // in upper sector ?
        vb_beg = vb_mid;
        med_beg = med_mid;
      } else {                              // otherwise lower sector
        vb_end = vb_mid;
        med_end = med_mid;
      }
    }

    // end game: check whether beg, mid or end is best
    float dif_beg = std::abs(med_beg - base);
    float dif_mid = std::abs(med_mid - base);
    float dif_end = std::abs(med_end - base);
    int vb_fin = 0;
    float med_fin = 0.;
    
    if (!nxabort) {
      if (dif_beg < dif_mid) {
        vb_fin  = vb_beg;
        med_fin = med_beg;
      } else if (dif_end < dif_mid) {
        vb_fin  = vb_end;
        med_fin = med_end;
      } else {
        vb_fin  = vb_mid;
        med_fin = med_mid;
      }
      static boost::format fmt("==> VBiasS=%3d  median ADC=%4.0f  (target=%4d)");
      std::cout << fmt % vb_fin % med_fin % base << std::endl;
    }

    rc = gFeb->nx(nxind).i2c().setContext(save_cntx, nxyter::kDoCore);
    print_opererr("NxI2c::setContext {restore}", rc);    

    if (!nxabort && gUtil->testLoop()) {    // if not aborted
      rc = gFeb->nx(nxind).i2c().setRegister(nxyter::kNxRegVbiasS, 
                                             vb_fin, true);
      print_opererr("setRegister(kNxRegVbiasS,...)", rc);
    }
    
  }

  return 0;
}

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

int cmd_scanvbiasf()
{
  bool opt_v = get_opt("-v");
  int32_t nxbeg=0;
  int32_t nxend=0;
  int32_t vbeg=0;
  int32_t vend=255;
  int32_t vstep=1;
  int32_t npuls=100;
  if (get_nxrange(nxbeg, nxend)) return 1;
  if (get_arg(vbeg,  "vbeg=",  0, 255)) return 1;
  if (get_arg(vend,  "vend=",  0, 255)) return 1;
  if (get_arg(vstep, "vstep=", 1, 255)) return 1;
  if (get_arg(npuls, "npuls=", 1, 10000)) return 1;
  if (args_check(kNeedFeb|kNeedDaq)) return 1;

  int rc;
  nxyter::NxContext save_cntx;
  
  gUtil->startLoop(0.);
  for (int nxind=nxbeg; nxind<=nxend; nxind++) {
    if (!gUtil->testLoop()) break;
    gFeb->printNxHeadLine(std::cout, nxind);
    if (check_nxoffline(nxind, nxbeg, nxend)) continue; // skip of offline

    rc = gFeb->nx(nxind).i2c().getContext(save_cntx, 
                                          nxyter::kDoCore|nxyter::kDoMask);
    print_opererr("NxI2c::getContext {save}", rc);

    rc = gFeb->nx(nxind).i2c().setTestModes(true, false, 0);
    print_opererr("NxI2c::setTestModes", rc);
    
    for (int vb=vbeg; vb<=vend; vb+=vstep) {
      if (!gUtil->testLoop()) break;
      rc = gFeb->nx(nxind).i2c().setRegister(nxyter::kNxRegVbiasF, vb, true);
      print_opererr("setRegister(kNxRegVbiasF,...)", rc);

      nxyter::NxDataSummary nds;
      gUtil->acquireTestPulserData(nxind, save_cntx, npuls, nds);
      if (opt_v) {
        nds.print(std::cout, gFeb->nx(nxind).getNxNumber());
        gQdaq->stats().print(std::cout);
      }

      int ncha = 0;
      nxyter::DistFunc df_ent(128);
      nxyter::DistFunc df_med(128);
      nxyter::DistFunc df_w50(128);
    
      for (int ch=0; ch<128; ch++) {
        if (nds.numEntries(ch)==0) continue;
        ncha += 1;
        df_ent.addEntry(nds.numEntries(ch));
        df_med.addEntry(nds.getMedian(ch));
        df_w50.addEntry(nds.getWidth50(ch));
      }

      print_dfa_ent_med_w50(vb, ncha, df_ent, df_med, df_w50, true, vb==vbeg);

    }

    rc = gFeb->nx(nxind).i2c().setContext(save_cntx, 
                                          nxyter::kDoCore|nxyter::kDoMask);
    print_opererr("NxI2c::setContext {restore}", rc);
  
  }

  return 0;
}

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

int cmd_scanadclat()
{
  bool opt_v = get_opt("-v");
  bool opt_d = get_opt("-d");
  int32_t nxind=0;
  int32_t ch=0;
  int32_t ch2=-1;
  int32_t lbeg=61;
  int32_t lend=68;
  int32_t dbeg=0;
  int32_t dend=31;
  int32_t npuls=100;
  if (get_nxind(nxind)) return 1;
  if (get_arg(ch,    "ch=",    0, 127)) return 1;
  if (get_arg(lbeg,  "lbeg=",  0, 127)) return 1;
  if (get_arg(lend,  "lend=",  0, 127)) return 1;
  if (get_arg(dbeg,  "dbeg=",  0, 31)) return 1;
  if (get_arg(dend,  "dend=",  0, 31)) return 1;
  if (get_arg(npuls, "npuls=", 1, 10000)) return 1;
  if (get_arg(ch2,   "ch2=",   0, 127)) return 1;
  if (args_check(kNeedFeb|kNeedDaq)) return 1;

  int32_t dstep=1;
  int32_t lstep=1;

  if (opt_d) {
    int nlat = lend-lbeg+1;
    if (nlat > 16) {
      lstep = 4;
      if (lend > lbeg + (nlat-1)*lstep) lend = lbeg + (nlat-1)*lstep;
    } else if (nlat > 8) {
      lstep = 2;
    } 

  } else {
    int ndly = dend-dbeg+1;
    if (ndly > 16) {
      dstep = 4;
    } else if (ndly >  8) {
      dstep = 2;
    }
  }

  int rc;
  int nxnum = gFeb->nx(nxind).getNxNumber();
  nxyter::NxContext save_cntx;

  rc = gFeb->nx(nxind).i2c().getContext(save_cntx, 
                                        nxyter::kDoCore|nxyter::kDoMask);
  print_opererr("NxI2c::getContext {save}", rc);
  if (rc) return 0;                         // quit if save fails...

  nxyter::NxContext cntx;
  cntx.setToDefault(false);                 // all default
  cntx.setChannelMaskBit(0, 127, true);     // all channels off
  cntx.setChannelMaskBit(ch, ch, false);    // except channel ch
  if (ch2 >= 0) {
    cntx.setChannelMaskBit(ch2, ch2, false); // and optionally channel ch2
  }
  cntx.setRegister(nxyter::kNxRegVbiasS, 0);        // VBiasS = 0
  uint8_t config0 = cntx.getRegister(nxyter::kNxRegConfig0);
  cntx.setRegister(nxyter::kNxRegConfig0, 
                   config0 | nxyter::kNxC0TestTrigEnable);

  rc = gFeb->nx(nxind).i2c().setContext(cntx, nxyter::kDoCore|nxyter::kDoMask);
  print_opererr("NxI2c::setContext {setup}", rc);

  gUtil->startLoop(0.);

  uint32_t clkinit[32];
  uint32_t clkbufg[32];

  float ent[128][32];
  float med[128][32];
  float w80[128][32];

  for (int dly=0; dly<32; dly++) {
    clkinit[dly] = 0;
    clkbufg[dly] = 0;
    for (int lat=0; lat<128; lat++) {
      ent[lat][dly] = 0.;
      med[lat][dly] = 0.;
      w80[lat][dly] = 0.;
    }
  }  

  uint32_t save_clkinit;
  uint32_t save_clkbufg;
  uint32_t save_adclat;
  rc = gFeb->adc().getClockDelaySrInit(save_clkinit);
  print_opererr("MainAdc::getClockDelaySrInit {save}", rc);
  rc = gFeb->adc().getClockDelayBufg(save_clkbufg);
  print_opererr("MainAdc::getClockDelayBufg {save}", rc);
  rc = gFeb->adc().getChannelLatency(nxnum, save_adclat);
  print_opererr("MainAdc::getChannelLatency {save}", rc);

  static boost::format fmt_04x("%04x");
  static boost::format fmt_1d("%1d");
  static boost::format fmt_2d("%2d");
  static boost::format fmt_3d("%3d");
  static boost::format fmt_40f("%4.0f");

  if (opt_v) std::cout << "dly lat nhit   med  w50  w80  min  max" << std::endl;

  for (int dly=dbeg; dly<=dend; dly+=dstep) {
    if (!gUtil->testLoop()) break;

    gFeb->adc().setClockDelay(dly);
    rc = gFeb->adc().getClockDelaySrInit(clkinit[dly]);
    print_opererr("MainAdc::getClockDelaySrInit", rc);
    rc = gFeb->adc().getClockDelayBufg(clkbufg[dly]);
    print_opererr("MainAdc::getClockDelayBufg", rc);

    for (int lat=lbeg; lat<=lend; lat+=lstep) {
      if (!gUtil->testLoop()) break;

      rc = gFeb->adc().setChannelLatency(nxnum, lat);
      print_opererr("MainAdc::setChannelLatency", rc);

      nxyter::NxDataSummary nds;
      gUtil->acquireTestTriggerData(nxind, npuls, nds);
      ent[lat][dly] = nds.numEntries(ch);
      med[lat][dly] = nds.getMedian(ch);
      w80[lat][dly] = nds.getWidth80(ch);
      if (opt_v) {
        std::cout << " " << fmt_2d  % dly;
        std::cout << " " << fmt_3d  % lat;
        std::cout << " " << fmt_40f % nds.numEntries(ch);
        std::cout << ((nds.full(ch)) ? '+' : ' ');
        std::cout << " " << fmt_40f % nds.getMedian(ch);
        std::cout << " " << fmt_40f % nds.getWidth50(ch);
        std::cout << " " << fmt_40f % nds.getWidth80(ch);
        std::cout << " " << fmt_40f % nds.getMin(ch);
        std::cout << " " << fmt_40f % nds.getMax(ch);
        std::cout << std::endl;
      }
    }
  }

  rc = gFeb->adc().setClockDelaySrInit(save_clkinit);
  print_opererr("MainAdc::setClockDelaySrInit {restore}", rc);
  rc = gFeb->adc().setClockDelayBufg(save_clkbufg);
  print_opererr("MainAdc::setClockDelayBufg {restore}", rc);
  rc = gFeb->adc().setChannelLatency(nxnum, save_adclat);
  print_opererr("MainAdc::setChannelLatency {restore}", rc);

  if (opt_d) {
    // find warp point for the default case lstep==4 and dstep==1
    // simply search for largest absolute step between neighboring dly's
    int inddmed = -1;
    if (lstep==4 && dstep==1) {
      float maxdmed = 0.;
      for (int dly=dbeg; dly<=dend; dly+=dstep) {
        float absdmed = 0.;
        for (int lat=lbeg; lat<=lend; lat+=2*lstep) {
          absdmed += std::abs(med[lat][dly] - med[lat][(dly+1)%32]);
          if (lat+lstep <= lend) {
            absdmed += std::abs(med[lat+4][(dly+16)%32] - 
                                med[lat+4][(dly+17)%32]);
          }
        }
        if (absdmed > maxdmed) {
          inddmed = dly;
          maxdmed = absdmed;
        }
      }
    }
    
    std::cout << "dly init s  ";
    for (int lat=lbeg; lat<=lend; lat+=lstep) std::cout << " lat=" << fmt_3d % lat;
    std::cout << std::endl;
    
    for (int dly=dbeg; dly<=dend; dly+=dstep) {
      std::cout << " " << fmt_2d  % dly;
      std::cout << " " << fmt_04x % clkinit[dly];
      std::cout << " " << fmt_1d  % clkbufg[dly];
      std::cout << ": ";
      for (int lat=lbeg; lat<=lend; lat+=lstep) {
        std::cout << " " << fmt_40f % med[lat][dly];
        const char* del = "/";
        if (inddmed >= 0) {
          if (((lat-lbeg)%8==0) &&         dly==inddmed) del = "\\";
          if (((lat-lbeg)%8==4) && (dly+16)%32==inddmed) del = "\\";
        }
        std::cout << del;
        int width = int(w80[lat][dly]);
        if (width > 99) width = 99;
        std::cout << fmt_2d % width;
      }
      std::cout << std::endl;
    }

  } else {
    std::cout << "lat :";
    for (int dly=dbeg; dly<=dend; dly+=dstep) std::cout << "   dly=" << fmt_2d % dly;
    std::cout << std::endl;

    for (int lat=lbeg; lat<=lend; lat+=lstep) {
      std::cout << fmt_3d % lat << " :";
      for (int dly=dbeg; dly<=dend; dly+=dstep) {
        std::cout << "  " << fmt_40f % med[lat][dly];
        std::cout << "/";
        int width = int(w80[lat][dly]);
        if (width > 99) width = 99;
        std::cout << fmt_2d % width;
      }
      std::cout << std::endl;
    }
    
  }

  rc = gFeb->nx(nxind).i2c().setContext(save_cntx, 
                                        nxyter::kDoCore|nxyter::kDoMask);
  print_opererr("NxI2c::setContext {restore}", rc);

  return 0;
}

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

int cmd_testrocsync()
{
  bool opt_n  = get_opt("-n");
  bool opt_v  = get_opt("-v");
  int32_t ch=0;
  int32_t scale=5;
  double time=10.;
  if (get_arg(ch, "ch=", 0, 1)) return 1;
  if (get_arg(scale, "scale=", 0, 21)) return 1;
  if (get_arg(time, "time=")) return 1;
  if (args_check(kNeedDaq)) return 1;

  uint64_t nsync = 0;
  uint32_t syncdata_last = 0;
  uint32_t syncdata_inc  = (1<<scale);
  double   synctime_last = -1.;
  double   synctime_inc  = double(1<<(scale+14))/1.e9;
  int ecnt = 0;

  uint32_t syncmask = ~(-(1<<scale));       // mask with scale 1's LSB's

  double dif_avr = 0.;
  double sync_per_sec = 1.e9/(16384.*(1<<scale));//1GHz / 16k / 1<<scale
  double dif_avr_weight = 1./sync_per_sec;
  
  static boost::format fmt_06x("%06x");
  static boost::format fmt_4d("%4d");
  static boost::format fmt_5d("%5d");
  static boost::format fmt_159f("%15.9f");
  static boost::format fmt_63f("%6.3f");
  static boost::format fmt_p102e("%+10.2e");

  gQdaq->startRun(0, time, opt_n);

  while(gQdaq->testRun()) {
    roc::Message& msg = gQdaq->msg();
    if (msg.isSyncMsg()) {
      if (msg.getSyncChNum() != ch) continue;

      uint32_t syncdata = msg.getSyncData();
      uint32_t syncdata_exp = (syncdata_last + syncdata_inc) & 0xffffff;
      double   synctime = gQdaq->getMsgTime();
      double   synctime_exp = synctime_last + synctime_inc;
      double   synctime_dif = synctime - synctime_exp;

      nsync += 1;

      if (opt_v && nsync <= 30) {
        std::cout << get_timestamp("tm");
        std::cout << " @" << fmt_159f % synctime;
        std::cout << ": SYNC ";
        std::cout << " Ts: " << fmt_5d % msg.getSyncTs();
        std::cout << " Data: 0x" <<  fmt_06x % syncdata;
        if (synctime_last >= 0.) {
          std::cout << " delta: " << fmt_4d % int(round(1.e9*synctime_dif));
          std::cout << " ns";
        }
        std::cout << std::endl;
      }

      if ((syncdata & syncmask) != 0) {
        std::cout << get_timestamp("tm");
        std::cout << " @" << fmt_159f % synctime;
        std::cout << ": BAD LSB ERROR";
        std::cout << " data: 0x" << fmt_06x % syncdata;
        std::cout << " expected: 0x" << fmt_06x % syncdata_exp;
        std::cout << std::endl;
        ecnt += 1; 

      } else {

        if (synctime_last>=0.) {            // if not first sync
          if (syncdata != syncdata_exp) {
            int nmiss = syncdata - syncdata_exp;
            if (nmiss < 0) nmiss += 1<<24;
            nmiss = nmiss >> scale;
            std::cout << get_timestamp("tm");
            std::cout << " @" << fmt_159f % synctime;
            std::cout << ": SYNC MISS";
            std::cout << " now: 0x" << fmt_06x % syncdata;
            std::cout << " last: 0x" << fmt_06x % syncdata_last;
            std::cout << " nmiss: " << std::dec << nmiss;
            std::cout << std::endl;
            ecnt += 1;       
          }
          dif_avr = (1.-dif_avr_weight)*dif_avr + dif_avr_weight*synctime_dif;
        }
        
        if (opt_v && ((nsync<<scale) & 0xffff) == 0) {
          std::cout << get_timestamp("tm");
          std::cout << " @" << fmt_159f % synctime;
          std::cout << " : shift: ";
          std::cout << fmt_63f % (1.e9*dif_avr);
          std::cout << " ns/sync";
          std::cout << " drift: " << fmt_p102e % (dif_avr/synctime_inc);
          std::cout << std::endl;
        }
        
        syncdata_last = syncdata;
        synctime_last = synctime;
      }

    } else if (msg.isSysMsg() & msg.getSysMesType() == roc::SYSMSG_SYNC_PARITY) {
      // getMsgTime() returns 0 for system messages...
      // so generate msgtime from last received epoch marker...
      double msgtime = gQdaq->getMsgTime();
      std::cout << get_timestamp("tm");
      std::cout << " @" << fmt_159f % msgtime;
      std::cout << ": SYNC PARITY ERROR";
      std::cout << " data: 0x" << fmt_06x % msg.getSysMesData();
      std::cout << std::endl;
      ecnt += 1;
    }

  }

  if (opt_v || gQdaq->stats().errorCount()>0 ) {
    double dtime = gQdaq->getStopTime() - gQdaq->getStartTime();
    gQdaq->stats().print(std::cout, dtime);
  }
  
  print_daq_stats("testrocsync", nsync, ecnt);

  return 0;
}

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

int cmd_testrocaux()
{
  bool opt_n  = get_opt("-n");
  bool opt_v  = get_opt("-v");
  int32_t ch=2;
  int32_t scale=0;
  double time=10.;
  if (get_arg(ch, "ch=", 0, 3)) return 1;
  if (get_arg(scale, "scale=", 0, 11)) return 1;
  if (get_arg(time, "time=")) return 1;
  if (args_check(kNeedDaq)) return 1;

  uint64_t naux_re = 0;
  uint64_t naux_fe = 0;
  double   auxtime_re_last = -1.;
  double   auxtime_re_inc  = 31.25e-9*65536./(1<<scale);  // 31.25ns*64k/2^scale
  int      pw_last = -1;
  int ecnt = 0;

  static boost::format fmt_5d("%5d");
  static boost::format fmt_6d("%6d");
  static boost::format fmt_159f("%15.9f");
  static boost::format fmt_30f("%3.0f");
  static boost::format fmt_70f("%7.0f");

  gQdaq->startRun(0, time, opt_n);

  while(gQdaq->testRun()) {
    roc::Message& msg = gQdaq->msg();
    if (msg.isAuxMsg()) {
      if (msg.getAuxChNum() != ch) continue;

      double auxtime = gQdaq->getMsgTime();
      double dtime = auxtime-auxtime_re_last;
      int   nclock = int(round(dtime/31.25e-9)); // 32 MHz clock on SysGlue

      if (opt_v && (naux_re <= 20 || naux_fe <= 20)) {
        std::cout << get_timestamp("tm");
        std::cout << " @" << fmt_159f % auxtime;
        std::cout << ": AUX ";
        std::cout << " Ts: " << fmt_5d % msg.getAuxTs();
        if (auxtime_re_last >= 0.) {
          if (!msg.getAuxFalling()) {      // re
            std::cout << " rise, peri: ";
          } else {                          // fe
            std::cout << " fall, wdth: ";
          }
          std::cout << fmt_70f % (dtime*1.e9);
          std::cout << " ns";
          std::cout << fmt_6d % nclock;
          std::cout << " clk";
        }
        std::cout << std::endl;
      }

      if (!msg.getAuxFalling()) {          // re
        naux_re += 1;
        if (auxtime_re_last >=0.) {
          double dterr = dtime-auxtime_re_inc;
          double relerrlimit = 5.e-5;
          double dttol = auxtime_re_inc*relerrlimit;
          if (dttol < 10.e-9) dttol = 10.e-9;
          if (std::abs(dterr) > dttol) {
            std::cout << get_timestamp("tm");
            std::cout << " @" << fmt_159f % auxtime;
            std::cout << ": AUX ERROR PERI: ";
            std::cout << fmt_70f % (dtime*1.e9);
            std::cout << " ns exp: " << fmt_70f % (auxtime_re_inc*1.e9);
            std::cout << "+-" << fmt_30f % (dttol*1.e9);
            std::cout << " ns" << std::endl;
            ecnt += 1;
          }
        }
        auxtime_re_last = auxtime;

      } else {                              // fe
        naux_fe += 1;
        if (auxtime_re_last >= 0.) {
          if (pw_last >= 0) {
            int pw_exp = (pw_last & 0xf) + 1;
            if (nclock != pw_exp) {
            std::cout << get_timestamp("tm");
            std::cout << " @" << fmt_159f % auxtime;
            std::cout << ": AUX ERROR WDTH: ";
            std::cout << fmt_70f % (dtime*1.e9);
            std::cout << " ns exp: " << fmt_70f % (pw_exp*31.25);
            std::cout << "+- 14 ns" << std::endl;
            ecnt += 1;
            }
          }
          pw_last = nclock;
        }
      }
      
    }

  }

  if (opt_v || gQdaq->stats().errorCount()>0 ) {
    double dtime = gQdaq->getStopTime() - gQdaq->getStartTime();
    gQdaq->stats().print(std::cout, dtime);
  }
  
  print_daq_stats("testrocaux", naux_re, ecnt);

  return 0;
}

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

int cmd_testnxcntl()
{
  int32_t nxbeg=0;
  int32_t nxend=0;
  double time=10.;
  if (get_nxrange(nxbeg, nxend)) return 1;
  if (get_arg(time, "time=")) return 1;
  if (args_check(kNeedFeb)) return 1;

  for (int i=nxbeg; i<=nxend; i++) {
    if (check_nxoffline(i, nxbeg, nxend)) continue; // skip of offline
    if (nxend!=nxbeg) std::cout << "Test nx:" << i << std::endl;
    int ecnt = gUtil->testNxControlPath(i, time);
    print_loop_stats("testnxcntl", ecnt);
    if (gUtil->getLoopState()==nxyter::FebUtil::kLoopInterrupted) break;
  }
  return 0;
}

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

int cmd_testnxregs()
{
  int32_t nxbeg=0;
  int32_t nxend=0;
  if (get_nxrange(nxbeg, nxend)) return 1;
  if (args_check(kNeedFeb)) return 1;

  for (int i=nxbeg; i<=nxend; i++) {
    if (check_nxoffline(i, nxbeg, nxend)) continue; // skip of offline
    if (nxend!=nxbeg) std::cout << "Test nx:" << i << std::endl;
    int ecnt = gUtil->testNxRegisters(i);
    print_loop_stats("testnxregs", ecnt);
    if (gUtil->getLoopState()==nxyter::FebUtil::kLoopInterrupted) break;
  }
  return 0;
}

//----------------------------------------------------------------------------
int cmd_testadccntl()
{
  double time=10.;
  if (get_arg(time, "time=")) return 1;
  if (args_check(kNeedFeb)) return 1;

  int ecnt = gUtil->testMainAdcControlPath(time);
  print_loop_stats("testadccntl", ecnt);
  return 0;
}

//----------------------------------------------------------------------------
int cmd_testadcdata()
{
  double time=10.;
  if (get_arg(time, "time=")) return 1;
  if (args_check(kNeedFeb)) return 1;

  int ecnt = gUtil->testMainAdcDataPath(time);
  print_loop_stats("testadcdata", ecnt);
  return 0;
}

//----------------------------------------------------------------------------
int cmd_testfebcntl()
{
  double time=10.;
  if (get_arg(time, "time=")) return 1;
  if (args_check(kNeedFeb)) return 1;

  int ecnt = gUtil->testFebControlPathCombo(time);
  print_loop_stats("testfebcntl", ecnt);
  return 0;
}

//----------------------------------------------------------------------------
int cmd_printdata()
{
   bool opt_m  = get_opt("-m");
   bool opt_r  = get_opt("-r");
   bool opt_h  = get_opt("-h");
   bool opt_t  = get_opt("-t");
   bool opt_s  = get_opt("-s");
   bool opt_d  = get_opt("-d");
   bool opt_n  = get_opt("-n");
   bool opt_ia = get_opt("-ia");
   int32_t nmsg=-1;
   double time=-1.;
   int32_t npuls=0;
   int32_t pper=100000;
   int32_t pwth=32;
   int32_t pdly=1000;
   if (get_arg(nmsg,  "nmsg=", 0)) return 1;
   if (get_arg(time,  "time=")) return 1;
   if (get_arg(npuls, "npuls=", 0, 32767)) return 1;
   if (get_arg(pper,  "pper=", 2, 0x00ffffff)) return 1;
   if (get_arg(pwth,  "pwth=", -0x00ffffff, 0x00ffffff)) return 1;
   if (get_arg(pdly,  "pdly=", 1, 0x0000ffff)) return 1;
   if (args_check(kNeedDaq)) return 1;

   if (nmsg < 0 && time < 0.) {              // neither nmsg nor time specified
      if (gBaseBoard->isFile()) {
         nmsg = 0;
         time = 0.;
      } else {
         nmsg = 100;
         time = 10.;
      }
   }
   if (nmsg < 0) nmsg = 0;
   if (time < 0) time = 0.;

   if (!(opt_s | opt_d)) opt_m = true;       // assume -m if no -s or -d

   int rc;

   if (gRocNx && (npuls > 0)) {                          // test pulser requested ?
      if (opt_ia) {
         rc = gRocNx->fireTestPulse(0,0,0);      // if init-after just stop it
         print_opererr("RocNx::fireTestPulse", rc);
      } else {
         rc = gRocNx->fireTestPulse(pdly, pper, pwth, npuls); // or setup train
         print_opererr("RocNx::fireTestPulse", rc);
      }
   }

   gQdaq->startRun(nmsg, time, opt_n);

   if (opt_ia && gRocNx) {
      if (npuls > 0) {
         rc = gRocNx->fireTestPulse(pdly, pper, pwth, npuls); // setup pulse train
         print_opererr("RocNx::fireTestPulse", rc);
      }
      rc = gRocNx->resetRocNxTs();
      print_opererr("RocNx::resetRocNxTs", rc);
   }

   typedef std::auto_ptr<nxyter::DistFuncArray> ptr_dfa;
   ptr_dfa dfa[4];
   if (opt_d) {
      for (int i=0; i<4; i++)
         dfa[i] = ptr_dfa(new nxyter::DistFuncArray(128, 512));
   }

   // limit stats to 100k entries/channel
   // that will consume at most 4*128*4*100k = 200 MByte
   const static int nentmax = 100000;

   while(gQdaq->testRun()) {
      roc::Message& msg = gQdaq->msg();
      if (opt_m) {
         if (opt_t) std::cout << get_timestamp("tm") << ": ";
         unsigned kind = roc::msg_print_Human;
         if (opt_r) kind  = roc::msg_print_Prefix | roc::msg_print_Data;
         if (opt_h) kind |= roc::msg_print_Hex;
         msg.printData(std::cout, kind, gQdaq->getMsgEpoch());
      }

      if (opt_d) {
         if (msg.isHitMsg()) {
            int nxnum = msg.getNxNumber();
            int nxcha = msg.getNxChNum();
            int nxadc = msg.getNxAdcValue();
            if ((*dfa[nxnum])[nxcha].numEntries() < nentmax) {
               (*dfa[nxnum]).addEntry(nxcha, float(nxadc));
            }
         }
      }
   }

   if (gRocNx && (npuls > 0)) {
      rc = gRocNx->fireTestPulse(0,0,0);      // stop and disable pulser
      print_opererr("RocNx::fireTestPulse", rc);
   }

   if (opt_d) {
      for (int nxnum=0; nxnum<4; nxnum++) {
         if ((*dfa[nxnum]).numEntries() == 0) continue;
         nxyter::NxDataSummary nds;
         nds.analyse((*dfa[nxnum]));
         nds.print(std::cout, nxnum);
      }
   }

   double dtime = gQdaq->getStopTime() - gQdaq->getStartTime();
   gQdaq->stats().print(std::cout, dtime);

   return 0;
}

//----------------------------------------------------------------------------
// helper for cmd_autoped
// this is a temporary hack, to be removed when ROC hardware support is added.

int autoped_issue_system_message(uint32_t type)
{
  int rc = gRocBoard->operPPP(
        ROC_NX_FIFO_RESET, 1,   // and flush fifo
        ROC_NX_FIFO_RESET, 0,
        ROC_ADDSYSMSG, type ); // insert sysmsg
  print_opererr("operPPP(ROC_ADDSYSMSG,...)", rc);
  return rc;
}

//----------------------------------------------------------------------------
// helper for cmd_autoped

int autoped_setnxmode(bool testtrig)
{
  int32_t nxbeg = 0;
  int32_t nxend = gFeb->numNx()-1;
  int rc = 0;

  for (int i=nxbeg; i<=nxend; i++) {
    if (check_nxoffline(i, nxbeg, nxend)) continue; // skip of offline
    rc = gFeb->nx(i).i2c().setTestModes(false, testtrig, 0);
    print_opererr("NxI2c::setTestModes", rc);
  }

  return rc;
}

//----------------------------------------------------------------------------
int cmd_autoped()
{
  double tmeas=30.;
  double tped=0.1;
  if (get_arg(tmeas, "tmeas=")) return 1;
  if (get_arg(tped,  "tped=")) return 1;
  if (args_check(kNeedFeb)) return 1;

  if (tmeas < 0.1 || tped < 0.05) {
    std::cout << "rocutil-E: tmeas or tped out of range" << std::endl;
    return 1;
  }

  int rc;

  // setup AUX2
  uint32_t gpio_mask_save;
  rc = gGpio->getConfig(gpio_mask_save);
  print_opererr("Gpio::getConfig", rc);
  bool riseedge, falledge, throttled, extrafunc, altin;
  base::Gpio::unpackConfig(gpio_mask_save, 6,
                     riseedge, falledge, throttled, extrafunc, altin);

  extrafunc = true;
  altin     = true;
  uint32_t gpio_mask_on = gpio_mask_save;
  base::Gpio::packConfig(gpio_mask_on, 6,
                   riseedge, falledge, throttled, extrafunc, altin);

  extrafunc = false;
  altin     = false;
  uint32_t gpio_mask_off = gpio_mask_save;
  base::Gpio::packConfig(gpio_mask_off, 6,
                   riseedge, falledge, throttled, extrafunc, altin);


  // setup test pulse generator
  int32_t period=250000;                    // 1 khz
  rc = gRocNx->fireTestPulse(period, 128, 0);
  print_opererr("RocNx::fireTestPulse", rc);

  int imeas = (int) ((tmeas + 0.0999) / 0.1);

  struct timespec ts_tmeas;
  uint64_t itmeas = (uint64_t) (1.e9*tmeas);     // tmeas in ns
  ts_tmeas.tv_sec  = itmeas / (1000*1000*1000);
  ts_tmeas.tv_nsec = itmeas % (1000*1000*1000);

  struct timespec ts_tped;
  uint64_t itped = (uint64_t) (1.e9*tped);     // tped in ns
  ts_tped.tv_sec  = itped / (1000*1000*1000);
  ts_tped.tv_nsec = itped % (1000*1000*1000);

  gUtil->startLoop(0.);
  while (true) {
    // switch for pedestal taking mode
    autoped_issue_system_message(roc::SYSMSG_USER_RECONFIGURE);
    autoped_setnxmode(true);
    rc = gGpio->setConfig(gpio_mask_on);
    print_opererr("Gpio::setConfig{ped_on}", rc);
    autoped_issue_system_message(roc::SYSMSG_USER_CALIBR_ON);
    
    // do pedestal taking
    std::cout << get_timestamp() << " +++1a before tped  wait" << std::endl;
    nanosleep(&ts_tped, 0);
    std::cout << get_timestamp() << " +++1b after  tped  wait" << std::endl;

    // switch back to data taking mode
    autoped_issue_system_message(roc::SYSMSG_USER_RECONFIGURE);
    rc = gGpio->setConfig(gpio_mask_off);
    print_opererr("Gpio::setConfig{ped_off}", rc);
    autoped_setnxmode(false);
    autoped_issue_system_message(roc::SYSMSG_USER_CALIBR_OFF);

    // do data taking
    if (!gUtil->testLoop()) break;
    std::cout << get_timestamp() << " +++1c before tmeas wait" << std::endl;
    nanosleep(&ts_tmeas, 0);
    std::cout << get_timestamp() << " +++1d after  tmeas wait" << std::endl;
    if (!gUtil->testLoop()) break;
  }

  rc = gGpio->setConfig(gpio_mask_save);
  print_opererr("Gpio::setConfig{restore}", rc);

  // stop test pulse generator
  rc = gRocNx->fireTestPulse(0, 0, 0);
  print_opererr("RocNx::fireTestPulse", rc);

  return 0;
}

//----------------------------------------------------------------------------
int cmd_testnxdata()
{
  std::cout << "currently deactivated" << std::endl;

#ifdef never  
  bool opt_p = get_opt("-p");
  bool opt_r = get_opt("-r");
  bool opt_s = get_opt("-s");
  double time=10.;
  if (get_arg(time, "time=")) return 1;
  if (args_check(kNeedFeb|kNeedDaq)) return 1;

  int rc;
  rc = gFeb->setToDefault();
  if (print_opererr("FebBase::setToDefault", rc)) return 0;

  for (int i=0; i<16; i++) {
    rc = gFeb->setNxRegisterAll(i,0xff);
    if (print_opererr("FebBase::setNxRegisterAll", rc)) return 0;
  }

  rc = gFeb->setNxRegisterAll(1,0xf0);
  if (print_opererr("FebBase::setNxRegisterAll", rc)) return 0;

  rc = gFeb->setNxTestModes(false, true, 0); // use test trigger mode
  if (print_opererr("FebBase::setNxTestModes", rc)) return 0;

  nxyter::QuickDaq qd(gRocBoard, gFeb);

  qd.startRun(0, time);

  rc = gRocNx->fireTestPulse(100000, 50000, 0); // use 2.5 kHz pulse rate
  print_opererr("RocNx::fireTestPulse", rc);

  gUtil->startLoop(time+2.);

  double npulslast = -1.;
  int nhit         =  4;
  double tsbase    = -1.;

  int numnx = gFeb->numNx();

  // FIXME, logic now different !!
  nxyter::Data data;
  while(gUtil->testLoop()) {
    int rc = qd.getData(data);              // get data
    if (rc) break;                          // if end-of-run quit
    if (msg.isNopMsg()) continue;          //  if nop ignore
    if (opt_p) msg.printData(std::cout, opt_r ? 3 : 8, qd.getEpoch());
    if (msg.isHitMsg()) {
      int nxnum = msg.getNxNumber();
      int nxchn = msg.getNxChNum();
      double ts = msg.getMsgFullTime(qd.getEpoch())*1.e-9;
      if (tsbase < 0.) tsbase = ts;

      double npuls = floor((2500. * (ts - tsbase)) + 0.5);
      double tsoffset = ts - (tsbase + npuls/2500.);

      if (opt_p) {
        static boost::format fmt("Nx:%|1| Chn:%|3| puls: %|6.0f| offset:%|3.0f|");
        std::cout << fmt % nxnum % nxchn % npuls % (1.e9*tsoffset) << std::endl;
      }

      if (npuls != npulslast) {
        if (tsoffset < -4.e-9 || tsoffset > +4.e-9) {
          std::cout << "outlayer hit, offset " << int(1.e9*tsoffset) 
               << "ns" << std::endl;
          msg.printData(std::cout, opt_r ? 3 : 8, qd.getEpoch());
        }
        if (nhit != 4*numnx) {
          std::cout << "last pulse has != 4*numnx hits, nhit = " << nhit << std::endl;
        }
        if (npuls != npulslast + 1.) {
          std::cout << "pulses missing, now " << int(npuls)
               << " last was " << int(npulslast) << std::endl;
        }
        nhit = 0;
        npulslast = npuls;
      }

      nhit += 1;

    }
  }
  
  if (opt_s) qd.getStats().print(std::cout);
  // show errors in case not -s !!

  rc = gRocNx->fireTestPulse(0, 0, 0);          // stop pulser
  print_opererr("RocNx::fireTestPulse", rc);
#endif

  return 0;
}

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

int cmd_saverocconf()
{
  if (args_check(kNeedRocBoard)) return 1;

  roc::UdpBoard* udp = dynamic_cast<roc::UdpBoard*> (gRocBoard);
  if (udp) {
    udp->saveConfig();
  } else {
    std::cout << "rocutil-E: only supported for 'ROC-over-Ethernet'" << std::endl;
  }
  
  return 0;
}

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

int cmd_restartbrd()
{
  if (args_check(kNeedBoard)) return 1;

  std::cout << "rocutil-I: Board self-destruct initiated, have a nice day :)" << std::endl;
  gBaseBoard->restartBoard();
  std::cout << "rocutil-I: restart rocutil when board back on-line" << std::endl;
  std::cout << "rocutil-I: use 'setbrddef' command to initialize board" << std::endl;

  return -2;
}

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

int cmd_printrocmap()
{
   bool byname = get_opt("-n");
   if (args_check(kNeedBoard)) return 1;
   gBaseBoard->printRegAddressMap(std::cout, byname);
   return 0;
}


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

int cmd_putroc()
{
  std::string sname;
  int32_t val;
  if (get_arg(sname, 0)) return 1;
  if (get_arg(val, 0)) return 1;
  if (args_check(kNeedBoard)) return 1;

  uint32_t addr = gBaseBoard->findRegAddressByName(sname.c_str());

  if (addr==base::Board::kAddrError) {
     const char* cstr = sname.c_str();
     char* eptr(0);
     int base(0);

     if (cstr[0]=='b' || cstr[0]=='B') { cstr += 1; base = 2; }
     addr = strtol(cstr, &eptr, base);
     if (errno || (eptr && (*eptr!=0))) {
        std::cout << "Board address '" << sname << "' not known" << std::endl;
        return 0;
     }
  }

  uint32_t value = uint32_t(val);
  int rc = gBaseBoard->put(addr, value);
  print_opererr("Board::put", rc);
  if (rc==0) {
     static boost::format fmt("put(%s [0x%08x]) -> 0x%08x  %10d");
     std::cout << fmt % sname % addr % value % value << std::endl;
  }
  return 0;
}

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

int cmd_getroc()
{
  std::string sname;
  if (get_arg(sname, 0)) return 1;
  if (args_check(kNeedBoard)) return 1;

  uint32_t addr = gBaseBoard->findRegAddressByName(sname.c_str());
  if (addr==base::Board::kAddrError) {
     const char* cstr = sname.c_str();
     char* eptr(0);
     int base(0);

     if (cstr[0]=='b' || cstr[0]=='B') { cstr += 1; base = 2; }
     addr = strtol(cstr, &eptr, base);
     if (errno || (eptr && (*eptr!=0))) {
        std::cout << "Board address '" << sname << "' not known" << std::endl;
        return 0;
     }
  }

  uint32_t value;
  int rc = gBaseBoard->get(addr, value);
  if (rc==0) {
    static boost::format fmt("get(%s [0x%08x]) -> 0x%08x %10d");
    std::cout << fmt % sname % addr % value % value  << std::endl;
  }
  print_opererr("Board::get", rc);
  return 0;
}

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

int cmd_resetrocnxts()
{
   if (gRocNx==0) return 1;
   int rc = gRocNx->resetRocNxTs();
   print_opererr("RocNx::resetRocNxTs", rc);
   return 0;
}


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

int cmd_printdatadbg()
{
  bool    opt_c  = get_opt("-c");
  bool    opt_ib = get_opt("-ib");
  bool    opt_ia = get_opt("-ia");
  int32_t nmsg=100;
  double  time=1.;
  if (get_arg(nmsg, "nmsg=", 1)) return 1;
  if (get_arg(time, "time=")) return 1;
  if (args_check(kNeedDaq)) return 1;

  std::vector<nxyter::DataDebug> datvec;

  int rc = gRocNx->setDebugMode(1);
  print_opererr("RocNx::setDebugMode", rc);

  gUtil->startLoop(time);
  int nempty = 0;

  if (opt_ib) {
    rc = gRocNx->resetRocNxTs();
    print_opererr("RocNx::resetRocNxTs", rc);
  }

  if (opt_c)  gRocBoard->clearRocFifo();

  if (opt_ia) {
    rc = gRocNx->resetRocNxTs();
    print_opererr("RocNx::resetRocNxTs", rc);
  }
  
  std::cout << "getDataDebug(): ";
  while(gUtil->testLoop() && datvec.size() < nmsg) {
    rc = gRocNx->getDataDebug(datvec, nmsg-datvec.size());
    if (rc < 0) {
      std::cout << "getDataDebug(): bail-out with rc=" << rc << std::endl;
      break;
    }
    if (rc >0) {
      if (nempty > 0) std::cout << "(" << nempty << ") ";
      std::cout << rc << " ";
      nempty = 0;
    } else {
      nempty += 1;
    }
  }
  std::cout << std::endl;

  rc = gRocNx->setDebugMode(0);
  print_opererr("RocNx::setDebugMode", rc);

  for (int i=0; i<datvec.size(); i++) {
    datvec[i].print(std::cout);
  }

  return 0;
}


void acquire_data( int nxind, std::vector<std::vector<float> > & data, float time )
{
        if( data.size() != 128 ) {
                printf("Error in acquire_data: data must be vector[128][4096] of floats\n");
                return;
        }
        for( int iChannel = 0; iChannel < 128; iChannel++ ) {
                if( data.at(iChannel).size() != 4096 ) {
                        printf("Error in acquire_data: data must be vector[128][4096] of floats\n");
                        return;
                }
                data.at(iChannel).assign( 4096, 0. );
        }

        gQdaq->startRun( 0, time, true );

        while( gQdaq->testRun() ) {
                roc::Message & msg = gQdaq->msg();

                if( msg.isHitMsg() ) {
                        int num = msg.getNxNumber();
                        if (num != nxind) {
                                printf("Error in acquire_data: hit from nXYTER %d received, while not expected\n", num);
                        }
                        uint8_t ch = msg.getNxChNum();
                        uint16_t adcVal = msg.getNxAdcValue();
                        data.at(ch).at(adcVal)++;
                }
        }
        if (gQdaq->stats().errorCount()) {
                gQdaq->stats().print(std::cout, 0., nxyter::QuickDaqStats::kPrintError);
        }
}

//----------------------------------------------------------------------------
void acquire_data(int nxind, std::vector<int> & nhits, float time)
{
        if( nhits.size() != 128 ) {
                printf("Error in count_pulses: npulses is expected to be 128 in size\n");
                return;
        }
        nhits.assign( 128, 0 );

        gQdaq->startRun( 0, time, true );

        while( gQdaq->testRun() ) {
                roc::Message & msg = gQdaq->msg();

                if( msg.isHitMsg() ) {
                        int num = msg.getNxNumber();
                        if (num != nxind) {
                                printf("Error in acquire_data: hit from nXYTER %d received, while not expected\n", num);
                        }
                        int ch = msg.getNxChNum();
                        nhits.at(ch)++;
                }
        }
        if (gQdaq->stats().errorCount()) {
                gQdaq->stats().print(std::cout, 0., nxyter::QuickDaqStats::kPrintError);
        }
}


void autotrim_print_rates(const std::vector<int> & npulses, double time )
{
        printf("    -- -- -- -- -- -- -- -- -- -- -- Rates per channel -- -- -- -- -- -- -- -- -- -- --\n");
        for( int i=0; i < 16; i++ ) {
                printf("     %3d..%-3d:", i*8, i*8 + 7);
                for( int j=0; j < 8; j++ ) {
                        printf( "%9.1f", static_cast<float>( npulses.at(i*8 + j) ) / time );
                }
                printf("\n");
        }
        printf("    -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --\n");
}

void autotrim_print_trim(const nxyter::NxContext & cntx_trim)
{
        printf("    -- -- -- -- -- -- -- -- -- -- -- -- Trim values -- -- -- -- -- -- -- -- -- -- -- --\n");
        for( int i = 0; i < 16; i++ ) {
                printf("     %3d..%-3d:", i*8, i*8 + 7);
                for( int j = 0; j < 8; j++ ) {
                        int ch = i * 8 + j;
                        printf("%9d", cntx_trim.getThresholdTrim(ch));
                }
                printf("\n");
        }
        printf("    -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --\n");
}

void autotrim_print_trim_dbg(const nxyter::NxContext & cntx_trim, const std::vector<int> & trim_min, const std::vector<int> & trim_max )
{
        printf("    -- -- -- -- -- -- -- -- -- -- -- -- Trim values -- -- -- -- -- -- -- -- -- -- -- --\n");
        for( int i = 0; i < 16; i++ ) {
                printf("     %3d..%-3d:", i*8, i*8 + 7);
                for( int j = 0; j < 8; j++ ) {
                        int ch = i * 8 + j;
                        printf("%2d(%2d-%2d)", cntx_trim.getThresholdTrim(ch), trim_min.at(ch), trim_max.at(ch));
                }
                printf("\n");
        }
        printf("    -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --\n");
}

float get_npuls_avg( const std::vector< int > & npuls, int nchactive )
{
        int npuls_tot = 0;
        for( int ch = 0; ch < npuls.size(); ch++ ) {
                npuls_tot += npuls[ch];
        }
        return static_cast<float>( npuls_tot ) / nchactive;
}




//----------------------------------------------------------------------------
int cmd_autotrim()
{
        const int knch = 128; // nXYTER number of channels
        int gainsign_vth = 1; // 1, if physical threshold increase with the vth register value, -1 otherwise
        int gainsign_trim = -1; // 1, if physical threshold increase with the trim register value, -1 otherwise
        bool posgain_vth = true;
        bool posgain_trim = false;

        // *** process arguments and prerequisites ***:
        bool opt_k = get_opt("-k");
        bool opt_m = get_opt("-m");
        bool opt_q = get_opt("-q");
        bool opt_t = get_opt("-t");


        int32_t nxbeg=0;
        int32_t nxend=0;
        if (get_nxrange(nxbeg, nxend)) return 1;

        double rate;
        if (get_arg(rate)) return 1;

        double time = 4;
        if (get_arg(time,"time=")) return 1;
        if( time < 0. ) {
                printf("ERROR in cmd_autotrim: time must be larger than 0.\n");
                return 1;
        }

        int32_t vth_range_min = 20;
        if (get_arg(vth_range_min, "vth_min=", 0, 255)) return 1;

        int32_t vth_range_max = 255;
        if (get_arg(vth_range_max, "vth_max=", 1, 255)) return 1;
        if( vth_range_max < vth_range_min ) {
                printf("ERROR in cmd_autotrim: vth_max must be larger than vth_min\n");
                return 1;
        }

        double target = 0.5;
        if (get_arg(target, "target=")) return 1;
        if( target < 0. || target > 1.) {
                printf("ERROR in cmd_autotrim: target must be within ( 0. ; 1. ) range \n");
                return 1;
        }

        if (args_check(kNeedFeb|kNeedDaq)) return 1;

        //      printf("nxbeg=%d nxend=%d\n",nxbeg,nxend);
        //      printf("rate=%lf\n",rate);
        //      printf("time=%lf\n",time);
        //      printf("vth_min=%d vth_max=%d\n",vth_min, vth_max);
        //      printf("target=%lf\n",target);
        //      printf("arguments processed successfully\n");
        //      return 0;

        for( int nxind = nxbeg; nxind <= nxend; nxind++ ) {

                // *** remember initial value of vth ***
                int rc;
                uint8_t vth_init;
                rc = gFeb->nx(nxind).i2c().getRegister(nxyter::kNxRegVth, vth_init);
                print_opererr("getRegister(kNxRegVth,...)", rc);

                // *** get list of masked channels ***
                nxyter::NxContext mask_cntx;
                rc = gFeb->nx(nxind).i2c().getContext(mask_cntx, nxyter::kDoMask);

                // *** get number of active channels ***
                int nchactive = 0;
                for( int ch = 0; ch < knch; ch++ ) {
                        nchactive += ( ! mask_cntx.getChannelMaskBit(ch) );
                }

                // *** read trim values ***
                nxyter::NxContext cntx_trim;
                rc = gFeb->nx(nxind).i2c().getContext(cntx_trim, nxyter::kDoTrim);
                print_opererr("GetContext(cntx_trim,...)", rc);

                std::vector< int > npuls( knch );
                float npuls_exp = rate * time;
                if( opt_m ) {
                        if( ! opt_q ) printf("Measuring efficiency at vth=%d, and with trim values:\n", vth_init);
                        if( ! opt_q ) autotrim_print_trim(cntx_trim);
                        acquire_data( nxind, npuls, time );
                        if( ! opt_q ) autotrim_print_rates( npuls, time );
                        if( ! opt_q ) printf( "Average efficiency: %f\n", get_npuls_avg( npuls, nchactive ) / npuls_exp );
                        return 0;
                }

                // *** reset trim values ***
                if( ! opt_q ) printf("Setting trim to 16 in all channels...\n");
                nxyter::NxContext cntx_trim_reset;
                cntx_trim_reset.setThresholdTrim(0, knch - 1, 16, 1);
                rc = gFeb->nx(nxind).i2c().setContext(cntx_trim_reset, nxyter::kDoTrim);
                print_opererr("SetContext(cntx_trim_reset,...)", rc);

                if( ! opt_t ) {
                        // *** adjust vth to 50% detection efficiency in average within the chip ***
                        if( ! opt_q ) printf("Start adjusting vth to average detection efficiency of %f\n", target);

                        uint8_t vth_step = 0;
                        int vth_step_prev_signed = 0;
                        uint8_t vth_curr = vth_init;
                        uint8_t vth_prev = 0;

                        {
                                bool first = true;
                                float eff_curr = 0;
                                float eff_prev = 0;
                                float diff_curr = 0;
                                float diff_prev = 0;
                                int vth_step_sign = 0;
                                while( true ) {

                                        // *** remember previous results ***
                                        if( ! first ) {
                                                eff_prev = eff_curr;
                                                diff_prev = diff_curr;
                                        }
                                        // *** remember the previous step ***
                                        vth_step_prev_signed = vth_step * vth_step_sign;

                                        // *** measure the rate ***
                                        if( ! opt_q ) printf("Measuring efficiency at vth=%d...\n", vth_curr);
                                        acquire_data( nxind, npuls, time );
                                        if( ! opt_q ) autotrim_print_rates( npuls, time );
                                        eff_curr = get_npuls_avg( npuls, nchactive ) / npuls_exp;
                                        if( ! opt_q ) printf( "Average efficiency: %f\n", eff_curr );
                                        diff_curr = std::abs( target - eff_curr );

                                        // *** check if the efficiency changes in the expected direction ***
                                        if( ! first ) {
                                                if( ( eff_prev > eff_curr) != ( (vth_step_sign > 0) == posgain_vth )  ) {
                                                        printf("WARNING: detection efficiency changes in the same direction as physical threshold -- system is not stable. Try to increase the measurement time?\n");
                                                }
                                        }

                                        // *** evaluate the sign of the next vth step ***
                                        if( ( eff_curr > target) == posgain_vth ) {
                                                vth_step_sign = 1; }
                                        else {
                                                vth_step_sign = -1;
                                        }

                                        // *** evaluate the magnitude of the next vth step ***
                                        if( first ) {
                                                if( vth_step_sign > 0 ) {
                                                        vth_step = vth_range_max - vth_curr;
                                                }
                                                else {
                                                        vth_step = vth_curr - vth_range_min;
                                                }
                                        }
                                        vth_step = vth_step / 2 + vth_step % 2;

                                        // *** check if the step is within the vth range ***
                                        int vth_prelim =  vth_curr + vth_step * vth_step_sign;
                                        if( vth_prelim > vth_range_max || vth_prelim < vth_range_min ) {
                                                printf("ERROR: target efficiency can not be reached with vth within the specified range\n");
                                                return 1;
                                        }

                                        // *** check if converged ***
                                        if( ! first ) {
                                                if( vth_step == 1 && vth_step_sign == - vth_step_prev_signed ) {
                                                        if( diff_prev < diff_curr ) {
                                                                vth_curr = vth_prev;
                                                                rc = gFeb->nx(nxind).i2c().setRegister(nxyter::kNxRegVth, vth_curr, true);
                                                                print_opererr("setRegister(kNxRegVth,...)", rc);
                                                        }
                                                        break;
                                                }
                                        }

                                        // *** make the step in vth ***
                                        vth_prev = vth_curr;
                                        vth_curr = vth_curr + vth_step * vth_step_sign;
                                        rc = gFeb->nx(nxind).i2c().setRegister(nxyter::kNxRegVth, vth_curr, true);
                                        print_opererr("setRegister(kNxRegVth,...)", rc);

                                        first = false;
                                }
                                if( ! opt_q ) printf("Finished with vth=%d\n", vth_curr);
                        }
                }

                // *** adjust threshold trim ***
                if( ! opt_q ) printf("Start trimming the thresholds\n");

                std::vector<int> trim_step(128, 16);
                std::vector<int> trim_step_sign(128, 0);
                std::vector<int> trim_step_prev_signed(128, 0);
                std::vector<float> eff_curr(128, 0);
                std::vector<float> eff_prev(128, 0);
                std::vector<float> diff_curr(128, 0);
                std::vector<float> diff_prev(128, 0);

                bool first = true;

                nxyter::NxContext cntx_trim_prev( cntx_trim );

                while( 1 ) {

                        // *** evaluate the detection efficiencies ***
                        for( int ch = 0; ch < knch; ch++ ) {
                                if( ! mask_cntx.getChannelMaskBit(ch) ) {
                                        eff_prev.at(ch) = eff_curr.at(ch);
                                        eff_curr.at(ch) = npuls.at(ch) / npuls_exp;
                                        diff_prev.at(ch) = diff_curr.at(ch);
                                        diff_curr.at(ch) = std::abs( target - eff_curr.at(ch) );
                                }
                        }

                        // *** remember the previous trim step ***
                        for( int ch = 0; ch < knch; ch++ ) {
                                if( ! mask_cntx.getChannelMaskBit(ch) ) {
                                        trim_step_prev_signed.at(ch) = trim_step.at(ch) * trim_step_sign.at(ch);
                                }
                        }

                        // *** check if the rate changes in the expected direction ***
                        for( int ch = 0; ch < knch; ch++ ) {
                                if( ! mask_cntx.getChannelMaskBit(ch) ) {
                                        if( trim_step_prev_signed.at(ch) != 0 ) {
                                                if( ( eff_curr.at(ch) < eff_prev.at(ch) ) != ( ( trim_step_prev_signed.at(ch) > 0 ) == posgain_trim ) ) {
                                                        printf("WARNING: In channel %d detection efficiency changes in the same direction as physical threshold -- system is not stable. Try to increase the measurement time?\n", ch);
                                                }
                                        }
                                }
                        }

                        // *** evaluate the sign of the next trim step ***
                        for( int ch = 0; ch < knch; ch++ ) {
                                if( ! mask_cntx.getChannelMaskBit(ch) ) {
                                        if( ( eff_curr.at(ch) > target ) == posgain_trim ) {
                                                trim_step_sign.at(ch) = 1;
                                        }
                                        else {
                                                trim_step_sign.at(ch) = -1;
                                        }
                                        // printf("Ch=%d, trim_step_sign=%d\n", ch, trim_step_sign.at(ch) );
                                }
                        }

                        // *** evaluate the trim step magnitude ***
                        for( int ch = 0; ch < knch; ch++ ) {
                                if( ! mask_cntx.getChannelMaskBit(ch) ) {
                                        trim_step.at(ch) = trim_step.at(ch) / 2 + trim_step.at(ch) % 2;
                                        int prelim_new_trim = cntx_trim.getThresholdTrim(ch) + trim_step_sign.at(ch) * trim_step.at(ch);
                                        if( prelim_new_trim > 31 ) {
                                                trim_step.at(ch) -= prelim_new_trim - 31;
                                        }
                                        if( prelim_new_trim < 0 ) {
                                                trim_step.at(ch) -= 0 - prelim_new_trim;
                                        }
                                }
                        }

                        // *** check if converged ***
                        if( ! first ) {
                                bool all_ch_converge = true;
                                nxyter::NxContext cntx_trim_converge(cntx_trim);
                                for( int ch = 0; ch < knch; ch++ ) {
                                        if( ! mask_cntx.getChannelMaskBit(ch) ) {
                                                if( trim_step.at(ch) == 0 || ( trim_step.at(ch) == 1 && trim_step_sign.at(ch) == - trim_step_prev_signed.at(ch) ) ) {
                                                        if( diff_prev.at(ch) < diff_curr.at(ch) ) {
                                                                cntx_trim_converge.setThresholdTrim( ch, static_cast<uint8_t>( cntx_trim.getThresholdTrim(ch) - trim_step_prev_signed.at(ch) ) );
                                                        }
                                                }
                                                else {
                                                        all_ch_converge = false;
                                                }

                                        }
                                }
                                if( all_ch_converge ) {
                                        for( int ch = 0; ch < knch; ch++ ) {
                                                if( ! mask_cntx.getChannelMaskBit(ch) ) {
                                                        cntx_trim.setThresholdTrim( ch, cntx_trim_converge.getThresholdTrim(ch) );
                                                }
                                        }
                                        rc = gFeb->nx(nxind).i2c().setContext(cntx_trim, nxyter::kDoTrim);
                                        print_opererr("SetContext(cntx_trim,...)", rc);
                                        break;
                                }
                        }

                        // *** apply new trim ***
                        for( int ch = 0; ch < knch; ch++ ) {
                                if( ! mask_cntx.getChannelMaskBit(ch) ) {
                                        cntx_trim_prev.setThresholdTrim( ch, cntx_trim.getThresholdTrim(ch) );
                                        cntx_trim.setThresholdTrim(ch, cntx_trim.getThresholdTrim(ch) + trim_step.at(ch) * trim_step_sign.at(ch) );
                                }
                        }


                        // *** measure with new trim values ***
                        rc = gFeb->nx(nxind).i2c().setContext(cntx_trim, nxyter::kDoTrim);
                        print_opererr("SetContext(cntx_trim_reset,...)", rc);
                        if( ! opt_q ) printf("Measuring with trim values:\n");
                        if( ! opt_q ) autotrim_print_trim(cntx_trim);
                        // if( ! opt_q ) autotrim_print_trim_dbg(cntx_trim, trim_min, trim_max);
                        acquire_data( nxind, npuls, time );
                        if( ! opt_q ) printf("Resulting rates:\n");
                        if( ! opt_q ) autotrim_print_rates( npuls, time );

                        first = false;
                }

                printf("Finished with trim values:\n");
                autotrim_print_trim(cntx_trim);

                return 0;

                // *** set vth to the initial value ***
                if( ! opt_k ) {
                        rc = gFeb->nx(nxind).i2c().setRegister(nxyter::kNxRegVth, vth_init, true);
                        print_opererr("setRegister(kNxRegVth,...)", rc);
                }

        }
        return 0;

}

float get_mean( std::vector< float > const & vect )
{
        double sum = 0;
        double ncnt = 0;
        for( int ch = 0; ch < vect.size(); ch++ ) {
                sum += ch * vect.at(ch);
                ncnt += vect.at(ch);
        }
        return sum / ncnt;
}

int cmd_idsigch()
{
        int32_t nxbeg=0;
        int32_t nxend=0;
        int32_t npuls=2000;
        if (get_nxrange(nxbeg, nxend)) return 1;
        float time=4.;
        float amp_min = 100.;
        if (args_check(kNeedFeb|kNeedDaq)) return 1;

        int rc;
        nxyter::NxContext save_cntx;

        gUtil->startLoop(0.);
        for (int nxind=nxbeg; nxind<=nxend; nxind++) {
                if (!gUtil->testLoop()) break;
                gFeb->printNxHeadLine(std::cout, nxind);
                if (check_nxoffline(nxind, nxbeg, nxend)) continue; // skip of offline

                rc = gFeb->nx(nxind).i2c().getContext(save_cntx, nxyter::kDoCore);
                print_opererr("NxI2c::getContext {save}", rc);

                rc = gFeb->nx(nxind).i2c().setTestModes(false, true, 0);
                print_opererr("NxI2c::setTestModes", rc);

                int vb_beg =   0;
                int vb_end = 255;
                int vb_mid;
                float med_beg;
                float med_end;
                float med_mid;
                bool nxabort = false;

                nxyter::DistFuncArray dfa_bl(128, npuls);
                dfa_bl.setMaxEntries(2*npuls);
                int rc = gUtil->acquireTestTriggerData(nxind, npuls, dfa_bl);
                nxyter::NxDataSummary nds_bl;
                nds_bl.analyse(dfa_bl);

                rc = gFeb->nx(nxind).i2c().setTestModes(false, false, 0);
                print_opererr("NxI2c::setTestModes", rc);

                std::vector< std::vector<float> > data;
                data.resize(128);
                for( int ch = 0; ch < 128; ch++ )  {
                        data.at( ch ).resize( 4096 );
                }
                acquire_data(nxind, data, time );

                for( int ch = 0; ch < 128; ch++) {
                        float bl = nds_bl.getMedian(ch);
                        float mean = get_mean( data.at(ch) ); //->GetMean();
                        //float sigma = data.at(ch)->GetRMS();
                        float amp = bl - mean;
                        if( amp > amp_min ) {
                                printf("In idsigch: detected signal in channel %d, amp = %f\n", ch, amp );
                        }
                }
        }

        return 0;
}

//----------------------------------------------------------------------------
//++ command dispatcher, ^C interrupt handler and the main program +++++++++++

int process_command(const std::string& line, int level)
{
  gIntCount = 0;                            // reset interrupt watch

  std::string cmdline(line);

  size_t  pos_delcomment = 0;

  // trim everything beyond a '//' in the line
  while (pos_delcomment < cmdline.length()) {
     pos_delcomment = cmdline.find("//", pos_delcomment);

     if (pos_delcomment == std::string::npos) break;

     // but do not destroy url
     if ((pos_delcomment>0) && (cmdline[pos_delcomment-1]==':')) { pos_delcomment+=2;  continue; }

     cmdline.erase(pos_delcomment);

     break;
  }


  trim_whitespace(cmdline);
  if (cmdline.size() == 0) return 0;

  // if cmdline starts with '/*', print the line and quit
  if (cmdline.find("/*") == 0) {
    std::cout << cmdline << std::endl;
    return 0;
  }
  
  // if cmdline starts with '@' take it as command file name
  // in this case open the file and process the commands
  if (cmdline.find("@") == 0) {
    cmdline.erase(0,1);
    std::ifstream cmdfile;
    cmdfile.open(cmdline.c_str(), std::ifstream::in);
    if (cmdfile.fail()) {
      std::cerr << "rocutil-E: Failed to open file '" << cmdline << "'" << std::endl;
      return 1;
    }

    
    for (int i=0; i<std::max(int(0),level+1); i++) std::cout << ">";
    std::cout << " (open) @" << cmdline << std::endl;

    while (cmdfile.good()) {
      std::string line;
      std::getline(cmdfile, line);
      if (line.size()) {
        int rc = process_command(line, std::max(int(0),level) + 1);
        if (rc > 0) std::cerr << "rocutil-E: Aborting command file '" 
                         << cmdline << "'" << std::endl;
        if (rc) return rc;
      }
    }

    for (int i=0; i<level+1; i++) std::cout << ">";
    std::cout << " (close) @" << cmdline << std::endl;

    return 0;
  }

  if (level > 0) {
    for (int i=0; i<level; i++) std::cout << ">";
    std::cout << " " << cmdline << std::endl;
  }

  // replace all tabs by a blank
  for (size_t i=0; i<cmdline.size(); i++) {
    if (cmdline[i] == '\t') cmdline[i] = ' ';
  }

  // if '=' found before ' ', replace it with a ' '
  size_t pos_deleq = cmdline.find("=");
  size_t pos_delsp = cmdline.find(" ");
  if (pos_deleq != std::string::npos && pos_deleq < pos_delsp) {
    cmdline[pos_deleq] = ' ';
  }
  
  // now split cmdline into the command (before ' ') and argument list
  pos_delsp = cmdline.find(" ");
  std::string cmd;
  std::string args;

  if (pos_delsp != std::string::npos) {
    cmd  = cmdline.substr(0,pos_delsp);
    args = cmdline.substr(pos_delsp+1);
  } else {
    cmd  = cmdline;
  }

  // now split the ' ' or ',' separated argument list 

  argspos.clear();
  argsopt.clear();

  trim_whitespace(args);

  while(args.size()) {
    std::string curarg;
    size_t pos_del = args.find_first_of(" ,");
    if (pos_del != std::string::npos) {
      curarg = args.substr(0,pos_del);
      args.erase(0,pos_del+1);
      trim_whitespace(args);
    } else {
      curarg = args;
      args.clear();
    }

    bool isopt = false;
    if ((curarg.size()>=2) && (curarg[0]=='-') && isalpha(curarg[1])) {
      isopt = true;
    } else if (curarg.find("=") !=  std::string::npos) {
      isopt = true;
    }

    if (isopt) {
      argsopt.push_back(curarg);
    } else {
      argspos.push_back(curarg);
    }
  }

  for (unsigned i=0; i<cmdlist.size(); i++) {
    std::string cmdfull;
    std::string cmdshort;
    cmd_full_short(cmdlist[i]->name, cmdfull, cmdshort);
    if (cmd.compare(cmdfull)==0 || cmd.compare(cmdshort)==0) {
      int rc = cmdlist[i]->func();
      if (rc > 0) {
        std::cerr << "rocutil-E: Error in command '" << cmdline << "'" << std::endl;
      }
      return rc;
    }
  }

  std::cerr << "rocutil-E: Command '" << cmd << "' not defined, use 'help'" << std::endl;
  return 1;

}

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

void hdl_int(int sig, siginfo_t *info, void *cnxt)
{
  switch (gIntCount) {
  case 1: 
    std::cerr << '\007' << std::flush;
    break;
  case 2:
    std::cerr << std::endl 
         << "rocutil-W: not responding on ^C, next will terminate" << std::endl;
    break;
  case 3:
    std::cerr << "rocutil-E: ^C abort, have a nice day..." << std::endl;
    exit(1);
    break;
  }
  gIntCount += 1;
  if (gUtil) gUtil->interruptLoop();
  if (gQdaq) gQdaq->interruptRun();
}

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

static const char* history_file = "./.rocutil_history";
static const int   history_max  = 250;

int main(int argc, char* argv[])
{
  struct sigaction act;
  memset (&act, '\0', sizeof(act));
  act.sa_sigaction = &hdl_int;
  act.sa_flags = SA_SIGINFO;
  if (sigaction(SIGINT, &act, 0) < 0) {
    perror ("sigaction");
  }

  reset_cmdlist();

  bool prompt = (argc<=1);
  
  for (int i=1; i<argc; i++) {
    if (i==argc-1 && strcmp(argv[i],"-")==0) {
      prompt = true;
    } else {
      int rc = process_command(argv[i], -1);
      if (rc > 0) std::cerr << "rocutil-F: Aborting rocutil...." << std::endl;
      if (rc) { base::Board::Close(gRocBoard); return (rc<=0) ? 0 : rc; }
    }
  }

  if (!prompt) {
     // close board in the 
     base::Board::Close(gRocBoard);
     return 0;
  }

  std::string lastline;

  char* buf = 0;
  int rc;
  rc = read_history(history_file);

  while ( (buf=readline("rocutil> ")) ) {
    std::string line(buf);                       // get readline buf into std::string
    trim_whitespace(line);
    if (line.size() && line != lastline) add_history(buf);
    lastline = line;
    free(buf);                              // release readline buf
    int rc = process_command(line, 0);
    if (rc < 0) break;                      // exit on quit
  }

  // check whether 'quit' was used (buf!=0) or ^D (buf==0) to end rocutil.
  // in case of ^D, send a std::endl, otherwise shell prompt will be after rocutil
  // prompt.
  // This code is fragile and should be cleaned up/
  if (buf==0)  std::cout << std::endl;

  // Close connection to ROC to avoid dangling messages
  // But only of rc > -2; This prevents a close after
  // a 'restartroc' whih will always fail.
  //
  if (gRocBoard && rc>-2) {                    // if connected to a ROC
     base::Board::Close(gRocBoard);
     gRocBoard = 0;
  }
  
  rc = append_history (history_max, history_file);
  if (rc) {
    rc = write_history(history_file);
  } else {
    rc = history_truncate_file(history_file, history_max);
  }

  return 0;
}

int cmd_autosettrh()
{


   // default: max 100 hits per channel per seconf, max 5000 hits per chip per second, min 80 unmasked channels - it's our goal - priority of this demands!!
   // finding rate - in 5 seconds? 10 seconds? let's say in 5
   // up in treshold - by 1? by 2? by 5? by 10? let's say by 5
   // should be defined - even if hits per all channels per second are ok, maybe some channels are much more noisy than the others, so maybe one has to mask
   // them  ... maybe not (or later improvement)

   int time = 5;
   int rc;
   int nentmax;
   int nxmax;
   int maskmax;
   int starttrh, up, low, diff;
   int step;
   int sig;
   int minchan, counter;
   int previous = 0, previous2 = 0;
   nentmax = 500;
   nxmax = 10000;                                       // for now default
   minchan = 100;                                       // prefered number of working channels
   starttrh = 255;
   up = 255;                    // upper limit
   low = 0;                     // lower limit
   step = 20;

   if (get_arg(time, "time=")) return 1;
   if (get_arg(minchan, "min=")) return 1;
   if (get_arg(nentmax, "nnc=")) return 1;
   if (get_arg(nxmax, "nnx=")) return 1;


   std::cout << "Used values:" << std::endl;
   std::cout << "     time: " << time << std::endl;
   std::cout << "     minimum working channels: " << minchan << std::endl;
   std::cout << "     maximum noise rate per channel: " << nentmax << std::endl;
   std::cout << "     maximum noise rate per chip: "<< nxmax << std::endl;

   diff = up - low;             //difference between thresholds

   nxyter::NxContext cntx;

   int32_t nonx = 0;
   if( gFeb ) {
      nonx = gFeb->numNx();
   }
   else {
      printf("Log to the FEB!\n");
   }

   std::cout << "Number of nXYTERs at FEB: " << nonx << std::endl;


   typedef std::auto_ptr<nxyter::DistFuncArray> ptr_dfa;
   ptr_dfa dfa[4];

   for (int i=0; i<gFeb->numNx(); i++) {
      dfa[i] = ptr_dfa(new nxyter::DistFuncArray(128, 512));
   }                                            // ending array creation
   rc = gRocNx->fireTestPulse(0,0,0);                   // turn off pulsar (self-triggering mode)
   // need to put - turn off test trigger mode and test pulse mode
   // remeber the initial state of nXYTERs

   // setting up threshohld to 255 for all nXYTERs
   for (int i=0; i<gFeb->numNx(); i++) {
      rc = gFeb->nx(i).i2c().setRegister(uint8_t(18), uint8_t(up), true);
   }
   // ending threshold setting

   bool mainstop = false;
   int totalentries[4];
   int totalrate[4];
   int channelentries[512];
   int channelrate[512];
   int channelcontrol[4];
   bool control[4];
   bool masking[4];
   bool trhcontrol[2];
   int trhvalue[2];
   int val[4];
   bool channelid[4][128];


   int noisy = 0;
   int maskedch = 0;
   int tobemasked = 0;

   for (int i=0;i<gFeb->numNx();i++) {                  //which nXYTER

      std::cout << "Setup is running for nXYTER: " << i << std::endl;

      mainstop = false;
      trhvalue[0]=up;
      trhvalue[1]=low;
      trhcontrol[0]=false;
      trhcontrol[1]=false;


      while (!mainstop)   {

         for (int k=0; k<2; k++){               //max k - number of FEBs
            masking[i]=false;

            for (int l=0; l<4; l++) {           // max l - number of nXYTERs
               totalentries[l] = 0;
               totalrate[l] = 0;
               channelcontrol[l] = 0;
               control[l] = false;
               masking[l] = false;
               for (int j=0; j<128; j++) {              // max j - number of channles in nXYTER
                  channelid[l][j] = false;
                  channelrate[(l*128)+j] = 0;
                  channelentries[(l*128)+j] = 0;
               }                                // ending j loop
            }// ending i loop


            delete gQdaq;
            gQdaq = 0;
            gQdaq = new nxyter::QuickDaq(gFeb);
            int rc = gFeb->nx(i).i2c().setRegister(uint8_t(18), uint8_t(trhvalue[k]), true);
            cntx.setChannelMaskBit(0, 127, 0, 1);                       // beg, end, val, step
            rc = gFeb->nx(i).i2c().setContext(cntx, nxyter::kDoMask);
            dfa[i] = ptr_dfa(new nxyter::DistFuncArray(128, 512));

            gQdaq->startRun(0, time);                                   // start DAQ
            //std::cout << " \n" << std::endl;
            //    std::cout << "Running set up for threshohld "<< trhvalue[k] << std::endl;
            // counting rate for whole chip and for each channel
            while(gQdaq->testRun()) {
               roc::Message& msg = gQdaq->msg();
               if (msg.isHitMsg()) {
                  int nxnum = msg.getNxNumber();
                  int nxcha = msg.getNxChNum();
                  int nxadc = msg.getNxAdcValue();
                  if (nxnum == i) {
                     (*dfa[i]).addEntry(nxcha, float(nxadc));
                  }
               }
            }

            for (int j=0; j< 128; j++) {
               totalentries[i] = totalentries[i] + (*dfa[i])[j].numEntries();

               channelrate[(i*128)+j] = (*dfa[i])[j].numEntries()/time;
            }
            totalrate[i] = totalentries[i]/time;
            //        std::cout << "Hit rate in chip is: " << totalrate[i] << std::endl;
            //        std::cout << "Channel rate in channel 64 is: " << channelrate[(i*128)+64] << std::endl;

            // counting how many channels have hit rate below the allowed
            for (int j=0; j<128; j++) {
               if (channelrate[(i*128)+j] <= (nentmax-1)){
                  channelcontrol[i]++;
               }
            }
            if ((channelcontrol[i] <= (minchan-1))) {           // && (totalrate[i] >= (nxmax+1))
               //       std::cout << "Threshold for "<< i << " nXYTER has to go up" << std::endl;
               trhcontrol[k] = false;
            }

            if ((channelcontrol[i] >= minchan) && (totalrate[i] >= nxmax)) {
               //       std::cout << "Masking of channels in "<< i << " nXYTER is coming" << std::endl;
               masking[i] = true;                                       // this threshold can be good, but it has to be found out according to how many channels must                                                           // be masked
               trhcontrol[k] = false;

            }

            if ((channelcontrol[i] >= minchan) && (totalrate[i] <= nxmax)) {
               //       std::cout << i << " nXYTER settings are sufficient" << std::endl;
               trhcontrol[k] = true;
            }

            tobemasked=0;

            if (masking[i]) {

               while (totalrate[i] >= (nxmax+1)) {                                      // checking if total rate at chip still higher that wanted value
                  tobemasked++;

                  noisy = 0;
                  for (int j=0; j<128; j++) {                                                   // go through all channels
                     if (!channelid[i][j]) {                                    // checks, if this channel is not already set to be masked, if not

                        if (channelrate[(i*128)+j]>=noisy) {

                           noisy = channelrate[(i*128)+j];
                           maskedch = j;
                        }

                     }

                  }
                  channelid[i][maskedch] = true;
                  totalrate[i] = totalrate[i] - channelrate[(i*128)+maskedch];

                  // puts channel to be masked
                  // reduces total rate to new level
               }
               for (int j=0; j<128; j++) {
                  if (!channelid[i][j]) {
                     if (channelrate[(i*128)+j]>=nentmax) {
                        tobemasked++;
                        channelid[i][j] = true;
                        totalrate[i] = totalrate[i] - channelrate[(i*128)+maskedch];
                     }
                  }
               }



               if (tobemasked >= (128-minchan)) {
                  totalrate[i]=0;
                  trhcontrol[k] = false;
                  //        std::cout << "Threshold has to be set higher - too many channels will be masked - " << tobemasked << std::endl;
               }

               if (tobemasked <= (128-minchan)) {
                  trhcontrol[k] = true;                                                 // this setting is still ok
                  //    std::cout << i << " nXYTER settings are sufficient" << std::endl;
               }
            }           // end of masking

            masking[i] = false;
            //end if previous

            if (previous == trhvalue[1]) {
               k++;
            }
            if (previous2 == trhvalue[1]) {
               k++;
            }

         }               //ends k run


         previous = trhvalue[1];
         previous2 = trhvalue[0];

         if ((diff/2) == 0) { //if (trhcontrol[0] && trhcontrol[1]) {
            mainstop = true;
         }

         if (trhcontrol[0]) {
            trhvalue[0] = trhvalue[0] - (diff/2);
            diff = trhvalue[0]-trhvalue[1];
         }

         if (!trhcontrol[0]) {
            trhvalue[1] = trhvalue[0];
            trhvalue[0] = trhvalue[0] + (diff/2);
            trhcontrol[1] = trhcontrol[0];
            diff = trhvalue[0]-trhvalue[1];
         }



      } //while


      for (int l=0; l<4; l++) {
         totalentries[l] = 0;
         totalrate[l] = 0;
         channelcontrol[l] = 0;
         control[l] = false;
         masking[l] = false;
         for (int j=0; j<128; j++) {
            channelid[l][j] = false;
            channelrate[(l*128)+j] = 0;
            channelentries[(l*128)+j] = 0;
         }                              // ending j loop
      }// ending i loop

      int settrhvalue = 0;

      if (trhvalue[0] && trhvalue[1]) {
         settrhvalue = trhvalue[1]+1;
      }

      if (trhvalue[0] && !trhvalue[1]){
         settrhvalue = trhvalue[0];
      }

      delete gQdaq;
      gQdaq = 0;
      gQdaq = new nxyter::QuickDaq(gFeb);
      int rc = gFeb->nx(i).i2c().setRegister(uint8_t(18), uint8_t(settrhvalue), true);
      cntx.setChannelMaskBit(0, 127, 0, 1);                     // beg, end, val, step
      rc = gFeb->nx(i).i2c().setContext(cntx, nxyter::kDoMask);
      dfa[i] = ptr_dfa(new nxyter::DistFuncArray(128, 512));

      gQdaq->startRun(0, time);                                 // start DAQ
      //    std::cout << "Running setup for threshohld "<< settrhvalue << std::endl;
      // counting rate for whole chip and for each channel
      while(gQdaq->testRun()) {
         roc::Message& msg = gQdaq->msg();
         if (msg.isHitMsg()) {
            int nxnum = msg.getNxNumber();
            int nxcha = msg.getNxChNum();
            int nxadc = msg.getNxAdcValue();
            if (nxnum == i) {
               (*dfa[i]).addEntry(nxcha, float(nxadc));
            }
         }
      }


      for (int j=0; j< 128; j++) {
         totalentries[i] = totalentries[i] + (*dfa[i])[j].numEntries();
         channelrate[(i*128)+j] = (*dfa[i])[j].numEntries()/time;
         //std::cout << (*dfa[i])[j].numEntries() << std::endl;
      }
      totalrate[i] = totalentries[i]/time;
      //       std::cout << "Hit rate in chip is: " << totalrate[i] << std::endl;
      //       std::cout << "Channel rate in channel 64 is: " << channelrate[(i*128)+64] << std::endl;

      while (totalrate[i] >= (nxmax+1)) {                                       // checking if total rate at chip still higher that wanted value
         tobemasked++;

         noisy = 0;
         for (int j=0; j<128; j++) {                                                    // go through all channels
            if (!channelid[i][j]) {                                     // checks, if this channel is not already set to be masked, if not

               if (channelrate[(i*128)+j]>=noisy) {

                  noisy = channelrate[(i*128)+j];
                  maskedch = j;
               }

            }

         }
         channelid[i][maskedch] = true;
         totalrate[i] = totalrate[i] - channelrate[(i*128)+maskedch];
      }

      for (int j=0; j<128; j++) {
         if (!channelid[i][j]) {
            if (channelrate[(i*128)+j]>=nentmax) {
               tobemasked++;
               channelid[i][j] = true;
               totalrate[i] = totalrate[i] - channelrate[(i*128)+j];
            }
         }
      }



      //masking
      for (int j=0; j<128; j++) {
         if (channelid[i][j]) {
            cntx.setChannelMaskBit(j, j, 1, 1);                         // beg, end, val, step
            rc = gFeb->nx(i).i2c().setContext(cntx, nxyter::kDoMask);
         }
      }

      for (int i=0; i<gFeb->numNx(); i++) {

         // std::cout << " \n" << std::endl;
         // std::cout << "Working channels are: \n" << std::endl;
         //
         //     for (int j=0; j<128; j++) {
         //
         //             if (!channelid[i][j]){
         //
         //             std::cout << "   nXYTER " << i << " channel "<< j << " with noise rate " << channelrate[(i*128)+j] << std::endl;
         //
         //            }
         //            }
         //
         // std::cout << " \n" << std::endl;
         std::cout << "\n Masked channels are:" << std::endl;
         std::cout << "   nXYTER " << i << " channels: " ;
         for (int j=0; j<128; j++) {

            if (channelid[i][j]){

               std::cout << " " << j << ", " ;

            }
         }
         std::cout << "\n" << std::endl;

         std::cout << "Total noise rate in chip is " << totalrate[i] << std::endl;
         std::cout << "Set threshold in " << i << " nXYTER is " << settrhvalue << std::endl;

      }


      std::cout << "Setup has finished this difficult work. You are welcome ...\n" << std::endl;

   }//for nxyters


   mainstop = false;
   return 0;

}       // ending main program




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