1.机器配方参数的获取；

LAPTOP-SNT8I5JK\Boounion

2025-09-04 1efb832676e8ad27e7a495dba6ffc19479e0c76f

 SourceCode/Bond/Servo/CEquipment.cpp

@@ -7,26 +7,11 @@
#include "Servo.h"


#define CHECK_READ_STEP_SIGNAL(addr, data, size) {                     \
   BOOL bFlag = isBitOn(data, size, addr);                           \
   SERVO::CStep* pStep = getStep(addr);                           \
   if (pStep != nullptr) {                                       \
      ((CReadStep*)pStep)->onReadSignal(bFlag ? addr : 0);            \
   }                                                      \
}

#define CHECK_WRITE_STEP_SIGNAL(addr, data, size) {                     \
   BOOL bFlag = isBitOn(data, size, addr);                           \
   SERVO::CStep* pStep = getStep(addr);                           \
   if (pStep != nullptr) {                                       \
      ((CWriteStep*)pStep)->onRecvSignal(bFlag ? addr : 0);            \
   }                                                      \
}

namespace SERVO {

   CEquipment::CEquipment() : m_nID(0), m_strName(""), m_strDescription(""), m_station(0, 255)
   {
      m_bEnable = TRUE;
      m_listener = { };
      m_alive = { FALSE, 0, FALSE };
      m_bCimState = FALSE;
@@ -42,6 +27,7 @@
      m_pArm = nullptr;
      m_processState = PROCESS_STATE::Ready;
      m_blockReadBit = { 0 };
      m_nTestFlag = 0;
      InitializeCriticalSection(&m_criticalSection);
   }

@@ -70,6 +56,16 @@
      m_outputPins.clear();

      DeleteCriticalSection(&m_criticalSection);
   }

   void CEquipment::SetEnable(BOOL bEnable)
   {
      m_bEnable = bEnable;
   }

   BOOL CEquipment::IsEnabled() const
   {
      return m_bEnable;
   }

   void CEquipment::setListener(EquipmentListener listener)
@@ -500,6 +496,11 @@
      // 主配方上报
      CHECK_READ_STEP_SIGNAL(STEP_ID_MASTER_RECIPE_LIST_REPORT, pszData, size);

      // 配方参数
      CHECK_WRITE_STEP_SIGNAL(STEP_ID_RECIPE_PARAMETER_CMD_REPLY, pszData, size);
      CHECK_READ_STEP_SIGNAL(STEP_ID_RECIPE_PARAMETER_REPORT, pszData, size);
		

      // CIM Mode
      CHECK_WRITE_STEP_SIGNAL(STEP_ID_CIMMODE_CHANGED_CMD_REPLY, pszData, size);

@@ -530,8 +531,12 @@
      // EQ Job Event
      CHECK_READ_STEP_SIGNAL(STEP_ID_RECIVE_JOB_UPS1, pszData, size);
      CHECK_READ_STEP_SIGNAL(STEP_ID_RECIVE_JOB_UPS2, pszData, size);
      CHECK_READ_STEP_SIGNAL(STEP_ID_RECIVE_JOB_UPS3, pszData, size);
      CHECK_READ_STEP_SIGNAL(STEP_ID_RECIVE_JOB_UPS4, pszData, size);
      CHECK_READ_STEP_SIGNAL(STEP_ID_SENT_OUT_JOB_DOWNS1, pszData, size);
      CHECK_READ_STEP_SIGNAL(STEP_ID_SENT_OUT_JOB_DOWNS2, pszData, size);
      CHECK_READ_STEP_SIGNAL(STEP_ID_SENT_OUT_JOB_DOWNS3, pszData, size);
      CHECK_READ_STEP_SIGNAL(STEP_ID_SENT_OUT_JOB_DOWNS4, pszData, size);

      // Store Job Report #1~15
      CHECK_READ_STEP_SIGNAL(STEP_ID_STORE_JOB_REPORT1, pszData, size);
@@ -601,7 +606,7 @@
      CHECK_WRITE_STEP_SIGNAL(STEP_ID_IN_OP_CMD_REPLY, pszData, size);

      // Panel Data Report
      CHECK_WRITE_STEP_SIGNAL(STEP_ID_PANEL_DATA_REPORT, pszData, size);
      CHECK_READ_STEP_SIGNAL(STEP_ID_PANEL_DATA_REPORT, pszData, size);

      // Panel Data Request
      CHECK_WRITE_STEP_SIGNAL(STEP_ID_PANEL_DATA_REQUEST, pszData, size);   
@@ -612,6 +617,11 @@
      // job process start/end report
      CHECK_READ_STEP_SIGNAL(STEP_ID_JOB_PROCESS_START_REPORT, pszData, size);
      CHECK_READ_STEP_SIGNAL(STEP_ID_JOB_PROCESS_END_REPORT, pszData, size);

      CHECK_WRITE_STEP_SIGNAL(STEP_ID_PROT1_CASSETTE_CTR_CMD_REPLY, pszData, size);
      CHECK_WRITE_STEP_SIGNAL(STEP_ID_PROT2_CASSETTE_CTR_CMD_REPLY, pszData, size);
      CHECK_WRITE_STEP_SIGNAL(STEP_ID_PROT3_CASSETTE_CTR_CMD_REPLY, pszData, size);
      CHECK_WRITE_STEP_SIGNAL(STEP_ID_PROT4_CASSETTE_CTR_CMD_REPLY, pszData, size);
   }

   BOOL CEquipment::isBitOn(const char* pszData, size_t size, int index)
@@ -806,6 +816,16 @@
   CRecipeList* CEquipment::getRecipeList(int unitNo)
   {
      return m_recipesManager.getRecipeList(unitNo);
   }

   bool CEquipment::saveRecipeList(int unitNo, std::string& strFilepath)
   {
      return m_recipesManager.saveRecipeList(unitNo, strFilepath);
   }

   bool CEquipment::readRecipeList(int unitNo, std::string& strFilepath)
   {
      return m_recipesManager.readRecipeList(unitNo, strFilepath);
   }

   int CEquipment::recvIntent(CPin* pPin, CIntent* pIntent)
@@ -1184,28 +1204,39 @@
      return 0;
   }

   int CEquipment::recipeParameterRequest(short masterRecipeId, short localRecipeId, short unitNo)
   int CEquipment::recipeParameterRequest(short masterRecipeId, short localRecipeId, short unitNo, ONSYNCINGSTATECHANGED block)
   {
      SERVO::CEqWriteStep* pStep = (SERVO::CEqWriteStep*)getStepWithName(STEP_EQ_MASTER_RECIPE_LIST_REQ);
      LOGI("<CEquipment-%s>正在请求单元<%d>主配参数列表", m_strName.c_str(), unitNo);
      m_recipesManager.setOnSyncingStateChanged(block);
      if (m_recipesManager.syncing() != 0) {
         return -2;
      }

      SERVO::CEqWriteStep* pStep = (SERVO::CEqWriteStep*)getStepWithName(STEP_EQ_RECIPE_PARAMETER_REQ);
      if (pStep == nullptr) {
         return -1;
      }

      LOGI("<CEquipment-%s>正在请求单元<%d>主配方列表", m_strName.c_str(), unitNo);
      if (m_recipesManager.syncing() != 0) {
         return -2;
      }
      pStep->writeShort(unitNo, [&, unitNo](int code) -> int {
      char szBuffer[14 * 2] = {0};
      int index = 0;
      memcpy(&szBuffer[index], &masterRecipeId, sizeof(short)); 
      index += sizeof(short);
      memcpy(&szBuffer[index], &localRecipeId, sizeof(short));
      index += sizeof(short);
      memcpy(&szBuffer[index], &unitNo, sizeof(short));

      pStep->writeDataEx(szBuffer, 14 * 2, [&, unitNo](int code) -> int {
         if (code == WOK) {
            LOGI("<CEquipment-%s>请求单元<%d>主配方列表成功，正在等待数据.", m_strName.c_str(), unitNo);
            LOGI("<CEquipment-%s>请求单元<%d>主配方参数列表成功，正在等待数据.", m_strName.c_str(), unitNo);
         }
         else {
            m_recipesManager.syncFailed();
            LOGI("<CEquipment-%s>请求单元<%d>主配方列表失败，code:%d", m_strName.c_str(), unitNo, code);
            LOGI("<CEquipment-%s>请求单元<%d>主配方参数列表失败，code:%d", m_strName.c_str(), unitNo, code);
         }

         return 0;
         });
      });

      return 0;
   }

@@ -1270,6 +1301,12 @@
               if (m_slot[i].isLock()) continue;
               if (!m_slot[i].isEmpty()) continue;

               int lsPath = m_slot[i].getLinkSignalPath();
               if (!m_bLinkSignalToDownstream[lsPath][SIGNAL_UPSTREAM_INLINE]
                  || m_bLinkSignalToDownstream[lsPath][SIGNAL_UPSTREAM_TROUBLE]
                  || !m_bLinkSignalToDownstream[lsPath][SIGNAL_INTERLOCK]
                  || !m_bLinkSignalToDownstream[lsPath][SIGNAL_RECEIVE_ABLE]) continue;

               MaterialsType slotType = m_slot[i].getType();
               if (type == MaterialsType::G1 && slotType == MaterialsType::G2) continue;
               if (type == MaterialsType::G2 && slotType == MaterialsType::G1) continue;
@@ -1280,6 +1317,21 @@
      }

      return nullptr;
   }

   CSlot* CEquipment::isSlotAvailable(unsigned int slot)
   {
      if (slot >= 8) return nullptr;
      if (!m_slot[slot].isEnable()) return nullptr;
      if (m_slot[slot].isLock()) return nullptr;
      if (!m_slot[slot].isEmpty()) return nullptr;
      int lsPath = m_slot[slot].getLinkSignalPath();
      if (!m_bLinkSignalToDownstream[lsPath][SIGNAL_UPSTREAM_INLINE]
         || m_bLinkSignalToDownstream[lsPath][SIGNAL_UPSTREAM_TROUBLE]
         || !m_bLinkSignalToDownstream[lsPath][SIGNAL_INTERLOCK]
         || !m_bLinkSignalToDownstream[lsPath][SIGNAL_RECEIVE_ABLE]) return nullptr;

      return &m_slot[slot];
   }

   CSlot* CEquipment::getNonEmptySlot(MaterialsType putSlotType)
@@ -1300,24 +1352,35 @@
      return nullptr;
   }

   CSlot* CEquipment::getProcessedSlot(MaterialsType putSlotType)
   CSlot* CEquipment::getProcessedSlot(MaterialsType putSlotType, BOOL bJobMode/* = FALSE*/)
   {
      for (int i = 0; i < SLOT_MAX; i++) {
         if (m_nTestFlag == 1) LOGI("getProcessedSlot 001");
         if (!m_slot[i].isEnable()) continue;
         if (m_nTestFlag == 1) LOGI("getProcessedSlot 002");
         if (m_slot[i].isLock()) continue;
         if (m_nTestFlag == 1) LOGI("getProcessedSlot 003");
         CGlass* pGlass = (CGlass*)m_slot[i].getContext();
         if (!isSlotProcessed(i)) continue;
         if (m_nTestFlag == 1) LOGI("getProcessedSlot 004");
         if (pGlass == nullptr) continue;
         if (m_nTestFlag == 1) LOGI("getProcessedSlot 005");
         if (!pGlass->isScheduledForProcessing()) continue;
         if (m_nTestFlag == 1) LOGI("getProcessedSlot 006");
         if (bJobMode && pGlass->getProcessJob() == nullptr) continue;
         if (m_nTestFlag == 1) LOGI("getProcessedSlot 007");
         if(pGlass->getInspResult(m_nID, 0) == InspResult::Fail) continue;
         int lsPath = m_slot[i].getLinkSignalPath();
         if(!m_bLinkSignalToUpstream[lsPath][SIGNAL_UPSTREAM_INLINE]
            || m_bLinkSignalToUpstream[lsPath][SIGNAL_UPSTREAM_TROUBLE]
            || !m_bLinkSignalToUpstream[lsPath][SIGNAL_INTERLOCK]
            || !m_bLinkSignalToUpstream[lsPath][SIGNAL_SEND_ABLE] ) continue;

         if (m_nTestFlag == 1) LOGI("getProcessedSlot 008");
         MaterialsType glassType = pGlass->getType();
         if (glassType == MaterialsType::G1 && putSlotType == MaterialsType::G2) continue;
         if (m_nTestFlag == 1) LOGI("getProcessedSlot 009");
         if (glassType == MaterialsType::G2 && putSlotType == MaterialsType::G1) continue;

         if (m_nTestFlag == 1) LOGI("getProcessedSlot 00a");
         return &m_slot[i];
      }

@@ -1352,6 +1415,43 @@
      return nullptr;
   }

   CSlot* CEquipment::getProcessedSlotCt(unsigned int slot)
   {
      if (slot >= 8) return nullptr;
      if (!m_slot[slot].isEnable()) return nullptr;
      if (m_slot[slot].isLock()) return nullptr;
      CGlass* pGlass = (CGlass*)m_slot[slot].getContext();
      if (pGlass == nullptr) return nullptr;
      int lsPath = m_slot[slot].getLinkSignalPath();
      if (!m_bLinkSignalToUpstream[lsPath][SIGNAL_UPSTREAM_INLINE]
         || m_bLinkSignalToUpstream[lsPath][SIGNAL_UPSTREAM_TROUBLE]
         || !m_bLinkSignalToUpstream[lsPath][SIGNAL_INTERLOCK]
         || !m_bLinkSignalToUpstream[lsPath][SIGNAL_SEND_ABLE]) return nullptr;
		
      return &m_slot[slot];
   }

   CSlot* CEquipment::getInspFailSlot()
   {
      for (int i = 0; i < SLOT_MAX; i++) {
         if (!m_slot[i].isEnable()) continue;
         if (m_slot[i].isLock()) continue;
         CGlass* pGlass = (CGlass*)m_slot[i].getContext();
         if (pGlass == nullptr) continue;
         if (!pGlass->isScheduledForProcessing()) continue;
         if (pGlass->getInspResult(m_nID, 0) != InspResult::Fail) continue;
         int lsPath = m_slot[i].getLinkSignalPath();
         if (!m_bLinkSignalToUpstream[lsPath][SIGNAL_UPSTREAM_INLINE]
            || m_bLinkSignalToUpstream[lsPath][SIGNAL_UPSTREAM_TROUBLE]
            || !m_bLinkSignalToUpstream[lsPath][SIGNAL_INTERLOCK]
            || !m_bLinkSignalToUpstream[lsPath][SIGNAL_SEND_ABLE]) continue;

         return &m_slot[i];
      }

      return nullptr;
   }

   CSlot* CEquipment::getSlot(int index)
   {
      if (index >= SLOT_MAX) return nullptr;
@@ -1380,6 +1480,13 @@
      return TRUE;
   }

   BOOL CEquipment::slotHasGlass(int slotIndex/* = 0*/)
   {
      ASSERT(slotIndex < 8);
      CGlass* pGlass = (CGlass*)m_slot[slotIndex].getContext();
      return (pGlass != nullptr);
   }

   int CEquipment::removeGlass(int slotNo)
   {
      CSlot* pSlot = nullptr;
@@ -1392,6 +1499,10 @@

      if (pSlot == nullptr) return -1;
      pSlot->setContext(nullptr);
      if (m_listener.onDataChanged != nullptr) {
         m_listener.onDataChanged(this, EDCC_FETCHOUT_JOB);
      }

      return 0;
   }

@@ -1586,7 +1697,7 @@
   int CEquipment::decodeVCREventReport(CStep* pStep, const char* pszData, size_t size)
   {
      CVcrEventReport vcrEventReport;
      vcrEventReport.unserialize(pszData, size);
      vcrEventReport.unserialize(pszData, (int)size);
      LOGI("<CEquipment-%s>decodeVCREventReport<Result:%d, GlassId:%s>\n", m_strName.c_str(),
         vcrEventReport.getVcrResult(),
         vcrEventReport.getGlassId().c_str());
@@ -1614,7 +1725,7 @@
      index += sizeof(short);
      CToolUnits::convertString(&pszData[index], 128 * 2, strPanelJudgeData);
      index += 128 * 2;
      CToolUnits::convertString(&pszData[index], 256 * 2, strPanelJudgeData);
      CToolUnits::convertString(&pszData[index], 256 * 2, strPanelGradeData);
      index += 256 * 2;


@@ -1630,6 +1741,15 @@
         strPanelGradeData.c_str(), "", weight++));


      // 更新检测结果
      CGlass* pGlass = getGlassWithCassette(cassetteNo, jobSequenceNo);
      if (pGlass == nullptr) {
         LOGE("<CEquipment-%s>更新Panel Data失败，找不到对应的Glass.cassetteNo=%d, jobSequenceNo=%d",
            getName().c_str(), cassetteNo, jobSequenceNo);
         return -1;
      }
      pGlass->setInspResult(m_nID, 0, judgeStringToInspResult(strPanelJudgeData));

      return 0;
   }

@@ -1639,7 +1759,7 @@
      std::string strSvTimeRecord, strSvData;
      CToolUnits::convertString(&pszData[index], 8 * 2, strSvTimeRecord);
      index += 128 * 2;
      CToolUnits::convertString(&pszData[index], 640 * 2, strSvData);
      CToolUnits::convertString(&pszData[index], 100 * 2, strSvData);
      index += 256 * 2;


@@ -1913,14 +2033,14 @@
    */
   int CEquipment::onSendAble(int port)
   {
      LOGI("<CEquipment-%s>onSendAble.port:%d", m_strName.c_str(), port);
      // LOGI("<CEquipment-%s>onSendAble.port:%d", m_strName.c_str(), port);

      return 0;
   }

   int CEquipment::onReceiveAble(int port)
   {
      LOGI("<CEquipment-%s>onReceiveAble.port:%d", m_strName.c_str(), port);
      // LOGI("<CEquipment-%s>onReceiveAble.port:%d", m_strName.c_str(), port);

      return 0;
   }
@@ -1969,4 +2089,50 @@
         );
      }
   }

   InspResult CEquipment::judgeStringToInspResult(std::string& strJudge)
   {
      if (strJudge.compare("N") == 0) {
         return InspResult::Fail;
      }
      if (strJudge.compare("G") == 0) {
         return InspResult::Pass;
      }

      return InspResult::NotInspected;
   }

   float CEquipment::toFloat(const char* pszAddr)
   {
      BYTE szBuffer[4];
      szBuffer[0] = pszAddr[0];
      szBuffer[1] = pszAddr[1];
      szBuffer[2] = pszAddr[2];
      szBuffer[3] = pszAddr[3];
      float f = 0.0;
      memcpy(&f, szBuffer, 4);

      return f;
   }

   int CEquipment::parsingParams(const char* pszData, size_t size, std::string& strOut)
   {
      std::vector<CParam> params;
      int nRet = parsingParams(pszData, size, params);
      if (nRet <= 0) return nRet;

      char szBuffer[256];
      for (auto p : params) {
         if(!strOut.empty()) strOut.append(",");
         if (p.getValueType() == PVT_INT) {
            sprintf_s(szBuffer, 256, "%s:%d", p.getName().c_str(), p.getIntValue());
         }
         else if (p.getValueType() == PVT_DOUBLE) {
            sprintf_s(szBuffer, 256, "%s:%f", p.getName().c_str(), p.getDoubleValue());
         }
         strOut.append(szBuffer);
      }

      return 0; 
   };
}