comAdptBase.hpp

Go to the documentation of this file.

 
#ifndef CCF_COMMON_COM_ADPT_BASE_HPP_H_
#define CCF_COMMON_COM_ADPT_BASE_HPP_H_
 
#include <ifw/core/utils/param/parameter.hpp>
 
#include <ifw/ccf/common/base.hpp>
#include <ifw/ccf/common/dataFrame.hpp>
#include <ifw/ccf/common/nameMapping.hpp>
#include <ifw/ccf/common/config.hpp>
#include <ifw/ccf/common/db.hpp>
 
 
namespace ifw::ccf::common {
 
  enum class TriggerType {
    SIGNAL = 0,
    ABS_TIME = 1,
    CUSTOM = 2,
    NOT_USED = 3
  };
 
  class AcqTrigger {
    public:
      TriggerType    m_trigger_type{TriggerType::NOT_USED};
      double         m_abs_time{0};
      std::string    m_custom_trigger;
      std::string    m_info;
      bool           m_deferred_acq_start_active{false};
  };

  std::string GetHostAddress();

  class ComAdptBase: public Base {
  public:
 
    ComAdptBase();
    virtual ~ComAdptBase();

    const std::string& GetDeviceAddress() const;

    static std::string ResolveHostname(const std::string& address);

    const int16_t GetDeviceWidth() const;

    const int16_t GetDeviceHeight() const;

    const int8_t GetDeviceResolution() const;

    const std::string& GetId() const;

    double GetMaxFrameRate() const;

    void SetHostAdddress(const std::string& host_address);

    virtual const std::string& GetHostAddress();

    void SetIsSimAdapter(const bool is_sim);

    bool GetIsSimAdapter() const;

    const std::string& GetProtocol() const;

    template <class TYPE>
    TYPE GetDeviceProperty(const std::string& property) {
      LOG4CPLUS_TRACE_METHOD(Logger(), __PRETTY_FUNCTION__);
      std::string tmp_value;
      if (HasDeviceProperty(property, tmp_value)) {
        TYPE ret_value;
        ifw::core::utils::conversion::Convert(tmp_value, ret_value);
        return ret_value;
      } else {
        CCFTHROW("Requesting undefined device property: " + property);
      }
    }

    bool HasDeviceProperty(const std::string& property,
                           std::string& value);

    double GetTheoreticFrameRate();

    void Initialise(const bool re_init = false);

    void SetDeviceAddress(const std::string& address);

    void CheckConnection(bool& connected);

    void CheckStatus(ifw::ccf::HwStatus& status,
                     std::string& message);

    bool IsConnected() const;

    void CheckIfConnected() const;
 
    // Connect to the device. If already connected, it will disconnect and reconnect.
    void Connect();

    void AutoConnect(const uint8_t attempts = 5,
                     const double timeout = 10);

    void Disconnect();

    void WriteDeviceProps();

    virtual void WriteDevicePropsUser();

    void WriteDefaultSetup();

    virtual void WriteDefaultSetupUser();

    void SetIsConnected(const bool connected);

    bool GetAllowLostFrames() const;

    uint64_t IncLostFramesCount();
    void     SetLostFramesCount(const int64_t count);

    uint64_t GetLostFramesCount() const;

    uint64_t GetFrameCounter() const;
 
    double GetTimeForLastFrame() const;

    void ResetLostFramesCount();

    void Read(const std::string& name,
              ifw::core::utils::param::Parameter& par);

    void Read(const std::vector<std::string>& names,
              std::vector<ifw::core::utils::param::Parameter>& pars);

    std::string Read(const std::string& name);

    template <class TYPE>
    TYPE Read(const std::string& name) {
      LOG4CPLUS_TRACE_METHOD(Logger(), __PRETTY_FUNCTION__);
      ifw::core::utils::param::Parameter par;
      Read(name, par);
      TYPE native_value;
      ifw::core::utils::conversion::Convert(par.GetValue(), native_value);
      return native_value;
      //return boost::l_exical_cast<TYPE>(par.GetValue());
    }

    void Write(const ifw::core::utils::param::Parameter& par);

    void Write(const std::vector<ifw::core::utils::param::Parameter>& pars);

    template <class TYPE>
    void Write(const std::string& name, const TYPE& value) {
      LOG4CPLUS_TRACE_METHOD(Logger(), __PRETTY_FUNCTION__);
      ifw::core::utils::param::Parameter tmp_par(name, value);
      Write(tmp_par);
    }

    void Receive(ifw::ccf::common::DataFrame& frame,
                 bool& frame_received,
                 const double timeout,
                 bool& timed_out);

    void Scan(std::vector<ifw::core::utils::param::Parameter>& pars);

    void Start();

    void Stop();

    void HandleSetup();

    void HandleParPreWrite(ifw::core::utils::param::Parameter& par);

    void HandleParPostWrite(ifw::core::utils::param::Parameter& par);

    void HandleParPostRead(ifw::core::utils::param::Parameter& par);

    void MapParForDevice(ifw::core::utils::param::Parameter& par) const;

    void MapParFromDevice(ifw::core::utils::param::Parameter& par) const;

    bool HasNameMapping(const std::string& name) const;
 
    virtual void SetAcqTrigger(const AcqTrigger& acq_trigger);
 
    AcqTrigger& GetAcqTrigger();
 
    ifw::ccf::common::TriggerType GetAcqTriggerType() const;

    virtual void InitialiseUser();

    virtual void SetDeviceAddressUser(const std::string& address);

    virtual void CheckConnectionUser(bool& connected);

    virtual void CheckStatusUser(ifw::ccf::HwStatus& status,
                                 std::string& message);

    virtual bool HasDevicePropertyUser(const std::string& property,
                                       std::string& value);

    virtual double GetTheoreticFrameRateUser();

    virtual void ConnectUser();

    virtual void DisconnectUser();

    virtual bool IsConnectedUser() const;

    virtual void ReadUser(const std::string& name,
                          ifw::core::utils::param::Parameter& par);

    virtual void ReadUser(const std::vector<std::string>& names,
                          std::vector<ifw::core::utils::param::Parameter>& pars);

    virtual void ReceiveUser(ifw::ccf::common::DataFrame& frame,
                             bool& frame_received,
                             const double timeout,
                             bool& timed_out);

    virtual void AddMetaDataUser(ifw::ccf::common::DataFrame& frame);

    virtual void ScanUser(std::vector<ifw::core::utils::param::Parameter>& pars);

    virtual void StartUser();

    virtual void StopUser();

    virtual void WriteUser(const ifw::core::utils::param::Parameter& par);

    virtual void WriteUser(const std::vector<ifw::core::utils::param::Parameter>& pars);

    virtual void HandleSetupUser();

    void ReadMutableSetupPars();

    virtual void HandleParPreWriteUser(ifw::core::utils::param::Parameter& par);

    virtual void HandleParPostWriteUser(ifw::core::utils::param::Parameter& par);

    virtual void HandleParPostReadUser(ifw::core::utils::param::Parameter& par);
 
    const NameMapping& GetNameMapping() const;

    virtual void SetAcqTriggerUser();
 
  protected:
    bool                                m_is_connected;
    AcqTrigger                          m_acq_trigger;
 
    virtual void                        AdjustExpoTimeFrameRate();
 
  private:
    bool                                m_initialised{false};
    bool                                m_is_sim_adapter{false};
    std::string                         m_device_address;
    int16_t                             m_device_array_width{0};
    int16_t                             m_device_array_height{0};
    int8_t                              m_device_pixel_resolution{0};
    std::string                         m_host_address;
    bool                                m_allow_lost_frames{false};
    uint64_t                            m_lost_frames_count{0};
    bool                                m_auto_adjust_time_rate{true};
    NameMapping                         m_device_name_mapping;
 
    // The following map defines the keys to read back. Depending on the device, the key to read
    // back may be different than the one written (setup vs status key). Due to this the second
    // column is added.
    std::map<std::string, std::string>  m_status_setup_keys{
      {"status.expo.time",        "expo.time"},
      // Frame rate may be calculated and not available immediately after setup.
      // => the setup key:
      {"expo.frame_rate",         "status.expo.frame_rate"}, 
      {"status.expo.win_start_x", "expo.win_start_x"},
      {"status.expo.win_start_y", "expo.win_start_y"},
      {"status.expo.win_width",   "expo.win_width"},
      {"status.expo.win_height",  "expo.win_height"}};
 
    DeviceInfo                          m_device_info;
    std::atomic<double>                 m_min_acq_period{0};  // Used to delimit the frame acq.
    std::atomic<double>                 m_time_last_frame{0}; // Time for receiving last frame.
    std::atomic<bool>                   m_dev_acq_running{false};
    std::atomic<uint64_t>               m_frame_counter{0};
 
    std::map<std::string, ifw::core::utils::param::Parameter> m_device_property_registry;
  };
 
}
 
#endif // CCF_COMMON_COM_ADPT_BASE_HPP_H_