FunctionGenerator.h

Go to the documentation of this file.

// This file is part of DynExp.
 
#pragma once
 
#include "stdafx.h"
#include "DataStreamInstrument.h"
 
namespace DynExpInstr
{
    class FunctionGenerator;
 
    namespace FunctionGeneratorDefs
    {
        enum WaveformTypes {
            None,   
            Sine,   
            Rect,   
            Ramp,   
            Pulse   
        };
 
        struct FunctionDescType
        {
            constexpr FunctionDescType() noexcept = default;
 
            constexpr FunctionDescType(double FrequencyInHz, double Amplitude, double Offset) noexcept
                : FrequencyInHz(FrequencyInHz), Amplitude(Amplitude), Offset(Offset) {}
 
            double FrequencyInHz{};     
            double Amplitude{};         
            double Offset{};            
        };
 
        struct SineFunctionDescType : FunctionDescType
        {
            constexpr SineFunctionDescType() noexcept = default;
 
            constexpr SineFunctionDescType(double FrequencyInHz, double Amplitude, double Offset, double PhaseInRad) noexcept
                : FunctionDescType(FrequencyInHz, Amplitude, Offset), PhaseInRad(PhaseInRad) {}
 
            double PhaseInRad{};        
        };
 
        struct RectFunctionDescType : FunctionDescType
        {
            constexpr RectFunctionDescType() noexcept = default;
 
            constexpr RectFunctionDescType(double FrequencyInHz, double Amplitude, double Offset, double PhaseInRad, double DutyCycle) noexcept
                : FunctionDescType(FrequencyInHz, Amplitude, Offset), PhaseInRad(PhaseInRad), DutyCycle(DutyCycle) {}
 
            double PhaseInRad{};        
            double DutyCycle{};         
        };
 
        struct RampFunctionDescType : FunctionDescType
        {
            constexpr RampFunctionDescType() noexcept = default;
 
            constexpr RampFunctionDescType(double FrequencyInHz, double Amplitude, double Offset, double PhaseInRad, double RiseFallRatio) noexcept
                : FunctionDescType(FrequencyInHz, Amplitude, Offset), PhaseInRad(PhaseInRad), RiseFallRatio(RiseFallRatio) {}
 
            double PhaseInRad{};        
            double RiseFallRatio{};     
        };
 
        struct PulsesDescType
        {
            using PulsesType = std::map<double, double>;
 
            PulsesDescType() = default;
 
            PulsesDescType(const PulsesDescType& Other) : Pulses(Other.Pulses), Offset(Other.Offset) {}
 
            PulsesDescType(PulsesDescType&& Other);
 
            PulsesDescType(const PulsesType& Pulses) : Pulses(Pulses), Offset(0.0) {}
 
            PulsesDescType(PulsesType&& Pulses);
 
            PulsesDescType(const std::vector<double>& PulseStarts, const std::vector<double>& PulseAmplitudes, double Offset = 0.0);
 
            PulsesDescType& operator=(PulsesDescType&& Other);
 
            void Reset() { Pulses.clear(); }
 
            PulsesType Pulses;
 
            double Offset{};            
        };
 
        struct ModulationDescType
        {
            enum class ModulationType {
                Disabled,   
                Amplitude,  
                Frequency,  
                Phase       
            };
 
            enum class ModulationShapeType {
                Sine,       
                Pulse       
            };
 
            ModulationDescType() noexcept = default;
 
            ModulationDescType(ModulationType Type, double Depth, double FrequencyInHz,
                ModulationShapeType Shape = ModulationShapeType::Sine, double PulseDutyCycle = .5) noexcept
                : Type(Type), Depth(Depth), FrequencyInHz(FrequencyInHz),
                Shape(Shape), PulseDutyCycle(PulseDutyCycle) {}
 
            ModulationType Type = ModulationType::Disabled;         
            double Depth{};                                         
            double FrequencyInHz{};                                 
            ModulationShapeType Shape = ModulationShapeType::Sine;  
            double PulseDutyCycle{};                                
        };
 
        struct SweepDescType
        {
            enum class SweepType {
                Disabled,   
                Amplitude,  
                Frequency   
            };
 
            SweepDescType() noexcept = default;
 
            SweepDescType(SweepType Type, double Min, double Max, double ValueDiffPerSample, double TimeDiffPerSample_ms, bool Retrace) noexcept
                : Type(Type), Min(Min), Max(Max), ValueDiffPerSample(ValueDiffPerSample), TimeDiffPerSample_ms(TimeDiffPerSample_ms), Retrace(Retrace) {}
 
            SweepType Type = SweepType::Disabled;       
            double Min{};                               
            double Max{};                               
            double ValueDiffPerSample{};                
            double TimeDiffPerSample_ms{};              
            bool Retrace{};                             
        };
 
        struct TriggerDescType
        {
            enum TriggerModeType {
                Continuous,     
                ExternSingle,   
                ExternStep,     
                Manual          
            };
 
            enum TriggerEdgeType {
                Rise,           
                Fall            
            };
 
            TriggerDescType() noexcept = default;
 
            TriggerDescType(TriggerModeType TriggerMode, TriggerEdgeType TriggerEdge) noexcept
                : TriggerMode(TriggerMode), TriggerEdge(TriggerEdge) {}
 
            TriggerModeType TriggerMode = TriggerModeType::Continuous;  
            TriggerEdgeType TriggerEdge = TriggerEdgeType::Rise;        
        };
 
        constexpr FunctionDescType GetDefaultMinFunctionDesc() { return { 0.0, std::numeric_limits<double>::lowest(), std::numeric_limits<double>::lowest() }; }
 
        constexpr FunctionDescType GetDefaultMaxFunctionDesc() { return { std::numeric_limits<double>::max(), std::numeric_limits<double>::max(), std::numeric_limits<double>::max() }; }
 
        constexpr FunctionDescType GetDefaultDefaultFunctionDesc() { return { 1, 1, 0 }; }
 
        inline constexpr Util::seconds PeriodFromFunctionDesc(const FunctionDescType& FunctionDesc);
 
        inline double RectFunc(double DutyCycle, double Phase);
 
        inline double InvRectFunc(double DutyCycle, double Phase);
 
        inline double RampFunc(double RiseFallRatio, double Phase);
    }
 
    namespace FunctionGeneratorTasks
    {
        class InitTask : public DataStreamInstrumentTasks::InitTask
        {
            void InitFuncImpl(dispatch_tag<DataStreamInstrumentTasks::InitTask>, DynExp::InstrumentInstance& Instance) override final;
            
            virtual void InitFuncImpl(dispatch_tag<InitTask>, DynExp::InstrumentInstance& Instance) {}
        };
 
        class ExitTask : public DataStreamInstrumentTasks::ExitTask
        {
            void ExitFuncImpl(dispatch_tag<DataStreamInstrumentTasks::ExitTask>, DynExp::InstrumentInstance& Instance) override final { ExitFuncImpl(dispatch_tag<ExitTask>(), Instance); }
            
            virtual void ExitFuncImpl(dispatch_tag<ExitTask>, DynExp::InstrumentInstance& Instance) {}
        };
 
        class UpdateTask : public DataStreamInstrumentTasks::UpdateTask
        {
            void UpdateFuncImpl(dispatch_tag<DataStreamInstrumentTasks::UpdateTask>, DynExp::InstrumentInstance& Instance) override final;
            
            virtual void UpdateFuncImpl(dispatch_tag<UpdateTask>, DynExp::InstrumentInstance& Instance) {}
        };
 
        class SetSineFunctionTask : public DynExp::TaskBase
        {
        public:
            SetSineFunctionTask(const FunctionGeneratorDefs::SineFunctionDescType& FunctionDesc, bool Autostart, CallbackType CallbackFunc) noexcept
                : TaskBase(CallbackFunc), FunctionDesc(FunctionDesc), Autostart(Autostart) {}
 
        private:
            virtual DynExp::TaskResultType RunChild(DynExp::InstrumentInstance& Instance) override;
 
            FunctionGeneratorDefs::SineFunctionDescType FunctionDesc;       
 
            bool Autostart;
        };
 
        class SetRectFunctionTask : public DynExp::TaskBase
        {
        public:
            SetRectFunctionTask(const FunctionGeneratorDefs::RectFunctionDescType& FunctionDesc, bool Autostart, CallbackType CallbackFunc) noexcept
                : TaskBase(CallbackFunc), FunctionDesc(FunctionDesc), Autostart(Autostart) {}
 
        private:
            virtual DynExp::TaskResultType RunChild(DynExp::InstrumentInstance& Instance) override;
 
            FunctionGeneratorDefs::RectFunctionDescType FunctionDesc;       
            bool Autostart;                                                 
        };
 
        class SetRampFunctionTask : public DynExp::TaskBase
        {
        public:
            SetRampFunctionTask(const FunctionGeneratorDefs::RampFunctionDescType& FunctionDesc, bool Autostart, CallbackType CallbackFunc) noexcept
                : TaskBase(CallbackFunc), FunctionDesc(FunctionDesc), Autostart(Autostart) {}
 
        private:
            virtual DynExp::TaskResultType RunChild(DynExp::InstrumentInstance& Instance) override;
 
            FunctionGeneratorDefs::RampFunctionDescType FunctionDesc;       
            bool Autostart;                                                 
        };
 
        class SetPulseFunctionTask : public DynExp::TaskBase
        {
        public:
            SetPulseFunctionTask(const FunctionGeneratorDefs::PulsesDescType& FunctionDesc, bool Autostart, CallbackType CallbackFunc) noexcept
                : TaskBase(CallbackFunc), FunctionDesc(FunctionDesc), Autostart(Autostart) {}
 
        private:
            virtual DynExp::TaskResultType RunChild(DynExp::InstrumentInstance& Instance) override;
 
            FunctionGeneratorDefs::PulsesDescType FunctionDesc;             
            bool Autostart;                                                 
        };
 
        class SetArbitraryFunctionTask : public DynExp::TaskBase
        {
        public:
            SetArbitraryFunctionTask(DataStreamBase::BasicSampleListType&& Samples, bool Autostart, CallbackType CallbackFunc) noexcept
                : TaskBase(CallbackFunc), Samples(std::move(Samples)), Autostart(Autostart) {}
 
        private:
            virtual DynExp::TaskResultType RunChild(DynExp::InstrumentInstance& Instance) override;
 
            DataStreamBase::BasicSampleListType Samples;                    
            bool Autostart;                                                 
        };
 
        class SetTriggerTask : public DynExp::TaskBase
        {
        public:
            SetTriggerTask(const FunctionGeneratorDefs::TriggerDescType& TriggerDesc) noexcept
                : TaskBase(nullptr), TriggerDesc(TriggerDesc) {}
 
        private:
            virtual DynExp::TaskResultType RunChild(DynExp::InstrumentInstance& Instance) override;
 
            FunctionGeneratorDefs::TriggerDescType TriggerDesc;             
        };
    }
 
    class FunctionGeneratorData : public DataStreamInstrumentData
    {
        friend class FunctionGeneratorTasks::UpdateTask;
        friend class FunctionGeneratorTasks::SetSineFunctionTask;
        friend class FunctionGeneratorTasks::SetRectFunctionTask;
        friend class FunctionGeneratorTasks::SetRampFunctionTask;
        friend class FunctionGeneratorTasks::SetPulseFunctionTask;
        friend class FunctionGeneratorTasks::SetArbitraryFunctionTask;
        friend class FunctionGeneratorTasks::SetTriggerTask;
 
    public:
        FunctionGeneratorData(DataStreamBasePtrType&& SampleStream) : DataStreamInstrumentData(std::move(SampleStream)) {}
 
        virtual ~FunctionGeneratorData() = default;
 
        auto GetCurrentWaveformType() const noexcept { return CurrentWaveformType; }    
        auto GetCurrentFrequencyInHz() const noexcept { return CurrentFrequencyInHz; }  
        auto GetCurrentAmplitude() const noexcept { return CurrentAmplitude; }          
        auto GetCurrentOffset() const noexcept { return CurrentOffset; }                
        auto GetCurrentPhaseInRad() const noexcept { return CurrentPhaseInRad; }        
        auto GetCurrentDutyCycle() const noexcept { return CurrentDutyCycle; }          
        auto GetCurrentTriggerMode() const noexcept { return CurrentTriggerMode; }      
        auto GetCurrentTriggerEdge() const noexcept { return CurrentTriggerEdge; }      
        auto GetShouldAutostart() const noexcept { return ShouldAutostart; }            
        auto GetCurrentPulses() const noexcept { return CurrentPulses; }                
 
    private:
        void ResetImpl(dispatch_tag<DataStreamInstrumentData>) override final;
        
        virtual void ResetImpl(dispatch_tag<FunctionGeneratorData>) {};
 
        bool DataHasBeenUpdated{ false };
 
        FunctionGeneratorDefs::WaveformTypes CurrentWaveformType{};                 
        double CurrentFrequencyInHz{};                                              
        double CurrentAmplitude{};                                                  
        double CurrentOffset{};                                                     
        double CurrentPhaseInRad{};                                                 
        double CurrentDutyCycle{};                                                  
        FunctionGeneratorDefs::TriggerDescType::TriggerModeType CurrentTriggerMode; 
        FunctionGeneratorDefs::TriggerDescType::TriggerEdgeType CurrentTriggerEdge; 
        bool ShouldAutostart{};                                                     
 
        FunctionGeneratorDefs::PulsesDescType CurrentPulses;                        
    };
 
    class FunctionGeneratorParams : public DataStreamInstrumentParams
    {
    public:
        FunctionGeneratorParams(DynExp::ItemIDType ID, const DynExp::DynExpCore& Core) : DataStreamInstrumentParams(ID, Core) {}
 
        virtual ~FunctionGeneratorParams() = 0;
 
        virtual const char* GetParamClassTag() const noexcept override { return "FunctionGeneratorParams"; }
 
        Param<FunctionGeneratorDefs::WaveformTypes> WaveformType = { *this, "WaveformTypes", FunctionGeneratorDefs::WaveformTypes::None };
 
        Param<double> FrequencyInHz = { *this, "FrequencyInHz", FunctionGeneratorDefs::GetDefaultDefaultFunctionDesc().FrequencyInHz,
            FunctionGeneratorDefs::GetDefaultMinFunctionDesc().FrequencyInHz, FunctionGeneratorDefs::GetDefaultMaxFunctionDesc().FrequencyInHz };
 
        Param<double> Amplitude = { *this, "Amplitude", FunctionGeneratorDefs::GetDefaultDefaultFunctionDesc().Amplitude,
            FunctionGeneratorDefs::GetDefaultMinFunctionDesc().Amplitude, FunctionGeneratorDefs::GetDefaultMaxFunctionDesc().Amplitude };
 
        Param<double> Offset = { *this, "Offset", FunctionGeneratorDefs::GetDefaultDefaultFunctionDesc().Offset,
            FunctionGeneratorDefs::GetDefaultMinFunctionDesc().Offset, FunctionGeneratorDefs::GetDefaultMaxFunctionDesc().Offset };
 
        Param<double> PhaseInRad = { *this, "PhaseInRad", 0, 0, 2.0 * std::numbers::pi };
 
        Param<double> DutyCycle = { *this, "DutyCycle", .5, 0, 1 };
 
        ListParam<double> PulseStarts = { *this, "PulseStarts", {}, 0};
 
        ListParam<double> PulseAmplitudes = { *this, "PulseAmplitudes", {} };
 
        Param<FunctionGeneratorDefs::TriggerDescType::TriggerModeType> TriggerMode = { *this, "TriggerMode", FunctionGeneratorDefs::TriggerDescType::TriggerModeType::Continuous };
 
        Param<FunctionGeneratorDefs::TriggerDescType::TriggerEdgeType> TriggerEdge = { *this, "TriggerEdge", FunctionGeneratorDefs::TriggerDescType::TriggerEdgeType::Rise };
 
        Param<bool> Autostart = { *this, "Autostart", false };
 
    private:
        void ConfigureParamsImpl(dispatch_tag<DataStreamInstrumentParams>) override final { ConfigureParamsImpl(dispatch_tag<FunctionGeneratorParams>()); }
        virtual void ConfigureParamsImpl(dispatch_tag<FunctionGeneratorParams>) {}  
    };
 
    class FunctionGeneratorConfigurator : public DataStreamInstrumentConfigurator
    {
    public:
        using ObjectType = FunctionGenerator;
        using ParamsType = FunctionGeneratorParams;
 
        FunctionGeneratorConfigurator() = default;
        virtual ~FunctionGeneratorConfigurator() = 0;
    };
 
    class FunctionGenerator : public DataStreamInstrument
    {
    public:
        using ParamsType = FunctionGeneratorParams;                             
        using ConfigType = FunctionGeneratorConfigurator;                       
        using InstrumentDataType = FunctionGeneratorData;                       
 
        using InitTaskType = FunctionGeneratorTasks::InitTask;                  
        using ExitTaskType = FunctionGeneratorTasks::ExitTask;                  
        using UpdateTaskType = FunctionGeneratorTasks::UpdateTask;              
 
        enum class WaveformCapsType {
            UserDefined,        
            Sine,               
            Rect,               
            Ramp,               
            Pulse,              
            NUM_ELEMENTS        
        };
 
        enum class QuantityCapsType {
            Amplitude,          
            Frequency,          
            Phase,              
            NUM_ELEMENTS        
        };
 
        enum class TriggerCapsType {
            CanConfigure,       
            CanForce,           
            NUM_ELEMENTS        
        };
 
        constexpr static auto Name() noexcept { return "Function Generator"; }  
        constexpr static auto Category() noexcept { return "I/O"; }             
 
        FunctionGenerator(const std::thread::id OwnerThreadID, DynExp::ParamsBasePtrType&& Params)
            : DataStreamInstrument(OwnerThreadID, std::move(Params)) {}
 
        virtual ~FunctionGenerator() = 0;
 
        virtual std::string GetName() const override { return Name(); }
        virtual std::string GetCategory() const override { return Category(); }
 
        FunctionGeneratorDefs::FunctionDescType GetMinCaps() const { return GetMinCapsChild(); }                
        FunctionGeneratorDefs::FunctionDescType GetMaxCaps() const { return GetMaxCapsChild(); }                
        FunctionGeneratorDefs::FunctionDescType GetParamDefaults() const { return GetParamDefaultsChild(); }    
        Util::FeatureTester<WaveformCapsType> GetWaveformCaps() const { return GetWaveformCapsChild(); }        
        Util::FeatureTester<QuantityCapsType> GetModulationCaps() const { return GetModulationCapsChild(); }    
        Util::FeatureTester<QuantityCapsType> GetSweepCaps() const { return GetSweepCapsChild(); }              
        Util::FeatureTester<TriggerCapsType> GetTriggerCaps() const { return GetTriggerCapsChild(); }           
 
 
        virtual bool IsPhaseAdjustable() const noexcept { return true; }
 
 
        virtual void SetSineFunction(const FunctionGeneratorDefs::SineFunctionDescType& FunctionDesc,
            bool PersistParams = false, bool Autostart = false, DynExp::TaskBase::CallbackType CallbackFunc = nullptr) const;
 
        virtual void SetRectFunction(const FunctionGeneratorDefs::RectFunctionDescType& FunctionDesc,
            bool PersistParams = false, bool Autostart = false, DynExp::TaskBase::CallbackType CallbackFunc = nullptr) const;
 
        virtual void SetRampFunction(const FunctionGeneratorDefs::RampFunctionDescType& FunctionDesc,
            bool PersistParams = false, bool Autostart = false, DynExp::TaskBase::CallbackType CallbackFunc = nullptr) const;
 
        virtual void SetPulseFunction(const FunctionGeneratorDefs::PulsesDescType& FunctionDesc,
            bool PersistParams = false, bool Autostart = false, DynExp::TaskBase::CallbackType CallbackFunc = nullptr) const;
 
        virtual void SetArbitraryFunction(DataStreamBase::BasicSampleListType&& Samples,
            bool Autostart = false, DynExp::TaskBase::CallbackType CallbackFunc = nullptr) const;
 
        virtual void SetModulation(const FunctionGeneratorDefs::ModulationDescType& ModulationDesc,
            bool PersistParams = false, DynExp::TaskBase::CallbackType CallbackFunc = nullptr) const;
 
        virtual void SetSweep(const FunctionGeneratorDefs::SweepDescType& SweepDesc,
            bool PersistParams = false, DynExp::TaskBase::CallbackType CallbackFunc = nullptr) const;
 
        void SetTrigger(const FunctionGeneratorDefs::TriggerDescType& TriggerDesc,
            bool PersistParams = false, DynExp::TaskBase::CallbackType CallbackFunc = nullptr) const;
 
        virtual void ForceTrigger(DynExp::TaskBase::CallbackType CallbackFunc = nullptr) const;
 
        virtual void ForceTriggerSync() const;
 
    private:
        void ResetImpl(dispatch_tag<DataStreamInstrument>) override final;
        virtual void ResetImpl(dispatch_tag<FunctionGenerator>) = 0;        
 
        virtual FunctionGeneratorDefs::FunctionDescType GetMinCapsChild() const { return FunctionGeneratorDefs::GetDefaultMinFunctionDesc(); }              
        virtual FunctionGeneratorDefs::FunctionDescType GetMaxCapsChild() const { return FunctionGeneratorDefs::GetDefaultMaxFunctionDesc(); }              
        virtual FunctionGeneratorDefs::FunctionDescType GetParamDefaultsChild() const { return FunctionGeneratorDefs::GetDefaultDefaultFunctionDesc(); }    
        virtual Util::FeatureTester<WaveformCapsType> GetWaveformCapsChild() const = 0;                                                                     
        virtual Util::FeatureTester<QuantityCapsType> GetModulationCapsChild() const { return {}; }                                                         
        virtual Util::FeatureTester<QuantityCapsType> GetSweepCapsChild() const { return {}; }                                                              
        virtual Util::FeatureTester<TriggerCapsType> GetTriggerCapsChild() const { return {}; }                                                             
 
 
        virtual void SetTriggerChild(const FunctionGeneratorDefs::TriggerDescType& TriggerDesc,
            bool PersistParams, DynExp::TaskBase::CallbackType CallbackFunc) const;
 
        virtual std::unique_ptr<DynExp::InitTaskBase> MakeInitTask() const override { return DynExp::MakeTask<FunctionGeneratorTasks::InitTask>(); }
        virtual std::unique_ptr<DynExp::ExitTaskBase> MakeExitTask() const override { return DynExp::MakeTask<FunctionGeneratorTasks::ExitTask>(); }
        virtual std::unique_ptr<DynExp::UpdateTaskBase> MakeUpdateTask() const override { return DynExp::MakeTask<FunctionGeneratorTasks::UpdateTask>(); }
    };
}