Commit 87fa6aae authored by fipps's avatar fipps
Browse files

Commit cfd2 (Patrick tests)

parent e8270ef5
/*
* Nomad Instrument Control Software
*
* Copyright 2011 Institut Laue-Langevin
*
* Licensed under the EUPL, Version 1.1 only (the "License");
* You may not use this work except in compliance with the Licence.
* You may obtain a copy of the Licence at:
*
* http://joinup.ec.europa.eu/software/page/eupl
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the Licence is distributed on an "AS IS" basis,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the Licence for the specific language governing permissions and
* limitations under the Licence.
*/
#include "CAENCfd2Controller.h"
#include "drivers/global/DriversCommands.h"
#include "controllers/common/family/Families.h"
#include <boost/thread/thread.hpp>
#include <lstdpp128/lstdpp.h>
#include <controllers/common/acquisition/mode/DPPAcquisitionCommon.h>
using namespace std;
using namespace boost;
namespace npp {
const string CAENCfd2Controller::TYPE = "cfd2_controller";
/*
* Constructor
*/
CAENCfd2Controller::CAENCfd2Controller(const string& name) : CAENAdcController(name) {
setFamily(family::ACQUISITION, family::SETTING);
nbBits.init(this, NOSAVE, "nb_bits");
signalDecayTime.init(this, NOSAVE, "decay_time");
trapezoidFlatTop.init(this, NOSAVE, "trapezoid_flat");
trapezoidRiseTime.init(this, NOSAVE, "trapezoid_rise");
flatTopDelay.init(this, NOSAVE, "flat_top");
triggerSmoothing.init(this, NOSAVE, "trigger_smoothing");
signalRiseTime.init(this, NOSAVE, "rise_time");
triggerThreshold.init(this, NOSAVE, "trigger_threshold");
baselineMean.init(this, NOSAVE, "base_mean");
peakMean.init(this, NOSAVE, "peak_mean");
peakHoldOff.init(this, NOSAVE, "peak_holdoff");
baselineHoldOff.init(this, NOSAVE, "base_holdoff");
triggerHoldOff.init(this, NOSAVE, "trigger_holdoff");
triggerWindowSize.init(this, NOSAVE, "trigger_window_size");
triggerWindowEnable.init(this, NOSAVE, "trigger_window_enable");
digitalGain.init(this, NOSAVE, "digital_gain");
trapezoidGain.init(this, NOSAVE, "trapezoid_gain");
decimation.init(this, NOSAVE, "decimation");
useFirstDerivative.init(this, NOSAVE, "use_first_derivative");
cfdActive.init(this, NOSAVE, "cfd_active");
cfdFraction.init(this, NOSAVE, "cfd_fraction");
cfdDelay.init(this, NOSAVE, "cfd_delay");
cfdSignalZero.init(this, NOSAVE, "signal_zero");
dynamicRange.init(this, NOSAVE, "dynamic_range");
cfdTrap.init(this, SAVE, "cfd_trap");
adcTemperature.init(this, NOSAVE, "adc_temperature");
m_dgtzDriver.init(this, "cfd_driver");
registerFunction(TYPE);
adcTemperature.resize(16);
}
/*
* Destructor
*/
CAENCfd2Controller::~CAENCfd2Controller() {
}
/*
* postConfiguration
*/
void CAENCfd2Controller::postConfiguration() {
registerRefresher(recordLength, &CAENCfd2Controller::refreshRecordLengthProperty, this);
registerRefresher(cfdTrap, &CAENCfd2Controller::refreshcfdTrapProperty, this);
registerRefresher(nbChannels, &CAENCfd2Controller::refreshNbChannelsProperty, this);
registerRefresher(dppAcqMode, &CAENCfd2Controller::refreshDppAcqModeProperty, this);
registerRefresher(displayChannel, &CAENCfd2Controller::refreshDisplayChannelProperty, this);
registerRefresher(signalDecayTime, &CAENCfd2Controller::refreshSignalDecayTime, this);
registerRefresher(trapezoidFlatTop, &CAENCfd2Controller::refreshTrapezoidFlatTopProperty, this);
registerRefresher(trapezoidRiseTime, &CAENCfd2Controller::refreshTrapezoidRiseTimeProperty, this);
registerRefresher(flatTopDelay, &CAENCfd2Controller::refreshFlatTopDelayProperty, this);
registerRefresher(triggerSmoothing, &CAENCfd2Controller::refreshTriggerSmoothing, this);
registerRefresher(signalRiseTime, &CAENCfd2Controller::refreshSignalRiseTimeProperty, this);
registerRefresher(triggerThreshold, &CAENCfd2Controller::refreshTriggerThresholdProperty, this);
registerRefresher(baselineMean, &CAENCfd2Controller::refreshBaselineMean, this);
registerRefresher(peakMean, &CAENCfd2Controller::refreshPeakMean, this);
registerRefresher(peakHoldOff, &CAENCfd2Controller::refreshPeaklineHoldOffProperty, this);
registerRefresher(baselineHoldOff, &CAENCfd2Controller::refreshBaselineHoldOffProperty, this);
registerRefresher(triggerHoldOff, &CAENCfd2Controller::refreshTriggerHoldOffProperty, this);
registerRefresher(triggerWindowSize, &CAENCfd2Controller::refreshTriggerWindowSizeProperty, this);
registerRefresher(triggerWindowEnable, &CAENCfd2Controller::refreshTriggerWindowEnableProperty, this);
registerRefresher(digitalGain, &CAENCfd2Controller::refreshDigitalGainProperty, this);
registerRefresher(trapezoidGain, &CAENCfd2Controller::refreshTrapezoidGainProperty, this);
registerRefresher(decimation, &CAENCfd2Controller::refreshDecimationProperty, this);
registerRefresher(channelActive, &CAENCfd2Controller::refreshChannelActiveProperty, this);
registerRefresher(dcOffset, &CAENCfd2Controller::refreshDcOffsetProperty, this);
registerRefresher(preTrigger, &CAENCfd2Controller::refreshPreTriggerProperty, this);
registerRefresher(pulsePolarity, &CAENCfd2Controller::refreshPulsePolarityProperty, this);
registerRefresher(useFirstDerivative, &CAENCfd2Controller::refreshUseFirstDerivativeProperty, this);
registerRefresher(cfdActive, &CAENCfd2Controller::refreshCfdActiveProperty, this);
registerRefresher(cfdFraction, &CAENCfd2Controller::refreshCfdFractionProperty, this);
registerRefresher(cfdDelay, &CAENCfd2Controller::refreshCfdDelayProperty, this);
registerRefresher(cfdSignalZero, &CAENCfd2Controller::refreshCfdSignalZeroProperty, this);
registerRefresher(dynamicRange, &CAENCfd2Controller::refreshDynamicRangeProperty, this);
registerUpdater(m_dgtzDriver->adcTemperature, &CAENCfd2Controller::updateAdcTemperatureProperty, this);
updateBoardProperties();
}
void CAENCfd2Controller::refreshRecordLengthProperty(int32 aValue) throw (CannotSetValue) {
m_dgtzDriver->recordLength.update(aValue);
}
void CAENCfd2Controller::refreshcfdTrapProperty(int32 aValue) throw (CannotSetValue) {
m_dgtzDriver->cfdTrap.update(aValue);
}
void CAENCfd2Controller::refreshNbChannelsProperty(int32 aValue) throw (CannotSetValue) {
minRange = 0;
maxRange = aValue - 1;
m_dgtzDriver->nbChannels.update(aValue);
if (displayChannel() >= aValue)
displayChannel = aValue - 1;
}
void CAENCfd2Controller::refreshDppAcqModeProperty(int32 aValue) throw (CannotSetValue) {
CAENAdcController::refreshDppAcqModeProperty(aValue);
m_dgtzDriver->dppAcqMode.update(aValue);
boost::thread td(boost::bind(&CAENCfd2Controller::initBoard, this));
}
void CAENCfd2Controller::refreshDisplayChannelProperty(int32 aChannel) throw (CannotSetValue) {
float64 decayTime = m_dgtzDriver->signalDecayTime.get(aChannel) / 1000.0;
if (decayTime == 0.0)
decayTime = 20.0;
signalDecayTime.update(decayTime);
float64 flatTop = m_dgtzDriver->trapezoidFlatTop.get(aChannel) / 1000.0;
if (flatTop == 0.0)
flatTop = 1.0;
trapezoidFlatTop.update(flatTop);
float64 trapRise = m_dgtzDriver->trapezoidRiseTime.get(aChannel) / 1000.0;
if (trapRise == 0.0)
trapRise = 1.0;
trapezoidRiseTime.update(trapRise);
float64 peaking = m_dgtzDriver->flatTopDelay.get(aChannel) / 1000.0;
if (peaking == 0.0)
peaking = 0.5;
flatTopDelay.update(peaking);
int32 trigAvrg = m_dgtzDriver->triggerSmoothing.get(aChannel);
if (trigAvrg == 0)
trigAvrg = 2;
triggerSmoothing.update(trigAvrg);
float64 riseTime = m_dgtzDriver->signalRiseTime.get(aChannel) / 1000.0;
if (riseTime == 0.0)
riseTime = 0.2;
signalRiseTime.update(riseTime);
int32 trigTrsd = m_dgtzDriver->triggerThreshold.get(aChannel);
if (trigTrsd == 0)
trigTrsd = 200;
triggerThreshold.update(trigTrsd);
int32 baseAvrg = m_dgtzDriver->baselineMean.get(aChannel);
if (baseAvrg == 0)
baseAvrg = 2;
baselineMean.update(baseAvrg);
int32 peakAvrg = m_dgtzDriver->peakMean.get(aChannel);
if (peakAvrg == 0)
peakAvrg = 1;
peakMean.update(peakAvrg);
float64 peakHold = m_dgtzDriver->peakHoldOff.get(aChannel) / 1000.0;
if (peakHold == 0.0)
peakHold = 0.5;
peakHoldOff.update(peakHold);
float64 baseHold = m_dgtzDriver->baselineHoldOff.get(aChannel) / 1000.0;
if (baseHold == 0.0)
baseHold = 0.5;
baselineHoldOff.update(baseHold);
float64 trigHold = m_dgtzDriver->triggerHoldOff.get(aChannel) / 1000.0;
if (trigHold == 0.0)
trigHold = 0.5;
triggerHoldOff.update(trigHold);
int32 trigWindow = m_dgtzDriver->triggerWindowSize.get(aChannel);
if (trigWindow == 0)
trigWindow = 300;
triggerWindowSize.update(trigWindow);
triggerWindowEnable.update(m_dgtzDriver->triggerWindowEnable.get(aChannel));
digitalGain.update(m_dgtzDriver->digitalGain.get(aChannel));
float64 trapGain = m_dgtzDriver->trapezoidGain.get(aChannel);
if (trapGain == 0.0)
trapGain = 1.0;
trapezoidGain.update(trapGain);
decimation.update(m_dgtzDriver->decimation.get(aChannel));
channelActive.update(m_dgtzDriver->channelActive.get(aChannel));
int32 offSet = m_dgtzDriver->dcOffset.get(aChannel);
if (offSet == 0)
offSet = 10;
dcOffset.update(offSet);
int32 preTrig = m_dgtzDriver->preTrigger.get(aChannel);
if (preTrig == 0)
preTrig = 500;
preTrigger.update(preTrig);
pulsePolarity.update(m_dgtzDriver->pulsePolarity.get(aChannel));
useFirstDerivative.update(m_dgtzDriver->useFirstDerivative.get(aChannel));
cfdActive.update(m_dgtzDriver->cfdActive.get(aChannel));
cfdFraction.update(m_dgtzDriver->cfdFraction.get(aChannel));
cfdDelay.update(m_dgtzDriver->cfdDelay.get(aChannel));
cfdSignalZero.update(m_dgtzDriver->cfdSignalZero.get(aChannel));
initChannel(aChannel);
}
void CAENCfd2Controller::refreshSignalDecayTime(float64 aValue) throw (CannotSetValue) {
m_dgtzDriver->signalDecayTime.set(displayChannel(), (int32)(aValue * 1000));
boost::thread td(boost::bind(&CAENCfd2Controller::writeParam, this));
}
void CAENCfd2Controller::refreshTrapezoidFlatTopProperty(float64 aValue) throw (CannotSetValue) {
m_dgtzDriver->trapezoidFlatTop.set(displayChannel(), (int32)(aValue * 1000));
boost::thread td(boost::bind(&CAENCfd2Controller::writeParam, this));
}
void CAENCfd2Controller::refreshTrapezoidRiseTimeProperty(float64 aValue) throw (CannotSetValue) {
m_dgtzDriver->trapezoidRiseTime.set(displayChannel(), (int32)(aValue * 1000));
boost::thread td(boost::bind(&CAENCfd2Controller::writeParam, this));
}
void CAENCfd2Controller::refreshFlatTopDelayProperty(float64 aValue) throw (CannotSetValue) {
m_dgtzDriver->flatTopDelay.set(displayChannel(), (int32)(aValue * 1000));
boost::thread td(boost::bind(&CAENCfd2Controller::writeParam, this));
}
void CAENCfd2Controller::refreshTriggerSmoothing(int32 aValue) throw (CannotSetValue) {
m_dgtzDriver->triggerSmoothing.set(displayChannel(), aValue);
boost::thread td(boost::bind(&CAENCfd2Controller::writeParam, this));
}
void CAENCfd2Controller::refreshSignalRiseTimeProperty(float64 aValue) throw (CannotSetValue) {
m_dgtzDriver->signalRiseTime.set(displayChannel(), (int32)(aValue * 1000));
boost::thread td(boost::bind(&CAENCfd2Controller::writeParam, this));
}
void CAENCfd2Controller::refreshTriggerThresholdProperty(int32 aValue) throw (CannotSetValue) {
m_dgtzDriver->triggerThreshold.set(displayChannel(), aValue);
boost::thread td(boost::bind(&CAENCfd2Controller::writeParam, this));
}
void CAENCfd2Controller::refreshBaselineMean(int32 aValue) throw (CannotSetValue) {
m_dgtzDriver->baselineMean.set(displayChannel(), aValue);
boost::thread td(boost::bind(&CAENCfd2Controller::writeParam, this));
}
void CAENCfd2Controller::refreshPeakMean(int32 aValue) throw (CannotSetValue) {
m_dgtzDriver->peakMean.set(displayChannel(), aValue);
boost::thread td(boost::bind(&CAENCfd2Controller::writeParam, this));
}
void CAENCfd2Controller::refreshPeaklineHoldOffProperty(float64 aValue) throw (CannotSetValue) {
m_dgtzDriver->peakHoldOff.set(displayChannel(), (int32)(aValue * 1000));
boost::thread td(boost::bind(&CAENCfd2Controller::writeParam, this));
}
void CAENCfd2Controller::refreshBaselineHoldOffProperty(float64 aValue) throw (CannotSetValue) {
m_dgtzDriver->baselineHoldOff.set(displayChannel(), (int32)(aValue * 1000));
boost::thread td(boost::bind(&CAENCfd2Controller::writeParam, this));
}
void CAENCfd2Controller::refreshTriggerHoldOffProperty(float64 aValue) throw (CannotSetValue) {
m_dgtzDriver->triggerHoldOff.set(displayChannel(), (int32)(aValue * 1000));
boost::thread td(boost::bind(&CAENCfd2Controller::writeParam, this));
}
void CAENCfd2Controller::refreshTriggerWindowSizeProperty(int32 aValue) throw (CannotSetValue) {
m_dgtzDriver->triggerWindowSize.set(displayChannel(), aValue);
boost::thread td(boost::bind(&CAENCfd2Controller::writeParam, this));
}
void CAENCfd2Controller::refreshTriggerWindowEnableProperty(int32 aValue) throw (CannotSetValue) {
m_dgtzDriver->triggerWindowEnable.set(displayChannel(), aValue);
boost::thread td(boost::bind(&CAENCfd2Controller::writeParam, this));
}
void CAENCfd2Controller::refreshDigitalGainProperty(int32 aValue) throw (CannotSetValue) {
m_dgtzDriver->digitalGain.set(displayChannel(), aValue);
boost::thread td(boost::bind(&CAENCfd2Controller::writeParam, this));
}
void CAENCfd2Controller::refreshTrapezoidGainProperty(float64 aValue) throw (CannotSetValue) {
m_dgtzDriver->trapezoidGain.set(displayChannel(), aValue);
boost::thread td(boost::bind(&CAENCfd2Controller::writeParam, this));
}
void CAENCfd2Controller::refreshDecimationProperty(int32 aValue) throw (CannotSetValue) {
m_dgtzDriver->decimation.set(displayChannel(), aValue);
boost::thread td(boost::bind(&CAENCfd2Controller::writeParam, this));
}
void CAENCfd2Controller::refreshChannelActiveProperty(int32 aValue) throw (CannotSetValue) {
m_dgtzDriver->channelActive.set(displayChannel(), aValue);
// Update channel mask
int32 mask = 0;
for (int32 i=0; i<m_dgtzDriver->nbChannels(); ++i) {
if (m_dgtzDriver->channelActive.get(i))
mask += (m_dgtzDriver->channelActive.get(i) << i);
}
m_dgtzDriver->channelMask = mask;
boost::thread td(boost::bind(&CAENCfd2Controller::writeParam, this));
}
void CAENCfd2Controller::refreshDcOffsetProperty(int32 aValue) throw (CannotSetValue) {
m_dgtzDriver->dcOffset.set(displayChannel(), aValue);
boost::thread td(boost::bind(&CAENCfd2Controller::writeParam, this));
}
void CAENCfd2Controller::refreshPreTriggerProperty(int32 aValue) throw (CannotSetValue) {
m_dgtzDriver->preTrigger.set(displayChannel(), aValue);
boost::thread td(boost::bind(&CAENCfd2Controller::writeParam, this));
}
void CAENCfd2Controller::refreshPulsePolarityProperty(int32 aValue) throw (CannotSetValue) {
m_dgtzDriver->pulsePolarity.set(displayChannel(), aValue);
boost::thread td(boost::bind(&CAENCfd2Controller::writeParam, this));
}
void CAENCfd2Controller::refreshUseFirstDerivativeProperty(int32 aValue) throw (CannotSetValue) {
m_dgtzDriver->useFirstDerivative.set(displayChannel(), aValue);
boost::thread td(boost::bind(&CAENCfd2Controller::writeParam, this));
}
void CAENCfd2Controller::refreshCfdActiveProperty(int32 aValue) throw (CannotSetValue) {
m_dgtzDriver->cfdActive.set(displayChannel(), aValue);
boost::thread td(boost::bind(&CAENCfd2Controller::writeParam, this));
}
void CAENCfd2Controller::refreshCfdFractionProperty(int32 aValue) throw (CannotSetValue) {
m_dgtzDriver->cfdFraction.set(displayChannel(), aValue);
boost::thread td(boost::bind(&CAENCfd2Controller::writeParam, this));
}
void CAENCfd2Controller::refreshCfdDelayProperty(int32 aValue) throw (CannotSetValue) {
m_dgtzDriver->cfdDelay.set(displayChannel(), aValue);
boost::thread td(boost::bind(&CAENCfd2Controller::writeParam, this));
}
void CAENCfd2Controller::refreshCfdSignalZeroProperty(int32 aValue) throw (CannotSetValue) {
m_dgtzDriver->cfdSignalZero.set(displayChannel(), aValue);
boost::thread td(boost::bind(&CAENCfd2Controller::writeParam, this));
}
void CAENCfd2Controller::refreshDynamicRangeProperty(int32 aValue) throw (CannotSetValue) {
m_dgtzDriver->dynamicRange.set(displayChannel(), aValue);
if (aValue == 0) {
m_dgtzDriver->dynamicRangeStr.set(displayChannel(), "2");
} else if (aValue == 1) {
m_dgtzDriver->dynamicRangeStr.set(displayChannel(), "0.5");
}
boost::thread td(boost::bind(&CAENCfd2Controller::writeParam, this));
}
void CAENCfd2Controller::updateBoardProperties() {
modelName.update(m_dgtzDriver->modelName());
if (modelName() == "V1724") {
cardType = lstdpp128::C1724_PHA;
}
else if (modelName() == "V1730") {
cardType = lstdpp128::C1730_PHA;
}
else if (modelName() == "V1725") {
cardType = lstdpp128::C1725_PHA;
}
channels.update(m_dgtzDriver->channels());
nbChannels.update(m_dgtzDriver->nbChannels());
minRange = 0;
maxRange = m_dgtzDriver->nbChannels() - 1;
nbBits.update(m_dgtzDriver->nbBits());
dppAcqMode.update(m_dgtzDriver->dppAcqMode());
}
void CAENCfd2Controller::writeParam() {
m_dgtzDriver.execute(caen_cfd2::CAENCfd2Driver::WRITE_PARAMETERS_COMMAND, true);
}
void CAENCfd2Controller::initBoard() {
m_dgtzDriver.execute(caen_cfd2::CAENCfd2Driver::SET_MODE_COMMAND, true);
}
void CAENCfd2Controller::initChannel(int32 aChannel) {
m_dgtzDriver->signalDecayTime.set(aChannel, (int32)(signalDecayTime() * 1000));
m_dgtzDriver->trapezoidFlatTop.set(aChannel, (int32)(trapezoidFlatTop() * 1000));
m_dgtzDriver->trapezoidRiseTime.set(aChannel, (int32)(trapezoidRiseTime() * 1000));
m_dgtzDriver->flatTopDelay.set(aChannel, (int32)(flatTopDelay() * 1000));
m_dgtzDriver->triggerSmoothing.set(aChannel, triggerSmoothing());
m_dgtzDriver->signalRiseTime.set(aChannel, (int32)(signalRiseTime() * 1000));
m_dgtzDriver->triggerThreshold.set(aChannel, triggerThreshold());
m_dgtzDriver->baselineMean.set(aChannel, baselineMean());
m_dgtzDriver->peakMean.set(aChannel, peakMean());
m_dgtzDriver->peakHoldOff.set(aChannel, (int32)(peakHoldOff() * 1000));
m_dgtzDriver->baselineHoldOff.set(aChannel, (int32)(baselineHoldOff() * 1000));
m_dgtzDriver->triggerHoldOff.set(aChannel, (int32)(triggerHoldOff() * 1000));
m_dgtzDriver->triggerWindowSize.set(aChannel, triggerWindowSize());
m_dgtzDriver->triggerWindowEnable.set(aChannel, triggerWindowEnable());
m_dgtzDriver->digitalGain.set(aChannel, digitalGain());
m_dgtzDriver->trapezoidGain.set(aChannel, trapezoidGain());
m_dgtzDriver->decimation.set(aChannel, decimation());
m_dgtzDriver->channelActive.set(aChannel, channelActive());
// Update channel mask
int32 mask = 0;
for (int32 i=0; i<m_dgtzDriver->nbChannels(); ++i) {
if (m_dgtzDriver->channelActive.get(i))
mask += (m_dgtzDriver->channelActive.get(i) << i);
}
m_dgtzDriver->channelMask = mask;
m_dgtzDriver->dcOffset.set(aChannel, dcOffset());
m_dgtzDriver->preTrigger.set(aChannel, preTrigger());
m_dgtzDriver->pulsePolarity.set(aChannel, pulsePolarity());
m_dgtzDriver->useFirstDerivative.set(aChannel, useFirstDerivative());
boost::thread td(boost::bind(&CAENCfd2Controller::writeParam, this));
}
void CAENCfd2Controller::clearData() {
commandProgression = 0;
m_dgtzDriver.execute(caen_cfd2::CAENCfd2Driver::CLEAR_COMMAND, true);
commandProgression = 100;
}
void CAENCfd2Controller::updateAdcTemperatureProperty(int32 index) {
adcTemperature.set(index, m_dgtzDriver->adcTemperature(index));
}
}
/*
* Nomad Instrument Control Software
*
* Copyright 2011 Institut Laue-Langevin
*
* Licensed under the EUPL, Version 1.1 only (the "License");
* You may not use this work except in compliance with the Licence.
* You may obtain a copy of the Licence at:
*
* http://joinup.ec.europa.eu/software/page/eupl
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the Licence is distributed on an "AS IS" basis,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the Licence for the specific language governing permissions and
* limitations under the Licence.
*/
#ifndef CAENCfd2Controller2_H
#define CAENCfd2Controller2_H
#include "drivers/caen/caen_cfd2/CAENCfd2Driver.h"
#include "CAENAdcController.h"
//#include "drivers/ioxos/cfd/CfdDriver.h"
namespace npp {
/*!
* \class CAENV1725Driver
* \brief Main class for the CAENV1725Driver device driver
*
* \par
* Class for CAENV1725Driver driver. Implements DeviceDriver methods.
* \par
* The CAENV1724Driver device manages the global functionality of the CAEN V1725 VME Digitiser.
*/
class CAENCfd2Controller: public CAENAdcController {
public:
//! Driver type value
static const std::string TYPE;
/*!
* \brief Constructor
* \param[in] name the name of the device driver
*/
CAENCfd2Controller(const std::string& name);
/*!
* \brief Destructor
*/
virtual ~CAENCfd2Controller();
/**
* \brief Postconfiguration
*/
virtual void postConfiguration();
// Channels properties
Property<int32> nbBits;
Property<float64> signalDecayTime;
Property<float64> trapezoidFlatTop;
Property<float64> trapezoidRiseTime;
Property<float64> flatTopDelay;
Property<int32> triggerSmoothing;
Property<float64> signalRiseTime;
Property<int32> triggerThreshold;
Property<int32> baselineMean;
Property<int32> peakMean;
Property<float64> peakHoldOff;
Property<float64> baselineHoldOff;
Property<float64> triggerHoldOff;
Property<int32> triggerWindowSize;
Property<int32> triggerWindowEnable;
Property<int32> digitalGain;
Property<float64> trapezoidGain;
Property<int32> decimation;
Property<int32> cfdActive;