1.把LoadPort相关的step移到CLoadPort下，交它们当前efem的子设备来处理，逻辑上比较顺。

LAPTOP-SNT8I5JK\Boounion

2025-04-28 5fe38f3aa84459690a59667bff205f3f350c086c

1.把LoadPort相关的step移到CLoadPort下，交它们当前efem的子设备来处理，逻辑上比较顺。

 SourceCode/Bond/Servo/CEFEM.cpp

@@ -5,7 +5,10 @@
namespace SERVO {
    CEFEM::CEFEM() : CEquipment()
    {

        m_pPort[0] = nullptr;
        m_pPort[1] = nullptr;
        m_pPort[2] = nullptr;
        m_pPort[3] = nullptr;
    }

    CEFEM::~CEFEM()
@@ -17,6 +20,13 @@
    {
        static char* pszName = "CEFEM";
        return pszName;
    }

    void CEFEM::setPort(unsigned int index, CLoadPort* pPort)
    {
        if (index < 4) {
            m_pPort[index] = pPort;
        }
    }

    void CEFEM::init()
@@ -91,4 +101,15 @@

        return m_glassList.empty();
    }

    void CEFEM::onReceiveLBData(const char* pszData, size_t size)
    {
        __super::onReceiveLBData(pszData, size);

        for (unsigned int i = 0; i < 4; i++) {
            if (m_pPort[i] != nullptr) {
                m_pPort[i]->onReceiveLBData(pszData, size);
            }
        }
    }
}

 SourceCode/Bond/Servo/CEFEM.h

@@ -1,5 +1,6 @@
#pragma once
#include "CEquipment.h"
#include "CLoadPort.h"


namespace SERVO {
@@ -21,6 +22,14 @@
        virtual void getAttributeVector(CAttributeVector& attrubutes);
        virtual int recvIntent(CPin* pPin, CIntent* pIntent);
        virtual BOOL glassWillArrive(CGlass* pGlass);
        virtual void onReceiveLBData(const char* pszData, size_t size);

    public:
        void setPort(unsigned int index, CLoadPort* pPort);


    private:
        CLoadPort* m_pPort[4];
    };
}


 SourceCode/Bond/Servo/CEquipment.cpp

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


#define CHECK_READ_STEP_SIGNAL(addr, data, size) {                            \
@@ -406,31 +407,6 @@
        CHECK_READ_STEP_SIGNAL(STEP_ID_SENT_OUT_JOB_DOWNS1, pszData, size);
        CHECK_READ_STEP_SIGNAL(STEP_ID_SENT_OUT_JOB_DOWNS2, pszData, size);

        // Port1 ~ Port4
        CHECK_READ_STEP_SIGNAL(STEP_ID_PORT1_TYPE_CHANGE, pszData, size);
        CHECK_READ_STEP_SIGNAL(STEP_ID_PORT2_TYPE_CHANGE, pszData, size);
        CHECK_READ_STEP_SIGNAL(STEP_ID_PORT3_TYPE_CHANGE, pszData, size);
        CHECK_READ_STEP_SIGNAL(STEP_ID_PORT4_TYPE_CHANGE, pszData, size);
        CHECK_READ_STEP_SIGNAL(STEP_ID_PORT1_MODE_CHANGE, pszData, size);
        CHECK_READ_STEP_SIGNAL(STEP_ID_PORT2_MODE_CHANGE, pszData, size);
        CHECK_READ_STEP_SIGNAL(STEP_ID_PORT3_MODE_CHANGE, pszData, size);
        CHECK_READ_STEP_SIGNAL(STEP_ID_PORT4_MODE_CHANGE, pszData, size);
        CHECK_READ_STEP_SIGNAL(STEP_ID_PORT1_CASSETTE_TYPE_CHANGE, pszData, size);
        CHECK_READ_STEP_SIGNAL(STEP_ID_PORT2_CASSETTE_TYPE_CHANGE, pszData, size);
        CHECK_READ_STEP_SIGNAL(STEP_ID_PORT3_CASSETTE_TYPE_CHANGE, pszData, size);
        CHECK_READ_STEP_SIGNAL(STEP_ID_PORT4_CASSETTE_TYPE_CHANGE, pszData, size);
        CHECK_READ_STEP_SIGNAL(STEP_ID_PORT1_TRANSFER_MODE_CHANGE, pszData, size);
        CHECK_READ_STEP_SIGNAL(STEP_ID_PORT2_TRANSFER_MODE_CHANGE, pszData, size);
        CHECK_READ_STEP_SIGNAL(STEP_ID_PORT3_TRANSFER_MODE_CHANGE, pszData, size);
        CHECK_READ_STEP_SIGNAL(STEP_ID_PORT4_TRANSFER_MODE_CHANGE, pszData, size);
        CHECK_READ_STEP_SIGNAL(STEP_ID_PORT1_ENABLE_MODE_CHANGE, pszData, size);
        CHECK_READ_STEP_SIGNAL(STEP_ID_PORT2_ENABLE_MODE_CHANGE, pszData, size);
        CHECK_READ_STEP_SIGNAL(STEP_ID_PORT3_ENABLE_MODE_CHANGE, pszData, size);
        CHECK_READ_STEP_SIGNAL(STEP_ID_PORT4_ENABLE_MODE_CHANGE, pszData, size);
        CHECK_READ_STEP_SIGNAL(STEP_ID_PORT1_TYPE_AUTO_CHANGE, pszData, size);
        CHECK_READ_STEP_SIGNAL(STEP_ID_PORT2_TYPE_AUTO_CHANGE, pszData, size);
        CHECK_READ_STEP_SIGNAL(STEP_ID_PORT3_TYPE_AUTO_CHANGE, pszData, size);
        CHECK_READ_STEP_SIGNAL(STEP_ID_PORT4_TYPE_AUTO_CHANGE, pszData, size);

        // CEqCassetteTranserStateStep
        CHECK_READ_STEP_SIGNAL(STEP_ID_PORT1_CASSETTIE_EMPTY, pszData, size);
@@ -789,10 +765,46 @@
        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)
    {
        return CToolUnits::startsWith(pStep->getName(), "EQPort")
            && pStep->getName().find("Cassette") != std::string::npos;
        std::regex pattern("^EQPort\\d+Cassette.*");
        return std::regex_match(pStep->getName(), pattern);
    }

    bool CEquipment::isCimMessageConfirmStep(SERVO::CStep* pStep)

 SourceCode/Bond/Servo/CEquipment.h

@@ -111,6 +111,12 @@
        bool isAlarmStep(SERVO::CStep* pStep);
        bool isVcrEventStep(SERVO::CStep* pStep);
        bool isCassetteTransferStateStep(SERVO::CStep* pStep);
        bool isPortTypeStep(SERVO::CStep* pStep);
        bool isPortModeStep(SERVO::CStep* pStep);
        bool isPortCassetteTypeStep(SERVO::CStep* pStep);
        bool isPortTransferModeStep(SERVO::CStep* pStep);
        bool isPortEnableStep(SERVO::CStep* pStep);
        bool isPortTypeAutoChangeEnableStep(SERVO::CStep* pStep);
        bool isCimMessageConfirmStep(SERVO::CStep* pStep);
        int setEqMode(short mode);
        int setCimMode(BOOL bOn);
@@ -128,14 +134,11 @@
        BOOL isAutoRecipeChange();
        BOOL isVCREnable(unsigned int index);


    private:
        BOOL isBitOn(const char* pszData, size_t size, int index);
        inline BOOL equalBool(BOOL b1, BOOL b2);

    protected:
        inline void Lock() { EnterCriticalSection(&m_criticalSection); }
        inline void Unlock() { LeaveCriticalSection(&m_criticalSection); }
        BOOL isBitOn(const char* pszData, size_t size, int index);
        inline BOOL equalBool(BOOL b1, BOOL b2);
        void addGlassToList(CGlass* pGlass);

    protected:

 SourceCode/Bond/Servo/CLoadPort.cpp

@@ -2,13 +2,22 @@
#include "CLoadPort.h"


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

namespace SERVO {
    CLoadPort::CLoadPort() : CEquipment()
    {
        m_nType = 0;
        m_nMode = 0;
        m_nCassetteType = 0;
        m_nTransferMode = 4;
        m_nIndex = 0;
        m_nType = 1;
        m_nMode = 1;
        m_nCassetteType = 1;
        m_nTransferMode = 1;
        m_bEnable = FALSE;
        m_bAutoChangeEnable = FALSE;
    }
@@ -57,6 +66,22 @@
    void CLoadPort::getAttributeVector(CAttributeVector& attrubutes)
    {
        __super::getAttributeVector(attrubutes);

        std::string strTemp;
        attrubutes.addAttribute(new CAttribute("Index",
            std::to_string(m_nIndex).c_str(), ""));
        attrubutes.addAttribute(new CAttribute("Type",
            getPortTypeDescription(m_nType, strTemp).c_str(), ""));
        attrubutes.addAttribute(new CAttribute("Mode",
            getPortModeDescription(m_nMode, strTemp).c_str(), ""));
        attrubutes.addAttribute(new CAttribute("CassetteType",
            getPortCassetteTypeDescription(m_nCassetteType, strTemp).c_str(), ""));
        attrubutes.addAttribute(new CAttribute("TransferMode",
            getPortTransferModeDescription(m_nTransferMode, strTemp).c_str(), ""));
        attrubutes.addAttribute(new CAttribute("Enable",
            m_bEnable ? "Eanble" : "Disable", ""));
        attrubutes.addAttribute(new CAttribute("Auto Change",
            m_bAutoChangeEnable ? "Eanble" : "Disable", ""));
    }

    int CLoadPort::recvIntent(CPin* pPin, CIntent* pIntent)
@@ -125,6 +150,16 @@
        Unlock();

        return pStep;
    }

    void CLoadPort::setIndex(unsigned int index)
    {
        m_nIndex = index;
    }

    unsigned int CLoadPort::getIndex()
    {
        return m_nIndex;
    }

    BOOL CLoadPort::isEnable()
@@ -306,4 +341,63 @@

        return strDescription;
    }

    void CLoadPort::onReceiveLBData(const char* pszData, size_t size)
    {
        static int type[] = { STEP_ID_PORT1_TYPE_CHANGE, STEP_ID_PORT2_TYPE_CHANGE,
            STEP_ID_PORT3_TYPE_CHANGE, STEP_ID_PORT4_TYPE_CHANGE };
        static int mode[] = { STEP_ID_PORT1_MODE_CHANGE, STEP_ID_PORT2_MODE_CHANGE,
            STEP_ID_PORT3_MODE_CHANGE, STEP_ID_PORT4_MODE_CHANGE };
        static int cassetteType[] = { STEP_ID_PORT1_CASSETTE_TYPE_CHANGE, STEP_ID_PORT2_CASSETTE_TYPE_CHANGE,
            STEP_ID_PORT3_CASSETTE_TYPE_CHANGE, STEP_ID_PORT4_CASSETTE_TYPE_CHANGE };
        static int transferMode[] = { STEP_ID_PORT1_TRANSFER_MODE_CHANGE, STEP_ID_PORT2_TRANSFER_MODE_CHANGE,
            STEP_ID_PORT3_TRANSFER_MODE_CHANGE, STEP_ID_PORT4_TRANSFER_MODE_CHANGE };
        static int enable[] = { STEP_ID_PORT1_ENABLE_MODE_CHANGE, STEP_ID_PORT2_ENABLE_MODE_CHANGE,
            STEP_ID_PORT3_ENABLE_MODE_CHANGE, STEP_ID_PORT4_ENABLE_MODE_CHANGE };
        static int autoType[] = { STEP_ID_PORT1_TYPE_AUTO_CHANGE, STEP_ID_PORT2_TYPE_AUTO_CHANGE,
            STEP_ID_PORT3_TYPE_AUTO_CHANGE, STEP_ID_PORT4_TYPE_AUTO_CHANGE };

        CHECK_READ_STEP_SIGNAL2(type[m_nIndex], pszData, size);
        CHECK_READ_STEP_SIGNAL2(mode[m_nIndex], pszData, size);
        CHECK_READ_STEP_SIGNAL2(cassetteType[m_nIndex], pszData, size);
        CHECK_READ_STEP_SIGNAL2(transferMode[m_nIndex], pszData, size);
        CHECK_READ_STEP_SIGNAL2(enable[m_nIndex], pszData, size);
        CHECK_READ_STEP_SIGNAL2(autoType[m_nIndex], pszData, size);
    }

    int CLoadPort::onStepEvent(CStep* pStep, int code)
    {
        int nRet = CEquipment::onStepEvent(pStep, code);
        if (nRet > 0) return nRet;

        if (code == STEP_EVENT_READDATA) {
            if (isPortTypeStep(pStep)) {
                SERVO::CEqReadIntStep* pReadIntStep = (SERVO::CEqReadIntStep*)pStep;
                m_nType = pReadIntStep->getValue();
            }
            else if(isPortModeStep(pStep)) {
                SERVO::CEqReadIntStep* pReadIntStep = (SERVO::CEqReadIntStep*)pStep;
                m_nMode = pReadIntStep->getValue();
            }
            else if (isPortCassetteTypeStep(pStep)) {
                SERVO::CEqReadIntStep* pReadIntStep = (SERVO::CEqReadIntStep*)pStep;
                m_nCassetteType = pReadIntStep->getValue();
            }
            else if (isPortTransferModeStep(pStep)) {
                SERVO::CEqReadIntStep* pReadIntStep = (SERVO::CEqReadIntStep*)pStep;
                m_nTransferMode = pReadIntStep->getValue();
            }
            else if (isPortEnableStep(pStep)) {
                SERVO::CEqReadIntStep* pReadIntStep = (SERVO::CEqReadIntStep*)pStep;
                m_bEnable = pReadIntStep->getValue() == 1;
            }
            else if (isPortTypeAutoChangeEnableStep(pStep)) {
                SERVO::CEqReadIntStep* pReadIntStep = (SERVO::CEqReadIntStep*)pStep;
                m_bAutoChangeEnable = pReadIntStep->getValue() == 1;
            }
        }


        return 0;
    }
}

 SourceCode/Bond/Servo/CLoadPort.h

@@ -20,8 +20,12 @@
        virtual void getAttributeVector(CAttributeVector& attrubutes);
        virtual int recvIntent(CPin* pPin, CIntent* pIntent);
        virtual BOOL glassWillArrive(CGlass* pGlass);
        virtual void onReceiveLBData(const char* pszData, size_t size);
        virtual int onStepEvent(CStep* pStep, int code);

    public:
        void setIndex(unsigned int index);
        unsigned int getIndex();
        BOOL isEnable();
        int getPortType();
        int getPortMode();
@@ -47,6 +51,7 @@
        CStep* getCassetteCtrlCmdStep();

    private:
        unsigned int m_nIndex;
        int m_nType;
        int m_nMode;
        int m_nCassetteType;

 SourceCode/Bond/Servo/CMaster.cpp

@@ -100,14 +100,21 @@


        // 初始化添加各子设备
        addLoadPort(0);
        addLoadPort(1);
        addLoadPort(2);
        addLoadPort(3);
        CLoadPort* pPort1, * pPort2, * pPort3, * pPort4;
        CEFEM* pEfem;
        pPort1 = addLoadPort(0);
        pPort2 = addLoadPort(1);
        pPort3 = addLoadPort(2);
        pPort4 = addLoadPort(3);
        pEfem = addEFEM();
        pEfem->setPort(0, pPort1);
        pEfem->setPort(1, pPort1);
        pEfem->setPort(2, pPort1);
        pEfem->setPort(3, pPort1);

        addFliper();
        addVacuumBake();
        addAligner();
        addEFEM();
        addBonder(0);
        addBonder(1);
        addBakeCooling();
@@ -232,10 +239,11 @@
        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[] = { 
@@ -252,6 +260,7 @@
        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);
@@ -270,11 +279,102 @@
        }


        {
            // Type
            char* pszName[] = { STEP_EQ_PORT1_TYPE, STEP_EQ_PORT2_TYPE, STEP_EQ_PORT3_TYPE, STEP_EQ_PORT4_TYPE };
            int dev[] = { 0x6010 , 0x6020, 0x6030, 0x6040 };
            int writeSignalDev[] = { 0xa0, 0xa1, 0xa2, 0xa3 };
            int addr[] = { STEP_ID_PORT1_TYPE_CHANGE, STEP_ID_PORT2_TYPE_CHANGE, STEP_ID_PORT3_TYPE_CHANGE, STEP_ID_PORT4_TYPE_CHANGE };

            CEqReadIntStep* pStep = new CEqReadIntStep(__INT16, dev[index]);
            pStep->setName(pszName[index]);
            pStep->setWriteSignalDev(writeSignalDev[index]);
            if (pEquipment->addStep(addr[index], pStep) != 0) {
                delete pStep;
            }
        }
		
        {
            // Mode
            char* pszName[] = { STEP_EQ_PORT1_MODE, STEP_EQ_PORT2_MODE, STEP_EQ_PORT3_MODE, STEP_EQ_PORT4_MODE };
            int dev[] = { 0x6011, 0x6021, 0x6031, 0x6041};
            int writeSignalDev[] = { 0xa8, 0xa9, 0xaa, 0xab };
            int addr[] = { STEP_ID_PORT1_MODE_CHANGE, STEP_ID_PORT2_MODE_CHANGE, STEP_ID_PORT3_MODE_CHANGE, STEP_ID_PORT4_MODE_CHANGE };

            CEqReadIntStep* pStep = new CEqReadIntStep(__INT16, dev[index]);
            pStep->setName(pszName[index]);
            pStep->setWriteSignalDev(writeSignalDev[index]);
            if (pEquipment->addStep(addr[index], pStep) != 0) {
                delete pStep;
            }
        }

        {
            // Cassette type
            char* pszName[] = { STEP_EQ_PORT1_CASSETTE_TYPE, STEP_EQ_PORT2_CASSETTE_TYPE, STEP_EQ_PORT3_CASSETTE_TYPE, STEP_EQ_PORT4_CASSETTE_TYPE };
            int dev[] = { 0x6012, 0x6022, 0x6032, 0x6042 };
            int writeSignalDev[] = { 0xb0, 0xb1, 0xb2, 0xb3 };
            int addr[] = { STEP_ID_PORT1_CASSETTE_TYPE_CHANGE, STEP_ID_PORT2_CASSETTE_TYPE_CHANGE, STEP_ID_PORT3_CASSETTE_TYPE_CHANGE, STEP_ID_PORT4_CASSETTE_TYPE_CHANGE };

            CEqReadIntStep* pStep = new CEqReadIntStep(__INT16, dev[index]);
            pStep->setName(pszName[index]);
            pStep->setWriteSignalDev(writeSignalDev[index]);
            if (pEquipment->addStep(addr[index], pStep) != 0) {
                delete pStep;
            }
        }

        {
            // Transfer type
            char* pszName[] = { STEP_EQ_PORT1_TRANSFER_MODE, STEP_EQ_PORT2_TRANSFER_MODE, STEP_EQ_PORT3_TRANSFER_MODE, STEP_EQ_PORT4_TRANSFER_MODE };
            int dev[] = { 0x6014, 0x6024, 0x6034, 0x6044 };
            int writeSignalDev[] = { 0xb8, 0xb9, 0xba, 0xbb };
            int addr[] = { STEP_ID_PORT1_TRANSFER_MODE_CHANGE, STEP_ID_PORT2_TRANSFER_MODE_CHANGE, STEP_ID_PORT3_TRANSFER_MODE_CHANGE, STEP_ID_PORT4_TRANSFER_MODE_CHANGE };

            CEqReadIntStep* pStep = new CEqReadIntStep(__INT16, dev[index]);
            pStep->setName(pszName[index]);
            pStep->setWriteSignalDev(writeSignalDev[index]);
            if (pEquipment->addStep(addr[index], pStep) != 0) {
                delete pStep;
            }
        }

        {
            // Port enable
            char* pszName[] = { STEP_EQ_PORT1_ENABLE, STEP_EQ_PORT2_ENABLE, STEP_EQ_PORT3_ENABLE, STEP_EQ_PORT4_ENABLE };
            int dev[] = { 0x6015, 0x6025, 0x6035, 0x6045 };
            int writeSignalDev[] = { 0xc0, 0xc1, 0xc2, 0xc3 };
            int addr[] = { STEP_ID_PORT1_ENABLE_MODE_CHANGE, STEP_ID_PORT2_ENABLE_MODE_CHANGE, STEP_ID_PORT3_ENABLE_MODE_CHANGE, STEP_ID_PORT4_ENABLE_MODE_CHANGE };

            CEqReadIntStep* pStep = new CEqReadIntStep(__INT16, dev[index]);
            pStep->setName(pszName[index]);
            pStep->setWriteSignalDev(writeSignalDev[index]);
            if (pEquipment->addStep(addr[index], pStep) != 0) {
                delete pStep;
            }
        }

        {
            // Type auto change
            char* pszName[] = { STEP_EQ_PORT1_TYPE_ATUO, STEP_EQ_PORT2_TYPE_ATUO, STEP_EQ_PORT3_TYPE_ATUO, STEP_EQ_PORT4_TYPE_ATUO };
            int dev[] = { 0x6016, 0x6026, 0x6036, 0x6046 };
            int writeSignalDev[] = { 0xc8, 0xc9, 0xca, 0xcb };
            int addr[] = { STEP_ID_PORT1_TYPE_AUTO_CHANGE, STEP_ID_PORT2_TYPE_AUTO_CHANGE, STEP_ID_PORT3_TYPE_AUTO_CHANGE, STEP_ID_PORT4_TYPE_AUTO_CHANGE };

            CEqReadIntStep* pStep = new CEqReadIntStep(__INT16, dev[index]);
            pStep->setName(pszName[index]);
            pStep->setWriteSignalDev(writeSignalDev[index]);
            if (pEquipment->addStep(addr[index], pStep) != 0) {
                delete pStep;
            }
        }


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


        return 0;
        return pEquipment;
    }

    int CMaster::addFliper()
@@ -328,7 +428,7 @@
        return 0;
    }

    int CMaster::addEFEM()
    CEFEM* CMaster::addEFEM()
    {
        CEFEM* pEquipment = new CEFEM();
        pEquipment->setID(EQ_ID_EFEM);
@@ -488,206 +588,6 @@
            }
        }

        // Port1
        {
            CEqReadIntStep* pStep = new CEqReadIntStep(__INT16, 0x6010);
            pStep->setName(STEP_EQ_PORT1_TYPE);
            pStep->setWriteSignalDev(0xa0);
            if (pEquipment->addStep(STEP_ID_PORT1_TYPE_CHANGE, pStep) != 0) {
                delete pStep;
            }
        }
        {
            CEqReadIntStep* pStep = new CEqReadIntStep(__INT16, 0x6011);
            pStep->setName(STEP_EQ_PORT1_MODE);
            pStep->setWriteSignalDev(0xa8);
            if (pEquipment->addStep(STEP_ID_PORT1_MODE_CHANGE, pStep) != 0) {
                delete pStep;
            }
        }
        {
            CEqReadIntStep* pStep = new CEqReadIntStep(__INT32, 0x6012);
            pStep->setName(STEP_EQ_PORT1_CASSETTE_TYPE);
            pStep->setWriteSignalDev(0xb0);
            if (pEquipment->addStep(STEP_ID_PORT1_CASSETTE_TYPE_CHANGE, pStep) != 0) {
                delete pStep;
            }
        }
        {
            CEqReadIntStep* pStep = new CEqReadIntStep(__INT16, 0x6014);
            pStep->setName(STEP_EQ_PORT1_TRANSFER_MODE);
            pStep->setWriteSignalDev(0xb8);
            if (pEquipment->addStep(STEP_ID_PORT1_TRANSFER_MODE_CHANGE, pStep) != 0) {
                delete pStep;
            }
        }
        {
            CEqReadIntStep* pStep = new CEqReadIntStep(__INT16, 0x6015);
            pStep->setName(STEP_EQ_PORT1_ENABLE);
            pStep->setWriteSignalDev(0xc0);
            if (pEquipment->addStep(STEP_ID_PORT1_ENABLE_MODE_CHANGE, pStep) != 0) {
                delete pStep;
            }
        }
        {
            CEqReadIntStep* pStep = new CEqReadIntStep(__INT16, 0x6016);
            pStep->setName(STEP_EQ_PORT1_TYPE_ATUO);
            pStep->setWriteSignalDev(0xc8);
            if (pEquipment->addStep(STEP_ID_PORT1_TYPE_AUTO_CHANGE, pStep) != 0) {
                delete pStep;
            }
        }

        // Port2
        {
            CEqReadIntStep* pStep = new CEqReadIntStep(__INT16, 0x6020);
            pStep->setName(STEP_EQ_PORT2_TYPE);
            pStep->setWriteSignalDev(0xa1);
            if (pEquipment->addStep(STEP_ID_PORT2_TYPE_CHANGE, pStep) != 0) {
                delete pStep;
            }
        }
        {
            CEqReadIntStep* pStep = new CEqReadIntStep(__INT16, 0x6021);
            pStep->setName(STEP_EQ_PORT2_MODE);
            pStep->setWriteSignalDev(0xa9);
            if (pEquipment->addStep(STEP_ID_PORT2_MODE_CHANGE, pStep) != 0) {
                delete pStep;
            }
        }
        {
            CEqReadIntStep* pStep = new CEqReadIntStep(__INT32, 0x6022);
            pStep->setName(STEP_EQ_PORT2_CASSETTE_TYPE);
            pStep->setWriteSignalDev(0xb1);
            if (pEquipment->addStep(STEP_ID_PORT2_CASSETTE_TYPE_CHANGE, pStep) != 0) {
                delete pStep;
            }
        }
        {
            CEqReadIntStep* pStep = new CEqReadIntStep(__INT16, 0x6024);
            pStep->setName(STEP_EQ_PORT2_TRANSFER_MODE);
            pStep->setWriteSignalDev(0xb9);
            if (pEquipment->addStep(STEP_ID_PORT2_TRANSFER_MODE_CHANGE, pStep) != 0) {
                delete pStep;
            }
        }
        {
            CEqReadIntStep* pStep = new CEqReadIntStep(__INT16, 0x6025);
            pStep->setName(STEP_EQ_PORT2_ENABLE);
            pStep->setWriteSignalDev(0xc1);
            if (pEquipment->addStep(STEP_ID_PORT2_ENABLE_MODE_CHANGE, pStep) != 0) {
                delete pStep;
            }
        }
        {
            CEqReadIntStep* pStep = new CEqReadIntStep(__INT16, 0x6026);
            pStep->setName(STEP_EQ_PORT2_TYPE_ATUO);
            pStep->setWriteSignalDev(0xc9);
            if (pEquipment->addStep(STEP_ID_PORT2_TYPE_AUTO_CHANGE, pStep) != 0) {
                delete pStep;
            }
        }

        // Port3
        {
            CEqReadIntStep* pStep = new CEqReadIntStep(__INT16, 0x6030);
            pStep->setName(STEP_EQ_PORT3_TYPE);
            pStep->setWriteSignalDev(0xa2);
            if (pEquipment->addStep(STEP_ID_PORT3_TYPE_CHANGE, pStep) != 0) {
                delete pStep;
            }
        }
        {
            CEqReadIntStep* pStep = new CEqReadIntStep(__INT16, 0x6031);
            pStep->setName(STEP_EQ_PORT3_MODE);
            pStep->setWriteSignalDev(0xaa);
            if (pEquipment->addStep(STEP_ID_PORT3_MODE_CHANGE, pStep) != 0) {
                delete pStep;
            }
        }
        {
            CEqReadIntStep* pStep = new CEqReadIntStep(__INT32, 0x6032);
            pStep->setName(STEP_EQ_PORT3_CASSETTE_TYPE);
            pStep->setWriteSignalDev(0xb2);
            if (pEquipment->addStep(STEP_ID_PORT3_CASSETTE_TYPE_CHANGE, pStep) != 0) {
                delete pStep;
            }
        }
        {
            CEqReadIntStep* pStep = new CEqReadIntStep(__INT16, 0x6034);
            pStep->setName(STEP_EQ_PORT3_TRANSFER_MODE);
            pStep->setWriteSignalDev(0xba);
            if (pEquipment->addStep(STEP_ID_PORT3_TRANSFER_MODE_CHANGE, pStep) != 0) {
                delete pStep;
            }
        }
        {
            CEqReadIntStep* pStep = new CEqReadIntStep(__INT16, 0x6035);
            pStep->setName(STEP_EQ_PORT3_ENABLE);
            pStep->setWriteSignalDev(0xc2);
            if (pEquipment->addStep(STEP_ID_PORT3_ENABLE_MODE_CHANGE, pStep) != 0) {
                delete pStep;
            }
        }
        {
            CEqReadIntStep* pStep = new CEqReadIntStep(__INT16, 0x6036);
            pStep->setName(STEP_EQ_PORT3_TYPE_ATUO);
            pStep->setWriteSignalDev(0xca);
            if (pEquipment->addStep(STEP_ID_PORT3_TYPE_AUTO_CHANGE, pStep) != 0) {
                delete pStep;
            }
        }

        // Port4
        {
            CEqReadIntStep* pStep = new CEqReadIntStep(__INT16, 0x6040);
            pStep->setName(STEP_EQ_PORT4_TYPE);
            pStep->setWriteSignalDev(0xa3);
            if (pEquipment->addStep(STEP_ID_PORT4_TYPE_CHANGE, pStep) != 0) {
                delete pStep;
            }
        }
        {
            CEqReadIntStep* pStep = new CEqReadIntStep(__INT16, 0x6041);
            pStep->setName(STEP_EQ_PORT4_MODE);
            pStep->setWriteSignalDev(0xab);
            if (pEquipment->addStep(STEP_ID_PORT4_MODE_CHANGE, pStep) != 0) {
                delete pStep;
            }
        }
        {
            CEqReadIntStep* pStep = new CEqReadIntStep(__INT32, 0x6042);
            pStep->setName(STEP_EQ_PORT4_CASSETTE_TYPE);
            pStep->setWriteSignalDev(0xb3);
            if (pEquipment->addStep(STEP_ID_PORT4_CASSETTE_TYPE_CHANGE, pStep) != 0) {
                delete pStep;
            }
        }
        {
            CEqReadIntStep* pStep = new CEqReadIntStep(__INT16, 0x6044);
            pStep->setName(STEP_EQ_PORT4_TRANSFER_MODE);
            pStep->setWriteSignalDev(0xbb);
            if (pEquipment->addStep(STEP_ID_PORT4_TRANSFER_MODE_CHANGE, pStep) != 0) {
                delete pStep;
            }
        }
        {
            CEqReadIntStep* pStep = new CEqReadIntStep(__INT16, 0x6045);
            pStep->setName(STEP_EQ_PORT4_ENABLE);
            pStep->setWriteSignalDev(0xc3);
            if (pEquipment->addStep(STEP_ID_PORT4_ENABLE_MODE_CHANGE, pStep) != 0) {
                delete pStep;
            }
        }
        {
            CEqReadIntStep* pStep = new CEqReadIntStep(__INT16, 0x6046);
            pStep->setName(STEP_EQ_PORT4_TYPE_ATUO);
            pStep->setWriteSignalDev(STEP_ID_PORT4_TYPE_AUTO_CHANGE);
            if (pEquipment->addStep(0xcb, pStep) != 0) {
                delete pStep;
            }
        }


        // CEqCassetteTranserStateStep
        ADD_EQ_CASSETTE_TRANSFER_STATE_STEP(STEP_EQ_P1_CASSETTE_EMPTY, 0xd8, 
@@ -741,7 +641,8 @@

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

        return pEquipment;
    }

    /* 添加bonder1 或 bonder2 

 SourceCode/Bond/Servo/CMaster.h

@@ -43,11 +43,11 @@

    private:
        int addToEquipmentList(CEquipment* pEquipment);
        int addLoadPort(int index);
        CLoadPort* addLoadPort(int index);
        int addFliper();
        int addVacuumBake();
        int addAligner();
        int addEFEM();
        CEFEM* addEFEM();
        int addBonder(int index);
        int addBakeCooling();
        void connectEquipments();