v1740CONET2.cxx

Go to the documentation of this file.

/*****************************************************************************/
#include "v1740CONET2.hxx"
#include <stdlib.h>
 
#define UNUSED(x) ((void)(x)) 
 
using namespace std;
 
const char * v1740CONET2::config_str[] = {\
    "setup = INT : 0",\
    "Acq mode = INT : 1",\
    "Group Configuration = DWORD : 0",\
    "Buffer organization = INT : 8",\
    "Custom size = INT : 0",\
    "Group Mask = DWORD : 0xFF",\
    "Trigger Source = DWORD : 0x40000000",\
    "Trigger Output = DWORD : 0x40000000",\
    "Post Trigger = DWORD : 200",\
    "Threshold = DWORD[8] :",\
    "[0] 2080",\
    "[1] 1900",\
    "[2] 2080",\
    "[3] 9",\
    "[4] 9",\
    "[5] 9",\
    "[6] 9",\
    "[7] 9",\
    "DAC = DWORD[8] :",\
    "[0] 35000",\
    "[1] 35000",\
    "[2] 35000",\
    "[3] 35000",\
    "[4] 35000",\
    "[5] 35000",\
    "[6] 9190",\
    "[7] 9190",\
    NULL
};
 
v1740CONET2::v1740CONET2(int link, int board, int moduleID) :
        _link(link), _board(board), _moduleID(moduleID)
{
  _handle = -1;
  _odb_handle = 0;
  verbose = 0;
  _settings_loaded=false;
  _settings_touched=false;
  _running = false;
}
v1740CONET2::~v1740CONET2() {}
 
string v1740CONET2::GetName()
{
  stringstream txt;
  txt << "B" << _board;
  return txt.str();
}
bool v1740CONET2::IsConnected()
{
  return (_handle >= 0);
}
bool v1740CONET2::IsRunning()
{
  return _running;
}
CAENComm_ErrorCode v1740CONET2::Connect()
{
  if (verbose) cout << "Opening device (l,b) = (" << _link << "," << _board << ")" << endl;
  CAENComm_ErrorCode sCAEN;
 
#if SIMULATION  //Simulate success opening device
  sCAEN = CAENComm_Success;
  _handle = 1;  //random
#else
  sCAEN = CAENComm_OpenDevice(CAENComm_PCIE_OpticalLink, _link, _board, 0, &_handle);
#endif
 
  if (sCAEN != CAENComm_Success) _handle = -1;
  return sCAEN;
}
CAENComm_ErrorCode v1740CONET2::Disconnect()
{
  if (verbose) cout << "Closing device (l,b) = (" << _link << "," << _board << ")" << endl;
  CAENComm_ErrorCode sCAEN;
 
#if SIMULATION  //Simulate success closing device
  sCAEN = CAENComm_Success;
#else
  sCAEN = CAENComm_CloseDevice(_handle);
#endif
 
 
  _handle = -1;
  return sCAEN;
}
CAENComm_ErrorCode v1740CONET2::StartRun()
{
  if (verbose) cout << GetName() << "::StartRun()\n";
  if (IsRunning()) {
    cout << "Error: trying to start already started board" << endl;
    return (CAENComm_ErrorCode)1;
  }
  if (!IsConnected()) {
    cout << "Error: trying to start disconnected board" << endl;
    return (CAENComm_ErrorCode)1;
  }
  if (_settings_touched)
  {
    cm_msg(MINFO, "feoV1740", "Note: settings on board %s touched. Re-initializing board.",
        GetName().c_str());
    cout << "reinitializing" << endl;
    InitializeForAcq();
  }
 
  CAENComm_ErrorCode e = ov1740_AcqCtl(_handle, V1740_RUN_START);
  if (e == CAENComm_Success) _running=true;
  return e;
}
CAENComm_ErrorCode v1740CONET2::StopRun()
{
  CAENComm_ErrorCode e = ov1740_AcqCtl(_handle, V1740_RUN_STOP);
  if (e == CAENComm_Success) _running=false;
  return e;
}
CAENComm_ErrorCode v1740CONET2::SetupPreset(int mode)
{
#if SIMULATION
  return CAENComm_Success;
#else
  return ov1740_Setup(_handle, mode);
#endif
}
CAENComm_ErrorCode v1740CONET2::AcqCtl(uint32_t operation)
{
#if SIMULATION
  return CAENComm_Success;
#else
  return ov1740_AcqCtl(_handle, operation);
#endif
}
CAENComm_ErrorCode v1740CONET2::ReadReg(DWORD address, DWORD *val)
{
  if (verbose >= 2) cout << GetName() << "::ReadReg(" << hex << address << ")" << endl;
#if SIMULATION
  return CAENComm_Success;
#else
  return CAENComm_Read32(_handle, address, val);
#endif
}
CAENComm_ErrorCode v1740CONET2::WriteReg(DWORD address, DWORD val)
{
  if (verbose >= 2) cout << GetName() << "::WriteReg(" << hex << address << "," << val << ")" << endl;
#if SIMULATION
  return CAENComm_Success;
#else
  return CAENComm_Write32(_handle, address, val);
#endif
}
 
#define MAX_BLT_READ_SIZE 10000
CAENComm_ErrorCode v1740CONET2::ReadEvent(DWORD *data, int *dwords_read)
{
  DWORD size_remaining, *data_pos = data, to_read;
  int tempnw = 0;
  *dwords_read = 0;
 
#if SIMULATION  //read maximum size allowed
  CAENComm_ErrorCode sCAEN = CAENComm_Success;
  size_remaining = MAX_BLT_READ_SIZE;
#else
  CAENComm_ErrorCode sCAEN = ReadReg(V1740_EVENT_SIZE, &size_remaining);
#endif
 
  if (verbose>=2) cout << "Start of ReadEvent... "
      << "size_rem = " << size_remaining << " " << sCAEN << endl;
 
  while (size_remaining > 0 && sCAEN == CAENComm_Success)
  {
#if SIMULATION  //read random 32-bit integers
    to_read = size_remaining > MAX_BLT_READ_SIZE ? MAX_BLT_READ_SIZE : size_remaining;
    for (WORD i = 0; i < to_read; i++)
      *data_pos++ = rand();
    sCAEN = CAENComm_Success;
    tempnw = to_read; //simulate success reading all data
#else
    to_read = size_remaining > MAX_BLT_READ_SIZE ? MAX_BLT_READ_SIZE : size_remaining;
    sCAEN = CAENComm_BLTRead(_handle, V1740_EVENT_READOUT_BUFFER, data_pos, to_read, &tempnw);
#endif
 
    if (verbose>=2) cout << sCAEN << " = BLTRead(handle=" << _handle
        << ", addr=" << V1740_EVENT_READOUT_BUFFER
        << ", data_pos=" << data_pos
        << ", to_read=" << to_read
        << ", tempnw returned " << tempnw << ");" << endl;
    *dwords_read += tempnw;
    size_remaining -= tempnw;
    data_pos += tempnw;
  }
  if (verbose>=2) cout << "End of ReadEvent... "
      << "dwords_read = " << *dwords_read << endl;;
 
  return sCAEN;
}
CAENComm_ErrorCode v1740CONET2::SendTrigger()
{
  if (verbose) cout << "Sending Trigger (l,b) = (" << _link << "," << _board << ")" << endl;
  return WriteReg(V1740_SOFTWARE_TRIGGER, 0x1);
}
int v1740CONET2::SetODBRecord(HNDLE h, void(*cb_func)(INT,INT,void*))
{
  char set_str[80];
  int status,size;
 
#if SIMULATION
  sprintf(set_str, "/Equipment/FEv1740_SIM/Settings/Board%d", _board);
#else
  sprintf(set_str, "/Equipment/FEv1740/Settings/Board%d", _board);
#endif
 
  if (verbose) cout << GetName() << "::SetODBRecord(" << h << "," << set_str << ",...)" << endl;
 
  //create record if doesn't exist and find key
  status = db_create_record(h, 0, set_str, strcomb(config_str));
  status = db_find_key(h, 0, set_str, &_odb_handle);
  if (status != DB_SUCCESS) cm_msg(MINFO,"FE","Key %s not found", set_str);
 
  //hotlink
  //  size = sizeof(config_type);
  size = sizeof(V1740_CONFIG_SETTINGS);
  status = db_open_record(h, _odb_handle, &config, size, MODE_READ, cb_func, NULL);
 
  //get actual record
  status = db_get_record(h, _odb_handle, &config, &size, 0);
 
  if (status == DB_SUCCESS) _settings_loaded = true;
  _settings_touched = true;
 
  return status; //== DB_SUCCESS for success
}
int v1740CONET2::InitializeForAcq()
{
  if (!_settings_loaded) {
    cout << "Error: cannot call InitializeForAcq() without settings loaded properly" << endl;
    return -1;    }
  if (!IsConnected())     {
    cout << "Error: trying to call InitializeForAcq() to unconnected board" << endl;
    return -1;    }
  if (IsRunning())    {
    cout << "Error: trying to call InitializeForAcq() to already running board" << endl;
    return -1;    }
 
  if (_settings_loaded && !_settings_touched) return 0; //don't do anything if settings haven't been changed
 
  CAENComm_ErrorCode sCAEN;
  uint32_t temp;
 
  //use preset setting if enabled
  if (config.setup != 0) {
    SetupPreset(config.setup);
    //else use odb values
  } else {
 
    AcqCtl(config.acq_mode);
    printf("group config 0x%x\n", config.group_config);
    WriteReg(V1740_GROUP_CONFIG, config.group_config);
    WriteReg(V1740_GROUP_CONFIG        , config.group_config);
    WriteReg(V1740_BUFFER_ORGANIZATION   , config.buffer_organization);
    WriteReg(V1740_CUSTOM_SIZE       , config.custom_size);
    WriteReg(V1740_GROUP_EN_MASK       , config.group_mask);
    AcqCtl(V1740_COUNT_ACCEPTED_TRIGGER);
    WriteReg(V1740_TRIG_SRCE_EN_MASK     , config.trigger_source);
    WriteReg(V1740_FP_TRIGGER_OUT_EN_MASK, config.trigger_output);
    WriteReg(V1740_POST_TRIGGER_SETTING  , config.post_trigger);
    ReadReg(V1740_GROUP_CONFIG, &temp);
    WriteReg(V1740_MONITOR_MODE, 0x3);  // buffer occupancy
    printf("group config 0x%x\n",  temp);
    /*sCAEN = ov1740_GroupConfig(GetHandle()
      , config.trigger_positive_pulse == 1 ? V1740_TRIGGER_OVERTH : V1740_TRIGGER_UNDERTH);*/
    WriteReg(V1740_VME_CONTROL, V1740_ALIGN64);
 
    // Set individual channel stuff
    for (int i=0;i<8;i++) {
      //group threshold
      sCAEN = ov1740_GroupSet(GetHandle(), i, V1740_GROUP_THRESHOLD, config.threshold[i]);
      sCAEN = ov1740_GroupGet(GetHandle(), i, V1740_GROUP_THRESHOLD, &temp);
      printf("Threshold[%i] = %d \n", i, temp);
      //set DAC
      sCAEN = ov1740_GroupDACSet(GetHandle(), i, config.dac[i]);
      printf("DAC[%i] = %d \n", i, temp);
      //disable channel triggers
      WriteReg(V1740_GROUP_CH_TRG_MASK + (i<<8), 0);
    }
 
    // Doesn't set the ID in the data stream!
    WriteReg( V1740_BOARD_ID, 6);
    ov1740_Status(GetHandle());
  }
 
  _settings_touched = false;
  UNUSED(sCAEN);
 
  //ready to do startrun
 
  return 0;
}
void v1740CONET2::CheckBoardType()
{
  // Verify Board Type
  uint32_t version = 0;
  const uint32_t v1740_board_type = 0x04;
  CAENComm_ErrorCode sCAEN = ReadReg(V1740_BOARD_INFO, &version);
  if((version & 0xFF) != v1740_board_type)
    cm_msg(MINFO,"feoV1740","*** WARNING *** Trying to use a v1740 frontend with another"
        " type of board.  Results will be unexpected!");
 
  UNUSED(sCAEN);
}
void v1740CONET2::ShowRegs()
{
#if !SIMULATION
  DWORD temp;
  CAENComm_ErrorCode sCAEN;
  cout << "   *** regs: ";
  sCAEN = CAENComm_Read32(_handle, V1740_EVENT_SIZE, &temp); cout << "E_SIZE=0x" << hex <<  temp << " ";
  sCAEN = CAENComm_Read32(_handle, V1740_EVENT_STORED, &temp); cout << "E_STORED=0x" << hex <<  temp << " ";
  sCAEN = CAENComm_Read32(_handle, V1740_GROUP_BUFFER_OCCUPANCY, &temp); cout << "GRP_BUFF_OCC[0]=0x" << temp << " ";
  sCAEN = CAENComm_Read32(_handle, V1740_ACQUISITION_STATUS, &temp); cout << "ACQ_STATUS=0x" << temp << " lam=" << (temp & 0x4);
  //sCAEN = CAENComm_Read32(_handle, V1740_BLT_EVENT_NB, &temp); cout << "BLT_EVENT_NB=0x" << temp << " ";
  //sCAEN = CAENComm_Read32(_handle, V1740_GROUP_CONFIG, &temp); cout << "GROUP_CONFIG= " << temp << " ";
  //sCAEN = CAENComm_Read32(_handle, V1740_GROUP_EN_MASK, &temp); cout << "GROUP_EN_MASK= " << temp << " ";
  cout << dec << endl;
  UNUSED(sCAEN);
#endif
}