feoV1720.cxx

Go to the documentation of this file.

/*****************************************************************************/
#include <stdio.h>
#include <stdlib.h>
#include <sys/time.h>
#include <sched.h>
#include <sys/resource.h>
 
#include <vector>
using std::vector;
 
#include "midas.h"
 
extern "C" {
#include "CAENComm.h"
#include "ov1720drv.h"
}
 
#include "v1720CONET2.hxx"
 
// __________________________________________________________________
// --- General feov1720 parameters
 
#if SIMULATION
#define Nv1720 2              
#else
#define NBLINKSPERA3818   1   
#define NBLINKSPERFE      1   
#define NB1720PERLINK     2   
#define NBV1720TOTAL      2  
#endif
 
#define  EQ_EVID   1                
#define  EQ_TRGMSK 0                
#if SIMULATION
#define  FE_NAME   "feov1720_SIM"   
#else
#define  FE_NAME   "feov1720"       
#endif
 
#define UNUSED(x) ((void)(x)) 
 
// __________________________________________________________________
// --- MIDAS global variables
extern HNDLE hDB;   
extern BOOL debug;  
 
BOOL debugpolling = false;  
BOOL debugtrigger = false;  
 
/* make frontend functions callable from the C framework */
#ifdef __cplusplus
extern "C" {
#endif
 
/*-- Globals -------------------------------------------------------*/
 
char *frontend_name = (char*)FE_NAME;
char *frontend_file_name = (char*)__FILE__;
BOOL frontend_call_loop = FALSE;
INT display_period = 000;
INT max_event_size = 32 * 34000;
INT max_event_size_frag = 5 * 1024 * 1024;
INT event_buffer_size = 200 * max_event_size + 10000;
 
bool runInProgress = false; 
bool runOver = false; 
bool runStopRequested = false; 
 
 
// __________________________________________________________________
/*-- MIDAS Function declarations -----------------------------------------*/
INT frontend_init();
INT frontend_exit();
INT begin_of_run(INT run_number, char *error);
INT end_of_run(INT run_number, char *error);
INT pause_run(INT run_number, char *error);
INT resume_run(INT run_number, char *error);
INT frontend_loop();
extern void interrupt_routine(void);  
 
INT read_trigger_event(char *pevent, INT off);
INT read_scaler_event(char *pevent, INT off); 
 
// __________________________________________________________________
/*-- Equipment list ------------------------------------------------*/
#undef USE_INT
EQUIPMENT equipment[] =
{
  {
#if SIMULATION
    "FEv1720_SIM",            /* equipment name */
    {
      EQ_EVID, EQ_TRGMSK,     /* event ID, trigger mask */
      "SYSTEM",               /* event buffer */
# ifdef USE_INT
      EQ_INTERRUPT,           /* equipment type */
# else
      EQ_POLLED,              /* equipment type */
# endif //USE_INT
 
#else
    "FEv1720I%0d",            /* equipment name */
    {
      EQ_EVID, EQ_TRGMSK,     /* event ID, trigger mask */
      //      //Use this to make different frontends (indexes) write
      //      //to different buffers
      //      "BUF%0d",               /* event buffer */
      "SYSTEM",               /* event buffer */
 
# ifdef USE_INT
      EQ_INTERRUPT,           /* equipment type */
# else
      EQ_POLLED | EQ_EB,      /* equipment type */
# endif //USE_INT
 
#endif //SIMULATION
 
      LAM_SOURCE(0, 0x0),     /* event source crate 0, all stations */
      "MIDAS",                /* format */
      TRUE,                   /* enabled */
      RO_RUNNING,             /* read only when running */
      500,                    /* poll for 500ms */
      0,                      /* stop run after this event limit */
      0,                      /* number of sub events */
      0,                      /* don't log history */
      "", "", ""
    },
    read_trigger_event,       /* readout routine */
  },
  {""}
};
 
#ifdef __cplusplus
}
#endif
 
vector<v1720CONET2> ov1720; 
vector<v1720CONET2>::iterator itv1720;  
 
 
/********************************************************************/
/********************************************************************/
/********************************************************************/
 
void seq_callback(INT hDB, INT hseq, void *info){
  KEY key;
 
  for (itv1720 = ov1720.begin(); itv1720 != ov1720.end(); ++itv1720) {
    if (hseq == itv1720->GetODBHandle()){
      db_get_key(hDB, hseq, &key);
      itv1720->SetSettingsTouched(true);
      printf("Settings %s touched. Changes will take effect at start of next run.\n", key.name);
    }
  }
}
 
 
INT frontend_init(){
 
  set_equipment_status(equipment[0].name, "Initializing...", "#FFFF00");
 
  // --- Suppress watchdog for PICe for now
  cm_set_watchdog_params(FALSE, 0);
 
#if SIMULATION
  for (int iBoard=0; iBoard < Nv1720; iBoard++)
  {
    printf("<<< Init board %i\n", iBoard);
    ov1720.push_back(v1720CONET2(iBoard));
    ov1720[iBoard].verbose = 1;
 
    //load ODB settings
    ov1720[iBoard].SetODBRecord(hDB,seq_callback);
 
    // Open Optical interface
    CAENComm_ErrorCode sCAEN;
    sCAEN = ov1720[iBoard].Connect();
    if (sCAEN != CAENComm_Success) {
      cm_msg(MERROR, "fe", "Could not connect to board; error:%d", sCAEN);
    }
    else {
      printf("Connected successfully to module; handle: %d\n",ov1720[iBoard].GetHandle());
 
      ov1720[iBoard].InitializeForAcq();
      ov1720[iBoard].mZLE = false;
    }
  }
 
  // Lock to one core on the processor. Need to be moved to TFeCommon
  cpu_set_t mask;
  CPU_ZERO(&mask);
  CPU_SET(4, &mask);  // arbitrarily chose 4
  if( sched_setaffinity(0, sizeof(mask), &mask) < 0 ){
    printf("ERROR: affinity not set\n");
  }
  printf(">>> End of Init.\n\n");
#else
  // --- Get the frontend index. Derive the Optical link number
  int feIndex = get_frontend_index();
 
  int tNActivev1720=0;  //Number of v1720 boards activated at the end of frontend_init
 
  // If no index was supplied on the command-line, assume 1 frontend
  // to control all the links and boards
  if(feIndex == -1){
 
    printf("<<< No index supplied! Assuming only 1 frontend only and starting all boards on all links\n");
    for (int iLink=0; iLink < NBLINKSPERA3818; iLink++)
    {
      for (int iBoard=0; iBoard < NB1720PERLINK; iBoard++)
      {
        printf("<<< Begin of Init \n link:%i, board:%i\n", iLink, iBoard);
 
        // Compose unique module ID
        int moduleID = iLink*NB1720PERLINK + iBoard;
 
        // Create module objects
        ov1720.push_back(v1720CONET2(feIndex, iLink, iBoard, moduleID));
        ov1720.back().verbose = 1;
 
        // Setup ODB record (create if necessary)
        ov1720.back().SetODBRecord(hDB,seq_callback);
 
        // Open Optical interface
        printf("Opening optical interface Link %d, Board %d\n", iLink, iBoard);
        CAENComm_ErrorCode sCAEN;
        sCAEN = ov1720.back().Connect();
        if (sCAEN != CAENComm_Success) {
          cm_msg(MERROR, "fe", "Link#:%d iBoard#:%d error:%d", iLink, iBoard, sCAEN);
        }
        else {
          tNActivev1720++;
          printf("Link#:%d Board#:%d Module_Handle[%d]:%d (active:%d)\n",
              iLink, iBoard, moduleID, ov1720.back().GetHandle(), tNActivev1720);
 
          ov1720.back().InitializeForAcq();
 
        }
      }
    }
  }
  else {  //index supplied
 
    if((NBV1720TOTAL % (NB1720PERLINK*NBLINKSPERFE)) != 0){
      printf("Incorrect setup: the number of boards controlled by each frontend"
          " is not a fraction of the total number of boards.");
    }
 
    int maxIndex = (NBV1720TOTAL/NB1720PERLINK)/NBLINKSPERFE - 1;
    if(feIndex < 0 || feIndex > maxIndex){
      printf("Front end index must be between 0 and %d\n", maxIndex);
      exit(1);
    }
 
    int firstLink = (feIndex % (NBLINKSPERA3818 / NBLINKSPERFE)) * NBLINKSPERFE;
    int lastLink = firstLink + NBLINKSPERFE - 1;
    for (int iLink=firstLink; iLink <= lastLink; iLink++)
    {
      for (int iBoard=0; iBoard < NB1720PERLINK; iBoard++)
      {
 
        printf("<<< Begin of Init \n feIndex:%i, link:%i, board:%i\n",
            feIndex, iLink, iBoard);
 
        // Compose unique module ID
        int moduleID = feIndex*NBLINKSPERFE*NB1720PERLINK + iLink*NB1720PERLINK + iBoard;
 
        // Create module objects
        ov1720.push_back(v1720CONET2(feIndex, iLink, iBoard, moduleID));
        ov1720.back().verbose = 1;
 
        // Setup ODB record (create if necessary)
        ov1720.back().SetODBRecord(hDB,seq_callback);
 
        // Open Optical interface
        printf("Opening optical interface Link %d, Board %d\n", iLink, iBoard);
        CAENComm_ErrorCode sCAEN;
        sCAEN = ov1720.back().Connect();
        if (sCAEN != CAENComm_Success) {
          cm_msg(MERROR, "fe", "Link#:%d iBoard#:%d error:%d", iLink, iBoard, sCAEN);
        }
        else {
          tNActivev1720++;
          printf("Link#:%d Board#:%d Module_Handle[%d]:%d (active:%d)\n",
              iLink, iBoard, moduleID, ov1720.back().GetHandle(), tNActivev1720);
 
          ov1720.back().InitializeForAcq();
        }
      }
    }
  }
 
  // Lock to one core on the processor. Need to be moved to TFeCommon
  cpu_set_t mask;
  CPU_ZERO(&mask);
  CPU_SET(4, &mask);  // arbitrarily chose 4
  if( sched_setaffinity(0, sizeof(mask), &mask) < 0 ){
    printf("ERROR: affinity not set\n");
  }
 
  if(feIndex == -1 )
    printf(">>> End of Init. %d active v1720. Expected %d\n\n",
        tNActivev1720,NB1720PERLINK*NBLINKSPERA3818);
  else
    printf(">>> End of Init. %d active v1720. Expected %d\n\n",
        tNActivev1720,NB1720PERLINK*NBLINKSPERFE);
#endif  //SIMULATION
 
 
  set_equipment_status(equipment[0].name, "Initialized", "#00ff00");
 
#if SIMULATION
  printf("*** RUNNING SIMULATION ***\n");
#endif
 
  return SUCCESS;
}
 
 
INT frontend_exit(){
 
  set_equipment_status(equipment[0].name, "Exiting...", "#FFFF00");
 
  for (itv1720 = ov1720.begin(); itv1720 != ov1720.end(); ++itv1720) {
    if (itv1720->IsConnected()){
      itv1720->Disconnect();
    }
  }
  set_equipment_status(equipment[0].name, "Exited", "#00ff00");
  return SUCCESS;
}
 
INT begin_of_run(INT run_number, char *error){
 
  set_equipment_status(equipment[0].name, "Starting run...", "#FFFF00");
 
  printf("<<< Begin of begin_of_run\n");
 
  CAENComm_ErrorCode sCAEN = CAENComm_Success;
  //we've decided to only initialize at start of frontend
  //if odb stuff is changed, will need to restart fe to take effect.
 
  // Reset and Start v1720s
  for (itv1720 = ov1720.begin(); itv1720 != ov1720.end(); ++itv1720) {
    if (! itv1720->IsConnected()) continue;   // Skip unconnected board
    printf("Starting module iBoard %d\n", itv1720->GetModuleID());
    // Reset card (Alex) Moved to the beginning
    //sCAEN = ov1720[iBoard]->WriteReg(v1720_SW_RESET, 0x1);
    //sCAEN = ov1720[iBoard]->WriteReg(v1720_SW_CLEAR, 0x1);
    // Start run then wait for trigger
    itv1720->StartRun();
  }
 
  runInProgress = true;
 
  printf(">>> End of begin_of_run\n\n");
  set_equipment_status(equipment[0].name, "Started run", "#00ff00");
 
  return (sCAEN == CAENComm_Success ? SUCCESS : sCAEN);
}
 
INT end_of_run(INT run_number, char *error){
 
  DWORD buffLvl;
 
  set_equipment_status(equipment[0].name, "Ending run...", "#FFFF00");
 
  printf("<<< Beging of end_of_run \n");
  // Stop run
  CAENComm_ErrorCode sCAEN = CAENComm_Success;
 
  for (itv1720 = ov1720.begin(); itv1720 != ov1720.end(); ++itv1720) {
    if (itv1720->IsConnected()) {  // Skip unconnected board
      sCAEN = itv1720->StopRun();
    }
  }
 
  runOver = false;
  runStopRequested = false;
  runInProgress = false;
 
#if SIMULATION
  sCAEN = ov1720[0].Poll(&buffLvl);
#else
  sCAEN = ov1720[0].Poll(&buffLvl);
  if(buffLvl != 0x0) {
    cm_msg(MERROR, "feov1720:EOR", "Events left in the v1720: %d",buffLvl);
  }
#endif
 
  printf(">>> End Of end_of_run\n\n");
  set_equipment_status(equipment[0].name, "Ended run", "#00ff00");
 
  return (sCAEN == CAENComm_Success ? SUCCESS : sCAEN);
}
 
INT pause_run(INT run_number, char *error)
{
  runInProgress = false;
  return SUCCESS;
}
 
INT resume_run(INT run_number, char *error)
{
  runInProgress = true;
  return SUCCESS;
}
 
INT frontend_loop()
{
  char str[128];
  static DWORD evlimit;
 
  if (runStopRequested && !runOver) {
    db_set_value(hDB,0,"/logger/channels/0/Settings/Event limit", &evlimit, sizeof(evlimit), 1, TID_DWORD);
    if (cm_transition(TR_STOP, 0, str, sizeof(str), ASYNC, FALSE) != CM_SUCCESS) {
      cm_msg(MERROR, "feov1720", "cannot stop run: %s", str);
    }
    runInProgress = false;
    runOver = true;
    cm_msg(MERROR, "feov1720","feov1720 Stop requested");
  }
  return SUCCESS;
}
 
/*------------------------------------------------------------------*/
/********************************************************************\
  Readout routines for different events
\********************************************************************/
int Nloop;  
int Ncount; 
 
// ___________________________________________________________________
/*-- Trigger event routines ----------------------------------------*/
extern "C" INT poll_event(INT source, INT count, BOOL test)
{
  register int i;  // , mod=-1;
  register DWORD lam;
  register DWORD buffLvl;
  CAENComm_ErrorCode sCAEN;
  for (i = 0; i < count; i++) {
    //    if (gv1720Handle[board] < 0) continue;   // Skip unconnected board
    lam = 0;
    sCAEN = ov1720[0].Poll(&buffLvl);
 
    if (debugpolling) printf("loop: %d lam:%x, sCAEN:%d\n", i, lam, sCAEN);
 
    if (buffLvl > 0) {  // Why was this set to > 5? (Alex 01/03/13)
 
      //event available
      Nloop = i;
      Ncount = count;
#if 0
      DWORD acqStat;
      ov1720[0].ReadReg(v1720_ACQUISITION_STATUS, &acqStat);
      ov1720[0].ReadReg(v1720_EVENT_STORED ,&buffLvl);
      printf("vme %i | acq %i | buff lvl %i | count %i\n",lam, acqStat, buffLvl, Nloop);
#endif
      if (!test) return 1;
    } else {
      ss_sleep(1);
    }
  }
  return 0;
}
 
extern "C" INT interrupt_configure(INT cmd, INT source, POINTER_T adr)
{
  switch (cmd) {
  case CMD_INTERRUPT_ENABLE:
    break;
  case CMD_INTERRUPT_DISABLE:
    break;
  case CMD_INTERRUPT_ATTACH:
    break;
  case CMD_INTERRUPT_DETACH:
    break;
  }
  return SUCCESS;
}
 
INT read_trigger_event(char *pevent, INT off) {
 
  if (!runInProgress) return 0;
 
  DWORD *pdata, eStored, eSize, eSizeTot, sn, buffLvl;
 
  sn = SERIAL_NUMBER(pevent);
 
  bk_init32(pevent);
  char bankName[5];
  char statBankName[5];
  CAENComm_ErrorCode sCAEN;
 
  for (itv1720 = ov1720.begin(); itv1720 != ov1720.end(); ++itv1720) {
 
    if (! itv1720->IsConnected()) continue;   // Skip unconnected board
 
    // >>> Get time before read (for data throughput analysis. To be removed)
    timeval tv;
    gettimeofday(&tv,0);
    suseconds_t usStart = tv.tv_usec;
 
    // >>> Read a few registers
    sCAEN = itv1720->ReadReg(V1720_EVENT_STORED, &eStored);
    sCAEN = itv1720->ReadReg(V1720_EVENT_SIZE, &eSize);
    eSizeTot = eSize; // eSize will be decremented later on
    buffLvl = eStored;
    DWORD lam;
    sCAEN = itv1720->ReadReg(V1720_VME_STATUS, &lam);
    //    printf("S/N:%i B:%i eSt:%i eSze%i Lvl:%i Lam:%i \n",sn,iBoard,eStored,eSize,buffLvl,lam);
 
    if(debugtrigger){
      printf("Module:%02d Hndle:%d S/N:%8.8d Nloop:%d/%d (%5.2f) sCAEN:%d Event Stored:0x%x Event Size:0x%x\n"
          , itv1720->GetModuleID(), itv1720->GetHandle(), sn, Nloop, Ncount, (100.*Nloop/Ncount), sCAEN, eStored, eSize);
    }
 
    // >>> Calculate module number
    int module = itv1720->GetModuleID();
 
    // >>> create data bank
    if(itv1720->IsZLEData()){
      sprintf(bankName, "ZL%02d", module);
    }
    else{
      sprintf(bankName, "W2%02d", module);
    }
    bk_create(pevent, bankName, TID_DWORD, &pdata);
 
    //read event into bank
    int dwords_read = 0;
    sCAEN = itv1720->ReadEvent(pdata, &dwords_read);
 
    // >>> close data bank
    bk_close(pevent, pdata + dwords_read);
 
    //might eventually move this stuff into helper
 
    // >>> Fill Qt bank if ZLE data
    if(itv1720->IsZLEData()){
      itv1720->fillQtBank(pevent, pdata, module);
    }
 
    // >>> Statistical bank for data throughput analysis
    sprintf(statBankName, "ST%02d", module);
    bk_create(pevent, statBankName, TID_DWORD, &pdata);
    *pdata++ = module;
    *pdata++ = eStored;
    *pdata++ = eSizeTot;
    *pdata++ = buffLvl;
    gettimeofday(&tv,0);
    *pdata++ = usStart;
    *pdata++ = tv.tv_usec;
    bk_close(pevent, pdata);
 
  }
 
  //primitive progress bar
  if (sn % 100 == 0) printf(".");
 
  return bk_size(pevent);
}