1.ProcessStart和ProcessEnd加调上层时加上SlotNo, 状态也关联到SlotNo, 因为多腔可能 并行工作。 2.加入曲线采集...

LAPTOP-SNT8I5JK\Boounion

2025-10-10 7ddca21fdb798123239eab9daa390e2702afdff7

 SourceCode/Bond/Servo/CMaster.cpp

@@ -4,9 +4,16 @@
#include <future>
#include <vector>
#include "RecipeManager.h"
#include <fstream>
#include "SerializeUtil.h"


namespace SERVO {
   static inline int64_t now_ms_epoch() {
      using namespace std::chrono;
      return duration_cast<milliseconds>(system_clock::now().time_since_epoch()).count();
   }

   CMaster* g_pMaster = NULL;

   unsigned __stdcall DispatchThreadFunction(LPVOID lpParam)
@@ -51,14 +58,19 @@
      m_ullRunTime = 0;
      m_state = MASTERSTATE::READY;
      m_pActiveRobotTask = nullptr;
      m_nLastError = 0;
      m_nLastError = ER_CODE_NOERROR;
      m_isCompareMapsBeforeProceeding = FALSE;
      m_bJobMode = FALSE;
      m_bEnableEventReport = true;
      m_bEnableAlarmReport = true;
      m_bContinuousTransfer = false;
      m_bBatch = false;
      m_nContinuousTransferCount = 0;
      m_nContinuousTransferStep = CTStep_Unknow;
      m_nContinuousWorkingPort = 0;
      m_nContinuousWorkingSlot = 0;
      m_pControlJob = nullptr;
      m_nTestFlag = 0;
      InitializeCriticalSection(&m_criticalSection);
   }

@@ -126,7 +138,7 @@
         BoardVersion version{};
         int nRet = m_cclink.GetBoardVersion(version);
         if (nRet == 0) {
            LOGI("版本信息：%s.", version.toString().c_str());
            LOGD("版本信息：%s.", version.toString().c_str());
         }
         else {
            LOGE("获取CC-Link版本信息失败.");
@@ -135,7 +147,7 @@
         BoardStatus status;
         nRet = m_cclink.GetBoardStatus(status);
         if (nRet == 0) {
            LOGI("状态：%s.", status.toString().c_str());
            LOGD("状态：%s.", status.toString().c_str());
         }
         else {
            LOGE("获取CC-Link状态失败.");
@@ -206,10 +218,9 @@




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


      // 定时器
@@ -257,6 +268,12 @@
      m_listEquipment.clear();


      if (m_pCollector != nullptr) {
         m_pCollector->stopLoop();
         delete m_pCollector;
         m_pCollector = nullptr;
      }

      return 0;
   }

@@ -267,6 +284,7 @@
      }

      m_bContinuousTransfer = false;
      m_bBatch = false;
      setState(MASTERSTATE::STARTING);
      m_ullStartTime = GetTickCount64();

@@ -280,21 +298,53 @@
      }

      m_bContinuousTransfer = true;
      m_bBatch = false;
      setState(MASTERSTATE::STARTING);
      m_ullStartTime = GetTickCount64();

      return 0;
   }

   int CMaster::stop()
   int CMaster::startBatch()
   {
      // 运行时间为累加结果，本次停止时刷新；
      if (m_state != MASTERSTATE::RUNNING && m_state != MASTERSTATE::RUNNING_CONTINUOUS_TRANSFER) {
      if (m_state != MASTERSTATE::READY) {
         return -1;
      }

      m_bContinuousTransfer = false;
      m_bBatch = true;
      setState(MASTERSTATE::STARTING);
      m_ullStartTime = GetTickCount64();

      return 0;
   }

   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) {
         unlock();
         return -1;
      }
      m_ullRunTime += (GetTickCount64() - m_ullStartTime);
      unlock();


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


      // ControlJob暂停
      lock();
      if (m_pControlJob != nullptr) {
         m_pControlJob->pause();
         saveState();
      }
      unlock();


      return 0;
   }
@@ -308,7 +358,8 @@

   ULONGLONG CMaster::getRunTime()
   {
      if (m_state == MASTERSTATE::RUNNING || m_state == MASTERSTATE::RUNNING_CONTINUOUS_TRANSFER)
      if (m_state == MASTERSTATE::RUNNING || m_state == MASTERSTATE::RUNNING_CONTINUOUS_TRANSFER
         || m_state == MASTERSTATE::RUNNING_BATCH)
         return m_ullRunTime + (GetTickCount64() - m_ullStartTime);
      else
         return m_ullRunTime;
@@ -384,7 +435,8 @@
                  TRACE("a0001\n", writeCode, retCode);
               });
            if (nRet != 0) {
               LOGI("<Master>EFEM切换Start状态失败");
               LOGE("<Master>EFEM切换Start状态失败");
               m_nLastError = ER_CODE_OPERATION_MODE_FAIL;
               m_strLastError = "EFEM切换Start状态失败.";
               goto WAIT;
            }
@@ -397,7 +449,8 @@
                  TRACE("a0002\n");
               });
            if (nRet != 0) {
               LOGI("<Master>Bonder1切换Start状态失败");
               LOGE("<Master>Bonder1切换Start状态失败");
               m_nLastError = ER_CODE_BONDER_OPERATION_MODE_FAIL;
               m_strLastError = "Bonder1切换Start状态失败.";
               goto WAIT;
            }
@@ -410,7 +463,8 @@
                  TRACE("a0003\n");
               });
            if (nRet != 0) {
               LOGI("<Master>Bonder2切换Start状态失败");
               LOGE("<Master>Bonder2切换Start状态失败");
               m_nLastError = ER_CODE_BONDER_OPERATION_MODE_FAIL;
               m_strLastError = "Bonder2切换Start状态失败.";
               goto WAIT;
            }
@@ -423,7 +477,8 @@
                  TRACE("a0004\n");
               });
            if (nRet != 0) {
               LOGI("<Master>BakeCooling切换Start状态失败");
               LOGE("<Master>BakeCooling切换Start状态失败");
               m_nLastError = ER_CODE_OPERATION_MODE_FAIL;
               m_strLastError = "BakeCooling切换Start状态失败.";
               goto WAIT;
            }
@@ -436,7 +491,8 @@
                  TRACE("a0005\n");
               });
            if (nRet != 0) {
               LOGI("<Master>VacuumBake切换Start状态失败");
               LOGE("<Master>VacuumBake切换Start状态失败");
               m_nLastError = ER_CODE_OPERATION_MODE_FAIL;
               m_strLastError = "VacuumBake切换Start状态失败.";
               goto WAIT;
            }
@@ -449,7 +505,8 @@
                  TRACE("a0006\n");
               });
            if (nRet != 0) {
               LOGI("<Master>Measurement切换Start状态失败");
               LOGE("<Master>Measurement切换Start状态失败");
               m_nLastError = ER_CODE_OPERATION_MODE_FAIL;
               m_strLastError = "Measurement切换Start状态失败.";
               goto WAIT;
            }
@@ -463,7 +520,7 @@
            for (int i = 0; i < 6; i++) {
               if (!bIomcOk[i]) {
                  bIomcOk[6] = FALSE;
                  LOGI("<Master>%s切换Start状态失败", pEq[i]->getName().c_str());
                  LOGE("<Master>%s切换Start状态失败", pEq[i]->getName().c_str());
               }
            }
            
@@ -474,12 +531,13 @@
               continue;
            }


            unlock();
            if(!m_bContinuousTransfer)
               setState(MASTERSTATE::RUNNING);
            else 
            if(m_bContinuousTransfer)
               setState(MASTERSTATE::RUNNING_CONTINUOUS_TRANSFER);
            else if (m_bBatch)
               setState(MASTERSTATE::RUNNING_BATCH);
            else
               setState(MASTERSTATE::RUNNING);

            continue;
         }
@@ -506,7 +564,8 @@
                     TRACE("s000%d: ret=%d\n", i + 1, retCode);
                  });
               if (nRet != 0) {
                  LOGI("<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状态发送失败.";
                  bIomcOk[i] = FALSE;
                  promises[i].set_value(); // 避免 wait 阻塞
@@ -521,7 +580,7 @@
            for (int i = 0; i < 6; ++i) {
               if (!bIomcOk[i]) {
                  bIomcOk[6] = FALSE;
                  LOGI("<Master>%s切换Stop状态失败", pEq[i]->getName().c_str());
                  LOGE("<Master>%s切换Stop状态失败", pEq[i]->getName().c_str());
               }
            }

@@ -531,7 +590,11 @@
            }

            LOGI("<Master>所有设备成功切换到 Stop 模式");
            setState(MASTERSTATE::READY);
            if(m_nLastError == ER_CODE_NOERROR)
               setState(MASTERSTATE::READY);
            else
               setState(MASTERSTATE::ATHERERROR);

            continue;
         }

@@ -556,37 +619,62 @@
            }


            // 此处检测优先类型和次要类型（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;
               }
            // Bonder1、Bonder2、Fliper、VacuumBake、Aligner，统计G2和G1的数量, 配对组数, 多出的类型
            int nG2Count = 0, nG1Count = 0, nGlassGroup, nExtraType;
            if (pBonder1->slotHasGlass(0)) {
               nG2Count++;
            }
            else if ((pBonder1->canPlaceGlassInSlot(0) && !pBonder1->canPlaceGlassInSlot(1))
               || (pBonder2->canPlaceGlassInSlot(0) && !pBonder2->canPlaceGlassInSlot(1))) {
               primaryType = MaterialsType::G2;
               secondaryType = MaterialsType::G1;
            if (pBonder1->slotHasGlass(1)) {
               nG1Count++;
            }

            if (pBonder2->slotHasGlass(0)) {
               nG2Count++;
            }
            if (pBonder2->slotHasGlass(1)) {
               nG1Count++;
            }

            if (pFliper->slotHasGlass(0)) {
               nG2Count++;
            }

            if (pVacuumBake->slotHasGlass(0)) {
               nG1Count++;
            }
            if (pVacuumBake->slotHasGlass(1)) {
               nG1Count++;
            }

            CGlass* pTempGlass = pAligner->getGlassFromSlot(0);
            if (pTempGlass != nullptr) {
               MaterialsType type = pTempGlass->getType();
               if(type == MaterialsType::G1)
                  nG1Count++;
               else if (type == MaterialsType::G2)
                  nG2Count++;
            }
            nGlassGroup = min(nG1Count, nG2Count);
				
            if (nG1Count == nG2Count) {
               nExtraType = 0;
            }
            else if (nG1Count > nG2Count) {
               nExtraType = 1;
            }
            else {
               nExtraType = 2;
            }
            secondaryType = MaterialsType::G0;


            // Measurement -> LoadPort
            if (rmd.armState[0] || rmd.armState[1]) {
               LOGI("Arm1 %s, Arm2 %s.", rmd.armState[0] ? _T("不可用") : _T("可用"),
                  rmd.armState[1] ? _T("不可用") : _T("可用"));
            }
            for (int s = 0; s < 4; s++) {
               PortType pt = pLoadPorts[s]->getPortType();
               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);
                  m_pActiveRobotTask = createTransferTask(pMeasurement, pLoadPorts[s], MaterialsType::G1, secondaryType);
                  if (m_pActiveRobotTask != nullptr) {
                     goto PORT_PUT;
                  }
@@ -633,25 +721,30 @@


            // Fliper(G2) -> Bonder
            auto pSrcSlot = pVacuumBake->getProcessedSlot(primaryType);
            if (pSrcSlot != nullptr && !rmd.armState[1] && !pBonder1->hasBondClass()) {
               m_pActiveRobotTask = createTransferTask(pFliper, pBonder1, primaryType, secondaryType, 2);
            //m_nTestFlag = 1;
            //pVacuumBake->m_nTestFlag = 1;
            auto pSrcSlot = pVacuumBake->getProcessedSlot(MaterialsType::G1);
            //LOGI("<Master>pSrcSlot = %x", pSrcSlot,);
            if (pSrcSlot != nullptr && !rmd.armState[1]
               && pBonder1->canPlaceGlassInSlot(0)) {
               m_pActiveRobotTask = createTransferTask(pFliper, pBonder1, MaterialsType::G2, MaterialsType::G0, 2);
               CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
            }
            if (pSrcSlot != nullptr && !rmd.armState[1] && !pBonder2->hasBondClass()) {
               m_pActiveRobotTask = createTransferTask(pFliper, pBonder2, primaryType, secondaryType, 2);
            if (pSrcSlot != nullptr && !rmd.armState[1] 
               && pBonder2->canPlaceGlassInSlot(0)) {
               m_pActiveRobotTask = createTransferTask(pFliper, pBonder2, MaterialsType::G2, MaterialsType::G0, 2);
               CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
            }


            //m_nTestFlag = 0
               ;
            // VacuumBake(G1) -> Bonder
            if (!rmd.armState[0] && !pBonder1->hasBondClass()) {
               m_pActiveRobotTask = createTransferTask(pVacuumBake, pBonder1, primaryType, secondaryType);
            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 (!rmd.armState[0] && !pBonder2->hasBondClass()) {
               m_pActiveRobotTask = createTransferTask(pVacuumBake, pBonder2, primaryType, secondaryType);
            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);
            }

@@ -659,13 +752,16 @@
            // Aligner -> Fliper(G2)
            // Aligner -> VacuumBake(G1)
            if (!rmd.armState[1]) {
               m_pActiveRobotTask = createTransferTask(pAligner, pFliper, primaryType, secondaryType);
               m_pActiveRobotTask = createTransferTask(pAligner, pFliper, MaterialsType::G2, secondaryType);
               CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
            }

            if (!rmd.armState[0]) {
               m_pActiveRobotTask = createTransferTask(pAligner, pVacuumBake, primaryType, secondaryType);
               // m_nTestFlag = 1;
               if (m_nTestFlag == 1) LOGD("createTransferTask 004df %d, %d", MaterialsType::G1, secondaryType);
               m_pActiveRobotTask = createTransferTask(pAligner, pVacuumBake, MaterialsType::G1, secondaryType);
               CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
               m_nTestFlag = 0;
            }


@@ -677,13 +773,33 @@


            // LoadPort -> Aligner
            if (nGlassGroup >= 2) {
               unlock();
               continue;
            }

            if(nExtraType == 0)
               primaryType = MaterialsType::G2;
            else {
               primaryType = MaterialsType::G1;
            }

            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_pActiveRobotTask = createTransferTask(pLoadPorts[s], pAligner, primaryType, secondaryType, 1, m_bJobMode);
                  if (m_pActiveRobotTask != nullptr) {
                     CGlass* pGlass = (CGlass*)m_pActiveRobotTask->getContext();
                     if (pGlass->getBuddy() != nullptr) {
                        delete m_pActiveRobotTask;
                        m_pActiveRobotTask = nullptr;
                        continue;
                     }

                     pGlass->queue();
                     pGlass->start();
                     pEFEM->setContext(m_pActiveRobotTask->getContext());
                     goto PORT_GET;
                  }
@@ -697,6 +813,225 @@
            unlock();
            continue;
         }

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

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

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

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

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

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

            // 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("可用"),
                  rmd.armState[1] ? _T("不可用") : _T("可用"));
            }
            for (int s = 0; s < 4; s++) {
               PortType pt = pLoadPorts[s]->getPortType();
               if (!rmd.armState[0] && pLoadPorts[s]->isEnable()
                  && (pt == PortType::Unloading || pt == PortType::Both)
                  && pLoadPorts[s]->getPortStatus() == PORT_INUSE) {
                  m_pActiveRobotTask = createTransferTask(pMeasurement, pLoadPorts[s], MaterialsType::G1, secondaryType);
                  if (m_pActiveRobotTask != nullptr) { goto BATCH_PORT_PUT; }
               }
            }

            BATCH_PORT_PUT:
            CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);

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

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

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

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

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

            // 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);
            }
            if (!rmd.armState[0]) {
               m_pActiveRobotTask = createTransferTask(pAligner, pVacuumBake, MaterialsType::G1, MaterialsType::G0);
               CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
            }

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

            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, 1, m_bJobMode);
                  if (m_pActiveRobotTask != nullptr) {
                     auto* pGlass = static_cast<CGlass*>(m_pActiveRobotTask->getContext());
                     if (pGlass->getBuddy() != nullptr) {
                        delete m_pActiveRobotTask; m_pActiveRobotTask = nullptr;
                        continue;
                     }

                     // 统一：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());
                     }
                     else {
                        LOGE("<Master>Glass(%s)从等待列队到工艺列队转移失败.", pGlass->getID().c_str());
                     }

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

            BATCH_PORT_GET:
            CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);

            unlock();
            continue;
         }


         // 千传模式调度逻辑
         else if (m_state == MASTERSTATE::RUNNING_CONTINUOUS_TRANSFER) {
@@ -718,15 +1053,17 @@
            }

            // Measurement -> LoadPort
            for (int s = 0; s < 4; s++) {
               PortType pt = pLoadPorts[s]->getPortType();
            for (int p = 0; p < 4; p++) {
               if (p != m_nContinuousWorkingPort) continue;
               PortType pt = pLoadPorts[p]->getPortType();
               if ((m_nContinuousTransferStep == CTStep_Unknow || m_nContinuousTransferStep == CTStep_BakeCooling_Measurement)
                  && !rmd.armState[0] && pLoadPorts[s]->isEnable()
                  && !rmd.armState[0] && pLoadPorts[p]->isEnable()
                  && (pt == PortType::Unloading || pt == PortType::Both)
                  && pLoadPorts[s]->getPortStatus() == PORT_INUSE) {
                  && pLoadPorts[p]->getPortStatus() == PORT_INUSE) {
                  for (int slot = 0; slot < SLOT_MAX; slot++) {
                     if (slot != m_nContinuousWorkingSlot) continue;
                     m_pActiveRobotTask = createTransferTask_continuous_transfer(pMeasurement,
                        0, pLoadPorts[s], slot);
                        0, pLoadPorts[p], slot);
                     if (m_pActiveRobotTask != nullptr) {
                        m_nContinuousTransferStep = CTStep_Measurement_LoadPort;
                        m_nContinuousTransferStep = CTStep_end;
@@ -823,7 +1160,7 @@
            
            // Bonder1 -> Bonder2
            if ((m_nContinuousTransferStep == CTStep_Unknow || m_nContinuousTransferStep == CTStep_Fliper_Bonder1)
               && !rmd.armState[0] && !pBonder2->hasBondClass()) {
               && !rmd.armState[0] && !pBonder2->hasBondGlass()) {
               m_pActiveRobotTask = createTransferTask_continuous_transfer(pBonder1,
                  1, pBonder2, 1);
               if (m_pActiveRobotTask != nullptr) {
@@ -835,7 +1172,7 @@

            // Fliper(G2) -> Bonder1
            if ((m_nContinuousTransferStep == CTStep_Unknow || m_nContinuousTransferStep == CTStep_Aligner_Fliper)
               &&!rmd.armState[0] && !pBonder1->hasBondClass()) {
               &&!rmd.armState[0] && !pBonder1->hasBondGlass()) {
               m_pActiveRobotTask = createTransferTask_continuous_transfer(pFliper,
                  0, pBonder1, 1);
               if (m_pActiveRobotTask != nullptr) {
@@ -858,17 +1195,19 @@
            }

            // LoadPort -> Aligner
            for (int s = 0; s < 4; s++) {
               PortType pt = pLoadPorts[s]->getPortType();
            for (int p = 0; p < 4; p++) {
               PortType pt = pLoadPorts[p]->getPortType();
               if ((m_nContinuousTransferStep == CTStep_Unknow || m_nContinuousTransferStep == CTStep_end)
                  && !rmd.armState[0] && pLoadPorts[s]->isEnable()
                  && !rmd.armState[0] && pLoadPorts[p]->isEnable()
                  && (pt == PortType::Loading || pt == PortType::Both)
                  && pLoadPorts[s]->getPortStatus() == PORT_INUSE) {
                  && pLoadPorts[p]->getPortStatus() == PORT_INUSE) {
                  for (int slot = 0; slot < SLOT_MAX; slot++) {
                     m_pActiveRobotTask = createTransferTask_continuous_transfer(pLoadPorts[s], 
                     m_pActiveRobotTask = createTransferTask_continuous_transfer(pLoadPorts[p], 
                        slot, pAligner, 0);
                     if (m_pActiveRobotTask != nullptr) {
                        m_nContinuousTransferStep = CTStep_LoadPort_Aligner;
                        m_nContinuousWorkingPort = p;
                        m_nContinuousWorkingSlot = slot;
                        LOGI("<ContinuousTransfer>千传测试，开始搬送任务(LoadPort -> Aligner)...");
                        pEFEM->setContext(m_pActiveRobotTask->getContext());
                        goto CT_PORT_GET;
@@ -980,15 +1319,27 @@
         BOOL bOk = FALSE;
         lock();
         if (m_pActiveRobotTask != nullptr) {
            LOGD("<CMaster>onPreFethedOutJob 0001.");
            if (m_pActiveRobotTask->getSrcPosition() == p->getID()) {
               LOGD("<CMaster>onPreFethedOutJob 0002.");
               CGlass* pGlass = p->getGlassFromSlot(m_pActiveRobotTask->getSrcSlot());
               if (pGlass != nullptr) {
                  LOGD("<CMaster>onPreFethedOutJob 0003.");
                  CJobDataS* pJobDataS = pGlass->getJobDataS();
                  if (pJobDataS != nullptr
                     && pJobDataS->getCassetteSequenceNo() == pJobDataB->getCassetteSequenceNo()
                     && pJobDataS->getJobSequenceNo() == pJobDataB->getJobSequenceNo()) {
                     bOk = TRUE;
                     LOGI("<CMaster>onPreFethedOutJob, 已校验数据一致性.");
                     LOGD("<CMaster>onPreFethedOutJob, 已校验数据一致性.");
                  }
                  LOGD("<CMaster>onPreFethedOutJob 0004.");
                  if (pJobDataS != nullptr) {
                     LOGD("<CMaster>onPreFethedOutJob 0005. %d,%d,%d,%d", 
                        pJobDataS->getCassetteSequenceNo(),
                        pJobDataB->getCassetteSequenceNo(),
                        pJobDataS->getJobSequenceNo(),
                        pJobDataB->getJobSequenceNo()
                        );
                  }
               }
            }
@@ -1031,7 +1382,7 @@
               if (pGlass == nullptr) {
                  bOk = TRUE;
                  slot = m_pActiveRobotTask->getTarSlot();
                  LOGI("<CMaster>onPreFethedOutJob, 已校验数据一致性.");
                  LOGI("<CMaster>onPreStoredJob, 已校验数据一致性.");
               }
            }

@@ -1042,7 +1393,7 @@
               if (pGlass == nullptr && m_pActiveRobotTask->getSrcSlot() == port) {
                  bOk = TRUE;
                  slot = m_pActiveRobotTask->getSrcSlot();
                  LOGI("<CMaster>onPreFethedOutJob, 已校验数据一致性.");
                  LOGI("<CMaster>onPreStoredJob, 已校验数据一致性.");
               }
            }
         }
@@ -1100,6 +1451,54 @@

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

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

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

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

                        completeControlJob();
                     }
                  }
               }



               unlock();


@@ -1132,8 +1531,20 @@
            unlock();
         }
      };
      listener.onProcessStateChanged = [&](void* pEquipment, PROCESS_STATE state) -> void {
      listener.onProcessStateChanged = [&](void* pEquipment, int slotNo, PROCESS_STATE state) -> void {
         ASSERT(1 <= slotNo && slotNo <= 8);
         int eqid = ((CEquipment*)pEquipment)->getID();
         CGlass* pGlass = ((CEquipment*)pEquipment)->getGlassFromSlot(slotNo);
         LOGI("<Master>onProcessStateChanged<%d>", (int)state);
         if (state == PROCESS_STATE::Processing) {
            if (pGlass != nullptr) {
               m_pCollector->batchStart(eqid,
                  pGlass->getID().c_str(), 10 * 60 * 1000ULL);
            }
         }
         else if (state == PROCESS_STATE::Complete) {
            m_pCollector->batchStop(eqid);
         }
      };
      listener.onMapMismatch = [&](void* pEquipment, short scanMap, short downMap) {
         LOGE("<Master-%s>Port InUse, map(%d!=%d)不一致，请检查。",
@@ -1141,9 +1552,163 @@
      };
      listener.onPortStatusChanged = [&](void* pEquipment, short status, __int64 data) {
         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();
            for (auto pj : pjs) {
               auto carrier = pj->getCarrier(pPort->getCassetteId());
               if (carrier != nullptr) {
                  carrier->contexts.clear();
                  for (auto slot : carrier->slots) {
                     CGlass* pGlass = pPort->getGlassFromSlot(slot);
                     carrier->contexts.push_back((void*)pGlass);
                     if (pGlass != nullptr) {
                        pGlass->setProcessJob(pj);

                        PJWarp& jpWarp = pj->getPjWarp();
                        int nRecipeID = RecipeManager::getInstance().getIdByPPID(pj->recipeSpec());
                        RecipeInfo stRecipeInfo = RecipeManager::getInstance().getRecipeByPPID(pj->recipeSpec());
                        std::vector<DeviceRecipe> vecRecipeInfo = stRecipeInfo.vecDeviceList;

                        pGlass->setScheduledForProcessing(jpWarp.checkSlot[slot-1]);
                        pGlass->setType(static_cast<SERVO::MaterialsType>(jpWarp.material[slot-1]));

                        SERVO::CJobDataS* pJobDataS = pGlass->getJobDataS();
                        if (pJobDataS != nullptr) {
                           SERVO::CJobDataS* pJobDataS = pGlass->getJobDataS();
                           pJobDataS->setLotId(pj->getLotId().c_str());
                           pJobDataS->setProductId(pj->getProductId().c_str());
                           pJobDataS->setOperationId(pj->getOperationId().c_str());
                           pJobDataS->setMaterialsType(jpWarp.material[slot - 1]);
                           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);
                              }
                           }

                        }
                     }
                  }
               }
            }
         }
			
         if (m_listener.onLoadPortStatusChanged != nullptr) {
            m_listener.onLoadPortStatusChanged(this, (CEquipment*)pEquipment, status, data);
         }
      };
      listener.onSVDataReport = [&](void* pEquipment, void* pData) {
         CSVData* pSVData = (CSVData*)pData;
         auto rawData = pSVData->getSVRawData();
         std::vector<CParam> params;
         ((CEquipment*)pEquipment)->parsingSVData((const char*)rawData.data(), rawData.size(), params);
		

         // 以下加入到曲线数据中
         const int64_t ts = now_ms_epoch();
         int eqid = ((CEquipment*)pEquipment)->getID();
         if (eqid == EQ_ID_Bonder1 || eqid == EQ_ID_Bonder2) {
            m_pCollector->buffersPush(eqid, 1, ts, params.at(1).getDoubleValue());
            m_pCollector->buffersPush(eqid, 2, ts, params.at(2).getDoubleValue());
            m_pCollector->buffersPush(eqid, 3, ts, params.at(3).getDoubleValue());
            m_pCollector->buffersPush(eqid, 4, ts, params.at(4).getDoubleValue());
            m_pCollector->buffersPush(eqid, 5, ts, params.at(5).getDoubleValue());
            m_pCollector->buffersPush(eqid, 6, ts, params.at(6).getDoubleValue());
            m_pCollector->buffersPush(eqid, 7, ts, params.at(7).getDoubleValue());
            m_pCollector->buffersPush(eqid, 8, ts, params.at(8).getDoubleValue());
            m_pCollector->buffersPush(eqid, 9, ts, params.at(9).getDoubleValue());
            m_pCollector->buffersPush(eqid, 10, ts, params.at(10).getDoubleValue());
            m_pCollector->buffersPush(eqid, 11, ts, params.at(11).getDoubleValue());
            m_pCollector->buffersPush(eqid, 12, ts, params.at(12).getDoubleValue());
            m_pCollector->buffersPush(eqid, 13, ts, params.at(13).getDoubleValue());
            m_pCollector->buffersPush(eqid, 14, ts, params.at(14).getDoubleValue());
            m_pCollector->buffersPush(eqid, 15, ts, params.at(15).getDoubleValue());
            m_pCollector->buffersPush(eqid, 16, ts, params.at(16).getDoubleValue());
         }
         else if (eqid == EQ_ID_VACUUMBAKE) {
            m_pCollector->buffersPush(eqid, 1, ts, params.at(1).getDoubleValue());
            m_pCollector->buffersPush(eqid, 2, ts, params.at(2).getDoubleValue());
            m_pCollector->buffersPush(eqid, 3, ts, params.at(3).getDoubleValue());
            m_pCollector->buffersPush(eqid, 4, ts, params.at(4).getDoubleValue());
            m_pCollector->buffersPush(eqid, 5, ts, params.at(5).getDoubleValue());
            m_pCollector->buffersPush(eqid, 6, ts, params.at(6).getDoubleValue());
            m_pCollector->buffersPush(eqid, 7, ts, params.at(7).getDoubleValue());
            m_pCollector->buffersPush(eqid, 8, ts, params.at(10).getDoubleValue());
            m_pCollector->buffersPush(eqid, 9, ts, params.at(11).getDoubleValue());
            m_pCollector->buffersPush(eqid, 10, ts, params.at(12).getDoubleValue());
            m_pCollector->buffersPush(eqid, 11, ts, params.at(13).getDoubleValue());
            m_pCollector->buffersPush(eqid, 12, ts, params.at(14).getDoubleValue());
            m_pCollector->buffersPush(eqid, 13, ts, params.at(15).getDoubleValue());
            m_pCollector->buffersPush(eqid, 14, ts, params.at(16).getDoubleValue());
         }
         else if (eqid == EQ_ID_BAKE_COOLING) {
            m_pCollector->buffersPush(eqid, 1, ts, params.at(1).getDoubleValue());
            m_pCollector->buffersPush(eqid, 2, ts, params.at(2).getDoubleValue());
            m_pCollector->buffersPush(eqid, 3, ts, params.at(3).getDoubleValue());
            m_pCollector->buffersPush(eqid, 4, ts, params.at(4).getDoubleValue());
            m_pCollector->buffersPush(eqid, 5, ts, params.at(5).getDoubleValue());
            m_pCollector->buffersPush(eqid, 6, ts, params.at(6).getDoubleValue());
            m_pCollector->buffersPush(eqid, 7, ts, params.at(11).getDoubleValue());
            m_pCollector->buffersPush(eqid, 8, ts, params.at(12).getDoubleValue());
            m_pCollector->buffersPush(eqid, 9, ts, params.at(13).getDoubleValue());
            m_pCollector->buffersPush(eqid, 10, ts, params.at(14).getDoubleValue());
            m_pCollector->buffersPush(eqid, 11, ts, params.at(15).getDoubleValue());
            m_pCollector->buffersPush(eqid, 12, ts, params.at(16).getDoubleValue());
         }


         // 以下是输出测试
         std::string strOut;
         char szBuffer[256];
         for (auto p : params) {
            if (!strOut.empty()) strOut.append(",");
            if (p.getValueType() == PVT_INT) {
               sprintf_s(szBuffer, 256, "%s:%d", p.getName().c_str(), p.getIntValue());
            }
            else if (p.getValueType() == PVT_DOUBLE) {
               sprintf_s(szBuffer, 256, "%s:%f", p.getName().c_str(), p.getDoubleValue());
            }
            strOut.append(szBuffer);
         }
         LOGD("<CMaster-%s>SVDataReport:%s", ((CEquipment*)pEquipment)->getName().c_str(), strOut.c_str());
      };
      listener.onPanelDataReport = [&](void* pEquipment, void* pContext) {
         LOGD("<CMaster-%s>onPanelDataReport", ((CEquipment*)pEquipment)->getName().c_str());

         CEquipment* pEq = (CEquipment*)pEquipment;
         CGlass* pGlass = (CGlass*)pContext;

         // 如果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检测未通过.";
               }
            }
         }

      };
      pEquipment->setListener(listener);
      pEquipment->setCcLink(&m_cclink);
@@ -1382,6 +1947,64 @@
         }
      }



      // 模拟测试
      /*
      static int aaa = 0;
      aaa++;
      if (aaa % 30 == 0) {
         if (!m_queueGlasses.empty()) {
            CGlass* pGlass = m_queueGlasses.front();
            pGlass->start();
            glassFromQueueToInPorcess(pGlass);
            this->saveState();

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

      if (aaa % 45 == 0) {
         if (!m_inProcesGlasses.empty()) {
            CGlass* pGlass = m_inProcesGlasses.front();
            pGlass->complete();
            CGlass* pBuddy = pGlass->getBuddy();
            if (pBuddy != nullptr) pBuddy->complete();
            glassFromInPorcessToComplete(pGlass);
            this->saveState();

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

            CProcessJob* pJob = getGlassProcessJob(pGlass);
            if (pJob != nullptr && checkAndUpdatePjComplete(pJob)) {
               processJobFromInPorcessToComplete(pJob);
               this->saveState();
               LOGE("<Master>ProcessJob(%s)完成.",
                  pJob->id().c_str());
               if (m_listener.onPjEnd != nullptr) {
                  m_listener.onPjEnd(this, pJob);
               }

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

   void CMaster::connectEquipments()
@@ -1546,21 +2169,22 @@
   static int taskSeqNo = 0;
   CRobotTask* CMaster::createTransferTask(CEquipment* pSrcEq, CEquipment* pTarEq,
      MaterialsType primaryType/* = MaterialsType::G1*/, MaterialsType secondaryType/* = MaterialsType::G2*/,
      int armNo/* = 1*/)
      int armNo/* = 1*/, BOOL bJobMode/* = FALSE*/)
   {
      if (!pSrcEq->IsEnabled()) { 
         return nullptr;
      }

      CRobotTask* pTask = nullptr;
      CSlot* pSrcSlot, * pTarSlot;
      pSrcEq->m_nTestFlag = m_nTestFlag;
      pTarSlot = pTarEq->getAvailableSlotForGlass(primaryType);
      pSrcSlot = pSrcEq->getProcessedSlot(primaryType);
      if (pSrcSlot == nullptr || nullptr == pTarSlot) {
      pSrcSlot = pSrcEq->getProcessedSlot(primaryType, bJobMode);
      if (m_nTestFlag == 1) LOGD("createTransferTask 003 %x, %x", pTarSlot, pSrcSlot);
      if ((pSrcSlot == nullptr || nullptr == pTarSlot) && secondaryType != SERVO::MaterialsType::G0) {
         pTarSlot = pTarEq->getAvailableSlotForGlass(secondaryType);
         pSrcSlot = pSrcEq->getProcessedSlot(secondaryType);
         pSrcSlot = pSrcEq->getProcessedSlot(secondaryType, bJobMode);
      }

      if (m_nTestFlag == 1) LOGD("createTransferTask 004 %x, %x", pTarSlot, pSrcSlot);

      if (pSrcSlot != nullptr && nullptr != pTarSlot) {
         pTask = new CRobotTask();
@@ -1765,11 +2389,19 @@
      return 0;
   }

   void CMaster::setPortType(unsigned int index, BOOL enable, int type, int mode,
      int cassetteType, int transferMode, BOOL autoChangeEnable)
   void CMaster::setPortType(unsigned int index, int type)
   {
      ASSERT(index < 4);
      int eqid[] = { EQ_ID_LOADPORT1, EQ_ID_LOADPORT2, EQ_ID_LOADPORT3, EQ_ID_LOADPORT4};
      CLoadPort* pPort = (CLoadPort*)getEquipment(eqid[index]);
      pPort->localSetPortType((SERVO::PortType)type);
   }

   void CMaster::setPortTypeEx(unsigned int index, BOOL enable, int type, int mode,
      int cassetteType, int transferMode, BOOL autoChangeEnable)
   {
      ASSERT(index < 4);
      int eqid[] = { EQ_ID_LOADPORT1, EQ_ID_LOADPORT2, EQ_ID_LOADPORT3, EQ_ID_LOADPORT4 };
      CLoadPort* pPort = (CLoadPort*)getEquipment(eqid[index]);
      pPort->localEanblePort(enable);
      pPort->localSetPortType((SERVO::PortType)type);
@@ -1795,9 +2427,30 @@
      pPort->localEanblePort(bEnable);
   }

   int CMaster::getPortCassetteSnSeed(int port)
   {
      ASSERT(1 <= port && port <= 4);
      int eqid[] = { EQ_ID_LOADPORT1, EQ_ID_LOADPORT2, EQ_ID_LOADPORT3, EQ_ID_LOADPORT4 };
      CLoadPort* pPort = (CLoadPort*)getEquipment(eqid[port - 1]);
      return pPort->getPortCassetteSnSeed();
   }

   void CMaster::setPortCassetteSnSeed(int port, int seed)
   {
      ASSERT(1 <= port && port <= 4);
      int eqid[] = { EQ_ID_LOADPORT1, EQ_ID_LOADPORT2, EQ_ID_LOADPORT3, EQ_ID_LOADPORT4 };
      CLoadPort* pPort = (CLoadPort*)getEquipment(eqid[port - 1]);
      return pPort->setPortCassetteSnSeed(seed);
   }

   void CMaster::setCompareMapsBeforeProceeding(BOOL bCompare)
   {
      m_isCompareMapsBeforeProceeding = bCompare;
   }

   void CMaster::setJobMode(BOOL bJobMode)
   {
      m_bJobMode = bJobMode;
   }

   void CMaster::datetimeSync(SYSTEMTIME& time)
@@ -1862,9 +2515,34 @@
            temp.push_back(p);
         }
      }

      m_processJobs = temp;
      return m_processJobs.size();


      // 更新context
      std::vector<uint8_t> newSlots;
      std::vector<void*> newContexts;
      for (auto pj : m_processJobs) {
         for (auto& c : pj->carriers()) {
            auto pPort = getPortWithCarrierId(c.carrierId);
            if (pPort == nullptr) continue;

            for (auto s : c.slots) {
               auto pGlass = pPort->getGlassFromSlot(s);
               if (pGlass == nullptr) continue;

               newSlots.push_back(s);
               newContexts.push_back(pGlass);
            }

            pj->setCarrierSlotsAndContexts(c.carrierId, newSlots, newContexts);
         }
      }



      this->saveState();

      return (int)m_processJobs.size();
   }

   std::vector<CProcessJob*>& CMaster::getProcessJobs()
@@ -1919,7 +2597,15 @@
         }
      }
      m_pControlJob->setPJs(temps);
      this->saveState();


      return 0;
   }

   CControlJob* CMaster::getControlJob()
   {
      return m_pControlJob;
   }

   CLoadPort* CMaster::getPortWithCarrierId(const std::string& carrierId) const
@@ -1967,4 +2653,532 @@
      return true;
   }

   bool CMaster::saveState() const
   {
      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
      bool hasCJ = (m_pControlJob != nullptr);
      ofs.write(reinterpret_cast<const char*>(&hasCJ), sizeof(hasCJ));
      if (hasCJ) {
         m_pControlJob->serialize(ofs);
      }

      // 保存 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;
   }

   bool CMaster::loadState()
   {
      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;
      }

      if (m_pControlJob != nullptr) {
         delete m_pControlJob;
         m_pControlJob = nullptr;
      }

      // 读取 ControlJob
      bool hasCJ = false;
      ifs.read(reinterpret_cast<char*>(&hasCJ), sizeof(hasCJ));
      if (hasCJ) {
         m_pControlJob = new CControlJob();
         if (!CControlJob::deserialize(ifs, *m_pControlJob)) return false;
      }
      else {
         return false;
      }

      // 读取 ProcessJob 列表
      uint32_t count = 0;
      ifs.read(reinterpret_cast<char*>(&count), sizeof(count));
      m_processJobs.clear();
      for (uint32_t i = 0; i < count; i++) {
         CProcessJob* pProcessJob = new CProcessJob();
         if (!CProcessJob::deserialize(ifs, *pProcessJob)) return false;
         m_processJobs.push_back(pProcessJob);
      }


      // 找到CProcessJob指针加入列表中
      std::vector<CProcessJob*> tempPjs;
      auto ids = m_pControlJob->pjIds();
      for (auto id : ids) {
         auto pj = getProcessJob(id);
         if (pj != nullptr) {
            tempPjs.push_back(pj);
         }
      }
      m_pControlJob->setPJs(tempPjs);


      // 更新contexts
      auto pjs = m_pControlJob->getPjs();
      for (auto pj : pjs) {
         for (auto& c : pj->carriers()) {
            auto p = getPortWithCarrierId(c.carrierId);
            if (p == nullptr) continue;

            std::vector<void*> contexts;
            for (auto s : c.slots) {
               auto g = getGlass(p->getIndex(), s - 1);
               if (g == nullptr) continue;
               contexts.push_back(g);
            }
            pj->setCarrierContexts(c.carrierId, contexts);
         }
      }


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


      return true;
   }

   void CMaster::setStateFile(const std::string& path)
   {
      m_strStatePath = path;
   }

   CProcessJob* CMaster::acquireNextProcessJob()
   {
      auto& pjs = m_pControlJob->getPjs();
      for (const auto pj : pjs) {
         if (pj->state() == PJState::Queued) {
            pj->start();
            return pj;
         }
      }


      return nullptr;
   }

   CGlass* CMaster::acquireNextGlass()
   {
      for (auto* pj : m_inProcesJobs) {
         // 遍历 PJ 的 carriers 和 slots
         for (auto& cs : pj->carriers()) {
            for (auto ctx : cs.contexts) {
               CGlass* pGlass = (CGlass*)ctx;
               if (pGlass->state() == GlsState::NoState) {
                  pGlass->queue();
                  return pGlass;
               }
            }
         }
      }
      return nullptr; // 没有可加工的 Glass
   }

   int CMaster::acquireGlassToQueue()
   {
      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;
               if (pGlass->state() == GlsState::NoState) {
                  pGlass->queue();
                  if(addGlassToQueue(pGlass)) nCount++;
               }
            }
         }
      }
      return nCount;
   }

   bool CMaster::addGlassToQueue(CGlass* pGlass)
   {
      for (auto g : m_queueGlasses) {
         if (g == pGlass) return false;
      }

      m_queueGlasses.push_back(pGlass);
      return true;
   }

   bool CMaster::glassFromQueueToInPorcess(CGlass* pGlass)
   {
      auto it = std::find(m_queueGlasses.begin(), m_queueGlasses.end(), pGlass); 
      if (it != m_queueGlasses.end()) {
         m_inProcesGlasses.push_back(*it);
         m_queueGlasses.erase(it);
         return true;
      }
      return false;
   }

   bool CMaster::glassFromInPorcessToComplete(CGlass* pGlass)
   {
      auto it = std::find(m_inProcesGlasses.begin(), m_inProcesGlasses.end(), pGlass);
      if (it != m_inProcesGlasses.end()) {
         m_completeGlasses.push_back(*it);
         m_inProcesGlasses.erase(it);
         return true;
      }
      return false;
   }

   bool CMaster::processJobFromInPorcessToComplete(CProcessJob* pProcessJob)
   {
      auto it = std::find(m_inProcesJobs.begin(), m_inProcesJobs.end(), pProcessJob);
      if (it != m_inProcesJobs.end()) {
         m_completeProcessJobs.push_back(*it);
         m_inProcesJobs.erase(it);
         return true;
      }
      return false;
   }

   bool CMaster::checkAndUpdatePjComplete(CProcessJob* pJob)
   {
      ASSERT(pJob);
      auto state = pJob->state();
      if (state != PJState::InProcess && state != PJState::Paused) return false;

      for (auto c : pJob->carriers()) {
         for (auto g : c.contexts) {
            auto state = ((CGlass*)g)->state();
            if (state != GlsState::Aborted && state != GlsState::Completed
               && state != GlsState::Failed) return false;
         }
      }

      return pJob->complete();
   }

   bool CMaster::checkAndUpdateCjComplete(CControlJob* pJob)
   {
      ASSERT(pJob);
      auto state = pJob->state();
      if (state != CJState::Executing && state != CJState::Paused) return false;

      for (auto pj : pJob->getPjs()) {
         auto state = pj->state();
         if (state != PJState::Aborted && state != PJState::Completed
            && state != PJState::Failed) {
            return false;
         }
      }

      return pJob->complete();
   }

   CProcessJob* CMaster::getGlassProcessJob(CGlass* pGlass)
   {
      if (m_pControlJob == nullptr) return nullptr;
      for (auto pj : m_pControlJob->getPjs()) {
         for (auto c : pj->carriers()) {
            for (auto g : c.contexts) {
               if (g == pGlass) return pj;
            }
         }
      }

      return nullptr;
   }


   bool CMaster::completeControlJob()
   {
      if (m_pControlJob == nullptr) {
         return false;
      }
      for (auto item : m_processJobs) {
         if (item->state() != PJState::Completed) return false;
      }
      if (m_pControlJob->state() != CJState::Completed)
         return false;



      // 释放Job相关
      for (auto item : m_processJobs) {
         delete item;
      }
      m_processJobs.clear();
      if (m_pControlJob != nullptr) {
         delete m_pControlJob;
         m_pControlJob = nullptr;
      }

      // 注意要释放引用
      m_inProcesJobs.clear();
      m_completeProcessJobs.clear();
      m_queueGlasses.clear();
      m_inProcesGlasses.clear();
      m_completeGlasses.clear();


      saveState();

      return true;
   }

   bool CMaster::forceCompleteControlJob(std::string description)
   {
      if (m_pControlJob == nullptr || m_state != SERVO::MASTERSTATE::READY) {
         return false;
      }
      for (auto item : m_processJobs) {
         item->abort(description);
      }
      m_pControlJob->abort(description);


      // 释放Job相关
      for (auto item : m_processJobs) {
         delete item;
      }
      m_processJobs.clear();
      if (m_pControlJob != nullptr) {
         delete m_pControlJob;
         m_pControlJob = nullptr;
      }

      // 注意要释放引用
      m_inProcesJobs.clear();
      m_completeProcessJobs.clear();
      m_queueGlasses.clear();
      m_inProcesGlasses.clear();
      m_completeGlasses.clear();


      saveState();

      return true;
   }

   bool CMaster::canCreateControlJob()
   {
      return m_pControlJob == nullptr;
   }

   bool CMaster::canCompleteControlJob()
   {
      return m_pControlJob != nullptr && m_state == SERVO::MASTERSTATE::READY;
   }

   bool CMaster::canDeleteControlJob()
   {
      return m_pControlJob != nullptr 
         && m_pControlJob->state() == CJState::NoState
         && m_state == SERVO::MASTERSTATE::READY;
   }

   int CMaster::getWipGlasses(std::vector<CGlass*>& glasses)
   {
      for (auto eq : m_listEquipment) {
         auto p = dynamic_cast<CLoadPort*>(eq);
         if (p == nullptr) {
            eq->getAllGlass(glasses);
         }

      }

      return (int)glasses.size();
   }

   int CMaster::getLastError()
   {
      return m_nLastError;
   }

   std::string& CMaster::getLastErrorText()
   {
      return m_strLastError;
   }

   void CMaster::test()
   {
      if (stop() == 0) {
         m_nLastError = ER_CODE_AOI_NG;
         m_strLastError = "AOI检测未通过.";
      }
   }

   bool CMaster::moveGlassToBuf(int eqid, int slotNo)
   {
      CEquipment* pEquipment = getEquipment(eqid);
      if (pEquipment == nullptr) return false;

      CSlot* pSlot = pEquipment->getSlotWithNo(slotNo);
      if (pSlot == nullptr) return false;

      CGlass* pGlass = (CGlass*)pSlot->getContext();
      m_bufGlass.push_back(pGlass);
      pGlass->addRef();
      pSlot->setContext(nullptr);

      m_bDataModify = TRUE;
      if (m_listener.onEqDataChanged != nullptr) {
         m_listener.onEqDataChanged(this, pEquipment, 0);
      }

      return true;
   }

   bool CMaster::moveGlassToSlot(int eqid, int slotNo)
   {
      CEquipment* pEquipment = getEquipment(eqid);
      if (pEquipment == nullptr) return false;

      CSlot* pSlot = pEquipment->getSlotWithNo(slotNo);
      if (pSlot == nullptr) return false;
      if (m_bufGlass.empty()) return false;

      CGlass* pGlass = m_bufGlass.front();
      m_bufGlass.pop_front();
      if (pGlass == nullptr) return false;
      pSlot->setContext(pGlass);
      pGlass->release();

      m_bDataModify = TRUE;
      if (m_listener.onEqDataChanged != nullptr) {
         m_listener.onEqDataChanged(this, pEquipment, 0);
      }

      return true;
   }

   CGlass* CMaster::getGlass(int scrPort, int scrSlot)
   {
      for (auto eq : m_listEquipment) {
         std::vector<CGlass*> glasses;
         eq->getAllGlass(glasses);
         for (auto g : glasses) {
            int p, s;
            g->getOrginPort(p, s);
            if (p == scrPort && s == scrSlot) {
               return g;
            }
         }
      }

      return nullptr;
   }

   void CMaster::CreateDAQBridgeServer()
   {
      auto connectionStatusCallback = [&](int code, const std::string& status) {
         LOGI("<DAQBridge>status:", status.c_str());
      };
      auto rawDataCallback = [](const std::vector<uint8_t>& bytes) {

      };

      // 事件：有人连入/断开就上日志
      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);
      };

      if (m_pCollector == nullptr) {
         m_pCollector = new Collector();
         m_pCollector->setConnectionStatusCallback(connectionStatusCallback);
         m_pCollector->setRawDataCallback(rawDataCallback);
         m_pCollector->setClientEventCallback(clieintEventCallback);
         m_pCollector->createServer(8081);
         m_pCollector->startLoop(10);

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


         // 2) 为通道设置“曲线名称”
         m_pCollector->buffersSetChannelName(EQ_ID_Bonder1, 1, "气囊压力");
         m_pCollector->buffersSetChannelName(EQ_ID_Bonder1, 2, "上腔压力");
         m_pCollector->buffersSetChannelName(EQ_ID_Bonder1, 3, "管道真空规值");
         m_pCollector->buffersSetChannelName(EQ_ID_Bonder1, 4, "腔体真空规值");
         m_pCollector->buffersSetChannelName(EQ_ID_Bonder1, 5, "上腔温度1");
         m_pCollector->buffersSetChannelName(EQ_ID_Bonder1, 6, "上腔温度2");
         m_pCollector->buffersSetChannelName(EQ_ID_Bonder1, 7, "上腔温度3");
         m_pCollector->buffersSetChannelName(EQ_ID_Bonder1, 8, "上腔温度4");
         m_pCollector->buffersSetChannelName(EQ_ID_Bonder1, 9, "上腔温度5");
         m_pCollector->buffersSetChannelName(EQ_ID_Bonder1, 10, "上腔温度6");
         m_pCollector->buffersSetChannelName(EQ_ID_Bonder1, 11, "下腔温度1");
         m_pCollector->buffersSetChannelName(EQ_ID_Bonder1, 12, "下腔温度2");
         m_pCollector->buffersSetChannelName(EQ_ID_Bonder1, 13, "下腔温度3");
         m_pCollector->buffersSetChannelName(EQ_ID_Bonder1, 14, "下腔温度4");
         m_pCollector->buffersSetChannelName(EQ_ID_Bonder1, 15, "下腔温度5");
         m_pCollector->buffersSetChannelName(EQ_ID_Bonder1, 16, "下腔温度6");

         m_pCollector->buffersSetChannelName(EQ_ID_Bonder2, 1, "气囊压力");
         m_pCollector->buffersSetChannelName(EQ_ID_Bonder2, 2, "上腔压力");
         m_pCollector->buffersSetChannelName(EQ_ID_Bonder2, 3, "管道真空规值");
         m_pCollector->buffersSetChannelName(EQ_ID_Bonder2, 4, "腔体真空规值");
         m_pCollector->buffersSetChannelName(EQ_ID_Bonder2, 5, "上腔温度1");
         m_pCollector->buffersSetChannelName(EQ_ID_Bonder2, 6, "上腔温度2");
         m_pCollector->buffersSetChannelName(EQ_ID_Bonder2, 7, "上腔温度3");
         m_pCollector->buffersSetChannelName(EQ_ID_Bonder2, 8, "上腔温度4");
         m_pCollector->buffersSetChannelName(EQ_ID_Bonder2, 9, "上腔温度5");
         m_pCollector->buffersSetChannelName(EQ_ID_Bonder2, 10, "上腔温度6");
         m_pCollector->buffersSetChannelName(EQ_ID_Bonder2, 11, "下腔温度1");
         m_pCollector->buffersSetChannelName(EQ_ID_Bonder2, 12, "下腔温度2");
         m_pCollector->buffersSetChannelName(EQ_ID_Bonder2, 13, "下腔温度3");
         m_pCollector->buffersSetChannelName(EQ_ID_Bonder2, 14, "下腔温度4");
         m_pCollector->buffersSetChannelName(EQ_ID_Bonder2, 15, "下腔温度5");
         m_pCollector->buffersSetChannelName(EQ_ID_Bonder2, 16, "下腔温度6");

         m_pCollector->buffersSetChannelName(EQ_ID_VACUUMBAKE, 1, "A腔真空规值");
         m_pCollector->buffersSetChannelName(EQ_ID_VACUUMBAKE, 2, "A腔温控1");
         m_pCollector->buffersSetChannelName(EQ_ID_VACUUMBAKE, 3, "A腔温控2");
         m_pCollector->buffersSetChannelName(EQ_ID_VACUUMBAKE, 4, "A腔温控4");
         m_pCollector->buffersSetChannelName(EQ_ID_VACUUMBAKE, 5, "A腔温控5");
         m_pCollector->buffersSetChannelName(EQ_ID_VACUUMBAKE, 6, "A腔温控6");
         m_pCollector->buffersSetChannelName(EQ_ID_VACUUMBAKE, 7, "A腔温控7");
         m_pCollector->buffersSetChannelName(EQ_ID_VACUUMBAKE, 8, "B腔真空规值");
         m_pCollector->buffersSetChannelName(EQ_ID_VACUUMBAKE, 9, "B腔温控1");
         m_pCollector->buffersSetChannelName(EQ_ID_VACUUMBAKE, 10, "B腔温控2");
         m_pCollector->buffersSetChannelName(EQ_ID_VACUUMBAKE, 11, "B腔温控4");
         m_pCollector->buffersSetChannelName(EQ_ID_VACUUMBAKE, 12, "B腔温控5");
         m_pCollector->buffersSetChannelName(EQ_ID_VACUUMBAKE, 13, "B腔温控6");
         m_pCollector->buffersSetChannelName(EQ_ID_VACUUMBAKE, 14, "B腔温控7");

         m_pCollector->buffersSetChannelName(EQ_ID_BAKE_COOLING, 1, "A烘烤温控1");
         m_pCollector->buffersSetChannelName(EQ_ID_BAKE_COOLING, 2, "A烘烤温控2");
         m_pCollector->buffersSetChannelName(EQ_ID_BAKE_COOLING, 3, "A烘烤温控4");
         m_pCollector->buffersSetChannelName(EQ_ID_BAKE_COOLING, 4, "A烘烤温控5");
         m_pCollector->buffersSetChannelName(EQ_ID_BAKE_COOLING, 5, "A烘烤温控6");
         m_pCollector->buffersSetChannelName(EQ_ID_BAKE_COOLING, 6, "A烘烤温控7");
         m_pCollector->buffersSetChannelName(EQ_ID_BAKE_COOLING, 7, "B烘烤温控1");
         m_pCollector->buffersSetChannelName(EQ_ID_BAKE_COOLING, 8, "B烘烤温控2");
         m_pCollector->buffersSetChannelName(EQ_ID_BAKE_COOLING, 9, "B烘烤温控4");
         m_pCollector->buffersSetChannelName(EQ_ID_BAKE_COOLING, 10, "B烘烤温控5");
         m_pCollector->buffersSetChannelName(EQ_ID_BAKE_COOLING, 11, "B烘烤温控6");
         m_pCollector->buffersSetChannelName(EQ_ID_BAKE_COOLING, 12, "B烘烤温控7");
      }
   }
}