1.添加载具搬送状态类(CEqCassetteTransferStateStep)

LAPTOP-SNT8I5JK\Boounion

2025-03-29 57056db746cec1ad5c0cc5dad93b8f3474d2562d

1.添加载具搬送状态类(CEqCassetteTransferStateStep)

 SourceCode/Bond/Servo/CEqCassetteTransferStateStep.cpp

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,293 @@
#include "stdafx.h"
#include "CEqCassetteTransferStateStep.h"
#include "Log.h"
#include "Common.h"


namespace SERVO {
    CEqCassetteTransferStateStep::CEqCassetteTransferStateStep()
    {
        m_nPortStatusDev = 0;
        m_nPortStatus = 0;
        m_nCassetteSequenceNo = 0;
        m_nLoadingCassetteType = 0;
        m_nQTimeFlag = 0;
        m_nCassetteMappingState = 0;
        m_nCassetteStatus = 0;
    }

    CEqCassetteTransferStateStep::~CEqCassetteTransferStateStep()
    {

    }

    void CEqCassetteTransferStateStep::getAttributeVector(CAttributeVector& attrubutes)
    {
        CReadStep::getAttributeVector(attrubutes);

        std::string strTemp;
        attrubutes.addAttribute(new CAttribute("Dev",
            ("W" + CToolUnits::toHexString(m_nPortStatusDev, strTemp)).c_str(), ""));
        attrubutes.addAttribute(new CAttribute("Port Status",
            getPortStatusDescription(strTemp).c_str(), ""));
        attrubutes.addAttribute(new CAttribute("CassetteSequenceNo",
            std::to_string(m_nCassetteSequenceNo).c_str(), ""));
        attrubutes.addAttribute(new CAttribute("CassetteID",
            m_strCassetteID.c_str(), ""));
        attrubutes.addAttribute(new CAttribute("LoadingCassetteType",
            getLoadingCassetteTypeDescription(strTemp).c_str(), ""));
        attrubutes.addAttribute(new CAttribute("Q-Time Flag",
            getQTimeFlagDescription(strTemp).c_str(), ""));
        attrubutes.addAttribute(new CAttribute("CassetteMappingState",
            getCassetteMappingStateDescription(strTemp).c_str(), ""));
        attrubutes.addAttribute(new CAttribute("CassetteStatus",
            getCassetteStatusDescription(strTemp).c_str(), ""));
    }

    int CEqCassetteTransferStateStep::onReadData()
    {
        CReadStep::onReadData();


        char szBuffer[64];
        int nRet = m_pCclink->ReadData2(m_station, DeviceType::W, m_nPortStatusDev,
            64, szBuffer);
        if (0 != nRet) {
            return -1;
        }


        // Port status，
        // æ³¨ï¼šä¹Ÿå¯ä»¥æ ¹æ®m_nSignalType的值来判断状态值
        m_nPortStatus = (unsigned int)CToolUnits::toInt16(&szBuffer[0]);


        // Cassette序号、ID
        m_nCassetteSequenceNo = (unsigned int)CToolUnits::toInt16(&szBuffer[2]);
        convertString(&szBuffer[4], 20, m_strCassetteID);


        // Job Existence Slot
        if (PORT_INUSE == m_nPortStatus) {

        }


        // Q-Time
        if (PORT_UNLOAD_READY == m_nPortStatus) {
            m_nQTimeFlag = (unsigned int)CToolUnits::toInt16(&szBuffer[50]);
        }

        // å…¶å®ƒ
        m_nCassetteMappingState = (unsigned int)CToolUnits::toInt16(&szBuffer[52]);
        m_nCassetteStatus = (unsigned int)CToolUnits::toInt16(&szBuffer[54]);
        if (m_nCassetteStatus > 1) {
            m_nLoadingCassetteType = (unsigned int)CToolUnits::toInt16(&szBuffer[48]);
        }


        LOGI("<CCassetteTranserStateStep>Port status changed<Dev:%d, Status:%d, CassetteSequenceNo:%d>",
            m_nPortStatusDev, m_nPortStatus, m_nCassetteSequenceNo);

        return 0;
    }

    int CEqCassetteTransferStateStep::onComplete()
    {
        CReadStep::onComplete();
        LOGI("<CCassetteTranserStateStep> onComplete.");

        return 0;
    }

    int CEqCassetteTransferStateStep::onTimeout()
    {
        CReadStep::onTimeout();
        LOGI("<CCassetteTranserStateStep> onTimeout.");

        return 0;
    }

    void CEqCassetteTransferStateStep::setPortStatusDev(int nDev)
    {
        m_nPortStatusDev = nDev;
    }

    int CEqCassetteTransferStateStep::getPortStatus()
    {
        return m_nPortStatus;
    }

    int CEqCassetteTransferStateStep::getCassetteSequenceNo()
    {
        return m_nCassetteSequenceNo;
    }

    std::string& CEqCassetteTransferStateStep::getCassetteID()
    {
        return m_strCassetteID;
    }

    int CEqCassetteTransferStateStep::getLoadingCassetteType()
    {
        return m_nLoadingCassetteType;
    }

    int CEqCassetteTransferStateStep::getQTimeFlag()
    {
        return m_nQTimeFlag;
    }

    int CEqCassetteTransferStateStep::getCassetteMappingState()
    {
        return m_nCassetteMappingState;
    }

    int CEqCassetteTransferStateStep::getCassetteStatus()
    {
        return m_nCassetteStatus;
    }

    /*
     1: Load Ready(Load Request)
     2: Loaded
     3: In Use (Load Complete)
     4: Unload Ready (Unload Request)
     5: Empty (Unload Complete)
     6: Blocked
     */
    std::string& CEqCassetteTransferStateStep::getPortStatusDescription(std::string& strDescription)
    {
        switch (m_nPortStatus) {
        case PORT_LOAD_READY:
            strDescription = _T("Load Ready(Load Request)");
            break;
        case PORT_LOADED:
            strDescription = _T("Loaded");
            break;
        case PORT_INUSE:
            strDescription = _T("In Use (Load Complete)");
            break;
        case PORT_UNLOAD_READY:
            strDescription = _T("Unload Ready (Unload Request)");
            break;
        case PORT_EMPTY:
            strDescription = _T("Empty (Unload Complete)");
            break;
        case PORT_BLOCKED:
            strDescription = _T("Blocked");
            break;
        default:
            strDescription = _T("");
            break;
        }

        return strDescription;
    }

    /*
     1: Actual Cassette
     2: Empty Cassette
        *Include this item only when cassette exists
     */
    std::string& CEqCassetteTransferStateStep::getLoadingCassetteTypeDescription(std::string& strDescription)
    {
        switch (m_nLoadingCassetteType) {
        case PORT_LOADING_CASSETTE_ACTUAL:
            strDescription = _T("Actual Cassette");
            break;
        case PORT_LOADING_CASSETTE_EMPTY:
            strDescription = _T("Empty Cassette");
            break;
        default:
            strDescription = _T("");
            break;
        }

        return strDescription;
    }

    /*
     1: Normal Un-loading
     2: Q-Time Over & Un-loading
       * Include this item only when Port Status is 'Unload Ready'
     */
    std::string& CEqCassetteTransferStateStep::getQTimeFlagDescription(std::string& strDescription)
    {
        switch (m_nQTimeFlag) {
        case Q_TIME_NORMAL:
            strDescription = _T("Normal Un-loading");
            break;
        case Q_TIME_OVER:
            strDescription = _T("Q-Time Over & Un-loading");
            break;
        default:
            strDescription = _T("");
            break;
        }

        return strDescription;
    }

    /*
     1: mapping use
     2: mapping not use
     */
    std::string& CEqCassetteTransferStateStep::getCassetteMappingStateDescription(std::string& strDescription)
    {
        switch (m_nCassetteMappingState) {
        case CASSETTE_MAPPING_USE:
            strDescription = _T("mapping use");
            break;
        case CASSETTE_MAPPING_USE:
            strDescription = _T("mapping not use");
            break;
        default:
            strDescription = _T("");
            break;
        }

        return strDescription;
    }

    /*
     1: No Cassette Exist
     2: Waiting for Cassette Data
     3: Waiting for Start Command
     4: Waiting for Processing
     5: In Processing
     6: Process Paused
     7: Process Completed
     */
    std::string& CEqCassetteTransferStateStep::getCassetteStatusDescription(std::string& strDescription)
    {
        switch (m_nCassetteStatus) {
        case CASSETTE_NO_EXIST:
            strDescription = _T("No Cassette Exist");
            break;
        case CASSETTE_WAITING_DATA:
            strDescription = _T("Waiting for Cassette Data");
            break;
        case CASSETTE_WAITING_START:
            strDescription = _T("Waiting for Start Command");
            break;
        case CASSETTE_WAITING_PROCCESSING:
            strDescription = _T("Waiting for Processing");
            break;
        case CASSETTE_IN_PROCCESSING:
            strDescription = _T("In Processing");
            break;
        case CASSETTE_PROCCESS_PAUSED:
            strDescription = _T("Process Paused");
            break;
        case CASSETTE_PROCCESS_COMPLETED:
            strDescription = _T("Process Completed");
            break;
        default:
            strDescription = _T("");
            break;
        }

        return strDescription;
    }
}

 SourceCode/Bond/Servo/CEqCassetteTransferStateStep.h

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,44 @@
#pragma once
#include "CReadStep.h"


namespace SERVO {
    class CEqCassetteTransferStateStep : public CReadStep
    {
    public:
        CEqCassetteTransferStateStep();
        ~CEqCassetteTransferStateStep();

    public:
        virtual void getAttributeVector(CAttributeVector& attrubutes);
        virtual int onReadData();
        virtual int onComplete();
        virtual int onTimeout();
        void setPortStatusDev(int nDev);
        int getPortStatus();
        int getCassetteSequenceNo();
        std::string& getCassetteID();
        int getLoadingCassetteType();
        int getQTimeFlag();
        int getCassetteMappingState();
        int getCassetteStatus();
        std::string& getPortStatusDescription(std::string& strDescription);
        std::string& getLoadingCassetteTypeDescription(std::string& strDescription);
        std::string& getQTimeFlagDescription(std::string& strDescription);
        std::string& getCassetteMappingStateDescription(std::string& strDescription);
        std::string& getCassetteStatusDescription(std::string& strDescription);

    private:
        int m_nPortStatusDev;
        int m_nPortStatus;
        int m_nCassetteSequenceNo;
        std::string m_strCassetteID;
        int m_nLoadingCassetteType;
        int m_nQTimeFlag;
        int m_nCassetteMappingState;
        int m_nCassetteStatus;


    };
}


 SourceCode/Bond/Servo/CEquipment.cpp

@@ -3,6 +3,22 @@
#include "ToolUnits.h"


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

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

namespace SERVO {

    CEquipment::CEquipment() : m_nID(0), m_strName(""), m_strDescription(""), m_station(0, 255)
@@ -358,40 +374,65 @@
        // Equipment Status Change Report(0x361)
        // Equipment Alarm Change Report(0x362 ~ 0x366)
        for (int i = 0; i < 7; i++) {
            checkReadStepSignal(0x360 + i, pszData, size);
            CHECK_READ_STEP_SIGNAL(0x360 + i, pszData, size);
        }


        // CIM Mode
        checkWriteStepSignal(0x350, pszData, size);
        CHECK_WRITE_STEP_SIGNAL(0x350, pszData, size);


        // Port1 ~ Port4
        checkReadStepSignal(0x3e0, pszData, size);
        checkReadStepSignal(0x3e1, pszData, size);
        checkReadStepSignal(0x3e2, pszData, size);
        checkReadStepSignal(0x3e3, pszData, size);
        checkReadStepSignal(0x3e8, pszData, size);
        checkReadStepSignal(0x3e9, pszData, size);
        checkReadStepSignal(0x3ea, pszData, size);
        checkReadStepSignal(0x3eb, pszData, size);
        checkReadStepSignal(0x3f0, pszData, size);
        checkReadStepSignal(0x3f1, pszData, size);
        checkReadStepSignal(0x3f2, pszData, size);
        checkReadStepSignal(0x3f3, pszData, size);
        checkReadStepSignal(0x3f8, pszData, size);
        checkReadStepSignal(0x3f9, pszData, size);
        checkReadStepSignal(0x3fa, pszData, size);
        checkReadStepSignal(0x3fb, pszData, size);
        checkReadStepSignal(0x400, pszData, size);
        checkReadStepSignal(0x401, pszData, size);
        checkReadStepSignal(0x402, pszData, size);
        checkReadStepSignal(0x403, pszData, size);
        checkReadStepSignal(0x408, pszData, size);
        checkReadStepSignal(0x409, pszData, size);
        checkReadStepSignal(0x40a, pszData, size);
        checkReadStepSignal(0x40b, pszData, size);
        CHECK_READ_STEP_SIGNAL(0x3e0, pszData, size);
        CHECK_READ_STEP_SIGNAL(0x3e1, pszData, size);
        CHECK_READ_STEP_SIGNAL(0x3e2, pszData, size);
        CHECK_READ_STEP_SIGNAL(0x3e3, pszData, size);
        CHECK_READ_STEP_SIGNAL(0x3e8, pszData, size);
        CHECK_READ_STEP_SIGNAL(0x3e9, pszData, size);
        CHECK_READ_STEP_SIGNAL(0x3ea, pszData, size);
        CHECK_READ_STEP_SIGNAL(0x3eb, pszData, size);
        CHECK_READ_STEP_SIGNAL(0x3f0, pszData, size);
        CHECK_READ_STEP_SIGNAL(0x3f1, pszData, size);
        CHECK_READ_STEP_SIGNAL(0x3f2, pszData, size);
        CHECK_READ_STEP_SIGNAL(0x3f3, pszData, size);
        CHECK_READ_STEP_SIGNAL(0x3f8, pszData, size);
        CHECK_READ_STEP_SIGNAL(0x3f9, pszData, size);
        CHECK_READ_STEP_SIGNAL(0x3fa, pszData, size);
        CHECK_READ_STEP_SIGNAL(0x3fb, pszData, size);
        CHECK_READ_STEP_SIGNAL(0x400, pszData, size);
        CHECK_READ_STEP_SIGNAL(0x401, pszData, size);
        CHECK_READ_STEP_SIGNAL(0x402, pszData, size);
        CHECK_READ_STEP_SIGNAL(0x403, pszData, size);
        CHECK_READ_STEP_SIGNAL(0x408, pszData, size);
        CHECK_READ_STEP_SIGNAL(0x409, pszData, size);
        CHECK_READ_STEP_SIGNAL(0x40a, pszData, size);
        CHECK_READ_STEP_SIGNAL(0x40b, 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)
@@ -673,23 +714,5 @@
        Unlock();

        return pGlass;
    }

    void CEquipment::checkReadStepSignal(unsigned int addr, const char* pszData, size_t size)
    {
        BOOL bFlag = isBitOn(pszData, size, addr);
        SERVO::CStep* pStep = getStep(addr);
        if (pStep != nullptr) {
            ((CReadStep*)pStep)->onReadSignal(bFlag ? 1 : 0);
        }
    }

    void CEquipment::checkWriteStepSignal(unsigned int addr, const char* pszData, size_t size)
    {
        BOOL bFlag = isBitOn(pszData, size, addr);
        SERVO::CStep* pStep = getStep(addr);
        if (pStep != nullptr) {
            ((CWriteStep*)pStep)->onRecvSignal(bFlag);
        }
    }
}

 SourceCode/Bond/Servo/CEquipment.h

@@ -15,6 +15,7 @@
#include "CEqVCREnableStep.h"
#include "CEqPortChangeStep.h"
#include "CEqReadIntStep.h"
#include "CEqCassetteTransferStateStep.h"
#include <vector>
#include <map>
#include <list>
@@ -114,8 +115,6 @@
    private:
        BOOL isBitOn(const char* pszData, size_t size, int index);
        inline BOOL equalBool(BOOL b1, BOOL b2);
        void checkReadStepSignal(unsigned int addr, const char* pszData, size_t size);
        void checkWriteStepSignal(unsigned int addr, const char* pszData, size_t size);

    protected:
        inline void Lock() { EnterCriticalSection(&m_criticalSection); }

 SourceCode/Bond/Servo/CMaster.cpp

@@ -2,6 +2,18 @@
#include "Common.h"
#include "CMaster.h"


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

namespace SERVO {
    CMaster* g_pMaster = NULL;
    void CALLBACK MasterTimerProc(HWND hWnd, UINT nMsg, UINT nTimerid, DWORD dwTime)
@@ -602,6 +614,57 @@
            }
        }


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

 SourceCode/Bond/Servo/Common.h

@@ -104,6 +104,57 @@
#define STEP_EQ_PORT4_TRANSFER_MODE        _T("EQPort4TransferMode")
#define STEP_EQ_PORT4_ENABLE            _T("EQPort4Enable")
#define STEP_EQ_PORT4_TYPE_ATUO            _T("EQPort4TypeAuto")
#define STEP_EQ_P1_CASSETTE_EMPTY        _T("EQPort1CassetteEmpty")
#define STEP_EQ_P1_CASSETTE_LOAD_EADY    _T("EQPort1CassetteLoadReady")
#define STEP_EQ_P1_CASSETTE_LOADED        _T("EQPort1CassetteLoaded")
#define STEP_EQ_P1_CASSETTE_INUSE        _T("EQPort1CassetteInUse")
#define STEP_EQ_P1_CASSETTE_UNLOAD_EADY    _T("EQPort1CassetteUnloadReady")
#define STEP_EQ_P1_CASSETTE_BLOCKED        _T("EQPort1CassetteBlocked")
#define STEP_EQ_P2_CASSETTE_EMPTY        _T("EQPort2CassetteEmpty")
#define STEP_EQ_P2_CASSETTE_LOAD_EADY    _T("EQPort2CassetteLoadReady")
#define STEP_EQ_P2_CASSETTE_LOADED        _T("EQPort2CassetteLoaded")
#define STEP_EQ_P2_CASSETTE_INUSE        _T("EQPort2CassetteInUse")
#define STEP_EQ_P2_CASSETTE_UNLOAD_EADY    _T("EQPort2CassetteUnloadReady")
#define STEP_EQ_P2_CASSETTE_BLOCKED        _T("EQPort2CassetteBlocked")
#define STEP_EQ_P3_CASSETTE_EMPTY        _T("EQPort3CassetteEmpty")
#define STEP_EQ_P3_CASSETTE_LOAD_EADY    _T("EQPort3CassetteLoadReady")
#define STEP_EQ_P3_CASSETTE_LOADED        _T("EQPort3CassetteLoaded")
#define STEP_EQ_P3_CASSETTE_INUSE        _T("EQPort3CassetteInUse")
#define STEP_EQ_P3_CASSETTE_UNLOAD_EADY    _T("EQPort3CassetteUnloadReady")
#define STEP_EQ_P3_CASSETTE_BLOCKED        _T("EQPort3CassetteBlocked")
#define STEP_EQ_P4_CASSETTE_EMPTY        _T("EQPort4CassetteEmpty")
#define STEP_EQ_P4_CASSETTE_LOAD_EADY    _T("EQPort4CassetteLoadReady")
#define STEP_EQ_P4_CASSETTE_LOADED        _T("EQPort4CassetteLoaded")
#define STEP_EQ_P4_CASSETTE_INUSE        _T("EQPort4CassetteInUse")
#define STEP_EQ_P4_CASSETTE_UNLOAD_EADY    _T("EQPort4CassetteUnloadReady")
#define STEP_EQ_P4_CASSETTE_BLOCKED        _T("EQPort4CassetteBlocked")


/* Step ID */
#define STEP_ID_PORT1_CASSETTIE_EMPTY            0x418
#define STEP_ID_PORT1_CASSETTIE_LOAD_READY        0x420
#define STEP_ID_PORT1_CASSETTIE_LOADED            0x428
#define STEP_ID_PORT1_CASSETTIE_INUSE            0x430
#define STEP_ID_PORT1_CASSETTIE_UNLOAD_READY    0x438
#define STEP_ID_PORT1_CASSETTIE_BLOCKED            0x440
#define STEP_ID_PORT2_CASSETTIE_EMPTY            0x419
#define STEP_ID_PORT2_CASSETTIE_LOAD_READY        0x421
#define STEP_ID_PORT2_CASSETTIE_LOADED            0x429
#define STEP_ID_PORT2_CASSETTIE_INUSE            0x431
#define STEP_ID_PORT2_CASSETTIE_UNLOAD_READY    0x439
#define STEP_ID_PORT2_CASSETTIE_BLOCKED            0x441
#define STEP_ID_PORT3_CASSETTIE_EMPTY            0x41a
#define STEP_ID_PORT3_CASSETTIE_LOAD_READY        0x422
#define STEP_ID_PORT3_CASSETTIE_LOADED            0x42a
#define STEP_ID_PORT3_CASSETTIE_INUSE            0x432
#define STEP_ID_PORT3_CASSETTIE_UNLOAD_READY    0x43a
#define STEP_ID_PORT3_CASSETTIE_BLOCKED            0x442
#define STEP_ID_PORT4_CASSETTIE_EMPTY            0x41b
#define STEP_ID_PORT4_CASSETTIE_LOAD_READY        0x423
#define STEP_ID_PORT4_CASSETTIE_LOADED            0x42b
#define STEP_ID_PORT4_CASSETTIE_INUSE            0x433
#define STEP_ID_PORT4_CASSETTIE_UNLOAD_READY    0x43b
#define STEP_ID_PORT4_CASSETTIE_BLOCKED            0x443


/* base alarm */
@@ -128,4 +179,43 @@
#define FLOW_TEST                    0x1000
#define FLOW_SIGNAL                    0x1001
#define FLOW_DATA                    0x1002
#define FLOW_MOVE_MATERIAL            0x1003
#define FLOW_MOVE_MATERIAL            0x1003


/* Port Status */
#define PORT_LOAD_READY                1
#define PORT_LOADED                    2
#define PORT_INUSE                    3
#define PORT_LOAD_COMPLETE            PORT_INUSE
#define PORT_UNLOAD_READY            4
#define PORT_UNLOAD_REQUEST            PORT_RNLOAD_READY
#define PORT_EMPTY                    5
#define PORT_UNLOAD_COMPLETE        PORT_EMPTY
#define PORT_BLOCKED                6


/* Loading Cassette Type */
#define PORT_LOADING_CASSETTE_ACTUAL    1
#define PORT_LOADING_CASSETTE_EMPTY        2


/* Q-Time flag */
#define Q_TIME_NORMAL                    1
#define Q_TIME_OVER                        2


/* m_nCassetteMappingState */
#define CASSETTE_MAPPING_USE            1
#define CASSETTE_MAPPING_NOT_USE        2


/* Cassette Status */
#define CASSETTE_NO_EXIST                1
#define CASSETTE_WAITING_DATA            2
#define CASSETTE_WAITING_START            3
#define CASSETTE_WAITING_PROCCESSING    4
#define CASSETTE_IN_PROCCESSING            5
#define CASSETTE_PROCCESS_PAUSED        6
#define CASSETTE_PROCCESS_COMPLETED        7



 SourceCode/Bond/Servo/Servo.vcxproj

@@ -204,6 +204,7 @@
    <ClInclude Include="CAttributeVector.h" />
    <ClInclude Include="CBakeCooling.h" />
    <ClInclude Include="CBonder.h" />
    <ClInclude Include="CEqCassetteTransferStateStep.h" />
    <ClInclude Include="CCLinkPerformance\CCLinkIEControl.h" />
    <ClInclude Include="CCLinkPerformance\PerformanceMelsec.h" />
    <ClInclude Include="CEqAlarmStep.h" />
@@ -279,6 +280,7 @@
    <ClCompile Include="CAttributeVector.cpp" />
    <ClCompile Include="CBakeCooling.cpp" />
    <ClCompile Include="CBonder.cpp" />
    <ClCompile Include="CEqCassetteTransferStateStep.cpp" />
    <ClCompile Include="CCLinkPerformance\CCLinkIEControl.cpp" />
    <ClCompile Include="CCLinkPerformance\PerformanceMelsec.cpp" />
    <ClCompile Include="CEqAlarmStep.cpp" />

 SourceCode/Bond/Servo/Servo.vcxproj.filters

@@ -81,6 +81,7 @@
    <ClCompile Include="CHMPropertyDlg.cpp" />
    <ClCompile Include="CEqPortChangeStep.cpp" />
    <ClCompile Include="CEqReadIntStep.cpp" />
    <ClCompile Include="CEqCassetteTransferStateStep.cpp" />
  </ItemGroup>
  <ItemGroup>
    <ClInclude Include="AlarmManager.h" />
@@ -160,6 +161,7 @@
    <ClInclude Include="CHMPropertyDlg.h" />
    <ClInclude Include="CEqPortChangeStep.h" />
    <ClInclude Include="CEqReadIntStep.h" />
    <ClInclude Include="CEqCassetteTransferStateStep.h" />
  </ItemGroup>
  <ItemGroup>
    <ResourceCompile Include="Servo.rc" />