From 71464484ba1b1eb2309bb65fce43ec406b656cb5 Mon Sep 17 00:00:00 2001 From: "Ryan@WorkStation" Date: Thu, 21 Sep 2023 19:00:48 -0400 Subject: [PATCH] added PSD prarmeeters --- ClassDigitizer2Gen.cpp | 65 +++++- ClassDigitizer2Gen.h | 3 +- DigiParameters.h | 465 +++++++++++++++++++++++++++++++++++++++++ digiSettingsPanel.cpp | 16 +- mainwindow.cpp | 2 +- test.cpp | 2 +- 6 files changed, 540 insertions(+), 13 deletions(-) diff --git a/ClassDigitizer2Gen.cpp b/ClassDigitizer2Gen.cpp index 9692857..23cc44d 100644 --- a/ClassDigitizer2Gen.cpp +++ b/ClassDigitizer2Gen.cpp @@ -283,6 +283,20 @@ void Digitizer2Gen::StopACQ(){ acqON = false; } +//================ Data Format +//------- PHA +// 0 = all +// 1 = 1 trace +// 2 = no trace +// 3 = minimum (only energy and timestamp) +// 15 = raw buffer +//------- PSD +//?? 4 = all +//?? 5 = 1 trace +//?? 6 = no trace +//?? 7 = only energy + timestamp +//?? 16 = raw buffer + void Digitizer2Gen::SetPHADataFormat(unsigned short dataFormat){ printf("%s : %d\n", __func__, dataFormat); @@ -629,7 +643,7 @@ void Digitizer2Gen::SaveDataToFile(){ //########################################### void Digitizer2Gen::Reset(){ SendCommand("/cmd/Reset"); } -void Digitizer2Gen::ProgramPHABoard(){ +void Digitizer2Gen::ProgramDPPBoard(){ if( !isConnected ) return ; //============= Board @@ -687,12 +701,7 @@ void Digitizer2Gen::ProgramPHAChannels(bool testPulse){ // Channel setting if( testPulse){ WriteValue("/ch/0..63/par/ChEnable" , "false"); - WriteValue("/ch/0/par/ChEnable" , "true"); - WriteValue("/ch/1/par/ChEnable" , "true"); - WriteValue("/ch/2/par/ChEnable" , "true"); - WriteValue("/ch/3/par/ChEnable" , "true"); - - //WriteValue("/ch/0..63/par/ChEnable" , "true"); + WriteValue("/ch/0..63/par/ChEnable" , "true"); WriteValue("/ch/0..63/par/EventTriggerSource", "GlobalTriggerSource"); WriteValue("/ch/0..63/par/WaveTriggerSource" , "GlobalTriggerSource"); // EventTriggerSource enought @@ -707,7 +716,8 @@ void Digitizer2Gen::ProgramPHAChannels(bool testPulse){ //======== Self trigger for each channel WriteValue("/ch/0..63/par/ChEnable" , "true"); - WriteValue("/ch/0..63/par/WaveAnalogProbe0" , "ADCInput"); + WriteValue("/ch/0..63/par/WaveDaatSource" , "ADC_DATA"); + WriteValue("/ch/0..63/par/WaveResolution" , "RES8"); /// 8 ns WriteValue("/ch/0..63/par/WaveSaving" , "OnRequest"); WriteValue("/ch/0..63/par/PulsePolarity" , "Positive"); @@ -757,8 +767,45 @@ void Digitizer2Gen::ProgramPHAChannels(bool testPulse){ WriteValue("/ch/0..63/par/ITLConnect" , "Disabled"); } +} + +void Digitizer2Gen::ProgramPSDChannels(bool testPulse){ + if( testPulse){ + WriteValue("/ch/0..63/par/ChEnable" , "false"); + WriteValue("/ch/0..63/par/ChEnable" , "true"); + + WriteValue("/ch/0..63/par/EventTriggerSource", "GlobalTriggerSource"); + WriteValue("/ch/0..63/par/WaveTriggerSource" , "GlobalTriggerSource"); // EventTriggerSource enought + + WriteValue("/par/GlobalTriggerSource", "SwTrg | TestPulse"); + WriteValue("/par/TestPulsePeriod" , "1000000"); // 1.0 msec = 1000Hz, tested, 1 trace recording + WriteValue("/par/TestPulseWidth" , "1000"); // nsec + WriteValue("/par/TestPulseLowLevel" , "0"); + WriteValue("/par/TestPulseHighLevel" , "10000"); + + }else{ + + //TODO not finished. + + //======== Self trigger for each channel + WriteValue("/ch/0..63/par/ChEnable" , "true"); + WriteValue("/ch/0..63/par/WaveDaatSource" , "ADC_DATA"); + WriteValue("/ch/0..63/par/WaveResolution" , "RES8"); /// 8 ns + WriteValue("/ch/0..63/par/WaveSaving" , "OnRequest"); + WriteValue("/ch/0..63/par/PulsePolarity" , "Positive"); + WriteValue("/ch/0..63/par/DCOffset" , "20"); /// 20% + WriteValue("/ch/0..63/par/TriggerThr" , "1000"); + + WriteValue("/ch/0..63/par/EventNeutronReject", "Disabled"); + WriteValue("/ch/0..63/par/WaveNeutronReject", "Disabled"); + + WriteValue("/ch/0..63/par/WaveAnalogProbe0" , "ADCInput"); + + WriteValue("/ch/0..63/par/ChRecordLengthT" , "4096"); /// 4096 ns, S and T are not Sync + WriteValue("/ch/0..63/par/ChPreTriggerT" , "1000"); /// 1000 ns + + } - } std::string Digitizer2Gen::ErrorMsg(const char * funcName){ diff --git a/ClassDigitizer2Gen.h b/ClassDigitizer2Gen.h index ad9e475..db4e4dc 100644 --- a/ClassDigitizer2Gen.h +++ b/ClassDigitizer2Gen.h @@ -116,8 +116,9 @@ class Digitizer2Gen { uint64_t GetRealTime(int ch) const {return realTime[ch];} void Reset(); - void ProgramPHABoard(); + void ProgramDPPBoard(); void ProgramPHAChannels(bool testPulse = false); + void ProgramPSDChannels(bool testPulse = false); unsigned short GetNChannels() const {return nChannels;} unsigned short GetCh2ns() const {return ch2ns;} diff --git a/DigiParameters.h b/DigiParameters.h index 12427bd..fb5fa0b 100644 --- a/DigiParameters.h +++ b/DigiParameters.h @@ -655,4 +655,469 @@ namespace PHA{ }; +namespace PSD{ + + namespace DIG{ + + ///============== read only + const Reg CupVer = PHA::DIG::CupVer; + const Reg FPGA_firmwareVersion = PHA::DIG::FPGA_firmwareVersion; + const Reg FirmwareType = PHA::DIG::FirmwareType; + const Reg ModelCode = PHA::DIG::ModelCode; + const Reg PBCode = PHA::DIG::PBCode; + const Reg ModelName = PHA::DIG::ModelName; + const Reg FromFactor = PHA::DIG::FromFactor; + const Reg FamilyCode = PHA::DIG::FamilyCode; + const Reg SerialNumber = PHA::DIG::SerialNumber; + const Reg PCBrev_MB = PHA::DIG::PCBrev_MB; + const Reg PCBrev_PB = PHA::DIG::PCBrev_PB; + const Reg DPP_License = PHA::DIG::DPP_License; + const Reg DPP_LicenseStatus = PHA::DIG::DPP_LicenseStatus; + const Reg DPP_LicenseRemainingTime = PHA::DIG::DPP_LicenseRemainingTime; + const Reg NumberOfChannel = PHA::DIG::NumberOfChannel; + const Reg ADC_bit = PHA::DIG::ADC_bit; + const Reg ADC_SampleRate = PHA::DIG::ADC_SampleRate; + const Reg InputDynamicRange = PHA::DIG::InputDynamicRange; + const Reg InputType = PHA::DIG::InputType; + const Reg InputImpedance = PHA::DIG::InputImpedance; + const Reg IPAddress = PHA::DIG::IPAddress; + const Reg NetMask = PHA::DIG::NetMask; + const Reg Gateway = PHA::DIG::Gateway; + const Reg LED_status = PHA::DIG::LED_status; + const Reg ACQ_status = PHA::DIG::ACQ_status; + const Reg MaxRawDataSize = PHA::DIG::MaxRawDataSize; + const Reg TempSensAirIn = PHA::DIG::TempSensAirIn; + const Reg TempSensAirOut = PHA::DIG::TempSensAirOut; + const Reg TempSensCore = PHA::DIG::TempSensCore; + const Reg TempSensFirstADC = PHA::DIG::TempSensFirstADC; + const Reg TempSensLastADC = PHA::DIG::TempSensLastADC; + const Reg TempSensHottestADC = PHA::DIG::TempSensHottestADC; + const Reg TempSensADC0 = PHA::DIG::TempSensADC0; + const Reg TempSensADC1 = PHA::DIG::TempSensADC1; + const Reg TempSensADC2 = PHA::DIG::TempSensADC2; + const Reg TempSensADC3 = PHA::DIG::TempSensADC3; + const Reg TempSensADC4 = PHA::DIG::TempSensADC4; + const Reg TempSensADC5 = PHA::DIG::TempSensADC5; + const Reg TempSensADC6 = PHA::DIG::TempSensADC6; + const Reg TempSensADC7 = PHA::DIG::TempSensADC7; + + const std::vector TempSensADC = {TempSensADC0,TempSensADC1,TempSensADC2,TempSensADC3,TempSensADC4,TempSensADC5,TempSensADC6,TempSensADC7}; + const std::vector TempSensOthers = {TempSensAirIn,TempSensAirOut,TempSensCore,TempSensFirstADC,TempSensLastADC,TempSensHottestADC}; + + const Reg TempSensDCDC = PHA::DIG::TempSensDCDC; + const Reg VInSensDCDC = PHA::DIG::VInSensDCDC; + const Reg VOutSensDCDC = PHA::DIG::VOutSensDCDC; + const Reg IOutSensDCDC = PHA::DIG::IOutSensDCDC; + const Reg FreqSensCore = PHA::DIG::FreqSensCore; + const Reg DutyCycleSensDCDC = PHA::DIG::DutyCycleSensDCDC; + const Reg SpeedSensFan1 = PHA::DIG::SpeedSensFan1; + const Reg SpeedSensFan2 = PHA::DIG::SpeedSensFan2; + const Reg ErrorFlags = PHA::DIG::ErrorFlags; + const Reg BoardReady = PHA::DIG::BoardReady; + +///============= read write + //const Reg EnableClockOutBackplane ("EnClockOutP0", RW::ReadWrite, TYPE::DIG); + const Reg ClockSource = PHA::DIG::ClockSource; + const Reg IO_Level = PHA::DIG::IO_Level; + const Reg StartSource = PHA::DIG::StartSource; + const Reg GlobalTriggerSource = PHA::DIG::GlobalTriggerSource; + const Reg BusyInSource = PHA::DIG::BusyInSource; + const Reg EnableClockOutFrontPanel = PHA::DIG::EnableClockOutFrontPanel; + const Reg TrgOutMode = PHA::DIG::TrgOutMode; + const Reg GPIOMode = PHA::DIG::GPIOMode; + const Reg SyncOutMode = PHA::DIG::SyncOutMode; + const Reg BoardVetoSource = PHA::DIG::BoardVetoSource; + const Reg BoardVetoWidth = PHA::DIG::BoardVetoWidth; + const Reg BoardVetoPolarity = PHA::DIG::BoardVetoPolarity; + const Reg RunDelay = PHA::DIG::RunDelay; + const Reg EnableAutoDisarmACQ = PHA::DIG::EnableAutoDisarmACQ; + const Reg EnableDataReduction = PHA::DIG::EnableDataReduction; + const Reg EnableStatisticEvents = PHA::DIG::EnableStatisticEvents; + const Reg VolatileClockOutDelay = PHA::DIG::VolatileClockOutDelay; + const Reg PermanentClockOutDelay = PHA::DIG::PermanentClockOutDelay; + const Reg TestPulsePeriod = PHA::DIG::TestPulsePeriod; + const Reg TestPulseWidth = PHA::DIG::TestPulseWidth; + const Reg TestPulseLowLevel = PHA::DIG::TestPulseLowLevel; + const Reg TestPulseHighLevel = PHA::DIG::TestPulseHighLevel; + const Reg ErrorFlagMask = PHA::DIG::ErrorFlagMask; + const Reg ErrorFlagDataMask = PHA::DIG::ErrorFlagDataMask; + const Reg DACoutMode = PHA::DIG::DACoutMode; + const Reg DACoutStaticLevel = PHA::DIG::DACoutStaticLevel; + const Reg DACoutChSelect = PHA::DIG::DACoutChSelect; + const Reg EnableOffsetCalibration = PHA::DIG::EnableOffsetCalibration; + + const Reg ITLAMainLogic = PHA::DIG::ITLAMainLogic; + const Reg ITLAMajorityLev = PHA::DIG::ITLAMajorityLev; + const Reg ITLAPairLogic = PHA::DIG::ITLAPairLogic; + const Reg ITLAPolarity = PHA::DIG::ITLAPolarity; + const Reg ITLAMask = PHA::DIG::ITLAMask; + const Reg ITLAGateWidth = PHA::DIG::ITLAGateWidth; + const Reg ITLBMainLogic = PHA::DIG::ITLBMainLogic; + const Reg ITLBMajorityLev = PHA::DIG::ITLBMajorityLev; + const Reg ITLBPairLogic = PHA::DIG::ITLBPairLogic; + const Reg ITLBPolarity = PHA::DIG::ITLBPolarity; + const Reg ITLBMask = PHA::DIG::ITLBMask; + const Reg ITLBGateWidth = PHA::DIG::ITLBGateWidth; + + + const Reg LVDSIOReg = PHA::DIG::LVDSIOReg; + //const Reg LVDSTrgMask ("lvdstrgmask", RW::ReadWrite, TYPE::DIG, {}, ANSTYPE::BYTE, "64-bit"); + + /// ========== command + const Reg Reset = PHA::DIG::Reset; + const Reg ClearData = PHA::DIG::ClearData; + const Reg ArmACQ = PHA::DIG::ArmACQ; + const Reg DisarmACQ = PHA::DIG::DisarmACQ; + const Reg SoftwareStartACQ = PHA::DIG::SoftwareStartACQ; + const Reg SoftwareStopACQ = PHA::DIG::SoftwareStopACQ; + const Reg SendSoftwareTrigger = PHA::DIG::SendSoftwareTrigger; + const Reg ReloadCalibration = PHA::DIG::ReloadCalibration; + + + const std::vector AllSettings = { + CupVer , + FPGA_firmwareVersion , + FirmwareType , + ModelCode , + PBCode , + ModelName , + FromFactor , + FamilyCode , + SerialNumber , + PCBrev_MB , + PCBrev_PB , + DPP_License , + DPP_LicenseStatus , + DPP_LicenseRemainingTime , + NumberOfChannel , + ADC_bit , + ADC_SampleRate , + InputDynamicRange , + InputType , + InputImpedance , + IPAddress , + NetMask , + Gateway , + LED_status , + ACQ_status , + MaxRawDataSize , + TempSensAirIn , + TempSensAirOut , + TempSensCore , + TempSensFirstADC , + TempSensLastADC , + TempSensHottestADC , + TempSensADC0 , + TempSensADC1 , + TempSensADC2 , + TempSensADC3 , + TempSensADC4 , + TempSensADC5 , + TempSensADC6 , + TempSensADC7 , + TempSensDCDC , + VInSensDCDC , + VOutSensDCDC , + IOutSensDCDC , + FreqSensCore , + DutyCycleSensDCDC , + SpeedSensFan1 , + SpeedSensFan2 , + ErrorFlags , + BoardReady , + ClockSource , + IO_Level , + StartSource , + GlobalTriggerSource , + BusyInSource , + //EnableClockOutBackplane , + EnableClockOutFrontPanel , + TrgOutMode , + GPIOMode , + SyncOutMode , + BoardVetoSource , + BoardVetoWidth , + BoardVetoPolarity , + RunDelay , + EnableAutoDisarmACQ , + EnableDataReduction , + EnableStatisticEvents , + VolatileClockOutDelay , + PermanentClockOutDelay , + TestPulsePeriod , + TestPulseWidth , + TestPulseLowLevel , + TestPulseHighLevel , + ErrorFlagMask , + ErrorFlagDataMask , + DACoutMode , + DACoutStaticLevel , + DACoutChSelect , + EnableOffsetCalibration , + ITLAMainLogic , + ITLAMajorityLev , + ITLAPairLogic , + ITLAPolarity , + ITLAMask , + ITLAGateWidth , + ITLBMainLogic , + ITLBMajorityLev , + ITLBPairLogic , + ITLBPolarity , + ITLBMask , + ITLBGateWidth , + LVDSIOReg + //LVDSTrgMask + }; + + + } + + namespace VGA{ + const Reg VGAGain = PHA::VGA::VGAGain; + } + + namespace LVDS{ + + const Reg LVDSMode = PHA::LVDS::LVDSMode; + const Reg LVDSDirection = PHA::LVDS::LVDSDirection; + + const std::vector AllSettings = { + LVDSMode , + LVDSDirection + }; + + } + + namespace CH{ + + /// ========= red only + const Reg SelfTrgRate = PHA::CH::SelfTrgRate; + const Reg ChannelStatus = PHA::CH::ChannelStatus; + const Reg GainFactor = PHA::CH::GainFactor; + const Reg ADCToVolts = PHA::CH::ADCToVolts; + const Reg ChannelRealtime = PHA::CH::ChannelRealtime; + const Reg ChannelDeadtime = PHA::CH::ChannelDeadtime; + const Reg ChannelTriggerCount = PHA::CH::ChannelTriggerCount; + const Reg ChannelSavedCount = PHA::CH::ChannelSavedCount; + const Reg ChannelWaveCount = PHA::CH::ChannelWaveCount; + + /// ======= read write + const Reg ChannelEnable = PHA::CH::ChannelEnable; + const Reg DC_Offset = PHA::CH::DC_Offset; + const Reg TriggerThreshold = PHA::CH::TriggerThreshold; + const Reg Polarity = PHA::CH::Polarity; + + const Reg WaveDataSource = PHA::CH::WaveDataSource; + const Reg RecordLength = PHA::CH::RecordLength; + const Reg PreTrigger = PHA::CH::PreTrigger; + const Reg WaveSaving = PHA::CH::WaveSaving; + const Reg WaveResolution = PHA::CH::WaveResolution; + + + const Reg WaveAnalogProbe0 ("WaveAnalogProbe0", RW::ReadWrite, TYPE::CH, {{"ADCInput", "ADC Input"}, + {"ADCInputBaseline", "ADC Input baseline"}, + {"CFDFilter", "CFD Filter"}}); + const Reg WaveAnalogProbe1 ("WaveAnalogProbe1", RW::ReadWrite, TYPE::CH, {{"ADCInput", "ADC Input"}, + {"ADCInputBaseline", "ADC Input baseline"}, + {"CFDFilter", "CFD Filter"}}); + const Reg WaveDigitalProbe0 ("WaveDigitalProbe0", RW::ReadWrite, TYPE::CH, {{"Trigger", "Trigger"}, + {"CFDFilterArmed", "CFD Filter Armed"}, + {"ReTriggerGuard", "ReTrigger Guard"}, + {"ADCInputBaselineFreeze", "ADC Input basline Freeze"}, + {"ADCInputOverthreshold", "ADC Input Over-threshold"}, + {"ChargeReady", "Charge Ready"}, + {"LongGate", "Long Gate"}, + {"ShortGate", "Short Gate"}, + {"PileUpTrigger", "Pile-up Trig."}, + {"ChargeOverRange", "Charge Over Range"}, + {"ADCSaturation", "ADC Saturate"}, + {"ADCInputNegativeOverthreshold", "ADC Input Neg. Over-Threshold"} }); + const Reg WaveDigitalProbe1 ("WaveDigitalProbe1", RW::ReadWrite, TYPE::CH, {{"Trigger", "Trigger"}, + {"CFDFilterArmed", "CFD Filter Armed"}, + {"ReTriggerGuard", "ReTrigger Guard"}, + {"ADCInputBaselineFreeze", "ADC Input basline Freeze"}, + {"ADCInputOverthreshold", "ADC Input Over-threshold"}, + {"ChargeReady", "Charge Ready"}, + {"LongGate", "Long Gate"}, + {"ShortGate", "Short Gate"}, + {"PileUpTrigger", "Pile-up Trig."}, + {"ChargeOverRange", "Charge Over Range"}, + {"ADCSaturation", "ADC Saturate"}, + {"ADCInputNegativeOverthreshold", "ADC Input Neg. Over-Threshold"} }); + const Reg WaveDigitalProbe2 ("WaveDigitalProbe2", RW::ReadWrite, TYPE::CH, {{"Trigger", "Trigger"}, + {"CFDFilterArmed", "CFD Filter Armed"}, + {"ReTriggerGuard", "ReTrigger Guard"}, + {"ADCInputBaselineFreeze", "ADC Input basline Freeze"}, + {"ADCInputOverthreshold", "ADC Input Over-threshold"}, + {"ChargeReady", "Charge Ready"}, + {"LongGate", "Long Gate"}, + {"ShortGate", "Short Gate"}, + {"PileUpTrigger", "Pile-up Trig."}, + {"ChargeOverRange", "Charge Over Range"}, + {"ADCSaturation", "ADC Saturate"}, + {"ADCInputNegativeOverthreshold", "ADC Input Neg. Over-Threshold"} }); + const Reg WaveDigitalProbe3 ("WaveDigitalProbe3", RW::ReadWrite, TYPE::CH, {{"Trigger", "Trigger"}, + {"CFDFilterArmed", "CFD Filter Armed"}, + {"ReTriggerGuard", "ReTrigger Guard"}, + {"ADCInputBaselineFreeze", "ADC Input basline Freeze"}, + {"ADCInputOverthreshold", "ADC Input Over-threshold"}, + {"ChargeReady", "Charge Ready"}, + {"LongGate", "Long Gate"}, + {"ShortGate", "Short Gate"}, + {"PileUpTrigger", "Pile-up Trig."}, + {"ChargeOverRange", "Charge Over Range"}, + {"ADCSaturation", "ADC Saturate"}, + {"ADCInputNegativeOverthreshold", "ADC Input Neg. Over-Threshold"} }); + + const std::vector AnalogProbe = {WaveAnalogProbe0, WaveAnalogProbe1}; + const std::vector DigitalProbe = {WaveDigitalProbe0, WaveDigitalProbe1, WaveDigitalProbe2, WaveDigitalProbe3}; + + + const Reg EventTriggerSource = PHA::CH::EventTriggerSource; + const Reg ChannelsTriggerMask = PHA::CH::ChannelsTriggerMask; + const Reg ChannelVetoSource = PHA::CH::ChannelVetoSource; + const Reg WaveTriggerSource = PHA::CH::WaveTriggerSource; + + const Reg EventSelector = PHA::CH::EventSelector; + const Reg WaveSelector = PHA::CH::WaveSelector; + const Reg CoincidenceMask = PHA::CH::CoincidenceMask; + const Reg AntiCoincidenceMask = PHA::CH::AntiCoincidenceMask; + const Reg CoincidenceLength = PHA::CH::CoincidenceLength; + const Reg CoincidenceLengthSample = PHA::CH::CoincidenceLengthSample; + + const Reg ADCVetoWidth = PHA::CH::ADCVetoWidth; + + const Reg EventNeutronReject ("EventNeutronReject", RW::ReadWrite, TYPE::CH, {{"Disabled", "Disabled"},{"Enabled", "Enabled"}}); + const Reg WaveNeutronReject ("WaveNeutronReject", RW::ReadWrite, TYPE::CH, {{"Disabled", "Disabled"},{"Enabled", "Enabled"}}); + + const Reg EnergySkimLowDiscriminator = PHA::CH::EnergySkimLowDiscriminator; + const Reg EnergySkimHighDiscriminator = PHA::CH::EnergySkimHighDiscriminator; + + const Reg RecordLengthSample = PHA::CH::RecordLengthSample; + const Reg PreTriggerSample = PHA::CH::PreTriggerSample; + + const Reg ITLConnect = PHA::CH::ITLConnect; + + const Reg ADCInputBaselineAvg ("ADCInputBaselineAvg", RW::ReadWrite, TYPE::CH, {{"Fixed", "Fixed"}, + {"Low", "Low"}, + {"MediumLow", "MediumLow"}, + {"MediumHigh", "MediumHigh"}, + {"High", "High"}}); + + const Reg AbsoluteBaseline ("AbsoluteBaseline", RW::ReadWrite, TYPE::CH, {{"0", ""},{"65535", ""},{"1", ""}}, ANSTYPE::INTEGER, "sample"); + const Reg ADCInputBaselineGuard ("ADCInputBaselineGuardT", RW::ReadWrite, TYPE::CH, {{"0", ""},{"8000", ""},{"8", ""}}, ANSTYPE::INTEGER, "ns"); + + const Reg SmoothingFactor ("SmoothingFactor", RW::ReadWrite, TYPE::CH, {{"1", "Disabled"}, + {"2", "Avg. 2 samples"}, + {"4", "Avg. 4 samples"}, + {"8", "Avg. 8 samples"}, + {"16", "Avg. 16 samples"}}); + + const Reg ChargeSmoothing ("ChargeSmoothing", RW::ReadWrite, TYPE::CH, {{"Enabled", "Enabled"}, {"Disabled", "Disabled"}}); + const Reg TimeFilterSmoothing ("TimeFilterSmoothing", RW::ReadWrite, TYPE::CH, {{"Enabled", "Enabled"}, {"Disabled", "Disabled"}}); + const Reg TriggerFilterSelection ("TriggerFilterSelection", RW::ReadWrite, TYPE::CH, {{"LeadingEdge", "Leading Edge"}, {"CFD", "CFD"}}); + + const Reg CFDDelay ("CFDDelayT", RW::ReadWrite, TYPE::CH, {{"32", ""},{"8184", ""},{"8", ""}}, ANSTYPE::INTEGER, "ns"); + const Reg CFDFraction ("CFDFraction", RW::ReadWrite, TYPE::CH, {{"25", ""},{"100", ""},{"0", ""}}, ANSTYPE::INTEGER, "%"); + + const Reg TimeFilterRetriggerGuard ("TimeFilterRetriggerGuardT", RW::ReadWrite, TYPE::CH, {{"0", ""},{"8000", ""},{"8", ""}}, ANSTYPE::INTEGER, "ns"); + + const Reg TriggerHysteresis ("TriggerHysteresis", RW::ReadWrite, TYPE::CH, {{"Enabled", "Enabled"}, {"Disabled", "Disabled"}}); + const Reg PileupGap ("PileupGap", RW::ReadWrite, TYPE::CH, {{"0", ""},{"65535", ""},{"1", ""}}, ANSTYPE::INTEGER, "sample"); + const Reg GateLongLength ("GateLongLengthT", RW::ReadWrite, TYPE::CH, {{"0", ""},{"32000", ""},{"8", ""}}, ANSTYPE::INTEGER, "ns"); + const Reg GateShortLength ("GateShortLengthT", RW::ReadWrite, TYPE::CH, {{"0", ""},{"32000", ""},{"8", ""}}, ANSTYPE::INTEGER, "ns"); + const Reg GateOffset ("GateOffsetT", RW::ReadWrite, TYPE::CH, {{"0", ""},{"2000", ""},{"8", ""}}, ANSTYPE::INTEGER, "ns"); + const Reg LongChargeIntegratorPedestal ("LongChargeIntegratorPedestal", RW::ReadWrite, TYPE::CH, {{"0", ""},{"1000", ""},{"1", ""}}, ANSTYPE::INTEGER, "count"); + const Reg ShortChargeIntegratorPedestal ("ShortChargeIntegratorPedestal", RW::ReadWrite, TYPE::CH, {{"0", ""},{"1000", ""},{"1", ""}}, ANSTYPE::INTEGER, "count"); + + const Reg EnergyGain ("EnergyGain", RW::ReadWrite, TYPE::CH, {{"1", "No Gain"}, + {"4", "x4"}, + {"16", "x16"}, + {"64", "x64"}, + {"256", "x256"}}); + + const Reg NeutronThreshold ("NeutronThreshold", RW::ReadWrite, TYPE::CH, {{"0", ""},{"1000", ""},{"1", ""}}, ANSTYPE::INTEGER, "count"); + + const Reg ADCInputBaselineGuardSample ("ADCInputBaselineGuardS", RW::ReadWrite, TYPE::CH, {{"0", ""},{"1000", ""},{"1", ""}}, ANSTYPE::INTEGER, "sample"); + const Reg CFDDelaySample ("CFDDelayS", RW::ReadWrite, TYPE::CH, {{"4", ""},{"1023", ""},{"1", ""}}, ANSTYPE::INTEGER, "sample"); + const Reg TimeFilterRetriggerGuardSample ("TimeFilterRetriggerGuardT", RW::ReadWrite, TYPE::CH, {{"0", ""},{"8000", ""},{"8", ""}}, ANSTYPE::INTEGER, "sample"); + const Reg GateLongLengthSample ("GateLongLengthS", RW::ReadWrite, TYPE::CH, {{"0", ""},{"4000", ""},{"1", ""}}, ANSTYPE::INTEGER, "sample"); + const Reg GateShortLengthSample ("GateShortLengthS", RW::ReadWrite, TYPE::CH, {{"0", ""},{"4000", ""},{"1", ""}}, ANSTYPE::INTEGER, "sample"); + const Reg GateOffsetSample ("GateOffsetS", RW::ReadWrite, TYPE::CH, {{"0", ""},{"250", ""},{"1", ""}}, ANSTYPE::INTEGER, "sample"); + + + const std::vector AllSettings = { + SelfTrgRate , + ChannelStatus , + GainFactor , + ADCToVolts , + ChannelRealtime , + ChannelDeadtime , + ChannelTriggerCount , + ChannelSavedCount , + ChannelWaveCount , + ChannelEnable , + DC_Offset , + TriggerThreshold , + Polarity , + WaveDataSource , + RecordLength , + WaveSaving , + WaveResolution , + PreTrigger , + WaveAnalogProbe0 , + WaveAnalogProbe1 , + WaveDigitalProbe0 , + WaveDigitalProbe1 , + WaveDigitalProbe2 , + WaveDigitalProbe3 , + EventTriggerSource , + ChannelsTriggerMask , + ChannelVetoSource , + WaveTriggerSource , + EventSelector , + WaveSelector , + CoincidenceMask , + AntiCoincidenceMask , + CoincidenceLength , + CoincidenceLengthSample , + ADCVetoWidth , + EnergySkimLowDiscriminator , + EnergySkimHighDiscriminator, + RecordLengthSample , + PreTriggerSample , + ITLConnect , + ADCInputBaselineAvg , + AbsoluteBaseline , + ADCInputBaselineGuard , + SmoothingFactor , + ChargeSmoothing , + TimeFilterSmoothing , + TriggerFilterSelection , + CFDDelay , + CFDFraction , + TimeFilterRetriggerGuard , + TriggerHysteresis , + PileupGap , + GateLongLength , + GateShortLength , + GateOffset , + LongChargeIntegratorPedestal, + ShortChargeIntegratorPedestal, + EnergyGain , + NeutronThreshold , + ADCInputBaselineGuardSample, + CFDDelaySample , + TimeFilterRetriggerGuardSample, + GateLongLengthSample , + GateShortLengthSample , + GateOffsetSample + }; + + } + + +}; + #endif \ No newline at end of file diff --git a/digiSettingsPanel.cpp b/digiSettingsPanel.cpp index 73263a8..e4a3eeb 100644 --- a/digiSettingsPanel.cpp +++ b/digiSettingsPanel.cpp @@ -430,6 +430,20 @@ DigiSettingsPanel::DigiSettingsPanel(Digitizer2Gen ** digi, unsigned short nDigi cbbBdVetoPolarity[iDigi] = new RComboBox(tab); boardLayout->addWidget(cbbBdVetoPolarity[iDigi], rowId, 6); SetupShortComboBox(cbbBdVetoPolarity[iDigi], PHA::DIG::BoardVetoPolarity); + connect(cbbBdVetoPolarity[iDigi], &RComboBox::currentIndexChanged, this, [=](){ + if( !enableSignalSlot ) return; + QString msg; + msg = "DIG:"+ QString::number(digi[ID]->GetSerialNumber()) + "|" + QString::fromStdString(PHA::DIG::BoardVetoPolarity.GetPara()); + msg += " = " + cbbBdVetoPolarity[ID]->currentData().toString(); + if( digi[ID]->WriteValue(PHA::DIG::BoardVetoPolarity, cbbStatEvents[ID]->currentData().toString().toStdString()) ){ + SendLogMsg(msg + "|OK."); + cbbBdVetoPolarity[ID]->setStyleSheet(""); + }else{ + SendLogMsg(msg + "|Fail."); + cbbBdVetoPolarity[ID]->setStyleSheet("color:red"); + } + }); + //------------------------------------- rowId ++; @@ -1966,7 +1980,7 @@ void DigiSettingsPanel::LoadSettings(){ void DigiSettingsPanel::SetDefaultPHASettigns(){ SendLogMsg("Program Digitizer-" + QString::number(digi[ID]->GetSerialNumber()) + " to default PHA."); - digi[ID]->ProgramPHABoard(); + digi[ID]->ProgramDPPBoard(); digi[ID]->ProgramPHAChannels(); RefreshSettings(); } diff --git a/mainwindow.cpp b/mainwindow.cpp index 82426a5..30a61be 100644 --- a/mainwindow.cpp +++ b/mainwindow.cpp @@ -696,7 +696,7 @@ void MainWindow::OpenDigitizers(){ digi[i]->SetSettingFileName(""); //LogMsg("Reset digitizer And set default PHA settings."); //digi[i]->Reset(); - //digi[i]->ProgramPHABoard(false); + //digi[i]->ProgramDPPBoard(false); } digi[i]->ReadAllSettings(); diff --git a/test.cpp b/test.cpp index 5a57293..1c72c54 100644 --- a/test.cpp +++ b/test.cpp @@ -90,7 +90,7 @@ int main(int argc, char* argv[]){ digi->OpenDigitizer(url); digi->Reset(); - //digi->ProgramPHABoard(false); + //digi->ProgramDPPBoard(false); //printf("--------%s \n", digi->ReadChValue("0..63", "WaveAnalogprobe0", true).c_str());