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 devmgr::motor::MotorControllerData& GetMotor(std::string motor);

      inline void ClearMotors();

      inline void AddMotor(const std::string motor,
                           const 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);

      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 MovePos(int axis_id, double position, double velocity,
                   std::string move_type=devmgr::motor::RPC_MOVE_ABS);

    protected:
       std::vector<std::string> m_monitor_track_vector;

       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