1.获取配方后自动刷新列表； 2.HsmsAction序列化和反序列化，将来用于缓存上报的数据；

LAPTOP-SNT8I5JK\Boounion

2025-07-30 166fa1cb727d6fe6962bbd2b5c4a0c9da6088048

 SourceCode/Bond/Servo/CMaster.cpp

@@ -51,6 +51,9 @@
      m_state = MASTERSTATE::READY;
      m_pActiveRobotTask = nullptr;
      m_nLastError = 0;
      m_isCompareMapsBeforeProceeding = FALSE;
      m_bEnableEventReport = true;
      m_bEnableAlarmReport = true;
      InitializeCriticalSection(&m_criticalSection);
   }

@@ -545,15 +548,11 @@
               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++) {
               PortType pt = pLoadPorts[s]->getPortType();
               if (!rmd.armState[0] && pLoadPorts[s]->isEnable()
                  && pLoadPorts[s]->getPortType() == PortType::Unloading
                  && pLoadPorts[s]->getPortMode() == PortMode::ReadyToUnload) {
                  && (pt == PortType::Unloading || pt == PortType::Both)
                  && pLoadPorts[s]->getPortStatus() == PORT_INUSE) {
                  m_pActiveRobotTask = createTransferTask(pMeasurement, pLoadPorts[s], primaryType, secondaryType);
                  if (m_pActiveRobotTask != nullptr) {
                     goto PORT_PUT;
@@ -562,157 +561,65 @@
            }

         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;
            }
            CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);


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




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


            
            // BakeCooling内部
            // Bake -> Cooling
            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;
               }
               CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
            }


            // Bonder -> BakeCooling
            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;
               }
               CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
            }

            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;
               }
               CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
            }


            // Fliper(G2) -> Bonder
            // VacuumBake(G1) -> Bonder
            if (!rmd.armState[1] && !pBonder1->hasBondClass()) {
            auto pSrcSlot = pVacuumBake->getProcessedSlot(primaryType);
            if (pSrcSlot != nullptr && !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;
               }
               CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
            }

            if (!rmd.armState[1] && !pBonder2->hasBondClass()) {
            if (pSrcSlot != nullptr && !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;
               }
               CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
            }


            // VacuumBake(G1) -> Bonder
            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;
               }
               CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
            }

            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;
               }
               CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
            }


@@ -720,55 +627,28 @@
            // 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;
               }
               CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
            }

            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;
               }
               CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
            }


            // 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;
               }
               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()
                  && pLoadPorts[s]->getPortType() == PortType::Loading
                  && pLoadPorts[s]->getPortMode() == PortMode::ReadyToLoad) {
                  && (pt == PortType::Loading || pt == PortType::Both)
                  && pLoadPorts[s]->getPortStatus() == PORT_INUSE) {
                  m_pActiveRobotTask = createTransferTask(pLoadPorts[s], pAligner, primaryType, secondaryType);
                  if (m_pActiveRobotTask != nullptr) {
                     pEFEM->setContext(m_pActiveRobotTask->getContext());
@@ -778,19 +658,11 @@
            }

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;
            }
            CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);


            unlock();

            continue;
         }
         unlock();
      }
@@ -1016,6 +888,12 @@
         LOGE("<Master-%s>Port InUse, map(%d!=%d)不一致，请检查。",
            ((CEquipment*)pEquipment)->getName().c_str(), scanMap, downMap);
      };
      listener.onPortStatusChanged = [&](void* pEquipment, short status, __int64 data) {
         LOGE("<Master-%s>Port InUse。status=%d, data=%lld", ((CEquipment*)pEquipment)->getName().c_str(), status);
         if (m_listener.onLoadPortStatusChanged != nullptr) {
            m_listener.onLoadPortStatusChanged(this, (CEquipment*)pEquipment, status, data);
         }
      };
      pEquipment->setListener(listener);
      pEquipment->setCcLink(&m_cclink);
      m_listEquipment.push_back(pEquipment);
@@ -1053,6 +931,7 @@
      pEquipment->setID(EQ_ID_LOADPORT1 + index);
      pEquipment->setName(szName);
      pEquipment->setDescription(szName);
      pEquipment->setCompareMapsBeforeProceeding(m_isCompareMapsBeforeProceeding);		
      addToEquipmentList(pEquipment);


@@ -1409,6 +1288,10 @@
      MaterialsType primaryType/* = MaterialsType::G1*/, MaterialsType secondaryType/* = MaterialsType::G2*/,
      int armNo/* = 1*/)
   {
      if (!pSrcEq->IsEnabled()) { 
         return nullptr;
      }

      CRobotTask* pTask = nullptr;
      CSlot* pSrcSlot, * pTarSlot;
      pTarSlot = pTarEq->getAvailableSlotForGlass(primaryType);
@@ -1433,6 +1316,10 @@

   CRobotTask* CMaster::createTransferTask_bonder_to_bakecooling(CEquipment* pSrcEq, CEquipment* pTarEq)
   {
      if (!pSrcEq->IsEnabled()) {
         return nullptr;
      }

      std::vector<int> slots = {1, 3};

      CRobotTask* pTask = nullptr;
@@ -1454,6 +1341,10 @@

   CRobotTask* CMaster::createTransferTask_bake_to_cooling(CEquipment* pSrcEq)
   {
      if (!pSrcEq->IsEnabled()) {
         return nullptr;
      }

      std::vector<int> slotsTar = { 2, 4 };
      std::vector<int> slotsSrc = { 1, 3 };

@@ -1476,6 +1367,10 @@

   CRobotTask* CMaster::createTransferTask_bakecooling_to_measurement(CEquipment* pSrcEq, CEquipment* pTarEq)
   {
      if (!pSrcEq->IsEnabled()) {
         return nullptr;
      }

      std::vector<int> slots = { 2, 4 };

      CRobotTask* pTask = nullptr;
@@ -1497,6 +1392,10 @@

   CRobotTask* CMaster::createTransferTask_restore(CEquipment* pEqSrc, CLoadPort** pPorts)
   {
      if (!pEqSrc->IsEnabled()) {
         return nullptr;
      }

      CRobotTask* pTask = nullptr;
      CSlot* pSrcSlot, * pTarSlot = nullptr, * pTempSlot;
      pSrcSlot = pEqSrc->getInspFailSlot();
@@ -1547,7 +1446,8 @@
      unlock();

      // 当前任务手动中止后，停止调度，需要操作员在解决问题后，重新启动
      stop();
      // 25年7月23日后修改为不停止任务
      // stop();

      return 0;
   }
@@ -1557,6 +1457,18 @@
      lock();
      if (m_pActiveRobotTask != nullptr) {
         m_pActiveRobotTask->restore();
      }
      unlock();


      return 0;
   }

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

@@ -1578,6 +1490,27 @@
      pPort->localAutoChangeEnable(autoChangeEnable);
   }

   void CMaster::setPortCassetteType(unsigned int index, SERVO::CassetteType type)
   {
      ASSERT(index < 4);
      int eqid[] = { EQ_ID_LOADPORT1, EQ_ID_LOADPORT2, EQ_ID_LOADPORT3, EQ_ID_LOADPORT4 };
      CLoadPort* pPort = (CLoadPort*)getEquipment(eqid[index]);
      pPort->localSetCessetteType(type);
   }

   void CMaster::setPortEnable(unsigned int index, BOOL bEnable)
   {
      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(bEnable);
   }

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

   void CMaster::datetimeSync(SYSTEMTIME& time)
   {
      for (auto item : m_listEquipment) {
@@ -1585,4 +1518,19 @@
            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;
   }
}