DigitalOut.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 DigitalOut;
 
    namespace DigitalOutTasks
    {
        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) {}
        };
 
        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 DigitalOutData : public OutputPortData
    {
    public:
        using SampleStreamType = DigitalSampleStream;                   
 
        DigitalOutData(size_t BufferSizeInSamples = 1) : OutputPortData(std::make_unique<SampleStreamType>(BufferSizeInSamples)) {}
        
        DigitalOutData(DataStreamBasePtrType&& SampleStream) : OutputPortData(std::move(SampleStream)) {}
        
        virtual ~DigitalOutData() = default;
 
    private:
        void ResetImpl(dispatch_tag<OutputPortData>) override final;
        virtual void ResetImpl(dispatch_tag<DigitalOutData>) {};        
    };
 
    class DigitalOutParams : public OutputPortParams
    {
    public:
        DigitalOutParams(DynExp::ItemIDType ID, const DynExp::DynExpCore& Core)
            : OutputPortParams(ID, Core) {}
 
        virtual ~DigitalOutParams() = 0;
 
        virtual const char* GetParamClassTag() const noexcept override { return "DigitalOutParams"; }
 
        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, 0, 1, 1, 0 };
 
    protected:
        void DisableUserEditable();                                             
 
    private:
        void ConfigureParamsImpl(dispatch_tag<OutputPortParams>) override final { ConfigureParamsImpl(dispatch_tag<DigitalOutParams>()); }
        virtual void ConfigureParamsImpl(dispatch_tag<DigitalOutParams>) {}     
    };
 
    class DigitalOutConfigurator : public OutputPortConfigurator
    {
    public:
        using ObjectType = DigitalOut;
        using ParamsType = DigitalOutParams;
 
        DigitalOutConfigurator() = default;
        virtual ~DigitalOutConfigurator() = 0;
    };
 
    class DigitalOut : public OutputPort
    {
    public:
        using ParamsType = DigitalOutParams;                                    
        using ConfigType = DigitalOutConfigurator;                              
        using InstrumentDataType = DigitalOutData;                              
 
        using InitTaskType = DigitalOutTasks::InitTask;                         
        using ExitTaskType = DigitalOutTasks::ExitTask;                         
        using UpdateTaskType = DigitalOutTasks::UpdateTask;                     
 
        constexpr static auto Name() noexcept { return "Digital Out"; }         
        constexpr static auto Category() noexcept { return "I/O"; }             
 
        DigitalOut(const std::thread::id OwnerThreadID, DynExp::ParamsBasePtrType&& Params)
            : OutputPort(OwnerThreadID, std::move(Params)) {}
        
        virtual ~DigitalOut() = 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 DataStreamInstrumentData::ValueType GetUserMinValue() const override { return GetHardwareMinValue(); }
        virtual DataStreamInstrumentData::ValueType GetUserMaxValue() const override { return GetHardwareMaxValue(); }
        
        virtual NumericSampleStreamParamsExtension::ValueType GetNumericSampleStreamParams() const { return {}; }
 
 
        virtual void Set(DigitalOutData::SampleStreamType::SampleType Sample, DynExp::TaskBase::CallbackType CallbackFunc = nullptr) const;
 
        virtual void SetSync(DigitalOutData::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<DigitalOut>) = 0;                   
 
        virtual std::unique_ptr<DynExp::InitTaskBase> MakeInitTask() const override { return DynExp::MakeTask<DigitalOutTasks::InitTask>(); }
        virtual std::unique_ptr<DynExp::ExitTaskBase> MakeExitTask() const override { return DynExp::MakeTask<DigitalOutTasks::ExitTask>(); }
        virtual std::unique_ptr<DynExp::UpdateTaskBase> MakeUpdateTask() const override { return DynExp::MakeTask<DigitalOutTasks::UpdateTask>(); }
    };
}