iodevLcsIf.hpp

Go to the documentation of this file.

 
#ifndef FCF_DEVMGR_DEVICE_IODEV_LCSIF_HPP
#define FCF_DEVMGR_DEVICE_IODEV_LCSIF_HPP
 
#include <unordered_map>
 
#include <yaml-cpp/yaml.h>
 
#include <ifw/fcf/devmgr/common/deviceLcsIf.hpp>
#include <ifw/fcf/devmgr/devices/iodevConfig.hpp>
#include <ifw/fcf/devmgr/common/dataContext.hpp>
 
#include <Fcfif.hpp>
#include <rad/mal/publisher.hpp>
 
 
namespace ifw::fcf::devmgr::iodev {
 
   template <typename T>
   constexpr bool is_supported_scalar_v =
       std::is_same_v<T, bool> ||
       std::is_same_v<T, int> ||
       std::is_same_v<T, unsigned int> ||
       std::is_same_v<T, short> ||
       std::is_same_v<T, double> ||
       std::is_same_v<T, float> ||
       std::is_same_v<T, uint8_t>;

   struct IODevData
   {
      IODevData();
      virtual ~IODevData();
 
      void GetValue(bool &value) const;
      void GetValue(double &value) const;
      void GetValue(int &value) const;
      std::string GetNamedValue() const;
      void SetValue(const bool &value);
      void SetValue(const double &value);
      void SetValue(const int &value);
      void SetNamedValue(const std::string &value);
 
      ifw::fnd::defs::Value GetRawValue() const;
      void SetRawValue(const ifw::fnd::defs::Value &value);
      friend std::ostream &operator<<(std::ostream &dest, const IODevData &obj);
 
   private:
      ifw::fnd::defs::Value m_value;
      std::string m_named_value;
   };

 
 
  struct IODevControllerData : fcf::devmgr::common::DeviceControllerData  {
  public:
    IODevControllerData();
    virtual ~IODevControllerData();
 
    inline std::string GetErrorText() const;
    inline virtual std::string GetSubstateStr() const;
 
    inline void ClearChannelValues();
    inline void SetChannelValue(const std::string& channel,
                                const IODevData& value);
    inline void GetChannelValue(const std::string& channel,
                                IODevData& data) const;
 
 
 
    void SetData(const IODevControllerData& data);
 
 
  private:
    std::unordered_map<std::string, IODevData> m_values;
  };
 

 
  class IODevLcsIf : public ifw::fcf::devmgr::common::DeviceLcsIf {
      // enumerations for the iodev status
   public:
      enum {
        STAT_LOCAL       = 1,
        STAT_ERROR       = 2,
        STAT_STATE       = 3,
        STAT_SUBSTATE    = 4,
        STAT_CHANNEL     = 10,
 
      };
 
  public:
    using ifw::fcf::devmgr::common::DeviceLcsIf::ReadStatus;
    IODevLcsIf(std::shared_ptr<ifw::fcf::devmgr::common::IDeviceConfig> config,
                ifw::fcf::devmgr::common::DataContext& data_ctx);

    virtual ~IODevLcsIf() {};
 

    virtual void InitObject();

    void GetStates(int& state, int& substate) override;

    void Enable() override;

    void Stop() override;

    virtual bool IsReady() const;
 
    virtual bool IsNotReady() const;

    virtual bool IsOperational() const;

    bool IsHwFailure() const;
 
    void WriteOutputs(const std::vector<ifw::fnd::defs::WriteItem>& channel_list);
    void SetOutputs(const std::vector<ifw::fnd::defs::WriteItem>& channel_list);

    void StartMonitoring();

    void StopMonitoring();
 

    virtual void ReadStatus(IODevControllerData& status);
 

    void Listener(const ifw::fnd::defs::Notification& note);

    virtual std::string GetRpcError(const short error_code) const;
 
  private:

    void PublishState(const ifw::fnd::defs::Value& value);

    void PublishSubstate(const ifw::fnd::defs::Value& value);
 
    void PublishError(const ifw::fnd::defs::Value& value);
 
    void PublishChannel(const std::string channel,
                        const ifw::fnd::defs::Value& value);
 
  private:
    std::unordered_map<std::string, std::string> m_channels_map;
    std::unordered_map<std::string, IODevData> m_channel_values;
    log4cplus::Logger  m_logger;
 
  };
}
 
#include "iodevLcsIf.ipp"
 
#endif //FCF_DEVMGR_DEVICE_IODEV_LCSIF_HPP