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/motorLcsIf.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 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);
 
      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;
    };
 
 
 
    template<typename TOPIC_TYPE = fcfif::AdcTopicUnion>
    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<AdcConfig> config,
                         fcf::devmgr::common::DataContext& data_ctx);
 
       virtual ~AdcLcsIf() {};
 
       virtual void Init();
 
       void MoveAbs(int axis_id, double position, double velocity);
 
       void MoveRel(int axis_id, double position, double velocity);
 
       void MoveVel(int axis_id, double velocity);
 
       bool IsMoving();
 
       bool IsStandstill();
 
       bool IsTracking();
 
      void ReadConfig();
 
      std::string GetMotorMapValue(std::string motor, std::string category, std::string key);
 
      void MoveAngle(double angle);
 
      void StartTrack(double angle);
 
      void StopTrack();
 
      virtual void ReadStatus(AdcControllerData& status,
                              bool force_read = true);
 
      void StartTrackMonitoring();
 
      void StopMonitoring();
 
      void StopTrackMonitoring();
 
      void Listener(fcf::common::VectorVariant& params);
 
      virtual std::string GetRpcError(const short error_code) const;
 
    protected:
 
      void LoadConfig();
 
    private:
 
      void StoreAttribute(const std::string key,
                          const fcf::common::Variant& value,
                          bool publish,
                          int  attribute);
 
      void PublishPosition(const std::string nodeid_prefix,
                           const fcf::common::Variant& value,
                           int  attribute);
 
      void StoreMotorAttribute(const std::string nodeid_prefix,
                           const fcf::common::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;
 
       double m_alpha {};
       double m_delta {};
       short  m_track_mode {};
 
       std::map<std::string, fcf::devmgr::motor::MotorControllerData> m_motors_status;
 
       std::unordered_map<std::string,
            std::unique_ptr<rad::cii::Publisher<fcfif::MotorPositionTopic>>>  m_motor_publisher_map;
       std::unique_ptr<rad::cii::Publisher<TOPIC_TYPE>> m_publisher;
 
    private:
 
       // This is private reference of configuration object to avoid
       // casting the base one. It is used only for non virtual methods.
       std::shared_ptr<AdcConfig>        m_own_config;
 
       YAML::Node  m_motor_map_node;
    };
 
}
 
#include "adcLcsIf.ipp"
 
#endif //FCF_DEVMGR_DEVICE_ADC_IF_HPP