motorLcsIf.hpp

Go to the documentation of this file.

 
#ifndef FCF_DEVMGR_DEVICE_MOTOR_IF_HPP
#define FCF_DEVMGR_DEVICE_MOTOR_IF_HPP
 
// System headers
#include <unordered_map>
 
// Third party headers
#include <yaml-cpp/yaml.h>
 
#include <fcf/devmgr/common/deviceLcsIf.hpp>
#include <fcf/devmgr/devices/motorConfig.hpp>
#include <fcf/devmgr/common/dataContext.hpp>
 
#include <Fcfif.hpp>
#include <rad/mal/publisher.hpp>
 
namespace fcf::devmgr::motor {
 
  struct MotorControllerData : fcf::devmgr::common::DeviceControllerData {
  public:
    MotorControllerData();
    virtual ~MotorControllerData();
 
    inline double GetActualPos() const;
    inline void SetActualPos(double position);
    inline double GetPosError() const;
    inline void SetPosError(double pos_error);
    inline double GetActualVel() const;
    inline void SetActualVel(double velocity);
    inline double GetTargetPos() const;
    inline void SetTargetPos(double position);
    inline double GetTargetVel() const;
    inline void SetTargetVel(double velocity);
    inline double GetScaleFactor() const;
    inline void SetScaleFactor(double scale);
 
    inline bool GetBrakeFlag() const;
    inline void SetBrakeFlag(bool flag);
 
    inline bool GetEnableFlag() const;
    inline void SetEnableFlag(bool flag);
 
    inline bool GetLockFlag() const;
    inline void SetLockFlag(bool flag);
 
    inline int  GetMode() const;
    inline void SetMode(int mode);
 
    inline bool GetReadyFlag() const;
    inline void SetReadyFlag(bool flag);
 
    inline bool GetInPositionFlag() const;
    inline void SetInPositionFlag(bool flag);
 
    inline short  GetInfoData1() const;
    inline void SetInfoData1(short info);
 
    inline short  GetInfoData2() const;
    inline void SetInfoData2(short info);
 
    inline bool  GetSignalFlag(Signal signal) const;
    inline void SetSignalFlag(Signal signal, bool flag);
 
    inline virtual std::string GetErrorText() const;
    inline virtual std::string GetSubstateStr() const;
 
    void SetData(const MotorControllerData& data);
 
  protected:
    double   m_target_pos {};
    double   m_actual_pos {};
    double   m_pos_error {};
    double   m_actual_vel {};
    double   m_target_vel {};
    double   m_scale_factor {1};
    bool     m_brake {false};
    bool     m_enabled {false};
    bool     m_locked {false};
    int      m_mode {};
    bool     m_ready {false};
    bool     m_in_position {false};
    int      m_info_data1 {};
    int      m_info_data2 {};
    std::vector<bool> m_signals;
  };
 
  template<typename TOPIC_TYPE>
  class MotorLcsIf : public fcf::devmgr::common::DeviceLcsIf
  {
   public:
    enum {
      STAT_LOCAL       = 1,
      STAT_ERROR       = 2,
      STAT_HW_STATUS   = 3,
      STAT_STATE       = 4,
      STAT_SUBSTATE    = 5,
      STAT_ACTUAL_POS  = 6,
      STAT_TARGET_POS  = 7,
      STAT_POS_ERROR   = 8,
      STAT_ACTUAL_VEL  = 9,
      STAT_TARGET_VEL  = 10,
      STAT_AXIS_BRAKE  = 11,
      STAT_AXIS_ENABLE = 12,
      STAT_AXIS_LOCK   = 13,
      STAT_MODE        = 14,
      STAT_AXIS_READY  = 15,
      STAT_AXIS_INPOS  = 16,
      STAT_AXIS_INFO1  = 17,
      STAT_AXIS_INFO2  = 18,
      STAT_INITIALISED = 19,
      STAT_INIT_STEP   = 20,
      STAT_INIT_ACTION = 21,
      STAT_SIGNAL_LSTOP  = 22,
      STAT_SIGNAL_LHW    = 23,
      STAT_SIGNAL_REF    = 24,
      STAT_SIGNAL_INDEX  = 25,
      STAT_SIGNAL_UHW    = 26,
      STAT_SIGNAL_USTOP  = 27,
      STAT_SCALE_FACTOR  = 28,
      STAT_MOTOR_END
    };
 
  public:
    MotorLcsIf(std::shared_ptr<fcf::devmgr::common::IDeviceConfig> config,
               fcf::devmgr::common::DataContext& data_ctx, bool initialise = true);
 
    virtual ~MotorLcsIf() {};
 
    void MoveAbs(double position, double velocity);
 
    void MoveRel(double position, double velocity);
 
    void MoveVel(double velocity);
 
    virtual bool IsDisabling();
 
    bool IsMoving();
 
    bool IsStandstill();
 
    virtual void ReadStatus(MotorControllerData& status,
                            bool force_read = true);
 
    void Listener(fcf::common::VectorVariant& params);
 
    virtual std::string GetRpcError(const short error_code) const;
 
 
  protected:
 
    void StoreAttribute(const std::string key,
                        const fcf::common::Variant& value,
                        bool publish,
                        int  attribute);
 
    void PublishPosition(const fcf::common::Variant& value,
                         int  attribute);
 
  private:
    void MovePos(double position, double velocity, std::string move_type=RPC_MOVE_ABS);
 
  protected:
 
    std::unique_ptr<rad::cii::Publisher<fcfif::MotorPositionTopic>> m_motor_publisher;
    std::unique_ptr<rad::cii::Publisher<TOPIC_TYPE>> m_publisher;
 
    double m_mot_actual_pos {};
    double m_mot_target_pos {};
    double m_mot_pos_error {};
    double m_mot_actual_vel {};
    double m_mot_scale {1.0};
    bool   m_mot_initialised {false};
    int    m_mot_init_step {};
    int    m_mot_init_action {};
    int    m_mot_mode {};
    short  m_mot_axis_info1 {};
    short  m_mot_axis_info2 {};
    bool   m_mot_axis_ready {false};
    bool   m_mot_axis_enable {false};
    bool   m_mot_axis_brake {false};
    bool   m_mot_axis_lock {false};
    bool   m_mot_axis_inpos {false};
    bool   m_mot_signal_lstop {false};
    bool   m_mot_signal_lhw {false};
    bool   m_mot_signal_ref {false};
    bool   m_mot_signal_index {false};
    bool   m_mot_signal_uhw {false};
    bool   m_mot_signal_ustop {false};
 
  private:
    static std::timed_mutex           m_mutex;
 
 
 
 
  };
 
}
 
#include "motorLcsIf.ipp"
 
#endif //FCF_DEVMGR_DEVICE_MOTOR_IF_HPP