1. 重构机器人动画逻辑，采用分帧动画机制，避免在 OnTimer 中阻塞主线程； 2. 动画过程中允许动态中断，确保设备状态变化时可即时响应； 3....

mrDarker

2025-07-03 62a4a8db6c05c98f180ae7f6429a9a232fce6c0c

1. 重构机器人动画逻辑，采用分帧动画机制，避免在 OnTimer 中阻塞主线程；
2. 动画过程中允许动态中断，确保设备状态变化时可即时响应；
3. 动画结束时自动校正位置与角度，确保最终状态准确一致；

 SourceCode/Bond/Servo/CPageGraph1.cpp

@@ -41,6 +41,7 @@
// 定时器
#define TIMER_ID_DEVICE_STATUS      1   // 用于初始化设备状态
#define TIMER_ID_ROBOT_STATUS       2   // 用于周期刷新机器人位置/臂状态
#define TIMER_ID_ROBOT_ANIMATION    3    // 

// CPageGraph1 对话框

@@ -49,17 +50,29 @@
CPageGraph1::CPageGraph1(CWnd* pParent /*=nullptr*/)
    : CDialogEx(IDD_PAGE_GRAPH1, pParent)
{
    m_pGraph = nullptr;
    m_pObserver = nullptr;
    m_bIsRobotMoving = FALSE;
    m_crBkgnd = PAGE_GRPAH1_BACKGROUND_COLOR;
    m_hbrBkgnd = nullptr;
    m_lastRobotPosition = SERVO::ROBOT_POSITION::Port1;
    m_lastArmState[0] = FALSE;
    m_lastArmState[1] = FALSE;
    // ===== 图形界面相关成员变量初始化 =====
    m_pGraph = nullptr;                                 // 图形绘图对象
    m_pObserver = nullptr;                              // 观察者对象（可能是事件观察者）
    m_crBkgnd = PAGE_GRPAH1_BACKGROUND_COLOR;           // 背景颜色
    m_hbrBkgnd = nullptr;                               // 背景刷句柄

    m_arm1Offset = LoadArmOffset("ARM1");
    m_arm2Offset = LoadArmOffset("ARM2");
    // ===== 机器人动画状态初始化 =====
    m_bIsRobotMoving = FALSE;                           // 当前是否正在动画移动
    m_nRobotMoveStartX = 0;                             // 动画起始 X 坐标
    m_nRobotMoveEndX = 0;                               // 动画目标 X 坐标
    m_nRobotMoveSteps = 30;                             // 动画总步数（动画速度控制）
    m_nRobotMoveCurrentStep = 0;                        // 当前动画步数
    m_nRobotMoveStartAngle = 0.0f;                      // 动画起始角度
    m_nRobotMoveEndAngle = 0.0f;                        // 动画目标角度

    // ===== 机器人上一次状态初始化 =====
    m_lastRobotPosition = SERVO::ROBOT_POSITION::Port1; // 上次机器人位置（默认 Port1）
    m_lastArmState[0] = FALSE;                          // 上次机械臂1 状态（未占用）
    m_lastArmState[1] = FALSE;                          // 上次机械臂2 状态（未占用）

    // ===== 机械臂相对偏移量初始化（从配置中加载） =====
    m_arm1Offset = LoadArmOffset("ARM1");               // 加载机械臂1偏移
    m_arm2Offset = LoadArmOffset("ARM2");               // 加载机械臂2偏移

    //m_arm1Offset = { -30, -45 }; // ARM1 从中心向左47, 向上33
    //m_arm2Offset = { 27, -45 };     // ARM2 从中心向右10, 向上33
@@ -494,6 +507,32 @@
    m_lastRobotPosition = position;
}

void CPageGraph1::StartRobotMoveToPosition(SERVO::ROBOT_POSITION position)
{
    auto it = g_positionMap.find(position);
    if (it == g_positionMap.end()) {
        TRACE("Invalid robot position: %d\n", static_cast<int>(position));
        return;
    }

    const RobotPositionMapping& mapping = it->second;

    auto* pImage = m_pGraph->GetImage(IMAGE_ROBOT);
    if (!pImage) return;

    m_nRobotMoveStartX = pImage->x;
    m_nRobotMoveEndX = static_cast<int>(170 + mapping.percentage * (700 - 170));

    m_nRobotMoveStartAngle = pImage->angle;     // 起始角度（当前角度）
    m_nRobotMoveEndAngle = mapping.angle;       // 目标角度

    m_nRobotMoveCurrentStep = 0;
    m_targetRobotPosition = position;
    m_bIsRobotMoving = TRUE;

    SetTimer(TIMER_ID_ROBOT_ANIMATION, 16, nullptr);
}

POINT CPageGraph1::LoadArmOffset(const std::string& armName)
{
    std::string iniPath = GetConfigPath();
@@ -521,37 +560,37 @@

    // 移动到指定位置 (测试使用)
    if (pGraphNmhdr->dwData == INDICATE_LPORT1) {
        MoveRobotToPosition(SERVO::ROBOT_POSITION::Port1);
        StartRobotMoveToPosition(SERVO::ROBOT_POSITION::Port1);
    }
    else if (pGraphNmhdr->dwData == INDICATE_LPORT2) {
        MoveRobotToPosition(SERVO::ROBOT_POSITION::Port2);
        StartRobotMoveToPosition(SERVO::ROBOT_POSITION::Port2);
    }
    else if (pGraphNmhdr->dwData == INDICATE_LPORT3) {
        MoveRobotToPosition(SERVO::ROBOT_POSITION::Port3);
        StartRobotMoveToPosition(SERVO::ROBOT_POSITION::Port3);
    }
    else if (pGraphNmhdr->dwData == INDICATE_LPORT4) {
        MoveRobotToPosition(SERVO::ROBOT_POSITION::Port4);
        StartRobotMoveToPosition(SERVO::ROBOT_POSITION::Port4);
    }
    else if (pGraphNmhdr->dwData == INDICATE_ALIGNER) {
        MoveRobotToPosition(SERVO::ROBOT_POSITION::Aligner);
        StartRobotMoveToPosition(SERVO::ROBOT_POSITION::Aligner);
    }
    else if (pGraphNmhdr->dwData == INDICATE_FLIPER) {
        MoveRobotToPosition(SERVO::ROBOT_POSITION::Fliper);
        StartRobotMoveToPosition(SERVO::ROBOT_POSITION::Fliper);
    }
    else if (pGraphNmhdr->dwData == INDICATE_BONDER1) {
        MoveRobotToPosition(SERVO::ROBOT_POSITION::Bonder1);
        StartRobotMoveToPosition(SERVO::ROBOT_POSITION::Bonder1);
    }
    else if (pGraphNmhdr->dwData == INDICATE_BONDER2) {
        MoveRobotToPosition(SERVO::ROBOT_POSITION::Bonder2);
        StartRobotMoveToPosition(SERVO::ROBOT_POSITION::Bonder2);
    }
    else if (pGraphNmhdr->dwData == INDICATE_VACUUM_BAKE) {
        MoveRobotToPosition(SERVO::ROBOT_POSITION::Bake);
        StartRobotMoveToPosition(SERVO::ROBOT_POSITION::Bake);
    }
    else if (pGraphNmhdr->dwData == INDICATE_BAKE_COOLING) {
        MoveRobotToPosition(SERVO::ROBOT_POSITION::Cooling);
        StartRobotMoveToPosition(SERVO::ROBOT_POSITION::Cooling);
    }
    else if (pGraphNmhdr->dwData == INDICATE_MEASUREMENT) {
        MoveRobotToPosition(SERVO::ROBOT_POSITION::Measurement);
        StartRobotMoveToPosition(SERVO::ROBOT_POSITION::Measurement);
    }
    
    *pResult = 0;
@@ -636,9 +675,50 @@

        // 位置信息状态显示
        if (robotData.position != m_lastRobotPosition) {
            MoveRobotToPosition(robotData.position);
            StartRobotMoveToPosition(robotData.position);
        }
    }
    else if (nIDEvent == TIMER_ID_ROBOT_ANIMATION) {
        if (!m_bIsRobotMoving) {
            KillTimer(TIMER_ID_ROBOT_ANIMATION);
            return;
        }

        m_nRobotMoveCurrentStep++;

        float progress = static_cast<float>(m_nRobotMoveCurrentStep) / m_nRobotMoveSteps;
        if (progress >= 1.0f) {
            progress = 1.0f;
            m_bIsRobotMoving = FALSE;
            KillTimer(TIMER_ID_ROBOT_ANIMATION);
            m_lastRobotPosition = m_targetRobotPosition;
        }

        // 平滑计算位置
        int currentX = static_cast<int>(m_nRobotMoveStartX + progress * (m_nRobotMoveEndX - m_nRobotMoveStartX));
        auto* pImage = m_pGraph->GetImage(IMAGE_ROBOT);
        if (!pImage) return;

        int cx = currentX + pImage->bmWidth / 2;
        int y = 270;
        int cy = y + pImage->bmHeight / 2;

        // 平滑计算角度
        float currentAngle = m_nRobotMoveStartAngle + progress * (m_nRobotMoveEndAngle - m_nRobotMoveStartAngle);
        float radians = currentAngle * 3.1415926f / 180.0f;

        int rotatedX1 = static_cast<int>(cos(radians) * m_arm1Offset.x - sin(radians) * m_arm1Offset.y);
        int rotatedY1 = static_cast<int>(sin(radians) * m_arm1Offset.x + cos(radians) * m_arm1Offset.y);
        int rotatedX2 = static_cast<int>(cos(radians) * m_arm2Offset.x - sin(radians) * m_arm2Offset.y);
        int rotatedY2 = static_cast<int>(sin(radians) * m_arm2Offset.x + cos(radians) * m_arm2Offset.y);

        m_pGraph->UpdateImageCoordinates(IMAGE_ROBOT, currentX, y);
        m_pGraph->UpdateIndicateBoxCoordinates(INDICATE_ROBOT_ARM1, cx + rotatedX1, cy + rotatedY1);
        m_pGraph->UpdateIndicateBoxCoordinates(INDICATE_ROBOT_ARM2, cx + rotatedX2, cy + rotatedY2);
        m_pGraph->UpdateImageAngle(IMAGE_ROBOT, currentAngle);

        Invalidate();
    }

    CDialogEx::OnTimer(nIDEvent);
}

 SourceCode/Bond/Servo/CPageGraph1.h

@@ -34,6 +34,7 @@
    void RotateRobot(float angleInDegrees);
    void BindEquipmentToGraph();
    void MoveRobotToPosition(SERVO::ROBOT_POSITION position);
    void StartRobotMoveToPosition(SERVO::ROBOT_POSITION position);
    POINT LoadArmOffset(const std::string& armName);
    void SaveArmOffset(const std::string& armName, const POINT& pt);

@@ -43,10 +44,36 @@
    BOOL m_bIsRobotMoving;
    COLORREF m_crBkgnd;
    HBRUSH m_hbrBkgnd;

    // ===== 机器人动画相关成员变量 =====

    // 动画目标位置（机器人目标位置枚举）
    SERVO::ROBOT_POSITION m_targetRobotPosition;

    // 动画起始和目标 X 坐标（水平位移）
    int m_nRobotMoveStartX;
    int m_nRobotMoveEndX;

    // 动画步数控制（总步数 & 当前步）
    int m_nRobotMoveSteps;          // 动画总步数（控制动画速度）
    int m_nRobotMoveCurrentStep;    // 当前动画步数进度

    // 动画起始和目标角度（旋转角度，单位：度）
    float m_nRobotMoveStartAngle;   // 起始角度
    float m_nRobotMoveEndAngle;     // 目标角度（旋转角度）

    // ===== 机器人状态相关成员变量 =====

    // 上一次已完成的位置（用于判断是否需要移动）
    SERVO::ROBOT_POSITION m_lastRobotPosition;

    // 上一次已更新的机器人 ARM 占用状态（两个机械臂）
    BOOL m_lastArmState[2];
    POINT m_arm1Offset; // ARM1 从中心向左47, 向上33
    POINT m_arm2Offset; // ARM2 从中心向右10, 向上33

    // 两个机械臂相对于机器人中心的偏移（像素坐标）
    POINT m_arm1Offset;
    POINT m_arm2Offset;


// 对话框数据
#ifdef AFX_DESIGN_TIME