adcLcsIf.hpp

Go to the documentation of this file.

 
#ifndef FCF_DEVMGR_DEVICE_ADC_IF_HPP
#define FCF_DEVMGR_DEVICE_ADC_IF_HPP
 
#include <unordered_map>
 
#include <yaml-cpp/yaml.h>
#include "fcf/devmgr/devices/drotLcsIf.hpp"
#include "fcf/devmgr/devices/adcConfig.hpp"
#include "fcf/devmgr/common/dataContext.hpp"
 
namespace fcf::devmgr::adc {
 
    struct AdcControllerData : fcf::devmgr::common::DeviceControllerData {
    public:
      AdcControllerData();
      virtual ~AdcControllerData();
 
      void SetData(const AdcControllerData& data);
 
      inline virtual std::string GetErrorText() const;
      inline virtual std::string GetSubstateStr() const;
 
      inline short  GetTrackingMode() const;
      inline std::string GetTrackingModeStr() const;
      inline void SetTrackingMode(short mode);
 
      inline double  GetAlpha() const;
      inline void SetAlpha(double alpha);
 
      inline double  GetDelta() const;
      inline void SetDelta(double delta);
 
      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_alpha {};
      double m_delta {};
 
      std::map<std::string, fcf::devmgr::motor::MotorControllerData> m_motors;
    };
 
 
 
    class AdcLcsIf : public fcf::devmgr::common::DeviceLcsIf {
 
     // enumerations for Adc status
      enum {
        STAT_LOCAL       = 100,
        STAT_ERROR       = 101,
        STAT_STATE       = 102,
        STAT_SUBSTATE    = 103,
        STAT_TRACK_MODE  = 104,
        STAT_ALPHA       = 105,
        STAT_DELTA       = 106
      };
 
    public:
       AdcLcsIf(std::shared_ptr<fcf::devmgr::common::IDeviceConfig> config,
                fcf::devmgr::common::DataContext& data_ctx);
 
       virtual ~AdcLcsIf() {};
 
       virtual void InitObject();
 
       virtual void Init();
 
       void UpdateTargetPosition(int axis_id, double position, std::string move_type);
       void MoveAbs(int axis_id, double position, double velocity);
 
       void MoveRel(int axis_id, double position, double velocity);
 
       void MoveEncAbs(int axis_id, long int encoders);
 
       void MoveEncRel(int axis_id, long int encoders);
       void MoveVel(int axis_id, double velocity);
 
 
 
        void StartTrack(const double& angle);
 
       void StopTrack();
 
       void MoveAngle(const double& angle);
 
       bool IsTracking() const;
 
       bool IsMoving() const;
 
       bool IsInPosition(const int axis = -1) const;
 
       bool IsStandstill() const;
 
 
      void ReadConfig();
 
      std::string GetMotorMapValue(std::string motor, std::string category, std::string key);
 
 
 
 
      virtual void ReadStatus(AdcControllerData& status);
 
      void StartTrackMonitoring();
      void StopTrackMonitoring();
 
      void Listener(protocol::base::VectorVariant& params);
 
      virtual std::string GetRpcError(const short error_code) const;
 
    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);
 
    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;
 
       double m_mot_actual_pos {0.0};
       double m_mot_actual_pos_axis[2] {0.0,0.0};
       double m_alpha {};
       double m_delta {};
       short  m_track_mode {};
 
       std::map<std::string, fcf::devmgr::motor::MotorControllerData> m_motors_status;
 
    private:
      log4cplus::Logger  m_logger;
    };
 
}
 
#include "adcLcsIf.ipp"
 
#endif //FCF_DEVMGR_DEVICE_ADC_IF_HPP