motorLcsIf.hpp

Go to the documentation of this file.

#ifndef DEVMGR_DEVICE_MOTOR_IF_HPP
#define DEVMGR_DEVICE_MOTOR_IF_HPP

// System headers
#include <unordered_map>

// Third party headers
#include <yaml-cpp/yaml.h>

#include <devmgr/common/deviceLcsIf.hpp>
#include <devmgr/devices/motorConfig.hpp>
#include <devmgr/common/dataContext.hpp>

namespace devmgr {
  namespace motor {


    struct MotorControllerData : 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 std::string GetErrorText() 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;
      bool     m_brake;
      bool     m_enabled;
      bool     m_locked;
      int      m_mode;
      bool     m_ready;
      bool     m_in_position;
      int      m_info_data1;
      int      m_info_data2;
      std::vector<bool> m_signals;
    };

    class MotorLcsIf : public devmgr::common::DeviceLcsIf
    {

      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
      };

    public:
      MotorLcsIf(std::shared_ptr<devmgr::common::IDeviceConfig> config,
                 devmgr::common::DataContext& data_ctx);

      virtual bool IsReady();

      virtual bool IsNotReady() ;

      virtual bool IsOperational() ;

      void ReadConfig();

      void MoveAbs(double position, double velocity);

      void MoveRel(double position, double velocity);

      void MoveVel(double velocity);

      virtual bool IsDisabling() ;

      bool IsMoving() ;

      bool IsStandstill() ;

      bool IsHwFailure();

      virtual void ReadStatus(MotorControllerData& status);

      void StartMonitoring();

      void StopMonitoring();

      void Listener(fcf::common::VectorVariant& params);

      virtual std::string GetRpcError(const short error_code) const;

      virtual std::string GetHwError(int& error_code, const bool update = false);

    private:

      void PublishState(const fcf::common::Variant& value);

      void PublishSubstate(const fcf::common::Variant& value);

      void StoreAttribute(const std::string key,
                          const fcf::common::Variant& value,
                          bool publish,
                          int  attribute);

      void PublishPosition(const fcf::common::Variant& value,
                           int  attribute);

    protected:
      std::unordered_map<std::string, short> m_status_map;

      std::vector<std::string> m_monitor_vector;
    private:
      devmgr::common::DataContext&      m_data_ctx;
      static std::timed_mutex           m_mutex;

      std::shared_ptr<MotorConfig>      m_motor_config;


      void MovePos(double position, double velocity, std::string move_type=RPC_MOVE_ABS);
    };
  }
}

#include "motorLcsIf.inline"

#endif //DEVMGR_DEVICE_MOTOR_IF_HPP