IFW_HL/ccf/comAdptAravis_8hpp_source.html

#ifndef CCF_PROTOCOLS_ARAVIS_LIB_COM_ADPT_HPP_H_

#define CCF_PROTOCOLS_ARAVIS_LIB_COM_ADPT_HPP_H_


#include <stdint.h>

#include <vector>


#include <ccf/common/nameMapping.hpp>

#include <ccf/common/comAdptBase.hpp>


#include <ccf/protocols/aravis/defines.hpp>

#include <ccf/protocols/aravis/enumWrapper.hpp>


namespace ccf::protocols::aravis {


    void FrameReceptionThread(void* com_adapter);


    class ComAdptAravis: public ccf::common::ComAdptBase {

    public:

      // Constants

      // @{

      const double      CONNECT_TIMEOUT             = 10.0;

      const double      FRAME_REC_THR_SLEEP_TIME    = 0.0005;

      const uint16_t    MAX_NB_OF_RECEP_BUFFERS     = 100;

      const uint16_t    NB_OF_INPUT_BUFFERS         = 5;

      const int32_t     DEFAULT_PACKET_SIZE         = 1500;

      const uint32_t    STREAM_BYTES_PER_SECOND_MIN = 1000000;

      const uint32_t    STREAM_BYTES_PER_SECOND_MAX = 248000000; // 12400000;

      // @}


      // GigE Vision com. parameter names

      // @{

      const std::string GIGE_PAR_ACQUISITION_ABORT       = "AcquisitionAbort";

      const std::string GIGE_PAR_ACQUISITION_MODE        = "AcquisitionMode";

      const std::string GIGE_PAR_ACQUISITION_START       = "AcquisitionStart";

      const std::string GIGE_PAR_ACQUISITION_STOP        = "AcquisitionStop";

      const std::string GIGE_PAR_DEVICE_VENDOR_NAME      = "DeviceVendorName";

      const std::string GIGE_PAR_PACKET_SIZE             = "PacketSize";

      const std::string GIGE_PAR_PAYLOAD_SIZE            = "PayloadSize";

      const std::string GIGE_PAR_PIXELFORMAT             = "PixelFormat";

      const std::string GIGE_PAR_SENSOR_BITS             = "SensorBits";

      const std::string GIGE_PAR_SENSOR_HEIGHT           = "SensorHeight";

      const std::string GIGE_PAR_SENSOR_TYPE             = "SensorType";

      const std::string GIGE_PAR_SENSOR_WIDTH            = "SensorWidth";

      const std::string GIGE_PAR_STREAM_BYTES_PER_SECOND = "StreamBytesPerSecond";

      const std::string GIGE_PAR_TIMESTAMP_TICK_FREQ     = "TimestampTickFreq";

      const std::string GIGE_PAR_FRAME_TRIGGER_MODE      = "FrameStartTriggerMode";

      const std::string GIGE_PAR_TRIGGER_MODE            = "TriggerMode";

      const std::string GIGE_PAR_TRIGGER_SOURCE          = "TriggerSource";

      // @}


      // Status code lookup

      const std::map<int, std::string> ARV_BUFFER_STATUS_STRING =

        {

          {ARV_BUFFER_STATUS_UNKNOWN,         "Unknown error"},

          {ARV_BUFFER_STATUS_SUCCESS,         "Success"},

          {ARV_BUFFER_STATUS_CLEARED,         "Buffer cleared"},

          {ARV_BUFFER_STATUS_TIMEOUT,         "Timeout"},

          {ARV_BUFFER_STATUS_MISSING_PACKETS, "Missing packets"},

          {ARV_BUFFER_STATUS_WRONG_PACKET_ID, "Wrong packet ID"},

          {ARV_BUFFER_STATUS_SIZE_MISMATCH,   "Size mismatch"},

          {ARV_BUFFER_STATUS_FILLING,         "Buffer filling"},

          {ARV_BUFFER_STATUS_ABORTED,         "Aborted"}

        };


      ComAdptAravis();

      virtual ~ComAdptAravis();


      virtual void InitialiseUser();


      virtual void CheckConnectionUser(bool& connected);


      virtual void CheckStatusUser(ccf::common::HwStatus& status,

                                   std::string& message);

      virtual void ConnectUser();


      virtual void DisconnectUser();


      virtual bool IsConnectedUser() const;


      virtual void ReadUser(const std::string& name,

                            ctd::param::Parameter& par);


      virtual void ReceiveUser(ccf::common::DataFrame& frame,

                               bool& frame_received,

                               const double timeout,

                               bool& timed_out);


      virtual void ScanUser(std::vector<ctd::param::Parameter>& pars);


      virtual void StartUser();


      virtual void StopUser();


      virtual void WriteUser(const ctd::param::Parameter& par);


      virtual double GetTheoreticFrameRateUser();


      virtual void _AdjustStreamBytesPerSecHook();


      virtual int8_t _ReadBasicParsHook();


      // TODO: Check if support via aravisComAdpt::HandleParsPreWrite()

      virtual int8_t _WriteParHook(ctd::param::Parameter& par,

                                   bool& ignore_unknown);


      // Public member variables to allow FrameReceptionThread to access them.

      ccf::common::ExpoMode                  p_expo_mode;

      bool                                   p_exec_fr_acq_thr; // p_acq_thr_running;

      bool                                   p_term_fr_acq_thr;

      int32_t                                p_cur_buffer_index;

      ArvDevice*                             p_device;

      ArvFrame                               p_frame_buffers[100]; // TODO: Allocate from cfg?

      bool                                   p_frame_buffers_in_use[100];

      uint32_t                               p_frame_count;

      bool                                   p_ignore_frame_skipping;

      double                                 p_last_missing_data_log;

      int32_t                                p_payload_size;

      std::map<ArvBufferStatus, std::string> p_status_map;

      ArvStream*                             p_stream;

      int32_t                                p_acq_thr_buf_index;

      bool                                   p_waiting_for_frame;

      double                                 p_timestamp_frequency;

      std::thread*                           p_fr_acq_thr;

      struct sched_param                     p_fr_acq_thr_sched_par;


      bool           GetAcqThrExecFlag();


    protected:

      void           _Reset();

      void           _ClearCamHandle();


      std::string    m_vendor; // TODO: Check if needed.

      int32_t        m_bytes_per_pixel;

      int32_t        m_sensor_height; // TODO: Check if needed.

      int32_t        m_sensor_width; // TODO: Check if needed.


      // TODO: These parameters ("m_cur_expo*") should maybe be removed and this information based on the values from the camera.

      double         m_cur_expo_time;

      double         m_cur_expo_frame_rate;

      int32_t        m_cur_expo_bin_x;

      int32_t        m_cur_expo_bin_y;

      int32_t        m_cur_expo_win_start_x;

      int32_t        m_cur_expo_win_start_y;

      int32_t        m_cur_expo_win_width;

      int32_t        m_cur_expo_win_height;


    private:

      virtual void   _Write(ctd::param::Parameter& par);

      void           _UpdateObjectParStatus(const ctd::param::Parameter& par);

      void           _GetCameraAttributesList(ArvGc* gen_i_cam);

      void           _GetFlags(ArvGc* gen_i_cam, const std::string& name);

      void           _GetNode(const std::string& name, ArvGc* gen_i_cam, ArvGcNode** node);

      int16_t        _MonoPixelFormatToBits(std::string par_value);

      int16_t        _MonoPixelFormatToBits(ctd::param::Parameter& par);

      bool           _PackedPixelFormat(ArvPixelFormat pixel_format);

      void           _StartAcq();

      void           _StartAcqThr();

      void           _PauseAcqThr();

      void           _GetIntEnumValue(const std::string& name,

                                      ctd::param::Parameter& par);


      std::map<std::string, ArvAttributeInfo>                                  m_attributes;

      std::map<ccf::protocols::aravis::ArvDatatype, std::vector<std::string>>  m_data_type_map;


      double                  m_delay_start_after_stop;

      double                  m_last_frame_recv;

      gulong                  m_sig_handler_id;

      uint32_t                m_stream_bytes_max;

      double                  m_time_last_stop;

      std::string             m_host_address;

    };


  }


  #endif // CCF_PROTOCOLS_ARAVIS_LIB_COM_ADPT_HPP_H_