motorConfig.hpp

Go to the documentation of this file.

 
#ifndef FCF_DEVMGR_DEVICE_MOTOR_CONFIG_HPP
#define FCF_DEVMGR_DEVICE_MOTOR_CONFIG_HPP
 
#include <string>
#include <unordered_map>
 
#include <yaml-cpp/yaml.h>
 
#include <ifw/core/utils/bat/logger.hpp>
 
#include <ifw/fcf/devmgr/common/dataContext.hpp>
#include <ifw/fcf/devmgr/devices/motorBaseConfig.hpp>
#include <ifw/fcf/devmgr/devices/motorRpcErrors.hpp>
#include <ifw/fcf/devmgr/devices/motorHwErrors.hpp>
 
 
namespace ifw::fcf::devmgr::motor {
 
  constexpr auto LOGGER_NAME = "motor";
 
  // Constants for internal mapping
  constexpr auto CI_BRAKE                 = "brake";
  constexpr auto CI_BACKLASH              = "backlash";
  constexpr auto CI_AXIS_TYPE             = "axis_type";
 
  constexpr auto CI_CHECK_INPOS           = "check_inpos";
  constexpr auto CI_LOCK                  = "lock";
  constexpr auto CI_LOCK_POS              = "lock_pos";
  constexpr auto CI_LOCK_TOLERANCE        = "lock_tolerance";
  constexpr auto CI_DISABLE               = "disable";
 
  constexpr auto CI_ACTIVE_LOW_BRAKE      = "low_brake";
  constexpr auto CI_ACTIVE_LOW_INPOS      = "low_inpos";
  constexpr auto CI_ACTIVE_LOW_STOP       = "active_low_lstop";
  constexpr auto CI_ACTIVE_LOW_LHW        = "active_low_lhw";
  constexpr auto CI_ACTIVE_LOW_REF        = "active_low_ref";
  constexpr auto CI_ACTIVE_LOW_INDEX      = "active_low_index";
  constexpr auto CI_ACTIVE_LOW_UHW        = "active_low_uhw";
  constexpr auto CI_ACTIVE_LOW_USTOP      = "active_low_ustop";
 
  constexpr auto CI_EXEC_PRE_INIT         = "exec_pre_init";
  constexpr auto CI_EXEC_POST_INIT        = "exec_post_init";
  constexpr auto CI_EXEC_PRE_MOVE         = "exec_pre_move";
  constexpr auto CI_EXEC_POST_MOVE        = "exec_post_move";
 
  constexpr auto CI_INITIALISATION        = "initialisation";
  constexpr auto CI_INIT_SEQUENCE         = "sequence";
  constexpr auto CI_INIT_ACTION           = "step";
  constexpr auto CI_INIT_VALUE_1          = "value1";
  constexpr auto CI_INIT_VALUE_2          = "value2";
 
 
  // WS configuration keywords
  // These configuration only matters for WS level
 
  constexpr int CI_AXIS_TYPE_LINEAR              = 1;
  constexpr int CI_AXIS_TYPE_CIRCULAR            = 2;
  constexpr int CI_AXIS_TYPE_CIRCULAR_OPT        = 3;
 
  constexpr auto CI_AXIS_TYPE_LINEAR_STR         = "LINEAR";
  constexpr auto CI_AXIS_TYPE_CIRCULAR_STR       = "CIRCULAR";
  constexpr auto CI_AXIS_TYPE_CIRCULAR_OPT_STR   = "CIRCULAR_OPT";
 
  constexpr int CI_AXIS_MODE_INPOS               = 0;
  constexpr int CI_AXIS_MODE_INVEL               = 1;
 
  constexpr auto CI_AXIS_MODE_INPOS_STR   = "InPosition";
  constexpr auto CI_AXIS_MODE_INVEL_STR   = "InVelocity";
 
  const std::unordered_map<int, std::string>  AXIS_MODE_MAP = {
    {CI_AXIS_MODE_INPOS, CI_AXIS_MODE_INPOS_STR},
    {CI_AXIS_MODE_INVEL, CI_AXIS_MODE_INVEL_STR}
  };
 
  constexpr int CI_MAX_INIT_STEPS                     = 10;
 
  constexpr auto CI_INIT_ACTION_END            = "END";
  constexpr auto CI_INIT_ACTION_FIND_INDEX     = "FIND_INDEX";
  constexpr auto CI_INIT_ACTION_FIND_REF_LE    = "FIND_REF_LE";
  constexpr auto CI_INIT_ACTION_FIND_REF_UE    = "FIND_REF_UE";
  constexpr auto CI_INIT_ACTION_FIND_LHW       = "FIND_LHW";
  constexpr auto CI_INIT_ACTION_FIND_UHW       = "FIND_UHW";
  constexpr auto CI_INIT_ACTION_DELAY          = "DELAY";
  constexpr auto CI_INIT_ACTION_MOVE_ABS       = "MOVE_ABS";
  constexpr auto CI_INIT_ACTION_MOVE_REL       = "MOVE_REL";
  constexpr auto CI_INIT_ACTION_CALIB_ABS      = "CALIB_ABS";
  constexpr auto CI_INIT_ACTION_CALIB_REL      = "CALIB_REL";
  constexpr auto CI_INIT_ACTION_CALIB_SWITCH   = "CALIB_SWITCH";
 
 
  // encoders are used only at the WS level
 
  constexpr auto CI_STAT_SCALE_FACTOR         = "scale_factor";
  constexpr auto CI_STAT_BACKLASH_STEP        = "backlash_step";
  constexpr auto CI_STAT_MODE                 = "mode";
  constexpr auto CI_STAT_INIT_STEP            = "init_step";
  constexpr auto CI_STAT_INIT_ACTION          = "init_action";
  constexpr auto CI_STAT_AXIS_READY           = "axis_ready";
  constexpr auto CI_STAT_AXIS_ENABLE          = "axis_enable";
  constexpr auto CI_STAT_AXIS_INPOS           = "axis_inposition";
  constexpr auto CI_STAT_AXIS_LOCK            = "axis_lock";
  constexpr auto CI_STAT_AXIS_BRAKE           = "axis_brake";
  constexpr auto CI_STAT_AXIS_STOP_NEG        = "axis_stop_pos";
  constexpr auto CI_STAT_AXIS_STOP_POS        = "axis_stop_neg";
  constexpr auto CI_STAT_AXIS_INFO_DATA_1     = "axis_info_data1";
  constexpr auto CI_STAT_AXIS_INFO_DATA_2     = "axis_info_data2";
 
  constexpr auto CI_STAT_SIGNAL_LSTOP         = "signal_lstop";
  constexpr auto CI_STAT_SIGNAL_LHW           = "signal_lhw";
  constexpr auto CI_STAT_SIGNAL_REF           = "signal_ref";
  constexpr auto CI_STAT_SIGNAL_INDEX         = "signal_index";
  constexpr auto CI_STAT_SIGNAL_UHW           = "signal_uhw";
  constexpr auto CI_STAT_SIGNAL_USTOP         = "signal_ustop";
 
  enum class Signal : short {LSTOP = 0,
                             LHW   = 1,
                             REF   = 2,
                             INDEX = 3,
                             UHW   = 4,
                             USTOP = 5};
 
  constexpr auto FITS_PARAM_BRAKE        = "BRAKE";
  constexpr auto FITS_PARAM_LOCK         = "LOCK";
 
  // Map of Axis type to do the converstion between strings to numbers
  const std::unordered_map<std::string, int> AXIS_TYPE_MAP = {
    {CI_AXIS_TYPE_LINEAR_STR,       CI_AXIS_TYPE_LINEAR},
    {CI_AXIS_TYPE_CIRCULAR_STR,     CI_AXIS_TYPE_CIRCULAR},
    {CI_AXIS_TYPE_CIRCULAR_OPT_STR,  CI_AXIS_TYPE_CIRCULAR_OPT}
  };
 
  enum {
    INIT_ACTION_END          = 0,
    INIT_ACTION_FIND_INDEX   = 1,
    INIT_ACTION_FIND_REF_LE  = 2,
    INIT_ACTION_FIND_REF_UE  = 3,
    INIT_ACTION_FIND_LHW     = 4,
    INIT_ACTION_FIND_UHW     = 5,
    INIT_ACTION_DELAY        = 6,
    INIT_ACTION_MOVE_ABS     = 7,
    INIT_ACTION_MOVE_REL     = 8,
    INIT_ACTION_CALIB_ABS    = 9,
    INIT_ACTION_CALIB_REL    = 10,
    INIT_ACTION_CALIB_SWITCH = 11
  };
 
  // @TODO: replaced by boost bimaps
  // Tried with boost bimap but I've got hundred of errors.
  // I added temporaly two maps.
 
  // Map of motor initialisation steps
  const std::unordered_map<std::string, int> INIT_ACTIONS_MAP= {
    {CI_INIT_ACTION_END,        INIT_ACTION_END},
    {CI_INIT_ACTION_FIND_INDEX,  INIT_ACTION_FIND_INDEX},
    {CI_INIT_ACTION_FIND_REF_LE,  INIT_ACTION_FIND_REF_LE},
    {CI_INIT_ACTION_FIND_REF_UE,  INIT_ACTION_FIND_REF_UE},
    {CI_INIT_ACTION_FIND_LHW,    INIT_ACTION_FIND_LHW},
    {CI_INIT_ACTION_FIND_UHW,    INIT_ACTION_FIND_UHW},
    {CI_INIT_ACTION_DELAY,      INIT_ACTION_DELAY},
    {CI_INIT_ACTION_MOVE_ABS,    INIT_ACTION_MOVE_ABS},
    {CI_INIT_ACTION_MOVE_REL,    INIT_ACTION_MOVE_REL},
    {CI_INIT_ACTION_CALIB_ABS,   INIT_ACTION_CALIB_ABS},
    {CI_INIT_ACTION_CALIB_REL,   INIT_ACTION_CALIB_REL},
    {CI_INIT_ACTION_CALIB_SWITCH,INIT_ACTION_CALIB_SWITCH}
  };
 
  // Map of motor initialisation steps
  const std::unordered_map<int, std::string> INIT_ACTIONS2_MAP= {
    {INIT_ACTION_END,         CI_INIT_ACTION_END},
    {INIT_ACTION_FIND_INDEX,  CI_INIT_ACTION_FIND_INDEX},
    {INIT_ACTION_FIND_REF_LE, CI_INIT_ACTION_FIND_REF_LE},
    {INIT_ACTION_FIND_REF_UE, CI_INIT_ACTION_FIND_REF_UE},
    {INIT_ACTION_FIND_LHW,    CI_INIT_ACTION_FIND_LHW},
    {INIT_ACTION_FIND_UHW,    CI_INIT_ACTION_FIND_UHW},
    {INIT_ACTION_DELAY,       CI_INIT_ACTION_DELAY},
    {INIT_ACTION_MOVE_ABS,    CI_INIT_ACTION_MOVE_ABS},
    {INIT_ACTION_MOVE_REL,    CI_INIT_ACTION_MOVE_REL},
    {INIT_ACTION_CALIB_ABS,   CI_INIT_ACTION_CALIB_ABS},
    {INIT_ACTION_CALIB_REL,   CI_INIT_ACTION_CALIB_REL},
    {INIT_ACTION_CALIB_SWITCH, CI_INIT_ACTION_CALIB_SWITCH}
  };
 
  struct InitAction {
 
 
    InitAction():m_id(0), m_value1(0.0), m_value2(0.0) {}
    int GetId() const;
    void SetId(int id);
    double GetValue1() const;
    void SetValue1(double value);
    double GetValue2() const;
    void SetValue2(double value);
 
   private:
    int m_id;
    double m_value1;
    double m_value2;
  };
 
  class Sensor;
  class MotorConfig : public ifw::fcf::devmgr::motor::MotorBaseConfig
  {
    friend class Sensor;
 
 
  public:
    MotorConfig(const std::string filename,
                const std::string name);
 
    MotorConfig(const std::string name);
 
    virtual ~MotorConfig() = default;
 
 
    void Init();
    virtual void GetConfig(ifw::core::protocol::base::VectorVariant& params) const override;
 
 
    virtual void GetConfigList(ifw::core::utils::bat::DbVector& cfg_list,
                               std::string prefix) const override;
 
 
    inline int GetNumberOfInitSteps() const noexcept {return m_init_sequence.size();};
 
 
    double GetScaleFactor() const override;
 
    void SetScaleFactor(double scale);
 
  private:
    // Map of motor init step to do the conversion between strings to numbers
    std::vector<InitAction> m_init_sequence;
    double m_scale_factor{1.0};
 
  private:
 
    log4cplus::Logger  m_logger;
 
  };
 
}
 
 
#endif //FCF_DEVMGR_DEVICE_MOTOR_CONFIG_H