sensorLcsIf.hpp

Go to the documentation of this file.

 
#ifndef FCF_DEVMGR_DEVICE_SENSOR_LCSIF_HPP
#define FCF_DEVMGR_DEVICE_SENSOR_LCSIF_HPP
 
// System headers
#include <unordered_map>
 
// Third party headers
#include <yaml-cpp/yaml.h>
 
#include <fcf/devmgr/common/deviceLcsIf.hpp>
#include <fcf/devmgr/devices/sensorConfig.hpp>
#include <fcf/devmgr/common/dataContext.hpp>
 
#include <Fcfif.hpp>
#include <rad/mal/publisher.hpp>
 
 
namespace fcf::devmgr::sensor {
 
  struct ChannelData {
    ChannelData();
    virtual ~ChannelData();
 
 
    void GetValue(bool& value) const;
    void GetValue(double& value) const;
    void GetValue(int& value) const;
    fcf::common::Variant GetRawValue() const;
 
    void SetValue(const fcf::common::Variant value);
    friend std::ostream& operator<<(std::ostream& dest, const ChannelData& obj);
 
  protected:
 
    fcf::common::Variant m_value;
  };
 
  struct SensorControllerData : fcf::devmgr::common::DeviceControllerData {
  public:
    SensorControllerData();
    virtual ~SensorControllerData();
 
    inline std::string GetErrorText() const;
    inline virtual std::string GetSubstateStr() const;
 
    inline void ClearChannelValues();
    inline void SetChannelValue(std::string channel,
                                fcf::common::Variant value);
    inline void GetChannelValue(std::string channel,
                                ChannelData& data);
 
 
    void SetData(const SensorControllerData& data);
 
    //friend class SensorLcsIf<TOPIC_TYPE>;
  protected:
    std::unordered_map<std::string, ChannelData> m_values;
  };
 
 
  template<typename TOPIC_TYPE = fcfif::SensorTopicUnion>
  class SensorLcsIf : public fcf::devmgr::common::DeviceLcsIf {
    // enumerations for the Sensor status
 
    enum {
      STAT_LOCAL       = 1,
      STAT_ERROR       = 2,
      STAT_STATE       = 3,
      STAT_SUBSTATE    = 4,
      STAT_CHANNEL     = 5,
    };
 
  public:
    SensorLcsIf(std::shared_ptr<fcf::devmgr::common::IDeviceConfig> config,
                fcf::devmgr::common::DataContext& data_ctx, bool initialise = true);
 
    virtual ~SensorLcsIf() {};
 
    virtual bool IsReady();
 
    virtual bool IsNotReady();
 
    virtual bool IsOperational();
 
    bool IsHwFailure();
 
    virtual void ReadStatus(SensorControllerData& status,
                            bool force_read = true);
 
    void StartMonitoring();
 
    void StopMonitoring();
 
    void Listener(fcf::common::VectorVariant& params);
 
    virtual std::string GetRpcError(const short error_code) const;
 
 
  private:
 
    void PublishState(const fcf::common::Variant& value);
 
    void PublishSubstate(const fcf::common::Variant& value);
 
    void PublishError(const fcf::common::Variant& value);
 
    void PublishChannel(const std::string channel,
                        const fcf::common::Variant& value);
 
 
  protected:
 
 
    std::unordered_map<std::string, std::string> m_channels_map;
    std::unordered_map<std::string, ChannelData> m_channel_values;
    std::unique_ptr<rad::cii::Publisher<TOPIC_TYPE>> m_publisher;
 
  private:
 
 
 
  };
}
 
#include "sensorLcsIf.ipp"
 
#endif //FCF_DEVMGR_DEVICE_SENSOR_LCSIF_HPP