FSUDAQ_Qt6/ClassDigitizer.h

194 lines
11 KiB
C
Raw Normal View History

2023-04-11 11:13:23 -04:00
#ifndef DIGITIZER_H
#define DIGITIZER_H
#include <stdio.h>
#include <string>
#include <sstream>
#include <cmath>
#include <cstring> ///memset
#include <iostream> ///cout
#include <bitset>
#include "CAENDigitizer.h"
#include "CAENDigitizerType.h"
#include "macro.h"
#include "ClassData.h"
#include "RegisterAddress.h"
//################################################################
class Digitizer{
protected:
Data * data;
2023-04-14 16:12:52 -04:00
//^---- fixed parameter
2023-04-11 11:13:23 -04:00
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;
2023-04-14 16:12:52 -04:00
//^----- adjustable parameters
2023-04-11 11:13:23 -04:00
uint32_t channelMask ; /// the channel mask from NChannel
uint32_t VMEBaseAddress; /// For direct USB or Optical-link connection, VMEBaseAddress must be 0
CAEN_DGTZ_ConnectionType LinkType; /// USB or Optic
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)
2023-04-14 16:12:52 -04:00
//^------- other parameters
2023-04-11 11:13:23 -04:00
int ret; /// return value, refer to CAEN_DGTZ_ErrorCode
bool isConnected; /// true for digitizer communication estabished.
bool AcqRun; /// true when digitizer is taking data
bool isDummy; /// true for a dummy digitizer.
2023-04-14 16:12:52 -04:00
//^-------- setting
2023-04-11 11:13:23 -04:00
std::string settingFileName; ///
FILE * settingFile; ///
bool settingFileExist; ///
bool isSettingFilledinMemeory; /// false for disabled ReadAllSettingFromBoard()
unsigned int setting[SETTINGSIZE]; /// Setting, 4bytes x 2048 = 8192 bytes
2023-04-14 16:12:52 -04:00
//^-------- other protected functions
2023-04-11 11:13:23 -04:00
void ErrorMsg(std::string header = "");
uint32_t returnData;
2023-04-11 11:13:23 -04:00
public:
Digitizer(); /// no digitizer open
Digitizer(int boardID, int portID = 0, bool program = false, bool verbose = false);
2023-04-14 16:12:52 -04:00
virtual ~Digitizer();
2023-04-11 11:13:23 -04:00
2023-04-14 16:12:52 -04:00
//^------ portID is for optical link for using PCIe card, from 0, 1, 2, 3
2023-04-11 11:13:23 -04:00
int OpenDigitizer(int boardID, int portID = 0, bool program = false, bool verbose = false);
void SetDPPType (int type) { this->DPPType = type;} /// for manual override, or, digitizer does not open
void SetChannelMask (uint32_t mask);
void SetChannelOnOff (unsigned short ch, bool onOff);
int CloseDigitizer();
void Initalization();
void Reset();
2023-04-11 14:23:38 -04:00
bool IsDummy() {return isDummy;}
bool IsConnected() {return isConnected;}
2023-04-11 11:13:23 -04:00
void PrintBoard() ;
2023-04-14 16:12:52 -04:00
virtual int ProgramBoard() ; /// program a generic board, no program channel
int ProgramPHABoard() ; /// program a default PHA board with dual trace
2023-05-12 16:06:32 -04:00
int ProgramPSDBoard() ;
2023-04-11 11:13:23 -04:00
2023-04-14 16:12:52 -04:00
//^================ ACQ control
2023-04-11 11:13:23 -04:00
void StopACQ();
void StartACQ();
2023-04-14 16:12:52 -04:00
int ReadData();
2023-04-11 11:13:23 -04:00
bool IsRunning() const {return AcqRun;}
Data * GetData() const {return data;}
void PrintACQStatue();
unsigned int CalByteForBuffer();
2023-04-14 16:12:52 -04:00
//^================= Settings
2023-04-11 11:13:23 -04:00
/// write value to digitizer, memory, and settingFile (if exist)
/// ONLY WriteRegister can have ch = -1, for writting all channels
/// for board setting, ignore ch
void WriteRegister (Reg registerAddress, uint32_t value, int ch = -1, bool isSave2MemAndFile = true);
2023-04-11 11:13:23 -04:00
/// read value from digitizer and memory, and save to memory, and settingFile(if exist),
/// for board setting, ignore ch
uint32_t ReadRegister (Reg registerAddress, unsigned short ch = 0, bool isSave2MemAndFile = true, std::string str = "" );
2023-04-11 11:13:23 -04:00
uint32_t PrintRegister(uint32_t address, std::string msg);
2023-04-14 16:12:52 -04:00
//^================ Get Board info
2023-04-24 17:37:03 -04:00
CAEN_DGTZ_BoardInfo_t GetBoardInfo() const {return BoardInfo;}
2023-04-11 11:13:23 -04:00
std::string GetModelName() const {return BoardInfo.ModelName;}
int GetSerialNumber() const {return BoardInfo.SerialNumber;}
int GetChannelMask() const {return channelMask;}
bool GetChannelOnOff(unsigned ch) const {return (channelMask & ( 1 << ch) );}
float GetCh2ns() const {return ch2ns;}
2023-04-17 15:17:25 -04:00
int GetNChannels() const {return NChannel;}
2023-04-11 11:13:23 -04:00
int GetHandle() const {return handle;}
int GetDPPType() const {return DPPType;}
std::string GetDPPString(int DPPType = 0); /// if no input, use digitizer DPPType
int GetADCBits() const {return BoardInfo.ADC_NBits;}
std::string GetROCVersion() const {return BoardInfo.ROC_FirmwareRel;}
std::string GetAMCVersion() const {return BoardInfo.AMC_FirmwareRel;}
CAEN_DGTZ_ConnectionType GetLinkType() const {return LinkType;}
2023-04-20 18:15:30 -04:00
int GetErrorCode() const {return ret;}
2023-04-11 11:13:23 -04:00
2023-04-14 16:12:52 -04:00
//^================ Setting
Reg FindRegister(uint32_t address);
2023-04-11 11:13:23 -04:00
/// board <--> memory functions
void ReadAllSettingsFromBoard (bool force = false);
void ProgramSettingsToBoard ();
/// simply read settings from memory
void SetSettingToMemory (Reg registerAddress, unsigned int value, unsigned short ch = 0);
unsigned int GetSettingFromMemory (Reg registerAddress, unsigned short ch = 0);
2023-04-11 11:13:23 -04:00
void PrintSettingFromMemory ();
unsigned int * GetSettings() {return setting;};
/// memory <--> file
void SaveAllSettingsAsText (std::string fileName);
void SaveAllSettingsAsBin (std::string fileName);
std::string GetSettingFileName() {return settingFileName;}
/// tell the digitizer where to look at the setting file.
/// if not exist, call SaveAllSettinsAsBin();
void SetSettingBinaryPath (std::string fileName);
/// load setting file to memory
/// if problem, return -1; load without problem, return 0;
int LoadSettingBinaryToMemory (std::string fileName);
void SaveSettingToFile (Reg registerAddress, unsigned int value, unsigned short ch = 0); /// also save to memory
unsigned int ReadSettingFromFile (Reg registerAddress, unsigned short ch = 0); /// read from setting binary
2023-04-11 11:13:23 -04:00
//============ old methods, that only manipulate digitizer register, not setting in memory
2023-04-24 15:27:05 -04:00
void SetDPPAlgorithmControl(uint32_t bit, int ch);
unsigned int ReadBits(Reg address, unsigned int bitLength, unsigned int bitSmallestPos, int ch );
void SetBits(Reg address, unsigned int bitValue, unsigned int bitLength, unsigned int bitSmallestPos, int ch);
void SetBits(Reg address, std::pair<unsigned short, unsigned short> bit, unsigned int bitValue, int ch){ SetBits(address, bitValue, bit.first, bit.second, ch);}
2023-04-25 17:04:46 -04:00
static unsigned int ExtractBits(uint32_t value, std::pair<unsigned short, unsigned short> bit){ return ((value >> bit.second) & uint(pow(2, bit.first)-1) ); }
2023-04-20 18:15:30 -04:00
//====== Board Config breakDown
// bool IsEnabledAutoDataFlush() {return ( GetSettingFromMemory(DPP::BoardConfiguration) & 0x1 );}
// bool IsDecimateTrace() {return ( (GetSettingFromMemory(DPP::BoardConfiguration) >> 1) & 0x1 );}
// bool IsTriggerPropagate() {return ( (GetSettingFromMemory(DPP::BoardConfiguration) >> 2) & 0x1 );}
bool IsDualTrace() {return ( (GetSettingFromMemory(DPP::BoardConfiguration) >> 11) & 0x1 );}
// unsigned short AnaProbe1Type() {return ( (GetSettingFromMemory(DPP::BoardConfiguration) >> 12) & 0x3 );}
// unsigned short AnaProbe2Type() {return ( (GetSettingFromMemory(DPP::BoardConfiguration) >> 14) & 0x3 );}
// bool IsRecordTrace() {return ( (GetSettingFromMemory(DPP::BoardConfiguration) >> 16) & 0x1 );}
// bool IsEnabledExtra2() {return ( (GetSettingFromMemory(DPP::BoardConfiguration) >> 17) & 0x1 );}
// bool IsRecordTimeStamp() {return ( (GetSettingFromMemory(DPP::BoardConfiguration) >> 18) & 0x1 );}
// bool IsRecordEnergy() {return ( (GetSettingFromMemory(DPP::BoardConfiguration) >> 19) & 0x1 );}
// unsigned short DigiProbe1Type() {return ( (GetSettingFromMemory(DPP::BoardConfiguration) >> 20) & 0xF );}
// unsigned short DigiProbe2Type() {return ( (GetSettingFromMemory(DPP::BoardConfiguration) >> 26) & 0x7 );}
// //====== DPP Algorithm Contol breakdown
// unsigned short TrapReScaling(int ch) {return ( (GetSettingFromMemory(DPP::DPPAlgorithmControl, ch) >> 0) & 0x1F );}
// unsigned short TraceDecimation(int ch) {return ( (GetSettingFromMemory(DPP::DPPAlgorithmControl, ch) >> 8) & 0x3 );}
// unsigned short TraceDecimationGain(int ch) {return ( (GetSettingFromMemory(DPP::DPPAlgorithmControl, ch) >> 10) & 0x3 );}
// unsigned short PeakMean(int ch) {return ( (GetSettingFromMemory(DPP::DPPAlgorithmControl, ch) >> 12) & 0x3 );}
// unsigned short Polarity(int ch) {return ( (GetSettingFromMemory(DPP::DPPAlgorithmControl, ch) >> 16) & 0x1 );}
// unsigned short TriggerMode(int ch) {return ( (GetSettingFromMemory(DPP::DPPAlgorithmControl, ch) >> 18) & 0x3 );}
// unsigned short BaseLineAvg(int ch) {return ( (GetSettingFromMemory(DPP::DPPAlgorithmControl, ch) >> 18) & 0x7 );}
// unsigned short DisableSelfTrigger(int ch) {return ( (GetSettingFromMemory(DPP::DPPAlgorithmControl, ch) >> 24) & 0x1 );}
// unsigned short EnableRollOverFlag(int ch) {return ( (GetSettingFromMemory(DPP::DPPAlgorithmControl, ch) >> 26) & 0x1 );}
// unsigned short EnablePileUpFlag(int ch) {return ( (GetSettingFromMemory(DPP::DPPAlgorithmControl, ch) >> 27) & 0x1 );}
// //====== DPP Algorithm Contol 2 breakdown
// unsigned short LocalShapeMode(int ch) {return ( (GetSettingFromMemory(DPP::PHA::DPPAlgorithmControl2_G, ch) >> 0) & 0x7 );}
// unsigned short LocalTrigValidMode(int ch) {return ( (GetSettingFromMemory(DPP::PHA::DPPAlgorithmControl2_G, ch) >> 4) & 0x7 );}
// unsigned short Extra2Option(int ch) {return ( (GetSettingFromMemory(DPP::PHA::DPPAlgorithmControl2_G, ch) >> 8) & 0x3 );}
// unsigned short VetoSource(int ch) {return ( (GetSettingFromMemory(DPP::PHA::DPPAlgorithmControl2_G, ch) >> 14) & 0x3 );}
// unsigned short TrigCounter(int ch) {return ( (GetSettingFromMemory(DPP::PHA::DPPAlgorithmControl2_G, ch) >> 16) & 0x3 );}
// unsigned short ActiveBaseLineCal(int ch) {return ( (GetSettingFromMemory(DPP::PHA::DPPAlgorithmControl2_G, ch) >> 18) & 0x1 );}
// unsigned short TagCorrelatedEvents(int ch) {return ( (GetSettingFromMemory(DPP::PHA::DPPAlgorithmControl2_G, ch) >> 19) & 0x1 );}
// unsigned short OptimizeBaseLineRestorer(int ch) {return ( (GetSettingFromMemory(DPP::PHA::DPPAlgorithmControl2_G, ch) >> 29) & 0x1 );}
//====== Acquistion Control vreakdown
2023-04-24 15:27:05 -04:00
2023-04-20 18:15:30 -04:00
2023-04-11 11:13:23 -04:00
};
#endif