commit 240a35aba64a50d170ebd8ed05a044ffc15b0e6f Author: splitPoleDAQ Date: Wed Aug 3 19:00:41 2022 -0400 building the digitizer class diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..9daeafb --- /dev/null +++ b/.gitignore @@ -0,0 +1 @@ +test diff --git a/DigitizerClass.h b/DigitizerClass.h new file mode 100644 index 0000000..029f9f7 --- /dev/null +++ b/DigitizerClass.h @@ -0,0 +1,855 @@ +#ifndef DIGITIZER_H +#define DIGITIZER_H + +#include +#include +#include +#include +#include ///memset +#include ///cout +#include + +//#include +//#include + +#include "CAENDigitizer.h" +#include "CAENDigitizerType.h" + +#include "RegisterAddress.h" + +#define MaxNChannels 16 +#define MaxRecordLength 0x1fff /// 8191 + +using namespace std; + + +struct DigitizerChannelSetting { + + /// combined all DPP, PHA, and PSD + unsigned int recordLength; /// ch + unsigned int EventAggr; /// number of events in one aggregate (0=automatic), number of event acculated for read-off + unsigned int dynamicRange; /// 0 = 2 Vpp, 1 = 0.5 Vpp + unsigned int preTrigger; /// the number of samples before the trigger in the waveform saved into memory + float DCOffsetPrecentage; /// precentage of Max ADC + uint32_t VetoWidth; /// see manual, uint32_t to ensure it is 32 bit + bool triggerPolarity; /// 0 = on rising edge, 1 = on falling edge + + uint32_t DPPAlgorithmControl; + unsigned int baselineSampling; + unsigned int peakSampling; + bool pulsePolarity_DPP; /// 0 = positive, 1 = negative + bool rollOverFlag; + bool pileUpFlag; + + uint32_t DPPAlgorithmControl2; + + unsigned int triggerThreshold; /// [LSB] + unsigned int triggerHoldOff; /// [ch], Other triggers are inhibited for the overall Trigger Hold‐Off duration. + + + unsigned int shapedTriggerWidth; + + + /// PHA + unsigned int triggerSmoothingFactor; /// 0x0 = disabled; 0x1 = 2 sample; 0x2 = 4 samples; 0x4 = 8 samples; 0x8 = 16 samples; 0x10 = 32 samples; 0x20 = 64 samples; 0x3F = 128 samples + unsigned int inputRiseTime; /// [ch] + + unsigned int trapRiseTime; /// [ch] + unsigned int trapFlatTop; /// [ch] + unsigned int decayTime; /// [ch] + unsigned int peakingTime; /// [ch] flatTop delay, where the samples are used for the calculation of the peak height + unsigned int peakHoldOff; /// [ch] how close must be two trapezoids to be considered piled‐up after the start of flat top + + unsigned int fineGain; + unsigned int riseTimeValidWindow; /// [ch] used by the rise time discriminator (RTD) to reject pulses that overlap in the rise time + + + /// PDS + unsigned int cfdSetting; + unsigned int chargeZeroSuppThreshold; + unsigned int shortGateWidth; + unsigned int longGateWidth; + unsigned int gateOffset; + unsigned int fixedBaseline; + unsigned int triggerLatency; + unsigned int thresholdPSDCut; + unsigned int pureGapThreshold; + unsigned int earlyBaselineFreeze; + +}; + +//################################################################ + +class Digitizer{ + + public: + Digitizer(); + Digitizer(int boardID, int portID = 0); + ~Digitizer(); + + void Reset(); + int OpenDigitizer(int boardID, int portID = 0);/// portID is for optical link for using PCIe card, from 0, 1, 2, 3 + int CloseDigitizer(); + + ///=================Settings + void WriteRegister(uint32_t address, uint32_t value, int ch = -1); + uint32_t ReadRegister(uint32_t address, unsigned int ch); + + ///common for PHA and PSD digitizers + void SetChannelMask(uint32_t mask); + void SetRecordLength(unsigned int lenght, int ch = -1); /// when ch == -1, mean set all channels + void SetEventAggregation(unsigned int numEvent, int ch = -1); + void SetInputDynamicRange(unsigned int TwoVol_0_or_halfVol_1, int ch = -1); + void SetNumSamplePreTrigger(unsigned int nSample, int ch = -1 ); + void SetDCOffset(float offsetPrecentage, int ch = -1); + void SetVetoWidth(uint32_t bit, int ch = -1); /// See manual + void SetTriggerPolarity(bool RiseingIsZero, int ch = -1); + + void SetDPPAlgorithmControl(uint32_t bit, bool useControl2 = false, int ch = -1); + void SetDPPAlgorithmControlBit(unsigned int bitValue, unsigned int bitLength, unsigned int bitSmallestPos, bool useControl2 = false, int ch = -1); + void SetTrapezoidRescaling(unsigned int rightShiftBits, int ch = -1); /// DPPAlgoritmControl bit-0:5 + void SetPeakSampling(unsigned int bit, int ch = -1); /// DPPAlgoritmControl bit-10:11 + void SetPulsePolarity(bool PositiveIsZero, int ch = -1); /// DPPAlgoritmControl bit-16 + void SetBaselineSampling(unsigned int bit, int ch = -1); /// DPPAlgoritmControl bit-20:22 + void SetRollOverFlag(bool isRollOver, int ch = -1); /// DPPAlgoritmControl bit-26 + void SetPileUpFlag(bool isPileUpFlag, int ch = -1); /// DPPAlgoritmControl bit-27 + + //int SetChannelParity(int ch, bool isPositive); + //int SetChannelThreshold(int ch, string folder, int threshold); + //int SetInputDynamicRange(int ch, string folder, int dyRange); + + int SetAcqMode(string mode); + + ///================ Get Settings + int GetSerialNumber() {return BoardInfo.SerialNumber;} + int GetChannelMask() {return channelMask;} + float GetCh2ns() {return ch2ns;} + int GetNChannel() {return NChannel;} + + + int GetChTemperature(int ch) ; + + + void PrintBoardConfiguration(); + uint32_t GetChannelStatus(unsigned int ch); + + + ///================ ACQ control + void StopACQ(); + void StartACQ(); + + protected: + + ///---- fixed parameter + int portID; /// port ID for optical link for using PCIe card, from 0, 1, 2, 3 + int boardID; /// board identity + int handle; /// i don't know why, but better separete the handle from boardID + int NChannel; /// number of channel + int ADCbits; /// ADC bit + int DPPType; /// DPP verion + unsigned int ADCFullSize; /// pow(2, ADCbits) - 1 + float ch2ns; /// channel to ns + CAEN_DGTZ_BoardInfo_t BoardInfo; + + + ///----- adjustable parameters + uint32_t VMEBaseAddress; /// For direct USB or Optical-link connection, VMEBaseAddress must be 0 + CAEN_DGTZ_ConnectionType LinkType; + CAEN_DGTZ_IOLevel_t IOlev; /// TTL signal (1 = 1.5 to 5V, 0 = 0 to 0.7V ) or NIM signal (1 = -1 to -0.8V, 0 = 0V) + CAEN_DGTZ_DPP_AcqMode_t AcqMode; + + uint32_t channelMask ; /// the channel mask from NChannel + DigitizerChannelSetting setting[MaxNChannels]; + + + ///------- other parameters + int ret; /// return value, refer to CAEN_DGTZ_ErrorCode + bool isConnected; + + ///========== + virtual int ProgramBoard(); + void ErrorMsg(string header = ""); +}; + +//========================================== methods + +Digitizer::Digitizer(){ + + portID = -1; + boardID = -1; + handle = -1; + NChannel = 0; + ADCbits = 1; + ch2ns = 0; + BoardInfo = {}; + + channelMask = 0xFFFF; + for( int ch = 0; ch < MaxNChannels ; ch ++ ) { + setting[ch] = {}; + setting[ch].recordLength = 2000; + setting[ch].EventAggr = 0; + } + ret = -1; + + isConnected = false; + + 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 + +} + +Digitizer::Digitizer(int boardID, int portID){ + Digitizer(); + OpenDigitizer(boardID, portID); +} + +Digitizer::~Digitizer(){ + CloseDigitizer(); +} + +void Digitizer::Reset(){ + ret = CAEN_DGTZ_Reset(handle); + if( ret != 0 ) ErrorMsg("Reset"); +} + +int Digitizer::OpenDigitizer(int boardID, int portID){ + + this->boardID = boardID; + this->portID = portID; + + /***************************************************/ + /** Open the digitizer and read board information */ + /***************************************************/ + + 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) { + printf("Can't open digitizer\n"); + }else{ + ///----- Getting Board Info + ret = (int) CAEN_DGTZ_GetInfo(handle, &BoardInfo); + if (ret != 0) { + printf("Can't read board info\n"); + }else{ + isConnected = true; + printf("Connected to Model %s with handle %d using %s\n", BoardInfo.ModelName, handle, LinkType == CAEN_DGTZ_USB ? "USB" : "Optical Link"); + 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 + } + 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); + ADCbits = BoardInfo.ADC_NBits; + ADCFullSize = (unsigned int)( pow(2, ADCbits) -1 ); + 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 != V1730_DPP_PHA_CODE) { + printf("This digitizer does not have DPP-PHA firmware\n"); + } + } + } + + // Check firmware revision (DPP firmwares cannot be used with this demo */ + sscanf(BoardInfo.AMC_FirmwareRel, "%d", &DPPType); + if (DPPType >= 128) { + printf("\t==== This digitizer has a DPP firmware!\n"); + printf("\e[32m"); + switch (DPPType){ + case 0x80: printf("\tDPP-PHA for x724 boards \n"); break; + case 0x82: printf("\tDPP-CI for x720 boards \n"); break; + case 0x83: printf("\tDPP-PSD for x720 boards \n"); break; + case 0x84: printf("\tDPP-PSD for x751 boards \n"); break; + case 0x85: printf("\tDPP-ZLE for x751 boards \n"); break; + case 0x86: printf("\tDPP-PSD for x743 boards \n"); break; + case 0x87: printf("\tDPP-QDC for x740 boards \n"); break; + case 0x88: printf("\tDPP-PSD for x730 boards \n"); break; + case 0x8B: printf("\tDPP-PHA for x730 boards \n"); break; + case 0x8C: printf("\tDPP-ZLE for x730 boards \n"); break; + case 0x8D: printf("\tDPP-DAW for x730 boards \n"); break; + } + printf("\e[0m"); + } + + int probes[MAX_SUPPORTED_PROBES]; + int numProbes; + ret = CAEN_DGTZ_GetDPP_SupportedVirtualProbes(handle, 1, probes, &numProbes); + 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(){ + + 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); + + 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; + } + +} + +void Digitizer::PrintBoardConfiguration(){ + uint32_t * value = new uint32_t[1]; + CAEN_DGTZ_ReadRegister(handle, (uint32_t) Register::BoardConfiguration, value); + printf(" 32 28 24 20 16 12 8 4 0\n"); + printf(" | | | | | | | | |\n"); + cout <<" Board Configuration : 0b" << bitset<32>(value[0]) << endl; + printf(" Bit[ 0] = Auto Data Flush \n"); + printf(" Bit[16] = WaveForm Recording \n"); + printf(" Bit[17] = Extended Time Tag \n"); + printf(" Bit[18] = Record Time Stamp \n"); + printf(" Bit[19] = Record Energy \n"); + printf("====================================== \n"); +} + +int Digitizer::ProgramBoard(){ + + 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); /// default 2000 ch + ///ret |= CAEN_DGTZ_SetRecordLength(handle, recordLength); + + /// Set how many events to accumulate in the board memory before being available for readout + SetEventAggregation(0); + ///ret |= CAEN_DGTZ_SetDPPEventAggregation(handle, EventAggr, 0); + + /// 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 */ + ret |= CAEN_DGTZ_SetExtTriggerInputMode(handle, CAEN_DGTZ_TRGMODE_ACQ_ONLY); + + /** Set the mode used to syncronize the acquisition between different boards. + In this example the sync is disabled */ + ret |= CAEN_DGTZ_SetRunSynchronizationMode(handle, CAEN_DGTZ_RUN_SYNC_Disabled); + + if (ret) { + ErrorMsg("End of ProgramBoard"); + return ret; + } else { + return 0; + } +} + +//=========================================================== +void Digitizer::WriteRegister(uint32_t address, uint32_t value, int ch ){ + if( ch < 0 ) { + ret = CAEN_DGTZ_WriteRegister(handle, address + 0x7000, value); + }else{ + ret = CAEN_DGTZ_WriteRegister(handle, address + (ch<<8), value); + } + if( ret != 0 ) ErrorMsg("WriteRegister"); +} + +uint32_t Digitizer::ReadRegister(uint32_t address, unsigned int ch = 0){ + uint32_t * Data = new uint32_t[NChannel]; + if( ch < 0 ) { + ret = CAEN_DGTZ_ReadRegister(handle, address + 0x7000, Data); + }else{ + ret = CAEN_DGTZ_ReadRegister(handle, address + (ch << 8), Data); + } + if( ret != 0 ) ErrorMsg("ReadRegister"); + ///printf("ch = %2d | %d \n", ch, Data[0]); + return Data[0]; +} + +void Digitizer::SetChannelMask(uint32_t mask){ + channelMask = mask; + ret |= CAEN_DGTZ_SetChannelEnableMask(handle, channelMask); + if( ret != 0 ) ErrorMsg("SetChannelMask"); +} + +void Digitizer::SetRecordLength(unsigned int lenght, int ch){ + if ( ch < 0 ){ + for( int i = 0; i < MaxNChannels; i++ ) setting[i].recordLength = min((int)lenght, MaxRecordLength ); + ret |= CAEN_DGTZ_SetRecordLength(handle, lenght); + }else{ + setting[ch].recordLength = min((int)lenght, MaxRecordLength ); + WriteRegister((uint32_t) RegisterDPP::RecordLength, setting[ch].recordLength, ch); + } + if( ret != 0 ) ErrorMsg("SetRecordLength"); +} + +void Digitizer::SetEventAggregation(unsigned int numEvent, int ch){ + if( ch < 0 ){ + for( int i = 0; i < MaxNChannels; i++ ) setting[i].EventAggr = numEvent; + ret |= CAEN_DGTZ_SetDPPEventAggregation(handle, numEvent, 0); + }else{ + setting[ch].EventAggr = numEvent; + WriteRegister((uint32_t) RegisterDPP::NumberEventsPerAggregate, numEvent, ch); + } + if( ret != 0 ) ErrorMsg("SetEventAggregation"); +} + +void Digitizer::SetInputDynamicRange(unsigned int TwoVol_0_or_halfVol_1, int ch){ + if( ch < 0 ) { + for( int i = 0; i < MaxNChannels; i++) setting[i].dynamicRange = TwoVol_0_or_halfVol_1; + }else{ + setting[ch].dynamicRange = TwoVol_0_or_halfVol_1; + } + WriteRegister((uint32_t) Register::InputDynamicRange, TwoVol_0_or_halfVol_1, ch); + if( ret != 0 ) ErrorMsg("SetInputDynamicRange"); +} + +void Digitizer::SetNumSamplePreTrigger(unsigned int nSample, int ch){ + if( ch < 0 ) { + for( int i = 0; i < MaxNChannels; i++) setting[i].preTrigger = nSample; + }else{ + setting[ch].preTrigger = nSample; + } + WriteRegister((uint32_t) RegisterDPP::PreTrigger, nSample, ch); + if( ret != 0 ) ErrorMsg("SetNumSamplePreTrigger"); +} + +void Digitizer::SetDCOffset(float offsetPrecentage, int ch){ + if( ch < 0 ) { + for( int i = 0; i < MaxNChannels; i++) setting[i].DCOffsetPrecentage = offsetPrecentage; + }else{ + setting[ch].DCOffsetPrecentage = offsetPrecentage; + } + WriteRegister((uint32_t) RegisterDPP::ChannelDCOffset, uint( ADCFullSize * offsetPrecentage), ch ); + if( ret != 0 ) ErrorMsg("SetDCOffset"); +} + +void Digitizer::SetVetoWidth(uint32_t bit, int ch){ + if( ch < 0 ) { + for( int i = 0; i < MaxNChannels; i++) setting[i].VetoWidth = bit; + }else{ + setting[ch].VetoWidth = bit; + } + WriteRegister((uint32_t) RegisterDPP::VetoWidth, bit, ch); + if( ret != 0 ) ErrorMsg("SetVetoWidth"); +} + +void Digitizer::SetTriggerPolarity(bool RiseingIsZero, int ch ){ + if( ch < 0 ) { + ret = 0; + for (int i = 0; i < NChannel; i++){ + setting[i].triggerPolarity = RiseingIsZero; + ret |= CAEN_DGTZ_SetTriggerPolarity(handle, i, CAEN_DGTZ_TriggerPolarity_t(RiseingIsZero)); + } + }else{ + setting[ch].triggerPolarity = RiseingIsZero; + 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, bool useControl2, 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 + + uint32_t address = (uint32_t) RegisterDPP::DPPAlgorithmControl; + if( useControl2 == true) { + if (DPPType == 0x88) address = (uint32_t) RegisterPSD::DPPAlgorithmControl2; + if (DPPType == 0x8B) address = (uint32_t) RegisterPHA::DPPAlgorithmControl2; + if (DPPType != 0x88 && DPPType != 0x8B ) { + printf(" DPP version is nto PSD or PHA, not supported. \n"); + return; + } + } + + if (ch < 0 ){ + for( int i = 0; i < MaxNChannels; i++) setting[i].DPPAlgorithmControl = bit; + WriteRegister( address, bit); + }else{ + setting[ch].DPPAlgorithmControl = bit; + WriteRegister( address, bit, ch); + } + if( ret != 0 ) ErrorMsg("SetDPPAlgorithmControl"); +} + +void Digitizer::SetDPPAlgorithmControlBit(unsigned int bitValue, unsigned int bitLength, unsigned int bitSmallestPos, bool useControl2, int ch){ + uint32_t address = (uint32_t) RegisterDPP::DPPAlgorithmControl; + if( useControl2 == true){ + if (DPPType == 0x88) address = (uint32_t) RegisterPSD::DPPAlgorithmControl2; + if (DPPType == 0x8B) address = (uint32_t) RegisterPHA::DPPAlgorithmControl2; + if (DPPType != 0x88 && DPPType != 0x8B ) { + printf(" DPP version is nto PSD or PHA, not supported. \n"); + return; + } + } + uint32_t bit ; + uint32_t bitmask = (uint(pow(2, bitLength)-1) << bitSmallestPos); + if (ch < 0 ){ + /// take ch-0 + bit = ReadRegister(address, 0); + bit = (bit & ~bitmask) | (bitValue << bitSmallestPos); + for( int i = 0; i < MaxNChannels; i++) setting[i].DPPAlgorithmControl = bit; + }else{ + bit = ReadRegister(address, ch); + bit = (bit & ~bitmask) | (bitValue << bitSmallestPos); + setting[ch].DPPAlgorithmControl = bit; + } + WriteRegister(address, bit, ch); + if( ret != 0 ) ErrorMsg("SetDPPAlgorithmControlBit"); +} + +void Digitizer::SetTrapezoidRescaling(unsigned int rightShiftBits, int ch ){ + SetDPPAlgorithmControlBit(rightShiftBits, 5, 0, false, ch); + if( ret != 0 ) ErrorMsg("SetTrapezoidRescaling"); +} + +void Digitizer::SetPeakSampling(unsigned int bit, int ch){ + if (ch < 0 ){ + for( int i = 0; i < MaxNChannels; i++) setting[i].peakSampling = bit; + }else{ + setting[ch].peakSampling = bit; + } + SetDPPAlgorithmControlBit(bit, 2, 12, false, ch); + if( ret != 0 ) ErrorMsg("SetPeakSampling"); +} + +void Digitizer::SetPulsePolarity(bool PositiveIsZero, int ch){ + if (ch < 0 ){ + for( int i = 0; i < MaxNChannels; i++) setting[i].pulsePolarity_DPP = PositiveIsZero; + }else{ + setting[ch].pulsePolarity_DPP = PositiveIsZero; + } + SetDPPAlgorithmControlBit(PositiveIsZero, 1, 16, false, ch); + if( ret != 0 ) ErrorMsg("SetPulsePolarity"); +} + +void Digitizer::SetBaselineSampling(unsigned int bit, int ch){ + if (ch < 0 ){ + for( int i = 0; i < MaxNChannels; i++) setting[i].baselineSampling = bit; + }else{ + setting[ch].baselineSampling = bit; + } + SetDPPAlgorithmControlBit(bit, 2, 20, false, ch); + if( ret != 0 ) ErrorMsg("SetBaselineSampling"); +} + +void Digitizer::SetRollOverFlag(bool isRollOver, int ch){ + if (ch < 0 ){ + for( int i = 0; i < MaxNChannels; i++) setting[i].rollOverFlag = isRollOver; + }else{ + setting[ch].rollOverFlag = isRollOver; + } + SetDPPAlgorithmControlBit(isRollOver, 1, 26, false, ch); + if( ret != 0 ) ErrorMsg("SetRollOverFlag"); +} + +void Digitizer::SetPileUpFlag(bool isPileUpFlag, int ch){ + if (ch < 0 ){ + for( int i = 0; i < MaxNChannels; i++) setting[i].pileUpFlag = isPileUpFlag; + }else{ + setting[ch].pileUpFlag = isPileUpFlag; + } + SetDPPAlgorithmControlBit(isPileUpFlag, 1, 27, false, ch); + if( ret != 0 ) ErrorMsg("SetPileUpFlag"); +} + + +int Digitizer::SetAcqMode(string mode){ + + return ret; +} + + +int Digitizer::GetChTemperature(int ch){ + + 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]; +} + +//################################################################ + +class DigitizerPHA : public Digitizer { + + public: + DigitizerPHA(); + DigitizerPHA(int boardID, int portID = 0); + ~DigitizerPHA(); + + int ProgramBoard(); + + void GetChannelSetting(int ch); + +}; + +DigitizerPHA::DigitizerPHA(){ + +} + +DigitizerPHA::DigitizerPHA(int boardID, int portID){ + OpenDigitizer(boardID, portID); +} + +DigitizerPHA::~DigitizerPHA(){ + +} + +int DigitizerPHA::ProgramBoard(){ + + /// Board Configuration for PHA + ///bx0000 0000 0000 1110 0000 0001 0001 0100 = + /// | | |||| | | | | ||+- (0) automatic data flush, 0 = disable + /// | | |||| | | | | |+- (1) decimated smae of waveform, 0 = disable + /// | | |||| | | | | +- (2) trigger propagation, required in case of coincident trigger + /// | | |||| | | | +- (8) indivual trigger: must be 1 + /// | | |||| | | + (11) dual trace. use 12:13 bit and 14:15 bit for choice of trace. but the trace recorded in half ADC frequency. + /// | | |||| | + (12:13) Analog Probe 1, 00 = input, 01 = input 1st derivative, 10 = input 2nd derivative, 11 = Trapezoid + /// | | |||| + (14:15) Analog Probe 2, 00 = input, 01 = threshold, 10 = Trapezoid - Baseline, 11 = baseline + /// | | |||+ (16) Waveform recording, 0 = disable, 1 = enable + /// | | ||+ (17) Enable Extra 2, i.e. 64 bit timestamp + /// | | |+ (18) time stamp recording: must be 1 + /// | | + (19) peak recording: must be 1 + /// | + (20:23) Digital Virtual probe 1: in mixed mode, virual probe can be enabled. See manual + /// + (26:28) Digitial Virtual probe 2 + + ret |= CAEN_DGTZ_WriteRegister(handle, (uint32_t) Register::BoardConfiguration , 0x000E0114); /// Channel Control Reg (indiv trg, seq readout) ?? + + ErrorMsg("PHA-ProgramBoard"); + return ret; +} + + +void DigitizerPHA::GetChannelSetting(int ch){ + + uint32_t * value = new uint32_t[NChannel]; + printf("\e[33m================================================\n"); + printf("================ Getting setting for channel %d \n", ch); + printf("================================================\e[0m\n"); + ///DPP algorithm Control + CAEN_DGTZ_ReadRegister(handle, 0x1080 + (ch << 8), value); + printf(" 32 28 24 20 16 12 8 4 0\n"); + printf(" | | | | | | | | |\n"); + cout <<" DPP algorithm Control : 0b" << bitset<32>(value[0]) << endl; + + int trapRescaling = int(value[0]) & 31 ; + int polarity = int(value[0] >> 16); /// in bit[16] + int baseline = int(value[0] >> 20) ; /// in bit[22:20] + int NsPeak = int(value[0] >> 12); /// in bit[13:12] + ///DPP algorithm Control 2 + CAEN_DGTZ_ReadRegister(handle, 0x10A0 + (ch << 8), value); + cout <<" DPP algorithm Control 2: 0b" << bitset<32>(value[0]) << endl; + + printf("* = multiple of 8 \n"); + printf("** = multiple of 16 \n"); + + printf("==========----- input \n"); + CAEN_DGTZ_ReadRegister(handle, 0x1020 + (ch << 8), value); printf("%20s %d ch \n", "Record Length", value[0] * 8); ///Record length + CAEN_DGTZ_ReadRegister(handle, 0x1038 + (ch << 8), value); printf("%20s %d ch \n", "Pre-tigger", value[0] * 4); ///Pre-trigger + printf("%20s %s \n", "polarity", (polarity & 1) == 0 ? "Positive" : "negative"); ///Polarity + printf("%20s %.0f sample \n", "Ns baseline", pow(4, 1 + baseline & 7)); ///Ns baseline + CAEN_DGTZ_ReadRegister(handle, 0x1098 + (ch << 8), value); printf("%20s %.2f %% of %d\n", "DC offset", value[0] * 100./ ADCFullSize, ADCFullSize); ///DC offset + CAEN_DGTZ_ReadRegister(handle, 0x1028 + (ch << 8), value); printf("%20s %.1f Vpp \n", "input Dynamic", value[0] == 0 ? 2 : 0.5); ///InputDynamic + + printf("==========----- discriminator \n"); + CAEN_DGTZ_ReadRegister(handle, 0x106C + (ch << 8), value); printf("%20s %d LSB\n", "Threshold", value[0]); ///Threshold + CAEN_DGTZ_ReadRegister(handle, 0x1074 + (ch << 8), value); printf("%20s %d ch \n", "trigger hold off *", value[0] * 8); ///Trigger Hold off + CAEN_DGTZ_ReadRegister(handle, 0x1054 + (ch << 8), value); printf("%20s %d sample \n", "Fast Dis. smoothing", value[0] ); ///Fast Discriminator smoothing + CAEN_DGTZ_ReadRegister(handle, 0x1058 + (ch << 8), value); printf("%20s %.1f ns \n", "Input rise time **", value[0] * 8 * ch2ns); ///Input rise time + + printf("==========----- Trapezoid \n"); + CAEN_DGTZ_ReadRegister(handle, 0x1080 + (ch << 8), value); printf("%20s %d bit = Floor( rise x decay / 64 )\n", "Trap. Rescaling", trapRescaling ); ///Trap. Rescaling Factor + CAEN_DGTZ_ReadRegister(handle, 0x105C + (ch << 8), value); printf("%20s %.1f ns \n", "Trap. rise time **", value[0] * 8 * ch2ns ); ///Trap. rise time, 2 for 1 ch to 2ns + CAEN_DGTZ_ReadRegister(handle, 0x1060 + (ch << 8), value); + int flatTopTime = value[0] * 8 * ch2ns; printf("%20s %d ns \n", "Trap. flat time **", flatTopTime); ///Trap. flat time + CAEN_DGTZ_ReadRegister(handle, 0x1068 + (ch << 8), value); printf("%20s %.1f ns \n", "Decay time **", value[0] * 8 * ch2ns); ///Trap. pole zero + CAEN_DGTZ_ReadRegister(handle, 0x1064 + (ch << 8), value); printf("%20s %.1f ns = %.2f %% \n", "peaking time **", value[0] * 8 * ch2ns, value[0] * 800. * ch2ns / flatTopTime ); //Peaking time + printf("%20s %.0f sample\n", "Ns peak", pow(4, NsPeak & 3)); //Ns peak + CAEN_DGTZ_ReadRegister(handle, 0x1078 + (ch << 8), value); printf("%20s %.1f ns \n", "Peak hole off **", value[0] * 8 *ch2ns ); ///Peak hold off + + printf("==========----- Other \n"); + CAEN_DGTZ_ReadRegister(handle, 0x10C4 + (ch << 8), value); printf("%20s %d \n", "Energy fine gain ?", value[0]); ///Energy fine gain + + printf("========================================= end of ch-%d\n", ch); + +} + +//################################################################ + +class DigitizerPSD : public Digitizer { + public: + DigitizerPSD(); + DigitizerPSD(int boardID, int portID = 0); + ~DigitizerPSD(); + + //int ProgramBoard(); + // + //void GetChannelSetting(int ch); + +}; + + +DigitizerPSD::DigitizerPSD(){ + +} + +DigitizerPSD::DigitizerPSD(int boardID, int portID){ + OpenDigitizer(boardID, portID); +} + +DigitizerPSD::~DigitizerPSD(){ + +} +#endif diff --git a/Makefile b/Makefile new file mode 100755 index 0000000..ecf816c --- /dev/null +++ b/Makefile @@ -0,0 +1,38 @@ +######################################################################## +# +## --- CAEN SpA - Computing Division --- +# +## CAENDigitizer Software Project +# +## Created : October 2009 (Rel. 1.0) +# +## Auth: A. Lucchesi +# +######################################################################### +ARCH = `uname -m` + +CC = g++ + +COPTS = -fPIC -DLINUX -w + +DEPLIBS = -lCAENDigitizer + +ROOTLIBS = `root-config --cflags --glibs` + +######################################################################### + +all : test + +#clean : +# /bin/rm -f $(OBJS1) $(OBJS2) $(OUT2) ./CutsCreator ./BoxScore ./BoxScoreReader + +test : test.cpp DigitizerClass.h + $(CC) -o test test.cpp $(DEPLIBS) + + +#CutsCreator: $(OBJS3) src/CutsCreator.c +# g++ -std=c++17 -pthread src/CutsCreator.c -o CutsCreator $(ROOTLIBS) + +#BoxScore : src/BoxScore.c Class/DigitizerClass.h Class/FileIO.h Class/GenericPlane.h Class/HelioTarget.h Class/IsoDetect.h Class/HelioArray.h Class/MCPClass.h +# g++ -std=c++17 -pthread src/BoxScore.c -o BoxScore $(DEPLIBS) $(ROOTLIBS) + diff --git a/RegisterAddress.h b/RegisterAddress.h new file mode 100644 index 0000000..21d3ace --- /dev/null +++ b/RegisterAddress.h @@ -0,0 +1,155 @@ +#ifndef REGISTERADDRESS_H +#define REGISTERADDRESS_H + +enum class Register : uint32_t { + + EventReadOutBuffer = 0x0000, /// R + ///========== Channel or Group + ChannelDummy32 = 0x1024, /// R/W + InputDynamicRange = 0x1028, /// R/W + ChannelPulseWidth = 0x1070, /// R/W + ChannelTriggerThreshold = 0x1080, /// R/W + CoupleSelfTriggerLogic = 0x1084, /// R/W + ChannelStatus = 0x1088, /// R + AMCFirmwareRevision = 0x108C, /// R + ChannelDCOffset = 0x1098, /// R/W + ChannelADCTemperature = 0x10A8, /// R + ChannelSelfTriggerRateMeter = 0x10EC, /// R + + ///========== Board + BoardConfiguration = 0x8000, /// R/W + BufferOrganization = 0x800C, /// R/W + CustomSize = 0x8020, /// R/W + ADCCalibration = 0x809C, /// W + AcquisitionControl = 0x8100, /// R/W + AcquisitionStatus = 0x8104, /// R + SoftwareTrigger = 0x8108, /// W + GlobalTriggerMask = 0x810C, /// R/W + FrontPanelTRGOUTEnableMask = 0x8110, /// R/W + PostTrigger = 0x8114, /// R/W + LVDSIOData = 0x8118, /// R/W + FrontPanelIOControl = 0x811C, /// R/W + ChannelEnableMask = 0x8120, /// R/W + ROCFPGAFirmwareRevision = 0x8124, /// R + EventStored = 0x812C, /// R + VoltageLevelModeConfig = 0x8138, /// R/W + SoftwareClockSync = 0x813C, /// W + BoardInfo = 0x8140, /// R + AnalogMonitorMode = 0x8144, /// R/W + EventSize = 0x814C, /// R + FanSpeedControl = 0x8168, /// R/W + MemoryBufferAlmostFullLevel = 0x816C, /// R/W + RunStartStopDelay = 0x8170, /// R/W + BoardFailureStatus = 0x8178, /// R + FrontPanelLVDSIONewFeatures = 0x81A0, /// R/W + BufferOccupancyGain = 0x81B4, /// R/W + ChannelsShutdown = 0x81C0, /// W + ExtendedVetoDelay = 0x81C4, /// R/W + ReadoutControl = 0xEF00, /// R/W + ReadoutStatus = 0xEF04, /// R + BoardID = 0xEF08, /// R/W + MCSTBaseAddressAndControl = 0xEF0C, /// R/W + RelocationAddress = 0xEF10, /// R/W + InterruptStatusID = 0xEF14, /// R/W + InterruptEventNumber = 0xEF18, /// R/W + MaxNumberOfEventsPerBLT = 0xEF1C, /// R/W + Scratch = 0xEF20, /// R/W + SoftwareReset = 0xEF24, /// W + SoftwareClear = 0xEF28 /// W +}; + +///====== Common for PHA and PSD +enum class RegisterDPP : uint32_t { + + RecordLength = 0x1020, /// R/W + InputDynamicRange = 0x1028, /// R/W + NumberEventsPerAggregate = 0x1034, /// R/W + PreTrigger = 0x1038, /// R/W + TriggerThreshold = 0x106C, /// R/W + TriggerHoldOffWidth = 0x1074, /// R/W + DPPAlgorithmControl = 0x1080, /// R/W + ChannelStatus = 0x1088, /// R + AMCFirmwareRevision = 0x108C, /// R + ChannelDCOffset = 0x1098, /// R/W + ChannelADCTemperature = 0x10A8, /// R + IndividualSoftwareTrigger = 0x10C0, /// W + VetoWidth = 0x10D4, /// R/W + + BoardConfiguration = 0x8000, /// R/W + AggregateOrganization = 0x800C, /// R/W + ADCCalibration = 0x809C, /// W + ChannelShutdown = 0x80BC, /// W + AcquisitionControl = 0x8100, /// R/W + AcquisitionStatus = 0x8104, /// R + SoftwareTrigger = 0x8108, /// W + GlobalTriggerMask = 0x810C, /// R/W + FrontPanelTRGOUTEnableMask = 0x8110, /// R/W + LVDSIOData = 0x8118, /// R/W + FrontPanelIOControl = 0x811C, /// R/W + ChannelEnableMask = 0x8120, /// R/W + ROCFPGAFirmwareRevision = 0x8124, /// R + EventStored = 0x812C, /// R + VoltageLevelModeConfig = 0x8138, /// R/W + SoftwareClockSync = 0x813C, /// W + BoardInfo = 0x8140, /// R + AnalogMonitorMode = 0x8144, /// R/W + EventSize = 0x814C, /// R + TimeBombDowncounter = 0x8158, /// R + FanSpeedControl = 0x8168, /// R/W + RunStartStopDelay = 0x8170, /// R/W + BoardFailureStatus = 0x8178, /// R + DisableExternalTrigger = 0x817C, /// R/W + TriggerValidationMask = 0x8180, /// R/W, 0x8180 + 4n + FrontPanelLVDSIONewFeatures = 0x81A0, /// R/W + BufferOccupancyGain = 0x81B4, /// R/W + ExtendedVetoDelay = 0x81C4, /// R/W + ReadoutControl = 0xEF00, /// R/W + ReadoutStatus = 0xEF04, /// R + BoardID = 0xEF08, /// R/W + MCSTBaseAddressAndControl = 0xEF0C, /// R/W + RelocationAddress = 0xEF10, /// R/W + InterruptStatusID = 0xEF14, /// R/W + InterruptEventNumber = 0xEF18, /// R/W + MaxNumberOfEventsPerBLT = 0xEF1C, /// R/W + Scratch = 0xEF20, /// R/W + SoftwareReset = 0xEF24, /// W + SoftwareClear = 0xEF28 /// W +}; + +enum class RegisterPHA : uint32_t { + DataFlush = 0x103C, /// W not sure + ChannelStopAcquisition = 0x1040, /// R/W not sure + RCCR2SmoothingFactor = 0x1054, /// R/W Trigger Filter smoothing, triggerSmoothingFactor + InputRiseTime = 0x1058, /// R/W OK + TrapezoidRiseTime = 0x105C, /// R/W OK + TrapezoidFlatTop = 0x1060, /// R/W OK + PeakingTime = 0x1064, /// R/W OK + DecayTime = 0x1068, /// R/W OK + TriggerThreshold = 0x106C, /// R/W OK + RiseTimeValidationWindow = 0x1070, /// R/W OK + TriggerHoldOffWidth = 0x1074, /// R/W OK + PeakHoldOff = 0x1078, /// R/W OK + ShapedTriggerWidth = 0x1084, /// R/W not sure + DPPAlgorithmControl2 = 0x10A0, /// R/W OK + FineGain = 0x10C4, /// R/W OK +}; + +enum class RegisterPSD : uint32_t { + CFDSetting = 0x103C, /// R/W + ForcedDataFlush = 0x1040, /// W + ChargeZeroSuppressionThreshold = 0x1044, /// R/W + ShortGateWidth = 0x1054, /// R/W + LongGateWidth = 0x1058, /// R/W + GateOffset = 0x105C, /// R/W + TriggerThreshold = 0x1060, /// R/W + FixedBaseline = 0x1064, /// R/W + TriggerLatency = 0x106C, /// R/W + ShapedTriggerWidth = 0x1070, /// R/W + TriggerHoldOffWidth = 0x1074, /// R/W + ThresholdForPSDCut = 0x1078, /// R/W + PureGapThreshold = 0x107C, /// R/W + DPPAlgorithmControl2 = 0x1084, /// R/W + EarlyBaselineFreeze = 0x10D8, /// R/W +}; + +#endif diff --git a/test.cpp b/test.cpp new file mode 100644 index 0000000..96e8835 --- /dev/null +++ b/test.cpp @@ -0,0 +1,36 @@ +#include "DigitizerClass.h" + +int main(int argc, char* argv[]){ + + DigitizerPHA * dig = new DigitizerPHA[2]; + DigitizerPSD * psd = new DigitizerPSD(); + + dig[0].OpenDigitizer(0,0); + dig[1].OpenDigitizer(1,0); + + psd->OpenDigitizer(2,0); + + + printf("======================= \n"); + + //dig[0].SetDCOffset(0.2); + //dig[0].SetDCOffset(0.3, 1); + + dig[0].SetTrapezoidRescaling(0x1F); + dig[0].SetPulsePolarity(1); + dig[0].SetPulsePolarity(0, 1); + + //for( int ch = 0; ch < dig[0].GetNChannel(); ch++){ + // uint32_t data = dig[0].ReadRegister((uint32_t) RegisterDPP::ChannelDCOffset, ch); + // printf(" %d %% \n", data ); + //} + + dig[0].GetChannelSetting(0); + dig[0].GetChannelSetting(1); + + printf("temp : %d \n", dig[0].GetChTemperature(1)); + + delete [] dig; + + return 0; +}