迁移入tty持续连接

armor/include/serialComm.hpp

@@ -0,0 +1,58 @@
+#ifndef SERIAL_COMM_H
+#define SERIAL_COMM_H
+
+#include <vector>
+#include "CSerialPort/SerialPort.h"
+#include "CSerialPort/SerialPortInfo.h"
+#include <fmt/core.h>
+
+using namespace itas109;
+
+// Serial port configuration
+namespace SerialConfig {
+    constexpr int BAUD_RATE = 115200;
+    constexpr Parity PARITY_TYPE = Parity::ParityNone;
+    constexpr DataBits DATA_BITS = DataBits::DataBits8;
+    constexpr StopBits STOP_BITS = StopBits::StopOne;
+    constexpr FlowControl FLOW_CTRL = FlowControl::FlowNone;
+    constexpr int READ_TIMEOUT_MS = 1000;
+}
+
+class SerialComm {
+private:
+    CSerialPort m_serialPort;
+    char m_portName[256];
+    bool m_isOpen;
+
+public:
+    SerialComm();
+    ~SerialComm();
+
+    // Find first ttyUSB device
+    bool findFirstTtyUSB();
+    
+    // Open serial port
+    bool openPort();
+    
+    // Close serial port
+    void closePort();
+    
+    // Send data
+    bool sendData(const char* data, size_t length);
+    bool sendData(const uint8_t* data, size_t length);
+    
+    // Receive data
+    int receiveData(uint8_t* buffer, size_t maxLength);
+    int receiveData(char* buffer, size_t maxLength);
+    
+    // Check if port is open
+    bool isOpen() const { return m_isOpen; }
+    
+    // Get current port name
+    const char* getPortName() const { return m_portName; }
+    
+    // List all available ports
+    static void listAllPorts();
+};
+
+#endif // SERIAL_COMM_H

armor/include/serialManager.hpp

@@ -0,0 +1,126 @@
+#ifndef SERIAL_MANAGER_HPP
+#define SERIAL_MANAGER_HPP
+
+#include "serialComm.hpp"
+#include <thread>
+#include <atomic>
+#include <mutex>
+#include <fmt/core.h>
+#include <chrono>
+
+class SerialManager {
+private:
+    SerialComm m_serial;
+    std::thread m_connectionThread;
+    std::atomic<bool> m_isConnected;
+    std::atomic<bool> m_shouldStop;
+    std::mutex m_serialMutex;
+    int m_retryIntervalMs;
+
+    // 后台重连线程函数
+    void connectionThreadFunc() {
+        fmt::print("[I][SerialMgr]: RETRY\n");
+        
+        while (!m_shouldStop.load()) {
+            if (!m_isConnected.load()) {
+                
+                std::lock_guard<std::mutex> lock(m_serialMutex);
+                
+                if (m_serial.findFirstTtyUSB() && m_serial.openPort()) {
+                    m_isConnected.store(true);
+                } else {
+                    fmt::print("[W][SerialMgr]: Failed, retry in {}ms\n", m_retryIntervalMs);
+                }
+            }
+            
+            std::this_thread::sleep_for(std::chrono::milliseconds(m_retryIntervalMs));
+        }
+        
+        fmt::print("[I][SerialMgr]: EXIT\n");
+    }
+
+public:
+    // 构造函数：retryIntervalMs - 重试间隔（毫秒）
+    SerialManager(int retryIntervalMs = 500) 
+        : m_isConnected(false)
+        , m_shouldStop(false)
+        , m_retryIntervalMs(retryIntervalMs) {
+    }
+
+    ~SerialManager() {
+        stop();
+    }
+
+    // 启动管理器（开始后台重连）
+    void start() {
+        if (!m_connectionThread.joinable()) {
+            m_shouldStop.store(false);
+            m_connectionThread = std::thread(&SerialManager::connectionThreadFunc, this);
+            fmt::print("[I][SerialMgr]: START\n");
+        }
+    }
+
+    // 停止管理器
+    void stop() {
+        if (m_connectionThread.joinable()) {
+            m_shouldStop.store(true);
+            m_connectionThread.join();
+            
+            std::lock_guard<std::mutex> lock(m_serialMutex);
+            m_serial.closePort();
+            m_isConnected.store(false);
+            
+            fmt::print("[I][SerialMgr]: STOP\n");
+        }
+    }
+
+    // 检查是否已连接
+    bool isConnected() const {
+        return m_isConnected.load();
+    }
+
+    // 发送数据（线程安全）
+    bool sendData(const char* data, size_t length) {
+        if (!m_isConnected.load()) {
+            return false;
+        }
+
+        std::lock_guard<std::mutex> lock(m_serialMutex);
+        
+        if (!m_serial.sendData(data, length)) {
+            // 发送失败，标记为断开
+            m_isConnected.store(false);
+            fmt::print("[W][SerialMgr]: Failed, mark DISCONNECT\n");
+            return false;
+        }
+        
+        return true;
+    }
+
+    // 发送数据（字节数组）
+    bool sendData(const uint8_t* data, size_t length) {
+        return sendData(reinterpret_cast<const char*>(data), length);
+    }
+
+    // 接收数据（线程安全）
+    int receiveData(uint8_t* buffer, size_t maxLength) {
+        if (!m_isConnected.load()) {
+            return -1;
+        }
+
+        std::lock_guard<std::mutex> lock(m_serialMutex);
+        return m_serial.receiveData(buffer, maxLength);
+    }
+
+    // 接收数据（字符数组）
+    int receiveData(char* buffer, size_t maxLength) {
+        return receiveData(reinterpret_cast<uint8_t*>(buffer), maxLength);
+    }
+
+    // 获取端口名
+    const char* getPortName() const {
+        return m_serial.getPortName();
+    }
+};
+
+#endif // SERIAL_MANAGER_HPP

armor/include/unifiedManager.hpp

@@ -0,0 +1,49 @@
+#ifndef UNIFIED_MANAGER_HPP
+#define UNIFIED_MANAGER_HPP
+
+#include "serialComm.hpp"
+#include <memory>
+#include <thread>
+#include <atomic>
+#include <mutex>
+
+// Unified device manager (Serial )
+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