1.CMaster调度线程中添加任务运行发送到EFEM;

LAPTOP-SNT8I5JK\Boounion

2025-06-09 fac102938562e13dd4e4e4914d0fde9b1cd05d8b

 SourceCode/Bond/Servo/CMaster.cpp

@@ -33,7 +33,7 @@

   CMaster::CMaster()
   {
      m_listener = {nullptr, nullptr, nullptr, nullptr, nullptr, nullptr};
      m_listener = {};
      m_bDataModify = FALSE;
      m_hEventReadBitsThreadExit[0] = ::CreateEvent(NULL, TRUE, FALSE, NULL);
      m_hEventReadBitsThreadExit[1] = ::CreateEvent(NULL, TRUE, FALSE, NULL);
@@ -83,12 +83,7 @@

   void CMaster::setListener(MasterListener listener)
   {
      m_listener.onMasterStateChanged = listener.onMasterStateChanged;
      m_listener.onEqAlive = listener.onEqAlive;
      m_listener.onEqCimStateChanged = listener.onEqCimStateChanged;
      m_listener.onEqAlarm = listener.onEqAlarm;
      m_listener.onEqVcrEventReport = listener.onEqVcrEventReport;
      m_listener.onEqDataChanged = listener.onEqDataChanged;
      m_listener = listener;
   }

   CRobotTask* CMaster::getActiveRobotTask()
@@ -284,6 +279,36 @@

   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);
      CFliper* pFliper = (CFliper*)getEquipment(EQ_ID_FLIPER);
      CVacuumBake* pVacuumBack = (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(pFliper);
      ASSERT(pVacuumBack);
      ASSERT(pAligner);
      ASSERT(pBonder1);
      ASSERT(pBonder2);
      ASSERT(pBakeCooling);
      ASSERT(pMeasurement);

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

            lock();
            if (m_pActiveRobotTask != nullptr) {
               unlock();
               // 检测到当前有正在下午的任务，确保当前任务完成或中止后继续
               LOGI("检测到当前有正在下午的任务，确保当前任务完成或中止后继续...");
               // 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);
            // 此处检测优先类型和次要类型（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;
               }
            }
            else if ((pBonder1->canPlaceGlassInSlot(0) && !pBonder1->canPlaceGlassInSlot(1))
               || (pBonder2->canPlaceGlassInSlot(0) && !pBonder2->canPlaceGlassInSlot(1))) {
               primaryType = MaterialsType::G2;
               secondaryType = MaterialsType::G1;
            }


            // BakeCooling ->Measurement
            m_pActiveRobotTask = createTransferTask_bakecooling_to_measurement(pBakeCooling, pMeasurement);
            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, pFliper);
				
            // 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);
               }
               LOGI("创建新任务<%s>...", strDescription.c_str());
               continue;
            }


            // Bonder -> BakeCooling
            m_pActiveRobotTask = createTransferTask_bonder_to_bakecooling(pBonder1, 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;
            }

            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;
            }
@@ -354,37 +513,29 @@


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

            m_pActiveRobotTask = createTransferTask(pLoadPort2, pVacuumBack);
            m_pActiveRobotTask = createTransferTask(pLoadPort2, pEqTar2, primaryType, secondaryType);
            if (m_pActiveRobotTask != nullptr) {
               m_pActiveRobotTask->run();
               std::string strDescription = m_pActiveRobotTask->getDescription();
               unlock();
               LOGI("创建新任务2<%s>...", strDescription.c_str());
               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


            // Aligner -> Bonder


            // Bonder -> BakeCooling


            // BakeCooling ->Measurement


            // Measurement -> LoadPort
@@ -414,6 +565,7 @@
            break;
         }

         // 读标志位
         for (auto item : m_listEquipment) {
            if (item->getID() == EQ_ID_Bonder1 ||
               item->getID() == EQ_ID_Bonder2) {
@@ -469,19 +621,54 @@
         CEquipment* p = (CEquipment*)pEquipment;


         // 取放片，更新当前搬送任务
         // 取片，更新当前搬送任务
         BOOL bOk = FALSE;
         lock();
         if (m_pActiveRobotTask != nullptr && 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()) {
         if (m_pActiveRobotTask != nullptr) {
            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()) {
                     bOk = TRUE;
                     LOGI("<CMaster>onPreFethedOutJob, 已校验数据一致性.");
                  }
               }
            }
            else if (p->getID() == EQ_ID_ARM_TRAY1 || p->getID() == EQ_ID_ARM_TRAY2) {
               bOk = TRUE;
            }
         }
         unlock();

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

         return bOk;

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


         // 放片，更新当前搬送任务
         BOOL bOk = FALSE;
         lock();
         if (m_pActiveRobotTask != nullptr) {
            if (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();
@@ -513,7 +700,20 @@
            lock();
            if (m_pActiveRobotTask != nullptr && 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;
            }
            unlock();
         }
@@ -929,17 +1129,82 @@
   }

   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*/)
   {
      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) {
         pTask = new CRobotTask();
         pTask->setContext(pSrcSlot->getContext());
         pTask->setEFEM((CEFEM*)getEquipment(EQ_ID_EFEM));
         pTask->setRobotTransferParam(++taskSeqNo, 1, pSrcSlot->getPosition(),
            pTarSlot->getPosition(), pSrcSlot->getNo(), pTarSlot->getNo());
      }


      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) {
         pTask = new CRobotTask();
         pTask->setContext(pSrcSlot->getContext());
         pTask->setEFEM((CEFEM*)getEquipment(EQ_ID_EFEM));
         pTask->setRobotTransferParam(++taskSeqNo, 1, pSrcSlot->getPosition(),
            pTarSlot->getPosition(), pSrcSlot->getNo(), pTarSlot->getNo());
      }


      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) {
         pTask = new CRobotTask();
         pTask->setContext(pSrcSlot->getContext());
         pTask->setEFEM((CEFEM*)getEquipment(EQ_ID_EFEM));
         pTask->setRobotTransferParam(++taskSeqNo, 1, pSrcSlot->getPosition(),
            pTarSlot->getPosition(), pSrcSlot->getNo(), pTarSlot->getNo());
      }


      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) {
         pTask = new CRobotTask();
@@ -951,4 +1216,29 @@

      return pTask;
   }

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