add file

Author: KingRichord

CMakeLists.txt

@@ -11,10 +11,4 @@ if (NOT CMAKE_BUILD_TYPE)
 endif ()
 
 add_subdirectory(infinite_sense_core)
-
-add_executable(${PROJECT_NAME}_zmq_node
-        example/ZMQ/main.cpp
-)
-target_link_libraries(${PROJECT_NAME}_zmq_node PRIVATE
-        infinite_sense_core
-)
+add_subdirectory(example)

example/CMakeLists.txt

@@ -0,0 +1,4 @@
+cmake_minimum_required(VERSION 3.10)
+project(example)
+
+add_subdirectory(GigeCam)

example/CustomCam/CMakeLists.txt

@@ -0,0 +1,47 @@
+cmake_minimum_required(VERSION 3.16)
+
+project(gige_cam VERSION 1.0)
+
+set(CMAKE_CXX_STANDARD 17)
+
+if (NOT CMAKE_BUILD_TYPE)
+    set(CMAKE_BUILD_TYPE Release)
+    set(CMAKE_CXX_FLAGS "${CMAKE_C_FLAGS} -O3  -Wall")
+    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -O3  -Wall")
+endif ()
+
+
+# 检测平台并设置相关变量
+if (CMAKE_SYSTEM_PROCESSOR MATCHES "arm" OR CMAKE_SYSTEM_PROCESSOR MATCHES "aarch64")
+    set(PLATFORM_DIR "arm")
+    set(MVCAM_LIB_DIR ${CMAKE_CURRENT_SOURCE_DIR}/mvcam/lib/aarch64)
+elseif (CMAKE_SYSTEM_PROCESSOR MATCHES "x86_64" OR CMAKE_SYSTEM_PROCESSOR MATCHES "amd64")
+    set(PLATFORM_DIR "x86")
+    set(MVCAM_LIB_DIR ${CMAKE_CURRENT_SOURCE_DIR}/mvcam/lib/x86/64)
+else ()
+    message(STATUS "Unknown Architecture")
+    set(PLATFORM_DIR "Unknown")
+endif ()
+message(STATUS "Find MVCAM_LIB_DIR : ${MVCAM_LIB_DIR}")
+
+
+add_executable(${PROJECT_NAME}
+        main.cpp
+        mv_cam.cpp
+        mv_cam.h
+)
+target_link_directories(${PROJECT_NAME} PRIVATE
+        ${MVCAM_LIB_DIR}
+)
+
+target_link_libraries(${PROJECT_NAME} PRIVATE
+        infinite_sense_core
+        MvCameraControl
+)
+
+target_include_directories(${PROJECT_NAME} PRIVATE
+        mvcam/include
+)
+set_target_properties(${PROJECT_NAME} PROPERTIES
+        INSTALL_RPATH "$ORIGIN"
+)

example/GigeCam/CMakeLists.txt

@@ -2,14 +2,13 @@
 #include "mv_cam.h"
 using namespace infinite_sense;
 int main() {
-
   // 1.创建同步器
   Synchronizer synchronizer;
   synchronizer.SetUsbLink("/dev/ttyACM0", 460800);
   // 2.配置同步接口
-  std::map<std::string, TriggerDevice> params;
-  params["camera_1"] = CAM_1;
-  const auto mv_cam = std::make_shared<MvCam>(params);
+  std::map<std::string, TriggerDevice> params = {{"camera_1", CAM_1}};
+  auto mv_cam = std::make_shared<MvCam>();
+  mv_cam->SetParams(params);
   synchronizer.UseCam(mv_cam);
 
   // 3.开启同步

example/GigeCam/main.cpp

@@ -148,27 +148,17 @@ bool MvCam::Initialization() {
     return false;
   }
 }
-void MvCam::Restart() {
-  Stop();
-  std::this_thread::sleep_for(std::chrono::milliseconds{500});
-  if (!Initialization()) {
-    LOG(INFO) << "Camera initialization failed after restart!";
-  } else {
-    Start();
-    LOG(INFO) << "Cameras successfully restarted!";
-  }
-}
 
 void MvCam::Stop() {
   Disable();
   std::this_thread::sleep_for(std::chrono::milliseconds{500});
-  for (auto &cam_thread : cam_threads_) {
+  for (auto &cam_thread : cam_threads) {
     while (cam_thread.joinable()) {
       cam_thread.join();
     }
   }
-  cam_threads_.clear();
-  cam_threads_.shrink_to_fit();
+  cam_threads.clear();
+  cam_threads.shrink_to_fit();
   for (size_t i = 0; i < handles_.size(); ++i) {
     int n_ret = MV_OK;
     n_ret = MV_CC_StopGrabbing(handles_[i]);
@@ -193,7 +183,7 @@ void MvCam::Receive(void *handle, const std::string &name)  {
   MV_FRAME_OUT st_out_frame;
   CamData cam_data;
   Messenger &messenger = Messenger::GetInstance();
-  while (is_running_) {
+  while (is_running) {
     memset(&st_out_frame, 0, sizeof(MV_FRAME_OUT));
     int n_ret = MV_CC_GetImageBuffer(handle, &st_out_frame, 10);
     if (n_ret == MV_OK) {
@@ -203,11 +193,11 @@ void MvCam::Receive(void *handle, const std::string &name)  {
         LOG(ERROR) << "Get ExposureTime fail! n_ret [0x" << std::hex << n_ret << "]";
       }
       // 这里的time_stamp_us是相机触发时间，需要加上曝光时间的一半，以获得相机拍摄的时间
-      if (params_.find(name) == params_.end()) {
+      if (params.find(name) == params.end()) {
         LOG(ERROR) << "cam " << name << " not found!";
       }
       else {
-        if (uint64_t time; GET_LAST_TRIGGER_STATUS(params_[name], time)) {
+        if (uint64_t time; GET_LAST_TRIGGER_STATUS(params[name], time)) {
           cam_data.time_stamp_us = time + static_cast<uint64_t>(expose_time.fCurValue / 2.);
         }
         else {
@@ -272,7 +262,7 @@ void MvCam::Start() {
       name = "cam_" + std::to_string(cam_index++);
       LOG(WARNING) << "Camera name is empty,create name " << name;
     }
-    cam_threads_.emplace_back(&MvCam::Receive, this, handle, name);
+    cam_threads.emplace_back(&MvCam::Receive, this, handle, name);
     LOG(INFO) << "Camera name is " << name << " start";
   }
 }

example/GigeCam/mv_cam.cpp

@@ -3,7 +3,6 @@
 namespace infinite_sense {
 class MvCam final : public Sensor {
  public:
-  explicit MvCam(const std::map<std::string, TriggerDevice>& params) : params_(params) {}
   ~MvCam() override;
 
   bool Initialization() override;
@@ -12,10 +11,7 @@ class MvCam final : public Sensor {
 
  private:
   void Receive(void* handle, const std::string&) override;
-  bool is_running_{false};
   std::vector<int> rets_;
   std::vector<void*> handles_;
-  std::vector<std::thread> cam_threads_;
-  std::map<std::string, TriggerDevice> params_;
 };
 }  // namespace infinite_sense

example/GigeCam/mv_cam.h

@@ -28,6 +28,7 @@ add_library(${PROJECT_NAME} SHARED
   src/net.cpp
   src/messenger.cpp
   src/ptp.cpp
+  src/sensor.cpp
 )
 target_link_directories(${PROJECT_NAME} PUBLIC
     ${CMAKE_INSTALL_RPATH}

infinite_sense_core/CMakeLists.txt

@@ -2,37 +2,31 @@
 #include <thread>
 #include <vector>
 #include "messenger.h"
+#include "trigger.h"
 namespace infinite_sense {
 class Sensor {
  public:
   Sensor();
-  explicit Sensor(const std::map<std::string, TriggerDevice>& params) : params_(params) {}
   virtual ~Sensor();
 
-  Sensor(const Sensor&) = delete;
-  Sensor& operator=(const Sensor&) = delete;
+  virtual bool Initialization() = 0;
 
-  virtual bool Initialization();
-  virtual void Stop();
-  virtual void Start();
-  virtual void Restart() {
-    Stop();
-    std::this_thread::sleep_for(std::chrono::milliseconds{500});
-    if (!Initialization()) {
-      LOG(INFO) << "Camera initialization failed after restart!";
-    } else {
-      Start();
-      LOG(INFO) << "Cameras successfully restarted!";
-    }
-  }
-  void Enable() { is_running_ = true; }
-  void Disable() { is_running_ = false; }
+  virtual void Stop() = 0;
+
+  virtual void Start() = 0;
+
+  void Restart();
+  void Enable() { is_running = true; }
+  void Disable() { is_running = false; }
+  void SetParams(const std::map<std::string, TriggerDevice> &params_in) { params = params_in; };
 
  private:
-  virtual void Receive(void* handle, const std::string&);
-  bool is_running_{false};
-  std::vector<std::thread> cam_threads_{};
-  std::map<std::string, TriggerDevice> params_{};
+  virtual void Receive(void *handle, const std::string &) = 0;
+
+ protected:
+  bool is_running{false};
+  std::vector<std::thread> cam_threads{};
+  std::map<std::string, TriggerDevice> params{};
 };
 
 }  // namespace infinite_sense

infinite_sense_core/include/sensor.h

@@ -0,0 +1,18 @@
+#include "sensor.h"
+
+namespace infinite_sense {
+Sensor::Sensor() = default;
+
+Sensor::~Sensor() = default;
+
+void Sensor::Restart() {
+  Stop();
+  std::this_thread::sleep_for(std::chrono::milliseconds{500});
+  if (!Initialization()) {
+    LOG(INFO) << "Camera initialization failed after restart!";
+  } else {
+    Start();
+    LOG(INFO) << "Cameras successfully restarted!";
+  }
+}
+}  // namespace infinite_sense