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 "ifw/fcf/devmgr/devices/drotLcsIf.hpp"
#include "ifw/fcf/devmgr/devices/maxisConfig.hpp"
#include "ifw/fcf/devmgr/common/dataContext.hpp"
 
 
namespace ifw::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 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);
 
  private:
      std::map<std::string, fcf::devmgr::motor::MotorControllerData> m_motors;
    };
 
    class MAxisLcsIf : public ifw::fcf::devmgr::common::DeviceLcsIf {
 
     // enumerations for MAxis status
      enum {
        STAT_LOCAL       = 100,
        STAT_ERROR       = 101,
        STAT_STATE       = 102,
        STAT_SUBSTATE    = 103
      };
 
    public:
       MAxisLcsIf(std::shared_ptr<ifw::fcf::devmgr::common::IDeviceConfig> config,
                ifw::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 MoveAxesByName(std::string namedpos);
 
       void MoveAxes(const std::vector<double>& positions);
 
       bool IsMoving() const;
 
       bool IsInPosition(const std::string& axis_name) const;
       
       bool AreAllInPosition() const;
 
       bool IsStandstill() const;
 
 
 
      void ReadConfig();
 
      virtual void ReadStatus(MAxisControllerData& status);
 
      void Listener(ifw::core::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);
      
      void UpdateTargetPositions(const std::vector<double>& positions);
 
      virtual void AddCustomAttributes();
 
    protected:
 
      void LoadConfig();
 
      void StoreMotorPosition(const std::string nodeid_prefix,
                           const ifw::core::protocol::base::Variant& value,
                           int  attribute);
 
      void StoreMotorAttribute(const std::string nodeid_prefix,
                           const ifw::core::protocol::base::Variant& value,
                           int  attribute);
 
      void MovePos(int axis_id, double position, double velocity,
                   std::string move_type=ifw::fcf::devmgr::motor::RPC_MOVE_ABS);
 
      std::pair<std::string, std::string> GetObjectInfo(const std::string& map_value) const;
 
    private:
       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