Merge branch 'clh' into liuyang

mrDarker

2025-06-16 56fd8f57fcc763ae079ae752d82e41b38d7d9e5f

Merge branch 'clh' into liuyang

 SourceCode/Bond/Servo/CBonder.cpp

@@ -34,7 +34,8 @@
    {
        // 加入Pin初始化代码
        LOGI("<CBonder>initPins");
        addPin(SERVO::PinType::INPUT, _T("In"));
        addPin(SERVO::PinType::INPUT, _T("In1"));
        addPin(SERVO::PinType::INPUT, _T("In2"));
        addPin(SERVO::PinType::OUTPUT, _T("Out"));
    }


 SourceCode/Bond/Servo/CFliper.cpp

@@ -33,9 +33,9 @@
    {
        // 加入Pin初始化代码
        LOGI("<CFliper>initPins");
        addPin(SERVO::PinType::INPUT, _T("In1"));
        addPin(SERVO::PinType::INPUT, _T("In2"));
        addPin(SERVO::PinType::OUTPUT, _T("Out"));
        addPin(SERVO::PinType::INPUT, _T("In"));
        addPin(SERVO::PinType::OUTPUT, _T("Out1"));
        addPin(SERVO::PinType::OUTPUT, _T("Out2"));
    }

    // 必须要实现的虚函数，在此初始化Slot信息

 SourceCode/Bond/Servo/CLoadPort.cpp

@@ -51,8 +51,7 @@
        // 加入Pin初始化代码
        LOGI("<CLoadPort>initPins");
        addPin(SERVO::PinType::INPUT, _T("In"));
        addPin(SERVO::PinType::OUTPUT, _T("Out1"));
        addPin(SERVO::PinType::OUTPUT, _T("Out2"));
        addPin(SERVO::PinType::OUTPUT, _T("Out"));
    }

    // 必须要实现的虚函数，在此初始化Slot信息
@@ -379,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);
        }
    }
@@ -1078,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

@@ -293,7 +293,7 @@
        CLoadPort* pLoadPort3 = (CLoadPort*)getEquipment(EQ_ID_LOADPORT3);
        CLoadPort* pLoadPort4 = (CLoadPort*)getEquipment(EQ_ID_LOADPORT4);
        CFliper* pFliper = (CFliper*)getEquipment(EQ_ID_FLIPER);
        CVacuumBake* pVacuumBack = (CVacuumBake*)getEquipment(EQ_ID_VACUUMBAKE);
        CVacuumBake* pVacuumBake = (CVacuumBake*)getEquipment(EQ_ID_VACUUMBAKE);
        CAligner* pAligner = (CAligner*)getEquipment(EQ_ID_ALIGNER);
        CBonder* pBonder1 = (CBonder*)getEquipment(EQ_ID_Bonder1);
        CBonder* pBonder2 = (CBonder*)getEquipment(EQ_ID_Bonder2);
@@ -306,7 +306,7 @@
        ASSERT(pLoadPort3);
        ASSERT(pLoadPort4);
        ASSERT(pFliper);
        ASSERT(pVacuumBack);
        ASSERT(pVacuumBake);
        ASSERT(pAligner);
        ASSERT(pBonder1);
        ASSERT(pBonder2);
@@ -377,10 +377,10 @@

                // Measurement -> LoadPort
                CLoadPort* pEqLoadPort[] = { pLoadPort1, pLoadPort2, pLoadPort3, pLoadPort4 };
                CEquipment* pEqTar[] = { pVacuumBack, pFliper };
                CEquipment* pEqTar[] = { pVacuumBake, pFliper };
                if (primaryType == MaterialsType::G2) {
                    pEqTar[0] = pFliper;
                    pEqTar[1] = pVacuumBack;
                    pEqTar[1] = pVacuumBake;
                }
                for (int s = 0; s < 4; s++) {
                    if (pEqLoadPort[s]->isEnable()
@@ -395,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) {
@@ -409,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) {
@@ -424,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) {
@@ -438,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) {
@@ -450,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) {
@@ -460,10 +460,11 @@
                    continue;
                }

                // Aligner -> Bonder
                m_pActiveRobotTask = createTransferTask(pAligner, pBonder1, primaryType, secondaryType);
                // Fliper(G2) -> Bonder
                // VacuumBake(G1) -> Bonder
                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) {
@@ -473,9 +474,9 @@
                    continue;
                }

                m_pActiveRobotTask = createTransferTask(pAligner, pBonder2, primaryType, secondaryType);
                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) {
@@ -485,12 +486,9 @@
                    continue;
                }


                // Fliper(G2) -> Aligner
                // VacuumBake(G1) -> Aligner
                m_pActiveRobotTask = createTransferTask(pFliper, pAligner, primaryType, secondaryType);
                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) {
@@ -500,9 +498,35 @@
                    continue;
                }

                m_pActiveRobotTask = createTransferTask(pVacuumBack, pAligner, primaryType, secondaryType);
                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) {
                        m_listener.onRobotTaskEvent(this, m_pActiveRobotTask, ROBOT_EVENT_CREATE);
                    }
                    LOGI("创建新任务<%s>...", strDescription.c_str());
                    continue;
                }

                // Aligner -> Fliper(G2)
                // Aligner -> VacuumBake(G1)
                m_pActiveRobotTask = createTransferTask(pAligner, pFliper, primaryType, secondaryType, 2);
                if (m_pActiveRobotTask != nullptr) {
                    m_pActiveRobotTask->pick();
                    std::string strDescription = m_pActiveRobotTask->getDescription();
                    unlock();
                    if (m_listener.onRobotTaskEvent != nullptr) {
                        m_listener.onRobotTaskEvent(this, m_pActiveRobotTask, ROBOT_EVENT_CREATE);
                    }
                    LOGI("创建新任务<%s>...", strDescription.c_str());
                    continue;
                }

                m_pActiveRobotTask = createTransferTask(pAligner, pVacuumBake, primaryType, secondaryType);
                if (m_pActiveRobotTask != nullptr) {
                    m_pActiveRobotTask->pick();
                    std::string strDescription = m_pActiveRobotTask->getDescription();
                    unlock();
                    if (m_listener.onRobotTaskEvent != nullptr) {
@@ -513,24 +537,21 @@
                }


                // LoadPort -> Fliper(G2)
                // LoadPort -> VacuumBake(G1)
                // LoadPort -> Aligner
                for (int s = 0; s < 4; s++) {
                    for (int t = 0; t < 2; t++) {
                        if (pEqLoadPort[s]->isEnable()
                            && pEqLoadPort[s]->getPortType() == PortType::Loading
                            && pEqLoadPort[s]->getPortMode() == PortMode::ReadyToLoad) {
                            m_pActiveRobotTask = createTransferTask(pEqLoadPort[s], pEqTar[t], primaryType, secondaryType);
                        m_pActiveRobotTask = createTransferTask(pEqLoadPort[s], pAligner, primaryType, secondaryType);
                            if (m_pActiveRobotTask != nullptr) {
                                goto PORT_GET;
                            }
                        }
                    }
                }

PORT_GET:
                if (m_pActiveRobotTask != nullptr) {
                    m_pActiveRobotTask->run();
                    m_pActiveRobotTask->pick();
                    std::string strDescription = m_pActiveRobotTask->getDescription();
                    unlock();
                    if (m_listener.onRobotTaskEvent != nullptr) {
@@ -664,17 +685,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();
@@ -697,21 +725,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();
@@ -988,42 +1025,40 @@
        CBakeCooling* pBakeCooling = (CBakeCooling*)getEquipment(EQ_ID_BAKE_COOLING);
        CMeasurement* pMeasurement = (CMeasurement*)getEquipment(EQ_ID_MEASUREMENT);

        nRet = pLoadPort1->getPin("Out1")->connectPin(pFliper->getPin("In1"));
        nRet = pLoadPort1->getPin("Out")->connectPin(pAligner->getPin("In1"));
        if (nRet < 0) {
            LOGE("连接LoadPort1-Fliper失败");
        }
        nRet = pLoadPort2->getPin("Out1")->connectPin(pFliper->getPin("In2"));
        nRet = pLoadPort2->getPin("Out")->connectPin(pAligner->getPin("In2"));
        if (nRet < 0) {
            LOGE("连接LoadPort1-Fliper失败");
        }

        nRet = pLoadPort1->getPin("Out2")->connectPin(pVacuumBake->getPin("In1"));
        nRet = pAligner->getPin("Out1")->connectPin(pFliper->getPin("In"));
        if (nRet < 0) {
            LOGE("连接LoadPort1-VacuumBake失败");
            LOGE("连接Aligner-Fliper失败");
        }
        nRet = pLoadPort2->getPin("Out2")->connectPin(pVacuumBake->getPin("In2"));
        nRet = pAligner->getPin("Out2")->connectPin(pVacuumBake->getPin("In"));
        if (nRet < 0) {
            LOGE("连接LoadPort1-VacuumBake失败");
            LOGE("连接Aligner-VacuumBake失败");
        }

        nRet = pFliper->getPin("Out")->connectPin(pAligner->getPin("In1"));
        nRet = pFliper->getPin("Out1")->connectPin(pBonder1->getPin("In1"));
        if (nRet < 0) {
            LOGE("连接Fliper-Aligner失败");
            LOGE("连接Fliper-Bonder1失败");
        }
        nRet = pFliper->getPin("Out2")->connectPin(pBonder2->getPin("In1"));
        if (nRet < 0) {
            LOGE("连接Fliper-Bonder2失败");
        }

        nRet = pVacuumBake->getPin("Out")->connectPin(pAligner->getPin("In2"));
        nRet = pVacuumBake->getPin("Out1")->connectPin(pBonder1->getPin("In2"));
        if (nRet < 0) {
            LOGE("连接VacuumBake-Aligner失败");
            LOGE("连接VacuumBake-Bonder1失败");
        }

        nRet = pAligner->getPin("Out1")->connectPin(pBonder1->getPin("In"));
        nRet = pVacuumBake->getPin("Out2")->connectPin(pBonder2->getPin("In2"));
        if (nRet < 0) {
            LOGE("连接Aligner-Bondere1失败");
        }

        nRet = pAligner->getPin("Out2")->connectPin(pBonder2->getPin("In"));
        if (nRet < 0) {
            LOGE("连接Aligner-Bondere2失败");
            LOGE("连接VacuumBake-Bonder2失败");
        }

        nRet = pBonder1->getPin("Out")->connectPin(pBakeCooling->getPin("In1"));
@@ -1136,7 +1171,8 @@

    static int taskSeqNo = 0;
    CRobotTask* CMaster::createTransferTask(CEquipment* pSrcEq, CEquipment* pTarEq,
        MaterialsType primaryType/* = MaterialsType::G1*/, MaterialsType secondaryType/* = MaterialsType::G2*/)
        MaterialsType primaryType/* = MaterialsType::G1*/, MaterialsType secondaryType/* = MaterialsType::G2*/,
        int armNo/* = 1*/)
    {
        CRobotTask* pTask = nullptr;
        CSlot* pSrcSlot, * pTarSlot;
@@ -1149,11 +1185,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, 1, pSrcSlot->getPosition(),
                pTarSlot->getPosition(), pSrcSlot->getNo(), pTarSlot->getNo());
            taskSeqNo = pTask->setRobotTransferParam(taskSeqNo, armNo, srcPos,
                tarPos, srcSlot, tarSlot);
        }


@@ -1170,11 +1209,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);
        }


@@ -1192,11 +1234,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);
        }


@@ -1213,15 +1258,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()
@@ -1248,4 +1346,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); }
@@ -86,10 +88,12 @@
        void serialize(CArchive& ar);
        void setState(MASTERSTATE state);
        CRobotTask* createTransferTask(CEquipment* pSrcEq, CEquipment* pTarEq,
            MaterialsType primaryType = MaterialsType::G1, MaterialsType secondaryType = MaterialsType::G2);
            MaterialsType primaryType = MaterialsType::G1, MaterialsType secondaryType = MaterialsType::G2,
            int armNo = 1);
        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/CVacuumBake.cpp

@@ -33,9 +33,9 @@
    {
        // 加入Pin初始化代码
        LOGI("<CVacuumBake>initPins");
        addPin(SERVO::PinType::INPUT, _T("In1"));
        addPin(SERVO::PinType::INPUT, _T("In2"));
        addPin(SERVO::PinType::OUTPUT, _T("Out"));
        addPin(SERVO::PinType::INPUT, _T("In"));
        addPin(SERVO::PinType::OUTPUT, _T("Out1"));
        addPin(SERVO::PinType::OUTPUT, _T("Out2"));
    }

    void CVacuumBake::initSteps()

 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以后需要控件绑定数据

 SourceCode/Bond/x64/Debug/EqsGraph.ini

@@ -23,8 +23,8 @@
Left=279
Top=297
[Aligner]
Left=446
Top=363
Left=210
Top=317
[VacuumBake]
Left=279
Top=437
@@ -41,11 +41,11 @@
Left=467
Top=167
[Fliper(G2)]
Left=238
Top=251
Left=413
Top=285
[VacuumBake(G1)]
Left=238
Top=386
Left=413
Top=437
[Measurement]
Left=1041
Top=363