comAdptGenICam.hpp

Go to the documentation of this file.

 
#ifndef CCF_PROTOCOLS_GENICAM_COM_ADPT_GENICAM_HPP_H_
#define CCF_PROTOCOLS_GENICAM_COM_ADPT_GENICAM_HPP_H_
 
#include <memory>
#include <span>
#include <string>
#include <vector>
 
#include <ifw/fnd/defs/dataType.hpp>
#include <ifw/core/utils/param/parameter.hpp>
 
#include <ifw/ccf/common/comAdptBase.hpp>
#include <ifw/ccf/common/dataFrame.hpp>
 
// camcom — only the abstract base + value types are needed in the header; the
// concrete GenICamAdapter (which links Aravis) is created in the .cpp.
#include <camcom/common/adapterBase.hpp>
#include <camcom/common/parameter.hpp>
#include <camcom/common/datatype.hpp>
#include <camcom/common/frameInfo.hpp>
#include <camcom/common/receiveCfg.hpp>
 
namespace ifw::ccf::protocols::genicam {

  class ComAdptGenICam : public ifw::ccf::common::ComAdptBase {
  public:
    ComAdptGenICam();
    ~ComAdptGenICam() override;
 
    ComAdptGenICam(const ComAdptGenICam&) = delete;
    ComAdptGenICam& operator=(const ComAdptGenICam&) = delete;
 
    // --- Lifecycle / connection ---
    void InitialiseUser() override;
    void SetDeviceAddressUser(const std::string& address) override;
    void ConnectUser() override;
    void DisconnectUser() override;
    void CheckConnectionUser(bool& connected) override;
    bool IsConnectedUser() const override;
    void CheckStatusUser(ifw::ccf::HwStatus& status, std::string& message) override;
 
    // --- Parameters ---
    void ReadUser(const std::string& name,
                  ifw::core::utils::param::Parameter& par) override;
    void WriteUser(const ifw::core::utils::param::Parameter& par) override;
    void ScanUser(std::vector<ifw::core::utils::param::Parameter>& pars) override;
 
    // --- Acquisition ---
    void StartUser() override;
    void StopUser() override;
    void ReceiveUser(ifw::ccf::common::DataFrame& frame,
                     bool& frame_received,
                     const double timeout,
                     bool& timed_out) override;
 
  private:
    // --- Type translation seam (implemented in parameterConversion.cpp) ---
    static camcom::common::Parameter
        CcfToCamCom(const ifw::core::utils::param::Parameter& ccf_par);
    // Infer a numeric camcom type (int/double, else string) from an untyped
    // value string — used for setup parameters that arrive without a CCF
    // DataType, so a numeric GenICam node isn't handed a string. See
    // CcfToCamCom for the why.
    static camcom::common::Parameter
        InferTypedParam(const std::string& name, const std::string& value);
    static ifw::core::utils::param::Parameter
        CamComToCcf(const camcom::common::Parameter& camcom_par);
 
    // Copy a received camcom frame (span + FrameInfo) into a CCF DataFrame
    // (implemented in acquisition.cpp).
    void StoreFrame(std::span<uint8_t> data,
                    const camcom::common::FrameInfo& info,
                    ifw::ccf::common::DataFrame& frame);
 
    // The camcom GenICam adapter doing the real work. Held as the abstract
    // base so this header doesn't pull in the Aravis-linked concrete type.
    std::unique_ptr<camcom::common::AdapterBase> m_camcom;
 
    // Reusable receive buffer (camcom ReceiveFrame writes into a span we own).
    std::vector<uint8_t> m_frame_buffer;
  };
 
} // namespace ifw::ccf::protocols::genicam
 
#endif // CCF_PROTOCOLS_GENICAM_COM_ADPT_GENICAM_HPP_H_