feoV1740.cxx

Go to the documentation of this file.

/****************************************************************************/
#include <stdio.h>
#include <stdlib.h>
 
#include <vector>
using std::vector;
 
#include "midas.h"
#include "mvmestd.h"
 
extern "C" {
#include "CAENComm.h"
}
 
#include "v1740CONET2.hxx"
 
using namespace std;
 
#define Nv1740    1 
#define EQ_EVID   4 
#define EQ_TRGMSK 0 
 
#if SIMULATION
#define FE_NAME "feoV1740_SIM"  
#else
#define FE_NAME   "feoV1740"    
#endif
 
#define UNUSED(x) ((void)(x))   
 
/* Globals */
/* Hardware */
extern HNDLE hDB;   
extern BOOL debug;  
 
/* 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;
 
bool runInProgress = false; 
bool runOver = false; 
bool runStopRequested = false; 
 
/*-- 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
    "FEv1740_SIM",              /* equipment name */
#else
    "FEv1740",                  /* equipment name */
#endif
    {
      EQ_EVID, EQ_TRGMSK,       /* event ID, trigger mask */
      "SYSTEM",                 /* event buffer */
 
#ifdef USE_INT
      EQ_INTERRUPT,             /* equipment type */
#else
      EQ_POLLED,                /* equipment type */
#endif
 
      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
 
// v1740 object
vector<v1740CONET2> ov1740; 
vector<v1740CONET2>::iterator itv1740; 
 
 
/********************************************************************/
/********************************************************************/
/********************************************************************/
 
void seq_callback(INT hDB, INT hseq, void *info)
{
  KEY key;
 
  for (itv1740 = ov1740.begin(); itv1740 != ov1740.end(); ++itv1740) {
    if (hseq == itv1740->GetODBHandle()) {
      db_get_key(hDB, hseq, &key);
      itv1740->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 PCIe for now
  cm_set_watchdog_params(FALSE, 0);
 
  // --- Get the frontend index. Derive the Optical link number
  int feIndex = get_frontend_index();
 
  int tNActivev1740=0;  //Number of v1740 boards activated at the end of frontend_init
 
  for (int iBoard=0; iBoard < Nv1740; iBoard++)
  {
    printf("<<< Init board %i\n", iBoard);
 
    //If no index supplied, use link 0, else use index as link number
    if(feIndex == -1)
      ov1740.push_back(v1740CONET2(0, iBoard, iBoard));
    else
      ov1740.push_back(v1740CONET2(feIndex, iBoard, iBoard));
 
    ov1740.back().verbose = 1;
 
    //load ODB settings
    ov1740.back().SetODBRecord(hDB,seq_callback);
 
    // Open Optical interface
    CAENComm_ErrorCode sCAEN;
    sCAEN = ov1740.back().Connect();
    if (sCAEN != CAENComm_Success) {
      cm_msg(MERROR, "fe", "Could not connect to board; error:%d", sCAEN);
    }
    else {
      tNActivev1740++;
      printf("Board#:%d Module_Handle[%d]:%d (active:%d)\n",
          iBoard, iBoard, ov1740.back().GetHandle(), tNActivev1740);
 
      ov1740.back().CheckBoardType();
    }
  }
 
  printf(">>> End of Init. %d active v1740. Expected %d\n\n", tNActivev1740, Nv1740);
 
  set_equipment_status(equipment[0].name, "Initialized", "#00ff00");
  printf("end of Init: %d\n", SUCCESS);
 
#if SIMULATION
  printf("*** RUNNING SIMULATION ***\n");
#endif
 
  return SUCCESS;
}
 
INT frontend_exit()
{ 
  set_equipment_status(equipment[0].name, "Exiting...", "#FFFF00");
  cout << "frontend_exit";
 
  for (itv1740 = ov1740.begin(); itv1740 != ov1740.end(); ++itv1740) {
    if (itv1740->IsConnected()){
      cm_msg(MINFO,"exit", "Closing handle %d", itv1740->GetHandle());
      itv1740->Disconnect();
    }
  }
 
  set_equipment_status(equipment[0].name, "Exited", "#00ff00");
  printf("End of exit\n");
  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;  //hardcoded for now
 
  for (itv1740 = ov1740.begin(); itv1740 != ov1740.end(); ++itv1740) {
    if (! itv1740->IsConnected()) continue;   // Skip unconnected board
 
    //  //Done at SetOdbRecord (frontend_init)
    //  size = sizeof(V1740_CONFIG_SETTINGS);
    //  if ((status = db_get_record (hDB, hSet, &tsvc, &size, 0)) != DB_SUCCESS)
    //    return status;
 
    itv1740->InitializeForAcq();
    itv1740->StartRun();
  }
 
  runInProgress = true;
 
  //------ FINAL ACTIONS before BOR -----------
  set_equipment_status(equipment[0].name, "Started run", "#00ff00");
  printf(">>> End of begin_of_run\n\n");
  return (sCAEN == CAENComm_Success ? SUCCESS : sCAEN);
}
 
INT end_of_run(INT run_number, char *error)
{
  set_equipment_status(equipment[0].name, "Ending run...", "#FFFF00");
 
  printf("<<< Begin of end_of_run \n");
  // Stop run
  CAENComm_ErrorCode sCAEN = CAENComm_Success;
  uint32_t status, eStored;
 
  for (itv1740 = ov1740.begin(); itv1740 != ov1740.end(); ++itv1740) {
    if (itv1740->IsConnected()) {  // Skip unconnected board
      sCAEN = itv1740->StopRun();
 
      itv1740->ReadReg(V1740_ACQUISITION_STATUS, &status);
      itv1740->ReadReg(V1740_EVENT_STORED, &eStored);
 
      cout << "End of EOR. handle=" << itv1740->GetHandle() << " link=" << itv1740->GetLink()
                                   << " ACQ_STATUS=" << status << " EV_STORED=" << eStored << " sCAEN=" << sCAEN << endl;
    }
  }
 
  // Stop DAQ for seting up the parameters
  runOver = false;
  runStopRequested = false;
  runInProgress = false;
 
  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)
{
  cout << "pause";
 
  runInProgress = false;
  return SUCCESS;
}
 
INT resume_run(INT run_number, char *error)
{
  cout << "resume";
  runInProgress = true;
  return SUCCESS;
}
 
INT frontend_loop()
{
  cout << "frontend_lopp";
  /* if frontend_call_loop is true, this routine gets called when
     the frontend is idle or once between every event */
  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, "feodeap", "cannot stop run: %s", str);
    }
    runInProgress = false;
    runOver = true;
    cm_msg(MERROR, "feodeap","feodeap 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)
/* Polling routine for events. Returns TRUE if event
   is available. If test equals TRUE, don't return. The test
   flag is used to time the polling */
{
 
  register int i;  // , mod=-1;
  register uint32_t lam = 0;
  //  register uint32_t event_size = 0;
  CAENComm_ErrorCode sCAEN;
 
  for (i=0; i<count; i++)
  {
    sCAEN = ov1740[0].ReadReg(V1740_ACQUISITION_STATUS, &lam);
    UNUSED(sCAEN);
    lam &= 0x8;
 
    if (lam) {
      Nloop = i; Ncount = count;
      if (!test)
        return lam;
    }
  }
 
  return 0;
}
 
extern "C" INT interrupt_configure(INT cmd, INT source, POINTER_T adr)
{
  cout << "interrupt_configure";
  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;
  DWORD event_size, sn;
  int dwords_read;
  //  int sLoop, eEvent;
 
  sn = SERIAL_NUMBER(pevent);
  bk_init32(pevent);
 
  CAENComm_ErrorCode sCAEN;
 
  for (itv1740 = ov1740.begin(); itv1740 != ov1740.end(); ++itv1740) {
    if (!itv1740->IsConnected()) continue;   // Skip unconnected board
 
    itv1740->ReadReg(V1740_EVENT_SIZE, &event_size);
    if (event_size > 0)
    {
 
      char bankName[5];
      sprintf(bankName,"W4%02d",itv1740->GetLink());
      bk_create(pevent, bankName, TID_DWORD, &pdata);
 
      sCAEN = itv1740->ReadEvent(pdata, &dwords_read);
 
      //(eStored > 1) ? sLoop = 2 : sLoop = eStored;
      //  for (eEvent=0; eEvent < sLoop; eEvent++) {
      //sCAEN = CAENComm_Read32(v1740->GetHandle(), V1740_EVENT_SIZE, &eSize);
 
      bk_close(pevent, pdata + dwords_read);
    }
  }
 
  //primitive progress bar
  if (sn % 100 == 0) printf(".");
 
  UNUSED(sCAEN);
  return bk_size(pevent);
}
 
INT read_scaler_event(char *pevent, INT off)
{
  /* init bank structure */
  bk_init(pevent);
  return 0;  // bk_size(pevent);
}