AnalogIn.h

Go to the documentation of this file.

// This file is part of DynExp.
 
#pragma once
 
#include "stdafx.h"
#include "InputPort.h"
 
namespace DynExpInstr
{
    class AnalogIn;
 
    namespace AnalogInTasks
    {
        class InitTask : public InputPortTasks::InitTask
        {
            void InitFuncImpl(dispatch_tag<InputPortTasks::InitTask>, DynExp::InstrumentInstance& Instance) override final { InitFuncImpl(dispatch_tag<InitTask>(), Instance); }
            
            virtual void InitFuncImpl(dispatch_tag<InitTask>, DynExp::InstrumentInstance& Instance) {}
        };
 
        class ExitTask : public InputPortTasks::ExitTask
        {
            void ExitFuncImpl(dispatch_tag<InputPortTasks::ExitTask>, DynExp::InstrumentInstance& Instance) override final { ExitFuncImpl(dispatch_tag<ExitTask>(), Instance); }
            
            virtual void ExitFuncImpl(dispatch_tag<ExitTask>, DynExp::InstrumentInstance& Instance) {}
        };
 
        class UpdateTask : public InputPortTasks::UpdateTask
        {
            void UpdateFuncImpl(dispatch_tag<InputPortTasks::UpdateTask>, DynExp::InstrumentInstance& Instance) override final { UpdateFuncImpl(dispatch_tag<UpdateTask>(), Instance); }
            
            virtual void UpdateFuncImpl(dispatch_tag<UpdateTask>, DynExp::InstrumentInstance& Instance) {}
        };
    }
 
    class AnalogInData : public InputPortData
    {
    public:
        using SampleStreamType = AnalogSampleStream;                    
 
        AnalogInData(size_t BufferSizeInSamples = 1) : InputPortData(std::make_unique<SampleStreamType>(BufferSizeInSamples)) {}
        
        AnalogInData(DataStreamBasePtrType&& SampleStream) : InputPortData(std::move(SampleStream)) {}
        
        virtual ~AnalogInData() = default;
 
    private:
        void ResetImpl(dispatch_tag<InputPortData>) override final;
        virtual void ResetImpl(dispatch_tag<AnalogInData>) {};          
    };
 
    class AnalogInParams : public InputPortParams
    {
    public:
        AnalogInParams(DynExp::ItemIDType ID, const DynExp::DynExpCore& Core)
            : InputPortParams(ID, Core) {}
 
        virtual ~AnalogInParams() = 0;
 
        virtual const char* GetParamClassTag() const noexcept override { return "AnalogInParams"; }
 
    protected:
        void DisableUserEditable();                                             
 
    private:
        void ConfigureParamsImpl(dispatch_tag<InputPortParams>) override final { ConfigureParamsImpl(dispatch_tag<AnalogInParams>()); }
        virtual void ConfigureParamsImpl(dispatch_tag<AnalogInParams>) {}       
 
        DummyParam Dummy = { *this };                                           
    };
 
    class AnalogInConfigurator : public InputPortConfigurator
    {
    public:
        using ObjectType = AnalogIn;
        using ParamsType = AnalogInParams;
 
        AnalogInConfigurator() = default;
        virtual ~AnalogInConfigurator() = 0;
    };
 
    class AnalogIn : public InputPort
    {
    public:
        using ParamsType = AnalogInParams;                                      
        using ConfigType = AnalogInConfigurator;                                
        using InstrumentDataType = AnalogInData;                                
 
        using InitTaskType = AnalogInTasks::InitTask;                           
        using ExitTaskType = AnalogInTasks::ExitTask;                           
        using UpdateTaskType = AnalogInTasks::UpdateTask;                       
 
        constexpr static auto Name() noexcept { return "Analog In"; }           
        constexpr static auto Category() noexcept { return "I/O"; }             
 
        AnalogIn(const std::thread::id OwnerThreadID, DynExp::ParamsBasePtrType&& Params)
            : InputPort(OwnerThreadID, std::move(Params)) {}
        
        virtual ~AnalogIn() = 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 NumericSampleStreamParamsExtension::ValueType GetNumericSampleStreamParams() const { return {}; }
 
 
        virtual AnalogInData::SampleStreamType::SampleType Get(DynExp::TaskBase::CallbackType CallbackFunc = nullptr) const;
 
        virtual AnalogInData::SampleStreamType::SampleType GetSync() const;
 
    private:
        void ResetImpl(dispatch_tag<InputPort>) override final;
        virtual void ResetImpl(dispatch_tag<AnalogIn>) = 0;                     
 
        virtual std::unique_ptr<DynExp::InitTaskBase> MakeInitTask() const override { return DynExp::MakeTask<AnalogInTasks::InitTask>(); }
        virtual std::unique_ptr<DynExp::ExitTaskBase> MakeExitTask() const override { return DynExp::MakeTask<AnalogInTasks::ExitTask>(); }
        virtual std::unique_ptr<DynExp::UpdateTaskBase> MakeUpdateTask() const override { return DynExp::MakeTask<AnalogInTasks::UpdateTask>(); }
    };
}