1.暂存

LAPTOP-SNT8I5JK\Boounion

2025-07-28 e20a6e96aacc90667b7bed764a92f75993c20045

 SourceCode/Bond/Servo/CMaster.cpp

@@ -1,6 +1,8 @@
#include "stdafx.h"
#include "Common.h"
#include "CMaster.h"
#include <future>
#include <vector>


namespace SERVO {
@@ -48,6 +50,9 @@
      m_ullRunTime = 0;
      m_state = MASTERSTATE::READY;
      m_pActiveRobotTask = nullptr;
      m_nLastError = 0;
      m_bEnableEventReport = true;
      m_bEnableAlarmReport = true;
      InitializeCriticalSection(&m_criticalSection);
   }

@@ -160,9 +165,9 @@
      ASSERT(pMeasurement);

      pEfem->setPort(0, pPort1);
      pEfem->setPort(1, pPort1);
      pEfem->setPort(2, pPort1);
      pEfem->setPort(3, pPort1);
      pEfem->setPort(1, pPort2);
      pEfem->setPort(2, pPort3);
      pEfem->setPort(3, pPort4);
      pEfem->setFliper(pFliper);
      pEfem->setAligner(pAligner);
      pEfem->setArmTray(0, pArmTray1);
@@ -264,6 +269,13 @@
      return 0;
   }

   void CMaster::clearError()
   {
      m_nLastError = 0;
      m_strLastError = "";
      setState(MASTERSTATE::READY);
   }

   ULONGLONG CMaster::getRunTime()
   {
      if (m_state == MASTERSTATE::RUNNING)
@@ -287,11 +299,14 @@


      // 各种机器
      CLoadPort* pLoadPorts[4];
      CEFEM* pEFEM = (CEFEM*)getEquipment(EQ_ID_EFEM);
      CLoadPort* pLoadPort1 = (CLoadPort*)getEquipment(EQ_ID_LOADPORT1);
      CLoadPort* pLoadPort2 = (CLoadPort*)getEquipment(EQ_ID_LOADPORT2);
      pLoadPorts[0] = (CLoadPort*)getEquipment(EQ_ID_LOADPORT1);
      pLoadPorts[1] = (CLoadPort*)getEquipment(EQ_ID_LOADPORT2);
      pLoadPorts[2] = (CLoadPort*)getEquipment(EQ_ID_LOADPORT3);
      pLoadPorts[3] = (CLoadPort*)getEquipment(EQ_ID_LOADPORT4);
      CFliper* pFliper = (CFliper*)getEquipment(EQ_ID_FLIPER);
      CVacuumBake* pVacuumBack = (CVacuumBake*)getEquipment(EQ_ID_VACUUMBAKE);
      CVacuumBake* pVacuumBake = (CVacuumBake*)getEquipment(EQ_ID_VACUUMBAKE);
      CAligner* pAligner = (CAligner*)getEquipment(EQ_ID_ALIGNER);
      CBonder* pBonder1 = (CBonder*)getEquipment(EQ_ID_Bonder1);
      CBonder* pBonder2 = (CBonder*)getEquipment(EQ_ID_Bonder2);
@@ -299,10 +314,12 @@
      CMeasurement* pMeasurement = (CMeasurement*)getEquipment(EQ_ID_MEASUREMENT);

      ASSERT(pEFEM);
      ASSERT(pLoadPort1);
      ASSERT(pLoadPort2);
      ASSERT(pLoadPorts[0]);
      ASSERT(pLoadPorts[1]);
      ASSERT(pLoadPorts[2]);
      ASSERT(pLoadPorts[3]);
      ASSERT(pFliper);
      ASSERT(pVacuumBack);
      ASSERT(pVacuumBake);
      ASSERT(pAligner);
      ASSERT(pBonder1);
      ASSERT(pBonder2);
@@ -321,8 +338,114 @@
         // 如果状态为STARTING，开始工作并切换到RUNNING状态
         lock();
         if (m_state == MASTERSTATE::STARTING) {
            // 发送indexerOperationModeChange到各个机台，成功后切换到RUNNING状态
            // 否则切换到MSERROR状态
            int nRet;
            CEquipment* pEq[6] = { pEFEM, pBonder1, pBonder2, pBakeCooling, 
               pVacuumBake, pMeasurement};
            BOOL bIomcOk[7] = {FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE};
            std::vector<std::promise<void>> promises(6);
            std::vector<std::future<void>> futures;

            nRet = pEq[0]->indexerOperationModeChange(IDNEXER_OPERATION_MODE::Start,
               [&](int writeCode, int retCode) -> void {
                  bIomcOk[0] = retCode == (int)RET::OK;
                  promises[0].set_value();
                  TRACE("a0001\n", writeCode, retCode);
               });
            if (nRet != 0) {
               LOGI("<Master>EFEM切换Start状态失败");
               m_strLastError = "EFEM切换Start状态失败.";
               goto WAIT;
            }
            futures.push_back(promises[0].get_future());
            /*
            nRet = pEq[1]->indexerOperationModeChange(IDNEXER_OPERATION_MODE::Start,
               [&](int writeCode, int retCode) -> void {
                  bIomcOk[1] = retCode == (int)RET::OK;
                  promises[1].set_value();
                  TRACE("a0002\n");
               });
            if (nRet != 0) {
               LOGI("<Master>Bonder1切换Start状态失败");
               m_strLastError = "Bonder1切换Start状态失败.";
               goto WAIT;
            }
            futures.push_back(promises[1].get_future());

            nRet = pEq[2]->indexerOperationModeChange(IDNEXER_OPERATION_MODE::Start,
               [&](int writeCode, int retCode) -> void {
                  bIomcOk[2] = retCode == (int)RET::OK;
                  promises[2].set_value();
                  TRACE("a0003\n");
               });
            if (nRet != 0) {
               LOGI("<Master>Bonder2切换Start状态失败");
               m_strLastError = "Bonder2切换Start状态失败.";
               goto WAIT;
            }
            futures.push_back(promises[2].get_future());

            nRet = pEq[3]->indexerOperationModeChange(IDNEXER_OPERATION_MODE::Start,
               [&](int writeCode, int retCode) -> void {
                  bIomcOk[3] = retCode == (int)RET::OK;
                  promises[3].set_value();
                  TRACE("a0004\n");
               });
            if (nRet != 0) {
               LOGI("<Master>BakeCooling切换Start状态失败");
               m_strLastError = "BakeCooling切换Start状态失败.";
               goto WAIT;
            }
            futures.push_back(promises[3].get_future());

            nRet = pEq[4]->indexerOperationModeChange(IDNEXER_OPERATION_MODE::Start,
               [&](int writeCode, int retCode) -> void {
                  bIomcOk[4] = retCode == (int)RET::OK;
                  promises[4].set_value();
                  TRACE("a0005\n");
               });
            if (nRet != 0) {
               LOGI("<Master>VacuumBake切换Start状态失败");
               m_strLastError = "VacuumBake切换Start状态失败.";
               goto WAIT;
            }
            futures.push_back(promises[4].get_future());

            nRet = pEq[5]->indexerOperationModeChange(IDNEXER_OPERATION_MODE::Start,
               [&](int writeCode, int retCode) -> void {
                  bIomcOk[5] = retCode == (int)RET::OK;
                  promises[5].set_value();
                  TRACE("a0006\n");
               });
            if (nRet != 0) {
               LOGI("<Master>Measurement切换Start状态失败");
               m_strLastError = "Measurement切换Start状态失败.";
               goto WAIT;
            }
            futures.push_back(promises[5].get_future());
            */

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


            unlock();
            Sleep(1000);
            setState(MASTERSTATE::RUNNING);
            continue;
         }
@@ -331,7 +454,49 @@
         // 处理完成当前事务后，切换到停止或就绪状态
         else if (m_state == MASTERSTATE::STOPPING) {
            unlock();
            Sleep(1000);
            LOGI("<Master>开始切换各设备到 Stop 模式...");

            std::vector<std::promise<void>> promises(6);
            std::vector<std::future<void>> futures;
            BOOL bIomcOk[7] = { FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE };

            int nRet;
            CEquipment* pEq[6] = { pEFEM, pBonder1, pBonder2, pBakeCooling,
               pVacuumBake, pMeasurement };

            for (int i = 0; i < 1; ++i) {
               nRet = pEq[i]->indexerOperationModeChange(IDNEXER_OPERATION_MODE::Stop,
                  [i, &promises, &bIomcOk](int writeCode, int retCode) -> void {
                     bIomcOk[i] = retCode == (int)RET::OK;
                     promises[i].set_value();
                     TRACE("s000%d: ret=%d\n", i + 1, retCode);
                  });
               if (nRet != 0) {
                  LOGI("<Master>%s切换Stop状态发送失败", pEq[i]->getName().c_str());
                  m_strLastError = pEq[i]->getName() + "切换Stop状态发送失败.";
                  bIomcOk[i] = FALSE;
                  promises[i].set_value(); // 避免 wait 阻塞
               }
               futures.push_back(promises[i].get_future());
            }

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

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

            if (!bIomcOk[6]) {
               setState(MASTERSTATE::MSERROR);
               continue;
            }

            LOGI("<Master>所有设备成功切换到 Stop 模式");
            setState(MASTERSTATE::READY);
            continue;
         }
@@ -339,11 +504,17 @@

         // 调度逻辑处理
         else if (m_state == MASTERSTATE::RUNNING) {
            unlock();
            // LOGI("调度处理中...");
            // 检测判断robot状态
            RMDATA& rmd = pEFEM->getRobotMonitoringData();
            if (rmd.status != ROBOT_STATUS::Idle && rmd.status != ROBOT_STATUS::Run) {
               unlock();
               continue;
            }

            lock();
            if (m_pActiveRobotTask != nullptr) {
               if (m_pActiveRobotTask->isPicked()) {
                  m_pActiveRobotTask->place();
               }
               unlock();
               // 检测到当前有正在下午的任务，确保当前任务完成或中止后继续
               // LOGI("检测到当前有正在下午的任务，确保当前任务完成或中止后继续...");
@@ -371,10 +542,30 @@
            }


            // BakeCooling ->Measurement
            m_pActiveRobotTask = createTransferTask_bakecooling_to_measurement(pBakeCooling, pMeasurement);
            // Measurement -> LoadPort
            if (rmd.armState[0] || rmd.armState[1]) {
               LOGI("Arm1 %s, Arm2 %s.", rmd.armState[0] ? _T("不可用") : _T("可用"),
                  rmd.armState[1] ? _T("不可用") : _T("可用"));
            }
            CEquipment* pEqTar[] = { pVacuumBake, pFliper };
            if (primaryType == MaterialsType::G2) {
               pEqTar[0] = pFliper;
               pEqTar[1] = pVacuumBake;
            }
            for (int s = 0; s < 4; s++) {
               if (!rmd.armState[0] && pLoadPorts[s]->isEnable()
                  && pLoadPorts[s]->getPortType() == PortType::Unloading
                  && pLoadPorts[s]->getPortMode() == PortMode::ReadyToUnload) {
                  m_pActiveRobotTask = createTransferTask(pMeasurement, pLoadPorts[s], primaryType, secondaryType);
                  if (m_pActiveRobotTask != nullptr) {
                     goto PORT_PUT;
                  }
               }
            }

         PORT_PUT:
            if (m_pActiveRobotTask != nullptr) {
               m_pActiveRobotTask->run();
               m_pActiveRobotTask->pick();
               std::string strDescription = m_pActiveRobotTask->getDescription();
               unlock();
               if (m_listener.onRobotTaskEvent != nullptr) {
@@ -383,27 +574,214 @@
               LOGI("创建新任务<%s>...", strDescription.c_str());
               continue;
            }


            // Measurement NG -> LoadPort
            // NG回原位
            if (!rmd.armState[1]) {
               m_pActiveRobotTask = createTransferTask_restore(pMeasurement, pLoadPorts);
               if (m_pActiveRobotTask != nullptr) {
                  m_pActiveRobotTask->pick();
                  std::string strDescription = m_pActiveRobotTask->getDescription();
                  unlock();
                  if (m_listener.onRobotTaskEvent != nullptr) {
                     m_listener.onRobotTaskEvent(this, m_pActiveRobotTask, ROBOT_EVENT_CREATE);
                  }
                  LOGI("创建Measurement回退任务<%s>...", strDescription.c_str());
                  continue;
               }
            }




            // BakeCooling ->Measurement
            if (!rmd.armState[0]) {
               m_pActiveRobotTask = createTransferTask_bakecooling_to_measurement(pBakeCooling, pMeasurement);
               if (m_pActiveRobotTask != nullptr) {
                  m_pActiveRobotTask->pick();
                  std::string strDescription = m_pActiveRobotTask->getDescription();
                  unlock();
                  if (m_listener.onRobotTaskEvent != nullptr) {
                     m_listener.onRobotTaskEvent(this, m_pActiveRobotTask, ROBOT_EVENT_CREATE);
                  }
                  LOGI("创建新任务<%s>...", strDescription.c_str());
                  continue;
               }
            }


            
            // BakeCooling内部
            // Bake -> Cooling
            m_pActiveRobotTask = createTransferTask_bake_to_cooling(pBakeCooling);
            if (m_pActiveRobotTask != nullptr) {
               m_pActiveRobotTask->run();
               std::string strDescription = m_pActiveRobotTask->getDescription();
               unlock();
               if (m_listener.onRobotTaskEvent != nullptr) {
                  m_listener.onRobotTaskEvent(this, m_pActiveRobotTask, ROBOT_EVENT_CREATE);
            if (!rmd.armState[0]) {
               m_pActiveRobotTask = createTransferTask_bake_to_cooling(pBakeCooling);
               if (m_pActiveRobotTask != nullptr) {
                  m_pActiveRobotTask->pick();
                  std::string strDescription = m_pActiveRobotTask->getDescription();
                  unlock();
                  if (m_listener.onRobotTaskEvent != nullptr) {
                     m_listener.onRobotTaskEvent(this, m_pActiveRobotTask, ROBOT_EVENT_CREATE);
                  }
                  LOGI("创建新任务<%s>...", strDescription.c_str());
                  continue;
               }
               LOGI("创建新任务<%s>...", strDescription.c_str());
               continue;
            }


            // Bonder -> BakeCooling
            m_pActiveRobotTask = createTransferTask_bonder_to_bakecooling(pBonder1, pBakeCooling);
            if (!rmd.armState[0]) {
               m_pActiveRobotTask = createTransferTask_bonder_to_bakecooling(pBonder1, pBakeCooling);
               if (m_pActiveRobotTask != nullptr) {
                  m_pActiveRobotTask->pick();
                  std::string strDescription = m_pActiveRobotTask->getDescription();
                  unlock();
                  if (m_listener.onRobotTaskEvent != nullptr) {
                     m_listener.onRobotTaskEvent(this, m_pActiveRobotTask, ROBOT_EVENT_CREATE);
                  }
                  LOGI("创建新任务<%s>...", strDescription.c_str());
                  continue;
               }
            }

            if (!rmd.armState[0]) {
               m_pActiveRobotTask = createTransferTask_bonder_to_bakecooling(pBonder2, pBakeCooling);
               if (m_pActiveRobotTask != nullptr) {
                  m_pActiveRobotTask->pick();
                  std::string strDescription = m_pActiveRobotTask->getDescription();
                  unlock();
                  if (m_listener.onRobotTaskEvent != nullptr) {
                     m_listener.onRobotTaskEvent(this, m_pActiveRobotTask, ROBOT_EVENT_CREATE);
                  }
                  LOGI("创建新任务<%s>...", strDescription.c_str());
                  continue;
               }
            }


            // Fliper(G2) -> Bonder
            // VacuumBake(G1) -> Bonder
            if (!rmd.armState[1] && !pBonder1->hasBondClass()) {
               m_pActiveRobotTask = createTransferTask(pFliper, pBonder1, primaryType, secondaryType, 2);
               if (m_pActiveRobotTask != nullptr) {
                  m_pActiveRobotTask->pick();
                  std::string strDescription = m_pActiveRobotTask->getDescription();
                  unlock();
                  if (m_listener.onRobotTaskEvent != nullptr) {
                     m_listener.onRobotTaskEvent(this, m_pActiveRobotTask, ROBOT_EVENT_CREATE);
                  }
                  LOGI("创建新任务<%s>...", strDescription.c_str());
                  continue;
               }
            }

            if (!rmd.armState[1] && !pBonder2->hasBondClass()) {
               m_pActiveRobotTask = createTransferTask(pFliper, pBonder2, primaryType, secondaryType, 2);
               if (m_pActiveRobotTask != nullptr) {
                  m_pActiveRobotTask->pick();
                  std::string strDescription = m_pActiveRobotTask->getDescription();
                  unlock();
                  if (m_listener.onRobotTaskEvent != nullptr) {
                     m_listener.onRobotTaskEvent(this, m_pActiveRobotTask, ROBOT_EVENT_CREATE);
                  }
                  LOGI("创建新任务<%s>...", strDescription.c_str());
                  continue;
               }
            }

            if (!rmd.armState[0] && !pBonder1->hasBondClass()) {
               m_pActiveRobotTask = createTransferTask(pVacuumBake, pBonder1, primaryType, secondaryType);
               if (m_pActiveRobotTask != nullptr) {
                  m_pActiveRobotTask->pick();
                  std::string strDescription = m_pActiveRobotTask->getDescription();
                  unlock();
                  if (m_listener.onRobotTaskEvent != nullptr) {
                     m_listener.onRobotTaskEvent(this, m_pActiveRobotTask, ROBOT_EVENT_CREATE);
                  }
                  LOGI("创建新任务<%s>...", strDescription.c_str());
                  continue;
               }
            }

            if (!rmd.armState[0] && !pBonder2->hasBondClass()) {
               m_pActiveRobotTask = createTransferTask(pVacuumBake, pBonder2, primaryType, secondaryType);
               if (m_pActiveRobotTask != nullptr) {
                  m_pActiveRobotTask->pick();
                  std::string strDescription = m_pActiveRobotTask->getDescription();
                  unlock();
                  if (m_listener.onRobotTaskEvent != nullptr) {
                     m_listener.onRobotTaskEvent(this, m_pActiveRobotTask, ROBOT_EVENT_CREATE);
                  }
                  LOGI("创建新任务<%s>...", strDescription.c_str());
                  continue;
               }
            }


            // Aligner -> Fliper(G2)
            // Aligner -> VacuumBake(G1)
            if (!rmd.armState[1]) {
               m_pActiveRobotTask = createTransferTask(pAligner, pFliper, primaryType, secondaryType);
               if (m_pActiveRobotTask != nullptr) {
                  m_pActiveRobotTask->pick();
                  std::string strDescription = m_pActiveRobotTask->getDescription();
                  unlock();
                  if (m_listener.onRobotTaskEvent != nullptr) {
                     m_listener.onRobotTaskEvent(this, m_pActiveRobotTask, ROBOT_EVENT_CREATE);
                  }
                  LOGI("创建新任务<%s>...", strDescription.c_str());
                  continue;
               }
            }

            if (!rmd.armState[0]) {
               m_pActiveRobotTask = createTransferTask(pAligner, pVacuumBake, primaryType, secondaryType);
               if (m_pActiveRobotTask != nullptr) {
                  m_pActiveRobotTask->pick();
                  std::string strDescription = m_pActiveRobotTask->getDescription();
                  unlock();
                  if (m_listener.onRobotTaskEvent != nullptr) {
                     m_listener.onRobotTaskEvent(this, m_pActiveRobotTask, ROBOT_EVENT_CREATE);
                  }
                  LOGI("创建新任务<%s>...", strDescription.c_str());
                  continue;
               }
            }

            // Aligner -> LoadPort
            if (!rmd.armState[1]) {
               m_pActiveRobotTask = createTransferTask_restore(pAligner, pLoadPorts);
               if (m_pActiveRobotTask != nullptr) {
                  m_pActiveRobotTask->pick();
                  std::string strDescription = m_pActiveRobotTask->getDescription();
                  unlock();
                  if (m_listener.onRobotTaskEvent != nullptr) {
                     m_listener.onRobotTaskEvent(this, m_pActiveRobotTask, ROBOT_EVENT_CREATE);
                  }
                  LOGI("创建Aligner回退任务<%s>...", strDescription.c_str());
                  continue;
               }
            }




            // LoadPort -> Aligner
            for (int s = 0; s < 4; s++) {
               if (!rmd.armState[0] && pLoadPorts[s]->isEnable()
                  && pLoadPorts[s]->getPortType() == PortType::Loading
                  && pLoadPorts[s]->getPortMode() == PortMode::ReadyToLoad) {
                  m_pActiveRobotTask = createTransferTask(pLoadPorts[s], pAligner, primaryType, secondaryType);
                  if (m_pActiveRobotTask != nullptr) {
                     pEFEM->setContext(m_pActiveRobotTask->getContext());
                     goto PORT_GET;
                  }
               }
            }

PORT_GET:
            if (m_pActiveRobotTask != nullptr) {
               m_pActiveRobotTask->run();
               m_pActiveRobotTask->pick();
               std::string strDescription = m_pActiveRobotTask->getDescription();
               unlock();
               if (m_listener.onRobotTaskEvent != nullptr) {
@@ -412,135 +790,6 @@
               LOGI("创建新任务<%s>...", strDescription.c_str());
               continue;
            }

            m_pActiveRobotTask = createTransferTask_bonder_to_bakecooling(pBonder2, pBakeCooling);
            if (m_pActiveRobotTask != nullptr) {
               m_pActiveRobotTask->run();
               std::string strDescription = m_pActiveRobotTask->getDescription();
               unlock();
               if (m_listener.onRobotTaskEvent != nullptr) {
                  m_listener.onRobotTaskEvent(this, m_pActiveRobotTask, ROBOT_EVENT_CREATE);
               }
               LOGI("创建新任务<%s>...", strDescription.c_str());
               continue;
            }

            // Aligner -> Bonder
            m_pActiveRobotTask = createTransferTask(pAligner, pBonder1, primaryType, secondaryType);
            if (m_pActiveRobotTask != nullptr) {
               m_pActiveRobotTask->run();
               std::string strDescription = m_pActiveRobotTask->getDescription();
               unlock();
               if (m_listener.onRobotTaskEvent != nullptr) {
                  m_listener.onRobotTaskEvent(this, m_pActiveRobotTask, ROBOT_EVENT_CREATE);
               }
               LOGI("创建新任务<%s>...", strDescription.c_str());
               continue;
            }

            m_pActiveRobotTask = createTransferTask(pAligner, pBonder2, primaryType, secondaryType);
            if (m_pActiveRobotTask != nullptr) {
               m_pActiveRobotTask->run();
               std::string strDescription = m_pActiveRobotTask->getDescription();
               unlock();
               if (m_listener.onRobotTaskEvent != nullptr) {
                  m_listener.onRobotTaskEvent(this, m_pActiveRobotTask, ROBOT_EVENT_CREATE);
               }
               LOGI("创建新任务<%s>...", strDescription.c_str());
               continue;
            }


            // Fliper(G2) -> Aligner
            // VacuumBake(G1) -> Aligner
            m_pActiveRobotTask = createTransferTask(pFliper, pAligner, primaryType, secondaryType);
            if (m_pActiveRobotTask != nullptr) {
               m_pActiveRobotTask->run();
               std::string strDescription = m_pActiveRobotTask->getDescription();
               unlock();
               if (m_listener.onRobotTaskEvent != nullptr) {
                  m_listener.onRobotTaskEvent(this, m_pActiveRobotTask, ROBOT_EVENT_CREATE);
               }
               LOGI("创建新任务<%s>...", strDescription.c_str());
               continue;
            }

            m_pActiveRobotTask = createTransferTask(pVacuumBack, pAligner, primaryType, secondaryType);
            if (m_pActiveRobotTask != nullptr) {
               m_pActiveRobotTask->run();
               std::string strDescription = m_pActiveRobotTask->getDescription();
               unlock();
               if (m_listener.onRobotTaskEvent != nullptr) {
                  m_listener.onRobotTaskEvent(this, m_pActiveRobotTask, ROBOT_EVENT_CREATE);
               }
               LOGI("创建新任务<%s>...", strDescription.c_str());
               continue;
            }


            // LoadPort -> Fliper(G2)
            // LoadPort -> VacuumBake(G1)
            CEquipment* pEqTar1 = pVacuumBack;
            CEquipment* pEqTar2 = pFliper;
            if (primaryType == MaterialsType::G2) {
               pEqTar1 = pFliper;
               pEqTar2 = pVacuumBack;
            }
            m_pActiveRobotTask = createTransferTask(pLoadPort1, pEqTar1, primaryType, secondaryType);
            if (m_pActiveRobotTask != nullptr) {
               m_pActiveRobotTask->run();
               std::string strDescription = m_pActiveRobotTask->getDescription();
               unlock();
               if (m_listener.onRobotTaskEvent != nullptr) {
                  m_listener.onRobotTaskEvent(this, m_pActiveRobotTask, ROBOT_EVENT_CREATE);
               }
               LOGI("创建新任务<%s>...", strDescription.c_str());
               continue;
            }

            m_pActiveRobotTask = createTransferTask(pLoadPort2, pEqTar1, primaryType, secondaryType);
            if (m_pActiveRobotTask != nullptr) {
               m_pActiveRobotTask->run();
               std::string strDescription = m_pActiveRobotTask->getDescription();
               unlock();
               if (m_listener.onRobotTaskEvent != nullptr) {
                  m_listener.onRobotTaskEvent(this, m_pActiveRobotTask, ROBOT_EVENT_CREATE);
               }
               LOGI("创建新任务<%s>...", strDescription.c_str());
               continue;
            }



            // LoadPort -> VacuumBake(G1)
            m_pActiveRobotTask = createTransferTask(pLoadPort1, pEqTar2, primaryType, secondaryType);
            if (m_pActiveRobotTask != nullptr) {
               m_pActiveRobotTask->run();
               std::string strDescription = m_pActiveRobotTask->getDescription();
               unlock();
               if (m_listener.onRobotTaskEvent != nullptr) {
                  m_listener.onRobotTaskEvent(this, m_pActiveRobotTask, ROBOT_EVENT_CREATE);
               }
               LOGI("创建新任务<%s>...", strDescription.c_str());
               continue;
            }

            m_pActiveRobotTask = createTransferTask(pLoadPort2, pEqTar2, primaryType, secondaryType);
            if (m_pActiveRobotTask != nullptr) {
               m_pActiveRobotTask->run();
               std::string strDescription = m_pActiveRobotTask->getDescription();
               unlock();
               if (m_listener.onRobotTaskEvent != nullptr) {
                  m_listener.onRobotTaskEvent(this, m_pActiveRobotTask, ROBOT_EVENT_CREATE);
               }
               LOGI("创建新任务<%s>...", strDescription.c_str());
               continue;
            }


            // Measurement -> LoadPort



            unlock();

@@ -567,11 +816,9 @@

         // 读标志位
         for (auto item : m_listEquipment) {
            if (item->getID() == EQ_ID_Bonder1 ||
               item->getID() == EQ_ID_Bonder2) {
               const StationIdentifier& station = item->getStation();
               MemoryBlock& block = item->getReadBitBlock();

            const StationIdentifier& station = item->getStation();
            MemoryBlock& block = item->getReadBitBlock();
            if (block.end > block.start) {
               int nRet = m_cclink.ReadData2(station, (DeviceType)block.type,
                  block.start, block.size, block.buffer);
               if (0 == nRet) {
@@ -617,7 +864,7 @@
            m_listener.onEqVcrEventReport(this, p, p2);
         }
      };
      listener.onPreFethedOutJob = [&](void* pEquipment, CJobDataB* pJobDataB) -> BOOL {
      listener.onPreFethedOutJob = [&](void* pEquipment, int port, CJobDataB* pJobDataB) -> BOOL {
         CEquipment* p = (CEquipment*)pEquipment;


@@ -628,10 +875,10 @@
            if (m_pActiveRobotTask->getSrcPosition() == p->getID()) {
               CGlass* pGlass = p->getGlassFromSlot(m_pActiveRobotTask->getSrcSlot());
               if (pGlass != nullptr) {
                  CJobDataB* pJobDataBSrc = pGlass->getJobDataB();
                  if (pJobDataBSrc != nullptr
                     && pJobDataBSrc->getCassetteSequenceNo() == pJobDataB->getCassetteSequenceNo()
                     && pJobDataBSrc->getJobSequenceNo() == pJobDataB->getJobSequenceNo()) {
                  CJobDataS* pJobDataS = pGlass->getJobDataS();
                  if (pJobDataS != nullptr
                     && pJobDataS->getCassetteSequenceNo() == pJobDataB->getCassetteSequenceNo()
                     && pJobDataS->getJobSequenceNo() == pJobDataB->getJobSequenceNo()) {
                     bOk = TRUE;
                     LOGI("<CMaster>onPreFethedOutJob, 已校验数据一致性.");
                  }
@@ -650,7 +897,7 @@
         return bOk;

      };
      listener.onPreStoredJob = [&](void* pEquipment, CJobDataB* pJobDataB, short& slot) -> BOOL {
      listener.onPreStoredJob = [&](void* pEquipment, int port, CJobDataB* pJobDataB, short& slot) -> BOOL {
         CEquipment* p = (CEquipment*)pEquipment;


@@ -658,7 +905,18 @@
         BOOL bOk = FALSE;
         lock();
         if (m_pActiveRobotTask != nullptr) {
            if (m_pActiveRobotTask->getTarPosition() == p->getID()) {
            // 是否已经进入手臂(即取片完成),进入下一步，放片
            if (m_pActiveRobotTask->isPicking() && 
               ((m_pActiveRobotTask->getArmNo() == 1 && p->getID() == EQ_ID_ARM_TRAY1)
               || (m_pActiveRobotTask->getArmNo() == 2 && p->getID() == EQ_ID_ARM_TRAY2))
               ) {
               slot = 1;
               bOk = TRUE;
            }

            // 是否放片完成
            else if (m_pActiveRobotTask->isPlacing() &&
               m_pActiveRobotTask->getTarPosition() == p->getID()) {
               CGlass* pGlass = p->getGlassFromSlot(m_pActiveRobotTask->getTarSlot());
               if (pGlass == nullptr) {
                  bOk = TRUE;
@@ -666,15 +924,22 @@
                  LOGI("<CMaster>onPreFethedOutJob, 已校验数据一致性.");
               }
            }
            else if (p->getID() == EQ_ID_ARM_TRAY1 || p->getID() == EQ_ID_ARM_TRAY2) {
               slot = 1;
               bOk = TRUE;

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

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

         return bOk;
@@ -691,21 +956,30 @@
         if (code == EDCC_FETCHOUT_JOB) {
            lock();
            if (m_pActiveRobotTask != nullptr && m_pActiveRobotTask->getSrcPosition() == p->getID()) {
               m_pActiveRobotTask->fetchOut();
               LOGI("开始取片...");
            }
            unlock();
         }
         else if (code == EDCC_STORED_JOB) {
            lock();
            if (m_pActiveRobotTask != nullptr && m_pActiveRobotTask->getTarPosition() == p->getID()) {
            if (m_pActiveRobotTask != nullptr
               && m_pActiveRobotTask->isPicking()
               && ((m_pActiveRobotTask->getArmNo() == 1 && p->getID() == EQ_ID_ARM_TRAY1)
                  || (m_pActiveRobotTask->getArmNo() == 2 && p->getID() == EQ_ID_ARM_TRAY2))
               ) {
               LOGI("取片完成.");
               m_pActiveRobotTask->fetchOut();
               m_pActiveRobotTask->picked();
            }

            else if (m_pActiveRobotTask != nullptr
               && m_pActiveRobotTask->isPlacing() 
               && m_pActiveRobotTask->getTarPosition() == p->getID()) {
               m_pActiveRobotTask->stored();
               m_pActiveRobotTask->completed();
               LOGI("放片完成...");

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



               lock();
@@ -715,10 +989,35 @@
               delete m_pActiveRobotTask;
               m_pActiveRobotTask = nullptr;
            }

            else if (m_pActiveRobotTask != nullptr
               && m_pActiveRobotTask->isRestoring()
               && m_pActiveRobotTask->getSrcPosition() == p->getID()) {
               m_pActiveRobotTask->stored();
               m_pActiveRobotTask->restored();
               LOGI("回撤完成...");
               // 完成此条搬送任务，但要把数据和消息上抛应用层
               unlock();


               lock();
               if (m_listener.onRobotTaskEvent != nullptr) {
                  m_listener.onRobotTaskEvent(this, m_pActiveRobotTask, ROBOT_EVENT_RESTORE);
               }
               delete m_pActiveRobotTask;
               m_pActiveRobotTask = nullptr;
               stop();
            }
            unlock();
         }
      };

      listener.onProcessStateChanged = [&](void* pEquipment, PROCESS_STATE state) -> void {
         LOGI("<Master>onProcessStateChanged<%d>", (int)state);
      };
      listener.onMapMismatch = [&](void* pEquipment, short scanMap, short downMap) {
         LOGE("<Master-%s>Port InUse, map(%d!=%d)不一致，请检查。",
            ((CEquipment*)pEquipment)->getName().c_str(), scanMap, downMap);
      };
      pEquipment->setListener(listener);
      pEquipment->setCcLink(&m_cclink);
      m_listEquipment.push_back(pEquipment);
@@ -773,7 +1072,7 @@
      pEquipment->setBaseAlarmId(BASE_ALARM_EFEM);
      pEquipment->setName("Fliper(G2)");
      pEquipment->setDescription("Fliper(G2).");
      pEquipment->setReadBitBlock(0x4000, 0x45ff);
      pEquipment->setReadBitBlock(0x0, 0x0);
      pEquipment->setStation(0, 255);
      addToEquipmentList(pEquipment);

@@ -790,7 +1089,7 @@
      pEquipment->setBaseAlarmId(BASE_ALARM_EFEM);
      pEquipment->setName("VacuumBake(G1)");
      pEquipment->setDescription("VacuumBake(G1).");
      pEquipment->setReadBitBlock(0x4000, 0x45ff);
      pEquipment->setReadBitBlock(0x5c00, 0x66ff);
      pEquipment->setStation(0, 255);
      addToEquipmentList(pEquipment);

@@ -808,7 +1107,7 @@
      pEquipment->setBaseAlarmId(BASE_ALARM_EFEM);
      pEquipment->setName("Aligner");
      pEquipment->setDescription("Aligner.");
      pEquipment->setReadBitBlock(0x4000, 0x45ff);
      pEquipment->setReadBitBlock(0x0, 0x0);
      pEquipment->setStation(0, 255);
      addToEquipmentList(pEquipment);

@@ -901,7 +1200,7 @@
      pEquipment->setBaseAlarmId(BASE_ALARM_EFEM);
      pEquipment->setName("BakeCooling");
      pEquipment->setDescription("BakeCooling.");
      pEquipment->setReadBitBlock(0x4000, 0x45ff);
      pEquipment->setReadBitBlock(0x5100, 0x5bff);
      pEquipment->setStation(0, 255);
      addToEquipmentList(pEquipment);

@@ -935,27 +1234,8 @@
      }


      // 按一定频率扫描LB数据
      static int i = 0;
      i++;
      /*
      if (i % (4 * 1) == 0) {

         for (auto item : m_listEquipment) {
            if (item->getID() == EQ_ID_Bonder1) {
               const StationIdentifier& station = item->getStation();
               MemoryBlock& block = item->getReadBitBlock();

               int nRet = m_cclink.ReadData2(station, (DeviceType)block.type,
                  block.start, block.size, block.buffer);
               if (0 == nRet) {
                  item->onReceiveLBData(block.buffer, block.size);
               }
            }
         }
      }
      */


      // 自动保存缓存
      if (i % (4 * 2) == 0) {
@@ -982,42 +1262,40 @@
      CBakeCooling* pBakeCooling = (CBakeCooling*)getEquipment(EQ_ID_BAKE_COOLING);
      CMeasurement* pMeasurement = (CMeasurement*)getEquipment(EQ_ID_MEASUREMENT);

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

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

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

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

      nRet = pAligner->getPin("Out1")->connectPin(pBonder1->getPin("In"));
      nRet = pVacuumBake->getPin("Out2")->connectPin(pBonder2->getPin("In2"));
      if (nRet < 0) {
         LOGE("连接Aligner-Bondere1失败");
      }

      nRet = pAligner->getPin("Out2")->connectPin(pBonder2->getPin("In"));
      if (nRet < 0) {
         LOGE("连接Aligner-Bondere2失败");
         LOGE("连接VacuumBake-Bonder2失败");
      }

      nRet = pBonder1->getPin("Out")->connectPin(pBakeCooling->getPin("In1"));
@@ -1130,7 +1408,8 @@

   static int taskSeqNo = 0;
   CRobotTask* CMaster::createTransferTask(CEquipment* pSrcEq, CEquipment* pTarEq,
      MaterialsType primaryType/* = MaterialsType::G1*/, MaterialsType secondaryType/* = MaterialsType::G2*/)
      MaterialsType primaryType/* = MaterialsType::G1*/, MaterialsType secondaryType/* = MaterialsType::G2*/,
      int armNo/* = 1*/)
   {
      CRobotTask* pTask = nullptr;
      CSlot* pSrcSlot, * pTarSlot;
@@ -1146,7 +1425,7 @@
         pTask = new CRobotTask();
         pTask->setContext(pSrcSlot->getContext());
         pTask->setEFEM((CEFEM*)getEquipment(EQ_ID_EFEM));
         pTask->setRobotTransferParam(++taskSeqNo, 1, pSrcSlot->getPosition(),
         taskSeqNo = pTask->setRobotTransferParam(taskSeqNo, armNo, pSrcSlot->getPosition(),
            pTarSlot->getPosition(), pSrcSlot->getNo(), pTarSlot->getNo());
      }

@@ -1156,7 +1435,7 @@

   CRobotTask* CMaster::createTransferTask_bonder_to_bakecooling(CEquipment* pSrcEq, CEquipment* pTarEq)
   {
      std::vector<int> slots = {1, 2};
      std::vector<int> slots = {1, 3};

      CRobotTask* pTask = nullptr;
      CSlot* pSrcSlot, * pTarSlot;
@@ -1167,7 +1446,7 @@
         pTask = new CRobotTask();
         pTask->setContext(pSrcSlot->getContext());
         pTask->setEFEM((CEFEM*)getEquipment(EQ_ID_EFEM));
         pTask->setRobotTransferParam(++taskSeqNo, 1, pSrcSlot->getPosition(),
         taskSeqNo = pTask->setRobotTransferParam(taskSeqNo, 1, pSrcSlot->getPosition(),
            pTarSlot->getPosition(), pSrcSlot->getNo(), pTarSlot->getNo());
      }

@@ -1177,8 +1456,8 @@

   CRobotTask* CMaster::createTransferTask_bake_to_cooling(CEquipment* pSrcEq)
   {
      std::vector<int> slotsTar = { 3, 4 };
      std::vector<int> slotsSrc = { 1, 2 };
      std::vector<int> slotsTar = { 2, 4 };
      std::vector<int> slotsSrc = { 1, 3 };

      CRobotTask* pTask = nullptr;
      CSlot* pSrcSlot, * pTarSlot;
@@ -1189,7 +1468,7 @@
         pTask = new CRobotTask();
         pTask->setContext(pSrcSlot->getContext());
         pTask->setEFEM((CEFEM*)getEquipment(EQ_ID_EFEM));
         pTask->setRobotTransferParam(++taskSeqNo, 1, pSrcSlot->getPosition(),
         taskSeqNo = pTask->setRobotTransferParam(taskSeqNo, 1, pSrcSlot->getPosition(),
            pTarSlot->getPosition(), pSrcSlot->getNo(), pTarSlot->getNo());
      }

@@ -1199,7 +1478,7 @@

   CRobotTask* CMaster::createTransferTask_bakecooling_to_measurement(CEquipment* pSrcEq, CEquipment* pTarEq)
   {
      std::vector<int> slots = { 3, 4 };
      std::vector<int> slots = { 2, 4 };

      CRobotTask* pTask = nullptr;
      CSlot* pSrcSlot, * pTarSlot;
@@ -1209,7 +1488,40 @@
      if (pSrcSlot != nullptr && nullptr != pTarSlot) {
         pTask = new CRobotTask();
         pTask->setContext(pSrcSlot->getContext());
         pTask->setRobotTransferParam(++taskSeqNo, 1, pSrcSlot->getPosition(),
         pTask->setEFEM((CEFEM*)getEquipment(EQ_ID_EFEM));
         taskSeqNo = pTask->setRobotTransferParam(taskSeqNo, 1, pSrcSlot->getPosition(),
            pTarSlot->getPosition(), pSrcSlot->getNo(), pTarSlot->getNo());
      }


      return pTask;
   }

   CRobotTask* CMaster::createTransferTask_restore(CEquipment* pEqSrc, CLoadPort** pPorts)
   {
      CRobotTask* pTask = nullptr;
      CSlot* pSrcSlot, * pTarSlot = nullptr, * pTempSlot;
      pSrcSlot = pEqSrc->getInspFailSlot();
      if (pSrcSlot != nullptr) {
         CGlass* pGlass = (CGlass*)pSrcSlot->getContext();
         ASSERT(pGlass);
         int port, slot;
         pGlass->getOrginPort(port, slot);
         pGlass->setInspResult(pPorts[port]->getID(), 0, InspResult::Fail);
         ASSERT(0 <= port && port < 4);
         ASSERT(0 <= slot && slot < 8);
         pTempSlot = pPorts[port]->getSlot(slot);
         if (pTempSlot->getContext() == nullptr) {
            pTarSlot = pTempSlot;
         }
      }


      if (pSrcSlot != nullptr && nullptr != pTarSlot) {
         pTask = new CRobotTask();
         pTask->setContext(pSrcSlot->getContext());
         pTask->setEFEM((CEFEM*)getEquipment(EQ_ID_EFEM));
         taskSeqNo = pTask->setRobotTransferParam(taskSeqNo, 1, pSrcSlot->getPosition(),
            pTarSlot->getPosition(), pSrcSlot->getNo(), pTarSlot->getNo());
      }

@@ -1241,4 +1553,53 @@

      return 0;
   }

   int CMaster::restoreCurrentTask()
   {
      lock();
      if (m_pActiveRobotTask != nullptr) {
         m_pActiveRobotTask->restore();
      }
      unlock();


      return 0;
   }

   void CMaster::setPortType(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);
      pPort->localSetPortMode((SERVO::PortMode)mode);
      pPort->localSetCessetteType((SERVO::CassetteType)cassetteType);
      pPort->localSetTransferMode((SERVO::TransferMode)transferMode);
      pPort->localAutoChangeEnable(autoChangeEnable);
   }

   void CMaster::datetimeSync(SYSTEMTIME& time)
   {
      for (auto item : m_listEquipment) {
         item->setDateTime(time.wYear, time.wMonth, time.wDay,
            time.wHour, time.wMinute, time.wSecond);
      }
   }

   void CMaster::enableEventReport(bool bEnable)
   {
      m_bEnableEventReport = bEnable;
   }

   void CMaster::enableAlarmReport(bool bEnable)
   {
      m_bEnableAlarmReport = bEnable;
   }

   bool CMaster::isAlarmReportEnable()
   {
      return m_bEnableAlarmReport;
   }
}