AnalogOut.h

Go to the documentation of this file.

// This file is part of DynExp.
 
#pragma once
 
#include "stdafx.h"
#include "OutputPort.h"
 
namespace DynExpInstr
{
    class AnalogOut;
 
    namespace AnalogOutTasks
    {
        class InitTask : public OutputPortTasks::InitTask
        {
            void InitFuncImpl(dispatch_tag<OutputPortTasks::InitTask>, DynExp::InstrumentInstance& Instance) override final;
            
            virtual void InitFuncImpl(dispatch_tag<InitTask>, DynExp::InstrumentInstance& Instance) {}
 
 
            virtual bool ApplyLimits() const noexcept { return true; }
        };
 
        class ExitTask : public OutputPortTasks::ExitTask
        {
            void ExitFuncImpl(dispatch_tag<OutputPortTasks::ExitTask>, DynExp::InstrumentInstance& Instance) override final;
            
            virtual void ExitFuncImpl(dispatch_tag<ExitTask>, DynExp::InstrumentInstance& Instance) {}
        };
 
        class UpdateTask : public OutputPortTasks::UpdateTask
        {
            void UpdateFuncImpl(dispatch_tag<OutputPortTasks::UpdateTask>, DynExp::InstrumentInstance& Instance) override final { UpdateFuncImpl(dispatch_tag<UpdateTask>(), Instance); }
            
            virtual void UpdateFuncImpl(dispatch_tag<UpdateTask>, DynExp::InstrumentInstance& Instance) {}
        };
    }
 
    class AnalogOutData : public OutputPortData
    {
    public:
        using SampleStreamType = AnalogSampleStream;                    
 
        AnalogOutData(size_t BufferSizeInSamples = 1) : OutputPortData(std::make_unique<SampleStreamType>(BufferSizeInSamples)) {}
        
        AnalogOutData(DataStreamBasePtrType&& SampleStream) : OutputPortData(std::move(SampleStream)) {}
        
        virtual ~AnalogOutData() = default;
 
    private:
        void ResetImpl(dispatch_tag<OutputPortData>) override final;
        virtual void ResetImpl(dispatch_tag<AnalogOutData>) {};         
    };
 
    class AnalogOutParams : public OutputPortParams
    {
    public:
        AnalogOutParams(DynExp::ItemIDType ID, const DynExp::DynExpCore& Core)
            : OutputPortParams(ID, Core) {}
 
        virtual ~AnalogOutParams() = 0;
 
        virtual const char* GetParamClassTag() const noexcept override { return "AnalogOutParams"; }
 
        Param<ParamsConfigDialog::NumberType> DefaultValue = { *this, "DefaultValue", "Default value",
            "Value to be written to this output port after it has been initialized and before it is stopped.", false,
            0, std::numeric_limits<ParamsConfigDialog::NumberType>::lowest(), std::numeric_limits<ParamsConfigDialog::NumberType>::max(), 1, 3 };
 
        Param<ParamsConfigDialog::NumberType> MinValue = { *this, "MinValue", "Minimal value",
            "Lower limit the values written to this output port must not exceed.", true,
            -5, std::numeric_limits<ParamsConfigDialog::NumberType>::lowest(), std::numeric_limits<ParamsConfigDialog::NumberType>::max(), 1, 3 };
 
        Param<ParamsConfigDialog::NumberType> MaxValue = { *this, "MaxValue", "Maximal value",
            "Upper limit the values written to this output port must not exceed.", true,
            5, std::numeric_limits<ParamsConfigDialog::NumberType>::lowest(), std::numeric_limits<ParamsConfigDialog::NumberType>::max(), 1, 3 };
 
    protected:
        void DisableUserEditable();                                             
 
    private:
        void ConfigureParamsImpl(dispatch_tag<OutputPortParams>) override final { ConfigureParamsImpl(dispatch_tag<AnalogOutParams>()); }
        virtual void ConfigureParamsImpl(dispatch_tag<AnalogOutParams>) {}      
    };
 
    class AnalogOutConfigurator : public OutputPortConfigurator
    {
    public:
        using ObjectType = AnalogOut;
        using ParamsType = AnalogOutParams;
 
        AnalogOutConfigurator() = default;
        virtual ~AnalogOutConfigurator() = 0;
    };
 
    class AnalogOut : public OutputPort
    {
    public:
        using ParamsType = AnalogOutParams;                                     
        using ConfigType = AnalogOutConfigurator;                               
        using InstrumentDataType = AnalogOutData;                               
 
        using InitTaskType = AnalogOutTasks::InitTask;                          
        using ExitTaskType = AnalogOutTasks::ExitTask;                          
        using UpdateTaskType = AnalogOutTasks::UpdateTask;                      
 
        constexpr static auto Name() noexcept { return "Analog Out"; }          
        constexpr static auto Category() noexcept { return "I/O"; }             
 
        AnalogOut(const std::thread::id OwnerThreadID, DynExp::ParamsBasePtrType&& Params)
            : OutputPort(OwnerThreadID, std::move(Params)) {}
        
        virtual ~AnalogOut() = 0;
 
        virtual std::string GetName() const override { return Name(); }
        virtual std::string GetCategory() const override { return Category(); }
 
        virtual DataStreamInstrumentData::UnitType GetValueUnit() const override { return DataStreamInstrumentData::UnitType::Volt; }
        virtual DataStreamInstrumentData::ValueType GetUserMinValue() const override;
        virtual DataStreamInstrumentData::ValueType GetUserMaxValue() const override;
 
        virtual NumericSampleStreamParamsExtension::ValueType GetNumericSampleStreamParams() const { return {}; }
 
 
        virtual void Set(AnalogOutData::SampleStreamType::SampleType Sample, DynExp::TaskBase::CallbackType CallbackFunc = nullptr) const;
 
        virtual void SetSync(AnalogOutData::SampleStreamType::SampleType Sample) const;
 
        virtual void SetDefault(DynExp::TaskBase::CallbackType CallbackFunc = nullptr) const;
 
    private:
        virtual void OnPrepareExitChild() const override;
 
        void ResetImpl(dispatch_tag<OutputPort>) override final;
        virtual void ResetImpl(dispatch_tag<AnalogOut>) = 0;                    
 
        virtual std::unique_ptr<DynExp::InitTaskBase> MakeInitTask() const override { return DynExp::MakeTask<AnalogOutTasks::InitTask>(); }
        virtual std::unique_ptr<DynExp::ExitTaskBase> MakeExitTask() const override { return DynExp::MakeTask<AnalogOutTasks::ExitTask>(); }
        virtual std::unique_ptr<DynExp::UpdateTaskBase> MakeUpdateTask() const override { return DynExp::MakeTask<AnalogOutTasks::UpdateTask>(); }
    };
}