maxisLcsIf.hpp

Go to the documentation of this file.

 
#ifndef FCF_DEVMGR_DEVICE_MAXIS_IF_HPP
#define FCF_DEVMGR_DEVICE_MAXIS_IF_HPP
 
#include <unordered_map>
 
#include <yaml-cpp/yaml.h>
#include "fcf/devmgr/devices/drotLcsIf.hpp"
#include "fcf/devmgr/devices/maxisConfig.hpp"
#include "fcf/devmgr/common/dataContext.hpp"
 
namespace fcf::devmgr::maxis {
 
using VectorAttributes = std::vector <std::pair<std::string, unsigned int>>;
    struct MAxisControllerData : fcf::devmgr::common::DeviceControllerData {
    public:
      MAxisControllerData();
      virtual ~MAxisControllerData();
 
      void SetData(const MAxisControllerData& data);
 
      inline virtual std::string GetErrorText() const;
      inline virtual std::string GetSubstateStr() const;
      inline short  GetTrackingMode() const;
      inline void SetTrackingMode(short mode);
      inline double  GetTrackOffset() const;
      inline void SetTrackOffset(double offset);
      inline fcf::devmgr::motor::MotorControllerData GetMotor(std::string motor) const;
      inline void ClearMotors();
      inline void AddMotor(const std::string motor,
                           const fcf::devmgr::motor::MotorControllerData motor_data);
      inline void GetMotorNames(std::vector<std::string>& motor_vector);
 
  protected:
      short  m_tracking_mode {};
      double m_track_offset {0.0};
      std::map<std::string, fcf::devmgr::motor::MotorControllerData> m_motors;
    };
 
    class MAxisLcsIf : public fcf::devmgr::common::DeviceLcsIf {
 
     // enumerations for MAxis status
      enum {
        STAT_LOCAL       = 100,
        STAT_ERROR       = 101,
        STAT_STATE       = 102,
        STAT_SUBSTATE    = 103,
        STAT_TRACK_MODE  = 104
      };
 
    public:
       MAxisLcsIf(std::shared_ptr<fcf::devmgr::common::IDeviceConfig> config,
                fcf::devmgr::common::DataContext& data_ctx);
 
       virtual ~MAxisLcsIf() {};
 
       virtual void InitObject();
 
       virtual void Init();
 
       void MoveAbs(int axis_id, double position, double velocity, ::fcfif::MotorPosUnit unit = ::fcfif::MotorPosUnit::UU);
 
       void MoveRel(int axis_id, double position, double velocity, ::fcfif::MotorPosUnit unit = ::fcfif::MotorPosUnit::UU);
 
       void MoveEncAbs(int axis_id, long int encoders);
 
       void MoveEncRel(int axis_id, long int encoders);
 
       void MoveVel(int axis_id, double velocity);
 
       void MoveAngle(const double& angle, ::fcfif::MotorPosUnit unit = ::fcfif::MotorPosUnit::UU);
 
       void StartTrack(short mode, double angle);
 
       void StopTrack();
 
       bool IsMoving() const;
 
       bool IsInPosition(const int axis = -1) const;
 
       bool IsStandstill() const;
 
       void TrackOffset(double offset, ::fcfif::MotorPosUnit unit);
 
       bool IsTracking() const;
 
      void ReadConfig();
 
      virtual void ReadStatus(MAxisControllerData& status);
 
      void Listener(protocol::base::VectorVariant& params);
 
      virtual std::string GetRpcError(const short error_code) const;
 
      std::string GetMotorMapValue(std::string motor, std::string category, std::string key);
 
      std::optional<double> GetTargetInUserUnits(int axis_id, double value);
 
      void UpdateTargetPosition(int axis_id, double position, std::string move_type);
 
      virtual void AddCustomAttributes();
 
    protected:
 
      void LoadConfig();
 
    private:
 
 
      void StoreMotorPosition(const std::string nodeid_prefix,
                           const protocol::base::Variant& value,
                           int  attribute);
 
      void StoreMotorAttribute(const std::string nodeid_prefix,
                           const protocol::base::Variant& value,
                           int  attribute);
 
      void MovePos(int axis_id, double position, double velocity,
                   std::string move_type=fcf::devmgr::motor::RPC_MOVE_ABS);
 
      std::pair<std::string, std::string> GetObjectInfo(const std::string& map_value) const;
 
    protected:
       std::vector<std::string> m_monitor_track_vector;
       //std::map<std::string, int> m_motor_index;
       std::unique_ptr<elt::configng::CiiConfigDocument> m_motor_map_doc;
       short  m_track_mode {};
 
       std::map<std::string, fcf::devmgr::motor::MotorControllerData> m_motors_status;
 
    private:
      log4cplus::Logger  m_logger;
    };
 
}
 
#include "maxisLcsIf.ipp"
 
#endif //FCF_DEVMGR_DEVICE_MAXIS_IF_HPP