Document/ESWIN_EAS_Bonder_Inline_Mapping_Address_v1.1.7(1).xlsx

Binary files differ

 Document/ESWIN_EAS_Bonder_Inline_Mapping_Address_v1.1.7.xlsx

Binary files differ

 SourceCode/Bond/Servo/CArm.cpp

@@ -41,10 +41,6 @@
        m_slot[0].setPosition(m_nID);
        m_slot[0].setNo(1);
        m_slot[0].setName("Slot 1(Temp)");
        m_slot[1].enable();
        m_slot[1].setPosition(m_nID);
        m_slot[1].setNo(2);
        m_slot[1].setName("Slot 2(Temp)");
    }

    void CArm::onTimer(UINT nTimerid)
@@ -70,22 +66,14 @@
    int CArm::tempStore(CGlass* pGlass)
    {
        // åŽŸï¼šä¿è¯åˆ—表中只存储一个物料
        // ä¿®æ”¹ä¸ºï¼šå…ˆæ¸…空之前的，再添加当前pGlass, å¦‚æžœpGlass有buddy，也要加入列表中
        // ä¿®æ”¹ä¸ºï¼šå…ˆæ¸…空之前的，再添加当前pGlass
        Lock();
        CGlass* pPreviousGlass;
        pPreviousGlass = (CGlass*)m_slot[0].getContext();
        if (pPreviousGlass != nullptr) {
            pPreviousGlass->release();
        }
        pPreviousGlass = (CGlass*)m_slot[1].getContext();
        if (pPreviousGlass != nullptr) {
            pPreviousGlass->release();
        }

        m_slot[0].setContext(pGlass);
        if (pGlass->getBuddy() != nullptr) {
            m_slot[1].setContext(pGlass->getBuddy());
        }
        Unlock();

        if (m_listener.onDataChanged != nullptr) {
@@ -106,10 +94,6 @@
        pGlass = pPreviousGlass;
        pGlass->addRef();
        m_slot[0].setContext(nullptr);
        CGlass* pBuddy = pGlass->getBuddy();
        if (pBuddy != nullptr) {
            m_slot[1].setContext(nullptr);
        }
        Unlock();

        if (m_listener.onDataChanged != nullptr) {

 SourceCode/Bond/Servo/CArmTray.cpp

@@ -41,10 +41,6 @@
        m_slot[0].setPosition(m_nID);
        m_slot[0].setNo(1);
        m_slot[0].setName("Slot 1");
        m_slot[1].enable();
        m_slot[1].setPosition(m_nID);
        m_slot[1].setNo(2);
        m_slot[1].setName("Slot 2");
    }

    void CArmTray::onTimer(UINT nTimerid)

 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"));
    }

@@ -415,6 +416,14 @@
        return m_nIndex;
    }

    BOOL CBonder::hasBondClass()
    {
        CGlass* pGlass = (CGlass*)m_slot[1].getContext();
        if (pGlass == nullptr) return FALSE;
        CGlass* pBuddy = pGlass->getBuddy();
        return pBuddy != nullptr;
    }

    int CBonder::onProcessData(CProcessData* pProcessData)
    {
        CEquipment::onProcessData(pProcessData);
@@ -422,33 +431,27 @@

        // æ£€æŸ¥æ•°æ®ï¼Œå½“前两片玻璃，一片为G1, ä¸€ç‰‡ä¸ºG2, ä¸”pProcessData中的id能匹配G1或G2
        Lock();
        CGlass* pGlass1 = getGlassFromSlot(1);
        CGlass* pGlass2 = getGlassFromSlot(2);
        CGlass* pGlass2 = getGlassFromSlot(1);
        CGlass* pGlass1 = getGlassFromSlot(2);
        if (pGlass1 == nullptr || pGlass2 == nullptr) {
            LOGE("<CBonder-%s>onProcessData,错误!不满足两片玻璃且分别为G1与G2的条件，请检查数据是否正确!", m_strName.c_str());
            Unlock();
            return -1;
        }
        if (pGlass1->getBuddy() != nullptr || pGlass2->getBuddy() != nullptr) {
        if (pGlass1->getBuddy() != nullptr) {
            LOGE("<CBonder-%s>onProcessData,错误!玻璃较早前已被绑定，请检查数据是否正确!", m_strName.c_str());
            Unlock();
            return -1;
        }

        if (pGlass1->getBuddy() != nullptr || pGlass2->getBuddy() != nullptr) {
            LOGE("<CBonder-%s>onProcessData,错误!玻璃较早前已被贴合，请检查数据是否正确!", m_strName.c_str());
            Unlock();
            return -1;
        }

        if (pGlass1->getType() == pGlass2->getType()) {
        if (pGlass1->getType() != MaterialsType::G1 || pGlass2->getType() != MaterialsType::G2) {
            LOGE("<CBonder-%s>onProcessData,错误!两片玻璃未匹配，必须分别为G1和G2类型，请检查数据是否正确!", m_strName.c_str());
            Unlock();
            return -1;
        }

        pGlass1->setBuddy(pGlass2);
        pGlass2->setBuddy(pGlass1);
        getSlot(0)->setContext(nullptr);
        LOGE("<CBonder-%s>onProcessData,%s和%s已贴合!", m_strName.c_str(),
            pGlass1->getID().c_str(), pGlass2->getID().c_str());
        Unlock();

 SourceCode/Bond/Servo/CBonder.h

@@ -27,6 +27,7 @@
    public:
        void setIndex(unsigned int index);
        unsigned int getIndex();
        BOOL hasBondClass();

    private:
        unsigned int m_nIndex;

 SourceCode/Bond/Servo/CEFEM.cpp

@@ -22,6 +22,10 @@
        m_pPort[3] = nullptr;
        m_pAligner = nullptr;
        m_pFliper = nullptr;
        m_robotData.status = ROBOT_STATUS::Idle;
        m_robotData.position = ROBOT_POSITION::Port1;
        m_robotData.armState[0] = FALSE;
        m_robotData.armState[1] = FALSE;
    }

    CEFEM::~CEFEM()
@@ -329,6 +333,11 @@
        cmds[1].rcmd = static_cast<short>(SERVO::RCMD::Robot_home);

        return robotCmds(cmds, 2, onWritedBlock);
    }

    RMDATA& CEFEM::getRobotMonitoringData()
    {
        return m_robotData;
    }

    void CEFEM::init()
@@ -692,6 +701,28 @@
    {
        __super::onReceiveLBData(pszData, size);

        // è§£é‡Šå¾—到Robot状态
        // åœ°å€ä»Ž(0x3500 - 0x3000)开始
        int index = 0x500;
        for (int i = 0; i < 6; i++) {
            if (isBitOn(pszData, size, index + i)) {
                m_robotData.status = (ROBOT_STATUS)i;
                break;
            }
        }
        index += 8;

        for (int i = 0; i < 11; i++) {
            if (isBitOn(pszData, size, index + i)) {
                m_robotData.position = (ROBOT_POSITION)i;
                break;
            }
        }
        index += 16;
        m_robotData.armState[0] = isBitOn(pszData, size, index);
        m_robotData.armState[1] = isBitOn(pszData, size, index + 1);


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

 SourceCode/Bond/Servo/CEFEM.h

@@ -39,6 +39,7 @@
        void setArmTray(unsigned int index, CArmTray* pArmTray);
        int robotCmd(ROBOT_CMD_PARAM& robotCmdParam, ONWRITED onWritedBlock = nullptr);
        int robotCmds(ROBOT_CMD_PARAM* robotCmdParam, unsigned int count, ONWRITED onWritedBlock = nullptr);
        RMDATA& getRobotMonitoringData();

        // å¿«æ·å°è£…
        int robotSendHome(int seq, ONWRITED onWritedBlock = nullptr);
@@ -62,6 +63,7 @@
        CAligner* m_pAligner;
        CFliper* m_pFliper;
        CArmTray* m_pArmTray[2];
        RMDATA m_robotData;
    };
}


 SourceCode/Bond/Servo/CEquipment.cpp

@@ -255,13 +255,21 @@
            if (!m_slot[i].isEnable()) continue;

            CGlass* pGlass = (CGlass*)m_slot[i].getContext();
            CGlass* pBuddy = nullptr;
            if (pGlass == nullptr) {
                attrubutes.addAttribute(new CAttribute(m_slot[i].getName().c_str(),
                    "", "", weight++));
            }
            else {
                attrubutes.addAttribute(new CAttribute(m_slot[i].getName().c_str(),
                    pGlass->getID().c_str(), "", weight++));
                pBuddy = pGlass->getBuddy();
                if (pBuddy == nullptr) {
                    attrubutes.addAttribute(new CAttribute(m_slot[i].getName().c_str(),
                        pGlass->getID().c_str(), "", weight++));
                }
                else {
                    attrubutes.addAttribute(new CAttribute(m_slot[i].getName().c_str(),
                        (pGlass->getID() + " -> " + pBuddy->getID()).c_str(), "", weight++));
                }
            }

        }
@@ -317,8 +325,13 @@
            Lock();
            for (int i = 0; i < SLOT_MAX; i++) {
                m_slot[i].serialize(ar);
                if (m_slot[i].getContext() != nullptr) {
                    ((CGlass*)m_slot[i].getContext())->serialize(ar);
                CGlass* pGlass = (CGlass *)m_slot[i].getContext();
                if (pGlass != nullptr) {					
                    pGlass->serialize(ar);
                    CGlass* pBuddy = pGlass->getBuddy();
                    if (pBuddy != nullptr) {
                        pBuddy->serialize(ar);
                    }
                }
            }
            Unlock();
@@ -330,10 +343,16 @@
                    CGlass* pGlass = theApp.m_model.m_glassPool.allocaGlass();
                    pGlass->serialize(ar);
                    m_slot[i].setContext(pGlass);
                    if (pGlass->getBuddy() != nullptr) {
                        CGlass* pBuddy = theApp.m_model.m_glassPool.allocaGlass();
                        pBuddy->serialize(ar);
                        pGlass->forceSetBuddy(pBuddy);
                    }
                }
            }
            
            // æ¢³ç†å„玻璃之间的绑定关系
            /*
            Lock();
            for (int i = 0; i < SLOT_MAX; i++) {
                CGlass* pGlass = (CGlass*)m_slot[i].getContext();
@@ -351,6 +370,7 @@
                }
            }
            Unlock();
            */
        }
    }

@@ -770,18 +790,6 @@
            return -3;
        }

        // å¦‚果此玻璃已经贴合，贴合的玻璃也要从列表中移除
        CGlass* pBuddy = pContext->getBuddy();
        if (pBuddy != nullptr) {
            for (int i = 0; i < SLOT_MAX; i++) {
                CGlass* pGlass = (CGlass*)m_slot[i].getContext();
                if (pGlass != nullptr && compareJobDataB(pBuddy->getJobDataB(), pGlass->getJobDataB())) {
                    m_slot[i].setContext(nullptr);
                    break;
                }
            }
        }


        ((CArm*)m_pArm)->tempStore(pContext);
        pContext->release();
@@ -815,6 +823,7 @@


        // å¦‚果此玻璃已经贴合，贴合的玻璃也要从加入到列表中
        /*
        CGlass* pBuddy = pGlass->getBuddy();
        if (pBuddy != nullptr) {
            Lock();
@@ -827,7 +836,7 @@
            }
            Unlock();
        }

        */

        if (m_listener.onDataChanged != nullptr) {
            m_listener.onDataChanged(this, EDCC_STORED_JOB);

 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/CGlass.cpp

@@ -135,7 +135,7 @@
            m_jobDataB.unserialize(temp, JOBDATAB_SIZE);
            ar.Read(temp, JOBDATAS_SIZE);
            m_jobDataS.unserialize(temp, JOBDATAS_SIZE);
            ar >> ullPath;                    // è¿™æ˜¯m_pBuddy, ç”¨ä¸ä¸Š
            ar >> ullPath;    m_pBuddy = (CGlass*)ullPath;
            ReadString(ar, m_strBuddyId);
            Unlock();
        }
@@ -166,9 +166,16 @@
        if (m_pBuddy != nullptr) return FALSE;
        if (pGlass->getType() == this->getType()) return FALSE;
        m_pBuddy = pGlass;
        if (m_type == MaterialsType::G1) {
            m_pBuddy->addRef();
        }
        m_pBuddy->addRef();
        m_strBuddyId = m_pBuddy->getID();

        return TRUE;
    }

    BOOL CGlass::forceSetBuddy(CGlass* pGlass)
    {
        m_pBuddy = pGlass;
        m_pBuddy->addRef();
        m_strBuddyId = m_pBuddy->getID();

        return TRUE;

 SourceCode/Bond/Servo/CGlass.h

@@ -33,6 +33,7 @@
        void setJobDataS(CJobDataS* pJobDataS);
        CJobDataS* getJobDataS();
        BOOL setBuddy(CGlass* pGlass);
        BOOL forceSetBuddy(CGlass* pGlass);
        CGlass* getBuddy();
        std::string& getBuddyId();
        void processEnd(unsigned int nEqId, unsigned int nUnit);

 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);
@@ -343,10 +343,13 @@

            // è°ƒåº¦é€»è¾‘处理
            else if (m_state == MASTERSTATE::RUNNING) {
                unlock();
                // LOGI("调度处理中...");
                // æ£€æµ‹åˆ¤æ–­robot状态
                RMDATA& rmd = pEFEM->getRobotMonitoringData();
                if (rmd.status != ROBOT_STATUS::Idle && rmd.status != ROBOT_STATUS::Run) {
                    unlock();
                    continue;
                }

                lock();
                if (m_pActiveRobotTask != nullptr) {
                    unlock();
                    // æ£€æµ‹åˆ°å½“前有正在下午的任务，确保当前任务完成或中止后继续
@@ -376,14 +379,16 @@


                // Measurement -> LoadPort
                LOGI("Arm1 %s, Arm2 %s.", rmd.armState[0] ? _T("不可用") : _T("可用"), 
                    rmd.armState[1] ? _T("不可用") : _T("可用"));
                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()
                    if (!rmd.armState[0] && pEqLoadPort[s]->isEnable()
                        && pEqLoadPort[s]->getPortType() == PortType::Unloading
                        && pEqLoadPort[s]->getPortMode() == PortMode::ReadyToUnload) {
                        m_pActiveRobotTask = createTransferTask(pMeasurement, pEqLoadPort[s], primaryType, secondaryType);
@@ -395,7 +400,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) {
@@ -407,130 +412,173 @@


                // BakeCooling ->Measurement
                m_pActiveRobotTask = createTransferTask_bakecooling_to_measurement(pBakeCooling, pMeasurement);
                if (m_pActiveRobotTask != nullptr) {
                    m_pActiveRobotTask->run();
                    std::string strDescription = m_pActiveRobotTask->getDescription();
                    unlock();
                    if (m_listener.onRobotTaskEvent != nullptr) {
                        m_listener.onRobotTaskEvent(this, m_pActiveRobotTask, ROBOT_EVENT_CREATE);
                if (!rmd.armState[0]) {
                    m_pActiveRobotTask = createTransferTask_bakecooling_to_measurement(pBakeCooling, pMeasurement);
                    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;
                    }
                    LOGI("创建新任务<%s>...", strDescription.c_str());
                    continue;
                }


                
                // BakeCooling内部
                // Bake -> Cooling
                m_pActiveRobotTask = createTransferTask_bake_to_cooling(pBakeCooling);
                if (m_pActiveRobotTask != nullptr) {
                    m_pActiveRobotTask->run();
                    std::string strDescription = m_pActiveRobotTask->getDescription();
                    unlock();
                    if (m_listener.onRobotTaskEvent != nullptr) {
                        m_listener.onRobotTaskEvent(this, m_pActiveRobotTask, ROBOT_EVENT_CREATE);
                if (!rmd.armState[0]) {
                    m_pActiveRobotTask = createTransferTask_bake_to_cooling(pBakeCooling);
                    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;
                    }
                    LOGI("创建新任务<%s>...", strDescription.c_str());
                    continue;
                }


                // Bonder -> BakeCooling
                m_pActiveRobotTask = createTransferTask_bonder_to_bakecooling(pBonder1, pBakeCooling);
                if (m_pActiveRobotTask != nullptr) {
                    m_pActiveRobotTask->run();
                    std::string strDescription = m_pActiveRobotTask->getDescription();
                    unlock();
                    if (m_listener.onRobotTaskEvent != nullptr) {
                        m_listener.onRobotTaskEvent(this, m_pActiveRobotTask, ROBOT_EVENT_CREATE);
                if (!rmd.armState[0]) {
                    m_pActiveRobotTask = createTransferTask_bonder_to_bakecooling(pBonder1, pBakeCooling);
                    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;
                    }
                    LOGI("创建新任务<%s>...", strDescription.c_str());
                    continue;
                }

                m_pActiveRobotTask = createTransferTask_bonder_to_bakecooling(pBonder2, pBakeCooling);
                if (m_pActiveRobotTask != nullptr) {
                    m_pActiveRobotTask->run();
                    std::string strDescription = m_pActiveRobotTask->getDescription();
                    unlock();
                    if (m_listener.onRobotTaskEvent != nullptr) {
                        m_listener.onRobotTaskEvent(this, m_pActiveRobotTask, ROBOT_EVENT_CREATE);
                if (!rmd.armState[0]) {
                    m_pActiveRobotTask = createTransferTask_bonder_to_bakecooling(pBonder2, pBakeCooling);
                    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;
                    }
                    LOGI("创建新任务<%s>...", strDescription.c_str());
                    continue;
                }

                // Aligner -> Bonder
                m_pActiveRobotTask = createTransferTask(pAligner, pBonder1, primaryType, secondaryType);
                if (m_pActiveRobotTask != nullptr) {
                    m_pActiveRobotTask->run();
                    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, pBonder2, primaryType, secondaryType);
                if (m_pActiveRobotTask != nullptr) {
                    m_pActiveRobotTask->run();
                    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;
                }


                // Fliper(G2) -> Aligner
                // VacuumBake(G1) -> Aligner
                m_pActiveRobotTask = createTransferTask(pFliper, pAligner, primaryType, secondaryType);
                if (m_pActiveRobotTask != nullptr) {
                    m_pActiveRobotTask->run();
                    std::string strDescription = m_pActiveRobotTask->getDescription();
                    unlock();
                    if (m_listener.onRobotTaskEvent != nullptr) {
                        m_listener.onRobotTaskEvent(this, m_pActiveRobotTask, ROBOT_EVENT_CREATE);
                // Fliper(G2) -> Bonder
                // VacuumBake(G1) -> Bonder
                if (!rmd.armState[1] && !pBonder1->hasBondClass()) {
                    m_pActiveRobotTask = createTransferTask(pFliper, pBonder1, 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;
                    }
                    LOGI("创建新任务<%s>...", strDescription.c_str());
                    continue;
                }

                m_pActiveRobotTask = createTransferTask(pVacuumBack, pAligner, primaryType, secondaryType);
                if (m_pActiveRobotTask != nullptr) {
                    m_pActiveRobotTask->run();
                    std::string strDescription = m_pActiveRobotTask->getDescription();
                    unlock();
                    if (m_listener.onRobotTaskEvent != nullptr) {
                        m_listener.onRobotTaskEvent(this, m_pActiveRobotTask, ROBOT_EVENT_CREATE);
                if (!rmd.armState[1] && !pBonder2->hasBondClass()) {
                    m_pActiveRobotTask = createTransferTask(pFliper, pBonder2, 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;
                    }
                    LOGI("创建新任务<%s>...", strDescription.c_str());
                    continue;
                }

                if (!rmd.armState[0] && !pBonder1->hasBondClass()) {
                    m_pActiveRobotTask = createTransferTask(pVacuumBake, pBonder1, primaryType, secondaryType);
                    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;
                    }
                }

                if (!rmd.armState[0] && !pBonder2->hasBondClass()) {
                    m_pActiveRobotTask = createTransferTask(pVacuumBake, pBonder2, primaryType, secondaryType);
                    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;
                    }
                }


                // LoadPort -> Fliper(G2)
                // LoadPort -> VacuumBake(G1)
                // Aligner -> Fliper(G2)
                // Aligner -> VacuumBake(G1)
                if (!rmd.armState[1]) {
                    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;
                    }
                }

                if (!rmd.armState[0]) {
                    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) {
                            m_listener.onRobotTaskEvent(this, m_pActiveRobotTask, ROBOT_EVENT_CREATE);
                        }
                        LOGI("创建新任务<%s>...", strDescription.c_str());
                        continue;
                    }
                }

                // 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);
                            if (m_pActiveRobotTask != nullptr) {
                                goto PORT_GET;
                            }
                    if (!rmd.armState[0] && pEqLoadPort[s]->isEnable()
                        && pEqLoadPort[s]->getPortType() == PortType::Loading
                        && pEqLoadPort[s]->getPortMode() == PortMode::ReadyToLoad) {
                        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 +712,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 +752,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 +1052,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 +1198,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;
@@ -1152,7 +1215,7 @@
            pTask = new CRobotTask();
            pTask->setContext(pSrcSlot->getContext());
            pTask->setEFEM((CEFEM*)getEquipment(EQ_ID_EFEM));
            pTask->setRobotTransferParam(++taskSeqNo, 1, pSrcSlot->getPosition(),
            taskSeqNo = pTask->setRobotTransferParam(taskSeqNo, armNo, pSrcSlot->getPosition(),
                pTarSlot->getPosition(), pSrcSlot->getNo(), pTarSlot->getNo());
        }

@@ -1173,7 +1236,7 @@
            pTask = new CRobotTask();
            pTask->setContext(pSrcSlot->getContext());
            pTask->setEFEM((CEFEM*)getEquipment(EQ_ID_EFEM));
            pTask->setRobotTransferParam(++taskSeqNo, 1, pSrcSlot->getPosition(),
            taskSeqNo = pTask->setRobotTransferParam(taskSeqNo, 1, pSrcSlot->getPosition(),
                pTarSlot->getPosition(), pSrcSlot->getNo(), pTarSlot->getNo());
        }

@@ -1195,7 +1258,7 @@
            pTask = new CRobotTask();
            pTask->setContext(pSrcSlot->getContext());
            pTask->setEFEM((CEFEM*)getEquipment(EQ_ID_EFEM));
            pTask->setRobotTransferParam(++taskSeqNo, 1, pSrcSlot->getPosition(),
            taskSeqNo = pTask->setRobotTransferParam(taskSeqNo, 1, pSrcSlot->getPosition(),
                pTarSlot->getPosition(), pSrcSlot->getNo(), pTarSlot->getNo());
        }

@@ -1216,7 +1279,7 @@
            pTask = new CRobotTask();
            pTask->setContext(pSrcSlot->getContext());
            pTask->setEFEM((CEFEM*)getEquipment(EQ_ID_EFEM));
            pTask->setRobotTransferParam(++taskSeqNo, 1, pSrcSlot->getPosition(),
            taskSeqNo = pTask->setRobotTransferParam(taskSeqNo, 1, pSrcSlot->getPosition(),
                pTarSlot->getPosition(), pSrcSlot->getNo(), pTarSlot->getNo());
        }

@@ -1248,4 +1311,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,7 +88,8 @@
        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);

 SourceCode/Bond/Servo/CMeasurement.cpp

@@ -340,10 +340,6 @@
        m_slot[0].setPosition(m_nID);
        m_slot[0].setNo(1);
        m_slot[0].setName("Slot 1");
        m_slot[1].enable();
        m_slot[1].setPosition(m_nID);
        m_slot[1].setNo(2);
        m_slot[1].setName("Slot 2");
    }

    void CMeasurement::onTimer(UINT nTimerid)

 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,52 @@
        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);

        // è½¬æ¢ä¸€ä¸‹æºå’Œç›®æ ‡ç«™å·
        int srcPos, srcSlot, tarPos, tarSlot;
        transformPosAndSlot(fromPos, fromSlot, srcPos, srcSlot);
        transformPosAndSlot(toPos, toSlot, tarPos, tarSlot);

        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>(srcPos);
        m_robotCmdParam[ACTION_PICK].getSlotNo = static_cast<short>(srcSlot);

        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>(tarPos);
        m_robotCmdParam[ACTION_PLACE].putSlotNo = static_cast<short>(tarSlot);

        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>(srcPos);
        m_robotCmdParam[ACTION_RESTORE].putSlotNo = static_cast<short>(srcSlot);

        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 +172,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 +205,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 +302,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 +325,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");
@@ -226,4 +344,54 @@
    {
        m_timeStored = CToolUnits::getUnixTimestamp();;
    }

    void CRobotTask::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;
        }
    }
}

 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();
@@ -43,6 +55,7 @@

    private:
        static std::string& generateId(std::string& out);
        void transformPosAndSlot(int srcPos, int srcSlot, int& tarPos, int& tarSlot);

    private:
        ROBOT_TASK_STATE m_state;                    /* ä»»åŠ¡çŠ¶æ€ */
@@ -51,7 +64,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());
@@ -233,7 +244,7 @@

        // çŠ¶æ€æ˜ å°„
        static const char* STATUS_STR[] = {
            "Unknown", "Ready", "Running", "Error", "Abort", "Completed"
            "Unknown", "Ready", "Running", "Picking", "Placing", "Restoring", "Error", "Abort", "Completed"
        };
        auto state = pTask->getState();
        int index = static_cast<int>(state);

 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/RecipeManager.cpp

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,446 @@
#include "stdafx.h"
#include "RecipeManager.h"
#include <sstream>
#include <iomanip>
#include <fstream>
#include <iostream>

std::recursive_mutex RecipeManager::m_mutex;

RecipeManager& RecipeManager::getInstance() {
    static RecipeManager instance;
    return instance;
}

RecipeManager::RecipeManager() {
    m_pDB = new BL::SQLiteDatabase();
}

RecipeManager::~RecipeManager() {
    if (m_pDB) {
        delete m_pDB;
        m_pDB = nullptr;
    }
}

bool RecipeManager::initRecipeTable() {
    char szPath[MAX_PATH];
    GetModuleFileNameA(NULL, szPath, MAX_PATH);
    std::string exePath(szPath);
    std::string dbDir = exePath.substr(0, exePath.find_last_of("\\/")) + "\\DB";
    CreateDirectoryA(dbDir.c_str(), NULL);

    std::string dbPath = dbDir + "\\RecipeManager.db";
    if (!m_pDB->connect(dbPath, true)) {
        return false;
    }

    // å¯ç”¨ SQLite çš„外键约束支持
    if (!m_pDB->executeQuery("PRAGMA foreign_keys = ON;")) {
        std::cerr << "Failed to enable foreign keys." << std::endl;
        return false;
    }

    const std::string createRecipeTable = R"(
        CREATE TABLE IF NOT EXISTS recipes (
            ppid TEXT PRIMARY KEY NOT NULL,
            description TEXT,
            create_time TEXT DEFAULT (datetime('now', 'localtime'))
        );
    )";

    const std::string createDeviceTable = R"(
        CREATE TABLE IF NOT EXISTS recipe_devices (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            ppid TEXT NOT NULL,
            device_id INTEGER NOT NULL,
            device_name TEXT NOT NULL,
            recipe_id INTEGER NOT NULL,
            FOREIGN KEY(ppid) REFERENCES recipes(ppid) ON DELETE CASCADE,
            UNIQUE (ppid, device_id),
            UNIQUE (ppid, device_name)
        );
    )";

    return m_pDB->executeQuery(createRecipeTable)
        && m_pDB->executeQuery(createDeviceTable);
}

void RecipeManager::termRecipeTable() {
    if (!m_pDB) {
        return;
    }

    m_pDB->disconnect();
}

bool RecipeManager::destroyRecipeTable() {
    if (!m_pDB) {
        return false;
    }

    return m_pDB->executeQuery("DROP TABLE IF EXISTS recipe_devices;") && m_pDB->executeQuery("DROP TABLE IF EXISTS recipes;");
}

bool RecipeManager::ppidExists(const std::string& ppid) {
    std::ostringstream oss;
    oss << "SELECT COUNT(*) FROM recipes WHERE ppid = '" << ppid << "';";
    auto result = m_pDB->fetchResults(oss.str());
    return (!result.empty() && !result[0].empty() && result[0][0] != "0");
}

bool RecipeManager::deviceExists(const std::string& ppid, int nDeviceID) {
    std::ostringstream oss;
    oss << "SELECT COUNT(*) FROM recipe_devices WHERE ppid = '" << ppid
        << "' AND device_id = " << nDeviceID << ";";
    auto result = m_pDB->fetchResults(oss.str());
    return (!result.empty() && !result[0].empty() && result[0][0] != "0");
}

bool RecipeManager::addRecipe(const RecipeInfo& recipe) {
    if (!m_pDB || recipe.strPPID.empty() || recipe.vecDeviceList.empty()) {
        std::cerr << "[AddRecipe] Invalid input." << std::endl;
        return false;
    }

    std::string strTime = recipe.strCreateTime;
    if (strTime.empty()) {
        std::time_t now = std::time(nullptr);
        std::tm tm_now = {};
        localtime_s(&tm_now, &now);
        std::stringstream ss;
        ss << std::put_time(&tm_now, "%Y-%m-%d %H:%M:%S");
        strTime = ss.str();
    }

    std::lock_guard<std::recursive_mutex> lock(m_mutex);

    // å¼€å§‹äº‹åŠ¡
    m_pDB->executeQuery("BEGIN TRANSACTION;");

    std::ostringstream oss;
    oss << "INSERT OR REPLACE INTO recipes (ppid, description, create_time) VALUES ('"
        << recipe.strPPID << "', '"
        << recipe.strDescription << "', '"
        << strTime << "');";

    if (!m_pDB->executeQuery(oss.str())) {
        std::cerr << "[AddRecipe] Failed to insert recipe: " << recipe.strPPID << std::endl;
        m_pDB->executeQuery("ROLLBACK;");
        return false;
    }

    for (const auto& device : recipe.vecDeviceList) {
        std::ostringstream devSql;
        devSql << "INSERT OR REPLACE INTO recipe_devices (ppid, device_id, device_name, recipe_id) VALUES ('"
            << recipe.strPPID << "', "
            << device.nDeviceID << ", '"
            << device.strDeviceName << "', "
            << device.nRecipeID << ");";

        if (!m_pDB->executeQuery(devSql.str())) {
            std::cerr << "[AddRecipe] Failed to insert device mapping: " << device.nDeviceID << std::endl;
            m_pDB->executeQuery("ROLLBACK;");
            return false;
        }
    }

    // æäº¤äº‹åŠ¡
    m_pDB->executeQuery("COMMIT;");
    return true;
}

bool RecipeManager::addRecipeDevice(const std::string& ppid, const DeviceRecipe& device) {
    if (!m_pDB || ppid.empty() || device.nDeviceID <= 0 || device.nRecipeID <= 0) {
        std::cerr << "[addRecipeDevice] Invalid input." << std::endl;
        return false;
    }

    // æ£€æŸ¥ ppid æ˜¯å¦å­˜åœ¨
    if (!ppidExists(ppid)) {
        std::cerr << "[addRecipeDevice] PPID does not exist: " << ppid << std::endl;
        return false;
    }

    // æ’入设备记录
    std::ostringstream oss;
    oss << "INSERT OR REPLACE INTO recipe_devices (ppid, device_id, device_name, recipe_id) VALUES ('"
        << ppid << "', "
        << device.nDeviceID << ", '"
        << device.strDeviceName << "', "
        << device.nRecipeID << ");";

    std::lock_guard<std::recursive_mutex> lock(m_mutex);
    return m_pDB->executeQuery(oss.str());
}

bool RecipeManager::deleteRecipeDeviceByID(const std::string& ppid, int nDeviceID) {
    if (!m_pDB || ppid.empty() || nDeviceID <= 0) {
        std::cerr << "[deleteRecipeDeviceByID] Invalid input." << std::endl;
        return false;
    }

    std::ostringstream oss;
    oss << "DELETE FROM recipe_devices WHERE ppid = '" << ppid << "' AND device_id = " << nDeviceID << ";";

    std::lock_guard<std::recursive_mutex> lock(m_mutex);
    return m_pDB->executeQuery(oss.str());
}

bool RecipeManager::deleteRecipeDeviceByName(const std::string& ppid, const std::string& strDeviceName) {
    if (!m_pDB || ppid.empty() || strDeviceName.empty()) {
        std::cerr << "[deleteRecipeDeviceByName] Invalid input." << std::endl;
        return false;
    }

    std::ostringstream oss;
    oss << "DELETE FROM recipe_devices WHERE ppid = '" << ppid << "' AND device_name = '" << strDeviceName << "';";

    std::lock_guard<std::recursive_mutex> lock(m_mutex);
    return m_pDB->executeQuery(oss.str());
}

std::vector<RecipeInfo> RecipeManager::getAllRecipes() {
    if (!m_pDB) {
        return {};
    }

    std::vector<RecipeInfo> recipes;
    auto rows = m_pDB->fetchResults("SELECT ppid, description, create_time FROM recipes;");

    for (const auto& row : rows) {
        RecipeInfo info;
        info.strPPID = row[0];
        info.strDescription = row[1];
        info.strCreateTime = row[2];

        std::ostringstream devQuery;
        devQuery << "SELECT device_id, device_name, recipe_id FROM recipe_devices WHERE ppid = '" << info.strPPID << "';";
        auto devs = m_pDB->fetchResults(devQuery.str());

        for (const auto& dev : devs) {
            DeviceRecipe dr;
            dr.strPPID = info.strPPID;
            try {
                dr.nDeviceID = std::stoi(dev[0]);
                dr.strDeviceName = dev[1];
                dr.nRecipeID = std::stoi(dev[2]);
            }
            catch (...) {
                std::cerr << "Invalid data in recipe_devices for PPID: " << info.strPPID << std::endl;
                continue;
            }
            info.vecDeviceList.push_back(dr);
        }
        recipes.push_back(info);
    }

    return recipes;
}

RecipeInfo RecipeManager::getRecipeByPPID(const std::string& ppid) {
    RecipeInfo info;
    auto rows = m_pDB->fetchResults("SELECT ppid, description, create_time FROM recipes WHERE ppid = '" + ppid + "';");
    if (rows.empty()) {
        return info;
    }

    info.strPPID = rows[0][0];
    info.strDescription = rows[0][1];
    info.strCreateTime = rows[0][2];

    auto devs = m_pDB->fetchResults("SELECT device_id, device_name, recipe_id FROM recipe_devices WHERE ppid = '" + ppid + "';");
    for (const auto& dev : devs) {
        DeviceRecipe dr;
        dr.strPPID = ppid;
        try {
            dr.nDeviceID = std::stoi(dev[0]);
            dr.strDeviceName = dev[1];
            dr.nRecipeID = std::stoi(dev[2]);
        }
        catch (...) {
            std::cerr << "Invalid data in recipe_devices for PPID: " << ppid << std::endl;
            continue;
        }
        info.vecDeviceList.push_back(dr);
    }
    return info;
}

int RecipeManager::getDeviceRecipeIDByID(const std::string& ppid, int nDeviceID) {
    if (!m_pDB || ppid.empty() || nDeviceID <= 0) {
        return -1;
    }

    std::ostringstream query;
    query << "SELECT recipe_id FROM recipe_devices WHERE ppid = '" << ppid << "' AND device_id = " << nDeviceID << ";";

    auto result = m_pDB->fetchResults(query.str());
    if (!result.empty() && !result[0].empty()) {
        try {
            return std::stoi(result[0][0]);
        }
        catch (...) {
            return -1;
        }
    }
    return -1;
}

int RecipeManager::getDeviceRecipeIDByName(const std::string& ppid, const std::string& strDeviceName) {
    if (!m_pDB || ppid.empty() || strDeviceName.empty()) {
        return -1;
    }

    std::ostringstream query;
    query << "SELECT recipe_id FROM recipe_devices WHERE ppid = '" << ppid << "' AND device_name = '" << strDeviceName << "';";

    auto result = m_pDB->fetchResults(query.str());
    if (!result.empty() && !result[0].empty()) {
        try {
            return std::stoi(result[0][0]);
        }
        catch (...) {
            return -1;
        }
    }
    return -1;
}

bool RecipeManager::deleteRecipeByPPID(const std::string& ppid) {
    if (!m_pDB) {
        return false;
    }

    std::lock_guard<std::recursive_mutex> lock(m_mutex);
    return m_pDB->executeQuery("DELETE FROM recipes WHERE ppid = '" + ppid + "';");
}

bool RecipeManager::updateRecipe(const RecipeInfo& recipe) {
    if (!m_pDB) {
        return false;
    }

    if (recipe.strPPID.empty()) {
        std::cerr << "Recipe PPID cannot be empty." << std::endl;
        return false;
    }

    std::lock_guard<std::recursive_mutex> lock(m_mutex);
    deleteRecipeByPPID(recipe.strPPID);
    return addRecipe(recipe);
}

bool RecipeManager::updateDeviceRecipeIDByID(const std::string& ppid, int nDeviceID, int nNewRecipeID) {
    if (!m_pDB || ppid.empty() || nDeviceID <= 0 || nNewRecipeID <= 0) {
        return false;
    }

    std::ostringstream query;
    std::lock_guard<std::recursive_mutex> lock(m_mutex);
    query << "UPDATE recipe_devices SET recipe_id = " << nNewRecipeID
        << " WHERE ppid = '" << ppid << "' AND device_id = " << nDeviceID << ";";
    return m_pDB->executeQuery(query.str());
}

bool RecipeManager::updateDeviceRecipeIDByName(const std::string& ppid, const std::string& strDeviceName, int nNewRecipeID) {
    if (!m_pDB || ppid.empty() || strDeviceName.empty() || nNewRecipeID <= 0) {
        return false;
    }
    std::ostringstream query;
    std::lock_guard<std::recursive_mutex> lock(m_mutex);
    query << "UPDATE recipe_devices SET recipe_id = " << nNewRecipeID
        << " WHERE ppid = '" << ppid << "' AND device_name = '" << strDeviceName << "';";
    return m_pDB->executeQuery(query.str());
}

void RecipeManager::insertMockData() {
    if (!m_pDB) {
        return;
    }

    RecipeInfo recipe;
    recipe.strPPID = "P1001";
    recipe.strDescription = "Main Board Burn-in";

    recipe.vecDeviceList = {
        {1, 101, "P1001","Burner A"},
        {2, 102, "P1001", "Burner B"}
    };

    addRecipe(recipe);
}

bool RecipeManager::readRecipeFile(const std::string& filename) {
    if (!m_pDB) {
        return false;
    }

    std::ifstream file(filename);
    if (!file.is_open()) {
        return false;
    }

    std::unordered_map<std::string, RecipeInfo> recipeMap;
    std::string line;
    std::getline(file, line); // skip header

    while (std::getline(file, line)) {
        std::stringstream ss(line);
        std::string cell;
        std::string ppid, description, createTime;
        DeviceRecipe dev;

        std::getline(ss, ppid, ',');
        std::getline(ss, cell, ',');
        try { dev.nDeviceID = std::stoi(cell); }
        catch (...) { continue; }
        std::getline(ss, dev.strDeviceName, ',');
        std::getline(ss, cell, ',');
        try { dev.nRecipeID = std::stoi(cell); }
        catch (...) { continue; }
        std::getline(ss, description, ',');
        std::getline(ss, createTime, ',');

        dev.strPPID = ppid;
        auto& recipe = recipeMap[ppid];
        recipe.strPPID = ppid;
        recipe.strDescription = description;
        recipe.strCreateTime = createTime;
        recipe.vecDeviceList.push_back(dev);
    }

    for (const auto& pair : recipeMap) {
        if (!updateRecipe(pair.second)) {
            std::cerr << "Failed to update recipe from file: " << pair.first << std::endl;
        }
    }

    return true;
}

bool RecipeManager::saveRecipeFile(const std::string& filename) {
    if (!m_pDB) {
        return false;
    }

    std::ofstream file(filename);
    if (!file.is_open()) {
        return false;
    }

    file << "PPID,DeviceID,DeviceName,RecipeID,Description,CreateTime\n";
    auto recipes = getAllRecipes();
    for (const auto& recipe : recipes) {
        for (const auto& dev : recipe.vecDeviceList) {
            file << recipe.strPPID << ","
                << dev.nDeviceID << ","
                << dev.strDeviceName << ","
                << dev.nRecipeID << ","
                << recipe.strDescription << ","
                << recipe.strCreateTime << "\n";
        }
    }

    return true;
}

 SourceCode/Bond/Servo/RecipeManager.h

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,103 @@
#ifndef RECIPE_MANAGER_H
#define RECIPE_MANAGER_H

#include <string>
#include <vector>
#include <mutex>
#include <unordered_map>
#include "Database.h"

// å•ä¸ªè®¾å¤‡é…æ–¹æ˜ å°„信息
struct DeviceRecipe {
    int nDeviceID;               // è®¾å¤‡ID
    int nRecipeID;               // è¯¥è®¾å¤‡å¯¹åº”的子配方ID
    std::string strPPID;         // é…æ–¹ID（主键）
    std::string strDeviceName;   // è®¾å¤‡åç§° 
};

// é…æ–¹ä¿¡æ¯
struct RecipeInfo {
    std::string strPPID;         // é…æ–¹ID
    std::string strDescription;  // é…æ–¹æè¿°
    std::string strCreateTime;   // åˆ›å»ºæ—¶é—´
    std::vector<DeviceRecipe> vecDeviceList;  // å…³è”的设备信息列表
};

using RecipeMap = std::unordered_map<std::string, RecipeInfo>; // æŒ‰ PPID æ˜ å°„的配方表

class RecipeManager {
public:
    // èŽ·å–单例
    static RecipeManager& getInstance();

    // åˆå§‹åŒ–配方数据库
    bool initRecipeTable();

    // é”€æ¯è¡¨æˆ–关闭连接
    void termRecipeTable();
    bool destroyRecipeTable();

    // æ£€æŸ¥ PPID æ˜¯å¦å­˜åœ¨
    bool ppidExists(const std::string& ppid);

    // æ£€æŸ¥è®¾å¤‡æ˜¯å¦å­˜åœ¨äºŽæŒ‡å®š PPID çš„配方中
    bool deviceExists(const std::string& ppid, int nDeviceID);

    // æ·»åŠ ä¸€ä¸ªé…æ–¹åŠå…¶è®¾å¤‡æ˜ å°„
    bool addRecipe(const RecipeInfo& recipe);

    // æ·»åŠ è®¾å¤‡åˆ°æŒ‡å®šé…æ–¹
    bool addRecipeDevice(const std::string& ppid, const DeviceRecipe& device);

    // åˆ é™¤æŒ‡å®š PPID çš„设备配方
    bool deleteRecipeDeviceByID(const std::string& ppid, int nDeviceID);

    // åˆ é™¤æŒ‡å®š PPID çš„设备配方（通过设备名称）
    bool deleteRecipeDeviceByName(const std::string& ppid, const std::string& strDeviceName);

    // æŸ¥è¯¢æ‰€æœ‰é…æ–¹
    std::vector<RecipeInfo> getAllRecipes();

    // æŒ‰ PPID æŸ¥è¯¢é…æ–¹
    RecipeInfo getRecipeByPPID(const std::string& ppid);

    // æ ¹æ® PPID å’Œè®¾å¤‡ID èŽ·å–设备配方ID
    int getDeviceRecipeIDByID(const std::string& ppid, int nDeviceID);

    // æ ¹æ® PPID å’Œè®¾å¤‡åç§° èŽ·å–设备配方ID
    int getDeviceRecipeIDByName(const std::string& ppid, const std::string& strDeviceName);

    // åˆ é™¤æŒ‡å®š PPID çš„配方
    bool deleteRecipeByPPID(const std::string& ppid);

    // æ›´æ–°æŒ‡å®š PPID çš„配方
    bool updateRecipe(const RecipeInfo& recipe);

    // æ›´æ–°è®¾å¤‡é…æ–¹ID（通过 PPID å’Œè®¾å¤‡ID）
    bool updateDeviceRecipeIDByID(const std::string& ppid, int nDeviceID, int nNewRecipeID);

    // æ›´æ–°è®¾å¤‡é…æ–¹ID（通过 PPID å’Œè®¾å¤‡åç§°ï¼‰
    bool updateDeviceRecipeIDByName(const std::string& ppid, const std::string& strDeviceName, int nNewRecipeID);

    // æ¨¡æ‹Ÿæ’入数据（测试用）
    void insertMockData();

    // è¯»å–配方文件（CSV æˆ– JSON）
    bool readRecipeFile(const std::string& filename);

    // ä¿å­˜é…æ–¹åˆ°æ–‡ä»¶
    bool saveRecipeFile(const std::string& filename);

private:
    RecipeManager();
    ~RecipeManager();

    RecipeManager(const RecipeManager&) = delete;
    RecipeManager& operator=(const RecipeManager&) = delete;

private:
    BL::Database* m_pDB;
    static std::recursive_mutex m_mutex;
};

#endif // RECIPE_MANAGER_H

 SourceCode/Bond/Servo/Servo.cpp

@@ -11,6 +11,7 @@
#include "TransferManager.h"
#include "SystemLogManager.h"
#include "UserManager.h"
#include "RecipeManager.h"
#include "VerticalLine.h"
#include "HorizontalLine.h"
#include "EqsGraphWnd.h"
@@ -134,7 +135,6 @@
        AfxMessageBox(errorMsg, MB_ICONERROR);
        return FALSE;
    }
    AlarmManager::getInstance().insertMockData();

    // åˆå§‹åŒ–SECS运行设置管理库
    try {
@@ -194,6 +194,19 @@
        return FALSE;
    }

    // åˆå§‹åŒ–配方管理库
    try {
        if (!RecipeManager::getInstance().initRecipeTable()) {
            AfxMessageBox("初始化配方管理库失败！");
            return FALSE;
        }
    }
    catch (const std::exception& ex) {
        CString errorMsg;
        errorMsg.Format(_T("初始化配方管理库失败：%s"), CString(ex.what()));
        AfxMessageBox(errorMsg, MB_ICONERROR);
        return FALSE;
    }


    CServoDlg dlg;

 SourceCode/Bond/Servo/Servo.rc

Binary files differ

 SourceCode/Bond/Servo/Servo.vcxproj

@@ -317,6 +317,7 @@
    <ClInclude Include="PageTransferLog.h" />
    <ClInclude Include="PortConfigurationDlg.h" />
    <ClInclude Include="ProductionLogManager.h" />
    <ClInclude Include="RecipeManager.h" />
    <ClInclude Include="Resource.h" />
    <ClInclude Include="SECSRuntimeManager.h" />
    <ClInclude Include="SecsTestDlg.h" />
@@ -454,6 +455,7 @@
    <ClCompile Include="PageTransferLog.cpp" />
    <ClCompile Include="PortConfigurationDlg.cpp" />
    <ClCompile Include="ProductionLogManager.cpp" />
    <ClCompile Include="RecipeManager.cpp" />
    <ClCompile Include="SECSRuntimeManager.cpp" />
    <ClCompile Include="SecsTestDlg.cpp" />
    <ClCompile Include="Servo.cpp" />

 SourceCode/Bond/Servo/Servo.vcxproj.filters

@@ -167,6 +167,7 @@
    <ClCompile Include="SystemLogManager.cpp" />
    <ClCompile Include="UserManager.cpp" />
    <ClCompile Include="InputDialog.cpp" />
    <ClCompile Include="RecipeManager.cpp" />
  </ItemGroup>
  <ItemGroup>
    <ClInclude Include="AlarmManager.h" />
@@ -339,6 +340,7 @@
    <ClInclude Include="UserManager.h" />
    <ClInclude Include="SystemLogManager.h" />
    <ClInclude Include="InputDialog.h" />
    <ClInclude Include="RecipeManager.h" />
  </ItemGroup>
  <ItemGroup>
    <ResourceCompile Include="Servo.rc" />

 SourceCode/Bond/Servo/ServoCommo.h

@@ -110,11 +110,46 @@
    enum class ROBOT_TASK_STATE {
        Ready = 0,
        Running,
        Picking,
        Placing,
        Restoring,
        Error,
        Abort,
        Completed
    };

    enum class ROBOT_STATUS {
        Setup = 0,
        Idle,
        Run,
        Pause,
        Stop,
        Moving,
    };

    enum class ROBOT_POSITION {
        Port1 = 0,
        Port2,
        Port3,
        Port4,
        Aligner,
        Fliper,
        Bonder1,
        Bonder2,
        Bake,
        Cooling,
        Measurement
    };

    /* Indexer Monitoring Status */
    /* Robot Monitoring Data */
    typedef struct _ROBOT_MONITORING_DATA {
        ROBOT_STATUS status;
        ROBOT_POSITION position;
        BOOL armState[2];
    } ROBOT_MONITORING_DATA, RMDATA;


    /* EQ Data changed code */
#define EDCC_FETCHOUT_JOB                1000    /* È¡Æ¬ */
#define EDCC_STORED_JOB                    1001    /* æ”¾ç‰‡ */

 SourceCode/Bond/Servo/ServoDlg.cpp

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

    // ç›¸å½“于延时调用master的初始化
    theApp.m_model.m_master.init();
    theApp.m_model.loadPortParams();


    // åˆå§‹åŒ–master以后需要控件绑定数据

 SourceCode/Bond/Servo/SystemLogManager.cpp

@@ -42,7 +42,7 @@
    }

    // æž„造数据库路径
    std::string dbPath = dbDir + "\\SystemLog.db";
    std::string dbPath = dbDir + "\\SystemLogManager.db";

    // è¿žæŽ¥æ•°æ®åº“
    if (!m_pDB->connect(dbPath, true)) {

 SourceCode/Bond/Servo/TransferManager.cpp

@@ -29,45 +29,6 @@
    }
}

// ä»»åŠ¡çŠ¶æ€è½¬æ¢æˆ int ç±»åž‹
int TransferManager::statusToInt(TransferStatus status) {
    return static_cast<int>(status);
}

// int ç±»åž‹è½¬æ¢æˆä»»åŠ¡çŠ¶æ€
TransferStatus TransferManager::intToStatus(int value) {
    switch (value) {
        case 0: return TransferStatus::Ready;
        case 1: return TransferStatus::Running;
        case 2: return TransferStatus::Error;
        case 3: return TransferStatus::Abort;
        case 4: return TransferStatus::Completed;
        default: return TransferStatus::Error;
    }
}

// ä»»åŠ¡çŠ¶æ€è½¬æ¢æˆå­—符串
std::string TransferManager::statusToString(TransferStatus status) {
    switch (status) {
        case TransferStatus::Ready:     return "Ready";
        case TransferStatus::Running:   return "Running";
        case TransferStatus::Error:     return "Error";
        case TransferStatus::Abort:     return "Abort";
        case TransferStatus::Completed: return "Completed";
        default:                        return "Unknown";
    }
}

// å­—符串转换成任务状态
TransferStatus TransferManager::stringToStatus(const std::string& str) {
    if (str == "Ready")     return TransferStatus::Ready;
    if (str == "Running")   return TransferStatus::Running;
    if (str == "Error")     return TransferStatus::Error;
    if (str == "Abort")     return TransferStatus::Abort;
    if (str == "Completed") return TransferStatus::Completed;
    return TransferStatus::Error;
}

// æœ¬åœ°ç¼–码转为 UTF-8
std::string TransferManager::ansiToUtf8(const std::string& ansiStr) {
    // 1. ANSI â†’ UTF-16
@@ -134,35 +95,46 @@
}

// æ’入测试搬运记录
void TransferManager::insertTestTransferRecord() {
    if (nullptr != m_pDB) { 
        int nCount = 10000;
void TransferManager::insertTestTransferRecord(int nCount /*=10000*/) {
    if (nullptr != m_pDB) {
        static const char* STATUS_STR[] = {
            "Unknown", "Ready", "Running", "Picking", "Placing",
            "Restoring", "Error", "Abort", "Completed"
        };

        auto formatTime = [](const std::tm& time) {
            char szTime[64];
            strftime(szTime, sizeof(szTime), "%Y-%m-%d %H:%M:%S", &time);
            return std::string(szTime);
        };

        std::time_t startTime = std::time(nullptr);
        for (int i = 0; i < nCount; ++i) {
            TransferData data;
            data.strClassID = "T-" + std::to_string(1000 + i);
            data.strStatus = statusToString(static_cast<TransferStatus>(i % 5));
            data.strStatus = STATUS_STR[i % 9];

            std::time_t now = std::time(nullptr) + i * 60;  // æ¯æ¡è®°å½•é—´éš”1分钟
            std::time_t baseTime = startTime + i * 60;
            std::time_t pickTime = baseTime + 60;
            std::time_t placeTime = pickTime + 60;
            std::time_t endTime = placeTime + 60;

            std::tm tmCreate = {}, tmPick = {}, tmPlace = {}, tmEnd = {};
            localtime_s(&tmCreate, &now);
            localtime_s(&tmPick, &(now += 60));
            localtime_s(&tmPlace, &(now += 60));
            localtime_s(&tmEnd, &(now += 60));
            localtime_s(&tmCreate, &baseTime);
            localtime_s(&tmPick, &pickTime);
            localtime_s(&tmPlace, &placeTime);
            localtime_s(&tmEnd, &endTime);

            char szTime[64];
            strftime(szTime, sizeof(szTime), "%Y-%m-%d %H:%M:%S", &tmCreate);
            data.strCreateTime = szTime;
            strftime(szTime, sizeof(szTime), "%Y-%m-%d %H:%M:%S", &tmPick);
            data.strPickTime = szTime;
            strftime(szTime, sizeof(szTime), "%Y-%m-%d %H:%M:%S", &tmPlace);
            data.strPlaceTime = szTime;
            strftime(szTime, sizeof(szTime), "%Y-%m-%d %H:%M:%S", &tmEnd);
            data.strEndTime = szTime;

            data.strCreateTime = formatTime(tmCreate);
            data.strPickTime = formatTime(tmPick);
            data.strPlaceTime = formatTime(tmPlace);
            data.strEndTime = formatTime(tmEnd);
            data.strDescription = "Mock transfer task " + std::to_string(i);

            int nRecordId = 0;
            addTransferRecord(data, nRecordId);
            if (!addTransferRecord(data, nRecordId)) {
                std::cerr << "[Error] æ’入第 " << i << " æ¡è®°å½•å¤±è´¥" << std::endl;
            }
        }

        std::cout << "[Mock] æˆåŠŸæ’å…¥ " << nCount << " æ¡æµ‹è¯•æ¬è¿è®°å½•ã€‚" << std::endl;

 SourceCode/Bond/Servo/TransferManager.h

@@ -8,17 +8,6 @@
#include "Database.h"

/**
 * ä»»åŠ¡çŠ¶æ€æžšä¸¾ç±»åž‹
 */
enum class TransferStatus {
    Ready = 0,
    Running,
    Error,
    Abort,
    Completed
};

/**
 * æ¬è¿è®°å½•ç»“构体
 */
struct TransferData {
@@ -51,7 +40,7 @@
    /**
     * æ’入测试搬运记录
     */
    void insertTestTransferRecord();
    void insertTestTransferRecord(int nCount = 10000);

    /**
     * ç»ˆæ­¢æ•°æ®åº“连接
@@ -157,10 +146,6 @@
    TransferManager& operator=(const TransferManager&) = delete;

    // å†…联函数
    inline int statusToInt(TransferStatus status);
    inline TransferStatus intToStatus(int value);
    inline std::string statusToString(TransferStatus status);
    inline TransferStatus stringToStatus(const std::string& str);
    inline std::string ansiToUtf8(const std::string& ansiStr);
    inline std::string utf8ToAnsi(const std::string& utf8Str);


 SourceCode/Bond/Servo/UserManager.cpp

@@ -7,7 +7,7 @@
#include <sstream>

const std::string SESSION_FILE = R"(session.dat)";
const std::string DATABASE_FILE = R"(BondEq.db)";
const std::string DATABASE_FILE = R"(UserManager.db)";

const std::string INITIAL_ADMIN_USERNAME = "admin";
const std::string INITIAL_ADMIN_PASSWORD = "admin";
@@ -160,7 +160,7 @@
    char szPath[MAX_PATH];
    GetModuleFileName(NULL, szPath, MAX_PATH);
    std::string exePath(szPath);
    std::string dbDir = exePath.substr(0, exePath.find_last_of("\\/")) + "\\DB";
    std::string dbDir = exePath.substr(0, exePath.find_last_of("\\/")) + "\\DB\\";

    // æ£€æŸ¥å¹¶åˆ›å»ºconfig文件夹
    DWORD fileAttr = GetFileAttributes(dbDir.c_str());

 SourceCode/Bond/Servo/resource.h

Binary files differ

 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