adcConfig.hpp

Go to the documentation of this file.

#ifndef FCF_DEVMGR_DEVICE_ADC_CONFIG_HPP
#define FCF_DEVMGR_DEVICE_ADC_CONFIG_HPP

#include <string>
#include <yaml-cpp/yaml.h>
#include "fcf/common/iComm.hpp"

#include "fcf/devmgr/common/configSet.hpp"
#include "fcf/devmgr/common/dataContext.hpp"
#include "fcf/devmgr/devices/motorConfig.hpp"
#include "fcf/devmgr/devices/adcRpcErrors.hpp"
#include "fcf/devmgr/devices/adcHwErrors.hpp"

namespace fcf {
  namespace devmgr {
    namespace adc {

      // Constants for internal mapping
      // Specifics Adc status values
      constexpr auto CI_MOTOR_MAP_FILE    = "mapMotorFile";

      constexpr auto CI_AXES              = "axes";
      constexpr auto CI_FOCUS_SIGN        = "focus_sign";
      constexpr auto CI_DIR_SIGN          = "dir_sign";
      constexpr auto CI_STAT_REF          = "off_ref";
      constexpr auto CI_STAT_AUTO         = "auto_ref";

      constexpr auto CI_LATITUDE          = "latitude";
      constexpr auto CI_LONGITUDE         = "longitude";
      constexpr auto CI_TRK_PERIOD        = "trk_period";
      constexpr auto CI_TRK_THRESHOLD     = "trk_threshold";

      constexpr auto CI_PSLOPE            = "pslope";
      constexpr auto CI_POFFSET           = "poffset";
      constexpr auto CI_TSLOPE            = "tslope";
      constexpr auto CI_TOFFSET           = "toffset";
      constexpr auto CI_AFACTOR           = "afactor";
      constexpr auto CI_ZDLIMIT           = "zdlimit";
      constexpr auto CI_MINELEV           = "minelev";

      constexpr auto CI_MOT1_SIGN_OFF     = "mot1_signoff";
      constexpr auto CI_MOT2_SIGN_OFF     = "mot2_signoff";
      constexpr auto CI_MOT1_SIGN_AUTO    = "mot1_signauto";
      constexpr auto CI_MOT2_SIGN_AUTO    = "mot2_signauto";
      constexpr auto CI_MOT1_SIGN_PHI     = "mot1_signphi";
      constexpr auto CI_MOT2_SIGN_PHI     = "mot2_signphi";
      constexpr auto CI_MOT1_REF_OFF      = "mot1_refoff";
      constexpr auto CI_MOT2_REF_OFF      = "mot2_refoff";
      constexpr auto CI_MOT1_REF_AUTO     = "mot1_refauto";
      constexpr auto CI_MOT2_REF_AUTO     = "mot2_refauto";
      constexpr auto CI_MOT1_COFFSET      = "mot1_coffset";
      constexpr auto CI_MOT2_COFFSET      = "mot2_coffset";
      constexpr auto CI_MOT1_POSOFFSET    = "mot1_poffset";
      constexpr auto CI_MOT2_POSOFFSET    = "mot2_poffset";
      constexpr auto CI_MOT1_DROTFACTOR   = "mot1_drotfactor";
      constexpr auto CI_MOT2_DROTFACTOR   = "mot2_drotfactor";


      // Specific Adc RPC
      constexpr auto RPC_MOVE_ANGLE       = "rpcMoveAngle";
      constexpr auto RPC_START_TRACK      = "rpcStartTrack";
      constexpr auto RPC_STOP_TRACK       = "rpcStopTrack";


      // Specific constant values for Adc device state/substate

      constexpr int SUBSTATE_RESETTING           =  109;
      constexpr int SUBSTATE_ENABLING            =  110;

      constexpr int SUBSTATE_OP_TRACKING         =  220;
      constexpr int SUBSTATE_OP_PRESETTING       =  221;

      constexpr auto SUBSTATE_RESETTING_STR        =  "Resetting";
      constexpr auto SUBSTATE_ENABLING_STR         =  "Enabling";
      constexpr auto SUBSTATE_OP_TRACKING_STR      =  "Tracking";
      constexpr auto SUBSTATE_OP_PRESETTING_STR    =  "Presetting";



      const std::unordered_map<short, std::string>  SubstateMap = {
        {fcf::devmgr::common::SUBSTATE_NOTREADY,       fcf::devmgr::common::SUBSTATE_NOTREADY_STR},
        {SUBSTATE_RESETTING,      SUBSTATE_RESETTING_STR},
        {fcf::devmgr::common::SUBSTATE_INITIALISING,   fcf::devmgr::common::SUBSTATE_INITIALISING_STR},
        {fcf::devmgr::common::SUBSTATE_READY,          fcf::devmgr::common::SUBSTATE_READY_STR},
        {SUBSTATE_ENABLING,       SUBSTATE_ENABLING_STR},
        {devmgr::motor::SUBSTATE_ABORTING,       fcf::devmgr::motor::SUBSTATE_ABORTING_STR},
        {fcf::devmgr::common::SUBSTATE_ERROR,          fcf::devmgr::common::SUBSTATE_ERROR_STR},
        {fcf::devmgr::common::SUBSTATE_OP_DISABLING,   fcf::devmgr::common::SUBSTATE_OP_DISABLING_STR},
        {devmgr::motor::SUBSTATE_OP_STANDSTILL,  fcf::devmgr::motor::SUBSTATE_OP_STANDSTILL_STR},
        {devmgr::motor::SUBSTATE_OP_MOVING,      fcf::devmgr::motor::SUBSTATE_OP_MOVING_STR},
        {SUBSTATE_OP_TRACKING,    SUBSTATE_OP_TRACKING_STR},
        {SUBSTATE_OP_PRESETTING,    SUBSTATE_OP_PRESETTING_STR},
        {devmgr::motor::SUBSTATE_OP_STOPPING,    fcf::devmgr::motor::SUBSTATE_OP_STOPPING_STR},
        {fcf::devmgr::common::SUBSTATE_OP_ERROR,     fcf::devmgr::common::SUBSTATE_OP_ERROR_STR},
      };

      constexpr short TRK_MODE_ENG       = 0;
      constexpr short TRK_MODE_OFF       = 1;
      constexpr short TRK_MODE_AUTO      = 2;


      constexpr auto TRK_MODE_ENG_STR      = "eng";
      constexpr auto TRK_MODE_OFF_STR      = "off";
      constexpr auto TRK_MODE_AUTO_STR     = "auto";


      const std::unordered_map<short, std::string>  TrkModeMap = {
        {TRK_MODE_ENG,       TRK_MODE_ENG_STR},
        {TRK_MODE_OFF,       TRK_MODE_OFF_STR},
        {TRK_MODE_AUTO,      TRK_MODE_AUTO_STR},
      };

      constexpr auto CI_STAT_TRACK_MODE              = "track_mode";
      constexpr auto CI_STAT_ALPHA                   = "alpha";
      constexpr auto CI_STAT_DELTA                   = "delta";


      const std::vector<std::string> cfgMapping = {
      };

      const std::vector<std::string> statMapping = {
        fcf::devmgr::common::CI_STAT_SUBSTATE,
        fcf::devmgr::common::CI_STAT_STATE,
        fcf::devmgr::common::CI_STAT_LOCAL,
        CI_STAT_TRACK_MODE,
        CI_STAT_ALPHA,
        CI_STAT_DELTA
      };

      const std::vector<std::string> rpcMapping = {
        fcf::devmgr::common::RPC_INIT,
        fcf::devmgr::common::RPC_ENABLE,
        fcf::devmgr::common::RPC_DISABLE,
        fcf::devmgr::common::RPC_RESET,
        fcf::devmgr::common::RPC_STOP,
        RPC_MOVE_ANGLE,
        RPC_START_TRACK,
        RPC_STOP_TRACK
      };

      class AdcConfig : public fcf::devmgr::common::DeviceConfig
      {

        // Enumerations of configuration paramters:
        // C++ doesn not allow inheritance of enums so we are using the last
        // enum of the parent class to continue with the enumerations and thus
        // avoid the collission.
        enum {
          CFG_PSLOPE,
          CFG_POFFSET,
          CFG_TSLOPE,
          CFG_TOFFSET,
          CFG_AFACTOR,
          CFG_ZDLIMIT,
          CFG_MINELEV,
          CFG_MOT1_SIGN_OFF,
          CFG_MOT2_SIGN_OFF,
          CFG_MOT1_SIGN_AUTO,
          CFG_MOT2_SIGN_AUTO,
          CFG_MOT1_SIGN_PHI,
          CFG_MOT2_SIGN_PHI,
          CFG_MOT1_REF_OFF,
          CFG_MOT2_REF_OFF,
          CFG_MOT1_REF_AUTO,
          CFG_MOT2_REF_AUTO,
          CFG_MOT1_COFFSET,
          CFG_MOT2_COFFSET,
          CFG_MOT1_POSOFFSET,
          CFG_MOT2_POSOFFSET,
          CFG_MOT1_DROTFACTOR,
          CFG_MOT2_DROTFACTOR,
          CFG_LATITUDE,
          CFG_LONGITUDE,
          CFG_TRK_PERIOD,
          CFG_TRK_THRESHOLD,
          END_ENUM_ADC // WARNING: This should be always last enumerator.
        };


      public:

        AdcConfig(const std::string filename,
                  const std::string name);

        virtual ~AdcConfig();

        virtual void ReadConfig();

        virtual void GetConfig(fcf::common::VectorVariant& params);


        virtual void GetMotorConfig(fcf::common::VectorVariant& params);

        virtual void GetMotorConfig(const std::string motor, fcf::common::VectorVariant& params);

        virtual void SetScaleFactor(const std::string motor, double scale_factor);



        virtual void GetConfigList(std::vector<std::string>& cfg_list,
                                   std::string prefix);


        virtual std::string  GetMotorMapFile();

        virtual std::string  GetMotorType();

        virtual std::string  GetMotorPrefix(const std::string motor);

        void GetMotorNames(std::vector<std::string>& motor_names);

        void GetMotorPrefixes(std::vector<std::string>& motor_prefixes);

        double GetMotorVelocity(const int axis_num);

        double GetMotorScaleFactor(const int axis_num);

        double GetMotorScaleFactor(const std::string motor_name);

        std::string GetMotorName(const std::string nodeid);

      protected:
        // All configuration parameters related to the LCS are stored in
        // dedicated STL maps to make them easilly accessible when downloading
        // the configuration to the LCS.
        devmgr::common::MapCfgBool   m_map_cfg_bool;
        devmgr::common::MapCfgInt    m_map_cfg_int;
        devmgr::common::MapCfgUInt   m_map_cfg_uint;
        devmgr::common::MapCfgDouble m_map_cfg_double;

        int                          m_num_axis;



        std::map<std::string, std::unique_ptr<devmgr::motor::MotorConfig>> m_motor_config_map;

        std::map<std::string, std::string> m_motor_prefix_map;

      };
    }
  }
}

#endif //FCF_DEVMGR_DEVICE_ADC_CONFIG_H