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);

    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