sensorConfig.hpp

Go to the documentation of this file.

 
#ifndef FCF_DEVMGR_DEVICE_SENSOR_CONFIG_HPP
#define FCF_DEVMGR_DEVICE_SENSOR_CONFIG_HPP
 
// System headers
#include <string>
 
// Third party headers
#include <yaml-cpp/yaml.h>
 
#include <fcf/common/iComm.hpp>
#include <fcf/devmgr/common/deviceConfig.hpp>
#include <fcf/devmgr/common/configSet.hpp>
#include <fcf/devmgr/common/dataContext.hpp>
#include <fcf/devmgr/devices/sensorRpcErrors.hpp>
#include <fcf/devmgr/devices/sensorHwErrors.hpp>
 
namespace fcf::devmgr::sensor {
 
  constexpr auto CI_READONLY       = "readonly";
 
  // Constants for internal mapping
  constexpr auto CI_CHANNELS       = "channels";
  constexpr auto CI_DESCRIPTION    = "description";
  constexpr auto CI_ALIAS          = "alias";
  constexpr auto CI_TYPE           = "type";
  constexpr auto CI_HEADER         = "header";
  constexpr auto CI_LOG            = "log";
  constexpr auto CI_UNIT           = "unit";
  constexpr auto CI_MAP            = "map";
 
  // Specifics Sensor status values
 
  // Specific Sensor RPC
  
  // Specific constant values for Sensor device state/substate
  constexpr int SUBSTATE_OP_MONITORING      =  200;
  constexpr auto SUBSTATE_OP_MONITORING_STR = "Monitoring";
 
  const std::unordered_map<short, std::string>  SubstateMap = {
    {fcf::devmgr::common::SUBSTATE_NOTREADY,      fcf::devmgr::common::SUBSTATE_NOTREADY_STR},
    {fcf::devmgr::common::SUBSTATE_READY,         fcf::devmgr::common::SUBSTATE_READY_STR},
    {fcf::devmgr::common::SUBSTATE_ERROR,         fcf::devmgr::common::SUBSTATE_ERROR_STR},
    {SUBSTATE_OP_MONITORING,                 SUBSTATE_OP_MONITORING_STR},
    {fcf::devmgr::common::SUBSTATE_OP_ERROR,      fcf::devmgr::common::SUBSTATE_OP_ERROR_STR},
  };
 
  constexpr auto DI_TYPE_STR = "DI";
  constexpr auto AI_TYPE_STR = "AI";
  constexpr auto II_TYPE_STR = "II";
  constexpr auto SI_TYPE_STR = "SI";
 
  constexpr auto DI_CAT_STR = "diChannels";
  constexpr auto AI_CAT_STR = "aiChannels";
  constexpr auto II_CAT_STR = "iiChannels";
  constexpr auto SI_CAT_STR = "siChannels";
 
 
  const std::unordered_map<std::string, std::string> ChannelTypeMap = {
    {DI_TYPE_STR, DI_CAT_STR},
    {AI_TYPE_STR, AI_CAT_STR},
    {II_TYPE_STR, II_CAT_STR},
    {SI_TYPE_STR, SI_CAT_STR},
  };
 
  const std::vector<std::string> cfgMapping = {
  };
 
  const std::vector<std::string> statMapping = {
    fcf::devmgr::common::CI_STAT_SUBSTATE,
    fcf::devmgr::common::CI_STAT_STATE
  };
 
  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
  };
 
  struct Channel {
  public:
    Channel();
    virtual ~Channel();
 
    inline std::string GetDescription() const;
    inline std::string GetAlias() const;
    inline std::string GetType() const;
    inline bool        GetHeaderFlag() const;
    inline bool        GetLogFlag() const;
    inline std::string GetUnit() const;
    inline std::string GetMap() const;
    inline std::string GetCat() const;
    inline std::string GetFitsPrefix() const;
 
    inline void SetDescription(std::string description);
    inline void SetAlias(std::string alias);
    inline void SetType(std::string type);
    inline void SetHeaderFlag(bool flag);
    inline void SetLogFlag(bool flag);
    inline void SetUnit(std::string unit);
    inline void SetMap(std::string map);
    inline void SetFitsPrefix(std::string prefix);
 
  protected:
    std::string m_description;
    std::string m_alias;
    std::string m_type;
    bool        m_header;
    bool        m_log;
    std::string m_unit;
    std::string m_map;
    std::string m_prefix;
  };
 
  class Sensor;
  class SensorConfig : public fcf::devmgr::common::DeviceConfig
  {
 
    friend class Sensor;
    template<typename TOPIC_TYPE>
    friend class SensorLcsIf;
 
    // Enumerations of configuration paramters
    enum {
 
      END_ENUM_SENSOR // WARNING: This should be always last enumerator.
    };
 
 
  public:
 
    SensorConfig(const std::string filename,
                 const std::string name);
 
    SensorConfig(const std::string name);
 
    virtual ~SensorConfig();
 
    virtual void ReadConfig();
 
    virtual void GetConfig(fcf::common::VectorVariant& params);
 
    virtual void GetConfigList(std::vector<std::string>& cfg_list,
                               std::string prefix);
 
    virtual void GetChannelList(std::vector<std::string>& channel_list);
 
    bool IsReadOnly();
 
  private:
    bool                m_readonly;
    // Map of motor named positions
    std::map<std::string, Channel> m_channel_map;
  };
 
}
 
#include "sensorConfig.ipp"
#endif //FCF_DEVMGR_DEVICE_SENSOR_CONFIG_H