IO.cpp

#include "stdafx.h"
#include "IO.h"
#include "devices/daqmx/DAQmxTask.h"
#include "helpers/ScopeException.h"

namespace scope {

namespace parameters {

// Save some typing here...
using namespace boost::property_tree;


Inputs::Inputs()
    : channels(2, 1, SCOPE_MAXCHANNELS, L"Channels")
    , oversampling(true, false, true, L"Oversampling")
    , rangetype(Uint16RangeHelper::full, L"Uint16Range")
    , preframelines(0, 0, 20, L"PreframeLines") {
}

void Inputs::Load(const wptree& _pt) {
    channels.SetFromPropertyTree(_pt);
    oversampling.SetFromPropertyTree(_pt);
    rangetype.SetFromPropertyTree(_pt);
    preframelines.SetFromPropertyTree(_pt);
}

void Inputs::Save(wptree& _pt) const {
    channels.AddToPropertyTree(_pt);
    oversampling.AddToPropertyTree(_pt);
    rangetype.AddToPropertyTree(_pt);
    preframelines.AddToPropertyTree(_pt);
}

void Inputs::SetReadOnlyWhileScanning(const RunState& _runstate) {
}

std::unique_ptr<Inputs> Inputs::Factory(const InputsType& _type) {
    switch ( _type.t ) {
    case InputsTypeHelper::InputsDAQmx:
        return InputsDAQmx::Create();
    case InputsTypeHelper::InputsFPGA:
        return InputsFPGA::Create();
    case InputsTypeHelper::InputsFPGAIO6587:
        return InputsFPGAIO6587::Create();
    case InputsTypeHelper::InputsFPGADigitalDemultiplexer:
        return InputsFPGADigitalDemultiplexer::Create();
    case InputsTypeHelper::InputsFPGAPhotonCounter:
        return InputsFPGAPhotonCounter::Create();
    case InputsTypeHelper::InputsFPGAIO5771:
        return InputsFPGAIO5771::Create();
    case InputsTypeHelper::InputsFPGAIO5751:
        return InputsFPGAIO5751::Create();
    case InputsTypeHelper::InputsFPGAAnalogDemultiplexer:
        return InputsFPGAAnalogDemultiplexer::Create();
    case InputsTypeHelper::InputsFPGAAnalogIntegrator:
        return InputsFPGAAnalogIntegrator::Create();
    case InputsTypeHelper::InputsFPGAResonanceScanner:
        return InputsFPGAResonanceScanner::Create();
    default:
        return InputsDAQmx::Create();
    }
}

InputsDAQmx::InputsDAQmx()
    : channelsstring(L"PXI-6259_0/ai0:1", L"ChannelsString")
    , range(0.5, 0.1, 10, L"Range_V")
    , daq_timing(DaqTimingHelper::ReferenceClock, L"DAQTimingMethod")
    , referenceclocksource(L"PXI_Clk10", L"ReferenceClockSource")
    , referenceclockrate(10000000, 1000000, 100000000, L"ReferenceClockRate_Hz")
    , externalclocksource(L"/PXI-6259_0/PXI_Trig1", L"ExternalClockSource")
    , maxrateaggregate(1000000, 100000, 20000000, L"MaxRateAggregate_Hz")
    , sampling(DaqSamplingHelper::NonSimultaneousSampling, L"Sampling") {
    uInt32 data = 0;
    std::wostringstream stream;
    DAQmxGetSysNIDAQMajorVersion(&data);
    stream << data;
    DAQmxGetSysNIDAQMinorVersion(&data);
    stream << L"." << data;
    DAQmxGetSysNIDAQUpdateVersion(&data);
    stream << L"." << data;
    diagnosis.daqmxversion = stream.str();
}

double InputsDAQmx::MinimumPixeltime() const {
    if ( sampling() == DaqSamplingHelper::SimultaneousSampling )
        return 1/maxrateaggregate() * 1E6;
    else
        return channels()/maxrateaggregate() * 1E6;
}

double InputsDAQmx::CoercedPixeltime(const double& _pixeltime) const {
    // If oversampling pixeltime can only be integer multiple of minimum pixel time
    // If not oversampling, supported pixel time is dependent on DAQmx::CoerceSampleRates (see there)
    if ( oversampling() )
        return std::floor(_pixeltime/MinimumPixeltime()) * MinimumPixeltime();  // Always floor here, not to coerce to pixeltime bigger than upper limit (causes circular call in Daq::CoercePixeltime)
    else
        return 1/DAQmx::PredictSampleRate(1/_pixeltime, channels(), referenceclockrate(), DAQmx_Val_AI);
}

void InputsDAQmx::Load(const wptree& _pt) {
    Inputs::Load(_pt);
    channelsstring.SetFromPropertyTree(_pt);
    range.SetFromPropertyTree(_pt);
    daq_timing.SetFromPropertyTree(_pt);
    referenceclocksource.SetFromPropertyTree(_pt);
    referenceclockrate.SetFromPropertyTree(_pt);
    externalclocksource.SetFromPropertyTree(_pt);
    maxrateaggregate.SetFromPropertyTree(_pt);
    sampling.SetFromPropertyTree(_pt);
}

void InputsDAQmx::Save(wptree& _pt) const {
    Inputs::Save(_pt);
    channelsstring.AddToPropertyTree(_pt);
    range.AddToPropertyTree(_pt);
    daq_timing.AddToPropertyTree(_pt);
    referenceclocksource.AddToPropertyTree(_pt);
    referenceclockrate.AddToPropertyTree(_pt);
    externalclocksource.AddToPropertyTree(_pt);
    maxrateaggregate.AddToPropertyTree(_pt);
    sampling.AddToPropertyTree(_pt);
}

void InputsDAQmx::SetReadOnlyWhileScanning(const RunState& _runstate) {
}

InputsFPGA::InputsFPGA() {
    // Not oversampling is standard for FPGA, since FPGA generates the pixel clock for the output task
    oversampling = false;
}

double InputsFPGA::MinimumPixeltime() const {
    return 1.0;     // in µs
}

double InputsFPGA::CoercedPixeltime(const double& _pixeltime) const {
    return _pixeltime;
}

void InputsFPGA::Load(const wptree& _pt) {
    Inputs::Load(_pt);
}

void InputsFPGA::Save(wptree& _pt) const {
    Inputs::Save(_pt);
}

void InputsFPGA::SetReadOnlyWhileScanning(const RunState& _runstate) {
    Inputs::SetReadOnlyWhileScanning(_runstate);
}

InputsFPGAIO6587::InputsFPGAIO6587()
    : samplingrate(1E9, 1E8, 1.4E9, L"SamplingRate_Hz") {
}

double InputsFPGAIO6587::MinimumPixeltime() const {
    return 60.0 / samplingrate() * 1E6;     // in µs. Must be multiple of 60 samples, since FPGA acquistion loop works on arrays of 60 samples
}

double InputsFPGAIO6587::CoercedPixeltime(const double& _pixeltime) const {
    // must be multiple of 60 samples
    return std::floor(_pixeltime/MinimumPixeltime()) * MinimumPixeltime();      // Always floor here, not to coerce to pixeltime bigger than upper limit (causes circular call in Daq::CoercePixeltime)
}

void InputsFPGAIO6587::Load(const wptree& _pt) {
    InputsFPGA::Load(_pt);
    samplingrate.SetFromPropertyTree(_pt);
}

void InputsFPGAIO6587::Save(wptree& _pt) const {
    InputsFPGA::Save(_pt);
    samplingrate.AddToPropertyTree(_pt);
}

void InputsFPGAIO6587::SetReadOnlyWhileScanning(const RunState& _runstate) {
    InputsFPGA::SetReadOnlyWhileScanning(_runstate);
}


InputsFPGADigitalDemultiplexer::InputsFPGADigitalDemultiplexer()
    : countmode(true, false, true, L"CountingMode") {
}

void InputsFPGADigitalDemultiplexer::Load(const wptree& _pt) {
    InputsFPGAIO6587::Load(_pt);
    countmode.SetFromPropertyTree(_pt);
}

void InputsFPGADigitalDemultiplexer::Save(wptree& _pt) const {
    InputsFPGAIO6587::Save(_pt);
    countmode.AddToPropertyTree(_pt);
}

void InputsFPGADigitalDemultiplexer::SetReadOnlyWhileScanning(const RunState& _runstate) {
    InputsFPGAIO6587::SetReadOnlyWhileScanning(_runstate);
}

InputsFPGAPhotonCounter::InputsFPGAPhotonCounter()
    : countmode(true, false, true, L"CountingMode") {
}

void InputsFPGAPhotonCounter::Load(const wptree& _pt) {
    InputsFPGAIO6587::Load(_pt);
    countmode.SetFromPropertyTree(_pt);
}

void InputsFPGAPhotonCounter::Save(wptree& _pt) const {
    InputsFPGAIO6587::Save(_pt);
    countmode.AddToPropertyTree(_pt);
}

void InputsFPGAPhotonCounter::SetReadOnlyWhileScanning(const RunState& _runstate) {
    InputsFPGAIO6587::SetReadOnlyWhileScanning(_runstate);
}

InputsFPGAIO5771::InputsFPGAIO5771()
    : BaselineCh1(127, 0, 255, L"BaselineCh1")
    , BaselineCh2(127, 0, 255, L"BaselineCh2") 
    , CutoffCh1(127, 0, 255, L"CutoffCh1")
    , CutoffCh2(127, 0, 255, L"CutoffCh2"){
}

double InputsFPGAIO5771::MinimumPixeltime() const {
    return 8.0E6 / 1.5E9 ;      // in µs. Samples at 1.5GHz. Must be multiple of 8 samples, since FPGA acquires 8 samples in one loop cycle
}

double InputsFPGAIO5771::CoercedPixeltime(const double& _pixeltime) const {
    // must be multiple of 8 samples
    return std::floor(_pixeltime/MinimumPixeltime()) * MinimumPixeltime();      // Always floor here, not to coerce to pixeltime bigger than upper limit (causes circular call in Daq::CoercePixeltime)
}

void InputsFPGAIO5771::Load(const wptree& _pt) {
    InputsFPGA::Load(_pt);
    BaselineCh1.SetFromPropertyTree(_pt);
    BaselineCh2.SetFromPropertyTree(_pt);
    CutoffCh1.SetFromPropertyTree(_pt);
    CutoffCh2.SetFromPropertyTree(_pt);
}

void InputsFPGAIO5771::Save(wptree& _pt) const {
    InputsFPGA::Save(_pt);
    BaselineCh1.AddToPropertyTree(_pt);
    BaselineCh2.AddToPropertyTree(_pt);
    CutoffCh1.AddToPropertyTree(_pt);
    CutoffCh2.AddToPropertyTree(_pt);
}

void InputsFPGAIO5771::SetReadOnlyWhileScanning(const RunState& _runstate) {
    InputsFPGA::SetReadOnlyWhileScanning(_runstate);
}


InputsFPGAIO5751::InputsFPGAIO5751()
    : BaselineCh1(0, 0, 65535, L"BaselineCh1")
    , BaselineCh2(0, 0, 65535, L"BaselineCh2")
    , AcquisitionClockRate(40E6, 10E6, 50E6, L"AcquisitionClockRate_Hz") {
}

double InputsFPGAIO5751::MinimumPixeltime() const {
    return 1/AcquisitionClockRate()*1E6;        // in microseconds.
}

double InputsFPGAIO5751::MaximumPixeltime() const {
    return 10;
}

double InputsFPGAIO5751::CoercedPixeltime(const double& _pixeltime) const {
    // 2, because the fastest possible acqusition would lead to performance problems in Scope
    return std::max(2*MinimumPixeltime(), std::floor(_pixeltime*AcquisitionClockRate()/1E6) * 1E6/AcquisitionClockRate());      // Always floor here, not to coerce to pixeltime bigger than upper limit (causes circular call in Daq::CoercePixeltime)
}

void InputsFPGAIO5751::Load(const wptree& _pt) {
    InputsFPGA::Load(_pt);
    BaselineCh1.SetFromPropertyTree(_pt);
    BaselineCh2.SetFromPropertyTree(_pt);
    AcquisitionClockRate.SetFromPropertyTree(_pt);
}

void InputsFPGAIO5751::Save(wptree& _pt) const {
    InputsFPGA::Save(_pt);
    BaselineCh1.AddToPropertyTree(_pt);
    BaselineCh2.AddToPropertyTree(_pt);
    AcquisitionClockRate.AddToPropertyTree(_pt);
}

void InputsFPGAIO5751::SetReadOnlyWhileScanning(const RunState& _runstate) {
    InputsFPGA::SetReadOnlyWhileScanning(_runstate);
}


InputsFPGAAnalogDemultiplexer::InputsFPGAAnalogDemultiplexer()
    : BitshiftA1Ch1(3, 0, 16, L"BitshiftA1Ch1")
    , BitshiftA1Ch2(3, 0, 16, L"BitshiftA1Ch2")
    , BitshiftA2Ch1(3, 0, 16, L"BitshiftA2Ch1")
    , BitshiftA2Ch2(3, 0, 16, L"BitshiftA2Ch2") {
}

void InputsFPGAAnalogDemultiplexer::Load(const wptree& pt) {
    InputsFPGAIO5771::Load(pt);
    BitshiftA1Ch1.SetFromPropertyTree(pt);
    BitshiftA1Ch2.SetFromPropertyTree(pt);
    BitshiftA2Ch1.SetFromPropertyTree(pt);
    BitshiftA2Ch2.SetFromPropertyTree(pt);
}

void InputsFPGAAnalogDemultiplexer::Save(wptree& pt) const {
    InputsFPGAIO5771::Save(pt);
    BitshiftA1Ch1.AddToPropertyTree(pt);
    BitshiftA1Ch2.AddToPropertyTree(pt);
    BitshiftA2Ch1.AddToPropertyTree(pt);
    BitshiftA2Ch2.AddToPropertyTree(pt);
}

void InputsFPGAAnalogDemultiplexer::SetReadOnlyWhileScanning(const RunState& _runstate) {
    InputsFPGAIO5771::SetReadOnlyWhileScanning(_runstate);
}


InputsFPGAAnalogIntegrator::InputsFPGAAnalogIntegrator()
    : BitshiftCh1(3, 0, 16, L"BitshiftCh1")
    , BitshiftCh2(3, 1, 16, L"BitshiftCh2") {
}

void InputsFPGAAnalogIntegrator::Load(const wptree& pt) {
    InputsFPGAIO5771::Load(pt);
    BitshiftCh1.SetFromPropertyTree(pt);
    BitshiftCh2.SetFromPropertyTree(pt);
}

void InputsFPGAAnalogIntegrator::Save(wptree& pt) const {
    InputsFPGAIO5771::Save(pt);
    BitshiftCh1.AddToPropertyTree(pt);
    BitshiftCh2.AddToPropertyTree(pt);
}

void InputsFPGAAnalogIntegrator::SetReadOnlyWhileScanning(const RunState& _runstate) {
    InputsFPGAIO5771::SetReadOnlyWhileScanning(_runstate);
}


InputsFPGAResonanceScanner::InputsFPGAResonanceScanner()
    : BitshiftCh1(0, 0, 16, L"BitshiftCh1")
    , BitshiftCh2(0, 0, 16, L"BitshiftCh2") {
}

void InputsFPGAResonanceScanner::Load(const wptree& pt) {
    InputsFPGAIO5751::Load(pt);
    BitshiftCh1.SetFromPropertyTree(pt);
    BitshiftCh2.SetFromPropertyTree(pt);
}

void InputsFPGAResonanceScanner::Save(wptree& pt) const {
    InputsFPGAIO5751::Save(pt);
    BitshiftCh1.AddToPropertyTree(pt);
    BitshiftCh2.AddToPropertyTree(pt);
}

void InputsFPGAResonanceScanner::SetReadOnlyWhileScanning(const RunState& _runstate) {
    InputsFPGAIO5751::SetReadOnlyWhileScanning(_runstate);
}


Outputs::Outputs(void)
    : range(5, 0, 10, L"OutputRange_V")
    , minoutputscanner(-1, -10, 10, L"MinOutputScanner_V")
    , maxoutputscanner(1, -10, 10, L"MaxOutputScanner_V")
    , minoutputpockels(0.0, 0.0, 2.0, L"MinOutputPockels_V")
    , maxoutputpockels(2.0, 0.0, 2.0, L"MaxOutputPockels_V"){

}

void Outputs::Load(const wptree& _pt) {
    range.SetFromPropertyTree(_pt);
    minoutputscanner.SetFromPropertyTree(_pt);
    maxoutputscanner.SetFromPropertyTree(_pt);
    minoutputpockels.SetFromPropertyTree(_pt);
    maxoutputpockels.SetFromPropertyTree(_pt);
}

void Outputs::Save(wptree& _pt) const {
    range.AddToPropertyTree(_pt);
    minoutputscanner.AddToPropertyTree(_pt);
    maxoutputscanner.AddToPropertyTree(_pt);
    minoutputpockels.AddToPropertyTree(_pt);
    maxoutputpockels.AddToPropertyTree(_pt);
}

void Outputs::SetReadOnlyWhileScanning(const RunState& _runstate) {
    // too lazy to do it...
}

std::unique_ptr<Outputs> Outputs::Factory(const OutputsType& _type) {
    switch ( _type.t ) {
    case OutputsTypeHelper::OutputsDAQmx:
        return OutputsDAQmx::Create();
    case OutputsTypeHelper::OutputsDAQmxLineClock:
        return OutputsDAQmxLineClock::Create();
    case OutputsTypeHelper::OutputsDAQmxSlave:
        return OutputsDAQmxSlave::Create();
    case OutputsTypeHelper::OutputsDAQmxResonance:
        return OutputsDAQmxResonance::Create();
    default:
        return OutputsDAQmx::Create();
    }
}

OutputsDAQmx::OutputsDAQmx()
    : channelsstring(L"PXI-6259_0/ao0:3", L"ChannelsString")
    , daq_timing(DaqTimingHelper::ReferenceClock, L"DAQTimingMethod")
    , minimumpixeltime(0.8, 0.01, 10.0, L"MinimumPixelTime_us")
    , referenceclocksource(L"PXI_Clk10", L"ReferenceClockSource")
    , referenceclockrate(10000000, 1000000, 100000000, L"ReferenceClockRate_Hz")
    , externalclocksource(L"/PXI-6259_0/PXI_Trig1", L"ExternalClockSource")
    , exportpixelclockterminal(L"/PXI-6259_0/PFI12", L"ExportPixelClockTerminal") {
}

double OutputsDAQmx::CoercedPixeltime(const double& _pixeltime) const {
    return std::max(MinimumPixeltime(), 1/DAQmx::PredictSampleRate(1/_pixeltime, 4, referenceclockrate(), DAQmx_Val_AO));
}

double OutputsDAQmx::MinimumPixeltime() const {
    return minimumpixeltime();
}

void OutputsDAQmx::Load(const wptree& _pt) {
    Outputs::Load(_pt);
    channelsstring.SetFromPropertyTree(_pt);
    daq_timing.SetFromPropertyTree(_pt);
    minimumpixeltime.SetFromPropertyTree(_pt);
    referenceclocksource.SetFromPropertyTree(_pt);
    referenceclockrate.SetFromPropertyTree(_pt);
    externalclocksource.SetFromPropertyTree(_pt);
    exportpixelclockterminal.SetFromPropertyTree(_pt);
}

void OutputsDAQmx::Save(wptree& _pt) const {
    Outputs::Save(_pt);
    channelsstring.AddToPropertyTree(_pt);
    daq_timing.AddToPropertyTree(_pt);
    minimumpixeltime.AddToPropertyTree(_pt);;
    referenceclocksource.AddToPropertyTree(_pt);
    referenceclockrate.AddToPropertyTree(_pt);
    externalclocksource.AddToPropertyTree(_pt);
    exportpixelclockterminal.AddToPropertyTree(_pt);
}

void OutputsDAQmx::SetReadOnlyWhileScanning(const RunState& _runstate) {
    Outputs::SetReadOnlyWhileScanning(_runstate);
}

OutputsDAQmxLineClock::OutputsDAQmxLineClock()
    : xpout(L"PXI-6259_0/ao0:1", L"XPOutString")
    , yzout(L"PXI-6259_1/ao0:1", L"YZOutString")
    , pixel_timing(DaqTimingHelper::ReferenceClock, L"PixelTimingMethod")
    , line_timing(DaqTimingHelper::ReferenceClock, L"LineTimingMethod")
    , minimumpixeltime(0.8, 0.01, 10.0, L"MinimumPixelTime_us")
    , pixel_referenceclocksource(L"PXI_Clk10", L"PixelReferenceClockSource")
    , line_referenceclocksource(L"PXI_Clk10", L"LineReferenceClockSource")
    , pixel_referenceclockrate(10000000, 1000000, 100000000, L"ReferenceClockRate_Hz")
    , line_referenceclockrate(10000000, 1000000, 100000000, L"ReferenceClockRate_Hz")
    , pixel_externalclocksource(L"/PXI-6259_0/PXI_Trig1", L"ExternalPixelClockString")
    , line_externalclocksource(L"/PXI-6259_1/PXI_Trig2", L"ExternalLineClockString") {
}

double OutputsDAQmxLineClock::CoercedPixeltime(const double& _pixeltime) const {
    return std::max(MinimumPixeltime(), 1/DAQmx::PredictSampleRate(1/_pixeltime, 2, pixel_referenceclockrate(), DAQmx_Val_AO));
}

double OutputsDAQmxLineClock::MinimumPixeltime() const {
    return minimumpixeltime();
}

void OutputsDAQmxLineClock::Load(const wptree& _pt) {
    Outputs::Load(_pt);
    xpout.SetFromPropertyTree(_pt);
    yzout.SetFromPropertyTree(_pt);
    pixel_timing.SetFromPropertyTree(_pt);
    line_timing.SetFromPropertyTree(_pt);
    minimumpixeltime.SetFromPropertyTree(_pt);
    pixel_referenceclocksource.SetFromPropertyTree(_pt);
    line_referenceclocksource.SetFromPropertyTree(_pt);
    pixel_referenceclockrate.SetFromPropertyTree(_pt);
    line_referenceclockrate.SetFromPropertyTree(_pt);
    pixel_externalclocksource.SetFromPropertyTree(_pt);
    line_externalclocksource.SetFromPropertyTree(_pt);
}

void OutputsDAQmxLineClock::Save(wptree& _pt) const {
    Outputs::Save(_pt);
    xpout.AddToPropertyTree(_pt);
    yzout.AddToPropertyTree(_pt);
    pixel_timing.AddToPropertyTree(_pt);
    line_timing.AddToPropertyTree(_pt);
    minimumpixeltime.AddToPropertyTree(_pt);
    pixel_referenceclocksource.AddToPropertyTree(_pt);
    line_referenceclocksource.AddToPropertyTree(_pt);
    pixel_referenceclockrate.AddToPropertyTree(_pt);
    line_referenceclockrate.AddToPropertyTree(_pt);
    pixel_externalclocksource.AddToPropertyTree(_pt);
    line_externalclocksource.AddToPropertyTree(_pt);;
}

OutputsDAQmxSlave::OutputsDAQmxSlave()
    : zpout(L"PXI-6259_1/ao0:1", L"ZPOutString")
    , timing(DaqTimingHelper::ReferenceClock, L"DAQTimingMethod")
    , minimumpixeltime(0.8, 0.01, 10.0, L"MinimumPixelTime_us")
    , referenceclocksource(L"PXI_Clk10", L"ReferenceClockSource")
    , referenceclockrate(10000000, 1000000, 100000000, L"ReferenceClockRate_Hz")
    , externalclocksource(L"/PXI-6259_0/PXI_Trig1", L"ExternalClockSource") {

}

void OutputsDAQmxLineClock::SetReadOnlyWhileScanning(const RunState& _runstate) {
    Outputs::SetReadOnlyWhileScanning(_runstate);
}

double OutputsDAQmxSlave::CoercedPixeltime(const double& _pixeltime) const {
    return std::max(MinimumPixeltime(), 1/DAQmx::PredictSampleRate(1/_pixeltime, 2, referenceclockrate(), DAQmx_Val_AO));
}

double OutputsDAQmxSlave::MinimumPixeltime() const {
    return minimumpixeltime();
}

void OutputsDAQmxSlave::Load(const wptree& _pt) {
    Outputs::Load(_pt);
    zpout.SetFromPropertyTree(_pt);
    timing.SetFromPropertyTree(_pt);
    minimumpixeltime.SetFromPropertyTree(_pt);
    referenceclocksource.SetFromPropertyTree(_pt);
    referenceclockrate.SetFromPropertyTree(_pt);
    externalclocksource.SetFromPropertyTree(_pt);
}

void OutputsDAQmxSlave::Save(wptree& _pt) const {
    Outputs::Save(_pt);
    zpout.AddToPropertyTree(_pt);
    timing.AddToPropertyTree(_pt);
    minimumpixeltime.AddToPropertyTree(_pt);
    referenceclocksource.AddToPropertyTree(_pt);
    referenceclockrate.AddToPropertyTree(_pt);
    externalclocksource.AddToPropertyTree(_pt);
}

void OutputsDAQmxSlave::SetReadOnlyWhileScanning(const RunState& _runstate) {
    Outputs::SetReadOnlyWhileScanning(_runstate);
}


OutputsDAQmxResonance::OutputsDAQmxResonance()
    : channelsstring(L"PXI-6259_0/ao0:1", L"ChannelsString")
    , zoomchannelstring(L"PXI-6259_0/port0/line1:2", L"ZoomChannelsString")
    , daq_timing(DaqTimingHelper::ReferenceClock, DaqTimingHelper::OnboardClock, DaqTimingHelper::External, L"DAQTimingMethod")
    , minimumpixeltime(0.02, 0.02, 10.0, L"MinimumPixelTime_us")
    , referenceclocksource(L"PXI_Clk10", L"ReferenceClockSource")
    , referenceclockrate(10000000, 1000000, 100000000, L"ReferenceClockRate_Hz")
    , externalclocksource(L"/PXI-6259_0/PFI1", L"ExternalClockSource")
    , exportpixelclockterminal(L"/PXI-6259_0/PFI12", L"ExportPixelClockTerminal") {
}

double OutputsDAQmxResonance::CoercedPixeltime(const double& _pixeltime) const {
    return std::max(MinimumPixeltime(), 1/DAQmx::PredictSampleRate(1/_pixeltime, 4, referenceclockrate(), DAQmx_Val_AO));
}

double OutputsDAQmxResonance::MinimumPixeltime() const {
    return minimumpixeltime();
}

void OutputsDAQmxResonance::Load(const wptree& _pt) {
    Outputs::Load(_pt);
    channelsstring.SetFromPropertyTree(_pt);
    zoomchannelstring.SetFromPropertyTree(_pt);
    daq_timing.SetFromPropertyTree(_pt);
    minimumpixeltime.SetFromPropertyTree(_pt);
    referenceclocksource.SetFromPropertyTree(_pt);
    referenceclockrate.SetFromPropertyTree(_pt);
    externalclocksource.SetFromPropertyTree(_pt);
    exportpixelclockterminal.SetFromPropertyTree(_pt);
}

void OutputsDAQmxResonance::Save(wptree& _pt) const {
    Outputs::Save(_pt);
    channelsstring.AddToPropertyTree(_pt);
    zoomchannelstring.AddToPropertyTree(_pt);
    daq_timing.AddToPropertyTree(_pt);
    minimumpixeltime.AddToPropertyTree(_pt);;
    referenceclocksource.AddToPropertyTree(_pt);
    referenceclockrate.AddToPropertyTree(_pt);
    externalclocksource.AddToPropertyTree(_pt);
    exportpixelclockterminal.AddToPropertyTree(_pt);
}

void OutputsDAQmxResonance::SetReadOnlyWhileScanning(const RunState& _runstate) {
    Outputs::SetReadOnlyWhileScanning(_runstate);
}


Daq::Daq(const bool& _isslave)
    : isslave(_isslave)
    , inputs(Inputs::Factory(InputsTypeHelper::SCOPE_INPUTS_PARAMETERS_T))
    , outputs((_isslave)?Outputs::Factory(OutputsTypeHelper::SCOPE_SLAVEOUTPUTS_T):Outputs::Factory(OutputsTypeHelper::SCOPE_OUTPUTS_T))
    , shutterline(L"PXI-6259_0/port0/line0", L"ShutterLine")
    , switchresonanceline(L"PXI-6259_0/port0/line3", L"SwitchResonanceLine")
    , pixeltime(10, 0.02, 15, L"Pixeltime_us")
    , scannerdelay(0, -500, 500, L"Scannerdelay_us")
    , averages(1, 1, 32, L"Averages")
    , requested_frames(1, 1, 10000, L"RequestedFrames")
    , resonance_frequency(7910, 3000, 10000, L"ResonanceFrequency_Hz") {

    // Pixeltime lower limit is maximum of minimum pixel times of inputs and outputs (important for FPGA/DAQmx combinations)
    pixeltime.SetLimits(std::max(inputs->MinimumPixeltime(), outputs->MinimumPixeltime()), pixeltime.ul());
    pixeltime.ConnectOther(std::bind(&Daq::CoercePixeltime, this));
}

Daq::Daq(const Daq& _daq)
    : isslave(_daq.isslave)
    , inputs(_daq.inputs->Clone())
    , outputs(_daq.outputs->Clone())
    , shutterline(_daq.shutterline)
    , switchresonanceline(_daq.switchresonanceline)
    , pixeltime(_daq.pixeltime)
    , scannerdelay(_daq.scannerdelay)
    , averages(_daq.averages)
    , requested_frames(_daq.requested_frames)
    , resonance_frequency(_daq.resonance_frequency) {

    // Pixeltime lower limit is maximum of minimum pixel times of inputs and outputs (important for FPGA/DAQmx combinations)
    pixeltime.SetLimits(std::max(inputs->MinimumPixeltime(), outputs->MinimumPixeltime()), pixeltime.ul());
    pixeltime.ConnectOther(std::bind(&Daq::CoercePixeltime, this));
}

Daq& Daq::operator=(const Daq& _daq) {
    if (isslave != _daq.isslave )
        throw ScopeException(__FUNCTION__);

    inputs = _daq.inputs->Clone();
    outputs = _daq.outputs->Clone();

    shutterline = _daq.shutterline;
    switchresonanceline = _daq.switchresonanceline;
    pixeltime = _daq.pixeltime;
    scannerdelay = _daq.scannerdelay;
    averages = _daq.averages;
    requested_frames = _daq.requested_frames;
    resonance_frequency = _daq.resonance_frequency;

    // Pixeltime lower limit is maximum of minimum pixel times of inputs and outputs (important for FPGA/DAQmx combinations)
    pixeltime.SetLimits(std::max(inputs->MinimumPixeltime(), outputs->MinimumPixeltime()), pixeltime.ul());
    pixeltime.ConnectOther(std::bind(&Daq::CoercePixeltime, this));

    return *this;
}

int32_t Daq::ScannerDelaySamples(const bool& _respectoversampling) const {
    if ( inputs->oversampling() && _respectoversampling )
        return round2i32(scannerdelay() / inputs->MinimumPixeltime());
    else
        return round2i32(scannerdelay() / pixeltime());
}

void Daq::Load(const wptree& _pt) {
    inputs->Load(_pt.get_child(L"inputs"));
    outputs->Load(_pt.get_child(L"outputs"));
    shutterline.SetFromPropertyTree(_pt);
    switchresonanceline.SetFromPropertyTree(_pt);
    pixeltime.SetFromPropertyTree(_pt);
    scannerdelay.SetFromPropertyTree(_pt);
    averages.SetFromPropertyTree(_pt);
    requested_frames.SetFromPropertyTree(_pt);
    resonance_frequency.SetFromPropertyTree(_pt);
    // easier than to connect from samplingtype, maxrateaggregate, and channels
    pixeltime.SetLimits(std::max(inputs->MinimumPixeltime(), outputs->MinimumPixeltime()), pixeltime.ul());
}

void Daq::Save(wptree& _pt) const {
    wptree ptinputs;
    wptree ptoutputs;
    inputs->Save(ptinputs);
    _pt.add_child(L"inputs", ptinputs);
    outputs->Save(ptoutputs);
    _pt.add_child(L"outputs", ptoutputs);
    shutterline.AddToPropertyTree(_pt);
    switchresonanceline.AddToPropertyTree(_pt);
    pixeltime.AddToPropertyTree(_pt);
    scannerdelay.AddToPropertyTree(_pt);
    averages.AddToPropertyTree(_pt);
    requested_frames.AddToPropertyTree(_pt);
    resonance_frequency.AddToPropertyTree(_pt);
}

void Daq::SetReadOnlyWhileScanning(const RunState& _runstate) {
    inputs->SetReadOnlyWhileScanning(_runstate);
    outputs->SetReadOnlyWhileScanning(_runstate);
    switch ( static_cast<RunStateHelper::Mode>(_runstate) ) {
        case RunStateHelper::Mode::Stopped:
            pixeltime.SetRWState(true);
            averages.SetRWState(true);
            scannerdelay.SetRWState(true);
            break;
        // RESONANCE CODE
        case RunStateHelper::Mode::RunningSingle:
            //if( SCOPE_USE_RESONANCESCANNER )
            //  scannerdelay.SetRWState(false);
        case RunStateHelper::Mode::RunningStack:
            //if( SCOPE_USE_RESONANCESCANNER )
            //  scannerdelay.SetRWState(false);
        case RunStateHelper::Mode::RunningTimeseries:
            scannerdelay.SetRWState(false);
        case RunStateHelper::Mode::RunningContinuous:
            //if( SCOPE_USE_RESONANCESCANNER )
            //  scannerdelay.SetRWState(false);
        default:
            pixeltime.SetRWState(false);
            averages.SetRWState(false);
    }
}

void Daq::CoercePixeltime() {
    // If oversampling, input samples at maximum rate and pixel time can only be integer multiple of that sampling time
    // Otherwise, rate is given by DAQmx or by FPGA
    const double inputtime = inputs->CoercedPixeltime(pixeltime());
    const double outputtime = outputs->CoercedPixeltime(pixeltime());
    DBOUT(L"Daq::CoercePixeltime " << pixeltime() << L" " << inputtime << L" " << outputtime);
    // Only set if not good time already (otherwise we get circular calls...)
    DBOUT(L"Daq::CoercePixeltime inputtime " << inputtime);
    DBOUT(L"Daq::CoercePixeltime outputtime " << outputtime);
    // Do it like this to avoid trouble because of limited precision/rounding errors etc
    if ( !(std::fabs(pixeltime()-inputtime) < std::numeric_limits<double>::epsilon())  )
        pixeltime.Set(inputtime);
}


}

}