IO.h

#pragma once

#include "ScopeDefines.h"
#include "ScopeDatatypes.h"
#include "helpers/ScopeNumber.h"
#include "helpers/ScopeString.h"
#include "helpers/helpers.h"
#include "Base.h"

namespace scope {

namespace parameters {

using boost::property_tree::wptree;

class Inputs
    : public Base {

public:
    Inputs();

    virtual std::unique_ptr<Inputs> Clone() const = 0;

    static std::unique_ptr<Inputs> Factory(const InputsType& _type);

    ScopeNumber<uint32_t> channels;

    ScopeNumber<bool> oversampling;

    ScopeValue<Uint16Range> rangetype;

    ScopeNumber<uint32_t> preframelines;

    virtual double MinimumPixeltime() const { return 1.0; }

    virtual double MaximumPixeltime() const { return 15.0; }

    virtual double CoercedPixeltime(const double& _pixeltime) const { return _pixeltime; }

    void Load(const wptree& pt) override;
    void Save(wptree& pt) const override;
    void SetReadOnlyWhileScanning(const RunState& _runstate) override;

};

class InputsDAQmx
    : public Inputs {

public:
    InputsDAQmx();

    static std::unique_ptr<Inputs> Create() { return std::unique_ptr<Inputs>(new InputsDAQmx()); }

    std::unique_ptr<Inputs> Clone() const override { return std::unique_ptr<Inputs>(new InputsDAQmx(*this)); }

    ScopeString channelsstring;
    
    ScopeNumber<double> range;

    ScopeValue<DaqTiming> daq_timing;
    
    ScopeString referenceclocksource;
    
    ScopeNumber<double> referenceclockrate;
    
    ScopeString externalclocksource;
    
    ScopeNumber<double> maxrateaggregate;
    
    ScopeValue<DaqSampling> sampling;

    struct Diagnosis {
        ScopeString daqmxversion;

        Diagnosis()
            : daqmxversion(L"", L"DAQmxVersion") {
        }
    };
    
    Diagnosis diagnosis;

    double MinimumPixeltime() const override;

    double CoercedPixeltime(const double& _pixeltime) const override;

    void Load(const wptree& pt) override;
    void Save(wptree& pt) const override;
    void SetReadOnlyWhileScanning(const RunState& _runstate) override;
};

class InputsFPGA
    : public Inputs {
public:
    InputsFPGA();

    static std::unique_ptr<Inputs> Create() { return std::unique_ptr<Inputs>(new InputsFPGA()); }

    std::unique_ptr<Inputs> Clone() const override { return std::unique_ptr<Inputs>(new InputsFPGA(*this)); }

    double MinimumPixeltime() const override;

    double CoercedPixeltime(const double& _pixeltime) const override;

    void Load(const wptree& pt) override;
    void Save(wptree& pt) const override;
    void SetReadOnlyWhileScanning(const RunState& _runstate) override;
};

class InputsFPGANoiseOutput
    : public InputsFPGA {
public:
    InputsFPGANoiseOutput() { }

    static std::unique_ptr<Inputs> Create() { return std::unique_ptr<Inputs>(new InputsFPGANoiseOutput()); }

    std::unique_ptr<Inputs> Clone() const override { return std::unique_ptr<Inputs>(new InputsFPGANoiseOutput(*this)); }

    struct Diagnosis {
        ScopeNumber<bool> ToHostOverflowA1Ch1;
        ScopeNumber<bool> ToHostOverflowA1Ch2;
        ScopeNumber<bool> ToHostOverflowA2Ch1;
        ScopeNumber<bool> ToHostOverflowA2Ch2;
        ScopeNumber<bool> Acquiring;

        Diagnosis()
            : ToHostOverflowA1Ch1(false, false, true, L"ToHostOverflowA1Ch1")
            , ToHostOverflowA1Ch2(false, false, true, L"ToHostOverflowA1Ch2")
            , ToHostOverflowA2Ch1(false, false, true, L"ToHostOverflowA1Ch1")
            , ToHostOverflowA2Ch2(false, false, true, L"ToHostOverflowA1Ch2")
            , Acquiring(false, false, true, L"Acquiring") {
        }
    };
    
    Diagnosis diagnosis;
};

class InputsFPGAIO6587
    : public InputsFPGA {
public:
    InputsFPGAIO6587();

    static std::unique_ptr<Inputs> Create() { return std::unique_ptr<Inputs>(new InputsFPGAIO6587()); }

    std::unique_ptr<Inputs> Clone() const override { return std::unique_ptr<Inputs>(new InputsFPGAIO6587(*this)); }

    ScopeNumber<double> samplingrate;

    double MinimumPixeltime() const override;

    double CoercedPixeltime(const double& _pixeltime) const override;

    void Load(const wptree& pt) override;
    void Save(wptree& pt) const override;
    void SetReadOnlyWhileScanning(const RunState& _runstate) override;
};

class InputsFPGADigitalDemultiplexer
    : public InputsFPGAIO6587 {
public:
    InputsFPGADigitalDemultiplexer();

    static std::unique_ptr<Inputs> Create() { return std::unique_ptr<Inputs>(new InputsFPGADigitalDemultiplexer()); }

    std::unique_ptr<Inputs> Clone() const override { return std::unique_ptr<Inputs>(new InputsFPGADigitalDemultiplexer(*this)); }

    ScopeNumber<bool> countmode;

    struct Diagnosis {
        ScopeNumber<bool> ToHostOverflowA1Ch1;
        ScopeNumber<bool> ToHostOverflowA1Ch2;
        ScopeNumber<bool> ToHostOverflowA2Ch1;
        ScopeNumber<bool> ToHostOverflowA2Ch2;
        ScopeNumber<bool> InterloopOverflow;
        ScopeNumber<bool> InterloopTimeout;
        ScopeNumber<bool> Acquiring;
        ScopeNumber<double> MeasuredLaserFreq;

        Diagnosis()
            : ToHostOverflowA1Ch1(false, false, true, L"ToHostOverflowA1Ch1")
            , ToHostOverflowA1Ch2(false, false, true, L"ToHostOverflowA1Ch2")
            , ToHostOverflowA2Ch1(false, false, true, L"ToHostOverflowA2Ch1")
            , ToHostOverflowA2Ch2(false, false, true, L"ToHostOverflowA2Ch2")
            , InterloopOverflow(false, false, true, L"InterloopOverflow")
            , InterloopTimeout(false, false, true, L"InterloopTimeout")
            , Acquiring(false, false, true, L"Acquiring")
            , MeasuredLaserFreq(0.0, 0.0, 1E10, L"MeasuredLaserFrequency_Hz") {
        }
    };
    
    Diagnosis diagnosis;

    void Load(const wptree& pt) override;
    void Save(wptree& pt) const override;
    void SetReadOnlyWhileScanning(const RunState& _runstate) override;
};

class InputsFPGAPhotonCounter
    : public InputsFPGAIO6587 {
public:
    InputsFPGAPhotonCounter();

    static std::unique_ptr<Inputs> Create() { return std::unique_ptr<Inputs>(new InputsFPGAPhotonCounter()); }

    std::unique_ptr<Inputs> Clone() const override { return std::unique_ptr<Inputs>(new InputsFPGAPhotonCounter(*this)); }

    ScopeNumber<bool> countmode;

    struct Diagnosis {
        ScopeNumber<bool> ToHostOverflowCh1;
        ScopeNumber<bool> ToHostOverflowCh2;
        ScopeNumber<bool> InterloopOverflow;
        ScopeNumber<bool> InterloopTimeout;
        ScopeNumber<bool> Acquiring;

        ScopeNumber<bool> CountingMode;

        Diagnosis()
            : ToHostOverflowCh1(false, false, true, L"ToHostOverflowCh1")
            , ToHostOverflowCh2(false, false, true, L"ToHostOverflowCh2")
            , InterloopOverflow(true, false, true, L"InterloopOverflow")
            , InterloopTimeout(false, false, true, L"InterloopTimeout")
            , Acquiring(false, false, true, L"Acquiring")
            , CountingMode(true, false, true, L"CountingMode") {
        }
    };
    
    Diagnosis diagnosis;

    void Load(const wptree& pt) override;
    void Save(wptree& pt) const override;
    void SetReadOnlyWhileScanning(const RunState& _runstate) override;
};

class InputsFPGAIO5771
    : public InputsFPGA {
public:
    InputsFPGAIO5771();

    static std::unique_ptr<Inputs> Create() { return std::unique_ptr<Inputs>(new InputsFPGAIO5771()); }

    std::unique_ptr<Inputs> Clone() const override { return std::unique_ptr<Inputs>(new InputsFPGAIO5771(*this)); }

    ScopeNumber<uint8_t> BaselineCh1;

    ScopeNumber<uint8_t> BaselineCh2;

    ScopeNumber<uint8_t> CutoffCh1;

    ScopeNumber<uint8_t> CutoffCh2;

    double MinimumPixeltime() const override;

    double CoercedPixeltime(const double& _pixeltime) const override;

    void Load(const wptree& pt) override;
    void Save(wptree& pt) const override;
    void SetReadOnlyWhileScanning(const RunState& _runstate) override;
};

class InputsFPGAIO5751
    : public InputsFPGA {
public:
    InputsFPGAIO5751();

    static std::unique_ptr<Inputs> Create() { return std::unique_ptr<Inputs>(new InputsFPGAIO5751()); }

    std::unique_ptr<Inputs> Clone() const override { return std::unique_ptr<Inputs>(new InputsFPGAIO5751(*this)); }

    ScopeNumber<uint32_t> BaselineCh1;

    ScopeNumber<uint32_t> BaselineCh2;

    ScopeNumber<double> AcquisitionClockRate;

    double MinimumPixeltime() const override;
    double MaximumPixeltime() const override;

    double CoercedPixeltime(const double& _pixeltime) const override;

    void Load(const wptree& pt) override;
    void Save(wptree& pt) const override;
    void SetReadOnlyWhileScanning(const RunState& _runstate) override;
};

class InputsFPGAAnalogDemultiplexer
    : public InputsFPGAIO5771 {
public:
    InputsFPGAAnalogDemultiplexer();

    static std::unique_ptr<Inputs> Create() { return std::unique_ptr<Inputs>(new InputsFPGAAnalogDemultiplexer()); }

    std::unique_ptr<Inputs> Clone() const override { return std::unique_ptr<Inputs>(new InputsFPGAAnalogDemultiplexer(*this)); }

    ScopeNumber<uint8_t> BitshiftA1Ch1;

    ScopeNumber<uint8_t> BitshiftA1Ch2;

    ScopeNumber<uint8_t> BitshiftA2Ch1;

    ScopeNumber<uint8_t> BitshiftA2Ch2;

    struct Diagnosis {
        ScopeNumber<bool> ToHostOverflowA1;
        ScopeNumber<bool> ToHostOverflowA2;
        ScopeNumber<bool> InterloopOverflow;
        ScopeNumber<bool> InterloopTimeout;
        ScopeNumber<bool> Acquiring;

        ScopeNumber<bool> AIOverRange;

        Diagnosis()
            : ToHostOverflowA1(false, false, true, L"ToHostOverflowA1")
            , ToHostOverflowA2(false, false, true, L"ToHostOverflowA2")
            , InterloopOverflow(false, false, true, L"InterloopOverflow")
            , InterloopTimeout(false, false, true, L"InterloopTimeout")
            , Acquiring(false, false, true, L"Acquiring")
            , AIOverRange(false, false, true, L"AIOverRange") {
        }
    };
    
    Diagnosis diagnosis;

    void Load(const wptree& pt) override;
    void Save(wptree& pt) const override;
    void SetReadOnlyWhileScanning(const RunState& _runstate) override;
};

class InputsFPGAAnalogIntegrator
    : public InputsFPGAIO5771 {
public:
    InputsFPGAAnalogIntegrator();

    static std::unique_ptr<Inputs> Create() { return std::unique_ptr<Inputs>(new InputsFPGAAnalogIntegrator()); }

    std::unique_ptr<Inputs> Clone() const override { return std::unique_ptr<Inputs>(new InputsFPGAAnalogIntegrator(*this)); }

    ScopeNumber<uint8_t> BitshiftCh1;

    ScopeNumber<uint8_t> BitshiftCh2;

    struct Diagnosis {
        ScopeNumber<bool> ToHostOverflowCh1;
        ScopeNumber<bool> ToHostOverflowCh2;
        ScopeNumber<bool> InterloopOverflow;
        ScopeNumber<bool> InterloopTimeout;
        ScopeNumber<bool> Acquiring;

        ScopeNumber<bool> AIOverRange;

        Diagnosis()
            : ToHostOverflowCh1(false, false, true, L"ToHostOverflowCh1")
            , ToHostOverflowCh2(false, false, true, L"ToHostOverflowCh2")
            , InterloopOverflow(false, false, true, L"InterloopOverflow")
            , InterloopTimeout(false, false, true, L"InterloopTimeout")
            , Acquiring(false, false, true, L"Acquiring")
            , AIOverRange(false, false, true, L"AIOverRange") {
        }
    };
    
    Diagnosis diagnosis;

    void Load(const wptree& pt) override;
    void Save(wptree& pt) const override;
    void SetReadOnlyWhileScanning(const RunState& _runstate) override;
};

class InputsFPGAResonanceScanner
    : public InputsFPGAIO5751 {
public:
    InputsFPGAResonanceScanner();

    static std::unique_ptr<Inputs> Create() { return std::unique_ptr<Inputs>(new InputsFPGAResonanceScanner()); }

    std::unique_ptr<Inputs> Clone() const override { return std::unique_ptr<Inputs>(new InputsFPGAResonanceScanner(*this)); }

    ScopeNumber<uint8_t> BitshiftCh1;

    ScopeNumber<uint8_t> BitshiftCh2;

    struct Diagnosis {
        ScopeNumber<bool> ToHostOverflowCh1;
        ScopeNumber<bool> ToHostOverflowCh2;
        ScopeNumber<bool> InterloopOverflow;
        ScopeNumber<bool> InterloopTimeout;
        ScopeNumber<bool> Acquiring;

        ScopeNumber<bool> AIOverRange;

        Diagnosis()
            : ToHostOverflowCh1(false, false, true, L"ToHostOverflowCh1")
            , ToHostOverflowCh2(false, false, true, L"ToHostOverflowCh2")
            , InterloopOverflow(false, false, true, L"InterloopOverflow")
            , InterloopTimeout(false, false, true, L"InterloopTimeout")
            , Acquiring(false, false, true, L"Acquiring")
            , AIOverRange(false, false, true, L"AIOverRange") {
        }
    };
    
    Diagnosis diagnosis;

    void Load(const wptree& pt) override;
    void Save(wptree& pt) const override;
    void SetReadOnlyWhileScanning(const RunState& _runstate) override;
};

class Outputs
    : public Base {

public:
    Outputs();

    
    virtual std::unique_ptr<Outputs> Clone() const = 0;

    static std::unique_ptr<Outputs> Factory(const OutputsType& _type);

    ScopeNumber<double> range;

    ScopeNumber<double> minoutputscanner;
    
    ScopeNumber<double> maxoutputscanner;
    
    ScopeNumber<double> minoutputpockels;
    
    ScopeNumber<double> maxoutputpockels;

    virtual double CoercedPixeltime(const double& _pixeltime) const { return _pixeltime; }

    virtual double MinimumPixeltime() const { return 1.0; }

    void Load(const wptree& pt) override;
    void Save(wptree& pt) const override;
    void SetReadOnlyWhileScanning(const RunState& _runstate) override;
};

class OutputsDAQmx
    : public Outputs {

public:
    OutputsDAQmx();

    std::unique_ptr<Outputs> Clone() const override { return std::unique_ptr<Outputs>(new OutputsDAQmx(*this)); }

    static std::unique_ptr<Outputs> Create() { return std::unique_ptr<Outputs>(new OutputsDAQmx()); }

    ScopeString channelsstring;
    
    ScopeValue<DaqTiming> daq_timing;

    ScopeNumber<double> minimumpixeltime;
    
    ScopeString referenceclocksource;
    
    ScopeNumber<double> referenceclockrate;
    
    ScopeString externalclocksource;

    ScopeString exportpixelclockterminal;

    double CoercedPixeltime(const double& _pixeltime) const override;

    double MinimumPixeltime() const override;

    void Load(const wptree& pt) override;
    void Save(wptree& pt) const override;
    void SetReadOnlyWhileScanning(const RunState& _runstate) override;
};

class OutputsDAQmxLineClock
    : public Outputs {

public:
    OutputsDAQmxLineClock();

    std::unique_ptr<Outputs> Clone() const override { return std::unique_ptr<Outputs>(new OutputsDAQmxLineClock(*this)); }

    static std::unique_ptr<Outputs> Create() { return std::unique_ptr<Outputs>(new OutputsDAQmxLineClock()); }

    ScopeString xpout;

    ScopeString yzout;

    ScopeValue<DaqTiming> pixel_timing;

    ScopeValue<DaqTiming> line_timing;

    ScopeNumber<double> minimumpixeltime;
    
    ScopeString pixel_referenceclocksource;

    ScopeString line_referenceclocksource;

    ScopeNumber<double> pixel_referenceclockrate;

    ScopeNumber<double> line_referenceclockrate;

    ScopeString pixel_externalclocksource;

    ScopeString line_externalclocksource;

    double CoercedPixeltime(const double& _pixeltime) const override;

    double MinimumPixeltime() const override;

    void Load(const wptree& pt) override;
    void Save(wptree& pt) const override;
    void SetReadOnlyWhileScanning(const RunState& _runstate) override;
};

class OutputsDAQmxSlave
    : public Outputs {

public:
    OutputsDAQmxSlave();

    std::unique_ptr<Outputs> Clone() const override { return std::unique_ptr<Outputs>(new OutputsDAQmxSlave(*this)); }

    static std::unique_ptr<Outputs> Create() { return std::unique_ptr<Outputs>(new OutputsDAQmxSlave()); }

    ScopeString zpout;

    ScopeValue<DaqTiming> timing;

    ScopeNumber<double> minimumpixeltime;

    ScopeString referenceclocksource;

    ScopeNumber<double> referenceclockrate;

    ScopeString externalclocksource;

    double CoercedPixeltime(const double& _pixeltime) const override;

    double MinimumPixeltime() const override;

    void Load(const wptree& pt) override;
    void Save(wptree& pt) const override;
    void SetReadOnlyWhileScanning(const RunState& _runstate) override;
};

class OutputsDAQmxResonance
    : public Outputs {

public:
    OutputsDAQmxResonance();

    std::unique_ptr<Outputs> Clone() const override { return std::unique_ptr<Outputs>(new OutputsDAQmxResonance(*this)); }

    static std::unique_ptr<Outputs> Create() { return std::unique_ptr<Outputs>(new OutputsDAQmxResonance()); }

    ScopeString channelsstring;

    ScopeString scanveclength;
    
    ScopeString zoomchannelstring;

    ScopeNumber<DaqTiming> daq_timing;

    ScopeNumber<double> minimumpixeltime;
    
    ScopeString referenceclocksource;
    
    ScopeNumber<double> referenceclockrate;
    
    ScopeString externalclocksource;

    ScopeString exportpixelclockterminal;

    double CoercedPixeltime(const double& _pixeltime) const override;

    double MinimumPixeltime() const override;

    void Load(const wptree& pt) override;
    void Save(wptree& pt) const override;
    void SetReadOnlyWhileScanning(const RunState& _runstate) override;
};

class Daq
    : public Base {

public:
    Daq(const bool& _isslave);

    Daq(const Daq& _daq);

    Daq& operator=(const Daq& _daq);

    const bool isslave;

    std::unique_ptr<Inputs> inputs;

    std::unique_ptr<Outputs> outputs;
    
    ScopeString shutterline;

    ScopeString switchresonanceline;

    ScopeString zoomresonanceline;
    
    ScopeNumber<double> pixeltime;
    
    ScopeNumber<double> scannerdelay;
    
    ScopeNumber<uint32_t> averages;
    
    ScopeNumber<uint32_t> requested_frames;

    ScopeNumber<uint32_t> resonance_frequency;

    int32_t ScannerDelaySamples(const bool& _respectoversampling) const;
 
    void Load(const wptree& pt) override;
    void Save(wptree& pt) const override;
    void SetReadOnlyWhileScanning(const RunState& _runstate) override;

protected:
    void CoercePixeltime();
};


}

}