1.修复批高度逻辑与之前的单片调度同步；

LAPTOP-SNT8I5JK\Boounion

2025-09-20 922a39a04e535e745c1ef736a0ba427ae1696ef5

1.修复批高度逻辑与之前的单片调度同步；

 .gitignore

@@ -60,3 +60,6 @@
SourceCode/Bond/EAPSimulator/x64/
Document/___CEID_________________.csv
Document/______CEID__.csv
SourceCode/Bond/x64/Debug/HsmsPassive.cache
SourceCode/Bond/x64/Debug/MasterState.dat
SourceCode/Bond/x64/Debug/Recipe/EQ10_Unit0.recipelist

 SourceCode/Bond/Servo/CControlJobManagerDlg.cpp

@@ -454,9 +454,13 @@
    }


    SERVO::CLoadPort* pPort[4];
    pPort[0] = (SERVO::CLoadPort*)master.getEquipment(EQ_ID_LOADPORT1);
    pPort[1] = (SERVO::CLoadPort*)master.getEquipment(EQ_ID_LOADPORT2);
    pPort[2] = (SERVO::CLoadPort*)master.getEquipment(EQ_ID_LOADPORT3);
    pPort[3] = (SERVO::CLoadPort*)master.getEquipment(EQ_ID_LOADPORT4);


    int EQID[] = { EQ_ID_LOADPORT1, EQ_ID_LOADPORT2, EQ_ID_LOADPORT3, EQ_ID_LOADPORT4 };
    bool bProcessStart[] = {false, false, false, false};
    std::vector<SERVO::CProcessJob*> pjs;
    for (auto item : m_pjWarps) {
        if (!item.addToCj) continue;
@@ -470,17 +474,16 @@
        }
        if (!bCheck) continue;

        SERVO::CLoadPort* pPort = (SERVO::CLoadPort*)master.getEquipment(EQID[item.port]);
        SERVO::CProcessJob* pScr = (SERVO::CProcessJob*)item.pj;
        SERVO::CProcessJob * pj = new SERVO::CProcessJob(pScr->id());
        pj->setRecipe(SERVO::RecipeMethod::NoTuning, pScr->recipeSpec());

        std::vector<SERVO::CarrierSlotInfo> carriers;
        SERVO::CarrierSlotInfo csi;
        csi.carrierId = pPort->getCassetteId();
        csi.carrierId = pPort[item.port]->getCassetteId();
        for (int i = 0; i < 8; i++) {
            if (item.checkSlot[i]) {
                SERVO::CGlass* pGlass = pPort->getGlassFromSlot(i+1);
                SERVO::CGlass* pGlass = pPort[item.port]->getGlassFromSlot(i+1);
                if (pGlass != nullptr) {
                    csi.slots.push_back(i + 1);
                }
@@ -489,6 +492,7 @@
        carriers.push_back(csi);
        pj->setCarriers(carriers);
        pjs.push_back(pj);
        bProcessStart[item.port] = true;

        m_pControlJob->addPJ(pScr->id());
    }
@@ -502,6 +506,15 @@
    m_pControlJob->setPJs(pjs);
    m_pControlJob->clearIssues();
    int nRet = master.setProcessJobs(pjs);

    // 没有问题的pj要释放
    for (auto pj : pjs) {
        if (!pj->issues().empty()) {
            delete pj;
        }
    }
    pjs.clear();

    if (nRet <= 0) {
        std::string msg("同步Process Job失败!");
        for (auto pj : pjs) {
@@ -524,7 +537,6 @@
        return;
    }


    nRet = master.setControlJob(*m_pControlJob);
    if (nRet != 0) {
        std::string msg("同步ControlJob失败!");
@@ -544,63 +556,65 @@
    }


    // 假设成功，要判断，同步到slot的glass中，类型等
    if (true) {
        auto& master = theApp.m_model.getMaster();
        int EQID[] = { EQ_ID_LOADPORT1, EQ_ID_LOADPORT2, EQ_ID_LOADPORT3, EQ_ID_LOADPORT4 };
        for (int p = 0; p < 4; p++) {
            SERVO::CLoadPort* pPort = (SERVO::CLoadPort*)master.getEquipment(EQID[p]);
            for (int i = 0; i < SLOT_MAX; ++i) {
                SERVO::CSlot* pSlot = pPort->getSlot(i);
                if (!pSlot) {
                    continue;
                }
    // 成功，要判断，同步到slot的glass中，类型等
    for (int p = 0; p < 4; p++) {
        for (int i = 0; i < SLOT_MAX; ++i) {
            SERVO::CSlot* pSlot = pPort[p]->getSlot(i);
            if (!pSlot) {
                continue;
            }

                // 设置 Panel ID 和勾选框
                SERVO::CProcessJob* pj = (SERVO::CProcessJob*)m_pjWarps[p].pj;
                int nRecipeID = RecipeManager::getInstance().getIdByPPID(pj->recipeSpec());
                RecipeInfo stRecipeInfo = RecipeManager::getInstance().getRecipeByPPID(pj->recipeSpec());
                std::vector<DeviceRecipe> vecRecipeInfo = stRecipeInfo.vecDeviceList;
                SERVO::CGlass* pGlass = dynamic_cast<SERVO::CGlass*>(pSlot->getContext());
            // 设置 Panel ID 和勾选框
            SERVO::CProcessJob* pj = (SERVO::CProcessJob*)m_pjWarps[p].pj;
            int nRecipeID = RecipeManager::getInstance().getIdByPPID(pj->recipeSpec());
            RecipeInfo stRecipeInfo = RecipeManager::getInstance().getRecipeByPPID(pj->recipeSpec());
            std::vector<DeviceRecipe> vecRecipeInfo = stRecipeInfo.vecDeviceList;
            SERVO::CGlass* pGlass = dynamic_cast<SERVO::CGlass*>(pSlot->getContext());
            SERVO::CJobDataS* pJobDataS = pGlass->getJobDataS();
            if (pGlass != nullptr && pJobDataS != nullptr) {
                pGlass->setScheduledForProcessing(m_pjWarps[p].checkSlot[i]);
                pGlass->setType(static_cast<SERVO::MaterialsType>(m_pjWarps[p].material[i]));

                SERVO::CJobDataS* pJobDataS = pGlass->getJobDataS();
                if (pGlass != nullptr && pJobDataS != nullptr) {
                    pGlass->setScheduledForProcessing(m_pjWarps[p].checkSlot[i]);
                    pGlass->setType(static_cast<SERVO::MaterialsType>(m_pjWarps[p].material[i]));
                pJobDataS->setLotId("LotID1");
                pJobDataS->setProductId("ProductId1");
                pJobDataS->setOperationId("OPerationId");
                pJobDataS->setMaterialsType(m_pjWarps[p].material[i]);
                pJobDataS->setMasterRecipe(nRecipeID);

                    SERVO::CJobDataS* pJobDataS = pGlass->getJobDataS();
                    pJobDataS->setLotId("LotID1");
                    pJobDataS->setProductId("ProductId1");
                    pJobDataS->setOperationId("OPerationId");
                    pJobDataS->setMaterialsType(m_pjWarps[p].material[i]);
                    pJobDataS->setMasterRecipe(nRecipeID);

                    for (const auto& info : vecRecipeInfo) {
                        const std::string& name = info.strDeviceName;
                        short nRecipeID = (short)info.nRecipeID;

                        if (name == EQ_NAME_EFEM) {
                            pJobDataS->setDeviceRecipeId(0, nRecipeID);
                        }
                        else if (name == EQ_NAME_BONDER1) {
                            pJobDataS->setDeviceRecipeId(1, nRecipeID);
                        }
                        else if (name == EQ_NAME_BONDER2) {
                            pJobDataS->setDeviceRecipeId(2, nRecipeID);
                        }
                        else if (name == EQ_NAME_BAKE_COOLING) {
                            pJobDataS->setDeviceRecipeId(3, nRecipeID);
                        }
                        else if (name == EQ_NAME_VACUUMBAKE) {
                            pJobDataS->setDeviceRecipeId(4, nRecipeID);
                        }
                        else if (name == EQ_NAME_MEASUREMENT) {
                            pJobDataS->setDeviceRecipeId(5, nRecipeID);
                        }
                for (const auto& info : vecRecipeInfo) {
                    const std::string& name = info.strDeviceName;
                    short nRecipeID = (short)info.nRecipeID;
				
                    if (name == EQ_NAME_EFEM) {
                        pJobDataS->setDeviceRecipeId(0, nRecipeID);
                    }
                    else if (name == EQ_NAME_BONDER1) {
                        pJobDataS->setDeviceRecipeId(1, nRecipeID);
                    }
                    else if (name == EQ_NAME_BONDER2) {
                        pJobDataS->setDeviceRecipeId(2, nRecipeID);
                    }
                    else if (name == EQ_NAME_BAKE_COOLING) {
                        pJobDataS->setDeviceRecipeId(3, nRecipeID);
                    }
                    else if (name == EQ_NAME_VACUUMBAKE) {
                        pJobDataS->setDeviceRecipeId(4, nRecipeID);
                    }
                    else if (name == EQ_NAME_MEASUREMENT) {
                        pJobDataS->setDeviceRecipeId(5, nRecipeID);
                    }
                }
            }
        }
    }

    AfxMessageBox("断点检查一下数据");

    // process start
    for (int p = 0; p < 4; p++) {
        if (bProcessStart[p]) {
            pPort[p]->sendCassetteCtrlCmd(CCC_PROCESS_START, nullptr, 0, 0, 0, nullptr, nullptr);
            Sleep(100);
        }
    }
}

 SourceCode/Bond/Servo/CMaster.cpp

@@ -805,48 +805,32 @@

            // 批处理模式，最终以此为准，但先保留之前的单片模式
            else if (m_state == MASTERSTATE::RUNNING_BATCH) {
                // 首选检查有没有CControlJob, 状态等
                if (m_pControlJob == nullptr) {
                // 1) 控制作业生命周期保障
                if (m_pControlJob == nullptr) { unlock(); continue; }
                CJState cjst = m_pControlJob->state();
                if (cjst == CJState::Completed || cjst == CJState::Aborted || cjst == CJState::Failed) {
                    unlock();
                    continue;
                }
                CJState state = m_pControlJob->state();
                if (state == CJState::Completed || state == CJState::Aborted || state == CJState::Failed) {
                    // ConrolJpb已完成
                    LOGE("<Master>ControlJob已经完成或失败中断");
                    unlock();
                    continue;
                }


                if (m_pControlJob->state() == CJState::NoState) {
                if (cjst == CJState::NoState) {
                    LOGI("<Master>ControlJob已经进入列队");
                    m_pControlJob->queue();
                }
                if (m_pControlJob->state() == CJState::Queued) {
                    LOGI("<Master>ControlJob已经启动");
                    m_pControlJob->start();

                    if (m_listener.onCjStart != nullptr) {
                        m_listener.onCjStart(this, m_pControlJob);
                    }
                    if (m_listener.onCjStart) m_listener.onCjStart(this, m_pControlJob);
                }
                if (m_pControlJob->state() == CJState::Paused) {
                    LOGI("<Master>ControlJob已经恢复运行");
                    m_pControlJob->resume();
                }


                // 如果当前未选择CProcessJob, 选择一个
                // 2) 若当前无 PJ，则选择一个并上报
                if (m_inProcesJobs.empty()) {
                    auto pj = acquireNextProcessJob();
                    if (pj != nullptr) {
                    if (auto pj = acquireNextProcessJob()) {
                        m_inProcesJobs.push_back(pj);

                        // 这里上报PJ Start事件
                        if (m_listener.onPjStart != nullptr) {
                            m_listener.onPjStart(this, pj);
                        }
                        if (m_listener.onPjStart) m_listener.onPjStart(this, pj);
                    }
                }
                if (m_inProcesJobs.empty()) {
@@ -855,54 +839,64 @@
                    continue;
                }

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


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

                // 5) 正在执行的 RobotTask 先让它跑完一拍
                if (m_pActiveRobotTask != nullptr) {
                    if (m_pActiveRobotTask->isPicked()) {
                        m_pActiveRobotTask->place();
                    }
                    unlock();
                    // 检测到当前有正在下午的任务，确保当前任务完成或中止后继续
                    // LOGI("检测到当前有正在下午的任务，确保当前任务完成或中止后继续...");
                    unlock(); // 等当前任务完成或中止后继续
                    continue;
                }


                // 此处检测优先类型和次要类型（G1或G2）
                // 如果其中一Bonder有单个玻璃，优先取它的配对类型，否则无所谓了
                primaryType = MaterialsType::G1;
                secondaryType = MaterialsType::G2;
                if ((!pBonder1->canPlaceGlassInSlot(0) && !pBonder1->canPlaceGlassInSlot(1))
                    && (!pBonder2->canPlaceGlassInSlot(0) && !pBonder2->canPlaceGlassInSlot(1))) {
                    // 如果G1和G2都满了，那就看Aligner, 如果Aligner有玻璃为G1, 则取G2
                    CGlass* pGlass = pAligner->getGlassFromSlot(1);
                    if (pGlass != nullptr && pGlass->getType() == MaterialsType::G1) {
                        primaryType = MaterialsType::G2;
                        secondaryType = MaterialsType::G1;
                // 6) ——关键：全局统计 G1/G2 与组数门限（与单片分支对齐）——
                auto countG1G2 = [&]() {
                    int g1 = 0, g2 = 0;
                    if (pBonder1->slotHasGlass(0)) g2++;
                    if (pBonder1->slotHasGlass(1)) g1++;
                    if (pBonder2->slotHasGlass(0)) g2++;
                    if (pBonder2->slotHasGlass(1)) g1++;
                    if (pFliper->slotHasGlass(0))  g2++;
                    if (pVacuumBake->slotHasGlass(0)) g1++;
                    if (pVacuumBake->slotHasGlass(1)) g1++;
                    if (auto g = pAligner->getGlassFromSlot(0)) {
                        auto t = g->getType();
                        if (t == MaterialsType::G1) g1++; else if (t == MaterialsType::G2) g2++;
                    }
                }
                else if ((pBonder1->canPlaceGlassInSlot(0) && !pBonder1->canPlaceGlassInSlot(1))
                    || (pBonder2->canPlaceGlassInSlot(0) && !pBonder2->canPlaceGlassInSlot(1))) {
                    primaryType = MaterialsType::G2;
                    secondaryType = MaterialsType::G1;
                }
                    return std::pair<int, int>(g1, g2);
                };

                int g1Count = 0, g2Count = 0;
                std::tie(g1Count, g2Count) = countG1G2();
                int nGlassGroup = min(g1Count, g2Count);
                int nExtraType = (g1Count == g2Count ? 0 : (g1Count > g2Count ? 1 : 2));

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

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

                // 7) Measurement -> LoadPort（固定：G1 优先回 LP）
                if (rmd.armState[0] || rmd.armState[1]) {
                    LOGD("Arm1 %s, Arm2 %s.", rmd.armState[0] ? _T("不可用") : _T("可用"),
                    LOGD("Arm1 %s, Arm2 %s.",
                        rmd.armState[0] ? _T("不可用") : _T("可用"),
                        rmd.armState[1] ? _T("不可用") : _T("可用"));
                }
                for (int s = 0; s < 4; s++) {
@@ -910,140 +904,123 @@
                    if (!rmd.armState[0] && pLoadPorts[s]->isEnable()
                        && (pt == PortType::Unloading || pt == PortType::Both)
                        && pLoadPorts[s]->getPortStatus() == PORT_INUSE) {
                        m_pActiveRobotTask = createTransferTask(pMeasurement, pLoadPorts[s], primaryType, secondaryType);
                        if (m_pActiveRobotTask != nullptr) {
                            goto BATCH_PORT_PUT;
                        }
                        m_pActiveRobotTask = createTransferTask(pMeasurement, pLoadPorts[s], MaterialsType::G1, secondaryType);
                        if (m_pActiveRobotTask != nullptr) { goto BATCH_PORT_PUT; }
                    }
                }

            BATCH_PORT_PUT:
                BATCH_PORT_PUT:
                CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);


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


                // BakeCooling ->Measurement
                // 9) BakeCooling -> Measurement
                if (!rmd.armState[0]) {
                    m_pActiveRobotTask = createTransferTask_bakecooling_to_measurement(pBakeCooling, pMeasurement);
                    CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
                }


                // 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);
                }


                // Bonder -> BakeCooling
                // 11) Bonder -> BakeCooling
                if (!rmd.armState[0]) {
                    m_pActiveRobotTask = createTransferTask_bonder_to_bakecooling(pBonder1, pBakeCooling);
                    CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
                }

                if (!rmd.armState[0]) {
                    m_pActiveRobotTask = createTransferTask_bonder_to_bakecooling(pBonder2, pBakeCooling);
                    CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
                }

                // 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);
                        CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
                    }
                    if (!rmd.armState[1] && pBonder2->canPlaceGlassInSlot(0)) {
                        m_pActiveRobotTask = createTransferTask(pFliper, pBonder2, MaterialsType::G2, MaterialsType::G0, 2);
                        CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
                    }
                }

                // Fliper(G2) -> Bonder
                auto pSrcSlot = pVacuumBake->getProcessedSlot(primaryType);
                if (pSrcSlot != nullptr && !rmd.armState[1] && !pBonder1->hasBondGlass()) {
                    m_pActiveRobotTask = createTransferTask(pFliper, pBonder1, primaryType, secondaryType, 2);
                // 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);
                }
                if (pSrcSlot != nullptr && !rmd.armState[1] && !pBonder2->hasBondGlass()) {
                    m_pActiveRobotTask = createTransferTask(pFliper, pBonder2, primaryType, secondaryType, 2);
                if (!rmd.armState[0] && pBonder2->slotHasGlass(0) && !pBonder2->slotHasGlass(1)) {
                    m_pActiveRobotTask = createTransferTask(pVacuumBake, pBonder2, MaterialsType::G1, MaterialsType::G0);
                    CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
                }


                // VacuumBake(G1) -> Bonder
                if (!rmd.armState[0] && !pBonder1->hasBondGlass()) {
                    m_pActiveRobotTask = createTransferTask(pVacuumBake, pBonder1, primaryType, secondaryType);
                    CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
                }

                if (!rmd.armState[0] && !pBonder2->hasBondGlass()) {
                    m_pActiveRobotTask = createTransferTask(pVacuumBake, pBonder2, primaryType, secondaryType);
                    CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
                }


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

                if (!rmd.armState[0]) {
                    m_pActiveRobotTask = createTransferTask(pAligner, pVacuumBake, primaryType, secondaryType);
                    m_pActiveRobotTask = createTransferTask(pAligner, pVacuumBake, MaterialsType::G1, MaterialsType::G0);
                    CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
                }


                // Aligner -> LoadPort
                // 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/状态时序）
                if (blockLoadFromLP) { unlock(); continue; }

                // LoadPort -> Aligner
                for (int s = 0; s < 4; s++) {
                    PortType pt = pLoadPorts[s]->getPortType();
                    if (!rmd.armState[0] && pLoadPorts[s]->isEnable()
                        && (pt == PortType::Loading || pt == PortType::Both)
                        && pLoadPorts[s]->getPortStatus() == PORT_INUSE) {
                        m_pActiveRobotTask = createTransferTask(pLoadPorts[s], pAligner, primaryType, secondaryType, m_bJobMode);

                        m_pActiveRobotTask = createTransferTask(pLoadPorts[s], pAligner, primaryType, secondaryType, 1, m_bJobMode);
                        if (m_pActiveRobotTask != nullptr) {
                            CGlass* pGlass = (CGlass*)m_pActiveRobotTask->getContext();
                            auto* pGlass = static_cast<CGlass*>(m_pActiveRobotTask->getContext());
                            if (pGlass->getBuddy() != nullptr) {
                                delete m_pActiveRobotTask;
                                m_pActiveRobotTask = nullptr;
                                delete m_pActiveRobotTask; m_pActiveRobotTask = nullptr;
                                continue;
                            }

                            pEFEM->setContext(pGlass);
                            // 统一：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());
                            }

                            // 这里上报Panel Start事件
                            if (m_listener.onPanelStart != nullptr) {
                                m_listener.onPanelStart(this, pGlass);
                            }

                            if (m_listener.onPanelStart) m_listener.onPanelStart(this, pGlass);
                            goto BATCH_PORT_GET;
                        }
                    }
                }

            BATCH_PORT_GET:
                BATCH_PORT_GET:
                CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);


                unlock();
                continue;
            }


            // 千传模式调度逻辑
            else if (m_state == MASTERSTATE::RUNNING_CONTINUOUS_TRANSFER) {
@@ -1852,6 +1829,7 @@


        // 模拟测试
        /*
        static int aaa = 0;
        aaa++;
        if (aaa % 30 == 0) {
@@ -1905,7 +1883,7 @@
                }
            }
        }
		
        */
    }

    void CMaster::connectEquipments()
@@ -2695,6 +2673,7 @@
        int nCount = 0;
        for (auto* pj : m_inProcesJobs) {
            // 遍历 PJ 的 carriers 和 slots
            if (pj->carriers().empty()) continue;
            for (auto& cs : pj->carriers()) {
                for (auto ctx : cs.contexts) {
                    CGlass* pGlass = (CGlass*)ctx;