Stage.h

Go to the documentation of this file.

// This file is part of DynExp.
 
#pragma once
 
#include "stdafx.h"
#include "Instrument.h"
 
namespace DynExpInstr
{
    class PositionerStage;
    
    namespace PositionerStageTasks
    {
        class InitTask : public DynExp::InitTaskBase
        {
            void InitFuncImpl(dispatch_tag<InitTaskBase>, DynExp::InstrumentInstance& Instance) override final { InitFuncImpl(dispatch_tag<InitTask>(), Instance); }
 
            virtual void InitFuncImpl(dispatch_tag<InitTask>, DynExp::InstrumentInstance& Instance) {}
        };
 
        class ExitTask : public DynExp::ExitTaskBase
        {
            void ExitFuncImpl(dispatch_tag<ExitTaskBase>, DynExp::InstrumentInstance& Instance) override final { ExitFuncImpl(dispatch_tag<ExitTask>(), Instance); }
 
            virtual void ExitFuncImpl(dispatch_tag<ExitTask>, DynExp::InstrumentInstance& Instance) {}
        };
 
        class UpdateTask : public DynExp::UpdateTaskBase
        {
            void UpdateFuncImpl(dispatch_tag<UpdateTaskBase>, DynExp::InstrumentInstance& Instance) override final { UpdateFuncImpl(dispatch_tag<UpdateTask>(), Instance); }
 
            virtual void UpdateFuncImpl(dispatch_tag<UpdateTask>, DynExp::InstrumentInstance& Instance) {}
        };
    }
 
    class PositionerStageData : public DynExp::InstrumentDataBase
    {
    public:
        using PositionType = signed long long;
 
        PositionerStageData() = default;
        virtual ~PositionerStageData() = default;
 
        auto GetCurrentPosition() const noexcept { return Position; }                           
        auto GetVelocity() const noexcept { return Velocity; }                                  
        void SetCurrentPosition(PositionType Position) noexcept { this->Position = Position; }  
        void SetVelocity(PositionType Velocity) noexcept { this->Velocity = Velocity; }         
 
        bool IsMoving() const noexcept { return IsMovingChild(); }                              
        bool HasArrived() const noexcept { return HasArrivedChild(); }                          
        bool HasFailed() const noexcept { return HasFailedChild(); }                            
        bool IsReferenced() const noexcept { return IsReferencedChild(); }                      
 
    private:
        void ResetImpl(dispatch_tag<InstrumentDataBase>) override final;
 
        virtual void ResetImpl(dispatch_tag<PositionerStageData>) {};
 
        virtual bool IsMovingChild() const noexcept = 0;                                        
        virtual bool HasArrivedChild() const noexcept = 0;                                      
        virtual bool HasFailedChild() const noexcept = 0;                                       
        virtual bool IsReferencedChild() const noexcept { return false; }                       
 
        PositionType Position = 0;
 
        PositionType Velocity = 0;
    };
 
    class PositionerStageParams : public DynExp::InstrumentParamsBase
    {
    public:
        PositionerStageParams(DynExp::ItemIDType ID, const DynExp::DynExpCore& Core) : InstrumentParamsBase(ID, Core) {}
 
        virtual ~PositionerStageParams() = 0;
 
        virtual const char* GetParamClassTag() const noexcept override { return "PositionerStageParams"; }
 
    private:
        void ConfigureParamsImpl(dispatch_tag<InstrumentParamsBase>) override final { ConfigureParamsImpl(dispatch_tag<PositionerStageParams>()); }
        virtual void ConfigureParamsImpl(dispatch_tag<PositionerStageParams>) {}    
 
        DummyParam Dummy = { *this };                                               
    };
 
    class PositionerStageConfigurator : public DynExp::InstrumentConfiguratorBase
    {
    public:
        using ObjectType = PositionerStage;
        using ParamsType = PositionerStageParams;
 
        PositionerStageConfigurator() = default;
        virtual ~PositionerStageConfigurator() = 0;
    };
 
    class PositionerStage : public DynExp::InstrumentBase
    {
    public:
        enum class DirectionType { Forward, Backward };
        using ParamsType = PositionerStageParams;                               
        using ConfigType = PositionerStageConfigurator;                         
        using InstrumentDataType = PositionerStageData;                         
 
        using InitTaskType = PositionerStageTasks::InitTask;                    
        using ExitTaskType = PositionerStageTasks::ExitTask;                    
        using UpdateTaskType = PositionerStageTasks::UpdateTask;                
 
        constexpr static auto Name() noexcept { return "Positioner Stage"; }    
        constexpr static auto Category() noexcept { return "Positioners"; }     
        
        PositionerStage(const std::thread::id OwnerThreadID, DynExp::ParamsBasePtrType&& Params)
            : InstrumentBase(OwnerThreadID, std::move(Params)) {}
 
        virtual ~PositionerStage() = 0;
 
        virtual std::string GetName() const override { return Name(); }
        virtual std::string GetCategory() const override { return Category(); }
 
        virtual std::chrono::milliseconds GetTaskQueueDelay() const override { return std::chrono::milliseconds(100); }
 
        virtual PositionerStageData::PositionType GetMinPosition() const noexcept = 0;      
        virtual PositionerStageData::PositionType GetMaxPosition() const noexcept = 0;      
        virtual PositionerStageData::PositionType GetResolution() const noexcept = 0;       
        
        virtual PositionerStageData::PositionType GetMinVelocity() const noexcept = 0;      
        virtual PositionerStageData::PositionType GetMaxVelocity() const noexcept = 0;      
        virtual PositionerStageData::PositionType GetDefaultVelocity() const noexcept = 0;  
 
        virtual double GetStepNanoMeterRatio() const noexcept { return 1; }
 
        virtual bool IsUsingSIUnits() const noexcept { return false; }
 
 
        virtual void SetHome() const;
 
        virtual void Reference(DirectionType Direction = DirectionType::Forward, DynExp::TaskBase::CallbackType CallbackFunc = nullptr) const;
 
        virtual void Calibrate(DynExp::TaskBase::CallbackType CallbackFunc = nullptr) const;
 
        virtual void SetVelocity(const PositionerStageData::PositionType Velocity) const = 0;
 
        virtual void MoveToHome(DynExp::TaskBase::CallbackType CallbackFunc = nullptr) const;
 
        virtual void MoveAbsolute(const PositionerStageData::PositionType Steps, DynExp::TaskBase::CallbackType CallbackFunc = nullptr) const = 0;
 
        virtual void MoveRelative(const PositionerStageData::PositionType Steps, DynExp::TaskBase::CallbackType CallbackFunc = nullptr) const = 0;
 
        virtual void StopMotion() const = 0;
 
    private:
        void ResetImpl(dispatch_tag<InstrumentBase>) override final;
        virtual void ResetImpl(dispatch_tag<PositionerStage>) = 0;              
    };
}