Merge branch 'master' into liuyang

mrDarker

2025-06-03 0393d1ff2ebc378b3c4cff9b45f72ebc8a4ea516

 SourceCode/Bond/Servo/CMaster.cpp

@@ -3,18 +3,17 @@
#include "CMaster.h"


#define ADD_EQ_CASSETTE_TRANSFER_STATE_STEP(name,ws,index,psd) {            \
   CEqCassetteTransferStateStep* pStep = new CEqCassetteTransferStateStep();   \
   pStep->setName(name);                                          \
   pStep->setWriteSignalDev(ws);                                    \
   pStep->setPortStatusDev(psd);                                    \
   if (pEquipment->addStep(index, pStep) != 0) {                        \
      delete pStep;                                             \
   }                                                         \
}

namespace SERVO {
   CMaster* g_pMaster = NULL;

   unsigned __stdcall DispatchThreadFunction(LPVOID lpParam)
   {
      if (g_pMaster != NULL) {
         return g_pMaster->DispatchProc();
      }

      return 0;
   }

   unsigned __stdcall ReadBitsThreadFunction(LPVOID lpParam)
   {
@@ -34,21 +33,26 @@

   CMaster::CMaster()
   {
      m_listener = {nullptr, nullptr, nullptr};
      m_listener = {};
      m_bDataModify = FALSE;
      m_hEventReadBitsThreadExit[0] = ::CreateEvent(NULL, TRUE, FALSE, NULL);
      m_hEventReadBitsThreadExit[1] = ::CreateEvent(NULL, TRUE, FALSE, NULL);
      m_hReadBitsThreadHandle = nullptr;
      m_nReadBitsThreadAddr = 0;
      m_hDispatchEvent = ::CreateEvent(NULL, TRUE, FALSE, NULL);
      m_hEventDispatchThreadExit[0] = ::CreateEvent(NULL, TRUE, FALSE, NULL);
      m_hEventDispatchThreadExit[1] = ::CreateEvent(NULL, TRUE, FALSE, NULL);
      m_hDispatchThreadHandle = nullptr;
      m_nDispatchThreadAddr = 0;
      m_ullStartTime = 0;
      m_ullRunTime = 0;
      m_state = MASTERSTATE::READY;
      m_pActiveRobotTask = nullptr;
      InitializeCriticalSection(&m_criticalSection);
   }

   CMaster::~CMaster()
   {
      for (auto item : m_listEquipment) {
         delete item;
      }
      m_listEquipment.clear();

      if (m_hEventReadBitsThreadExit[0] != nullptr) {
         ::CloseHandle(m_hEventReadBitsThreadExit[0]);
         m_hEventReadBitsThreadExit[0] = nullptr;
@@ -58,13 +62,33 @@
         ::CloseHandle(m_hEventReadBitsThreadExit[1]);
         m_hEventReadBitsThreadExit[1] = nullptr;
      }

      if (m_hDispatchEvent != nullptr) {
         ::CloseHandle(m_hDispatchEvent);
         m_hDispatchEvent = nullptr;
      }

      if (m_hEventDispatchThreadExit[0] != nullptr) {
         ::CloseHandle(m_hEventDispatchThreadExit[0]);
         m_hEventDispatchThreadExit[0] = nullptr;
      }

      if (m_hEventDispatchThreadExit[1] != nullptr) {
         ::CloseHandle(m_hEventDispatchThreadExit[1]);
         m_hEventDispatchThreadExit[1] = nullptr;
      }

      DeleteCriticalSection(&m_criticalSection);
   }

   void CMaster::setListener(MasterListener listener)
   {
      m_listener.onEqAlive = listener.onEqAlive;
      m_listener.onEqCimStateChanged = listener.onEqCimStateChanged;
      m_listener.onEqAlarm = listener.onEqAlarm;
      m_listener = listener;
   }

   CRobotTask* CMaster::getActiveRobotTask()
   {
      return m_pActiveRobotTask;
   }

   int CMaster::init()
@@ -99,18 +123,68 @@


      // 初始化添加各子设备
      addLoadPort(0);
      addLoadPort(1);
      addLoadPort(2);
      addLoadPort(3);
      addFliper();
      addVacuumBake();
      addAligner();
      addEFEM();
      addBonder(0);
      addBonder(1);
      addBakeCooling();
      CLoadPort* pPort1, * pPort2, * pPort3, * pPort4;
      CBonder* pBonder1, * pBonder2;
      CEFEM* pEfem;
      CArm* pArm;
      CArmTray* pArmTray1, * pArmTray2;
      CFliper* pFliper;
      CVacuumBake* pVacuumBake;
      CAligner* pAligner;
      CBakeCooling* pBakeCooling;
      CMeasurement* pMeasurement;

      pPort1 = addLoadPort(0);
      pPort2 = addLoadPort(1);
      pPort3 = addLoadPort(2);
      pPort4 = addLoadPort(3);
      pEfem = addEFEM();
      pArm = addArm();
      pArmTray1 = addArmTray(0);
      pArmTray2 = addArmTray(1);
      pFliper = addFliper();
      pVacuumBake = addVacuumBake();
      pAligner = addAligner();
      pBonder1 = addBonder(0);
      pBonder2 = addBonder(1);
      pBakeCooling = addBakeCooling();
      pMeasurement = addMeasurement();

      ASSERT(pEfem);
      ASSERT(pFliper);
      ASSERT(pVacuumBake);
      ASSERT(pAligner);
      ASSERT(pBonder1);
      ASSERT(pBonder2);
      ASSERT(pBakeCooling);
      ASSERT(pMeasurement);

      pEfem->setPort(0, pPort1);
      pEfem->setPort(1, pPort1);
      pEfem->setPort(2, pPort1);
      pEfem->setPort(3, pPort1);
      pEfem->setFliper(pFliper);
      pEfem->setAligner(pAligner);
      pEfem->setArmTray(0, pArmTray1);
      pEfem->setArmTray(1, pArmTray2);
      pPort1->setArm(pArm);
      pPort2->setArm(pArm);
      pPort3->setArm(pArm);
      pPort4->setArm(pArm);
      pArmTray1->setArm(pArm);
      pArmTray2->setArm(pArm);
      pFliper->setArm(pArm);
      pVacuumBake->setArm(pArm);
      pAligner->setArm(pArm);
      pBonder1->setArm(pArm);
      pBonder2->setArm(pArm);
      pBakeCooling->setArm(pArm);
      pMeasurement->setArm(pArm);

      connectEquipments();




      
      // 读缓存数据
@@ -122,6 +196,12 @@
      SetTimer(NULL, 1, 250, (TIMERPROC)MasterTimerProc);


      // 调度线程
      m_hDispatchThreadHandle = (HANDLE)_beginthreadex(NULL, 0, SERVO::DispatchThreadFunction, this,
         0, &m_nDispatchThreadAddr);


      // 监控bit线程
      m_hReadBitsThreadHandle = (HANDLE)_beginthreadex(NULL, 0, SERVO::ReadBitsThreadFunction, this,
         0, &m_nReadBitsThreadAddr);

@@ -133,7 +213,9 @@
   int CMaster::term()
   {
      SetEvent(m_hEventReadBitsThreadExit[0]);
      SetEvent(m_hEventDispatchThreadExit[0]);
      ::WaitForSingleObject(m_hEventReadBitsThreadExit[1], INFINITE);
      ::WaitForSingleObject(m_hEventDispatchThreadExit[1], INFINITE);

      LOGI("<Master>正在结束程序.");
      for (auto item : m_listEquipment) {
@@ -141,8 +223,217 @@
      }
      saveCache();

      lock();
      if (m_pActiveRobotTask != nullptr) {
         delete m_pActiveRobotTask;
         m_pActiveRobotTask = nullptr;
      }
      unlock();

      for (auto item : m_listEquipment) {
         delete item;
      }
      m_listEquipment.clear();


      return 0;
   }

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

      setState(MASTERSTATE::STARTING);
      m_ullStartTime = GetTickCount64();

      return 0;
   }

   int CMaster::stop()
   {
      // 运行时间为累加结果，本次停止时刷新；
      if (m_state != MASTERSTATE::RUNNING) {
         return -1;
      }

      m_ullRunTime += (GetTickCount64() - m_ullStartTime);
      setState(MASTERSTATE::STOPPING);

      return 0;
   }

   ULONGLONG CMaster::getRunTime()
   {
      if (m_state == MASTERSTATE::RUNNING)
         return m_ullRunTime + (GetTickCount64() - m_ullStartTime);
      else
         return m_ullRunTime;
   }

   MASTERSTATE CMaster::getState()
   {
      return m_state;
   }

   unsigned CMaster::DispatchProc()
   {
      // 各种机器
      CLoadPort* pLoadPort1 = (CLoadPort*)getEquipment(EQ_ID_LOADPORT1);
      CLoadPort* pLoadPort2 = (CLoadPort*)getEquipment(EQ_ID_LOADPORT2);
      CFliper* pFliper = (CFliper*)getEquipment(EQ_ID_FLIPER);
      CVacuumBake* pVacuumBack = (CVacuumBake*)getEquipment(EQ_ID_VACUUMBAKE);
      CAligner* pAligner = (CAligner*)getEquipment(EQ_ID_ALIGNER);

      ASSERT(pLoadPort1);
      ASSERT(pLoadPort2);
      ASSERT(pFliper);
      ASSERT(pVacuumBack);
      ASSERT(pAligner);

      while (1) {
         // 待退出信号或时间到
         HANDLE hEvents[] = { m_hEventDispatchThreadExit[0], m_hDispatchEvent };
         int nRet = WaitForMultipleObjects(2, hEvents, FALSE, 1000);
         if (nRet == WAIT_OBJECT_0) {
            break;
         }
			

         // 如果状态为STARTING，开始工作并切换到RUNNING状态
         lock();
         if (m_state == MASTERSTATE::STARTING) {
            unlock();
            Sleep(1000);
            setState(MASTERSTATE::RUNNING);
            continue;
         }


         // 处理完成当前事务后，切换到停止或就绪状态
         else if (m_state == MASTERSTATE::STOPPING) {
            unlock();
            Sleep(1000);
            setState(MASTERSTATE::READY);
            continue;
         }


         // 调度逻辑处理
         else if (m_state == MASTERSTATE::RUNNING) {
            unlock();
            // LOGI("调度处理中...");

            lock();
            if (m_pActiveRobotTask != nullptr) {
               unlock();
               // 检测到当前有正在下午的任务，确保当前任务完成或中止后继续
               // LOGI("检测到当前有正在下午的任务，确保当前任务完成或中止后继续...");
               continue;
            }

            // LoadPort -> Fliper(G2)
            m_pActiveRobotTask = createTransferTask(pLoadPort1, pFliper);
            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, pFliper);
            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, pVacuumBack);
            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, pVacuumBack);
            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;
            }


            // Fliper(G2) -> Aligner
            // VacuumBake(G1) -> Aligner
            m_pActiveRobotTask = createTransferTask(pFliper, pAligner);
            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(pVacuumBack, pAligner);
            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;
            }





            // Aligner -> Bonder


            // Bonder -> BakeCooling


            // BakeCooling ->Measurement


            // Measurement -> LoadPort



            unlock();

         }
         unlock();
      }

      SetEvent(m_hEventDispatchThreadExit[1]);


      // _endthreadex(0);
      TRACE("CMaster::DispatchProc 线程退出\n");
      return 0;
   }

@@ -199,8 +490,114 @@
            m_listener.onEqAlarm(this, p, state, alarmId, unitId, level);
         }
      };
      listener.onVcrEventReport = [&](void* pEquipment, void* pReport) -> void {
         CEquipment* p = (CEquipment*)pEquipment;
         CVcrEventReport* p2 = (CVcrEventReport*)pReport;
         if (m_listener.onEqVcrEventReport != nullptr) {
            m_listener.onEqVcrEventReport(this, p, p2);
         }
      };
      listener.onPreFethedOutJob = [&](void* pEquipment, CJobDataB* pJobDataB) -> BOOL {
         CEquipment* p = (CEquipment*)pEquipment;


         // 取片，更新当前搬送任务
         BOOL bOk = FALSE;
         lock();
         if (m_pActiveRobotTask != nullptr) {
            if (m_pActiveRobotTask->getSrcPosition() == p->getID()) {
               CGlass* pGlass = p->getGlassFromSlot(m_pActiveRobotTask->getSrcSlot());
               if (pGlass != nullptr) {
                  CJobDataB* pJobDataBSrc = pGlass->getJobDataB();
                  if (pJobDataBSrc != nullptr
                     && pJobDataBSrc->getCassetteSequenceNo() == pJobDataB->getCassetteSequenceNo()
                     && pJobDataBSrc->getJobSequenceNo() == pJobDataB->getJobSequenceNo()) {
                     bOk = TRUE;
                     LOGI("<CMaster>onPreFethedOutJob, 已校验数据一致性.");
                  }
               }
            }
            else if (p->getID() == EQ_ID_ARM_TRAY1 || p->getID() == EQ_ID_ARM_TRAY2) {
               bOk = TRUE;
            }
         }
         unlock();

         if (!bOk) {
            LOGE("<CMaster>onPreFethedOutJob, 数据校验失败.");
         }

         return bOk;

      };
      listener.onPreStoredJob = [&](void* pEquipment, CJobDataB* pJobDataB, short& slot) -> BOOL {
         CEquipment* p = (CEquipment*)pEquipment;


         // 放片，更新当前搬送任务
         BOOL bOk = FALSE;
         lock();
         if (m_pActiveRobotTask != nullptr) {
            if (m_pActiveRobotTask->getTarPosition() == p->getID()) {
               CGlass* pGlass = p->getGlassFromSlot(m_pActiveRobotTask->getTarSlot());
               if (pGlass == nullptr) {
                  bOk = TRUE;
                  slot = m_pActiveRobotTask->getTarSlot();
                  LOGI("<CMaster>onPreFethedOutJob, 已校验数据一致性.");
               }
            }
            else if (p->getID() == EQ_ID_ARM_TRAY1 || p->getID() == EQ_ID_ARM_TRAY2) {
               slot = 1;
               bOk = TRUE;
            }
         }
         unlock();

         if (!bOk) {
            LOGE("<CMaster>onPreFethedOutJob, 数据校验失败.");
         }

         return bOk;

      };
      listener.onDataChanged = [&](void* pEquipment, int code) -> void {
         m_bDataModify = TRUE;
         CEquipment* p = (CEquipment*)pEquipment;
         if (m_listener.onEqDataChanged != nullptr) {
            m_listener.onEqDataChanged(this, p, 0);
         }

         // 取放片，更新当前搬送任务
         if (code == EDCC_FETCHOUT_JOB) {
            lock();
            if (m_pActiveRobotTask != nullptr && m_pActiveRobotTask->getSrcPosition() == p->getID()) {
               m_pActiveRobotTask->fetchOut();
               LOGI("开始取片...");
            }
            unlock();
         }
         else if (code == EDCC_STORED_JOB) {
            lock();
            if (m_pActiveRobotTask != nullptr && m_pActiveRobotTask->getTarPosition() == p->getID()) {
               m_pActiveRobotTask->stored();
               m_pActiveRobotTask->completed();
               LOGI("放片完成...");

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



               lock();
               delete m_pActiveRobotTask;
               m_pActiveRobotTask = nullptr;

               if (m_listener.onRobotTaskEvent != nullptr) {
                  m_listener.onRobotTaskEvent(this, m_pActiveRobotTask, 0);
               }
            }
            unlock();
         }
      };

      pEquipment->setListener(listener);
@@ -224,58 +621,39 @@
      return nullptr;
   }

   /* 添加LoadPort1
   /*
    * 添加LoadPort1
    * index -- 0~3
    */
   int CMaster::addLoadPort(int index)
   CLoadPort* CMaster::addLoadPort(int index)
   {
      ASSERT(index == 0 || index == 1 || index == 2 || index == 3);
      static char* pszCassetteCtrlCmd[] = { 
         STEP_EQ_P1_CASSETTE_CTRL_CMD,
         STEP_EQ_P2_CASSETTE_CTRL_CMD,
         STEP_EQ_P3_CASSETTE_CTRL_CMD,
         STEP_EQ_P4_CASSETTE_CTRL_CMD
      };
      int nWriteSignalDev[] = {0x120, 0x121, 0x122, 0x123};
      int nCtrlCmdDev[] = {0x45, 0x1a5, 0x305, 0x465};
      int nStepDev[] = { 0x480, 0x481, 0x482, 0x483 };


      char szName[64];
      sprintf_s(szName, 64, "LoadPort %d", index + 1);
      CLoadPort* pEquipment = new CLoadPort();
      pEquipment->setIndex(index);
      pEquipment->setID(EQ_ID_LOADPORT1 + index);
      pEquipment->setName(szName);
      pEquipment->setDescription(szName);
      addToEquipmentList(pEquipment);


      // step
      {
         CEqCassetteCtrlCmdStep* pStep = new CEqCassetteCtrlCmdStep();
         pStep->setName(pszCassetteCtrlCmd[index]);
         pStep->setWriteSignalDev(nWriteSignalDev[index]);
         pStep->setCtrlCmdDev(nCtrlCmdDev[index]);
         if (pEquipment->addStep(nStepDev[index], pStep) != 0) {
            delete pStep;
         }
      }


      pEquipment->init();
      LOGE("已添加“%s”.", pEquipment->getName().c_str());


      return 0;
      return pEquipment;
   }

   int CMaster::addFliper()
   CFliper* CMaster::addFliper()
   {
      CFliper* pEquipment = new CFliper();
      pEquipment->setID(EQ_ID_FLIPER);
      pEquipment->setBaseAlarmId(BASE_ALARM_EFEM);
      pEquipment->setName("Fliper");
      pEquipment->setDescription("Fliper.");
      pEquipment->setName("Fliper(G2)");
      pEquipment->setDescription("Fliper(G2).");
      pEquipment->setReadBitBlock(0x4000, 0x45ff);
      pEquipment->setStation(0, 255);
      addToEquipmentList(pEquipment);
@@ -283,16 +661,16 @@

      pEquipment->init();
      LOGE("已添加“Fliper”.");
      return 0;
      return pEquipment;
   }

   int CMaster::addVacuumBake()
   CVacuumBake* CMaster::addVacuumBake()
   {
      CVacuumBake* pEquipment = new CVacuumBake();
      pEquipment->setID(EQ_ID_VACUUMBAKE);
      pEquipment->setBaseAlarmId(BASE_ALARM_EFEM);
      pEquipment->setName("VacuumBake");
      pEquipment->setDescription("VacuumBake.");
      pEquipment->setName("VacuumBake(G1)");
      pEquipment->setDescription("VacuumBake(G1).");
      pEquipment->setReadBitBlock(0x4000, 0x45ff);
      pEquipment->setStation(0, 255);
      addToEquipmentList(pEquipment);
@@ -300,10 +678,11 @@

      pEquipment->init();
      LOGE("已添加“VacuumBake”.");
      return 0;

      return pEquipment;
   }

   int CMaster::addAligner()
   CAligner* CMaster::addAligner()
   {
      CAligner* pEquipment = new CAligner();
      pEquipment->setID(EQ_ID_ALIGNER);
@@ -317,410 +696,65 @@

      pEquipment->init();
      LOGE("已添加“Aligner”.");
      return 0;

      return pEquipment;
   }

   int CMaster::addEFEM()
   CEFEM* CMaster::addEFEM()
   {
      CEFEM* pEquipment = new CEFEM();
      pEquipment->setID(EQ_ID_EFEM);
      pEquipment->setBaseAlarmId(BASE_ALARM_EFEM);
      pEquipment->setName("EFEM(ROBOT)");
      pEquipment->setDescription("EFEM(ROBOT).");
      pEquipment->setReadBitBlock(0x4000, 0x45ff);
      pEquipment->setReadBitBlock(0x3000, 0x3aff);
      pEquipment->setStation(0, 255);
      addToEquipmentList(pEquipment);


      // 添加 step
      {
         CEqModeStep* pStep = new CEqModeStep();
         pStep->setName(STEP_MODE);
         pStep->setWriteSignalDev(0x30);
         pStep->setModeDev(0x4a8c);
         if (pEquipment->addStep(0x360, pStep) != 0) {
            delete pStep;
         }
      }
      {
         CEqStatusStep* pStep = new CEqStatusStep();
         pStep->setName(STEP_STATUS);
         pStep->setWriteSignalDev(0x31);
         pStep->setStatusDev(0x4a68);
         if (pEquipment->addStep(0x361, pStep) != 0) {
            delete pStep;
         }
      }
      {
         CEqAlarmStep* pStep = new CEqAlarmStep();
         pStep->setName(STEP_ALARM_BLOCK1);
         pStep->setWriteSignalDev(0x32);
         pStep->setAlarmDev(0x4c1d);
         if (pEquipment->addStep(0x362, pStep) != 0) {
            delete pStep;
         }
      }
      {
         CEqAlarmStep* pStep = new CEqAlarmStep();
         pStep->setName(STEP_ALARM_BLOCK2);
         pStep->setWriteSignalDev(0x33);
         pStep->setAlarmDev(0x4c4a);
         if (pEquipment->addStep(0x363, pStep) != 0) {
            delete pStep;
         }
      }
      {
         CEqAlarmStep* pStep = new CEqAlarmStep();
         pStep->setName(STEP_ALARM_BLOCK3);
         pStep->setWriteSignalDev(0x34);
         pStep->setAlarmDev(0x4c77);
         if (pEquipment->addStep(0x364, pStep) != 0) {
            delete pStep;
         }
      }
      {
         CEqAlarmStep* pStep = new CEqAlarmStep();
         pStep->setName(STEP_ALARM_BLOCK4);
         pStep->setWriteSignalDev(0x35);
         pStep->setAlarmDev(0x4ca4);
         if (pEquipment->addStep(0x365, pStep) != 0) {
            delete pStep;
         }
      }
      {
         CEqAlarmStep* pStep = new CEqAlarmStep();
         pStep->setName(STEP_ALARM_BLOCK5);
         pStep->setWriteSignalDev(0x36);
         pStep->setAlarmDev(0x4cd1);
         if (pEquipment->addStep(0x366, pStep) != 0) {
            delete pStep;
         }
      }
      {
         CEqProcessStep* pStep = new CEqProcessStep();
         pStep->setName(STEP_PROCESS);
         pStep->setWriteSignalDev(0x37);
         pStep->setProcessDev(0x5864);
         if (pEquipment->addStep(0x367, pStep) != 0) {
            delete pStep;
         }
      }
      {
         CEqCimModeChangeStep* pStep = new CEqCimModeChangeStep();
         pStep->setName(STEP_CIM_MODE_CHANGE);
         pStep->setWriteSignalDev(0x50);
         pStep->setCimModeDev(0x15);
         if (pEquipment->addStep(0x350, pStep) != 0) {
            delete pStep;
         }
      }
      {
         CEqCimMessageCmdStep* pStep = new CEqCimMessageCmdStep();
         pStep->setName(STEP_CIM_MESSAGE_CMD);
         pStep->setWriteSignalDev(0x51);
         pStep->setCimMessageDev(0x0);
         if (pEquipment->addStep(0x351, pStep) != 0) {
            delete pStep;
         }
      }
      {
         CEqCimMessageClearStep* pStep = new CEqCimMessageClearStep();
         pStep->setName(STEP_CIM_MESSAGE_CLEAR);
         pStep->setWriteSignalDev(0x52);
         pStep->setClearCimMessageDev(0x13);
         if (pEquipment->addStep(0x352, pStep) != 0) {
            delete pStep;
         }
      }
      {
         CEqDateTimeSetCmdStep* pStep = new CEqDateTimeSetCmdStep();
         pStep->setName(STEP_DATETIME_SET_CMD);
         pStep->setWriteSignalDev(0x53);
         pStep->setDateTimeDev(0x16);
         if (pEquipment->addStep(0x353, pStep) != 0) {
            delete pStep;
         }
      }
      {
         CEqVCREnableStep* pStep = new CEqVCREnableStep();
         pStep->setName(STEP_EQ_VCR_ENABLE);
         pStep->setWriteSignalDev(0x54);
         pStep->setEqVCRModeDev(0x1F);
         if (pEquipment->addStep(0x354, pStep) != 0) {
            delete pStep;
         }
      }
      {
         CEqModeChangeStep* pStep = new CEqModeChangeStep();
         pStep->setName(STEP_EQ_MODE_CHANGE);
         pStep->setWriteSignalDev(0x55);
         pStep->setEqModeDev(0x1E);
         if (pEquipment->addStep(0x355, pStep) != 0) {
            delete pStep;
         }
      }

      // Port1
      {
         CEqReadIntStep* pStep = new CEqReadIntStep(__INT16, 0x4d1f);
         pStep->setName(STEP_EQ_PORT1_TYPE);
         pStep->setWriteSignalDev(0x80);
         if (pEquipment->addStep(0x3e0, pStep) != 0) {
            delete pStep;
         }
      }
      {
         CEqReadIntStep* pStep = new CEqReadIntStep(__INT16, 0x4d20);
         pStep->setName(STEP_EQ_PORT1_MODE);
         pStep->setWriteSignalDev(0x88);
         if (pEquipment->addStep(0x3e8, pStep) != 0) {
            delete pStep;
         }
      }
      {
         CEqReadIntStep* pStep = new CEqReadIntStep(__INT32, 0x4d21);
         pStep->setName(STEP_EQ_PORT1_CASSETTE_TYPE);
         pStep->setWriteSignalDev(0x90);
         if (pEquipment->addStep(0x3f0, pStep) != 0) {
            delete pStep;
         }
      }
      {
         CEqReadIntStep* pStep = new CEqReadIntStep(__INT16, 0x4d23);
         pStep->setName(STEP_EQ_PORT1_TRANSFER_MODE);
         pStep->setWriteSignalDev(0x98);
         if (pEquipment->addStep(0x3f8, pStep) != 0) {
            delete pStep;
         }
      }
      {
         CEqReadIntStep* pStep = new CEqReadIntStep(__INT16, 0x4d24);
         pStep->setName(STEP_EQ_PORT1_ENABLE);
         pStep->setWriteSignalDev(0xa0);
         if (pEquipment->addStep(0x400, pStep) != 0) {
            delete pStep;
         }
      }
      {
         CEqReadIntStep* pStep = new CEqReadIntStep(__INT16, 0x4d25);
         pStep->setName(STEP_EQ_PORT1_TYPE_ATUO);
         pStep->setWriteSignalDev(0xa8);
         if (pEquipment->addStep(0x408, pStep) != 0) {
            delete pStep;
         }
      }

      // Port2
      {
         CEqReadIntStep* pStep = new CEqReadIntStep(__INT16, 0x4d2f);
         pStep->setName(STEP_EQ_PORT2_TYPE);
         pStep->setWriteSignalDev(0x81);
         if (pEquipment->addStep(0x3e1, pStep) != 0) {
            delete pStep;
         }
      }
      {
         CEqReadIntStep* pStep = new CEqReadIntStep(__INT16, 0x4d30);
         pStep->setName(STEP_EQ_PORT2_MODE);
         pStep->setWriteSignalDev(0x89);
         if (pEquipment->addStep(0x3e9, pStep) != 0) {
            delete pStep;
         }
      }
      {
         CEqReadIntStep* pStep = new CEqReadIntStep(__INT32, 0x4d31);
         pStep->setName(STEP_EQ_PORT2_CASSETTE_TYPE);
         pStep->setWriteSignalDev(0x91);
         if (pEquipment->addStep(0x3f1, pStep) != 0) {
            delete pStep;
         }
      }
      {
         CEqReadIntStep* pStep = new CEqReadIntStep(__INT16, 0x4d33);
         pStep->setName(STEP_EQ_PORT2_TRANSFER_MODE);
         pStep->setWriteSignalDev(0x99);
         if (pEquipment->addStep(0x3f9, pStep) != 0) {
            delete pStep;
         }
      }
      {
         CEqReadIntStep* pStep = new CEqReadIntStep(__INT16, 0x4d34);
         pStep->setName(STEP_EQ_PORT2_ENABLE);
         pStep->setWriteSignalDev(0xa1);
         if (pEquipment->addStep(0x401, pStep) != 0) {
            delete pStep;
         }
      }
      {
         CEqReadIntStep* pStep = new CEqReadIntStep(__INT16, 0x4d35);
         pStep->setName(STEP_EQ_PORT2_TYPE_ATUO);
         pStep->setWriteSignalDev(0xa9);
         if (pEquipment->addStep(0x409, pStep) != 0) {
            delete pStep;
         }
      }

      // Port3
      {
         CEqReadIntStep* pStep = new CEqReadIntStep(__INT16, 0x4d3f);
         pStep->setName(STEP_EQ_PORT3_TYPE);
         pStep->setWriteSignalDev(0x82);
         if (pEquipment->addStep(0x3e2, pStep) != 0) {
            delete pStep;
         }
      }
      {
         CEqReadIntStep* pStep = new CEqReadIntStep(__INT16, 0x4d40);
         pStep->setName(STEP_EQ_PORT3_MODE);
         pStep->setWriteSignalDev(0x8a);
         if (pEquipment->addStep(0x3ea, pStep) != 0) {
            delete pStep;
         }
      }
      {
         CEqReadIntStep* pStep = new CEqReadIntStep(__INT32, 0x4d41);
         pStep->setName(STEP_EQ_PORT3_CASSETTE_TYPE);
         pStep->setWriteSignalDev(0x92);
         if (pEquipment->addStep(0x3f2, pStep) != 0) {
            delete pStep;
         }
      }
      {
         CEqReadIntStep* pStep = new CEqReadIntStep(__INT16, 0x4d43);
         pStep->setName(STEP_EQ_PORT3_TRANSFER_MODE);
         pStep->setWriteSignalDev(0x9a);
         if (pEquipment->addStep(0x3fa, pStep) != 0) {
            delete pStep;
         }
      }
      {
         CEqReadIntStep* pStep = new CEqReadIntStep(__INT16, 0x4d44);
         pStep->setName(STEP_EQ_PORT3_ENABLE);
         pStep->setWriteSignalDev(0xa2);
         if (pEquipment->addStep(0x402, pStep) != 0) {
            delete pStep;
         }
      }
      {
         CEqReadIntStep* pStep = new CEqReadIntStep(__INT16, 0x4d45);
         pStep->setName(STEP_EQ_PORT3_TYPE_ATUO);
         pStep->setWriteSignalDev(0xaa);
         if (pEquipment->addStep(0x40a, pStep) != 0) {
            delete pStep;
         }
      }

      // Port4
      {
         CEqReadIntStep* pStep = new CEqReadIntStep(__INT16, 0x4d4f);
         pStep->setName(STEP_EQ_PORT4_TYPE);
         pStep->setWriteSignalDev(0x83);
         if (pEquipment->addStep(0x3e3, pStep) != 0) {
            delete pStep;
         }
      }
      {
         CEqReadIntStep* pStep = new CEqReadIntStep(__INT16, 0x4d50);
         pStep->setName(STEP_EQ_PORT4_MODE);
         pStep->setWriteSignalDev(0x8b);
         if (pEquipment->addStep(0x3eb, pStep) != 0) {
            delete pStep;
         }
      }
      {
         CEqReadIntStep* pStep = new CEqReadIntStep(__INT32, 0x4d51);
         pStep->setName(STEP_EQ_PORT4_CASSETTE_TYPE);
         pStep->setWriteSignalDev(0x93);
         if (pEquipment->addStep(0x3f3, pStep) != 0) {
            delete pStep;
         }
      }
      {
         CEqReadIntStep* pStep = new CEqReadIntStep(__INT16, 0x4d53);
         pStep->setName(STEP_EQ_PORT4_TRANSFER_MODE);
         pStep->setWriteSignalDev(0x9b);
         if (pEquipment->addStep(0x3fb, pStep) != 0) {
            delete pStep;
         }
      }
      {
         CEqReadIntStep* pStep = new CEqReadIntStep(__INT16, 0x4d54);
         pStep->setName(STEP_EQ_PORT4_ENABLE);
         pStep->setWriteSignalDev(0xa3);
         if (pEquipment->addStep(0x403, pStep) != 0) {
            delete pStep;
         }
      }
      {
         CEqReadIntStep* pStep = new CEqReadIntStep(__INT16, 0x4d55);
         pStep->setName(STEP_EQ_PORT4_TYPE_ATUO);
         pStep->setWriteSignalDev(0xab);
         if (pEquipment->addStep(0x40b, pStep) != 0) {
            delete pStep;
         }
      }


      // CEqCassetteTranserStateStep
      ADD_EQ_CASSETTE_TRANSFER_STATE_STEP(STEP_EQ_P1_CASSETTE_EMPTY, 0xb8, 
         STEP_ID_PORT1_CASSETTIE_EMPTY, 0x4d5f);
      ADD_EQ_CASSETTE_TRANSFER_STATE_STEP(STEP_EQ_P1_CASSETTE_LOAD_EADY, 0xc0,
         STEP_ID_PORT1_CASSETTIE_LOAD_READY, 0x4d5f);
      ADD_EQ_CASSETTE_TRANSFER_STATE_STEP(STEP_EQ_P1_CASSETTE_LOADED, 0xc8, 
         STEP_ID_PORT1_CASSETTIE_LOADED, 0x4d5f);
      ADD_EQ_CASSETTE_TRANSFER_STATE_STEP(STEP_EQ_P1_CASSETTE_INUSE, 0xd0,
         STEP_ID_PORT1_CASSETTIE_INUSE, 0x4d5f);
      ADD_EQ_CASSETTE_TRANSFER_STATE_STEP(STEP_EQ_P1_CASSETTE_UNLOAD_EADY, 0xd8,
         STEP_ID_PORT1_CASSETTIE_UNLOAD_READY, 0x4d5f);
      ADD_EQ_CASSETTE_TRANSFER_STATE_STEP(STEP_EQ_P1_CASSETTE_BLOCKED, 0xe0,
         STEP_ID_PORT1_CASSETTIE_BLOCKED, 0x4d5f);
      ADD_EQ_CASSETTE_TRANSFER_STATE_STEP(STEP_EQ_P2_CASSETTE_EMPTY, 
         STEP_ID_PORT2_CASSETTIE_EMPTY, 0x418, 0x4d7f);
      ADD_EQ_CASSETTE_TRANSFER_STATE_STEP(STEP_EQ_P2_CASSETTE_LOAD_EADY,
         STEP_ID_PORT2_CASSETTIE_LOAD_READY, 0x420, 0x4d7f);
      ADD_EQ_CASSETTE_TRANSFER_STATE_STEP(STEP_EQ_P2_CASSETTE_LOADED,
         STEP_ID_PORT2_CASSETTIE_LOADED, 0x428, 0x4d7f);
      ADD_EQ_CASSETTE_TRANSFER_STATE_STEP(STEP_EQ_P2_CASSETTE_INUSE, 
         STEP_ID_PORT2_CASSETTIE_INUSE, 0x430, 0x4d7f);
      ADD_EQ_CASSETTE_TRANSFER_STATE_STEP(STEP_EQ_P2_CASSETTE_UNLOAD_EADY,
         STEP_ID_PORT2_CASSETTIE_UNLOAD_READY, 0x438, 0x4d7f);
      ADD_EQ_CASSETTE_TRANSFER_STATE_STEP(STEP_EQ_P2_CASSETTE_BLOCKED, 
         STEP_ID_PORT2_CASSETTIE_BLOCKED, 0x440, 0x4d7f);
      ADD_EQ_CASSETTE_TRANSFER_STATE_STEP(STEP_EQ_P3_CASSETTE_EMPTY,
         STEP_ID_PORT3_CASSETTIE_EMPTY, 0x418, 0x4d9f);
      ADD_EQ_CASSETTE_TRANSFER_STATE_STEP(STEP_EQ_P3_CASSETTE_LOAD_EADY,
         STEP_ID_PORT3_CASSETTIE_LOAD_READY, 0x420, 0x4d9f);
      ADD_EQ_CASSETTE_TRANSFER_STATE_STEP(STEP_EQ_P3_CASSETTE_LOADED, 
         STEP_ID_PORT3_CASSETTIE_INUSE, 0x428, 0x4d9f);
      ADD_EQ_CASSETTE_TRANSFER_STATE_STEP(STEP_EQ_P3_CASSETTE_INUSE, 
         STEP_ID_PORT3_CASSETTIE_INUSE, 0x430, 0x4d9f);
      ADD_EQ_CASSETTE_TRANSFER_STATE_STEP(STEP_EQ_P3_CASSETTE_UNLOAD_EADY, 
         STEP_ID_PORT3_CASSETTIE_UNLOAD_READY, 0x438, 0x4d9f);
      ADD_EQ_CASSETTE_TRANSFER_STATE_STEP(STEP_EQ_P3_CASSETTE_BLOCKED,
         STEP_ID_PORT3_CASSETTIE_BLOCKED, 0x440, 0x4d9f);
      ADD_EQ_CASSETTE_TRANSFER_STATE_STEP(STEP_EQ_P4_CASSETTE_EMPTY, 
         STEP_ID_PORT4_CASSETTIE_EMPTY, 0x418, 0x4dbf);
      ADD_EQ_CASSETTE_TRANSFER_STATE_STEP(STEP_EQ_P4_CASSETTE_LOAD_EADY, 
         STEP_ID_PORT4_CASSETTIE_LOAD_READY, 0x420, 0x4dbf);
      ADD_EQ_CASSETTE_TRANSFER_STATE_STEP(STEP_EQ_P4_CASSETTE_LOADED, 
         STEP_ID_PORT4_CASSETTIE_LOADED, 0x428, 0x4dbf);
      ADD_EQ_CASSETTE_TRANSFER_STATE_STEP(STEP_EQ_P4_CASSETTE_INUSE,
         STEP_ID_PORT4_CASSETTIE_INUSE, 0x430, 0x4dbf);
      ADD_EQ_CASSETTE_TRANSFER_STATE_STEP(STEP_EQ_P4_CASSETTE_UNLOAD_EADY, 
         STEP_ID_PORT4_CASSETTIE_UNLOAD_READY, 0x438, 0x4dbf);
      ADD_EQ_CASSETTE_TRANSFER_STATE_STEP(STEP_EQ_P4_CASSETTE_BLOCKED, 
         STEP_ID_PORT4_CASSETTIE_BLOCKED, 0x440, 0x4dbf);

      pEquipment->init();
      LOGE("已添加“EFEM(ROBOT)”.");
      return 0;

      return pEquipment;
   }

   CArm* CMaster::addArm()
   {
      CArm* pEquipment = new CArm();
      pEquipment->setID(EQ_ID_ARM);
      pEquipment->setBaseAlarmId(BASE_ALARM_EFEM);
      pEquipment->setName("ARM");
      pEquipment->setDescription("ARM.");
      addToEquipmentList(pEquipment);


      pEquipment->init();
      LOGE("已添加“ARM”.");

      return pEquipment;
   }

   CArmTray* CMaster::addArmTray(int index)
   {
      CArmTray* pEquipment = new CArmTray();
      pEquipment->setID(index == 0 ? EQ_ID_ARM_TRAY1 : EQ_ID_ARM_TRAY2);
      pEquipment->setBaseAlarmId(BASE_ALARM_EFEM);
      pEquipment->setName(index == 0 ? "Arm Tray1" : "Arm Tray2");
      pEquipment->setDescription(index == 0 ? "Arm Tray1." : "Arm Tray2.");
      addToEquipmentList(pEquipment);


      pEquipment->init();
      LOGE("已添加“%s”.", pEquipment->getName().c_str());

      return pEquipment;
   }

   /* 添加bonder1 或 bonder2 
    * index -- 0, bonder1
    * index -- 1, bonder2
    */
   int CMaster::addBonder(int index)
   CBonder* CMaster::addBonder(int index)
   {
      ASSERT(index == 0 || index == 1);
      CBonder* pEquipment = new CBonder();
@@ -728,184 +762,20 @@
      pEquipment->setName(index == 0 ? "Bonder 1" : "Bonder 2");
      pEquipment->setDescription(index == 0 ? "Bonder 1." : "Bonder 2.");
      pEquipment->setStation(0, 255);
      pEquipment->setReadBitBlock(index == 0 ? 0x4600 : 0x4c00,
         index == 0 ? 0x4c00 : 0x5200);
      pEquipment->setReadBitBlock(index == 0 ? 0x3b00 : 0x4600,
         index == 0 ? 0x5600 : 0x6100);
      pEquipment->setIndex(index);
      addToEquipmentList(pEquipment);


      // 添加 step
      {
         CEqModeStep* pStep = new CEqModeStep();
         pStep->setName(STEP_MODE);
         pStep->setWriteSignalDev(index == 0 ? 0x330 : 0x630);
         pStep->setModeDev(index == 0 ? 0x6a8c : 0x8a8c);
         if (pEquipment->addStep(0x360, pStep) != 0) {
            delete pStep;
         }
      }
      {
         CEqStatusStep* pStep = new CEqStatusStep();
         pStep->setName(STEP_STATUS);
         pStep->setWriteSignalDev(index == 0 ? 0x331 : 0x631);
         pStep->setStatusDev(index == 0 ? 0x6a68 : 0x8a68);
         if (pEquipment->addStep(0x361, pStep) != 0) {
            delete pStep;
         }
      }
      {
         CEqAlarmStep* pStep = new CEqAlarmStep();
         pStep->setName(STEP_ALARM_BLOCK1);
         pStep->setWriteSignalDev(index == 0 ? 0x332 : 0x632);
         pStep->setAlarmDev(index == 0 ? 0x6c1d : 0x8c1d);
         if (pEquipment->addStep(0x362, pStep) != 0) {
            delete pStep;
         }
      }
      {
         CEqAlarmStep* pStep = new CEqAlarmStep();
         pStep->setName(STEP_ALARM_BLOCK2);
         pStep->setWriteSignalDev(index == 0 ? 0x333 : 0x633);
         pStep->setAlarmDev(index == 0 ? 0x6c4a : 0x8c4a);
         if (pEquipment->addStep(0x363, pStep) != 0) {
            delete pStep;
         }
      }
      {
         CEqAlarmStep* pStep = new CEqAlarmStep();
         pStep->setName(STEP_ALARM_BLOCK3);
         pStep->setWriteSignalDev(index == 0 ? 0x334 : 0x634);
         pStep->setAlarmDev(index == 0 ? 0x6c77 : 0x8c77);
         if (pEquipment->addStep(0x364, pStep) != 0) {
            delete pStep;
         }
      }
      {
         CEqAlarmStep* pStep = new CEqAlarmStep();
         pStep->setName(STEP_ALARM_BLOCK4);
         pStep->setWriteSignalDev(index == 0 ? 0x335 : 0x635);
         pStep->setAlarmDev(index == 0 ? 0x6ca4 : 0x8ca4);
         if (pEquipment->addStep(0x365, pStep) != 0) {
            delete pStep;
         }
      }
      {
         CEqAlarmStep* pStep = new CEqAlarmStep();
         pStep->setName(STEP_ALARM_BLOCK5);
         pStep->setWriteSignalDev(index == 0 ? 0x336 : 0x636);
         pStep->setAlarmDev(index == 0 ? 0x6cd1 : 0x8cd1);
         if (pEquipment->addStep(0x366, pStep) != 0) {
            delete pStep;
         }
      }
      {
         CEqProcessStep* pStep = new CEqProcessStep();
         pStep->setName(STEP_PROCESS);
         pStep->setWriteSignalDev(index == 0 ? 0x337 : 0x637);
         pStep->setProcessDev(index == 0 ? 0x7864 : 0x9864);
         if (pEquipment->addStep(0x367, pStep) != 0) {
            delete pStep;
         }
      }
      {
         CEqCimModeChangeStep* pStep = new CEqCimModeChangeStep();
         pStep->setName(STEP_CIM_MODE_CHANGE);
         pStep->setWriteSignalDev(index == 0 ? 0x350 : 0x650);
         pStep->setCimModeDev(index == 0 ? 0x965 : 0x12b5);
         if (pEquipment->addStep(0x350, pStep) != 0) {
            delete pStep;
         }
      }
      {
         CEqCimMessageCmdStep* pStep = new CEqCimMessageCmdStep();
         pStep->setName(STEP_CIM_MESSAGE_CMD);
         pStep->setWriteSignalDev(index == 0 ? 0x351 : 0x651);
         pStep->setCimMessageDev(index == 0 ? 0x950 : 0x12a0);
         if (pEquipment->addStep(0x351, pStep) != 0) {
            delete pStep;
         }
      }
      {
         // CIM Message Confirm
         CEqReadIntStep* pStep = new CEqReadIntStep(__INT32, index == 0 ? 0x6a8f : 0x8a8f);
         pStep->setName(STEP_EQ_CIM_MESSAGE_CONFIRM);
         pStep->setWriteSignalDev(index == 0 ? 0x339 : 0x639);
         if (pEquipment->addStep(0x369, pStep) != 0) {
            delete pStep;
         }
      }
      {
         CEqCimMessageClearStep* pStep = new CEqCimMessageClearStep();
         pStep->setName(STEP_CIM_MESSAGE_CLEAR);
         pStep->setWriteSignalDev(index == 0 ? 0x352 : 0x652);
         pStep->setClearCimMessageDev(index == 0 ? 0x963 : 0x12b3);
         if (pEquipment->addStep(0x352, pStep) != 0) {
            delete pStep;
         }
      }
      {
         CEqDateTimeSetCmdStep* pStep = new CEqDateTimeSetCmdStep();
         pStep->setName(STEP_DATETIME_SET_CMD);
         pStep->setWriteSignalDev(index == 0 ? 0x353 : 0x653);
         pStep->setDateTimeDev(index == 0 ? 0x966 : 0x12b6);
         if (pEquipment->addStep(0x353, pStep) != 0) {
            delete pStep;
         }
      }
      {
         CEqModeChangeStep* pStep = new CEqModeChangeStep();
         pStep->setName(STEP_EQ_MODE_CHANGE);
         pStep->setWriteSignalDev(index == 0 ? 0x355 : 0x655);
         pStep->setEqModeDev(index == 0 ? 0x96E : 0x12be);
         if (pEquipment->addStep(0x355, pStep) != 0) {
            delete pStep;
         }
      }
      {
         CEqJobEventStep* pStep = new CEqJobEventStep();
         pStep->setName(STEP_EQ_RECEIVED_JOB_UPS1);
         pStep->setWriteSignalDev(index == 0 ? 0x300 : 0x600);
         pStep->setJobDataDev(index == 0 ? 0x6388 : 0x8388);
         if (pEquipment->addStep(0x380, pStep) != 0) {
            delete pStep;
         }
      }
      {
         CEqJobEventStep* pStep = new CEqJobEventStep();
         pStep->setName(STEP_EQ_RECEIVED_JOB_UPS2);
         pStep->setWriteSignalDev(index == 0 ? 0x301 : 0x601);
         pStep->setJobDataDev(index == 0 ? 0x64c8 : 0x84c8);
         if (pEquipment->addStep(0x381, pStep) != 0) {
            delete pStep;
         }
      }
      {
         CEqJobEventStep* pStep = new CEqJobEventStep();
         pStep->setName(STEP_EQ_SENT_OUT_JOB_UPS1);
         pStep->setWriteSignalDev(index == 0 ? 0x306 : 0x606);
         pStep->setJobDataDev(index == 0 ? 0x6000 : 0x8000);
         if (pEquipment->addStep(0x386, pStep) != 0) {
            delete pStep;
         }
      }
      {
         CEqJobEventStep* pStep = new CEqJobEventStep();
         pStep->setName(STEP_EQ_SENT_OUT_JOB_UPS2);
         pStep->setWriteSignalDev(index == 0 ? 0x307 : 0x607);
         pStep->setJobDataDev(index == 0 ? 0x6140 : 0x8140);
         if (pEquipment->addStep(0x387, pStep) != 0) {
            delete pStep;
         }
      }


      pEquipment->init();
      LOGE("已添加“%s”.", pEquipment->getName().c_str());


      return 0;
      return pEquipment;
   }

   int CMaster::addBakeCooling()
   CBakeCooling* CMaster::addBakeCooling()
   {
      CBakeCooling* pEquipment = new CBakeCooling();
      pEquipment->setID(EQ_ID_BAKE_COOLING);
@@ -916,10 +786,27 @@
      pEquipment->setStation(0, 255);
      addToEquipmentList(pEquipment);


      pEquipment->init();
      LOGE("已添加“Aligner”.");
      return 0;

      return pEquipment;
   }

   CMeasurement* CMaster::addMeasurement()
   {
      CMeasurement* pEquipment = new CMeasurement();
      pEquipment->setID(EQ_ID_MEASUREMENT);
      pEquipment->setBaseAlarmId(BASE_ALARM_EFEM);
      pEquipment->setName("Measurement");
      pEquipment->setDescription("Measurement.");
      pEquipment->setReadBitBlock(0x6700, 0x6e00);
      pEquipment->setStation(0, 255);
      addToEquipmentList(pEquipment);

      pEquipment->init();
      LOGE("已添加“Measurement”.");

      return pEquipment;
   }

   void CMaster::onTimer(UINT nTimerid)
@@ -974,6 +861,7 @@
      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);

      nRet = pLoadPort1->getPin("Out1")->connectPin(pFliper->getPin("In1"));
      if (nRet < 0) {
@@ -1023,12 +911,17 @@
         LOGE("连接Bonder2-BakeCooling失败");
      }

      nRet = pBakeCooling->getPin("Out1")->connectPin(pLoadPort3->getPin("In"));
      nRet = pBakeCooling->getPin("Out")->connectPin(pMeasurement->getPin("In"));
      if (nRet < 0) {
         LOGE("连接BakeCooling-LoadPort3失败");
      }

      nRet = pBakeCooling->getPin("Out2")->connectPin(pLoadPort4->getPin("In"));
      nRet = pMeasurement->getPin("Out1")->connectPin(pLoadPort3->getPin("In"));
      if (nRet < 0) {
         LOGE("连接BakeCooling-LoadPort3失败");
      }

      nRet = pMeasurement->getPin("Out2")->connectPin(pLoadPort4->getPin("In"));
      if (nRet < 0) {
         LOGE("连接BakeCooling-LoadPort4失败");
      }
@@ -1080,15 +973,23 @@

   int CMaster::readCache()
   {
      CFile file;
      if (!file.Open(m_strFilepath.c_str(), CFile::modeRead)) {
         return -1;
      }
      try {
         CFile file;
         if (!file.Open(m_strFilepath.c_str(), CFile::modeRead)) {
            return -1;
         }

      CArchive ar(&file, CArchive::load);
      serialize(ar);
      ar.Close();
      file.Close();
         CArchive ar(&file, CArchive::load);
         serialize(ar);
         ar.Close();
         file.Close();
      }
      catch (CFileException* e) {
         TCHAR szErr[512];
         e->GetErrorMessage(szErr, 512);
         AfxMessageBox(szErr);
         e->Delete();
      }

      return 0;
   }
@@ -1099,4 +1000,36 @@
         item->serialize(ar);
      }
   }

   void CMaster::setState(MASTERSTATE state)
   {
      m_state = state;
      if (m_listener.onMasterStateChanged != nullptr) {
         m_listener.onMasterStateChanged(this, m_state);
      }
   }

   static int taskSeqNo = 0;
   CRobotTask* CMaster::createTransferTask(CEquipment* pSrcEq, CEquipment* pTarEq)
   {
      CRobotTask* pTask = nullptr;
      CSlot* pSrcSlot, * pTarSlot;
      pTarSlot = pTarEq->getAvailableSlotForGlass(MaterialsType::G1);
      pSrcSlot = pSrcEq->getNonEmptySlot(MaterialsType::G1);
      if (pSrcSlot == nullptr || nullptr == pTarSlot) {
         pTarSlot = pTarEq->getAvailableSlotForGlass(MaterialsType::G2);
         pSrcSlot = pSrcEq->getNonEmptySlot(MaterialsType::G2);
      }


      if (pSrcSlot != nullptr && nullptr != pTarSlot) {
         pTask = new CRobotTask();
         pTask->setContext(pSrcSlot->getContext());
         pTask->setRobotTransferParam(++taskSeqNo, 1, pSrcSlot->getPosition(),
            pTarSlot->getPosition(), pSrcSlot->getNo(), pTarSlot->getNo());
      }


      return pTask;
   }
}