1.修复加Job模式后，手臂号为0导致不能搬运的问题；

LAPTOP-SNT8I5JK\Boounion

2025-08-26 22122fe5fd927ccb8892cded1a2480d796e56ce9

 SourceCode/Bond/Servo/CMaster.cpp

@@ -59,6 +59,7 @@
      m_bEnableEventReport = true;
      m_bEnableAlarmReport = true;
      m_bContinuousTransfer = false;
      m_bBatch = false;
      m_nContinuousTransferCount = 0;
      m_nContinuousTransferStep = CTStep_Unknow;
      m_pControlJob = nullptr;
@@ -270,6 +271,7 @@
      }

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

@@ -283,6 +285,21 @@
      }

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

      return 0;
   }

   int CMaster::startBatch()
   {
      if (m_state != MASTERSTATE::READY) {
         return -1;
      }

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

@@ -292,12 +309,28 @@
   int CMaster::stop()
   {
      // 运行时间为累加结果，本次停止时刷新；
      if (m_state != MASTERSTATE::RUNNING && m_state != MASTERSTATE::RUNNING_CONTINUOUS_TRANSFER) {
      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();


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


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


      return 0;
   }
@@ -311,7 +344,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;
@@ -471,18 +505,21 @@
            }
            
            // 检查看是否都已经切换到START状态
            /*
            if (!bIomcOk[6]) {
               unlock();
               setState(MASTERSTATE::MSERROR);
               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;
         }
@@ -685,7 +722,7 @@
               if (!rmd.armState[0] && pLoadPorts[s]->isEnable()
                  && (pt == PortType::Loading || pt == PortType::Both)
                  && pLoadPorts[s]->getPortStatus() == PORT_INUSE) {
                  m_pActiveRobotTask = createTransferTask(pLoadPorts[s], pAligner, primaryType, secondaryType, m_bJobMode);
                  m_pActiveRobotTask = createTransferTask(pLoadPorts[s], pAligner, primaryType, secondaryType, 1, m_bJobMode);
                  if (m_pActiveRobotTask != nullptr) {
                     pEFEM->setContext(m_pActiveRobotTask->getContext());
                     goto PORT_GET;
@@ -694,6 +731,231 @@
            }

PORT_GET:
            CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);


            unlock();
            continue;
         }

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


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


            // 如果当前未选择CProcessJob, 选择一个
            if (m_inProcesJobs.empty()) {
               auto pj = acquireNextProcessJob();
               if (pj != nullptr) {
                  m_inProcesJobs.push_back(pj);

                  // 这里上报PJ Start事件
                  if (m_listener.onPjStart != nullptr) {
                     m_listener.onPjStart(this, pj);
                  }
               }
            }
            if (m_inProcesJobs.empty()) {
               LOGI("<Master>选择当前ProcessJob失败！");
               unlock();
               continue;
            }

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


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

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


            // 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);
                  if (m_pActiveRobotTask != nullptr) {
                     goto BATCH_PORT_PUT;
                  }
               }
            }

         BATCH_PORT_PUT:
            CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);


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


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


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


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


            // Fliper(G2) -> Bonder
            auto pSrcSlot = pVacuumBake->getProcessedSlot(primaryType);
            if (pSrcSlot != nullptr && !rmd.armState[1] && !pBonder1->hasBondClass()) {
               m_pActiveRobotTask = createTransferTask(pFliper, pBonder1, primaryType, secondaryType, 2);
               CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
            }
            if (pSrcSlot != nullptr && !rmd.armState[1] && !pBonder2->hasBondClass()) {
               m_pActiveRobotTask = createTransferTask(pFliper, pBonder2, primaryType, secondaryType, 2);
               CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
            }


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

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


            // Aligner -> Fliper(G2)
            // Aligner -> VacuumBake(G1)
            if (!rmd.armState[1]) {
               m_pActiveRobotTask = createTransferTask(pAligner, pFliper, primaryType, secondaryType);
               CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
            }

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


            // Aligner -> LoadPort
            if (!rmd.armState[1]) {
               m_pActiveRobotTask = createTransferTask_restore(pAligner, pLoadPorts);
               CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
            }


            // LoadPort -> Aligner
            for (int s = 0; s < 4; s++) {
               PortType pt = pLoadPorts[s]->getPortType();
               if (!rmd.armState[0] && pLoadPorts[s]->isEnable()
                  && (pt == PortType::Loading || pt == PortType::Both)
                  && pLoadPorts[s]->getPortStatus() == PORT_INUSE) {
                  m_pActiveRobotTask = createTransferTask(pLoadPorts[s], pAligner, primaryType, secondaryType, m_bJobMode);
                  if (m_pActiveRobotTask != nullptr) {
                     pEFEM->setContext(m_pActiveRobotTask->getContext());
                     bool bMoved = glassFromQueueToInPorcess((CGlass*)m_pActiveRobotTask->getContext());
                     if (bMoved) {
                        LOGI("<Master>Glass(%s)从等待列队到工艺列队转移成功.",
                           ((CGlass*)m_pActiveRobotTask->getContext())->getID().c_str());
                     }
                     else {
                        LOGE("<Master>Glass(%s)从等待列队到工艺列队转移失败.",
                           ((CGlass*)m_pActiveRobotTask->getContext())->getID().c_str());
                     }

                     goto BATCH_PORT_GET;
                  }
               }
            }

         BATCH_PORT_GET:
            CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);


@@ -983,9 +1245,12 @@
         BOOL bOk = FALSE;
         lock();
         if (m_pActiveRobotTask != nullptr) {
            LOGI("<CMaster>onPreFethedOutJob 0001.");
            if (m_pActiveRobotTask->getSrcPosition() == p->getID()) {
               LOGI("<CMaster>onPreFethedOutJob 0002.");
               CGlass* pGlass = p->getGlassFromSlot(m_pActiveRobotTask->getSrcSlot());
               if (pGlass != nullptr) {
                  LOGI("<CMaster>onPreFethedOutJob 0003.");
                  CJobDataS* pJobDataS = pGlass->getJobDataS();
                  if (pJobDataS != nullptr
                     && pJobDataS->getCassetteSequenceNo() == pJobDataB->getCassetteSequenceNo()
@@ -1103,6 +1368,21 @@

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

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


               unlock();


@@ -2095,4 +2375,85 @@

      return true;
   }

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