SourceCode/Bond/Servo/CLoadPort.cpp

@@ -378,23 +378,23 @@

        if (ar.IsStoring()) {
            ar << m_nIndex;
            ar << (int)m_portType;
            ar << (int)m_portMode;
            ar << (int)m_cassetteType;
            ar << (int)m_transferMode;
            ar << m_bEnable;
            ar << m_bAutoChangeEnable;
            //ar << (int)m_portType;
            //ar << (int)m_portMode;
            //ar << (int)m_cassetteType;
            //ar << (int)m_transferMode;
            //ar << m_bEnable;
            //ar << m_bAutoChangeEnable;
            m_portStatusReport.serialize(ar);
        }
        else {
            int temp;
            ar >> m_nIndex;
            ar >> temp; m_portType = (PortType)temp;
            ar >> temp; m_portMode = (PortMode)temp;
            ar >> temp; m_cassetteType = (CassetteType)temp;
            ar >> temp; m_transferMode = (TransferMode)temp;
            ar >> m_bEnable;
            ar >> m_bAutoChangeEnable;
            //ar >> temp; m_portType = (PortType)temp;
            //ar >> temp; m_portMode = (PortMode)temp;
            //ar >> temp; m_cassetteType = (CassetteType)temp;
            //ar >> temp; m_transferMode = (TransferMode)temp;
            //ar >> m_bEnable;
            //ar >> m_bAutoChangeEnable;
            m_portStatusReport.serialize(ar);
        }
    }
@@ -1077,6 +1077,36 @@
        return 0;
    }

    void CLoadPort::localEanblePort(BOOL bEnable)
    {
        m_bEnable = bEnable;
    }

    void CLoadPort::localSetPortType(PortType type)
    {
        m_portType = type;
    }

    void CLoadPort::localSetPortMode(PortMode mode)
    {
        m_portMode = mode;
    }

    void CLoadPort::localSetCessetteType(CassetteType type)
    {
        m_cassetteType = type;
    }

    void CLoadPort::localSetTransferMode(TransferMode mode)
    {
        m_transferMode = mode;
    }

    void CLoadPort::localAutoChangeEnable(BOOL bEnable)
    {
        m_bAutoChangeEnable = bEnable;
    }

    /*
     * 生成测试用的玻璃列表
     */

 SourceCode/Bond/Servo/CLoadPort.h

@@ -31,6 +31,12 @@
        int setCassetteType(CassetteType type, ONWRITED onWritedBlock = nullptr);
        int setTransferMode(TransferMode mode, ONWRITED onWritedBlock = nullptr);
        int eableAutoChange(BOOL bEnable, ONWRITED onWritedBlock = nullptr);
        void localEanblePort(BOOL bEnable);
        void localSetPortType(PortType type);
        void localSetPortMode(PortMode mode);
        void localSetCessetteType(CassetteType type);
        void localSetTransferMode(TransferMode mode);
        void localAutoChangeEnable(BOOL bEnable);

    public:
        void setIndex(unsigned int index);

 SourceCode/Bond/Servo/CMaster.cpp

@@ -284,7 +284,6 @@
        // Bonder1和Bonder2需要的G2就过不来了
        // 最基本的实现，可以G2和G2轮流搬送，但最好根据Bonder的需求来决定
        MaterialsType primaryType, secondaryType;
        int armNo = 1;            // 默认使用手臂2


        // 各种机器
@@ -387,7 +386,7 @@
                    if (pEqLoadPort[s]->isEnable()
                        && pEqLoadPort[s]->getPortType() == PortType::Unloading
                        && pEqLoadPort[s]->getPortMode() == PortMode::ReadyToUnload) {
                        m_pActiveRobotTask = createTransferTask(pMeasurement, pEqLoadPort[s], primaryType, secondaryType, armNo);
                        m_pActiveRobotTask = createTransferTask(pMeasurement, pEqLoadPort[s], primaryType, secondaryType);
                        if (m_pActiveRobotTask != nullptr) {
                            goto PORT_PUT;
                        }
@@ -396,7 +395,7 @@

            PORT_PUT:
                if (m_pActiveRobotTask != nullptr) {
                    m_pActiveRobotTask->run();
                    m_pActiveRobotTask->pick();
                    std::string strDescription = m_pActiveRobotTask->getDescription();
                    unlock();
                    if (m_listener.onRobotTaskEvent != nullptr) {
@@ -410,7 +409,7 @@
                // BakeCooling ->Measurement
                m_pActiveRobotTask = createTransferTask_bakecooling_to_measurement(pBakeCooling, pMeasurement);
                if (m_pActiveRobotTask != nullptr) {
                    m_pActiveRobotTask->run();
                    m_pActiveRobotTask->pick();
                    std::string strDescription = m_pActiveRobotTask->getDescription();
                    unlock();
                    if (m_listener.onRobotTaskEvent != nullptr) {
@@ -425,7 +424,7 @@
                // Bake -> Cooling
                m_pActiveRobotTask = createTransferTask_bake_to_cooling(pBakeCooling);
                if (m_pActiveRobotTask != nullptr) {
                    m_pActiveRobotTask->run();
                    m_pActiveRobotTask->pick();
                    std::string strDescription = m_pActiveRobotTask->getDescription();
                    unlock();
                    if (m_listener.onRobotTaskEvent != nullptr) {
@@ -439,7 +438,7 @@
                // Bonder -> BakeCooling
                m_pActiveRobotTask = createTransferTask_bonder_to_bakecooling(pBonder1, pBakeCooling);
                if (m_pActiveRobotTask != nullptr) {
                    m_pActiveRobotTask->run();
                    m_pActiveRobotTask->pick();
                    std::string strDescription = m_pActiveRobotTask->getDescription();
                    unlock();
                    if (m_listener.onRobotTaskEvent != nullptr) {
@@ -451,7 +450,7 @@

                m_pActiveRobotTask = createTransferTask_bonder_to_bakecooling(pBonder2, pBakeCooling);
                if (m_pActiveRobotTask != nullptr) {
                    m_pActiveRobotTask->run();
                    m_pActiveRobotTask->pick();
                    std::string strDescription = m_pActiveRobotTask->getDescription();
                    unlock();
                    if (m_listener.onRobotTaskEvent != nullptr) {
@@ -463,9 +462,9 @@

                // Fliper(G2) -> Bonder
                // VacuumBake(G1) -> Bonder
                m_pActiveRobotTask = createTransferTask(pFliper, pBonder1, primaryType, secondaryType, armNo);
                m_pActiveRobotTask = createTransferTask(pFliper, pBonder1, primaryType, secondaryType, 2);
                if (m_pActiveRobotTask != nullptr) {
                    m_pActiveRobotTask->run();
                    m_pActiveRobotTask->pick();
                    std::string strDescription = m_pActiveRobotTask->getDescription();
                    unlock();
                    if (m_listener.onRobotTaskEvent != nullptr) {
@@ -475,9 +474,9 @@
                    continue;
                }

                m_pActiveRobotTask = createTransferTask(pFliper, pBonder2, primaryType, secondaryType, armNo);
                m_pActiveRobotTask = createTransferTask(pFliper, pBonder2, primaryType, secondaryType, 2);
                if (m_pActiveRobotTask != nullptr) {
                    m_pActiveRobotTask->run();
                    m_pActiveRobotTask->pick();
                    std::string strDescription = m_pActiveRobotTask->getDescription();
                    unlock();
                    if (m_listener.onRobotTaskEvent != nullptr) {
@@ -487,9 +486,9 @@
                    continue;
                }

                m_pActiveRobotTask = createTransferTask(pVacuumBake, pBonder1, primaryType, secondaryType, armNo);
                m_pActiveRobotTask = createTransferTask(pVacuumBake, pBonder1, primaryType, secondaryType);
                if (m_pActiveRobotTask != nullptr) {
                    m_pActiveRobotTask->run();
                    m_pActiveRobotTask->pick();
                    std::string strDescription = m_pActiveRobotTask->getDescription();
                    unlock();
                    if (m_listener.onRobotTaskEvent != nullptr) {
@@ -499,9 +498,9 @@
                    continue;
                }

                m_pActiveRobotTask = createTransferTask(pVacuumBake, pBonder2, primaryType, secondaryType, armNo);
                m_pActiveRobotTask = createTransferTask(pVacuumBake, pBonder2, primaryType, secondaryType);
                if (m_pActiveRobotTask != nullptr) {
                    m_pActiveRobotTask->run();
                    m_pActiveRobotTask->pick();
                    std::string strDescription = m_pActiveRobotTask->getDescription();
                    unlock();
                    if (m_listener.onRobotTaskEvent != nullptr) {
@@ -513,9 +512,9 @@

                // Aligner -> Fliper(G2)
                // Aligner -> VacuumBake(G1)
                m_pActiveRobotTask = createTransferTask(pAligner, pFliper, primaryType, secondaryType, armNo);
                m_pActiveRobotTask = createTransferTask(pAligner, pFliper, primaryType, secondaryType, 2);
                if (m_pActiveRobotTask != nullptr) {
                    m_pActiveRobotTask->run();
                    m_pActiveRobotTask->pick();
                    std::string strDescription = m_pActiveRobotTask->getDescription();
                    unlock();
                    if (m_listener.onRobotTaskEvent != nullptr) {
@@ -525,9 +524,9 @@
                    continue;
                }

                m_pActiveRobotTask = createTransferTask(pAligner, pVacuumBake, primaryType, secondaryType, armNo);
                m_pActiveRobotTask = createTransferTask(pAligner, pVacuumBake, primaryType, secondaryType);
                if (m_pActiveRobotTask != nullptr) {
                    m_pActiveRobotTask->run();
                    m_pActiveRobotTask->pick();
                    std::string strDescription = m_pActiveRobotTask->getDescription();
                    unlock();
                    if (m_listener.onRobotTaskEvent != nullptr) {
@@ -543,7 +542,7 @@
                    if (pEqLoadPort[s]->isEnable()
                        && pEqLoadPort[s]->getPortType() == PortType::Loading
                        && pEqLoadPort[s]->getPortMode() == PortMode::ReadyToLoad) {
                        m_pActiveRobotTask = createTransferTask(pEqLoadPort[s], pAligner, primaryType, secondaryType, armNo);
                        m_pActiveRobotTask = createTransferTask(pEqLoadPort[s], pAligner, primaryType, secondaryType);
                        if (m_pActiveRobotTask != nullptr) {
                            goto PORT_GET;
                        }
@@ -552,7 +551,7 @@

PORT_GET:
                if (m_pActiveRobotTask != nullptr) {
                    m_pActiveRobotTask->run();
                    m_pActiveRobotTask->pick();
                    std::string strDescription = m_pActiveRobotTask->getDescription();
                    unlock();
                    if (m_listener.onRobotTaskEvent != nullptr) {
@@ -678,17 +677,24 @@
            BOOL bOk = FALSE;
            lock();
            if (m_pActiveRobotTask != nullptr) {
                if (m_pActiveRobotTask->getTarPosition() == p->getID()) {
                // 是否已经进入手臂(即取片完成),进入下一步，放片
                if (m_pActiveRobotTask->isPicking() && 
                    ((m_pActiveRobotTask->getArmNo() == 1 && p->getID() == EQ_ID_ARM_TRAY1)
                    || (m_pActiveRobotTask->getArmNo() == 2 && p->getID() == EQ_ID_ARM_TRAY2))
                    ) {
                    slot = 1;
                    bOk = TRUE;
                }

                // 是否放片完成
                else if (m_pActiveRobotTask->isPlacing() &&
                    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();
@@ -711,21 +717,30 @@
            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()) {
                if (m_pActiveRobotTask != nullptr
                    && m_pActiveRobotTask->isPicking()
                    && ((m_pActiveRobotTask->getArmNo() == 1 && p->getID() == EQ_ID_ARM_TRAY1)
                        || (m_pActiveRobotTask->getArmNo() == 2 && p->getID() == EQ_ID_ARM_TRAY2))
                    ) {
                    LOGI("取片完成.");
                    m_pActiveRobotTask->fetchOut();
                    m_pActiveRobotTask->place();
                }

                else if (m_pActiveRobotTask != nullptr
                    && m_pActiveRobotTask->isPlacing() 
                    && m_pActiveRobotTask->getTarPosition() == p->getID()) {
                    m_pActiveRobotTask->stored();
                    m_pActiveRobotTask->completed();
                    LOGI("放片完成...");

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



                    lock();
@@ -1162,11 +1177,14 @@


        if (pSrcSlot != nullptr && nullptr != pTarSlot) {
            int srcPos, srcSlot, tarPos, tarSlot;
            transformPosAndSlot(pSrcSlot->getPosition(), pSrcSlot->getNo(), srcPos, srcSlot);
            transformPosAndSlot(pTarSlot->getPosition(), pTarSlot->getNo(), tarPos, tarSlot);
            pTask = new CRobotTask();
            pTask->setContext(pSrcSlot->getContext());
            pTask->setEFEM((CEFEM*)getEquipment(EQ_ID_EFEM));
            pTask->setRobotTransferParam(++taskSeqNo, armNo, pSrcSlot->getPosition(),
                pTarSlot->getPosition(), pSrcSlot->getNo(), pTarSlot->getNo());
            taskSeqNo = pTask->setRobotTransferParam(taskSeqNo, armNo, srcPos,
                tarPos, srcSlot, tarSlot);
        }


@@ -1183,11 +1201,14 @@
        pSrcSlot = pSrcEq->getProcessedSlot(MaterialsType::G1);

        if (pSrcSlot != nullptr && nullptr != pTarSlot) {
            int srcPos, srcSlot, tarPos, tarSlot;
            transformPosAndSlot(pSrcSlot->getPosition(), pSrcSlot->getNo(), srcPos, srcSlot);
            transformPosAndSlot(pTarSlot->getPosition(), pTarSlot->getNo(), tarPos, tarSlot);
            pTask = new CRobotTask();
            pTask->setContext(pSrcSlot->getContext());
            pTask->setEFEM((CEFEM*)getEquipment(EQ_ID_EFEM));
            pTask->setRobotTransferParam(++taskSeqNo, 1, pSrcSlot->getPosition(),
                pTarSlot->getPosition(), pSrcSlot->getNo(), pTarSlot->getNo());
            taskSeqNo = pTask->setRobotTransferParam(taskSeqNo, 1, srcPos,
                tarPos, srcSlot, tarSlot);
        }


@@ -1205,11 +1226,14 @@
        pSrcSlot = pSrcEq->getProcessedSlot2(MaterialsType::G1, slotsSrc);

        if (pSrcSlot != nullptr && nullptr != pTarSlot) {
            int srcPos, srcSlot, tarPos, tarSlot;
            transformPosAndSlot(pSrcSlot->getPosition(), pSrcSlot->getNo(), srcPos, srcSlot);
            transformPosAndSlot(pTarSlot->getPosition(), pTarSlot->getNo(), tarPos, tarSlot);
            pTask = new CRobotTask();
            pTask->setContext(pSrcSlot->getContext());
            pTask->setEFEM((CEFEM*)getEquipment(EQ_ID_EFEM));
            pTask->setRobotTransferParam(++taskSeqNo, 1, pSrcSlot->getPosition(),
                pTarSlot->getPosition(), pSrcSlot->getNo(), pTarSlot->getNo());
            taskSeqNo = pTask->setRobotTransferParam(taskSeqNo, 1, srcPos,
                tarPos, srcSlot, tarSlot);
        }


@@ -1226,15 +1250,68 @@
        pSrcSlot = pSrcEq->getProcessedSlot2(MaterialsType::G1, slots);

        if (pSrcSlot != nullptr && nullptr != pTarSlot) {
            int srcPos, srcSlot, tarPos, tarSlot;
            transformPosAndSlot(pSrcSlot->getPosition(), pSrcSlot->getNo(), srcPos, srcSlot);
            transformPosAndSlot(pTarSlot->getPosition(), pTarSlot->getNo(), tarPos, tarSlot);
            pTask = new CRobotTask();
            pTask->setContext(pSrcSlot->getContext());
            pTask->setEFEM((CEFEM*)getEquipment(EQ_ID_EFEM));
            pTask->setRobotTransferParam(++taskSeqNo, 1, pSrcSlot->getPosition(),
                pTarSlot->getPosition(), pSrcSlot->getNo(), pTarSlot->getNo());
            taskSeqNo = pTask->setRobotTransferParam(taskSeqNo, 1, srcPos,
                tarPos, srcSlot, tarSlot);
        }


        return pTask;
    }

    void CMaster::transformPosAndSlot(int srcPos, int srcSlot, int& tarPos, int& tarSlot)
    {
        switch (srcPos)
        {
        case EQ_ID_LOADPORT1:
        case EQ_ID_LOADPORT2:
        case EQ_ID_LOADPORT3:
        case EQ_ID_LOADPORT4:
        case EQ_ID_ARM_TRAY1:
        case EQ_ID_ARM_TRAY2:
        case EQ_ID_ALIGNER:
        case EQ_ID_FLIPER:
            tarPos = srcPos;
            tarSlot = 1;
            break;
        case EQ_ID_Bonder1:
            if (1 <= srcSlot && srcSlot <= 2) {
                tarPos = 9 + srcSlot;
                tarSlot = 1;
            }
            break;
        case EQ_ID_Bonder2:
            if (1 <= srcSlot && srcSlot <= 2) {
                tarPos = 11 + srcSlot;
                tarSlot = 1;
            }
            break;
        case EQ_ID_VACUUMBAKE:
            if (1 <= srcSlot && srcSlot <= 2) {
                tarPos = 13 + srcSlot;
                tarSlot = 1;
            }
            break;
        case EQ_ID_BAKE_COOLING:
            if (1 <= srcSlot && srcSlot <= 4) {
                tarPos = 15 + srcSlot;
                tarSlot = 1;
            }
            break;
        case EQ_ID_MEASUREMENT:
            tarPos = 19;
            tarSlot = 1;
            break;
        default:
            tarPos = srcPos;
            tarSlot = srcSlot;
            break;
        }
    }

    int CMaster::abortCurrentTask()
@@ -1261,4 +1338,18 @@

        return 0;
    }

    void CMaster::setPortType(unsigned int index, BOOL enable, int type, int mode,
        int cassetteType, int transferMode, BOOL autoChangeEnable)
    {
        ASSERT(index < 4);
        int eqid[] = { EQ_ID_LOADPORT1, EQ_ID_LOADPORT2, EQ_ID_LOADPORT3, EQ_ID_LOADPORT4};
        CLoadPort* pPort = (CLoadPort*)getEquipment(eqid[index]);
        pPort->localEanblePort(enable);
        pPort->localSetPortType((SERVO::PortType)type);
        pPort->localSetPortMode((SERVO::PortMode)mode);
        pPort->localSetCessetteType((SERVO::CassetteType)cassetteType);
        pPort->localSetTransferMode((SERVO::TransferMode)transferMode);
        pPort->localAutoChangeEnable(autoChangeEnable);
    }
}

 SourceCode/Bond/Servo/CMaster.h

@@ -64,6 +64,8 @@
        CEquipment* getEquipment(int id);
        void setCacheFilepath(const char* pszFilepath);
        int abortCurrentTask();
        void setPortType(unsigned int index, BOOL enable, int type, int mode,
            int cassetteType, int transferMode, BOOL autoChangeEnable);

    private:
        inline void lock() { EnterCriticalSection(&m_criticalSection); }
@@ -91,6 +93,7 @@
        CRobotTask* createTransferTask_bonder_to_bakecooling(CEquipment* pSrcEq, CEquipment* pTarEq);
        CRobotTask* createTransferTask_bake_to_cooling(CEquipment* pSrcEq);
        CRobotTask* createTransferTask_bakecooling_to_measurement(CEquipment* pSrcEq, CEquipment* pTarEq);
        void transformPosAndSlot(int srcPos, int srcSlot, int& tarPos, int& tarSlot);

    private:
        CRITICAL_SECTION m_criticalSection;

 SourceCode/Bond/Servo/CPagePortProperty.cpp

@@ -57,7 +57,7 @@
    CComboBox* pComboBox;
    std::string strTemp;

	
    ((CButton*)GetDlgItem(IDC_CHECK_ENABLE))->SetCheck(m_pPort->isEnable() ? BST_CHECKED : BST_UNCHECKED);
    pComboBox = (CComboBox*)GetDlgItem(IDC_COMBO_PORT_TYPE);
    for (int i = 1; i <= 7; i++) {
        pComboBox->InsertString(i - 1, SERVO::CLoadPort::getPortTypeDescription((SERVO::PortType)i, strTemp).c_str());

 SourceCode/Bond/Servo/CRobotTask.cpp

@@ -28,17 +28,17 @@
    std::string CRobotTask::getDescription() const
    {
        std::string strOut = "CRobotTask<ID:";
        strOut = strOut + std::to_string(m_robotCmdParam.sequenceNo);
        strOut = strOut + std::to_string(m_robotCmdParam[ACTION_TRANSFER].sequenceNo);
        strOut = strOut + ",Arm:";
        strOut = strOut + std::to_string(m_robotCmdParam.armNo);
        strOut = strOut + std::to_string(m_robotCmdParam[ACTION_TRANSFER].armNo);
        strOut = strOut + ",GetPossion:";
        strOut = strOut + std::to_string(m_robotCmdParam.getPosition);
        strOut = strOut + std::to_string(m_robotCmdParam[ACTION_TRANSFER].getPosition);
        strOut = strOut + ",GetSlot:";
        strOut = strOut + std::to_string(m_robotCmdParam.getSlotNo);
        strOut = strOut + std::to_string(m_robotCmdParam[ACTION_TRANSFER].getSlotNo);
        strOut = strOut + ",PutPossion:";
        strOut = strOut + std::to_string(m_robotCmdParam.putPosition);
        strOut = strOut + std::to_string(m_robotCmdParam[ACTION_TRANSFER].putPosition);
        strOut = strOut + ",PutSlot:";
        strOut = strOut + std::to_string(m_robotCmdParam.putSlotNo);
        strOut = strOut + std::to_string(m_robotCmdParam[ACTION_TRANSFER].putSlotNo);
        strOut = strOut + ">";

        return strOut;
@@ -47,17 +47,17 @@
    std::string CRobotTask::getSimpleDescription() const
    {
        std::string strOut = "CRobotTask<ID:";
        strOut = strOut + std::to_string(m_robotCmdParam.sequenceNo);
        strOut = strOut + std::to_string(m_robotCmdParam[ACTION_TRANSFER].sequenceNo);
        strOut = strOut + ",Arm:";
        strOut = strOut + std::to_string(m_robotCmdParam.armNo);
        strOut = strOut + std::to_string(m_robotCmdParam[ACTION_TRANSFER].armNo);
        strOut = strOut + ",GetPossion:";
        strOut = strOut + std::to_string(m_robotCmdParam.getPosition);
        strOut = strOut + std::to_string(m_robotCmdParam[ACTION_TRANSFER].getPosition);
        strOut = strOut + ",GetSlot:";
        strOut = strOut + std::to_string(m_robotCmdParam.getSlotNo);
        strOut = strOut + std::to_string(m_robotCmdParam[ACTION_TRANSFER].getSlotNo);
        strOut = strOut + ",PutPossion:";
        strOut = strOut + std::to_string(m_robotCmdParam.putPosition);
        strOut = strOut + std::to_string(m_robotCmdParam[ACTION_TRANSFER].putPosition);
        strOut = strOut + ",PutSlot:";
        strOut = strOut + std::to_string(m_robotCmdParam.putSlotNo);
        strOut = strOut + std::to_string(m_robotCmdParam[ACTION_TRANSFER].putSlotNo);
        strOut = strOut + ">";

        return strOut;
@@ -104,21 +104,47 @@
        return m_strId;
    }

    void CRobotTask::setRobotTransferParam(int seq, int armNo, int fromPos, int toPos, int fromSlot, int toSlot)
    int CRobotTask::setRobotTransferParam(int seq, int armNo, int fromPos, int toPos, int fromSlot, int toSlot)
    {
        m_robotCmdParam = {};
        m_robotCmdParam.sequenceNo = static_cast<short>(seq);
        m_robotCmdParam.rcmd = static_cast<short>(SERVO::RCMD::Transfer);
        m_robotCmdParam.armNo = static_cast<short>(armNo);
        m_robotCmdParam.getPosition = static_cast<short>(fromPos);
        m_robotCmdParam.getSlotNo = static_cast<short>(fromSlot);
        m_robotCmdParam.putPosition = static_cast<short>(toPos);
        m_robotCmdParam.putSlotNo = static_cast<short>(toSlot);
        // 这是直接使用搬运模式的参数，
        // 如果EFEM不支持，还需要拆解为取和放的动作及回放原位置的其它3套参数
        m_robotCmdParam[ACTION_TRANSFER] = {};
        m_robotCmdParam[ACTION_TRANSFER].sequenceNo = static_cast<short>(seq+1);
        m_robotCmdParam[ACTION_TRANSFER].rcmd = static_cast<short>(SERVO::RCMD::Transfer);
        m_robotCmdParam[ACTION_TRANSFER].armNo = static_cast<short>(armNo);
        m_robotCmdParam[ACTION_TRANSFER].getPosition = static_cast<short>(fromPos);
        m_robotCmdParam[ACTION_TRANSFER].getSlotNo = static_cast<short>(fromSlot);
        m_robotCmdParam[ACTION_TRANSFER].putPosition = static_cast<short>(toPos);
        m_robotCmdParam[ACTION_TRANSFER].putSlotNo = static_cast<short>(toSlot);

        m_robotCmdParam[ACTION_PICK] = {};
        m_robotCmdParam[ACTION_PICK].sequenceNo = static_cast<short>(seq+2);
        m_robotCmdParam[ACTION_PICK].rcmd = static_cast<short>(SERVO::RCMD::Get);
        m_robotCmdParam[ACTION_PICK].armNo = static_cast<short>(armNo);
        m_robotCmdParam[ACTION_PICK].getPosition = static_cast<short>(fromPos);
        m_robotCmdParam[ACTION_PICK].getSlotNo = static_cast<short>(fromSlot);

        m_robotCmdParam[ACTION_PLACE] = {};
        m_robotCmdParam[ACTION_PLACE].sequenceNo = static_cast<short>(seq + 2);
        m_robotCmdParam[ACTION_PLACE].rcmd = static_cast<short>(SERVO::RCMD::Put);
        m_robotCmdParam[ACTION_PLACE].armNo = static_cast<short>(armNo);
        m_robotCmdParam[ACTION_PLACE].putPosition = static_cast<short>(toPos);
        m_robotCmdParam[ACTION_PLACE].putSlotNo = static_cast<short>(toSlot);

        m_robotCmdParam[ACTION_RESTORE] = {};
        m_robotCmdParam[ACTION_RESTORE].sequenceNo = static_cast<short>(seq + 1);
        m_robotCmdParam[ACTION_RESTORE].rcmd = static_cast<short>(SERVO::RCMD::Put);
        m_robotCmdParam[ACTION_RESTORE].armNo = static_cast<short>(armNo);
        m_robotCmdParam[ACTION_RESTORE].putPosition = static_cast<short>(fromPos);
        m_robotCmdParam[ACTION_RESTORE].putSlotNo = static_cast<short>(fromSlot);

        return seq + 1;
    }

    ROBOT_CMD_PARAM& CRobotTask::getRobotCmdParam()
    ROBOT_CMD_PARAM& CRobotTask::getRobotCmdParam(int index)
    {
        return m_robotCmdParam;
        ASSERT(ACTION_PICK <= index && index <= ACTION_TRANSFER);
        return m_robotCmdParam[index];
    }

    time_t CRobotTask::getCreateTime()
@@ -141,9 +167,30 @@
        return m_timeFinish;
    }

    int CRobotTask::getArmNo()
    {
        return m_robotCmdParam[ACTION_PICK].armNo;

    }

    ROBOT_TASK_STATE CRobotTask::getState()
    {
        return m_state;
    }

    bool CRobotTask::isPicking()
    {
        return m_state == ROBOT_TASK_STATE::Picking;
    }

    bool CRobotTask::isPlacing()
    {
        return m_state == ROBOT_TASK_STATE::Placing;
    }

    bool CRobotTask::isRestoring()
    {
        return m_state == ROBOT_TASK_STATE::Restoring;
    }

    void CRobotTask::run()
@@ -153,17 +200,80 @@

        static int seq = 0;
        m_pEFEM->robotSendTransfer(++seq,
            m_robotCmdParam.armNo,
            m_robotCmdParam.getPosition, 
            m_robotCmdParam.putPosition,
            m_robotCmdParam.getSlotNo,
            m_robotCmdParam.putSlotNo, 
            m_robotCmdParam[ACTION_TRANSFER].armNo,
            m_robotCmdParam[ACTION_TRANSFER].getPosition,
            m_robotCmdParam[ACTION_TRANSFER].putPosition,
            m_robotCmdParam[ACTION_TRANSFER].getSlotNo,
            m_robotCmdParam[ACTION_TRANSFER].putSlotNo,
            [&](int code) -> int {
                if (code == WOK) {
                    LOGI(_T("RobotTask已下发到EFEM"));
                }
                else {
                    LOGI(_T("RobotTask已下发失败"));
                }

                return 0;
            });
    }

    void CRobotTask::pick()
    {
        ASSERT(m_pEFEM);
        m_state = ROBOT_TASK_STATE::Picking;

        m_pEFEM->robotSendMoveToGet(m_robotCmdParam->sequenceNo,
            m_robotCmdParam[ACTION_PICK].armNo,
            m_robotCmdParam[ACTION_PICK].getPosition,
            m_robotCmdParam[ACTION_PICK].getSlotNo,
            [&](int code) -> int {
                if (code == WOK) {
                    LOGI(_T("RobotTask/get已下发到EFEM"));
                }
                else {
                    LOGI(_T("RobotTask/get已下发失败"));
                }

                return 0;
            });
    }

    void CRobotTask::place()
    {
        ASSERT(m_pEFEM);
        m_state = ROBOT_TASK_STATE::Placing;

        m_pEFEM->robotSendMoveToPut(m_robotCmdParam->sequenceNo,
            m_robotCmdParam[ACTION_PLACE].armNo,
            m_robotCmdParam[ACTION_PLACE].putPosition,
            m_robotCmdParam[ACTION_PLACE].putSlotNo,
            [&](int code) -> int {
                if (code == WOK) {
                    LOGI(_T("RobotTask/put已下发到EFEM"));
                }
                else {
                    LOGI(_T("RobotTask/put已下发失败"));
                }

                return 0;
            });
    }

    void CRobotTask::restore()
    {
        ASSERT(m_pEFEM);
        m_state = ROBOT_TASK_STATE::Restoring;

        m_pEFEM->robotSendMoveToPut(m_robotCmdParam->sequenceNo,
            m_robotCmdParam[ACTION_RESTORE].armNo,
            m_robotCmdParam[ACTION_RESTORE].putPosition,
            m_robotCmdParam[ACTION_RESTORE].putSlotNo,
            [&](int code) -> int {
                if (code == WOK) {
                    LOGI(_T("RobotTask/restore-put已下发到EFEM"));
                }
                else {
                    LOGI(_T("RobotTask/restore-put已下发失败"));
                }

                return 0;
@@ -187,22 +297,22 @@

    int CRobotTask::getSrcPosition()
    {
        return m_robotCmdParam.getPosition;
        return m_robotCmdParam[ACTION_TRANSFER].getPosition;
    }

    int CRobotTask::getTarPosition()
    {
        return m_robotCmdParam.putPosition;
        return m_robotCmdParam[ACTION_TRANSFER].putPosition;
    }

    int CRobotTask::getSrcSlot()
    {
        return m_robotCmdParam.getSlotNo;
        return m_robotCmdParam[ACTION_TRANSFER].getSlotNo;
    }

    int CRobotTask::getTarSlot()
    {
        return m_robotCmdParam.putSlotNo;
        return m_robotCmdParam[ACTION_TRANSFER].putSlotNo;
    }

    CString CRobotTask::getStateString()
@@ -210,6 +320,9 @@
        switch (m_state) {
        case ROBOT_TASK_STATE::Ready:     return _T("Ready");
        case ROBOT_TASK_STATE::Running:   return _T("Running");
        case ROBOT_TASK_STATE::Picking:   return _T("Picking");
        case ROBOT_TASK_STATE::Placing:   return _T("Placing");
        case ROBOT_TASK_STATE::Restoring: return _T("Restoring");
        case ROBOT_TASK_STATE::Error:     return _T("Error");
        case ROBOT_TASK_STATE::Abort:     return _T("Abort");
        case ROBOT_TASK_STATE::Completed: return _T("Completed");

 SourceCode/Bond/Servo/CRobotTask.h

@@ -4,6 +4,11 @@
#include "CEFEM.h"


#define ACTION_PICK            0            /* ȡ */
#define ACTION_PLACE        1            /* 放 */
#define ACTION_RESTORE        2            /* 回原点 */
#define ACTION_TRANSFER        3            /* 搬运 */

namespace SERVO {
    class CRobotTask
    {
@@ -18,14 +23,21 @@
        void setContext(CContext* pContext);
        CContext* getContext();
        void setEFEM(CEFEM* pEFEM);
        void setRobotTransferParam(int seq, int armNo, int fromPos, int toPos, int fromSlot, int toSlot);
        ROBOT_CMD_PARAM& getRobotCmdParam();
        int setRobotTransferParam(int seq, int armNo, int fromPos, int toPos, int fromSlot, int toSlot);
        ROBOT_CMD_PARAM& getRobotCmdParam(int index);
        time_t getCreateTime();
        time_t getFetchoutTime();
        time_t getStoredTime();
        time_t getFinishTime();
        int getArmNo();
        ROBOT_TASK_STATE getState();
        bool isPicking();
        bool isPlacing();
        bool isRestoring();
        void run();
        void pick();
        void place();
        void restore();
        void completed();
        void error();
        void abort();
@@ -51,7 +63,7 @@
        time_t m_timeFetchOut;                        /* 取片时间*/
        time_t m_timeStored;                        /* 放片时间 */
        time_t m_timeFinish;                        /* 结束时间 */
        ROBOT_CMD_PARAM m_robotCmdParam;            /* 参数 */
        ROBOT_CMD_PARAM m_robotCmdParam[4];            /* 参数 */
        CContext* m_pContext;
        CEFEM* m_pEFEM;
    };

 SourceCode/Bond/Servo/CRobotTaskDlg.cpp

@@ -58,7 +58,7 @@
        CEquipment* pSrcEq = theApp.m_model.getMaster().getEquipment(pRobotTask->getSrcPosition());
        CEquipment* pDstEq = theApp.m_model.getMaster().getEquipment(pRobotTask->getTarPosition());

        ROBOT_CMD_PARAM& param = pRobotTask->getRobotCmdParam();
        ROBOT_CMD_PARAM& param = pRobotTask->getRobotCmdParam(ACTION_TRANSFER);

        auto format_time = [](time_t t) -> CString {
            if (t == 0) {

 SourceCode/Bond/Servo/Configuration.cpp

@@ -103,3 +103,25 @@
        std::to_string(second).c_str(), m_strFilepath);
}

BOOL CConfiguration::getPortParms(unsigned int index, BOOL& bEnable, int& type, int& mode,
    int& cassetteType, int& transferMode, BOOL& bAutoChangeEnable)
{
    if (index >= 4) return FALSE;

    static char* pszSection[] = {"Port1", "Port2", "Port3", "Port4"};
    bEnable = GetPrivateProfileInt(pszSection[index], _T("Enable"), 0, m_strFilepath) == 1;
    type = GetPrivateProfileInt(pszSection[index], _T("Type"), 0, m_strFilepath);
    mode = GetPrivateProfileInt(pszSection[index], _T("Mode"), 0, m_strFilepath);
    cassetteType = GetPrivateProfileInt(pszSection[index], _T("CassetteType"), 0, m_strFilepath);
    transferMode = GetPrivateProfileInt(pszSection[index], _T("TransferMode"), 0, m_strFilepath);
    bAutoChangeEnable = GetPrivateProfileInt(pszSection[index], _T("AutoChangeEnable"), 0, m_strFilepath) == 1;

    // type, mode, cassetteType, transferMode 范围检查
    type = max(1, min(type, 7));
    mode = max(0, min(mode, 5));
    cassetteType = max(1, min(cassetteType, 3));
    transferMode = max(1, min(transferMode, 3));

    return TRUE;
}


 SourceCode/Bond/Servo/Configuration.h

@@ -20,6 +20,8 @@
    void setLogcatIncludeRegex(BOOL bRegex);
    BOOL isLogcatIncludeRegex();
    int getCustomLogcatIncludeTexts(std::vector<std::string>& texts);
    BOOL getPortParms(unsigned int index, BOOL& bEnable, int& type, int& mode,
        int& cassetteType, int& transferMode, BOOL& bAutoChangeEnable);

public:
    void setP2RemoteEqReconnectInterval(int second);

 SourceCode/Bond/Servo/Model.cpp

@@ -40,6 +40,18 @@
    m_strWorkDir = pszWorkDir;
}

void CModel::loadPortParams()
{
    BOOL portEnable, autoChangeEnable;
    int portType, portMode, cassetteType, transferMode;
    for (int i = 0; i < 4; i++) {
        m_configuration.getPortParms(i, portEnable, portType, portMode,
            cassetteType, transferMode, autoChangeEnable);
        m_master.setPortType(i, portEnable, portType, portMode, cassetteType,
            transferMode, autoChangeEnable);
    }
}

int CModel::init()
{
    CString strIniFile;
@@ -188,7 +200,6 @@
            break;
        case ROBOT_EVENT_FINISH:
            LOGI("<CModel>onRobotTaskEvent: 任务完成(%s, ClassID=%s).", strDesc.c_str(), strClassID.c_str());
            pTask->completed();
            break;
        case ROBOT_EVENT_ERROR:
            LOGE("<CModel>onRobotTaskEvent: 任务错误(%s, ClassID=%s).", strDesc.c_str(), strClassID.c_str());

 SourceCode/Bond/Servo/Model.h

@@ -14,6 +14,7 @@
    IObservable* getObservable();
    SERVO::CMaster& getMaster();
    void setWorkDir(const char* pszWorkDir);
    void loadPortParams();
    int init();
    int term();


 SourceCode/Bond/Servo/ServoCommo.h

@@ -110,6 +110,9 @@
    enum class ROBOT_TASK_STATE {
        Ready = 0,
        Running,
        Picking,
        Placing,
        Restoring,
        Error,
        Abort,
        Completed

 SourceCode/Bond/Servo/ServoDlg.cpp

@@ -349,6 +349,7 @@

    // 相当于延时调用master的初始化
    theApp.m_model.m_master.init();
    theApp.m_model.loadPortParams();


    // 初始化master以后需要控件绑定数据