comAdptAravis.hpp

Go to the documentation of this file.

 
#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::HwStatus& status,
                                   std::string& message);
      virtual void ConnectUser();
 
      virtual void DisconnectUser();
 
      virtual bool IsConnectedUser() const;
 
      virtual void ReadUser(const std::string& name,
                            core::utils::param::Parameter& par);
 
      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 double GetTheoreticFrameRateUser();
 
      virtual void _AdjustStreamBytesPerSecHook(); 
 
      virtual int8_t _ReadBasicParsHook();
 
      // TODO: Check if support via aravisComAdpt::HandleParsPreWrite()
      virtual int8_t _WriteParHook(core::utils::param::Parameter& par,
                                   bool& ignore_unknown);
 
      // Public member variables to allow FrameReceptionThread to access them.
      ccf::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_lost_frames;
      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:
      virtual void    _Reset();
      virtual void    _ClearCamHandle();
 
      int32_t         m_bytes_per_pixel;
 
      // Current setup installed.
      //std::map<std::string, core::utils::param::Parameter> m_setup;
      double          m_setup_expo_time;
      double          m_stat_expo_time;
      int             m_setup_expo_bin_x;
      int             m_setup_expo_bin_y;
 
      std::map<std::string, ArvAttributeInfo> m_attributes;
 
      virtual void    _Write(core::utils::param::Parameter& par);
 
      virtual void    _StartAcq();
      virtual void    _StartAcqThr();
      virtual void    _PauseAcqThr();
      virtual void    _GetIntEnumValue(const std::string& name,
                                       core::utils::param::Parameter& par);
 
    private: 
      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(core::utils::param::Parameter& par);
      bool           _PackedPixelFormat(ArvPixelFormat pixel_format);
 
      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_