DigitalIn.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 DigitalIn;
 
    namespace DigitalInTasks
    {
        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 DigitalInData : public InputPortData
    {
    public:
        using SampleStreamType = DigitalSampleStream;                   
 
        DigitalInData(size_t BufferSizeInSamples = 1) : InputPortData(std::make_unique<SampleStreamType>(BufferSizeInSamples)) {}
        
        DigitalInData(DataStreamBasePtrType&& SampleStream) : InputPortData(std::move(SampleStream)) {}
        
        virtual ~DigitalInData() = default;
 
    private:
        void ResetImpl(dispatch_tag<InputPortData>) override final;
        virtual void ResetImpl(dispatch_tag<DigitalInData>) {};         
    };
 
    class DigitalInParams : public InputPortParams
    {
    public:
        DigitalInParams(DynExp::ItemIDType ID, const DynExp::DynExpCore& Core)
            : InputPortParams(ID, Core) {}
 
        virtual ~DigitalInParams() = 0;
 
        virtual const char* GetParamClassTag() const noexcept override { return "DigitalInParams"; }
 
    protected:
        void DisableUserEditable();                                             
 
    private:
        void ConfigureParamsImpl(dispatch_tag<InputPortParams>) override final { ConfigureParamsImpl(dispatch_tag<DigitalInParams>()); }
        virtual void ConfigureParamsImpl(dispatch_tag<DigitalInParams>) {}      
 
        DummyParam Dummy = { *this };                                           
    };
 
    class DigitalInConfigurator : public InputPortConfigurator
    {
    public:
        using ObjectType = DigitalIn;
        using ParamsType = DigitalInParams;
 
        DigitalInConfigurator() = default;
        virtual ~DigitalInConfigurator() = 0;
    };
 
    class DigitalIn : public InputPort
    {
    public:
        using ParamsType = DigitalInParams;                                     
        using ConfigType = DigitalInConfigurator;                               
        using InstrumentDataType = DigitalInData;                               
 
        using InitTaskType = DigitalInTasks::InitTask;                          
        using ExitTaskType = DigitalInTasks::ExitTask;                          
        using UpdateTaskType = DigitalInTasks::UpdateTask;                      
 
        constexpr static auto Name() noexcept { return "Digital In"; }          
        constexpr static auto Category() noexcept { return "I/O"; }             
 
        DigitalIn(const std::thread::id OwnerThreadID, DynExp::ParamsBasePtrType&& Params)
            : InputPort(OwnerThreadID, std::move(Params)) {}
        
        virtual ~DigitalIn() = 0;
 
        virtual std::string GetName() const override { return Name(); }
        virtual std::string GetCategory() const override { return Category(); }
 
        virtual DataStreamInstrumentData::ValueType GetHardwareMinValue() const noexcept override final { return 0; }
        virtual DataStreamInstrumentData::ValueType GetHardwareMaxValue() const noexcept override final { return 1; }
        virtual DataStreamInstrumentData::ValueType GetHardwareResolution() const noexcept override final { return 1; }
        virtual DataStreamInstrumentData::UnitType GetValueUnit() const noexcept override final { return DataStreamInstrumentData::UnitType::LogicLevel; }
        
        virtual NumericSampleStreamParamsExtension::ValueType GetNumericSampleStreamParams() const { return {}; }
 
 
        virtual DigitalInData::SampleStreamType::SampleType Get(DynExp::TaskBase::CallbackType CallbackFunc = nullptr) const;
 
        virtual DigitalInData::SampleStreamType::SampleType GetSync() const;
 
    private:
        void ResetImpl(dispatch_tag<InputPort>) override final;
        virtual void ResetImpl(dispatch_tag<DigitalIn>) = 0;                    
 
        virtual std::unique_ptr<DynExp::InitTaskBase> MakeInitTask() const override { return DynExp::MakeTask<DigitalInTasks::InitTask>(); }
        virtual std::unique_ptr<DynExp::ExitTaskBase> MakeExitTask() const override { return DynExp::MakeTask<DigitalInTasks::ExitTask>(); }
        virtual std::unique_ptr<DynExp::UpdateTaskBase> MakeUpdateTask() const override { return DynExp::MakeTask<DigitalInTasks::UpdateTask>(); }
    };
}