1.CMaster.cpp 第 1644/1667/1691 行在记录 SV 曲线时通过 getGlassFromSlot(0) 取玻璃，而各设备的 ...

chenluhua1980

2025-11-08 bea6407b376a4e426f0b120bae569fba6ab867db

1.CMaster.cpp 第 1644/1667/1691 行在记录 SV 曲线时通过 getGlassFromSlot(0) 取玻璃，而各设备的 initSlots() 都是从 1 开始编号（例如 CBonder.cpp (line 408)、CVacuumBake.cpp (line 415) 等）。槽位 0 永远不存在，所以 pGlass 始终是 nullptr，pGlass->addSVData(...) 的分支从未执行。结果 SERVO::CGlass::m_svDatas 里没有任何曲线数据，GlassJson::ToPrettyString 生成的 pretty 字符串也就没有 sv_datas，导出 CSV 时自然读不到曲线。
同一段代码还有一个潜在 Bug：虽然判断了 channel - 1 < bonderTypes.size()，但真正索引却用的是 bonderTypes[channel]。索引偏移会导致数据类型错位，最后一个通道甚至可能越界。即使修正了槽位，这里也需要同步改成 bonderTypes[channel - 1]（另外两处 vacuumbakeTypes、coolingTypes 也一样）。

 SourceCode/Bond/Servo/CMaster.cpp

@@ -1,4 +1,4 @@
#include "stdafx.h"
#include "stdafx.h"
#include "Common.h"
#include "CMaster.h"
#include <future>
@@ -77,7 +77,7 @@

    CMaster::~CMaster()
    {
        // 释放Job相关
        // 释放Job相关
        for (auto item : m_processJobs) {
            delete item;
        }
@@ -127,36 +127,36 @@

    int CMaster::init()
    {
        LOGI("<Master>正在初始化...");
        LOGI("<Master>正在初始化...");


        //     cclink
        if (m_cclink.Connect(CC_LINK_IE_CONTROL_CHANNEL(1)) != 0) {
            LOGE("连接CC-Link失败.");
            LOGE("连接CC-Link失败.");
        }
        else {
            LOGI("连接CC-Link成功.");
            LOGI("连接CC-Link成功.");
            BoardVersion version{};
            int nRet = m_cclink.GetBoardVersion(version);
            if (nRet == 0) {
                LOGD("版本信息：%s.", version.toString().c_str());
                LOGD("版本信息：%s.", version.toString().c_str());
            }
            else {
                LOGE("获取CC-Link版本信息失败.");
                LOGE("获取CC-Link版本信息失败.");
            }

            BoardStatus status;
            nRet = m_cclink.GetBoardStatus(status);
            if (nRet == 0) {
                LOGD("状态：%s.", status.toString().c_str());
                LOGD("状态：%s.", status.toString().c_str());
            }
            else {
                LOGE("获取CC-Link状态失败.");
                LOGE("获取CC-Link状态失败.");
            }
        }


        // 初始化添加各子设备
        // 初始化添加各子设备
        CLoadPort* pPort1, * pPort2, * pPort3, * pPort4;
        CBonder* pBonder1, * pBonder2;
        CEFEM* pEfem;
@@ -219,31 +219,31 @@



        // 读缓存数据
        // 读缓存数据
        readCache();
        loadState();


        // 定时器
        // 定时器
        g_pMaster = this;
        SetTimer(NULL, 1, 250, (TIMERPROC)MasterTimerProc);


        // 调度线程
        // 调度线程
        m_hDispatchThreadHandle = (HANDLE)_beginthreadex(NULL, 0, SERVO::DispatchThreadFunction, this,
            0, &m_nDispatchThreadAddr);


        // 监控bit线程
        // 监控bit线程
        m_hReadBitsThreadHandle = (HANDLE)_beginthreadex(NULL, 0, SERVO::ReadBitsThreadFunction, this,
            0, &m_nReadBitsThreadAddr);


        // 曲线服务
        // 曲线服务
        CreateDAQBridgeServer();


        LOGI("<Master>初始化完成.");
        LOGI("<Master>初始化完成.");
        return 0;
    }

@@ -254,7 +254,7 @@
        ::WaitForSingleObject(m_hEventReadBitsThreadExit[1], INFINITE);
        ::WaitForSingleObject(m_hEventDispatchThreadExit[1], INFINITE);

        LOGI("<Master>正在结束程序.");
        LOGI("<Master>正在结束程序.");
        for (auto item : m_listEquipment) {
            item->term();
        }
@@ -326,7 +326,7 @@

    int CMaster::stop(int nErCode/* = ER_CODE_NOERROR*/)
    {
        // 运行时间为累加结果，本次停止时刷新；
        // 运行时间为累加结果，本次停止时刷新；
        lock();
        if (m_state != MASTERSTATE::RUNNING && m_state != MASTERSTATE::RUNNING_CONTINUOUS_TRANSFER
            && m_state != MASTERSTATE::RUNNING_BATCH) {
@@ -337,12 +337,12 @@
        unlock();


        // 更新状态
        // 更新状态
        m_nLastError = nErCode;
        setState(MASTERSTATE::STOPPING);


        // ControlJob暂停
        // ControlJob暂停
        lock();
        if (m_pControlJob != nullptr) {
            m_pControlJob->pause();
@@ -377,14 +377,14 @@

    unsigned CMaster::DispatchProc()
    {
        // 优先考虑的类型和次要类型
        // 一种情况，如果不分主次，一直搬G1, 等到Bonder1和Bonder2都放了G1, Aligner也放了G1,
        // Bonder1和Bonder2需要的G2就过不来了
        // 最基本的实现，可以G2和G2轮流搬送，但最好根据Bonder的需求来决定
        // 优先考虑的类型和次要类型
        // 一种情况，如果不分主次，一直搬G1, 等到Bonder1和Bonder2都放了G1, Aligner也放了G1,
        // Bonder1和Bonder2需要的G2就过不来了
        // 最基本的实现，可以G2和G2轮流搬送，但最好根据Bonder的需求来决定
        MaterialsType primaryType, secondaryType;


        // 各种机器
        // 各种机器
        CLoadPort* pLoadPorts[4];
        CEFEM* pEFEM = (CEFEM*)getEquipment(EQ_ID_EFEM);
        pLoadPorts[0] = (CLoadPort*)getEquipment(EQ_ID_LOADPORT1);
@@ -413,7 +413,7 @@
        ASSERT(pMeasurement);

        while (1) {
            // 待退出信号或时间到
            // 待退出信号或时间到
            HANDLE hEvents[] = { m_hEventDispatchThreadExit[0], m_hDispatchEvent };
            int nRet = WaitForMultipleObjects(2, hEvents, FALSE, 500);
            if (nRet == WAIT_OBJECT_0) {
@@ -421,11 +421,11 @@
            }
            

            // 如果状态为STARTING，开始工作并切换到RUNNING状态
            // 如果状态为STARTING，开始工作并切换到RUNNING状态
            lock();
            if (m_state == MASTERSTATE::STARTING) {
                // 发送indexerOperationModeChange到各个机台，成功后切换到RUNNING状态
                // 否则切换到MSERROR状态
                // 发送indexerOperationModeChange到各个机台，成功后切换到RUNNING状态
                // 否则切换到MSERROR状态
                int nRet;
                CEquipment* pEq[6] = { pEFEM, pBonder1, pBonder2, pBakeCooling, 
                    pVacuumBake, pMeasurement};
@@ -440,9 +440,9 @@
                        TRACE("a0001\n", writeCode, retCode);
                    });
                if (nRet != 0) {
                    LOGE("<Master>EFEM切换Start状态失败");
                    LOGE("<Master>EFEM切换Start状态失败");
                    m_nLastError = ER_CODE_OPERATION_MODE_FAIL;
                    m_strLastError = "EFEM切换Start状态失败.";
                    m_strLastError = "EFEM切换Start状态失败.";
                    goto WAIT;
                }
                futures.push_back(promises[0].get_future());
@@ -454,9 +454,9 @@
                        TRACE("a0002\n");
                    });
                if (nRet != 0) {
                    LOGE("<Master>Bonder1切换Start状态失败");
                    LOGE("<Master>Bonder1切换Start状态失败");
                    m_nLastError = ER_CODE_BONDER_OPERATION_MODE_FAIL;
                    m_strLastError = "Bonder1切换Start状态失败.";
                    m_strLastError = "Bonder1切换Start状态失败.";
                    goto WAIT;
                }
                futures.push_back(promises[1].get_future());
@@ -468,9 +468,9 @@
                        TRACE("a0003\n");
                    });
                if (nRet != 0) {
                    LOGE("<Master>Bonder2切换Start状态失败");
                    LOGE("<Master>Bonder2切换Start状态失败");
                    m_nLastError = ER_CODE_BONDER_OPERATION_MODE_FAIL;
                    m_strLastError = "Bonder2切换Start状态失败.";
                    m_strLastError = "Bonder2切换Start状态失败.";
                    goto WAIT;
                }
                futures.push_back(promises[2].get_future());
@@ -482,9 +482,9 @@
                        TRACE("a0004\n");
                    });
                if (nRet != 0) {
                    LOGE("<Master>BakeCooling切换Start状态失败");
                    LOGE("<Master>BakeCooling切换Start状态失败");
                    m_nLastError = ER_CODE_OPERATION_MODE_FAIL;
                    m_strLastError = "BakeCooling切换Start状态失败.";
                    m_strLastError = "BakeCooling切换Start状态失败.";
                    goto WAIT;
                }
                futures.push_back(promises[3].get_future());
@@ -496,9 +496,9 @@
                        TRACE("a0005\n");
                    });
                if (nRet != 0) {
                    LOGE("<Master>VacuumBake切换Start状态失败");
                    LOGE("<Master>VacuumBake切换Start状态失败");
                    m_nLastError = ER_CODE_OPERATION_MODE_FAIL;
                    m_strLastError = "VacuumBake切换Start状态失败.";
                    m_strLastError = "VacuumBake切换Start状态失败.";
                    goto WAIT;
                }
                futures.push_back(promises[4].get_future());
@@ -510,9 +510,9 @@
                        TRACE("a0006\n");
                    });
                if (nRet != 0) {
                    LOGE("<Master>Measurement切换Start状态失败");
                    LOGE("<Master>Measurement切换Start状态失败");
                    m_nLastError = ER_CODE_OPERATION_MODE_FAIL;
                    m_strLastError = "Measurement切换Start状态失败.";
                    m_strLastError = "Measurement切换Start状态失败.";
                    goto WAIT;
                }
                futures.push_back(promises[5].get_future());
@@ -520,16 +520,16 @@

WAIT:
                for (auto& f : futures) {
                    f.wait();  // 阻塞等待对应设备完成
                    f.wait();  // 阻塞等待对应设备完成
                }
                for (int i = 0; i < 6; i++) {
                    if (!bIomcOk[i]) {
                        bIomcOk[6] = FALSE;
                        LOGE("<Master>%s切换Start状态失败", pEq[i]->getName().c_str());
                        LOGE("<Master>%s切换Start状态失败", pEq[i]->getName().c_str());
                    }
                }
                
                // 检查看是否都已经切换到START状态
                // 检查看是否都已经切换到START状态
                if (!bIomcOk[6]) {
                    unlock();
                    setState(MASTERSTATE::MSERROR);
@@ -548,10 +548,10 @@
            }


            // 处理完成当前事务后，切换到停止或就绪状态
            // 处理完成当前事务后，切换到停止或就绪状态
            else if (m_state == MASTERSTATE::STOPPING) {
                unlock();
                LOGI("<Master>开始切换各设备到 Stop 模式...");
                LOGI("<Master>开始切换各设备到 Stop 模式...");

                std::vector<std::promise<void>> promises(6);
                std::vector<std::future<void>> futures;
@@ -569,23 +569,23 @@
                            TRACE("s000%d: ret=%d\n", i + 1, retCode);
                        });
                    if (nRet != 0) {
                        LOGE("<Master>%s切换Stop状态发送失败", pEq[i]->getName().c_str());
                        LOGE("<Master>%s切换Stop状态发送失败", pEq[i]->getName().c_str());
                        m_nLastError = ER_CODE_OPERATION_MODE_FAIL;
                        m_strLastError = pEq[i]->getName() + "切换Stop状态发送失败.";
                        m_strLastError = pEq[i]->getName() + "切换Stop状态发送失败.";
                        bIomcOk[i] = FALSE;
                        promises[i].set_value(); // 避免 wait 阻塞
                        promises[i].set_value(); // 避免 wait 阻塞
                    }
                    futures.push_back(promises[i].get_future());
                }

                for (auto& f : futures) {
                    f.wait();  // 等待所有完成
                    f.wait();  // 等待所有完成
                }

                for (int i = 0; i < 6; ++i) {
                    if (!bIomcOk[i]) {
                        bIomcOk[6] = FALSE;
                        LOGE("<Master>%s切换Stop状态失败", pEq[i]->getName().c_str());
                        LOGE("<Master>%s切换Stop状态失败", pEq[i]->getName().c_str());
                    }
                }

@@ -594,7 +594,7 @@
                    continue;
                }

                LOGI("<Master>所有设备成功切换到 Stop 模式");
                LOGI("<Master>所有设备成功切换到 Stop 模式");
                if(m_nLastError == ER_CODE_NOERROR)
                    setState(MASTERSTATE::READY);
                else
@@ -604,9 +604,9 @@
            }


            // 调度逻辑处理
            // 调度逻辑处理
            else if (m_state == MASTERSTATE::RUNNING) {
                // 检测判断robot状态
                // 检测判断robot状态
                RMDATA& rmd = pEFEM->getRobotMonitoringData();
                if (rmd.status != ROBOT_STATUS::Idle && rmd.status != ROBOT_STATUS::Run) {
                    unlock();
@@ -618,13 +618,13 @@
                        m_pActiveRobotTask->place();
                    }
                    unlock();
                    // 检测到当前有正在下午的任务，确保当前任务完成或中止后继续
                    // LOGI("检测到当前有正在下午的任务，确保当前任务完成或中止后继续...");
                    // 检测到当前有正在下午的任务，确保当前任务完成或中止后继续
                    // LOGI("检测到当前有正在下午的任务，确保当前任务完成或中止后继续...");
                    continue;
                }


                // Bonder1、Bonder2、Fliper、VacuumBake、Aligner，统计G2和G1的数量, 配对组数, 多出的类型
                // Bonder1、Bonder2、Fliper、VacuumBake、Aligner，统计G2和G1的数量, 配对组数, 多出的类型
                int nG2Count = 0, nG1Count = 0, nGlassGroup, nExtraType;
                if (pBonder1->slotHasGlass(0)) {
                    nG2Count++;
@@ -691,7 +691,7 @@


                // Measurement NG -> LoadPort
                // NG回原位
                // NG回原位
                if (!rmd.armState[1]) {
                    m_pActiveRobotTask = createTransferTask_restore(pMeasurement, pLoadPorts);
                    CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
@@ -705,7 +705,7 @@
                }

                
                // BakeCooling内部
                // BakeCooling内部
                // Bake -> Cooling
                if (!rmd.armState[0]) {
                    m_pActiveRobotTask = createTransferTask_bake_to_cooling(pBakeCooling);
@@ -819,9 +819,9 @@
                continue;
            }

            // 批处理模式，最终以此为准，但先保留之前的单片模式
            // 批处理模式，最终以此为准，但先保留之前的单片模式
            else if (m_state == MASTERSTATE::RUNNING_BATCH) {
                // 1) 控制作业生命周期保障
                // 1) 控制作业生命周期保障
                if (m_pControlJob == nullptr) { unlock(); continue; }
                CJState cjst = m_pControlJob->state();
                if (cjst == CJState::Completed || cjst == CJState::Aborted || cjst == CJState::Failed) {
@@ -829,20 +829,20 @@
                    continue;
                }
                if (cjst == CJState::NoState) {
                    LOGI("<Master>ControlJob已经进入列队");
                    LOGI("<Master>ControlJob已经进入列队");
                    m_pControlJob->queue();
                }
                if (m_pControlJob->state() == CJState::Queued) {
                    LOGI("<Master>ControlJob已经启动");
                    LOGI("<Master>ControlJob已经启动");
                    m_pControlJob->start();
                    if (m_listener.onCjStart) m_listener.onCjStart(this, m_pControlJob);
                }
                if (m_pControlJob->state() == CJState::Paused) {
                    LOGI("<Master>ControlJob已经恢复运行");
                    LOGI("<Master>ControlJob已经恢复运行");
                    m_pControlJob->resume();
                }

                // 2) 若当前无 PJ，则选择一个并上报
                // 2) 若当前无 PJ，则选择一个并上报
                if (m_inProcesJobs.empty()) {
                    if (auto pj = acquireNextProcessJob()) {
                        m_inProcesJobs.push_back(pj);
@@ -850,35 +850,35 @@
                    }
                }
                if (m_inProcesJobs.empty()) {
                    LOGE("<Master>选择当前ProcessJob失败！");
                    LOGE("<Master>选择当前ProcessJob失败！");
                    unlock();
                    continue;
                }

                // 3) 若队列无 Glass，拉取到等待队列
                // 3) 若队列无 Glass，拉取到等待队列
                if (m_queueGlasses.empty()) {
                    int nCount = acquireGlassToQueue();
                    if (nCount > 0) {
                        LOGI("<Master>已加入 %d 块Glass到工艺列队！", nCount);
                        LOGI("<Master>已加入 %d 块Glass到工艺列队！", nCount);
                    }
                }

                // 4) 机器人状态
                // 4) 机器人状态
                RMDATA& rmd = pEFEM->getRobotMonitoringData();
                if (rmd.status != ROBOT_STATUS::Idle && rmd.status != ROBOT_STATUS::Run) {
                    unlock(); continue;
                }

                // 5) 正在执行的 RobotTask 先让它跑完一拍
                // 5) 正在执行的 RobotTask 先让它跑完一拍
                if (m_pActiveRobotTask != nullptr) {
                    if (m_pActiveRobotTask->isPicked()) {
                        m_pActiveRobotTask->place();
                    }
                    unlock(); // 等当前任务完成或中止后继续
                    unlock(); // 等当前任务完成或中止后继续
                    continue;
                }

                // 6) ——关键：全局统计 G1/G2 与组数门限（与单片分支对齐）——
                // 6) ——关键：全局统计 G1/G2 与组数门限（与单片分支对齐）——
                auto countG1G2 = [&]() {
                    int g1 = 0, g2 = 0;
                    if (pBonder1->slotHasGlass(0)) g2++;
@@ -900,20 +900,20 @@
                int nGlassGroup = min(g1Count, g2Count);
                int nExtraType = (g1Count == g2Count ? 0 : (g1Count > g2Count ? 1 : 2));

                // primary/secondary 统一定义（secondary 默认 G0）
                // primary/secondary 统一定义（secondary 默认 G0）
                MaterialsType primaryType = MaterialsType::G1;
                MaterialsType secondaryType = MaterialsType::G0;
                if (nExtraType == 0) primaryType = MaterialsType::G2; // 与单片分支一致
                if (nExtraType == 0) primaryType = MaterialsType::G2; // 与单片分支一致
                else                 primaryType = MaterialsType::G1;

                // 组数门限：≥2 组时不再从 LP 上片，避免堆积（与单片一致）
                // 组数门限：≥2 组时不再从 LP 上片，避免堆积（与单片一致）
                bool blockLoadFromLP = (nGlassGroup >= 2);

                // 7) Measurement -> LoadPort（固定：G1 优先回 LP）
                // 7) Measurement -> LoadPort（固定：G1 优先回 LP）
                if (rmd.armState[0] || rmd.armState[1]) {
                    LOGD("Arm1 %s, Arm2 %s.",
                        rmd.armState[0] ? _T("不可用") : _T("可用"),
                        rmd.armState[1] ? _T("不可用") : _T("可用"));
                        rmd.armState[0] ? _T("不可用") : _T("可用"),
                        rmd.armState[1] ? _T("不可用") : _T("可用"));
                }
                for (int s = 0; s < 4; s++) {
                    PortType pt = pLoadPorts[s]->getPortType();
@@ -928,7 +928,7 @@
                BATCH_PORT_PUT:
                CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);

                // 8) Measurement NG -> LoadPort（原位回退）
                // 8) Measurement NG -> LoadPort（原位回退）
                if (!rmd.armState[1]) {
                    m_pActiveRobotTask = createTransferTask_restore(pMeasurement, pLoadPorts);
                    CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
@@ -940,7 +940,7 @@
                    CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
                }

                // 10) BakeCooling 内部（Bake -> Cooling）
                // 10) BakeCooling 内部（Bake -> Cooling）
                if (!rmd.armState[0]) {
                    m_pActiveRobotTask = createTransferTask_bake_to_cooling(pBakeCooling);
                    CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
@@ -956,7 +956,7 @@
                    CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
                }

                // 12) Fliper(G2) -> Bonder（前置：VacuumBake 有 processed G1；输出 G2 到 Bonder slot0）
                // 12) Fliper(G2) -> Bonder（前置：VacuumBake 有 processed G1；输出 G2 到 Bonder slot0）
                if (auto pSrcSlot = pVacuumBake->getProcessedSlot(MaterialsType::G1)) {
                    if (!rmd.armState[1] && pBonder1->canPlaceGlassInSlot(0)) {
                        m_pActiveRobotTask = createTransferTask(pFliper, pBonder1, MaterialsType::G2, MaterialsType::G0, 2);
@@ -968,7 +968,7 @@
                    }
                }

                // 13) VacuumBake(G1) -> Bonder（槽级判定：slot0(G2) 已有且 slot1(G1) 为空）
                // 13) VacuumBake(G1) -> Bonder（槽级判定：slot0(G2) 已有且 slot1(G1) 为空）
                if (!rmd.armState[0] && pBonder1->slotHasGlass(0) && !pBonder1->slotHasGlass(1)) {
                    m_pActiveRobotTask = createTransferTask(pVacuumBake, pBonder1, MaterialsType::G1, MaterialsType::G0);
                    CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
@@ -978,7 +978,7 @@
                    CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
                }

                // 14) Aligner -> Fliper(G2) 以及 -> VacuumBake(G1)（固定映射）
                // 14) Aligner -> Fliper(G2) 以及 -> VacuumBake(G1)（固定映射）
                if (!rmd.armState[1]) {
                    m_pActiveRobotTask = createTransferTask(pAligner, pFliper, MaterialsType::G2, MaterialsType::G0);
                    CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
@@ -988,13 +988,13 @@
                    CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
                }

                // 15) Aligner -> LoadPort（restore）
                // 15) Aligner -> LoadPort（restore）
                if (!rmd.armState[1]) {
                    m_pActiveRobotTask = createTransferTask_restore(pAligner, pLoadPorts);
                    CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
                }

                // 16) LoadPort -> Aligner（受组数门限控制；统一 buddy/状态时序）
                // 16) LoadPort -> Aligner（受组数门限控制；统一 buddy/状态时序）
                if (blockLoadFromLP) { unlock(); continue; }

                for (int s = 0; s < 4; s++) {
@@ -1011,17 +1011,17 @@
                                continue;
                            }

                            // 统一：queue -> start -> setContext -> move queue→inProcess -> onPanelStart
                            // 统一：queue -> start -> setContext -> move queue→inProcess -> onPanelStart
                            pGlass->queue();
                            pGlass->start();
                            pEFEM->setContext(pGlass);

                            bool bMoved = glassFromQueueToInPorcess(pGlass);
                            if (bMoved) {
                                LOGI("<Master>Glass(%s)从等待列队到工艺列队转移成功.", pGlass->getID().c_str());
                                LOGI("<Master>Glass(%s)从等待列队到工艺列队转移成功.", pGlass->getID().c_str());
                            }
                            else {
                                LOGE("<Master>Glass(%s)从等待列队到工艺列队转移失败.", pGlass->getID().c_str());
                                LOGE("<Master>Glass(%s)从等待列队到工艺列队转移失败.", pGlass->getID().c_str());
                            }

                            if (m_listener.onPanelStart) m_listener.onPanelStart(this, pGlass);
@@ -1038,9 +1038,9 @@
            }


            // 千传模式调度逻辑
            // 千传模式调度逻辑
            else if (m_state == MASTERSTATE::RUNNING_CONTINUOUS_TRANSFER) {
                // 检测判断robot状态
                // 检测判断robot状态
                RMDATA& rmd = pEFEM->getRobotMonitoringData();
                if (rmd.status != ROBOT_STATUS::Idle && rmd.status != ROBOT_STATUS::Run) {
                    unlock();
@@ -1052,8 +1052,8 @@
                        m_pActiveRobotTask->place();
                    }
                    unlock();
                    // 检测到当前有正在下午的任务，确保当前任务完成或中止后继续
                    // LOGI("检测到当前有正在下午的任务，确保当前任务完成或中止后继续...");
                    // 检测到当前有正在下午的任务，确保当前任务完成或中止后继续
                    // LOGI("检测到当前有正在下午的任务，确保当前任务完成或中止后继续...");
                    continue;
                }

@@ -1089,20 +1089,20 @@
                        3, pMeasurement, 0);
                    if (m_pActiveRobotTask != nullptr) {
                        m_nContinuousTransferStep = CTStep_BakeCooling_Measurement;
                        LOGI("<ContinuousTransfer>千传测试，开始搬送任务(BakeCooling -> Measurement)...");
                        LOGI("<ContinuousTransfer>千传测试，开始搬送任务(BakeCooling -> Measurement)...");
                    }
                    CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
                }

                
                // BakeCooling内部
                // BakeCooling内部
                if ((m_nContinuousTransferStep == CTStep_Unknow || m_nContinuousTransferStep == CTStep_BakeCooling_BakeCooling2)
                    && !rmd.armState[0]) {
                    m_pActiveRobotTask = createTransferTask_continuous_transfer(pBakeCooling,
                        2, pBakeCooling, 3);
                    if (m_pActiveRobotTask != nullptr) {
                        m_nContinuousTransferStep = CTStep_BakeCooling_BakeCooling3;
                        LOGI("<ContinuousTransfer>千传测试，开始搬送任务(BakeCooling-2 -> BakeCooling-3)...");
                        LOGI("<ContinuousTransfer>千传测试，开始搬送任务(BakeCooling-2 -> BakeCooling-3)...");
                    }
                    CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
                }
@@ -1112,7 +1112,7 @@
                        1, pBakeCooling, 2);
                    if (m_pActiveRobotTask != nullptr) {
                        m_nContinuousTransferStep = CTStep_BakeCooling_BakeCooling2;
                        LOGI("<ContinuousTransfer>千传测试，开始搬送任务(BakeCooling-1 -> BakeCooling-2)...");
                        LOGI("<ContinuousTransfer>千传测试，开始搬送任务(BakeCooling-1 -> BakeCooling-2)...");
                    }
                    CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
                }
@@ -1122,7 +1122,7 @@
                        0, pBakeCooling, 1);
                    if (m_pActiveRobotTask != nullptr) {
                        m_nContinuousTransferStep = CTStep_BakeCooling_BakeCooling1;
                        LOGI("<ContinuousTransfer>千传测试，开始搬送任务(BakeCooling-0 -> BakeCooling-1)...");
                        LOGI("<ContinuousTransfer>千传测试，开始搬送任务(BakeCooling-0 -> BakeCooling-1)...");
                    }
                    CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
                }
@@ -1134,7 +1134,7 @@
                        1, pBakeCooling, 0);
                    if (m_pActiveRobotTask != nullptr) {
                        m_nContinuousTransferStep = CTStep_VacuumBake_BakeCooling;
                        LOGI("<ContinuousTransfer>千传测试，开始搬送任务(VacuumBake(G1) -> BakeCooling)...");
                        LOGI("<ContinuousTransfer>千传测试，开始搬送任务(VacuumBake(G1) -> BakeCooling)...");
                    }
                    CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
                }
@@ -1146,7 +1146,7 @@
                        0, pVacuumBake, 1);
                    if (m_pActiveRobotTask != nullptr) {
                        m_nContinuousTransferStep = CTStep_VacuumBake_VacuumBake;
                        LOGI("<ContinuousTransfer>千传测试，开始搬送任务(VacuumBake(G1-0) -> VacuumBake(G1-1))...");
                        LOGI("<ContinuousTransfer>千传测试，开始搬送任务(VacuumBake(G1-0) -> VacuumBake(G1-1))...");
                    }
                    CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
                }
@@ -1158,7 +1158,7 @@
                        1, pVacuumBake, 0);
                    if (m_pActiveRobotTask != nullptr) {
                        m_nContinuousTransferStep = CTStep_Bonder2_VacuumBake;
                        LOGI("<ContinuousTransfer>千传测试，开始搬送任务(Bonder2 -> VacuumBake(G1))...");
                        LOGI("<ContinuousTransfer>千传测试，开始搬送任务(Bonder2 -> VacuumBake(G1))...");
                    }
                    CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
                }
@@ -1170,7 +1170,7 @@
                        1, pBonder2, 1);
                    if (m_pActiveRobotTask != nullptr) {
                        m_nContinuousTransferStep = CTStep_Bonder1_Bonder2;
                        LOGI("<ContinuousTransfer>千传测试，开始搬送任务(Bonder1 -> Bonder2)...");
                        LOGI("<ContinuousTransfer>千传测试，开始搬送任务(Bonder1 -> Bonder2)...");
                    }
                    CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
                }
@@ -1182,7 +1182,7 @@
                        0, pBonder1, 1);
                    if (m_pActiveRobotTask != nullptr) {
                        m_nContinuousTransferStep = CTStep_Fliper_Bonder1;
                        LOGI("<ContinuousTransfer>千传测试，开始搬送任务(Fliper(G2) -> Bonder1)...");
                        LOGI("<ContinuousTransfer>千传测试，开始搬送任务(Fliper(G2) -> Bonder1)...");
                    }
                    CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
                }
@@ -1194,7 +1194,7 @@
                        0, pFliper, 0);
                    if (m_pActiveRobotTask != nullptr) {
                        m_nContinuousTransferStep = CTStep_Aligner_Fliper;
                        LOGI("<ContinuousTransfer>千传测试，开始搬送任务(Aligner -> Fliper(G2))...");
                        LOGI("<ContinuousTransfer>千传测试，开始搬送任务(Aligner -> Fliper(G2))...");
                    }
                    CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
                }
@@ -1213,7 +1213,7 @@
                                m_nContinuousTransferStep = CTStep_LoadPort_Aligner;
                                m_nContinuousWorkingPort = p;
                                m_nContinuousWorkingSlot = slot;
                                LOGI("<ContinuousTransfer>千传测试，开始搬送任务(LoadPort -> Aligner)...");
                                LOGI("<ContinuousTransfer>千传测试，开始搬送任务(LoadPort -> Aligner)...");
                                pEFEM->setContext(m_pActiveRobotTask->getContext());
                                goto CT_PORT_GET;
                            }
@@ -1224,7 +1224,7 @@
            CT_PORT_GET:
                if (m_pActiveRobotTask != nullptr) {
                    m_nContinuousTransferStep = CTStep_begin;
                    LOGI("<ContinuousTransfer>千传测试，开始第 %d 轮", m_nContinuousTransferCount + 1);
                    LOGI("<ContinuousTransfer>千传测试，开始第 %d 轮", m_nContinuousTransferCount + 1);
                }
                CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);

@@ -1241,13 +1241,13 @@


        // _endthreadex(0);
        TRACE("CMaster::DispatchProc 线程退出\n");
        TRACE("CMaster::DispatchProc 线程退出\n");
        return 0;
    }

    unsigned CMaster::ReadBitsProc()
    {
        // 标志位清0复位		
        // 标志位清0复位		
        {
            StationIdentifier station;
            station.nNetNo = 0;
@@ -1258,13 +1258,13 @@


        while (1) {
            // 待退出信号或时间到
            // 待退出信号或时间到
            int nRet = ::WaitForSingleObject(m_hEventReadBitsThreadExit[0], 1000);
            if (nRet == WAIT_OBJECT_0) {
                break;
            }

            // 读标志位
            // 读标志位
            for (auto item : m_listEquipment) {
                const StationIdentifier& station = item->getStation();
                MemoryBlock& block = item->getReadBitBlock();
@@ -1282,7 +1282,7 @@


        // _endthreadex(0);
        TRACE("CMaster::ReadBitsProc 线程退出\n");
        TRACE("CMaster::ReadBitsProc 线程退出\n");
        return 0;
    }

@@ -1317,10 +1317,10 @@
        listener.onPreFethedOutJob = [&](void* pEquipment, int port, CJobDataB* pJobDataB) -> BOOL {
            CEquipment* p = (CEquipment*)pEquipment;

            // 可能要加这一句
            // 可能要加这一句
            Sleep(750);

            // 取片，更新当前搬送任务
            // 取片，更新当前搬送任务
            BOOL bOk = FALSE;
            lock();
            if (m_pActiveRobotTask != nullptr) {
@@ -1335,7 +1335,7 @@
                            && pJobDataS->getCassetteSequenceNo() == pJobDataB->getCassetteSequenceNo()
                            && pJobDataS->getJobSequenceNo() == pJobDataB->getJobSequenceNo()) {
                            bOk = TRUE;
                            LOGD("<CMaster>onPreFethedOutJob, 已校验数据一致性.");
                            LOGD("<CMaster>onPreFethedOutJob, 已校验数据一致性.");
                        }
                        LOGD("<CMaster>onPreFethedOutJob 0004.");
                        if (pJobDataS != nullptr) {
@@ -1355,7 +1355,7 @@
            unlock();

            if (!bOk) {
                LOGE("<CMaster>onPreFethedOutJob, 数据校验失败.");
                LOGE("<CMaster>onPreFethedOutJob, 数据校验失败.");
            }

            return bOk;
@@ -1364,14 +1364,14 @@
        listener.onPreStoredJob = [&](void* pEquipment, int port, CJobDataB* pJobDataB, short& slot) -> BOOL {
            CEquipment* p = (CEquipment*)pEquipment;

            // 可能要加这一句
            // 可能要加这一句
            Sleep(750);

            // 放片，更新当前搬送任务
            // 放片，更新当前搬送任务
            BOOL bOk = FALSE;
            lock();
            if (m_pActiveRobotTask != nullptr) {
                // 是否已经进入手臂(即取片完成),进入下一步，放片
                // 是否已经进入手臂(即取片完成),进入下一步，放片
                if (m_pActiveRobotTask->isPicking() && 
                    ((m_pActiveRobotTask->getArmNo() == 1 && p->getID() == EQ_ID_ARM_TRAY1)
                    || (m_pActiveRobotTask->getArmNo() == 2 && p->getID() == EQ_ID_ARM_TRAY2))
@@ -1380,32 +1380,32 @@
                    bOk = TRUE;
                }

                // 是否放片完成
                // 是否放片完成
                else if (m_pActiveRobotTask->isPlacing() &&
                    m_pActiveRobotTask->getTarPosition() == p->getID()) {
                    CGlass* pGlass = p->getGlassFromSlot(m_pActiveRobotTask->getTarSlot());
                    if (pGlass == nullptr) {
                        bOk = TRUE;
                        slot = m_pActiveRobotTask->getTarSlot();
                        LOGI("<CMaster>onPreStoredJob, 已校验数据一致性.");
                        LOGI("<CMaster>onPreStoredJob, 已校验数据一致性.");
                    }
                }

                // 是否回撤
                // 是否回撤
                else if (m_pActiveRobotTask->isRestoring() &&
                    m_pActiveRobotTask->getSrcPosition() == p->getID()) {
                    CGlass* pGlass = p->getGlassFromSlot(m_pActiveRobotTask->getSrcSlot());
                    if (pGlass == nullptr && m_pActiveRobotTask->getSrcSlot() == port) {
                        bOk = TRUE;
                        slot = m_pActiveRobotTask->getSrcSlot();
                        LOGI("<CMaster>onPreStoredJob, 已校验数据一致性.");
                        LOGI("<CMaster>onPreStoredJob, 已校验数据一致性.");
                    }
                }
            }
            unlock();

            if (!bOk) {
                LOGE("<CMaster>onPreStoredJob, 数据校验失败.");
                LOGE("<CMaster>onPreStoredJob, 数据校验失败.");
            }

            return bOk;
@@ -1418,11 +1418,11 @@
                m_listener.onEqDataChanged(this, p, 0);
            }

            // 取放片，更新当前搬送任务
            // 取放片，更新当前搬送任务
            if (code == EDCC_FETCHOUT_JOB) {
                lock();
                if (m_pActiveRobotTask != nullptr && m_pActiveRobotTask->getSrcPosition() == p->getID()) {
                    LOGI("开始取片...");
                    LOGI("开始取片...");
                }
                unlock();
            }
@@ -1433,7 +1433,7 @@
                    && ((m_pActiveRobotTask->getArmNo() == 1 && p->getID() == EQ_ID_ARM_TRAY1)
                        || (m_pActiveRobotTask->getArmNo() == 2 && p->getID() == EQ_ID_ARM_TRAY2))
                    ) {
                    LOGI("取片完成.");
                    LOGI("取片完成.");
                    m_pActiveRobotTask->fetchOut();
                    m_pActiveRobotTask->picked();
                }
@@ -1447,17 +1447,17 @@
                    if (m_state == MASTERSTATE::RUNNING_CONTINUOUS_TRANSFER) {
                        if (m_nContinuousTransferStep == CTStep_end) {
                            m_nContinuousTransferCount++;
                            LOGI("<ContinuousTransfer>千传测试，第 %d 轮结束", m_nContinuousTransferCount);
                            LOGI("<ContinuousTransfer>千传测试，第 %d 轮结束", m_nContinuousTransferCount);
                            if (m_listener.onCTRoundEnd != nullptr) {
                                m_listener.onCTRoundEnd(this, m_nContinuousTransferCount);
                            }
                        }
                    }

                    LOGI("放片完成...");
                    // 完成此条搬送任务，但要把数据和消息上抛应用层
                    LOGI("放片完成...");
                    // 完成此条搬送任务，但要把数据和消息上抛应用层

                    // 如果是搬送回从AOI搬送回Port, 则glass工艺完成
                    // 如果是搬送回从AOI搬送回Port, 则glass工艺完成
                    if (m_pActiveRobotTask->getSrcPosition() == EQ_ID_MEASUREMENT) {
                        CGlass* pGlass = (CGlass*)m_pActiveRobotTask->getContext();
                        pGlass->complete();
@@ -1466,32 +1466,32 @@
                        this->saveState();
                        bool bMoved = glassFromInPorcessToComplete(pGlass);
                        if (bMoved) {
                            LOGI("<Master>Glass(%s)从工艺列队到完成列队转移成功.",
                            LOGI("<Master>Glass(%s)从工艺列队到完成列队转移成功.",
                                pGlass->getID().c_str());
                        }
                        else {
                            LOGE("<Master>Glass(%s)从工艺列队到完成列队转移失败.",
                            LOGE("<Master>Glass(%s)从工艺列队到完成列队转移失败.",
                                pGlass->getID().c_str());
                        }
                        if (m_listener.onPanelEnd != nullptr) {
                            m_listener.onPanelEnd(this, pGlass);
                        }

                        // 检查PJ是否已经完成
                        // 检查PJ是否已经完成
                        CProcessJob* pJob = getGlassProcessJob((CGlass*)m_pActiveRobotTask->getContext());
                        if (pJob != nullptr && checkAndUpdatePjComplete(pJob)) {
                            this->saveState();
                            LOGE("<Master>ProcessJob(%s)完成.",
                            LOGE("<Master>ProcessJob(%s)完成.",
                                pJob->id().c_str());
                            if (m_listener.onPjEnd != nullptr) {
                                m_listener.onPjEnd(this, pJob);
                            }

                            // 检查CJ是否已经完成
                            // 检查CJ是否已经完成
                            ASSERT(m_pControlJob);
                            if (checkAndUpdateCjComplete(m_pControlJob)) {
                                this->saveState();
                                LOGE("<Master>ControlJob(%s)完成.",
                                LOGE("<Master>ControlJob(%s)完成.",
                                    m_pControlJob->id().c_str());
                                if (m_listener.onCjEnd != nullptr) {
                                    m_listener.onCjEnd(this, pJob);
@@ -1520,8 +1520,8 @@
                    && m_pActiveRobotTask->getSrcPosition() == p->getID()) {
                    m_pActiveRobotTask->stored();
                    m_pActiveRobotTask->restored();
                    LOGI("回撤完成...");
                    // 完成此条搬送任务，但要把数据和消息上抛应用层
                    LOGI("回撤完成...");
                    // 完成此条搬送任务，但要把数据和消息上抛应用层
                    unlock();


@@ -1552,11 +1552,11 @@
            }
        };
        listener.onMapMismatch = [&](void* pEquipment, short scanMap, short downMap) {
            LOGE("<Master-%s>Port InUse, map(%d!=%d)不一致，请检查。",
            LOGE("<Master-%s>Port InUse, map(%d!=%d)不一致，请检查。",
                ((CEquipment*)pEquipment)->getName().c_str(), scanMap, downMap);
        };
        listener.onPortStatusChanged = [&](void* pEquipment, short status, __int64 data) {
            LOGE("<Master-%s>onPortStatusChanged。status=%d, data=%lld", ((CEquipment*)pEquipment)->getName().c_str(), status);
            LOGE("<Master-%s>onPortStatusChanged。status=%d, data=%lld", ((CEquipment*)pEquipment)->getName().c_str(), status);
            if (status == PORT_INUSE && m_pControlJob != nullptr) {
                CLoadPort* pPort = (CLoadPort*)pEquipment;
                auto pjs = m_pControlJob->getPjs();
@@ -1628,19 +1628,20 @@
            ((CEquipment*)pEquipment)->parsingSVData((const char*)rawData.data(), rawData.size(), params);
        

            // 以下加入到曲线数据中

            // 以下加入到曲线数据中
            LOGD("<Master>onSVDataReport 001");

            const int64_t ts = now_ms_epoch();
            int eqid = ((CEquipment*)pEquipment)->getID();
            if (eqid == EQ_ID_Bonder1 || eqid == EQ_ID_Bonder2) {
                // 定义 Bonder 的特定映射
                LOGD("<Master>onSVDataReport 002A");
                // 定义 Bonder 的特定映射
                std::vector<std::pair<int, int>> bonderMapping = {
                    {1, 1}, {2, 2}, {3, 3}, {4, 4}, {5, 5}, {6, 6}, {7, 7},
                    {8, 8}, {9, 9}, {10, 10}, {11, 11}, {12, 12}, {13, 13}, {14, 14}, {15, 15}, {16, 16}
                };

                CGlass* pGlass = ((CEquipment*)pEquipment)->getGlassFromSlot(0);
                CGlass* pGlass = ((CEquipment*)pEquipment)->getGlassFromSlot(1);
                auto& dataTypes = CServoUtilsTool::getEqDataTypes();
                auto& bonderTypes = dataTypes[eqid];
                for (const auto& mapping : bonderMapping) {
@@ -1651,20 +1652,22 @@
                        if(m_pCollector != nullptr)
                            m_pCollector->buffersPush(eqid, channel, ts, params.at(paramIndex).getDoubleValue());
                        if(pGlass != nullptr)
                            pGlass->addSVData(eqid, bonderTypes[channel], ts, params.at(paramIndex).getDoubleValue());
                            pGlass->addSVData(eqid, bonderTypes[channel - 1], ts, params.at(paramIndex).getDoubleValue());
                    }
                }
            }
            else if (eqid == EQ_ID_VACUUMBAKE) {
                // 定义 VACUUMBAKE 的特定映射
                LOGD("<Master>onSVDataReport 002");
                // 定义 VACUUMBAKE 的特定映射
                std::vector<std::pair<int, int>> vacuumMapping = {
                    {1, 1}, {2, 2}, {3, 3}, {4, 4}, {5, 5}, {6, 6}, {7, 7},
                    {10, 8}, {11, 9}, {12, 10}, {13, 11}, {14, 12}, {15, 13}, {16, 14}
                };

                CGlass* pGlass = ((CEquipment*)pEquipment)->getGlassFromSlot(0);
                CGlass* pGlass = ((CEquipment*)pEquipment)->getGlassFromSlot(1);
                auto& dataTypes = CServoUtilsTool::getEqDataTypes();
                auto& vacuumbakeTypes = dataTypes[eqid];
                LOGD("<Master>onSVDataReport 003 : %d", vacuumMapping.size());
                for (const auto& mapping : vacuumMapping) {
                    int paramIndex = mapping.first;
                    int channel = mapping.second;
@@ -1673,20 +1676,22 @@
                        if (m_pCollector != nullptr)
                            m_pCollector->buffersPush(eqid, channel, ts, params.at(paramIndex).getDoubleValue());
                        if (pGlass != nullptr)
                            pGlass->addSVData(eqid, vacuumbakeTypes[channel], ts, params.at(paramIndex).getDoubleValue());
                            pGlass->addSVData(eqid, vacuumbakeTypes[channel - 1], ts, params.at(paramIndex).getDoubleValue());
                    }
                }
            }
            else if (eqid == EQ_ID_BAKE_COOLING) {
                // 定义 BAKE_COOLING 的特定映射
                LOGD("<Master>onSVDataReport 002B");
                // 定义 BAKE_COOLING 的特定映射
                std::vector<std::pair<int, int>> coolingMapping = {
                    {1, 1}, {2, 2}, {3, 3}, {4, 4}, {5, 5}, {6, 6},
                    {11, 7}, {12, 8}, {13, 9}, {14, 10}, {15, 11}, {16, 12}
                };

                CGlass* pGlass = ((CEquipment*)pEquipment)->getGlassFromSlot(0);
                CGlass* pGlass = ((CEquipment*)pEquipment)->getGlassFromSlot(1);
                auto& dataTypes = CServoUtilsTool::getEqDataTypes();
                auto& coolingTypes = dataTypes[eqid];
                LOGD("<Master>onSVDataReport 003B : %d", coolingMapping.size());
                for (const auto& mapping : coolingMapping) {
                    int paramIndex = mapping.first;
                    int channel = mapping.second;
@@ -1695,13 +1700,13 @@
                        if (m_pCollector != nullptr)
                            m_pCollector->buffersPush(eqid, channel, ts, params.at(paramIndex).getDoubleValue());
                        if (pGlass != nullptr)
                            pGlass->addSVData(eqid, coolingTypes[channel], ts, params.at(paramIndex).getDoubleValue());
                            pGlass->addSVData(eqid, coolingTypes[channel - 1], ts, params.at(paramIndex).getDoubleValue());
                    }
                }
            }


            // 以下是输出测试
            // 以下是输出测试
            std::string strOut;
            char szBuffer[256];
            for (auto p : params) {
@@ -1722,14 +1727,14 @@
            CEquipment* pEq = (CEquipment*)pEquipment;
            CGlass* pGlass = (CGlass*)pContext;

            // 如果AOI检测失败，要停机
            // 如果AOI检测失败，要停机
            if (pEq->getID() == EQ_ID_MEASUREMENT) {
                LOGD("<CMaster-%s>onPanelDataReport 01", ((CEquipment*)pEquipment)->getName().c_str());
                if (pGlass->getAOIInspResult() == InspResult::Fail) {
                    LOGD("<CMaster-%s>onPanelDataReport 02", ((CEquipment*)pEquipment)->getName().c_str());
                    if (stop() == 0) {
                        m_nLastError = ER_CODE_AOI_NG;
                        m_strLastError = "AOI检测未通过.";
                        m_strLastError = "AOI检测未通过.";
                    }
                }
            }
@@ -1766,7 +1771,7 @@
    }

    /*
     * 添加LoadPort1
     * 添加LoadPort1
     * index -- 0~3
     */
    CLoadPort* CMaster::addLoadPort(int index)
@@ -1786,7 +1791,7 @@


        pEquipment->init();
        LOGE("已添加“%s”.", pEquipment->getName().c_str());
        LOGE("已添加“%s”.", pEquipment->getName().c_str());


        return pEquipment;
@@ -1805,7 +1810,7 @@


        pEquipment->init();
        LOGE("已添加“Fliper”.");
        LOGE("已添加“Fliper”.");
        return pEquipment;
    }

@@ -1822,7 +1827,7 @@


        pEquipment->init();
        LOGE("已添加“VacuumBake”.");
        LOGE("已添加“VacuumBake”.");

        return pEquipment;
    }
@@ -1840,7 +1845,7 @@


        pEquipment->init();
        LOGE("已添加“Aligner”.");
        LOGE("已添加“Aligner”.");

        return pEquipment;
    }
@@ -1858,7 +1863,7 @@


        pEquipment->init();
        LOGE("已添加“EFEM(ROBOT)”.");
        LOGE("已添加“EFEM(ROBOT)”.");

        return pEquipment;
    }
@@ -1874,7 +1879,7 @@


        pEquipment->init();
        LOGE("已添加“ARM”.");
        LOGE("已添加“ARM”.");

        return pEquipment;
    }
@@ -1890,12 +1895,12 @@


        pEquipment->init();
        LOGE("已添加“%s”.", pEquipment->getName().c_str());
        LOGE("已添加“%s”.", pEquipment->getName().c_str());

        return pEquipment;
    }

    /* 添加bonder1 或 bonder2 
    /* 添加bonder1 或 bonder2 
     * index -- 0, bonder1
     * index -- 1, bonder2
     */
@@ -1914,7 +1919,7 @@


        pEquipment->init();
        LOGE("已添加“%s”.", pEquipment->getName().c_str());
        LOGE("已添加“%s”.", pEquipment->getName().c_str());


        return pEquipment;
@@ -1932,7 +1937,7 @@
        addToEquipmentList(pEquipment);

        pEquipment->init();
        LOGE("已添加“Aligner”.");
        LOGE("已添加“Aligner”.");

        return pEquipment;
    }
@@ -1949,7 +1954,7 @@
        addToEquipmentList(pEquipment);

        pEquipment->init();
        LOGE("已添加“Measurement”.");
        LOGE("已添加“Measurement”.");

        return pEquipment;
    }
@@ -1964,7 +1969,7 @@
        static int i = 0;
        i++;

        // 自动保存缓存
        // 自动保存缓存
        if (i % (4 * 2) == 0) {
            if (m_bDataModify) {
                saveCacheAndBackups();
@@ -1974,7 +1979,7 @@



        // 模拟测试
        // 模拟测试
        /*
        static int aaa = 0;
        aaa++;
@@ -1985,7 +1990,7 @@
                glassFromQueueToInPorcess(pGlass);
                this->saveState();

                // 这里上报Panel Start事件
                // 这里上报Panel Start事件
                if (m_listener.onPanelStart != nullptr) {
                    m_listener.onPanelStart(this, pGlass);
                }
@@ -2001,7 +2006,7 @@
                glassFromInPorcessToComplete(pGlass);
                this->saveState();

                // 这里上报Panel End事件
                // 这里上报Panel End事件
                if (m_listener.onPanelEnd != nullptr) {
                    m_listener.onPanelEnd(this, pGlass);
                }
@@ -2010,17 +2015,17 @@
                if (pJob != nullptr && checkAndUpdatePjComplete(pJob)) {
                    processJobFromInPorcessToComplete(pJob);
                    this->saveState();
                    LOGE("<Master>ProcessJob(%s)完成.",
                    LOGE("<Master>ProcessJob(%s)完成.",
                        pJob->id().c_str());
                    if (m_listener.onPjEnd != nullptr) {
                        m_listener.onPjEnd(this, pJob);
                    }

                    // 检查CJ是否已经完成
                    // 检查CJ是否已经完成
                    ASSERT(m_pControlJob);
                    if (checkAndUpdateCjComplete(m_pControlJob)) {
                        this->saveState();
                        LOGE("<Master>ControlJob(%s)完成.",
                        LOGE("<Master>ControlJob(%s)完成.",
                            m_pControlJob->id().c_str());
                        if (m_listener.onCjEnd != nullptr) {
                            m_listener.onCjEnd(this, pJob);
@@ -2049,63 +2054,63 @@

        nRet = pLoadPort1->getPin("Out")->connectPin(pAligner->getPin("In1"));
        if (nRet < 0) {
            LOGE("连接LoadPort1-Fliper失败");
            LOGE("连接LoadPort1-Fliper失败");
        }
        nRet = pLoadPort2->getPin("Out")->connectPin(pAligner->getPin("In2"));
        if (nRet < 0) {
            LOGE("连接LoadPort1-Fliper失败");
            LOGE("连接LoadPort1-Fliper失败");
        }

        nRet = pAligner->getPin("Out1")->connectPin(pFliper->getPin("In"));
        if (nRet < 0) {
            LOGE("连接Aligner-Fliper失败");
            LOGE("连接Aligner-Fliper失败");
        }
        nRet = pAligner->getPin("Out2")->connectPin(pVacuumBake->getPin("In"));
        if (nRet < 0) {
            LOGE("连接Aligner-VacuumBake失败");
            LOGE("连接Aligner-VacuumBake失败");
        }

        nRet = pFliper->getPin("Out1")->connectPin(pBonder1->getPin("In1"));
        if (nRet < 0) {
            LOGE("连接Fliper-Bonder1失败");
            LOGE("连接Fliper-Bonder1失败");
        }
        nRet = pFliper->getPin("Out2")->connectPin(pBonder2->getPin("In1"));
        if (nRet < 0) {
            LOGE("连接Fliper-Bonder2失败");
            LOGE("连接Fliper-Bonder2失败");
        }

        nRet = pVacuumBake->getPin("Out1")->connectPin(pBonder1->getPin("In2"));
        if (nRet < 0) {
            LOGE("连接VacuumBake-Bonder1失败");
            LOGE("连接VacuumBake-Bonder1失败");
        }
        nRet = pVacuumBake->getPin("Out2")->connectPin(pBonder2->getPin("In2"));
        if (nRet < 0) {
            LOGE("连接VacuumBake-Bonder2失败");
            LOGE("连接VacuumBake-Bonder2失败");
        }

        nRet = pBonder1->getPin("Out")->connectPin(pBakeCooling->getPin("In1"));
        if (nRet < 0) {
            LOGE("连接Bonder1-BakeCooling失败");
            LOGE("连接Bonder1-BakeCooling失败");
        }

        nRet = pBonder2->getPin("Out")->connectPin(pBakeCooling->getPin("In2"));
        if (nRet < 0) {
            LOGE("连接Bonder2-BakeCooling失败");
            LOGE("连接Bonder2-BakeCooling失败");
        }

        nRet = pBakeCooling->getPin("Out")->connectPin(pMeasurement->getPin("In"));
        if (nRet < 0) {
            LOGE("连接BakeCooling-LoadPort3失败");
            LOGE("连接BakeCooling-LoadPort3失败");
        }

        nRet = pMeasurement->getPin("Out1")->connectPin(pLoadPort3->getPin("In"));
        if (nRet < 0) {
            LOGE("连接BakeCooling-LoadPort3失败");
            LOGE("连接BakeCooling-LoadPort3失败");
        }

        nRet = pMeasurement->getPin("Out2")->connectPin(pLoadPort4->getPin("In"));
        if (nRet < 0) {
            LOGE("连接BakeCooling-LoadPort4失败");
            LOGE("连接BakeCooling-LoadPort4失败");
        }
    }

@@ -2129,7 +2134,7 @@
        saveCache();


        // 创建备份目录
        // 创建备份目录
        CString strNewFile;
        CString strFileDir = m_strFilepath.c_str();
        int index = strFileDir.ReverseFind('\\');
@@ -2383,8 +2388,8 @@
        }
        unlock();

        // 当前任务手动中止后，停止调度，需要操作员在解决问题后，重新启动
        // 25年7月23日后修改为不停止任务
        // 当前任务手动中止后，停止调度，需要操作员在解决问题后，重新启动
        // 25年7月23日后修改为不停止任务
        // stop();

        return 0;
@@ -2543,7 +2548,7 @@
        m_processJobs = temp;


        // 更新context
        // 更新context
        std::vector<uint8_t> newSlots;
        std::vector<void*> newContexts;
        for (auto pj : m_processJobs) {
@@ -2586,23 +2591,23 @@

    int CMaster::setControlJob(CControlJob& controlJob)
    {
        // 回调：是否参创建ControlJob
        // 回调：是否参创建ControlJob
        auto canCreateCjFn = [&](uint32_t& cc, std::string& mm) -> bool {
            if (m_pControlJob != nullptr) {
                cc = 1100;
                mm = "当前ControlJob未结批，不能创建新的ControlJob";
                mm = "当前ControlJob未结批，不能创建新的ControlJob";
                return false;
            }
            return true;
        };


        // 回调：是否存在
        // 回调：是否存在
        auto pjExists = [&](const std::string& id) -> bool {
            return getProcessJob(id) != nullptr;
        };

        // 回调：是否可加入 CJ（这里定义：必须是 Queued）
        // 回调：是否可加入 CJ（这里定义：必须是 Queued）
        auto pjJoinable = [&](const std::string& id) -> bool {
            auto pj = getProcessJob(id);
            if (pj == nullptr) return false;
@@ -2683,27 +2688,27 @@
        std::ofstream ofs(m_strStatePath, std::ios::binary);
        if (!ofs) return false;

        // 文件头
        // 文件头
        uint32_t magic = 0x4D415354; // 'MAST'
        uint16_t version = 1;
        ofs.write(reinterpret_cast<const char*>(&magic), sizeof(magic));
        ofs.write(reinterpret_cast<const char*>(&version), sizeof(version));

        // 保存 ControlJob
        // 保存 ControlJob
        bool hasCJ = (m_pControlJob != nullptr);
        ofs.write(reinterpret_cast<const char*>(&hasCJ), sizeof(hasCJ));
        if (hasCJ) {
            m_pControlJob->serialize(ofs);
        }

        // 保存 ProcessJob 列表
        // 保存 ProcessJob 列表
        uint32_t count = static_cast<uint32_t>(m_processJobs.size());
        ofs.write(reinterpret_cast<const char*>(&count), sizeof(count));
        for (const auto& job : m_processJobs) {
            job->serialize(ofs);
        }

        // 以后可以在这里追加新字段
        // 以后可以在这里追加新字段
        return true;
    }

@@ -2712,14 +2717,14 @@
        std::ifstream ifs(m_strStatePath, std::ios::binary);
        if (!ifs) return false;

        // 文件头
        // 文件头
        uint32_t magic = 0;
        uint16_t version = 0;
        ifs.read(reinterpret_cast<char*>(&magic), sizeof(magic));
        ifs.read(reinterpret_cast<char*>(&version), sizeof(version));

        if (magic != 0x4D415354) {
            // 文件不合法
            // 文件不合法
            return false;
        }

@@ -2728,7 +2733,7 @@
            m_pControlJob = nullptr;
        }

        // 读取 ControlJob
        // 读取 ControlJob
        bool hasCJ = false;
        ifs.read(reinterpret_cast<char*>(&hasCJ), sizeof(hasCJ));
        if (hasCJ) {
@@ -2739,7 +2744,7 @@
            return false;
        }

        // 读取 ProcessJob 列表
        // 读取 ProcessJob 列表
        uint32_t count = 0;
        ifs.read(reinterpret_cast<char*>(&count), sizeof(count));
        m_processJobs.clear();
@@ -2750,7 +2755,7 @@
        }


        // 找到CProcessJob指针加入列表中
        // 找到CProcessJob指针加入列表中
        std::vector<CProcessJob*> tempPjs;
        auto ids = m_pControlJob->pjIds();
        for (auto id : ids) {
@@ -2762,7 +2767,7 @@
        m_pControlJob->setPJs(tempPjs);


        // 更新contexts
        // 更新contexts
        auto pjs = m_pControlJob->getPjs();
        for (auto pj : pjs) {
            for (auto& c : pj->carriers()) {
@@ -2780,7 +2785,7 @@
        }


        // 如果版本升级，可在这里判断 version 来加载新字段
        // 如果版本升级，可在这里判断 version 来加载新字段


        return true;
@@ -2808,7 +2813,7 @@
    CGlass* CMaster::acquireNextGlass()
    {
        for (auto* pj : m_inProcesJobs) {
            // 遍历 PJ 的 carriers 和 slots
            // 遍历 PJ 的 carriers 和 slots
            for (auto& cs : pj->carriers()) {
                for (auto ctx : cs.contexts) {
                    CGlass* pGlass = (CGlass*)ctx;
@@ -2819,14 +2824,14 @@
                }
            }
        }
        return nullptr; // 没有可加工的 Glass
        return nullptr; // 没有可加工的 Glass
    }

    int CMaster::acquireGlassToQueue()
    {
        int nCount = 0;
        for (auto* pj : m_inProcesJobs) {
            // 遍历 PJ 的 carriers 和 slots
            // 遍历 PJ 的 carriers 和 slots
            if (pj->carriers().empty()) continue;
            for (auto& cs : pj->carriers()) {
                for (auto ctx : cs.contexts) {
@@ -2946,7 +2951,7 @@



        // 释放Job相关
        // 释放Job相关
        for (auto item : m_processJobs) {
            delete item;
        }
@@ -2956,7 +2961,7 @@
            m_pControlJob = nullptr;
        }

        // 注意要释放引用
        // 注意要释放引用
        m_inProcesJobs.clear();
        m_completeProcessJobs.clear();
        m_queueGlasses.clear();
@@ -2980,7 +2985,7 @@
        m_pControlJob->abort(description);


        // 释放Job相关
        // 释放Job相关
        for (auto item : m_processJobs) {
            delete item;
        }
@@ -2990,7 +2995,7 @@
            m_pControlJob = nullptr;
        }

        // 注意要释放引用
        // 注意要释放引用
        m_inProcesJobs.clear();
        m_completeProcessJobs.clear();
        m_queueGlasses.clear();
@@ -3047,7 +3052,7 @@
    {
        if (stop() == 0) {
            m_nLastError = ER_CODE_AOI_NG;
            m_strLastError = "AOI检测未通过.";
            m_strLastError = "AOI检测未通过.";
        }
    }

@@ -3121,7 +3126,7 @@

        };

        // 事件：有人连入/断开就上日志
        // 事件：有人连入/断开就上日志
        auto clieintEventCallback = [](const std::string& ip, uint16_t port, bool connected) {
            LOGI("<DAQBridge>[Client %s] %s:%u", connected ? _T("JOIN") : _T("LEAVE"), ip.c_str(), port);
        };
@@ -3134,15 +3139,15 @@
            m_pCollector->createServer(8081);
            m_pCollector->startLoop(10);

            // 1) 注册机台（推荐：先注册 id + 机器名称）
            // 1) 注册机台（推荐：先注册 id + 机器名称）
            RetentionPolicy defP; defP.mode = RetainMode::ByCount; defP.maxSamples = 200;
            m_pCollector->registryAddMachine(EQ_ID_Bonder1, "Bonder1", defP);
            m_pCollector->registryAddMachine(EQ_ID_Bonder2, "Bonder2", defP);
            m_pCollector->registryAddMachine(EQ_ID_VACUUMBAKE, "前烘烤", defP);
            m_pCollector->registryAddMachine(EQ_ID_BAKE_COOLING, "烘烤冷却", defP);
            m_pCollector->registryAddMachine(EQ_ID_VACUUMBAKE, "前烘烤", defP);
            m_pCollector->registryAddMachine(EQ_ID_BAKE_COOLING, "烘烤冷却", defP);


            // 2) 为通道设置“曲线名称”
            // 2) 为通道设置“曲线名称”
            auto& dataTypes = CServoUtilsTool::getEqDataTypes();
            auto& bonderTypes = dataTypes[EQ_ID_Bonder1];
            for (size_t i = 0; i < bonderTypes.size(); ++i) {