迁移入tty持续连接

armor/src/armor_finder/anti_top/anti_top.cpp

@@ -38,6 +38,12 @@ void ArmorFinder::antiTop() {
     // 通过两次装甲角度为零的时间差计算陀螺旋转周期
     // 根据旋转周期计算下一次装甲出现在角度为零的时间点
     if (getPointLength(last_box.getCenter() - target_box.getCenter()) > last_box.rect.height * 1.5) {
+        sum_yaw = sum_pitch = 0;
+        double dx = target_box.rect.x + target_box.rect.width / 2.0 - IMAGE_CENTER_X;
+        double dy = target_box.rect.y + target_box.rect.height / 2.0 - IMAGE_CENTER_Y;
+        last_yaw = dx;
+        last_pitch = dy;
+
         auto front_time = getFrontTime(time_seq, angle_seq);
         auto once_periodms = getTimeIntervalms(front_time, last_front_time);
 //        if (abs(once_periodms - top_periodms[-1]) > 50) {

armor/src/armor_finder/armor_finder.cpp

@@ -54,7 +54,9 @@ ArmorFinder::ArmorFinder(uint8_t &color, Serial &u, const string &paras_folder,
         anti_switch_cnt(0),
         classifier(paras_folder),
         contour_area(0),
-        tracking_cnt(0) {
+        tracking_cnt(0),
+        last_yaw(0), last_pitch(0),
+        sum_yaw(0), sum_pitch(0) {
 }
 
 void ArmorFinder::run(cv::Mat &src) {
@@ -75,6 +77,9 @@ void ArmorFinder::run(cv::Mat &src) {
                     tracker->init(src, target_box.rect);
                     state = TRACKING_STATE;
                     tracking_cnt = 0;
+                    last_yaw = target_box.rect.x + target_box.rect.width / 2.0 - IMAGE_CENTER_X;
+                    last_pitch = target_box.rect.y + target_box.rect.height / 2.0 - IMAGE_CENTER_Y;
+                    sum_yaw = sum_pitch = 0;
                     LOGM(STR_CTR(WORD_LIGHT_CYAN, "into track"));
                 }
             }
@@ -82,6 +87,8 @@ void ArmorFinder::run(cv::Mat &src) {
         case TRACKING_STATE:
             if (!stateTrackingTarget(src) || ++tracking_cnt > 100) {    // 最多追踪100帧图像
                 state = SEARCHING_STATE;
+                last_yaw = last_pitch = 0;
+                sum_yaw = sum_pitch = 0;
                 LOGM(STR_CTR(WORD_LIGHT_YELLOW, "into search!"));
             }
             break;
@@ -93,6 +100,11 @@ end:
     if(is_anti_top) { // 判断当前是否为反陀螺模式
         antiTop();
     }else if(target_box.rect != cv::Rect2d()) {
+        if (last_box.rect == cv::Rect2d()) {
+            sum_yaw = sum_pitch = 0;
+            last_yaw = target_box.rect.x + target_box.rect.width / 2.0 - IMAGE_CENTER_X;
+            last_pitch = target_box.rect.y + target_box.rect.height / 2.0 - IMAGE_CENTER_Y;
+        }
         anti_top_cnt = 0;
         time_seq.clear();
         angle_seq.clear();

armor/src/armor_finder/send_target/send_target.cpp

@@ -53,8 +53,12 @@ bool ArmorFinder::sendBoxPosition(uint16_t shoot_delay) {
     double dy = rect.y + rect.height / 2 - IMAGE_CENTER_Y;
 
     // PID
+    #define MAX_I 100 // 这里的数值可以根据实际调试情况进一步微调
     sum_yaw += dx;
     sum_pitch += dy;
+    sum_yaw = (sum_yaw > MAX_I) ? MAX_I : (sum_yaw < -MAX_I ? -MAX_I : sum_yaw);
+    sum_pitch = (sum_pitch > MAX_I) ? MAX_I : (sum_pitch < -MAX_I ? -MAX_I : sum_pitch);
+
     float yaw_I_component = YAW_AIM_KI * sum_yaw;
     float pitch_I_component = PITCH_AIM_KI * sum_pitch;
 

armor/src/serialComm.cpp

@@ -0,0 +1,131 @@
+#include "serialComm.hpp"
+#include <fmt/format.h>
+#include <cstring>
+
+SerialComm::SerialComm() : m_isOpen(false) {
+    std::memset(m_portName, 0, sizeof(m_portName));
+    
+    // Initialize serial port parameters
+    m_serialPort.init(
+        "",
+        SerialConfig::BAUD_RATE,
+        SerialConfig::PARITY_TYPE,
+        SerialConfig::DATA_BITS,
+        SerialConfig::STOP_BITS,
+        SerialConfig::FLOW_CTRL,
+        SerialConfig::READ_TIMEOUT_MS
+    );
+}
+
+SerialComm::~SerialComm() {
+    closePort();
+}
+
+bool SerialComm::findFirstTtyUSB() {
+    std::vector<SerialPortInfo> portInfos = CSerialPortInfo::availablePortInfos();
+    
+    for (const auto& info : portInfos) {
+        
+        // 查找第一个 ttyUSB 设备
+        const char* portStr = info.portName;
+        if (std::strstr(portStr, "ttyCH341USB") != nullptr) {
+            std::strncpy(m_portName, portStr, sizeof(m_portName) - 1);
+            m_portName[sizeof(m_portName) - 1] = '\0';  // 字符串结束
+            fmt::print("[I][SERIAL]: ttyUSB device found: {}\n", m_portName);
+            return true;
+        }
+    }
+    
+    return false;
+}
+
+bool SerialComm::openPort() {
+    if (std::strlen(m_portName) == 0) {
+        fmt::print("[E][Serial]: Port name is empty, call findFirstTtyUSB() first\n");
+        return false;
+    }
+    
+    // Set port name
+    m_serialPort.init(
+        m_portName,
+        SerialConfig::BAUD_RATE,
+        SerialConfig::PARITY_TYPE,
+        SerialConfig::DATA_BITS,
+        SerialConfig::STOP_BITS,
+        SerialConfig::FLOW_CTRL,
+        SerialConfig::READ_TIMEOUT_MS
+    );
+    
+    if (!m_serialPort.open()) {
+        fmt::print("[E][Serial]: Failed to open port {}\n", m_portName);
+        fmt::print("[E][Serial]: Error code: {}\n", m_serialPort.getLastError());
+        m_isOpen = false;
+        return false;
+    }
+    
+    m_isOpen = true;
+    fmt::print("[I][Serial]: Port opened successfully: {}\n", m_portName);
+    fmt::print("[I][Serial]:   Baud rate: {}\n", SerialConfig::BAUD_RATE);
+    fmt::print("[I][Serial]:   Data bits: 8\n");
+    fmt::print("[I][Serial]:   Stop bits: 1\n");
+    fmt::print("[I][Serial]:   Parity: None\n");
+    
+    return true;
+}
+
+void SerialComm::closePort() {
+    if (m_isOpen) {
+        m_serialPort.close();
+        m_isOpen = false;
+        fmt::print("[I][Serial]: Port closed: {}\n", m_portName);
+    }
+}
+
+bool SerialComm::sendData(const char* data, size_t length) {
+    return sendData(reinterpret_cast<const uint8_t*>(data), length);
+}
+
+bool SerialComm::sendData(const uint8_t* data, size_t length) {
+    if (!m_isOpen) {
+        fmt::print("[E][Serial]: Port not open\n");
+        return false;
+    }
+    
+    int bytesWritten = m_serialPort.writeData(data, length);
+    
+    if (bytesWritten > 0) {
+        fmt::print("[I][Serial]: Sent {} bytes\n", bytesWritten);
+        return true;
+    } else {
+        fmt::print("[E][Serial]: Failed to send data\n");
+        return false;
+    }
+}
+
+int SerialComm::receiveData(char* buffer, size_t maxLength) {
+    return receiveData(reinterpret_cast<uint8_t*>(buffer), maxLength);
+}
+
+int SerialComm::receiveData(uint8_t* buffer, size_t maxLength) {
+    if (!m_isOpen) {
+        fmt::print("[E][Serial]: Port not open\n");
+        return -1;
+    }
+    
+    int bytesRead = m_serialPort.readData(buffer, maxLength);
+    
+    if (bytesRead > 0) {
+        fmt::print("[I][Serial]: Received {} bytes\n", bytesRead);
+    }
+    
+    return bytesRead;
+}
+
+void SerialComm::listAllPorts() {
+    std::vector<SerialPortInfo> portInfos = CSerialPortInfo::availablePortInfos();
+    
+    fmt::print("[I][Serial]: Available ports:\n");
+    for (const auto& info : portInfos) {
+        fmt::print("[I][Serial]:   - {}\n", info.portName);
+    }
+}

armor/src/unifiedManager.cpp

@@ -0,0 +1,112 @@
+#include "unifiedManager.hpp"
+
+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)
+{
+    fmt::print("[I][Managr]: Unified device manager created\n");
+}
+
+UnifiedDeviceManager::~UnifiedDeviceManager() {
+    stop();
+}
+
+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", 
+                          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 {
+    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;
+}
+
+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();
+}