1. 通信地址修改 2. 修复设置Port时，只添加了Port1 3. 搬运测试界面优化

mrDarker

2025-06-16 817d91396abc1cca6f1ef5abb1fd5fbfd3511268

 SourceCode/Bond/Servo/CMaster.cpp

@@ -160,9 +160,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);
@@ -287,21 +287,31 @@


      // 各种机器
      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* 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(pLoadPort3);
      ASSERT(pLoadPort4);
      ASSERT(pFliper);
      ASSERT(pVacuumBack);
      ASSERT(pAligner);
      ASSERT(pBonder1);
      ASSERT(pBonder2);
      ASSERT(pBakeCooling);
      ASSERT(pMeasurement);

      while (1) {
         // 待退出信号或时间到
@@ -365,14 +375,99 @@
            }


            // Measurement -> LoadPort
            CLoadPort* pEqLoadPort[] = { pLoadPort1, pLoadPort2, pLoadPort3, pLoadPort4 };
            CEquipment* pEqTar[] = { pVacuumBack, pFliper };
            if (primaryType == MaterialsType::G2) {
               pEqTar[0] = pFliper;
               pEqTar[1] = pVacuumBack;
            }
            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->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;
            }


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

				
            // 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, 0);
                  m_listener.onRobotTaskEvent(this, m_pActiveRobotTask, ROBOT_EVENT_CREATE);
               }
               LOGI("创建新任务<%s>...", strDescription.c_str());
               continue;
@@ -380,10 +475,11 @@

            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, 0);
                  m_listener.onRobotTaskEvent(this, m_pActiveRobotTask, ROBOT_EVENT_CREATE);
               }
               LOGI("创建新任务<%s>...", strDescription.c_str());
               continue;
@@ -394,10 +490,11 @@
            // 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, 0);
                  m_listener.onRobotTaskEvent(this, m_pActiveRobotTask, ROBOT_EVENT_CREATE);
               }
               LOGI("创建新任务<%s>...", strDescription.c_str());
               continue;
@@ -405,10 +502,11 @@

            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, 0);
                  m_listener.onRobotTaskEvent(this, m_pActiveRobotTask, ROBOT_EVENT_CREATE);
               }
               LOGI("创建新任务<%s>...", strDescription.c_str());
               continue;
@@ -417,69 +515,30 @@

            // LoadPort -> Fliper(G2)
            // LoadPort -> VacuumBake(G1)
            CEquipment* pEqTar1 = pVacuumBack;
            CEquipment* pEqTar2 = pFliper;
            if (primaryType == MaterialsType::G2) {
               pEqTar1 = pFliper;
               pEqTar2 = pVacuumBack;
            for (int s = 0; s < 4; s++) {
               for (int t = 0; t < 2; t++) {
                  if (pEqLoadPort[s]->isEnable()
                     && pEqLoadPort[s]->getPortType() == PortType::Loading
                     && pEqLoadPort[s]->getPortMode() == PortMode::ReadyToLoad) {
                     m_pActiveRobotTask = createTransferTask(pEqLoadPort[s], pEqTar[t], primaryType, secondaryType);
                     if (m_pActiveRobotTask != nullptr) {
                        goto PORT_GET;
                     }
                  }
               }
            }
            m_pActiveRobotTask = createTransferTask(pLoadPort1, pEqTar1, primaryType, secondaryType);

PORT_GET:
            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, 0);
                  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) {
               std::string strDescription = m_pActiveRobotTask->getDescription();
               unlock();
               if (m_listener.onRobotTaskEvent != nullptr) {
                  m_listener.onRobotTaskEvent(this, m_pActiveRobotTask, 0);
               }
               LOGI("创建新任务<%s>...", strDescription.c_str());
               continue;
            }



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

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


            // Bonder -> BakeCooling


            // BakeCooling ->Measurement


            // Measurement -> LoadPort



            unlock();

@@ -504,17 +563,26 @@
            break;
         }

         // 读标志位
         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();
            //if (item->getID() == EQ_ID_Bonder1 ||
            //   item->getID() == EQ_ID_Bonder2) {
            //   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);
               }
            //   int nRet = m_cclink.ReadData2(station, (DeviceType)block.type,
            //      block.start, block.size, block.buffer);
            //   if (0 == nRet) {
            //      item->onReceiveLBData(block.buffer, block.size);
            //   }
            //}
            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);
            }
         }
      }
@@ -647,12 +715,11 @@


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

               if (m_listener.onRobotTaskEvent != nullptr) {
                  m_listener.onRobotTaskEvent(this, m_pActiveRobotTask, 0);
               }
            }
            unlock();
         }
@@ -729,7 +796,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);

@@ -840,7 +907,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);

@@ -1074,16 +1141,17 @@
      CRobotTask* pTask = nullptr;
      CSlot* pSrcSlot, * pTarSlot;
      pTarSlot = pTarEq->getAvailableSlotForGlass(primaryType);
      pSrcSlot = pSrcEq->getNonEmptySlot(primaryType);
      pSrcSlot = pSrcEq->getProcessedSlot(primaryType);
      if (pSrcSlot == nullptr || nullptr == pTarSlot) {
         pTarSlot = pTarEq->getAvailableSlotForGlass(secondaryType);
         pSrcSlot = pSrcEq->getNonEmptySlot(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());
      }
@@ -1091,4 +1159,93 @@

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

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