修改

CMakeLists.txt

@@ -1,4 +1,4 @@
-CMAKE_MINIMUM_REQUIRED(VERSION 3.5)
+CMAKE_MINIMUM_REQUIRED(VERSION 3.5)
 
 PROJECT(SJTU-RM-CV)
 SET(CMAKE_CXX_STANDARD 11)
@@ -28,6 +28,7 @@ ENDIF()
 FIND_PACKAGE(Eigen3 REQUIRED)
 FIND_PACKAGE(OpenCV 4 REQUIRED)
 FIND_PACKAGE(Threads)
+FIND_PACKAGE(fmt REQUIRED)
 
 LINK_DIRECTORIES(${PROJECT_SOURCE_DIR}/others)
 
@@ -41,6 +42,7 @@ ADD_EXECUTABLE(${BIN_NAME} main.cpp ${sourcefiles})
 
 TARGET_LINK_LIBRARIES(${BIN_NAME} ${CMAKE_THREAD_LIBS_INIT})
 TARGET_LINK_LIBRARIES(${BIN_NAME} ${OpenCV_LIBS})
+TARGET_LINK_LIBRARIES(${BIN_NAME} fmt::fmt)
 IF (CMAKE_SYSTEM_NAME MATCHES "Linux")
     MESSAGE(STATUS "current platform: Linux ")
     TARGET_LINK_LIBRARIES(${BIN_NAME} "${PROJECT_SOURCE_DIR}/others/libMVSDK.so")

armor/include/unifiedManager.hpp

@@ -6,44 +6,36 @@
 #include <thread>
 #include <atomic>
 #include <mutex>
+#include <chrono>
+#include <fmt/core.h>
 
-// Unified device manager (Serial )
+// Unified device manager (Serial only)
 class UnifiedDeviceManager {
 private:
-    // Device instances
     std::unique_ptr<SerialComm> m_serial;
-    std::unique_ptr<CameraManager> m_camera;
+
-    
-    // Thread management
     std::thread m_serialReconnectThread;
     std::atomic<bool> m_serialConnected;
     std::atomic<bool> m_shouldStop;
-    
+
     std::mutex m_serialMutex;
-    
+
     int m_retryIntervalMs;
-    
+
-    // Serial reconnect thread
     void serialReconnectThreadFunc();
 
 public:
     UnifiedDeviceManager(int retryIntervalMs = 500);
     ~UnifiedDeviceManager();
-    
+
-    // Control methods
     void start();
     void stop();
-    
+
-    // Status check
     bool isSerialConnected() const { return m_serialConnected.load(); }
-    
+
     // Serial operations (thread-safe)
     bool sendData(const char* data, size_t length);
     int receiveData(uint8_t* buffer, size_t maxLength);
-    
-    // Camera operations (thread-safe)
-    bool grabFrame(cv::Mat& frame);
-    const char* getCameraName() const;
 };
 
 #endif // UNIFIED_MANAGER_HPP

armor/src/unifiedManager.cpp

@@ -2,7 +2,6 @@
 
 UnifiedDeviceManager::UnifiedDeviceManager(int retryIntervalMs)
     : m_serial(std::make_unique<SerialComm>())
-    , m_camera(std::make_unique<CameraManager>(retryIntervalMs))
     , m_serialConnected(false)
     , m_shouldStop(false)
     , m_retryIntervalMs(retryIntervalMs)
@@ -16,81 +15,69 @@ UnifiedDeviceManager::~UnifiedDeviceManager() {
 
 void UnifiedDeviceManager::serialReconnectThreadFunc() {
     fmt::print("[I][Managr]: Serial reconnect thread started\n");
-    
+
     while (!m_shouldStop.load()) {
         if (!m_serialConnected.load()) {
             fmt::print("[I][Managr]: Attempting to connect serial port...\n");
-            
+
             std::lock_guard<std::mutex> lock(m_serialMutex);
-            
+
             if (m_serial->findFirstTtyUSB() && m_serial->openPort()) {
                 m_serialConnected.store(true);
                 fmt::print("[I][Managr]: Serial port connected successfully\n");
             } else {
-                fmt::print("[W][Managr]: Serial connection failed, retry in {}ms\n", 
+                fmt::print("[W][Managr]: Serial connection failed, retry in {}ms\n",
                           m_retryIntervalMs);
             }
         }
-        
+
         std::this_thread::sleep_for(std::chrono::milliseconds(m_retryIntervalMs));
     }
-    
+
     fmt::print("[I][Managr]: Serial reconnect thread stopped\n");
 }
 
 void UnifiedDeviceManager::start() {
     fmt::print("[I][Managr]: Starting unified device manager\n");
-    
+
     m_shouldStop.store(false);
-    
+
-    // Start serial reconnect thread
     if (!m_serialReconnectThread.joinable()) {
         m_serialReconnectThread = std::thread(&UnifiedDeviceManager::serialReconnectThreadFunc, this);
     }
-    
+
-    // Start camera manager (it has its own reconnect thread)
-    m_camera->start();
-    
     fmt::print("[I][Managr]: Unified device manager started\n");
 }
 
 void UnifiedDeviceManager::stop() {
     fmt::print("[I][Managr]: Stopping unified device manager\n");
-    
+
     m_shouldStop.store(true);
-    
+
-    // Stop camera manager
-    m_camera->stop();
-    
-    // Stop serial thread
     if (m_serialReconnectThread.joinable()) {
         m_serialReconnectThread.join();
-        
+
         std::lock_guard<std::mutex> lock(m_serialMutex);
         m_serial->closePort();
         m_serialConnected.store(false);
     }
-    
-    fmt::print("[I][Managr]: Unified device manager stopped\n");
-}
 
-bool UnifiedDeviceManager::isCameraConnected() const {
+    fmt::print("[I][Managr]: Unified device manager stopped\n");
-    return m_camera->isConnected();
 }
 
 bool UnifiedDeviceManager::sendData(const char* data, size_t length) {
     if (!m_serialConnected.load()) {
         return false;
     }
-    
+
     std::lock_guard<std::mutex> lock(m_serialMutex);
-    
+
     if (!m_serial->sendData(data, length)) {
         m_serialConnected.store(false);
         fmt::print("[W][Managr]: Serial send failed, marked as disconnected\n");
         return false;
     }
-    
+
     return true;
 }
 
@@ -98,15 +85,7 @@ int UnifiedDeviceManager::receiveData(uint8_t* buffer, size_t maxLength) {
     if (!m_serialConnected.load()) {
         return -1;
     }
-    
+
     std::lock_guard<std::mutex> lock(m_serialMutex);
     return m_serial->receiveData(buffer, maxLength);
-}
-
-bool UnifiedDeviceManager::grabFrame(cv::Mat& frame) {
-    return m_camera->grabFrame(frame);
-}
-
-const char* UnifiedDeviceManager::getCameraName() const {
-    return m_camera->getCameraName();
 }