1.暂存配方参数获取

LAPTOP-SNT8I5JK\Boounion

2025-05-06 5bcbdac9793e19713d41b58c9eeefbd0818d192b

 SourceCode/Bond/Servo/CEquipment.cpp

@@ -1,14 +1,31 @@
#include "stdafx.h"
#include "CEquipment.h"
#include "ToolUnits.h"
#include <regex>


#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_listener = { nullptr, nullptr };
      m_alive = {FALSE, 0, FALSE};
      m_listener = { nullptr, nullptr, nullptr, nullptr, nullptr };
      m_alive = { FALSE, 0, FALSE };
      m_bCimState = FALSE;
      m_bUpstreamInline = FALSE;
      m_bDownstreamInline = FALSE;
@@ -22,6 +39,11 @@

   CEquipment::~CEquipment()
   {
      for (auto item : m_glassList) {
         item->release();
      }
      m_glassList.clear();

      for (auto item : m_mapStep) {
         delete item.second;
      }
@@ -44,6 +66,9 @@
   {
      m_listener.onAlive = listener.onAlive;
      m_listener.onCimStateChanged = listener.onCimStateChanged;
      m_listener.onAlarm = listener.onAlarm;
      m_listener.onDataChanged = listener.onDataChanged;
      m_listener.onVcrEventReport = listener.onVcrEventReport;
   }

   void CEquipment::setCcLink(CCCLinkIEControl* pCcLink)
@@ -98,6 +123,7 @@
      auto iter = m_mapStep.find(addr);
      if (iter != m_mapStep.end()) return -1;
      pStep->setEquipment(this);
      pStep->setID(addr);
      pStep->setCcLink(m_pCclink);
      m_mapStep[addr] = pStep;
      return 0;
@@ -106,6 +132,7 @@
   void CEquipment::init()
   {
      initPins();
      initSteps();
      for (auto item : m_mapStep) {
         item.second->init();
      }
@@ -116,6 +143,11 @@
      for (auto item : m_mapStep) {
         item.second->term();
      }
   }

   void CEquipment::initSteps()
   {

   }

   void CEquipment::setID(int nID)
@@ -190,6 +222,21 @@
         attrubutes.addAttribute(new CAttribute(szTemp,
            m_bVCREnable[i] ? _T("Enable") : _T("Disable"), ""));
      }

      for (auto item : m_inputPins) {
         attrubutes.addAttribute(new CAttribute(item->getName().c_str(),
            std::to_string((int)item->getType()).c_str(), ""));
      }

      for (auto item : m_outputPins) {
         attrubutes.addAttribute(new CAttribute(item->getName().c_str(),
            std::to_string((int)item->getType()).c_str(), ""));
      }

      for (auto item : m_glassList) {
         attrubutes.addAttribute(new CAttribute("Glass",
            item->getID().c_str(), ""));
      }
   }

   void CEquipment::setReadBitBlock(unsigned int start, unsigned int end)
@@ -238,7 +285,26 @@

   void CEquipment::serialize(CArchive& ar)
   {

      if (ar.IsStoring()) {
         Lock();
         int count = (int)m_glassList.size();
         ar << count;
         for (auto item : m_glassList) {
            item->serialize(ar);
         }
         Unlock();
      }
      else {
         Lock();
         int count;
         ar >> count;
         for (int i = 0; i < count; i++) {
            CGlass* pGlass = new CGlass();
            pGlass->serialize(ar);
            addGlassToList(pGlass);
         }
         Unlock();
      }
   }

   void CEquipment::onReceiveLBData(const char* pszData, size_t size)
@@ -253,7 +319,7 @@

      // 以下解释和处理数据
      BOOL bFlag;
      int index = 0x340;
      int index = 0x840;


      // alive
@@ -270,7 +336,7 @@
            }
         }
      }
	

      // CIM State
      bFlag = isBitOn(pszData, size, ++index);
      if (!equalBool(m_bCimState, bFlag)) {
@@ -304,7 +370,7 @@
         m_bAutoRecipeChange = bFlag;
      }

      // AutoRecipeChange
      // VCR Enable
      bFlag = isBitOn(pszData, size, ++index);
      if (!equalBool(m_bVCREnable[0], bFlag)) {
         m_bVCREnable[0] = bFlag;
@@ -312,26 +378,70 @@


      // 以下根据信号做流程处理
      CStep* pStep;

      // Equipment Mode Change Report(0x360)
      // Equipment Status Change Report(0x361)
      // Equipment Alarm Change Report(0x362 ~ 0x366)
      for (int i = 0; i < 7; i++) {
         index = 0x360 + i;;
         bFlag = isBitOn(pszData, size, index);
         pStep = getStep(index);
         if (pStep != nullptr) {
            ((CReadStep*)pStep)->onReadSignal(bFlag);
         }
         CHECK_READ_STEP_SIGNAL(STEP_ID_EQMODE_CHANGED + i, pszData, size);
      }

      index = 0x350;
      bFlag = isBitOn(pszData, size, index);
      pStep = getStep(index);
      if (pStep != nullptr) {
         ((CWriteStep*)pStep)->onRecvSignal(bFlag);
      }

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

      // CIM Message Set cmd reply
      CHECK_WRITE_STEP_SIGNAL(STEP_ID_CIM_MSG_SET_CMD_REPLY, pszData, size);

      // CIM Message Clear cmd reply
      CHECK_WRITE_STEP_SIGNAL(STEP_ID_CIM_MSG_CLEAR_CMD_REPLY, pszData, size);

      // Datetime set cmd reply
      CHECK_WRITE_STEP_SIGNAL(STEP_ID_DATETIME_SET_CMD_REPLY, pszData, size);

      // vcr enable cmd reply
      CHECK_WRITE_STEP_SIGNAL(STEP_ID_VCR_ENABLE_CMD_REPLY, pszData, size);

      // EQ mode change cmd reply
      CHECK_WRITE_STEP_SIGNAL(STEP_ID_EQMODE_CHANGE_CMD_REPLY, pszData, size);

      // EQ Master recipe request cmd reply
      CHECK_WRITE_STEP_SIGNAL(STEP_ID_MASTER_RECIPE_LIST_CMD_REPLY, pszData, size);

      // CIM Message Confirm
      CHECK_READ_STEP_SIGNAL(STEP_ID_CIM_MSG_CONFIRM_REPORT, pszData, size);

      // VCR1 Event report
      CHECK_READ_STEP_SIGNAL(STEP_ID_VCR1_EVENT_REPORT, pszData, size);

      // 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_SENT_OUT_JOB_DOWNS1, pszData, size);
      CHECK_READ_STEP_SIGNAL(STEP_ID_SENT_OUT_JOB_DOWNS2, pszData, size);


      // CEqCassetteTranserStateStep
      CHECK_READ_STEP_SIGNAL(STEP_ID_PORT1_CASSETTIE_EMPTY, pszData, size);
      CHECK_READ_STEP_SIGNAL(STEP_ID_PORT1_CASSETTIE_LOAD_READY, pszData, size);
      CHECK_READ_STEP_SIGNAL(STEP_ID_PORT1_CASSETTIE_LOADED, pszData, size);
      CHECK_READ_STEP_SIGNAL(STEP_ID_PORT1_CASSETTIE_INUSE, pszData, size);
      CHECK_READ_STEP_SIGNAL(STEP_ID_PORT1_CASSETTIE_UNLOAD_READY, pszData, size);
      CHECK_READ_STEP_SIGNAL(STEP_ID_PORT1_CASSETTIE_BLOCKED, pszData, size);
      CHECK_READ_STEP_SIGNAL(STEP_ID_PORT2_CASSETTIE_EMPTY, pszData, size);
      CHECK_READ_STEP_SIGNAL(STEP_ID_PORT2_CASSETTIE_LOAD_READY, pszData, size);
      CHECK_READ_STEP_SIGNAL(STEP_ID_PORT2_CASSETTIE_LOADED, pszData, size);
      CHECK_READ_STEP_SIGNAL(STEP_ID_PORT2_CASSETTIE_INUSE, pszData, size);
      CHECK_READ_STEP_SIGNAL(STEP_ID_PORT2_CASSETTIE_UNLOAD_READY, pszData, size);
      CHECK_READ_STEP_SIGNAL(STEP_ID_PORT2_CASSETTIE_BLOCKED, pszData, size);
      CHECK_READ_STEP_SIGNAL(STEP_ID_PORT3_CASSETTIE_EMPTY, pszData, size);
      CHECK_READ_STEP_SIGNAL(STEP_ID_PORT3_CASSETTIE_LOAD_READY, pszData, size);
      CHECK_READ_STEP_SIGNAL(STEP_ID_PORT3_CASSETTIE_LOADED, pszData, size);
      CHECK_READ_STEP_SIGNAL(STEP_ID_PORT3_CASSETTIE_INUSE, pszData, size);
      CHECK_READ_STEP_SIGNAL(STEP_ID_PORT3_CASSETTIE_UNLOAD_READY, pszData, size);
      CHECK_READ_STEP_SIGNAL(STEP_ID_PORT3_CASSETTIE_BLOCKED, pszData, size);
      CHECK_READ_STEP_SIGNAL(STEP_ID_PORT4_CASSETTIE_EMPTY, pszData, size);
      CHECK_READ_STEP_SIGNAL(STEP_ID_PORT4_CASSETTIE_LOAD_READY, pszData, size);
      CHECK_READ_STEP_SIGNAL(STEP_ID_PORT4_CASSETTIE_LOADED, pszData, size);
      CHECK_READ_STEP_SIGNAL(STEP_ID_PORT4_CASSETTIE_INUSE, pszData, size);
      CHECK_READ_STEP_SIGNAL(STEP_ID_PORT4_CASSETTIE_UNLOAD_READY, pszData, size);
      CHECK_READ_STEP_SIGNAL(STEP_ID_PORT4_CASSETTIE_BLOCKED, pszData, size);
   }

   BOOL CEquipment::isBitOn(const char* pszData, size_t size, int index)
@@ -384,6 +494,50 @@
      return m_bVCREnable[index];
   }

   int CEquipment::onStepEvent(CStep* pStep, int code)
   {
      if (code == STEP_EVENT_READDATA) {
         if (isAlarmStep(pStep)) {
            SERVO::CEqAlarmStep* pEqAlarmStep = (SERVO::CEqAlarmStep*)pStep;
            int state = pEqAlarmStep->getAlarmState();
            ASSERT(state == 0 || state == 1);
            if (m_listener.onAlarm != nullptr) {
               m_listener.onAlarm(this, state,
                  pEqAlarmStep->getAlarmId(),
                  pEqAlarmStep->getUnitId(),
                  pEqAlarmStep->getAlarmLevel());
            }

            return 1;
         }
         else if (isCimMessageConfirmStep(pStep)) {
            SERVO::CEqReadIntStep* pEqReadIntStep = (SERVO::CEqReadIntStep*)pStep;
            int value = pEqReadIntStep->getValue();
            // 此处将value按高低位拆分为message id和panel no.
            // 可能还需要上报到cim
            short msgId, panelNo;
            msgId = (value & 0xffff0000 >> 16);
            panelNo = (value & 0xffff);
            LOGI("Cim Message Confirm(msgID = %d, panel no.=%d).", msgId, panelNo);
         }
         else if (isVcrEventStep(pStep)) {
            SERVO::CEqVcrEventStep* pEqVcrEventStep = (SERVO::CEqVcrEventStep*)pStep;
            CVcrEventReport* pVcrEventReport = pEqVcrEventStep->getVcrEventReport();
            ASSERT(pVcrEventReport);
            if (m_listener.onVcrEventReport != nullptr) {
               m_listener.onVcrEventReport(this, pVcrEventReport);
            }

            // 0426, 先固定返回1(OK)
            pEqVcrEventStep->setReturnCode(1);		
            return 1;
         }
      }


      return 0;
   }

   CPin* CEquipment::addPin(PinType type, char* pszName)
   {
      // 不允许名字添加重复的pin
@@ -433,9 +587,355 @@
      return m_outputPins;
   }

   int CEquipment::recvSample(CPin* pPin, CSample* pSample)
   int CEquipment::recvIntent(CPin* pPin, CIntent* pIntent)
   {
      LOGI("<CEquipment>recvSample, pin:%s", pPin->getName().c_str());
      ASSERT(pPin);
      CPin* pFromPin = pPin->getConnectedPin();
      ASSERT(pFromPin);
      CEquipment* pFromEq = pFromPin->getEquipment();
      ASSERT(pFromEq);

      LOGI("<CEquipment><%s-%s>收到来自<%s.%s>的Intent<%d,%s,0x%x>",
         this->getName().c_str(),
         pPin->getName().c_str(),
         pFromEq->getName().c_str(),
         pFromPin->getName().c_str(),
         pIntent->getCode(),
         pIntent->getMsg(),
         pIntent->getContext());



      // 以下解释处理数据
      int code = pIntent->getCode();


      // 测试
      if (code == FLOW_TEST) {
         AfxMessageBox(pIntent->getMsg());
         return FLOW_ACCEPT;
      }


      // 信号
      if (code == FLOW_SIGNAL) {
         return FLOW_ACCEPT;
      }


      // 数据
      if (code == FLOW_SIGNAL) {
         return FLOW_ACCEPT;
      }


      // 物料
      if (code == FLOW_MOVE_MATERIAL) {
         CGlass* pGlass = (CGlass*)pIntent->getContext();
         ASSERT(pGlass);
         if (!glassWillArrive(pGlass)) {
            return FLOW_REJECT;
         }
         return glassArrived(pGlass);
      }



      return FLOW_ACCEPT;
   }

   int CEquipment::outputGlass(int port)
   {
      CPin* pOutPin = nullptr;
      if (port == 0) {
         pOutPin = getPin("Out");
         if (pOutPin == nullptr) {
            pOutPin = getPin("Out1");
         }
      }
      else if (port == 1) {
         pOutPin = getPin("Out2");
      }
      if (pOutPin == nullptr) {
         return -1;
      }


      // 模拟取出第一张Panel,传送到下一环节
      ULONGLONG time = CToolUnits::getTimestamp();
      Lock();
      if (m_glassList.empty()) {
         Unlock();
         return -2;
      }
      CGlass* pContext = m_glassList.front();
      pContext->addRef();

      CIntent intent(FLOW_MOVE_MATERIAL, "", pContext);
      int nRet = pOutPin->sendIntent(&intent);
      if (nRet == FLOW_REJECT) {
         LOGE("<CEquipment>对方拒绝接收Intent.");
      }
      else if (nRet == FLOW_ACCEPT) {
         CPath* pPath = pContext->getPathWithSiteID(m_nID);
         if (pPath != nullptr) {
            pPath->setOutTime(time);
         }
         m_glassList.pop_front();
         pContext->release();      // 添加到列队时addRef, 取出时release
         if (m_listener.onDataChanged != nullptr) {
            m_listener.onDataChanged(this, 0);
         }
      }

      pContext->release();
      Unlock();

      return 0;
   }
}

   BOOL CEquipment::glassWillArrive(CGlass* pGlass)
   {
      return TRUE;
   }

   int CEquipment::glassArrived(CGlass* pGlass)
   {
      Lock();
      pGlass->addPath(m_nID);
      pGlass->addRef();
      m_glassList.push_back(pGlass);
      Unlock();

      if (m_listener.onDataChanged != nullptr) {
         m_listener.onDataChanged(this, 0);
      }

      return FLOW_ACCEPT;
   }

   void CEquipment::addGlassToList(CGlass* pGlass)
   {
      ASSERT(pGlass);

      Lock();
      pGlass->addRef();
      m_glassList.push_back(pGlass);
      Unlock();

      if (m_listener.onDataChanged != nullptr) {
         m_listener.onDataChanged(this, 0);
      }
   }

   BOOL CEquipment::removeClass(CGlass* pGlass)
   {
      Lock();
      bool bExist = std::find(m_glassList.begin(), m_glassList.end(), pGlass) != m_glassList.end();
      if (bExist) {
         pGlass->addPath(EQ_ID_OPERATOR_REMOVE);
         pGlass->release();
         m_glassList.remove(pGlass);
      }
      Unlock();

      if (bExist && m_listener.onDataChanged != nullptr) {
         m_listener.onDataChanged(this, 0);
      }

      return bExist;
   }

   void CEquipment::getGlassList(std::list<CGlass*>& list)
   {
      Lock();
      for (auto item : m_glassList) {
         item->addRef();
         list.push_back(item);
      }
      Unlock();
   }

   CGlass* CEquipment::getFrontGlass()
   {
      CGlass* pGlass = nullptr;

      Lock();
      if (!m_glassList.empty()) {
         pGlass = m_glassList.front();
      }
      Unlock();

      return pGlass;
   }

   bool CEquipment::isAlarmStep(SERVO::CStep* pStep)
   {
      return CToolUnits::startsWith(pStep->getName(), STEP_ALARM_START);
   }

   bool CEquipment::isPortTypeStep(SERVO::CStep* pStep)
   {
      std::regex pattern("^EQPort\\d+Type$");
      return std::regex_match(pStep->getName(), pattern);
   }

   bool CEquipment::isPortModeStep(SERVO::CStep* pStep)
   {
      std::regex pattern("^EQPort\\d+Mode$");
      return std::regex_match(pStep->getName(), pattern);
   }

   bool CEquipment::isPortCassetteTypeStep(SERVO::CStep* pStep)
   {
      std::regex pattern("^EQPort\\d+CassetteType$");
      return std::regex_match(pStep->getName(), pattern);
   }

   bool CEquipment::isPortTransferModeStep(SERVO::CStep* pStep)
   {
      std::regex pattern("^EQPort\\d+TransferMode$");
      return std::regex_match(pStep->getName(), pattern);
   }

   bool CEquipment::isPortEnableStep(SERVO::CStep* pStep)
   {
      std::regex pattern("^EQPort\\d+Enable$");
      return std::regex_match(pStep->getName(), pattern);
   }

   bool CEquipment::isPortTypeAutoChangeEnableStep(SERVO::CStep* pStep)
   {
      std::regex pattern("^EQPort\\d+CassetteType$");
      return std::regex_match(pStep->getName(), pattern);
   }

   bool CEquipment::isCassetteTransferStateStep(SERVO::CStep* pStep)
   {
      std::regex pattern("^EQPort\\d+Cassette.*");
      return std::regex_match(pStep->getName(), pattern);
   }

   bool CEquipment::isCimMessageConfirmStep(SERVO::CStep* pStep)
   {
      return pStep->getName().compare(STEP_EQ_CIM_MESSAGE_CONFIRM) == 0;
   }

   bool CEquipment::isVcrEventStep(SERVO::CStep* pStep)
   {
      return pStep->getName().compare(STEP_EQ_VCR1_EVENT_REPORT) == 0;
   }

   int CEquipment::setEqMode(short mode)
   {
      SERVO::CEqModeChangeStep* pStep = (SERVO::CEqModeChangeStep*)getStepWithName(STEP_EQ_MODE_CHANGE);
      if (pStep == nullptr) {
         return -1;
      }

      return pStep->setEqMode(mode);
   }

   int CEquipment::setCimMode(BOOL bOn)
   {
      SERVO::CEqCimModeChangeStep* pStep = (SERVO::CEqCimModeChangeStep*)getStepWithName(STEP_CIM_MODE_CHANGE);
      if (pStep == nullptr) {
         return -1;
      }

      if (bOn)
         return pStep->cimOn();
      else 
         return pStep->cimOff();
   }

   int CEquipment::setCimMessage(const char* pszMessage, short id, short nTouchPanelNo)
   {
      SERVO::CEqCimMessageCmdStep* pStep = (SERVO::CEqCimMessageCmdStep*)getStepWithName(STEP_CIM_MESSAGE_CMD);
      if (pStep == nullptr) {
         return -1;
      }

      return pStep->setCimMessage(pszMessage, id, nTouchPanelNo);
   }

   int CEquipment::clearCimMessage(short id, short nTouchPanelNo)
   {
      SERVO::CEqCimMessageClearStep* pStep = (SERVO::CEqCimMessageClearStep*)getStepWithName(STEP_CIM_MESSAGE_CLEAR);
      if (pStep == nullptr) {
         return -1;
      }

      return pStep->clearCimMessage(id, nTouchPanelNo);
   }

   int CEquipment::setDateTime(short year, short month, short day, short hour, short minute, short second)
   {
      SERVO::CEqDateTimeSetCmdStep* pStep = (SERVO::CEqDateTimeSetCmdStep*)getStepWithName(STEP_DATETIME_SET_CMD);
      if (pStep == nullptr) {
         return -1;
      }

      return pStep->setDateTime(year, month, day, hour, minute, second);
   }

   int CEquipment::masterRecipeListRequest(short unitNo)
   {
      SERVO::CEqWriteStep* pStep = (SERVO::CEqWriteStep*)getStepWithName(STEP_EQ_MASTER_RECIPE_LIST_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 {
         if (code == WOK) {
            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);
         }

         return 0;
      });
      return 0;
   }

   int CEquipment::recipeParameterRequest(short masterRecipeId, short localRecipeId, short unitNo)
   {
      SERVO::CEqWriteStep* pStep = (SERVO::CEqWriteStep*)getStepWithName(STEP_EQ_MASTER_RECIPE_LIST_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 {
         if (code == WOK) {
            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);
         }

         return 0;
         });
      return 0;
   }

   short CEquipment::decodeRecipeListReport(const char* pszData, size_t size)
   {
      return m_recipesManager.decodeRecipeListReport(pszData, size);
   }

   short CEquipment::decodeRecipeParameterReport(const char* pszData, size_t size)
   {
      return m_recipesManager.decodeRecipeParameterReport(pszData, size);
   }
}