sensorConfig.hpp

Go to the documentation of this file.

#ifndef DEVMGR_DEVICE_SENSOR_CONFIG_HPP
#define DEVMGR_DEVICE_SENSOR_CONFIG_HPP

// System headers
#include <string>

// Third party headers
#include <yaml-cpp/yaml.h>

#include <fcf/common/iComm.hpp>
#include <devmgr/common/deviceConfig.hpp>
#include <devmgr/common/configSet.hpp>
#include <devmgr/common/dataContext.hpp>
#include <devmgr/devices/sensorRpcErrors.hpp>
#include <devmgr/devices/sensorHwErrors.hpp>

namespace devmgr {
  namespace sensor {

    // Constants for internal mapping
    const std::string CI_CHANNELS       = "channels";
    const std::string CI_DESCRIPTION    = "description";
    const std::string CI_TYPE           = "type";
    const std::string CI_HEADER         = "header";
    const std::string CI_LOG            = "log";
    const std::string CI_UNIT           = "unit";
    const std::string CI_MAP            = "map";

    // Specifics Sensor status values

    // Specific Sensor RPC
  


    // Specific constant values for Sensor device state/substate
    const short SUBSTATE_NOTREADY             =  100;
    const short SUBSTATE_READY                =  101;
    const short SUBSTATE_STANDBY_FAILURE      =  102;

    const short SUBSTATE_OP_MONITORING        =  200;
    const short SUBSTATE_OP_FAILURE           =  201;

    const std::string SUBSTATE_NOTREADY_STR   =  "NotReady";
    const std::string SUBSTATE_READY_STR      =  "Ready";
    const std::string SUBSTATE_FAILURE_STR    =  "Failure";

    const std::string SUBSTATE_OP_MONITORING_STR = "Monitoring";
    
    const std::unordered_map<short, std::string>  SubstateMap = {
      {SUBSTATE_NOTREADY,      SUBSTATE_NOTREADY_STR},
      {SUBSTATE_READY,         SUBSTATE_READY_STR},
      {SUBSTATE_STANDBY_FAILURE, SUBSTATE_FAILURE_STR},
      {SUBSTATE_OP_MONITORING, SUBSTATE_OP_MONITORING_STR},
      {SUBSTATE_OP_FAILURE,    SUBSTATE_FAILURE_STR},
    };

    const std::string DI_TYPE_STR = "DI";
    const std::string AI_TYPE_STR = "AI";
    const std::string II_TYPE_STR = "II";
    const std::string SI_TYPE_STR = "SI";

    const std::string DI_CAT_STR = "diChannels";
    const std::string AI_CAT_STR = "aiChannels";
    const std::string II_CAT_STR = "iiChannels";
    const std::string 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 = {
      devmgr::common::CI_STAT_SUBSTATE,
      devmgr::common::CI_STAT_STATE
    };

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

    struct Channel {
    public:
      Channel();
      virtual ~Channel();

      inline std::string GetDescription() 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 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_type;
      bool        m_header;
      bool        m_log;
      std::string m_unit;
      std::string m_map;
      std::string m_prefix;
    };

    class Sensor;
    class SensorConfig : public devmgr::common::DeviceConfig
    {

      friend class Sensor;
      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 std::string  GetMapFile();

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

      virtual void GetChannelList(std::vector<std::string>& channel_list);


    private:
      // Map of motor named positions
      std::unordered_map<std::string, Channel> m_channel_map;
    };
  }
}

#include "sensorConfig.inline"
#endif //DEVMGR_DEVICE_SENSOR_CONFIG_H