1.将Port的配置数据从.dat文件驳离到ini文件中。

LAPTOP-SNT8I5JK\Boounion

2025-06-13 f6e82f09bb6fb4727da61366c195cb99f3474e49

 SourceCode/Bond/Servo/CMaster.cpp

@@ -279,6 +279,40 @@

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


      // 各种机器
      CEFEM* pEFEM = (CEFEM*)getEquipment(EQ_ID_EFEM);
      CLoadPort* pLoadPort1 = (CLoadPort*)getEquipment(EQ_ID_LOADPORT1);
      CLoadPort* pLoadPort2 = (CLoadPort*)getEquipment(EQ_ID_LOADPORT2);
      CLoadPort* pLoadPort3 = (CLoadPort*)getEquipment(EQ_ID_LOADPORT3);
      CLoadPort* pLoadPort4 = (CLoadPort*)getEquipment(EQ_ID_LOADPORT4);
      CFliper* pFliper = (CFliper*)getEquipment(EQ_ID_FLIPER);
      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);
      CBakeCooling* pBakeCooling = (CBakeCooling*)getEquipment(EQ_ID_BAKE_COOLING);
      CMeasurement* pMeasurement = (CMeasurement*)getEquipment(EQ_ID_MEASUREMENT);

      ASSERT(pEFEM);
      ASSERT(pLoadPort1);
      ASSERT(pLoadPort2);
      ASSERT(pLoadPort3);
      ASSERT(pLoadPort4);
      ASSERT(pFliper);
      ASSERT(pVacuumBake);
      ASSERT(pAligner);
      ASSERT(pBonder1);
      ASSERT(pBonder2);
      ASSERT(pBakeCooling);
      ASSERT(pMeasurement);

      while (1) {
         // 待退出信号或时间到
         HANDLE hEvents[] = { m_hEventDispatchThreadExit[0], m_hDispatchEvent };
@@ -310,81 +344,222 @@
         // 调度逻辑处理
         else if (m_state == MASTERSTATE::RUNNING) {
            unlock();
            LOGI("调度处理中...");
            // LOGI("调度处理中...");

            lock();
            if (m_pActiveRobotTask != nullptr) {
               unlock();
               // 检测到当前有正在下午的任务，确保当前任务完成或中止后继续
               LOGI("检测到当前有正在下午的任务，确保当前任务完成或中止后继续...");
               continue;
            }

            // LoadPort -> Fliper(G2)
            CLoadPort* pLoadPort1 = (CLoadPort*)getEquipment(EQ_ID_LOADPORT1);
            CLoadPort* pLoadPort2 = (CLoadPort*)getEquipment(EQ_ID_LOADPORT2);
            CFliper* pFliper = (CFliper*)getEquipment(EQ_ID_FLIPER);
            CVacuumBake* pVacuumBack = (CVacuumBake*)getEquipment(EQ_ID_VACUUMBAKE);
            ASSERT(pLoadPort1);
            ASSERT(pLoadPort2);
            ASSERT(pFliper);
            ASSERT(pVacuumBack);

            m_pActiveRobotTask = createTransferTask(pLoadPort1, pFliper);
            if (m_pActiveRobotTask != nullptr) {
               std::string strDescription = m_pActiveRobotTask->getDescription();
               unlock();
               LOGI("创建新任务<%s>...", strDescription.c_str());
               continue;
            }

            m_pActiveRobotTask = createTransferTask(pLoadPort2, pFliper);
            if (m_pActiveRobotTask != nullptr) {
               std::string strDescription = m_pActiveRobotTask->getDescription();
               unlock();
               LOGI("创建新任务<%s>...", strDescription.c_str());
               // LOGI("检测到当前有正在下午的任务，确保当前任务完成或中止后继续...");
               continue;
            }



            // LoadPort -> VacuumBake(G1)
            m_pActiveRobotTask = createTransferTask(pLoadPort1, pVacuumBack);
            if (m_pActiveRobotTask != nullptr) {
               std::string strDescription = m_pActiveRobotTask->getDescription();
               unlock();
               LOGI("创建新任务1<%s>...", strDescription.c_str());
               continue;
            // 此处检测优先类型和次要类型（G1或G2）
            // 如果其中一Bonder有单个玻璃，优先取它的配对类型，否则无所谓了
            primaryType = MaterialsType::G1;
            secondaryType = MaterialsType::G2;
            if ((!pBonder1->canPlaceGlassInSlot(0) && !pBonder1->canPlaceGlassInSlot(1))
               && (!pBonder2->canPlaceGlassInSlot(0) && !pBonder2->canPlaceGlassInSlot(1))) {
               // 如果G1和G2都满了，那就看Aligner, 如果Aligner有玻璃为G1, 则取G2
               CGlass* pGlass = pAligner->getGlassFromSlot(1);
               if (pGlass != nullptr && pGlass->getType() == MaterialsType::G1) {
                  primaryType = MaterialsType::G2;
                  secondaryType = MaterialsType::G1;
               }
            }

            m_pActiveRobotTask = createTransferTask(pLoadPort2, pVacuumBack);
            if (m_pActiveRobotTask != nullptr) {
               std::string strDescription = m_pActiveRobotTask->getDescription();
               unlock();
               LOGI("创建新任务2<%s>...", strDescription.c_str());
               continue;
            else if ((pBonder1->canPlaceGlassInSlot(0) && !pBonder1->canPlaceGlassInSlot(1))
               || (pBonder2->canPlaceGlassInSlot(0) && !pBonder2->canPlaceGlassInSlot(1))) {
               primaryType = MaterialsType::G2;
               secondaryType = MaterialsType::G1;
            }



            // Fliper(G2) -> Aligner


            // VacuumBake(G1) -> Aligner


            // Aligner -> Bonder


            // Bonder -> BakeCooling


            // BakeCooling ->Measurement


            // Measurement -> LoadPort
            CLoadPort* pEqLoadPort[] = { pLoadPort1, pLoadPort2, pLoadPort3, pLoadPort4 };
            CEquipment* pEqTar[] = { pVacuumBake, pFliper };
            if (primaryType == MaterialsType::G2) {
               pEqTar[0] = pFliper;
               pEqTar[1] = pVacuumBake;
            }
            for (int s = 0; s < 4; s++) {
               if (pEqLoadPort[s]->isEnable()
                  && pEqLoadPort[s]->getPortType() == PortType::Unloading
                  && pEqLoadPort[s]->getPortMode() == PortMode::ReadyToUnload) {
                  m_pActiveRobotTask = createTransferTask(pMeasurement, pEqLoadPort[s], primaryType, secondaryType);
                  if (m_pActiveRobotTask != nullptr) {
                     goto PORT_PUT;
                  }
               }
            }

         PORT_PUT:
            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 ->Measurement
            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->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;
            }


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

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

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

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

            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)
            m_pActiveRobotTask = createTransferTask(pAligner, pFliper, 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;
            }

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


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

PORT_GET:
            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;
            }

            unlock();

@@ -409,6 +584,7 @@
            break;
         }

         // 读标志位
         for (auto item : m_listEquipment) {
            if (item->getID() == EQ_ID_Bonder1 ||
               item->getID() == EQ_ID_Bonder2) {
@@ -501,17 +677,24 @@
         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;
                  slot = m_pActiveRobotTask->getTarSlot();
                  LOGI("<CMaster>onPreFethedOutJob, 已校验数据一致性.");
               }
            }
            else if (p->getID() == EQ_ID_ARM_TRAY1 || p->getID() == EQ_ID_ARM_TRAY2) {
               slot = 1;
               bOk = TRUE;
            }
         }
         unlock();
@@ -534,24 +717,36 @@
         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->place();
            }

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

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



               lock();
               if (m_listener.onRobotTaskEvent != nullptr) {
                  m_listener.onRobotTaskEvent(this, m_pActiveRobotTask, ROBOT_EVENT_FINISH);
               }
               delete m_pActiveRobotTask;
               m_pActiveRobotTask = nullptr;
            }
@@ -822,42 +1017,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"));
@@ -969,26 +1162,194 @@
   }

   static int taskSeqNo = 0;
   CRobotTask* CMaster::createTransferTask(CEquipment* pSrcEq, CEquipment* pTarEq)
   CRobotTask* CMaster::createTransferTask(CEquipment* pSrcEq, CEquipment* pTarEq,
      MaterialsType primaryType/* = MaterialsType::G1*/, MaterialsType secondaryType/* = MaterialsType::G2*/,
      int armNo/* = 1*/)
   {
      CRobotTask* pTask = nullptr;
      CSlot* pSrcSlot, * pTarSlot;
      pTarSlot = pTarEq->getAvailableSlotForGlass(MaterialsType::G1);
      pSrcSlot = pSrcEq->getNonEmptySlot(MaterialsType::G1);
      pTarSlot = pTarEq->getAvailableSlotForGlass(primaryType);
      pSrcSlot = pSrcEq->getProcessedSlot(primaryType);
      if (pSrcSlot == nullptr || nullptr == pTarSlot) {
         pTarSlot = pTarEq->getAvailableSlotForGlass(MaterialsType::G2);
         pSrcSlot = pSrcEq->getNonEmptySlot(MaterialsType::G2);
         pTarSlot = pTarEq->getAvailableSlotForGlass(secondaryType);
         pSrcSlot = pSrcEq->getProcessedSlot(secondaryType);
      }


      if (pSrcSlot != nullptr && nullptr != pTarSlot) {
         int srcPos, srcSlot, tarPos, tarSlot;
         transformPosAndSlot(pSrcSlot->getPosition(), pSrcSlot->getNo(), srcPos, srcSlot);
         transformPosAndSlot(pTarSlot->getPosition(), pTarSlot->getNo(), tarPos, tarSlot);
         pTask = new CRobotTask();
         pTask->setContext(pSrcSlot->getContext());
         pTask->setRobotTransferParam(++taskSeqNo, 1, pSrcSlot->getPosition(),
            pTarSlot->getPosition(), pSrcSlot->getNo(), pTarSlot->getNo());
         pTask->setEFEM((CEFEM*)getEquipment(EQ_ID_EFEM));
         taskSeqNo = pTask->setRobotTransferParam(taskSeqNo, armNo, srcPos,
            tarPos, srcSlot, tarSlot);
      }


      return pTask;
   }

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

      CRobotTask* pTask = nullptr;
      CSlot* pSrcSlot, * pTarSlot;
      pTarSlot = pTarEq->getAvailableSlotForGlass2(MaterialsType::G1, slots);
      pSrcSlot = pSrcEq->getProcessedSlot(MaterialsType::G1);

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


      return pTask;
   }

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

      CRobotTask* pTask = nullptr;
      CSlot* pSrcSlot, * pTarSlot;
      pTarSlot = pSrcEq->getAvailableSlotForGlass2(MaterialsType::G1, slotsTar);
      pSrcSlot = pSrcEq->getProcessedSlot2(MaterialsType::G1, slotsSrc);

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


      return pTask;
   }

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

      CRobotTask* pTask = nullptr;
      CSlot* pSrcSlot, * pTarSlot;
      pTarSlot = pTarEq->getAvailableSlotForGlass(MaterialsType::G1);
      pSrcSlot = pSrcEq->getProcessedSlot2(MaterialsType::G1, slots);

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


      return pTask;
   }

   void CMaster::transformPosAndSlot(int srcPos, int srcSlot, int& tarPos, int& tarSlot)
   {
      switch (srcPos)
      {
      case EQ_ID_LOADPORT1:
      case EQ_ID_LOADPORT2:
      case EQ_ID_LOADPORT3:
      case EQ_ID_LOADPORT4:
      case EQ_ID_ARM_TRAY1:
      case EQ_ID_ARM_TRAY2:
      case EQ_ID_ALIGNER:
      case EQ_ID_FLIPER:
         tarPos = srcPos;
         tarSlot = 1;
         break;
      case EQ_ID_Bonder1:
         if (1 <= srcSlot && srcSlot <= 2) {
            tarPos = 9 + srcSlot;
            tarSlot = 1;
         }
         break;
      case EQ_ID_Bonder2:
         if (1 <= srcSlot && srcSlot <= 2) {
            tarPos = 11 + srcSlot;
            tarSlot = 1;
         }
         break;
      case EQ_ID_VACUUMBAKE:
         if (1 <= srcSlot && srcSlot <= 2) {
            tarPos = 13 + srcSlot;
            tarSlot = 1;
         }
         break;
      case EQ_ID_BAKE_COOLING:
         if (1 <= srcSlot && srcSlot <= 4) {
            tarPos = 15 + srcSlot;
            tarSlot = 1;
         }
         break;
      case EQ_ID_MEASUREMENT:
         tarPos = 19;
         tarSlot = 1;
         break;
      default:
         tarPos = srcPos;
         tarSlot = srcSlot;
         break;
      }
   }

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

      if (m_listener.onRobotTaskEvent != nullptr) {
         m_listener.onRobotTaskEvent(this, m_pActiveRobotTask, ROBOT_EVENT_ABORT);
      }

      lock();
      if (m_pActiveRobotTask != nullptr) {
         delete m_pActiveRobotTask;
         m_pActiveRobotTask = nullptr;
      }
      unlock();

      // 当前任务手动中止后，停止调度，需要操作员在解决问题后，重新启动
      stop();

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