687 lines
32 KiB
C++
687 lines
32 KiB
C++
#include "ClassDigitizer.h"
|
||
|
||
Digitizer::Digitizer(){
|
||
|
||
portID = -1;
|
||
boardID = -1;
|
||
handle = -1;
|
||
NChannel = 0;
|
||
ADCbits = 1;
|
||
DPPType = 0;
|
||
ADCFullSize = 0;
|
||
ch2ns = 0;
|
||
BoardInfo = {};
|
||
|
||
VMEBaseAddress = 0;
|
||
LinkType = CAEN_DGTZ_USB; /// default USB
|
||
IOlev = CAEN_DGTZ_IOLevel_NIM; ///default NIM
|
||
AcqMode = CAEN_DGTZ_DPP_ACQ_MODE_List; ///default list mode
|
||
|
||
channelMask = 0xFFFF;
|
||
|
||
data = new Data();
|
||
|
||
settingFileName = "";
|
||
settingFileExist = false;
|
||
settingFile = NULL;
|
||
|
||
ret = -1;
|
||
isConnected = false;
|
||
AcqRun = false;
|
||
|
||
}
|
||
|
||
Digitizer::Digitizer(int boardID, int portID, bool verbose){
|
||
Digitizer();
|
||
OpenDigitizer(boardID, portID, verbose);
|
||
}
|
||
|
||
Digitizer::~Digitizer(){
|
||
CloseDigitizer();
|
||
|
||
delete data;
|
||
}
|
||
|
||
void Digitizer::Reset(){
|
||
ret = CAEN_DGTZ_Reset(handle);
|
||
if( ret != 0 ) ErrorMsg("Reset");
|
||
}
|
||
|
||
int Digitizer::OpenDigitizer(int boardID, int portID, bool verbose){
|
||
|
||
this->boardID = boardID;
|
||
this->portID = portID;
|
||
|
||
/***************************************************/
|
||
/** Open the digitizer and read board information */
|
||
/***************************************************/
|
||
|
||
if( verbose) printf("============= Opening Digitizer at Board %d, Port %d \n", boardID, portID);
|
||
|
||
///-------- try USB first
|
||
LinkType = CAEN_DGTZ_USB; /// Link Type
|
||
ret = (int) CAEN_DGTZ_OpenDigitizer(LinkType, boardID, 0, VMEBaseAddress, &handle);
|
||
if (ret != 0){ ///---------- try Optical link
|
||
LinkType = CAEN_DGTZ_OpticalLink ;
|
||
ret = (int) CAEN_DGTZ_OpenDigitizer(LinkType, portID, boardID, VMEBaseAddress, &handle);
|
||
}
|
||
|
||
if (ret != 0) {
|
||
if( verbose) printf("Can't open digitizer\n");
|
||
return -1;
|
||
}else{
|
||
///----- Getting Board Info
|
||
ret = (int) CAEN_DGTZ_GetInfo(handle, &BoardInfo);
|
||
if (ret != 0) {
|
||
if( verbose) printf("Can't read board info\n");
|
||
}else{
|
||
isConnected = true;
|
||
NChannel = BoardInfo.Channels;
|
||
channelMask = pow(2, NChannel)-1;
|
||
switch(BoardInfo.Model){
|
||
case CAEN_DGTZ_V1730: ch2ns = 2.0; break; ///ns -> 500 MSamples/s
|
||
case CAEN_DGTZ_V1725: ch2ns = 4.0; break; ///ns -> 250 MSamples/s
|
||
}
|
||
ADCbits = BoardInfo.ADC_NBits;
|
||
ADCFullSize = (unsigned int)( pow(2, ADCbits) -1 );
|
||
|
||
if( verbose) {
|
||
printf("Connected to Model %s with handle %d using %s\n", BoardInfo.ModelName, handle, LinkType == CAEN_DGTZ_USB ? "USB" : "Optical Link");
|
||
printf("Sampling rate : %.0f MHz = %.1f ns \n", 1000/ch2ns, ch2ns);
|
||
printf("Number of Channels : %d = 0x%X\n", NChannel, channelMask);
|
||
printf("SerialNumber :\e[1m\e[33m %d\e[0m\n", BoardInfo.SerialNumber);
|
||
printf("ADC bit is \e[33m%d\e[0m, %d = 0x%x\n", ADCbits, ADCFullSize, ADCFullSize);
|
||
printf("ROC FPGA Release is %s\n", BoardInfo.ROC_FirmwareRel);
|
||
printf("AMC FPGA Release is %s\n", BoardInfo.AMC_FirmwareRel);
|
||
}
|
||
int DPPType;
|
||
sscanf(BoardInfo.AMC_FirmwareRel, "%d", &DPPType);
|
||
if (DPPType < 128) {
|
||
if( verbose) printf("This digitizer does not have DPP-PHA firmware\n");
|
||
}
|
||
data->DPPType = DPPType;
|
||
|
||
//SetBoardID(BoardInfo.SerialNumber);
|
||
}
|
||
}
|
||
|
||
///====================== Check DPP firmware revision
|
||
sscanf(BoardInfo.AMC_FirmwareRel, "%d", &DPPType);
|
||
if (DPPType >= 0x80 && verbose) {
|
||
printf("\t==== This digitizer has a DPP firmware!\n");
|
||
printf("\e[32m");
|
||
switch (DPPType){
|
||
case V1724_DPP_PHA_CODE: printf("\tDPP-PHA for x724 boards \n"); break;
|
||
case V1720_DPP_CI_CODE : printf("\tDPP-CI for x720 boards \n"); break;
|
||
case V1720_DPP_PSD_CODE: printf("\tDPP-PSD for x720 boards \n"); break;
|
||
case V1751_DPP_PSD_CODE: printf("\tDPP-PSD for x751 boards \n"); break;
|
||
case V1751_DPP_ZLE_CODE: printf("\tDPP-ZLE for x751 boards \n"); break;
|
||
case V1743_DPP_CI_CODE: printf("\tDPP-PSD for x743 boards \n"); break;
|
||
case V1740_DPP_QDC_CODE: printf("\tDPP-QDC for x740 boards \n"); break;
|
||
case V1730_DPP_PSD_CODE: printf("\tDPP-PSD for x730 boards \n"); break;
|
||
case V1730_DPP_PHA_CODE: printf("\tDPP-PHA for x730 boards \n"); break;
|
||
case V1730_DPP_ZLE_CODE: printf("\tDPP-ZLE for x730 boards \n"); break;
|
||
case V1730_DPP_DAW_CODE: printf("\tDPP-DAW for x730 boards \n"); break;
|
||
}
|
||
printf("\e[0m");
|
||
}
|
||
|
||
///======================= Check virtual probe
|
||
int probes[MAX_SUPPORTED_PROBES];
|
||
int numProbes;
|
||
ret = CAEN_DGTZ_GetDPP_SupportedVirtualProbes(handle, 1, probes, &numProbes);
|
||
if( verbose ){
|
||
printf("\t==== supported virtual probe (number of Probe : %d)\n", numProbes);
|
||
for( int i = 0 ; i < numProbes; i++){
|
||
switch (probes[i]){
|
||
case 0: printf("\t\t CAEN_DGTZ_DPP_VIRTUALPROBE_Input\n"); break;
|
||
case 1: printf("\t\t CAEN_DGTZ_DPP_VIRTUALPROBE_Delta\n"); break;
|
||
case 2: printf("\t\t CAEN_DGTZ_DPP_VIRTUALPROBE_Delta2\n"); break;
|
||
case 3: printf("\t\t CAEN_DGTZ_DPP_VIRTUALPROBE_Trapezoid\n"); break;
|
||
case 4: printf("\t\t CAEN_DGTZ_DPP_VIRTUALPROBE_TrapezoidReduced\n"); break;
|
||
case 5: printf("\t\t CAEN_DGTZ_DPP_VIRTUALPROBE_Baseline\n"); break;
|
||
case 6: printf("\t\t CAEN_DGTZ_DPP_VIRTUALPROBE_Threshold\n"); break;
|
||
case 7: printf("\t\t CAEN_DGTZ_DPP_VIRTUALPROBE_CFD\n"); break;
|
||
case 8: printf("\t\t CAEN_DGTZ_DPP_VIRTUALPROBE_SmoothedInput\n"); break;
|
||
case 9: printf("\t\t CAEN_DGTZ_DPP_VIRTUALPROBE_None\n"); break;
|
||
case 10: printf("\t\t CAEN_DGTZ_DPP_DIGITALPROBE_TRGWin\n"); break;
|
||
case 11: printf("\t\t CAEN_DGTZ_DPP_DIGITALPROBE_Armed\n"); break;
|
||
case 12: printf("\t\t CAEN_DGTZ_DPP_DIGITALPROBE_PkRun\n"); break;
|
||
case 13: printf("\t\t CAEN_DGTZ_DPP_DIGITALPROBE_Peaking\n"); break;
|
||
case 14: printf("\t\t CAEN_DGTZ_DPP_DIGITALPROBE_CoincWin\n"); break;
|
||
case 15: printf("\t\t CAEN_DGTZ_DPP_DIGITALPROBE_BLHoldoff\n"); break;
|
||
case 16: printf("\t\t CAEN_DGTZ_DPP_DIGITALPROBE_TRGHoldoff\n"); break;
|
||
case 17: printf("\t\t CAEN_DGTZ_DPP_DIGITALPROBE_TRGVal\n"); break;
|
||
case 18: printf("\t\t CAEN_DGTZ_DPP_DIGITALPROBE_ACQVeto\n"); break;
|
||
case 19: printf("\t\t CAEN_DGTZ_DPP_DIGITALPROBE_BFMVeto\n"); break;
|
||
case 20: printf("\t\t CAEN_DGTZ_DPP_DIGITALPROBE_ExtTRG\n"); break;
|
||
case 21: printf("\t\t CAEN_DGTZ_DPP_DIGITALPROBE_OverThr\n"); break;
|
||
case 22: printf("\t\t CAEN_DGTZ_DPP_DIGITALPROBE_TRGOut\n"); break;
|
||
case 23: printf("\t\t CAEN_DGTZ_DPP_DIGITALPROBE_Coincidence \n"); break;
|
||
case 24: printf("\t\t CAEN_DGTZ_DPP_DIGITALPROBE_PileUp \n"); break;
|
||
case 25: printf("\t\t CAEN_DGTZ_DPP_DIGITALPROBE_Gate \n"); break;
|
||
case 26: printf("\t\t CAEN_DGTZ_DPP_DIGITALPROBE_GateShort \n"); break;
|
||
case 27: printf("\t\t CAEN_DGTZ_DPP_DIGITALPROBE_Trigger \n"); break;
|
||
case 28: printf("\t\t CAEN_DGTZ_DPP_DIGITALPROBE_None \n"); break;
|
||
case 29: printf("\t\t CAEN_DGTZ_DPP_DIGITALPROBE_BLFreeze \n"); break;
|
||
case 30: printf("\t\t CAEN_DGTZ_DPP_DIGITALPROBE_Busy \n"); break;
|
||
case 31: printf("\t\t CAEN_DGTZ_DPP_DIGITALPROBE_PrgVeto \n"); break;
|
||
}
|
||
}
|
||
}
|
||
|
||
ErrorMsg("end of OpenDigitizer");
|
||
|
||
if( isConnected ) {
|
||
ProgramBoard();
|
||
}
|
||
|
||
return ret;
|
||
}
|
||
|
||
int Digitizer::CloseDigitizer(){
|
||
|
||
if( !isConnected ) return 0;
|
||
isConnected = false;
|
||
printf("-------- Closing Digtizer Board : %d Port : %d \n", boardID, portID);
|
||
printf(" Model %s with handle %d using %s\n", BoardInfo.ModelName, handle, LinkType == CAEN_DGTZ_USB ? "USB" : "Optical Link");
|
||
ret = CAEN_DGTZ_SWStopAcquisition(handle);
|
||
ret |= CAEN_DGTZ_CloseDigitizer(handle);
|
||
|
||
data->FreeMemory();
|
||
|
||
return ret;
|
||
}
|
||
|
||
void Digitizer::ErrorMsg(string header){
|
||
switch (ret){
|
||
///case CAEN_DGTZ_Success : /** 0 */ printf("%s | Operation completed successfully.\n", header.c_str()); break;
|
||
case CAEN_DGTZ_CommError : /** -1 */ printf("%s | Communication Error.\n", header.c_str()); break;
|
||
case CAEN_DGTZ_GenericError : /** -2 */ printf("%s | Unspecified error.\n", header.c_str()); break;
|
||
case CAEN_DGTZ_InvalidParam : /** -3 */ printf("%s | Invalid parameter.\n", header.c_str()); break;
|
||
case CAEN_DGTZ_InvalidLinkType : /** -4 */ printf("%s | Invalid Link Type.\n", header.c_str()); break;
|
||
case CAEN_DGTZ_InvalidHandle : /** -5 */ printf("%s | Invalid device handler.\n", header.c_str()); break;
|
||
case CAEN_DGTZ_MaxDevicesError : /** -6 */ printf("%s | Maximum number of devices exceeded.\n", header.c_str()); break;
|
||
case CAEN_DGTZ_BadBoardType : /** -7 */ printf("%s | Operation not allowed on this type of board.\n", header.c_str()); break;
|
||
case CAEN_DGTZ_BadInterruptLev : /** -8 */ printf("%s | The interrupt level is not allowed.\n", header.c_str()); break;
|
||
case CAEN_DGTZ_BadEventNumber : /** -9 */ printf("%s | The event number is bad.\n", header.c_str()); break;
|
||
case CAEN_DGTZ_ReadDeviceRegisterFail : /** -10 */ printf("%s | Unable to read the registry.\n", header.c_str()); break;
|
||
case CAEN_DGTZ_WriteDeviceRegisterFail : /** -11 */ printf("%s | Unable to write the registry.\n", header.c_str()); break;
|
||
case CAEN_DGTZ_InvalidChannelNumber : /** -13 */ printf("%s | The channel number is invalid.\n", header.c_str()); break;
|
||
case CAEN_DGTZ_ChannelBusy : /** -14 */ printf("%s | The channel is busy.\n", header.c_str()); break;
|
||
case CAEN_DGTZ_FPIOModeInvalid : /** -15 */ printf("%s | Invalid FPIO mode.\n", header.c_str()); break;
|
||
case CAEN_DGTZ_WrongAcqMode : /** -16 */ printf("%s | Wrong Acquistion mode.\n", header.c_str()); break;
|
||
case CAEN_DGTZ_FunctionNotAllowed : /** -17 */ printf("%s | This function is not allowed on this module.\n", header.c_str()); break;
|
||
case CAEN_DGTZ_Timeout : /** -18 */ printf("%s | Communication Timeout.\n", header.c_str()); break;
|
||
case CAEN_DGTZ_InvalidBuffer : /** -19 */ printf("%s | The buffer is invalid.\n", header.c_str()); break;
|
||
case CAEN_DGTZ_EventNotFound : /** -20 */ printf("%s | The event is not found.\n", header.c_str()); break;
|
||
case CAEN_DGTZ_InvalidEvent : /** -21 */ printf("%s | The event is invalid.\n", header.c_str()); break;
|
||
case CAEN_DGTZ_OutOfMemory : /** -22 */ printf("%s | Out of memory.\n", header.c_str()); break;
|
||
case CAEN_DGTZ_CalibrationError : /** -23 */ printf("%s | Unable to calibrate the board.\n", header.c_str()); break;
|
||
case CAEN_DGTZ_DigitizerNotFound : /** -24 */ printf("%s | Unbale to open the digitizer.\n", header.c_str()); break;
|
||
case CAEN_DGTZ_DigitizerAlreadyOpen : /** -25 */ printf("%s | The digitizer is already open.\n", header.c_str()); break;
|
||
case CAEN_DGTZ_DigitizerNotReady : /** -26 */ printf("%s | The digitizer is not ready.\n", header.c_str()); break;
|
||
case CAEN_DGTZ_InterruptNotConfigured : /** -27 */ printf("%s | The digitizer has no IRQ configured.\n", header.c_str()); break;
|
||
case CAEN_DGTZ_DigitizerMemoryCorrupted: /** -28 */ printf("%s | The digitizer flash memory is corrupted.\n", header.c_str()); break;
|
||
case CAEN_DGTZ_DPPFirmwareNotSupported : /** -29 */ printf("%s | The digitier DPP firmware is not supported in this lib version.\n", header.c_str()); break;
|
||
case CAEN_DGTZ_InvalidLicense : /** -30 */ printf("%s | Invalid firmware licence.\n", header.c_str()); break;
|
||
case CAEN_DGTZ_InvalidDigitizerStatus : /** -31 */ printf("%s | The digitizer is found in a corrupted status.\n", header.c_str()); break;
|
||
case CAEN_DGTZ_UnsupportedTrace : /** -32 */ printf("%s | The given trace is not supported.\n", header.c_str()); break;
|
||
case CAEN_DGTZ_InvalidProbe : /** -33 */ printf("%s | The given probe is not supported.\n", header.c_str()); break;
|
||
case CAEN_DGTZ_UnsupportedBaseAddress : /** -34 */ printf("%s | The base address is not supported.\n", header.c_str()); break;
|
||
case CAEN_DGTZ_NotYetImplemented : /** -99 */ printf("%s | The function is not yet implemented.\n", header.c_str()); break;
|
||
}
|
||
|
||
}
|
||
|
||
int Digitizer::ProgramBoard(){
|
||
|
||
printf("----- program Board\n");
|
||
ret = CAEN_DGTZ_Reset(handle);
|
||
if (ret) {
|
||
printf("ERROR: can't reset the digitizer.\n");
|
||
return -1;
|
||
}
|
||
|
||
/// Board Configuration without PHA or PSD fireware
|
||
///bx0000 0000 0000 0000 0000 0000 0001 0000 =
|
||
/// | | +- (1) trigger overlap not allowed
|
||
/// | +- (3) test pattern disable
|
||
/// + (6) Self-trigger polarity, 1 = negative, 0 = Positive
|
||
ret = CAEN_DGTZ_WriteRegister(handle, (uint32_t) Register::BoardConfiguration , 0x000E0114); /// Channel Control Reg (indiv trg, seq readout) ??
|
||
|
||
/// Set the I/O level (CAEN_DGTZ_IOLevel_NIM or CAEN_DGTZ_IOLevel_TTL)
|
||
ret |= CAEN_DGTZ_SetIOLevel(handle, IOlev);
|
||
|
||
/// Set the enabled channels
|
||
ret |= CAEN_DGTZ_SetChannelEnableMask(handle, channelMask);
|
||
|
||
/// Set the number of samples for each waveform
|
||
SetRecordLength(2000); /// ns
|
||
|
||
/// Set Extras 2 to enable, this override Accusition mode, focring list mode
|
||
ret |= CAEN_DGTZ_WriteRegister(handle, Register::BoardConfiguration , 0x00E8114 );
|
||
|
||
/// Set how many events to accumulate in the board memory before being available for readout
|
||
SetEventAggregation(0); /// when zero, digitizer auto set
|
||
|
||
/// Set the digitizer acquisition mode (CAEN_DGTZ_SW_CONTROLLED or CAEN_DGTZ_S_IN_CONTROLLED)
|
||
ret |= CAEN_DGTZ_SetAcquisitionMode(handle, CAEN_DGTZ_SW_CONTROLLED); /// software command
|
||
ret |= CAEN_DGTZ_SetDPPAcquisitionMode(handle, AcqMode, CAEN_DGTZ_DPP_SAVE_PARAM_EnergyAndTime);
|
||
|
||
/** Set the digitizer's behaviour when an external trigger arrives:
|
||
CAEN_DGTZ_TRGMODE_DISABLED: do nothing
|
||
CAEN_DGTZ_TRGMODE_EXTOUT_ONLY: generate the Trigger Output signal
|
||
CAEN_DGTZ_TRGMODE_ACQ_ONLY = generate acquisition trigger
|
||
CAEN_DGTZ_TRGMODE_ACQ_AND_EXTOUT = generate both Trigger Output and acquisition trigger
|
||
see CAENDigitizer user manual, chapter "Trigger configuration" for details */
|
||
//TODO set bit
|
||
ret |= CAEN_DGTZ_SetExtTriggerInputMode(handle, CAEN_DGTZ_TRGMODE_ACQ_ONLY);
|
||
|
||
ret |= CAEN_DGTZ_SetRunSynchronizationMode(handle, CAEN_DGTZ_RUN_SYNC_Disabled);
|
||
|
||
ErrorMsg("End of ProgramBoard");
|
||
return ret;
|
||
|
||
}
|
||
|
||
//========================================================= ACQ control
|
||
void Digitizer::StartACQ(){
|
||
if ( AcqRun ) return;
|
||
ret = CAEN_DGTZ_SWStartAcquisition(handle);
|
||
if( ret != 0 ) {
|
||
ErrorMsg("Start ACQ");
|
||
return;
|
||
}
|
||
printf("\e[1m\e[33m======= Acquisition Started for Board %d\e[0m\n", boardID);
|
||
AcqRun = true;
|
||
}
|
||
|
||
void Digitizer::StopACQ(){
|
||
if( !AcqRun ) return;
|
||
int ret = CAEN_DGTZ_SWStopAcquisition(handle);
|
||
ret |= CAEN_DGTZ_ClearData(handle);
|
||
if( ret != 0 ) ErrorMsg("something wrong when try to stop ACQ and clear buffer");
|
||
printf("\n\e[1m\e[33m====== Acquisition STOPPED for Board %d\e[0m\n", boardID);
|
||
AcqRun = false;
|
||
}
|
||
|
||
unsigned int Digitizer::CalByteForBuffer(){
|
||
|
||
//TODO
|
||
unsigned int numAggBLT = ReadRegister(Register::DPP::MaxAggregatePerBlockTransfer);
|
||
|
||
/// Channel Mask
|
||
/// is takeing waveForm
|
||
/// Record Length
|
||
|
||
return 0;
|
||
|
||
}
|
||
|
||
void Digitizer::ReadData(){
|
||
if( !isConnected ) return;
|
||
if( data->buffer == NULL ) {
|
||
printf("need allocate memory for readout buffer\n");
|
||
return;
|
||
}
|
||
|
||
ret = CAEN_DGTZ_ReadData(handle, CAEN_DGTZ_SLAVE_TERMINATED_READOUT_MBLT, data->buffer, &(data->nByte));
|
||
printf("Read Buffer size %d byte \n", data->nByte);
|
||
if (ret || data->nByte == 0) {
|
||
ErrorMsg("ReadData");
|
||
return;
|
||
}
|
||
|
||
}
|
||
|
||
//===========================================================
|
||
void Digitizer::WriteRegister(uint32_t address, uint32_t value, int ch ){
|
||
if( !isConnected ) return;
|
||
if( address < 0x8000){
|
||
///printf("0x%x, 0x%x=%u, ch:%d\n", address, value, value, ch);
|
||
if( ch < 0 ) {
|
||
ret = CAEN_DGTZ_WriteRegister(handle, address + 0x7000, value);
|
||
for( int i = 0; i < NChannel; i++) EditByte(value, address + (i << 8));
|
||
}else{
|
||
ret = CAEN_DGTZ_WriteRegister(handle, address + (ch<<8), value);
|
||
EditByte( value, address + (ch<<8) );
|
||
}
|
||
}else{
|
||
ret = CAEN_DGTZ_WriteRegister(handle, address, value);
|
||
}
|
||
ErrorMsg("WriteRegister:" + std::to_string(address));
|
||
}
|
||
|
||
uint32_t Digitizer::ReadRegister(uint32_t address, int ch, string str ){
|
||
if( !isConnected ) return 0;
|
||
uint32_t * Data = new uint32_t[NChannel];
|
||
if( address < 0x8000) {
|
||
if( ch < 0 ) {
|
||
ret = CAEN_DGTZ_ReadRegister(handle, address + 0x7000, Data);
|
||
}else{
|
||
ret = CAEN_DGTZ_ReadRegister(handle, address + (ch << 8), Data);
|
||
}
|
||
}else{
|
||
ret = CAEN_DGTZ_ReadRegister(handle, address, Data);
|
||
}
|
||
ErrorMsg("ReadRegister:" + std::to_string(address));
|
||
if( str != "" ) printf("%s : 0x%x \n", str.c_str(), Data[0]);
|
||
return Data[0];
|
||
}
|
||
|
||
void Digitizer::SetChannelMask(uint32_t mask){
|
||
if( !isConnected ) return;
|
||
channelMask = mask;
|
||
ret |= CAEN_DGTZ_SetChannelEnableMask(handle, channelMask);
|
||
EditByteByRegister(Register::DPP::ChannelEnableMask);
|
||
ErrorMsg("SetChannelMask");
|
||
}
|
||
|
||
void Digitizer::SetRecordLength(unsigned int ns, int ch){
|
||
WriteRegister( Register::DPP::RecordLength_G, ns / ch2ns / 8 , ch);
|
||
if( ch >= 0 ) WriteRegister( Register::DPP::RecordLength_G, ns / ch2ns / 8 , ch + int(pow(-1, ch)));
|
||
ErrorMsg("SetRecordLength");
|
||
}
|
||
|
||
void Digitizer::SetAggregateOrganization(unsigned int bit){
|
||
WriteRegister(Register::DPP::AggregateOrganization, bit & 0x7);
|
||
ErrorMsg("SetAggregateOrganization");
|
||
}
|
||
|
||
|
||
void Digitizer::SetEventAggregation(unsigned int numEvent, int ch){
|
||
WriteRegister( Register::DPP::NumberEventsPerAggregate_G,numEvent, ch);
|
||
if( ch >= 0 ) WriteRegister( Register::DPP::NumberEventsPerAggregate_G,numEvent, ch + int(pow(-1, ch)));
|
||
ErrorMsg("SetEventAggregation");
|
||
}
|
||
|
||
void Digitizer::SetMaxAggregatePerBlockTransfer(unsigned int numEvent){
|
||
WriteRegister( Register::DPP::MaxAggregatePerBlockTransfer,numEvent);
|
||
ErrorMsg("SetMaxNumberOfAggregatePerBlockTransfer");
|
||
}
|
||
|
||
|
||
void Digitizer::SetACQControl(uint32_t bit){
|
||
WriteRegister( Register::DPP::AcquisitionControl, bit);
|
||
ErrorMsg("SetACQControl");
|
||
}
|
||
|
||
void Digitizer::SetGlobalTriggerMask(uint32_t bit){
|
||
WriteRegister( Register::DPP::GlobalTriggerMask, bit);
|
||
ErrorMsg("SetGlobalTriggerMask");
|
||
}
|
||
|
||
void Digitizer::SetFrontPanelTRGOUTMask(uint32_t bit){
|
||
WriteRegister( Register::DPP::FrontPanelTRGOUTEnableMask, bit);
|
||
ErrorMsg("SetFrontPanelTRGOUTMask");
|
||
}
|
||
|
||
void Digitizer::SetFrontPanelIOControl(uint32_t bit){
|
||
WriteRegister( Register::DPP::FrontPanelIOControl, bit);
|
||
ErrorMsg("SetFrontPanelIOControl");
|
||
}
|
||
|
||
void Digitizer::SetTriggerValidationMask(uint32_t bit){
|
||
WriteRegister( Register::DPP::TriggerValidationMask, bit);
|
||
ErrorMsg("SetTriggerValidationMask");
|
||
}
|
||
|
||
void Digitizer::SetInputDynamicRange(unsigned int TwoVol_0_or_halfVol_1, int ch){ WriteRegister( Register::DPP::InputDynamicRange, TwoVol_0_or_halfVol_1, ch); ErrorMsg("SetInputDynamicRange");}
|
||
void Digitizer::SetPreTriggerSample(unsigned int nSample, int ch) { WriteRegister( Register::DPP::PreTrigger, nSample / 4, ch); ErrorMsg("SetPreTriggerSample");}
|
||
void Digitizer::SetPreTriggerDuration(unsigned int ns, int ch) { WriteRegister( Register::DPP::PreTrigger, ns / ch2ns / 4, ch); ErrorMsg("SetPreTriggerSample");}
|
||
void Digitizer::SetDCOffset(float offsetPrecentage, int ch) { WriteRegister( Register::DPP::ChannelDCOffset, uint( 0xFFFF * (1.0-offsetPrecentage)), ch ); ErrorMsg("SetDCOffset");}
|
||
void Digitizer::SetVetoWidth(uint32_t bit, int ch) { WriteRegister( Register::DPP::VetoWidth, bit, ch); ErrorMsg("SetVetoWidth");}
|
||
|
||
void Digitizer::SetTriggerPolarity(bool RiseingIsZero, int ch ){
|
||
if( !isConnected ) return;
|
||
if ( DPPType >= 128 ) return; /// do thing for DPP firmware
|
||
if( ch < 0 ) {
|
||
ret = 0;
|
||
for (int i = 0; i < NChannel; i++){
|
||
ret |= CAEN_DGTZ_SetTriggerPolarity(handle, i, CAEN_DGTZ_TriggerPolarity_t(RiseingIsZero));
|
||
}
|
||
}else{
|
||
ret = CAEN_DGTZ_SetTriggerPolarity(handle, ch, CAEN_DGTZ_TriggerPolarity_t(RiseingIsZero));
|
||
}
|
||
if( ret != 0 ) ErrorMsg("SetTriggerPolarity");
|
||
}
|
||
|
||
|
||
//============================== DPP-Alpgorthm Control
|
||
void Digitizer::SetDPPAlgorithmControl(uint32_t bit, int ch){
|
||
///============= DPP algorithm control is 32 bit
|
||
/// [ 0: 5] Trapazoid Rescaling. the trapazoid ADC is 48 bit. it need to bit-shift before the 0x3FFF (14 bit filter)
|
||
/// [ 8: 9] Decimation. 00 = disable, 01 = 2 samples, 10 = 4 samples, 11 = 8 sample
|
||
/// [10:11] Decimation Gain. This gain apply to the Trapazoid Rescaling and fine gain
|
||
/// [12:13] Peak Mean. sample for averaging the trapezoid height calculation. 00 = 1 sample, 01 = 4 samples, 10 = 16 sample, 11 = 64 sample
|
||
/// [16] pulse polarity. 0 = positve, 1 = negative
|
||
/// [18:19] Trigger mode. 00 = normal, 01 = coincident, 10 = reserved. 11 = anti coincident
|
||
/// [20:22] number of samples for the baseline average calculation. 000 = baseline disable (energy not subtraced with baseline)
|
||
/// 001 = 16 samples
|
||
/// 010 = 64 samples
|
||
/// 011 = 256 samples
|
||
/// 100 = 1024 samples
|
||
/// 101 = 4096 samples
|
||
/// 110 = 16384 samples
|
||
/// 111 = resertved.
|
||
/// [24] Disable self trigger. 0 = self‐trigger used to acquire and propagated to the trigger logic;
|
||
/// 1 = self‐trigger only propagated to the trigger logic.
|
||
/// [26] Enable Roll-Over flag. see manual 0 = disable, 1 = enable
|
||
/// [27] Enable pile-up flag.
|
||
|
||
///============= PHA - DPP algorithm control 2 is 32 bit
|
||
/// [ 0: 1] Local Shaped Trigger mode. see manual
|
||
/// [ 2] Enable Local Shaped Trigger
|
||
/// [ 4: 5] Local Trigger Validation mode, see manual
|
||
/// [ 6] Enable Local Trigger Validation
|
||
/// [ 8:10] Extra 2 word option. 000 = [0:15] baseline *4 [16:31] extended time stamp
|
||
/// 001 = reserved
|
||
/// 010 = [0:15] fine time stamp [16:31] extended time stamp
|
||
/// 011 = reserved
|
||
/// 100 = [0:15] total tigger counter [16:31] Lost trigger counter
|
||
/// 101 = [0:15] event after the zero crosiing [16:31] event before zero crossing
|
||
/// 110, 111 = reserved.
|
||
/// [14:15] source of veto. 00 = disable, 01 veto is common to all channels, 10 = veto for coupled channels, 11 = veto comes from negative saturation
|
||
/// [16:17] Select the step for the trigger counter rate flag. see manual
|
||
/// [18] baseline calculation is active also when the acquisition is not running. 0 = disbale, 1 = enable
|
||
/// [19] Tag correlated events. see manual 0 = disbale, 1 = enable
|
||
/// [29] Enable the optimization of the Baseline Restorer to avoid tails in the energy peaks. 0 = disbale, 1 = enable
|
||
|
||
WriteRegister( Register::DPP::DPPAlgorithmControl, bit, ch);
|
||
if( ret != 0 ) ErrorMsg("SetDPPAlgorithmControl");
|
||
}
|
||
|
||
unsigned int Digitizer::ReadBits(uint32_t address, unsigned int bitLength, unsigned int bitSmallestPos, int ch ){
|
||
uint32_t bit ;
|
||
uint32_t bitmask = (uint(pow(2, bitLength)-1) << bitSmallestPos);
|
||
int tempCh = ch;
|
||
if (ch < 0 && address < 0x8000 ) tempCh = 0; /// take ch-0
|
||
bit = ReadRegister(address, tempCh);
|
||
///printf("bit : 0x%x, bitmask : 0x%x \n", bit, bitmask);
|
||
bit = (bit & ~bitmask);
|
||
return bit;
|
||
}
|
||
|
||
void Digitizer::SetBits(uint32_t address, unsigned int bitValue, unsigned int bitLength, unsigned int bitSmallestPos, int ch){
|
||
///printf("address : 0x%x, value : 0x%x, len : %d, pos : %d, ch : %d \n", address, bitValue, bitLength, bitSmallestPos, ch);
|
||
uint32_t bit ;
|
||
uint32_t bitmask = (uint(pow(2, bitLength)-1) << bitSmallestPos);
|
||
int tempCh = ch;
|
||
if (ch < 0 && address < 0x8000 ) tempCh = 0; /// take ch-0
|
||
bit = ReadRegister(address, tempCh);
|
||
///printf("bit : 0x%x, bitmask : 0x%x \n", bit, bitmask);
|
||
bit = (bit & ~bitmask) | (bitValue << bitSmallestPos);
|
||
///printf("bit : 0x%x, ch : %d \n", bit, ch);
|
||
WriteRegister(address, bit, ch);
|
||
if( ret != 0 ) ErrorMsg("SetBits");
|
||
}
|
||
|
||
int Digitizer::GetChTemperature(int ch){
|
||
if( !isConnected ) return -404;
|
||
if( BoardInfo.Model != CAEN_DGTZ_V1730 &&
|
||
BoardInfo.Model != CAEN_DGTZ_V1725 &&
|
||
BoardInfo.Model != CAEN_DGTZ_V1751 ) return -404;
|
||
|
||
uint32_t * temp;
|
||
ret |= CAEN_DGTZ_ReadTemperature(handle, ch, temp);
|
||
if( ret != 0 ) ErrorMsg("GetChTemperature");
|
||
return temp[0];
|
||
}
|
||
|
||
void Digitizer::PrintACQStatue(){
|
||
if( !isConnected ) return;
|
||
unsigned int status = ReadRegister(Register::DPP::AcquisitionStatus);
|
||
|
||
printf("=================== Print ACQ status \n");
|
||
printf(" 32 28 24 20 16 12 8 4 0\n");
|
||
printf(" | | | | | | | | |\n");
|
||
cout <<" 0b" << bitset<32>(status) << endl;
|
||
printf(" Acq state (0x%1x): %s \n", (status >> 2) & 0x1, ((status >> 2) & 0x1) == 0? "stopped" : "running");
|
||
printf(" Event Ready (0x%1x): %s \n", (status >> 3) & 0x1, ((status >> 3) & 0x1) == 0? "no event in buffer" : "event in buffer");
|
||
printf(" Event Full (0x%1x): %s \n", (status >> 4) & 0x1, ((status >> 4) & 0x1) == 0? "not full" : "full");
|
||
printf(" Clock source (0x%1x): %s \n", (status >> 5) & 0x1, ((status >> 5) & 0x1) == 0? "internal" : "external");
|
||
printf(" Board ready (0x%1x): %s \n", (status >> 8) & 0x1, ((status >> 8) & 0x1) == 0? "not ready" : "ready");
|
||
printf(" Ch shutDown (0x%1x): %s \n", (status >> 19) & 0x1, ((status >> 19) & 0x1) == 0? "Channels are on" : "channels are shutdown");
|
||
printf(" TRG-IN 0x%1x \n", (status >> 16) & 0x1);
|
||
printf(" Ch temp state 0x%04x \n", (status >> 20) & 0xF);
|
||
|
||
}
|
||
|
||
//========================================== setting file IO
|
||
void Digitizer::OpenSettingBinary(string fileName){
|
||
settingFile = NULL;
|
||
this->settingFileName = fileName;
|
||
settingFile = fopen(fileName.c_str(), "r+");
|
||
if( settingFile == NULL ){
|
||
printf("cannot open file %s. \n", fileName.c_str());
|
||
CreateAndSaveSettingBinary(fileName);
|
||
}else{
|
||
settingFileExist = true;
|
||
}
|
||
}
|
||
|
||
void Digitizer::CreateAndSaveSettingBinary(string fileName){
|
||
/// for 1 digitizer, 16 channels, needs 0x10XX to 0x1FXX
|
||
/// Board setting is 0x8000 --> 0x0000
|
||
/// Saved date YYYYMMDDHH --> 0x0004
|
||
/// Global Trigger Mask 0x810C --> 0x010C
|
||
/// Channel mask 0x8120 --> 0x0120
|
||
/// ROM Board version 0xF030 --> 0x0030
|
||
/// Board Form factor 0xF034 --> 0x0034
|
||
/// Board ID Byte 1 0xF038 --> 0x0038
|
||
/// Board ID Byte 0 0xF03C --> 0x003C
|
||
/// Board Serial Num Byte1 0xF080 --> 0x0080
|
||
/// Board Serial Num Byte0 0xF084 --> 0x0084 /// serial number = byte0 << 8 + byte1
|
||
/// ROC fireware version is 0x8124 --> 0x0124
|
||
/// Board Info is 0x8140 --> 0x0140
|
||
/// -------------------------------------
|
||
/// for 1 channel is 0x2000 = 8192 byte should be enough for all setting for 1 board
|
||
|
||
settingFileName = fileName;
|
||
settingFile = fopen(settingFileName.c_str(), "w+");
|
||
unsigned int haha[1] = {0x00000000}; /// 4 bytes
|
||
|
||
for(int i = 0; i < 8192/4 ; i++){
|
||
fwrite(haha, sizeof(unsigned int), 1, settingFile);
|
||
}
|
||
|
||
fseek(settingFile, 0L, SEEK_END);
|
||
unsigned int inFileSize = ftell(settingFile);
|
||
printf("Created file : %s. file size : %d Byte\n", settingFileName.c_str(), inFileSize);
|
||
fclose (settingFile);
|
||
settingFileExist = true;
|
||
|
||
///Save board setting
|
||
EditByteByRegister(Register::DPP::BoardConfiguration); /// 0x8000
|
||
EditByteByRegister(Register::DPP::AggregateOrganization); /// 0x800C
|
||
EditByteByRegister(Register::DPP::GlobalTriggerMask); /// 0x810C
|
||
EditByteByRegister(Register::DPP::ChannelEnableMask); /// 0x8120
|
||
EditByteByRegister(Register::DPP::ROM_BoardVersion); /// 0xF030
|
||
EditByteByRegister(Register::DPP::ROM_BoardFromFactor); /// 0xF034
|
||
EditByteByRegister(Register::DPP::ROM_BoardIDByte1); /// 0xF038
|
||
EditByteByRegister(Register::DPP::ROM_BoardIDByte0); /// 0xF03C
|
||
EditByteByRegister(Register::DPP::ROM_BoardSerialNumByte1); /// 0xF080
|
||
EditByteByRegister(Register::DPP::ROM_BoardSerialNumByte0); /// 0xF084
|
||
EditByteByRegister(Register::DPP::FrontPanelTRGOUTEnableMask); /// 0x8110
|
||
EditByteByRegister(Register::DPP::FrontPanelIOControl); /// 0x811C
|
||
EditByteByRegister(Register::DPP::ROCFPGAFirmwareRevision); /// 0x8124
|
||
EditByteByRegister(Register::DPP::BoardInfo); /// 0x8140
|
||
EditByteByRegister(Register::DPP::DisableExternalTrigger); /// 0x817C
|
||
EditByteByRegister(Register::DPP::TriggerValidationMask); /// 0x8180
|
||
EditByteByRegister(Register::DPP::MaxAggregatePerBlockTransfer); /// 0xEF1C
|
||
|
||
|
||
///================ channel settings
|
||
for( int ch = 0; ch < NChannel ; ch++){
|
||
|
||
EditByteByRegister(Register::DPP::RecordLength_G, ch);
|
||
EditByteByRegister(Register::DPP::InputDynamicRange, ch);
|
||
EditByteByRegister(Register::DPP::PreTrigger, ch);
|
||
EditByteByRegister(Register::DPP::ChannelDCOffset, ch);
|
||
EditByteByRegister(Register::DPP::NumberEventsPerAggregate_G, ch);
|
||
EditByteByRegister(Register::DPP::DPPAlgorithmControl, ch);
|
||
EditByteByRegister(Register::DPP::AMCFirmwareRevision, ch);
|
||
EditByteByRegister(Register::DPP::VetoWidth, ch);
|
||
|
||
if( DPPType == 0x8B ) { /// DPP-PHA
|
||
EditByteByRegister(Register::DPP::PHA::TriggerThreshold, ch);
|
||
EditByteByRegister(Register::DPP::PHA::RCCR2SmoothingFactor, ch);
|
||
EditByteByRegister(Register::DPP::PHA::RiseTimeValidationWindow, ch);
|
||
EditByteByRegister(Register::DPP::PHA::TriggerHoldOffWidth, ch);
|
||
EditByteByRegister(Register::DPP::PHA::InputRiseTime, ch);
|
||
EditByteByRegister(Register::DPP::PHA::ShapedTriggerWidth, ch);
|
||
|
||
EditByteByRegister(Register::DPP::PHA::TrapezoidRiseTime, ch);
|
||
EditByteByRegister(Register::DPP::PHA::TrapezoidFlatTop, ch);
|
||
EditByteByRegister(Register::DPP::PHA::DecayTime, ch);
|
||
EditByteByRegister(Register::DPP::PHA::PeakingTime, ch);
|
||
EditByteByRegister(Register::DPP::PHA::PeakHoldOff, ch);
|
||
|
||
EditByteByRegister(Register::DPP::PHA::DPPAlgorithmControl2_G, ch);
|
||
EditByteByRegister(Register::DPP::PHA::FineGain, ch);
|
||
}
|
||
}
|
||
|
||
}
|
||
|
||
unsigned long Digitizer::ReadSettingBinary(uint32_t filePos, int ch){
|
||
if ( !settingFileExist ) return -1;
|
||
|
||
if( filePos >= 0x8000 ) {
|
||
filePos = filePos & 0x0FFF;
|
||
}else{
|
||
if( ch >= 0 ) {
|
||
filePos = filePos + (ch << 8);
|
||
}else{
|
||
return -1;
|
||
}
|
||
}
|
||
|
||
settingFile = fopen (settingFileName.c_str(),"r");
|
||
fseek( settingFile, filePos, SEEK_SET);
|
||
///printf(" at pos %lu \n", ftell(settingFile));
|
||
unsigned int lala[1];
|
||
size_t dummy = fread( lala, sizeof(unsigned int), 1, settingFile);
|
||
///printf(" data at pos %lu : %x \n", ftell(settingFile), lala[0]);
|
||
fclose (settingFile);
|
||
return lala[0];
|
||
}
|
||
|
||
void Digitizer::EditByte(unsigned int value, uint32_t filePos){
|
||
if ( !settingFileExist ) return ;
|
||
|
||
if( filePos >= 0x8000 ) filePos = filePos & 0x0FFF;
|
||
///printf(" file Pos : 0x%x \n", filePos);
|
||
settingFile = fopen (settingFileName.c_str(),"r+");
|
||
fseek( settingFile, filePos, SEEK_SET);
|
||
unsigned int jaja[1] = {value};
|
||
size_t dummy = fwrite( jaja, sizeof(unsigned int), 1, settingFile);
|
||
///printf("fwrie ret : %d, %x = %d\n", (int)dummy, jaja[0], jaja[0]);
|
||
fclose (settingFile);
|
||
}
|
||
|
||
void Digitizer::EditByteByRegister(uint32_t registerAddress, int ch){
|
||
EditByte( ReadRegister(registerAddress, ch), registerAddress);
|
||
}
|