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 <core/utils/param/parameter.hpp>
 
#include <ccf/common/base.hpp>
#include <ccf/common/dataFrame.hpp>
#include <ccf/common/nameMapping.hpp>
#include <ccf/common/config.hpp>
#include <ccf/common/db.hpp>
 
 
namespace ccf::common {
 
  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;
        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 LoadDeviceNameMapping(const std::string& name_mapping_file);
 
    void Initialise(const bool re_init = false);
 
    void SetDeviceAddress(const std::string& address);
 
    void CheckConnection(bool& connected);
 
    void CheckStatus(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();
 
    uint64_t GetLostFramesCount() const;
 
    void ResetLostFramesCount();
 
    void Read(const std::string& name,
              core::utils::param::Parameter& par);
 
    void Read(const std::vector<std::string>& names,
              std::vector<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__);
      core::utils::param::Parameter par;
      Read(name, par);
      TYPE native_value;
      core::utils::conversion::Convert(par.GetValue(), native_value);
      return native_value;
      //return boost::l_exical_cast<TYPE>(par.GetValue());
    }
 
    void Write(const core::utils::param::Parameter& par);
 
    void Write(const std::vector<core::utils::param::Parameter>& pars);
 
    template <class TYPE>
    void Write(const std::string& name, const TYPE& value) {
      LOG4CPLUS_TRACE_METHOD(Logger(), __PRETTY_FUNCTION__);
      core::utils::param::Parameter tmp_par(name, value);
      Write(tmp_par);
    }
 
    void Receive(ccf::common::DataFrame& frame,
                 bool& frame_received,
                 const double timeout,
                 bool& timed_out);
 
    void Scan(std::vector<core::utils::param::Parameter>& pars);
 
    void Start();
 
    void Stop();
 
    void HandleSetup();
 
    void HandleParPreWrite(core::utils::param::Parameter& par);
 
    void HandleParPostWrite(core::utils::param::Parameter& par);
 
    void HandleParPostRead(core::utils::param::Parameter& par);
 
    void MapParForDevice(core::utils::param::Parameter& par) const;
 
    void MapParFromDevice(core::utils::param::Parameter& par) const;
 
    bool HasNameMapping(const std::string& name) const;
 
    virtual void InitialiseUser();
 
    virtual void SetDeviceAddressUser(const std::string& address);
 
    virtual void CheckConnectionUser(bool& connected);
 
    virtual void CheckStatusUser(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,
                          core::utils::param::Parameter& par);
 
    virtual void ReadUser(const std::vector<std::string>& names,
                          std::vector<core::utils::param::Parameter>& pars);
 
    virtual void ReceiveUser(ccf::common::DataFrame& frame,
                             bool& frame_received,
                             const double timeout,
                             bool& timed_out);
 
    virtual void ScanUser(std::vector<core::utils::param::Parameter>& pars);
 
    virtual void StartUser();
 
    virtual void StopUser();
 
    virtual void WriteUser(const core::utils::param::Parameter& par);
 
    virtual void WriteUser(const std::vector<core::utils::param::Parameter>& pars);
 
    virtual void HandleSetupUser();
 
    virtual void HandleParPreWriteUser(core::utils::param::Parameter& par);
 
    virtual void HandleParPostWriteUser(core::utils::param::Parameter& par);
 
    virtual void HandleParPostReadUser(core::utils::param::Parameter& par);
 
  protected:
    bool                              m_is_connected;
 
  private:
    bool                              m_initialised;
    bool                              m_is_sim_adapter;
    std::string                       m_device_address;
    int16_t                           m_device_array_width;
    int16_t                           m_device_array_height;
    int8_t                            m_device_pixel_resolution;
    std::string                       m_host_address;
    bool                              m_allow_lost_frames;
    uint64_t                          m_lost_frames_count;
    NameMapping                       m_device_name_mapping;
    DeviceInfo                        m_device_info;
    double                            m_min_acq_period;  // Used to delimit the frame acq.
    double                            m_time_last_frame; // Time for receiving last frame.
 
    std::map<std::string, core::utils::param::Parameter> m_device_property_registry;
  };
 
}
 
#endif // CCF_COMMON_COM_ADPT_BASE_HPP_H_