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