From a2209cc432cb9c80779d83e51ef090f782e8404a Mon Sep 17 00:00:00 2001
From: LAPTOP-SNT8I5JK\Boounion <Chenluhua@qq.com>
Date: 星期四, 14 八月 2025 17:30:52 +0800
Subject: [PATCH] 1.Create PJ功能实现；
---
SourceCode/Bond/Servo/CMaster.cpp | 1158 +++++++++++++++++++++++++++++++++++++++++++++------------
1 files changed, 911 insertions(+), 247 deletions(-)
diff --git a/SourceCode/Bond/Servo/CMaster.cpp b/SourceCode/Bond/Servo/CMaster.cpp
index 6a7437a..f664b6e 100644
--- a/SourceCode/Bond/Servo/CMaster.cpp
+++ b/SourceCode/Bond/Servo/CMaster.cpp
@@ -1,6 +1,9 @@
#include "stdafx.h"
#include "Common.h"
#include "CMaster.h"
+#include <future>
+#include <vector>
+#include "RecipeManager.h"
namespace SERVO {
@@ -48,11 +51,23 @@
m_ullRunTime = 0;
m_state = MASTERSTATE::READY;
m_pActiveRobotTask = nullptr;
+ m_nLastError = 0;
+ m_isCompareMapsBeforeProceeding = FALSE;
+ m_bEnableEventReport = true;
+ m_bEnableAlarmReport = true;
+ m_bContinuousTransfer = false;
+ m_nContinuousTransferCount = 0;
+ m_nContinuousTransferStep = CTStep_Unknow;
InitializeCriticalSection(&m_criticalSection);
}
CMaster::~CMaster()
{
+ for (auto item : m_processJobs) {
+ delete item;
+ }
+ m_processJobs.clear();
+
if (m_hEventReadBitsThreadExit[0] != nullptr) {
::CloseHandle(m_hEventReadBitsThreadExit[0]);
m_hEventReadBitsThreadExit[0] = nullptr;
@@ -160,9 +175,9 @@
ASSERT(pMeasurement);
pEfem->setPort(0, pPort1);
- pEfem->setPort(1, pPort1);
- pEfem->setPort(2, pPort1);
- pEfem->setPort(3, pPort1);
+ pEfem->setPort(1, pPort2);
+ pEfem->setPort(2, pPort3);
+ pEfem->setPort(3, pPort4);
pEfem->setFliper(pFliper);
pEfem->setAligner(pAligner);
pEfem->setArmTray(0, pArmTray1);
@@ -245,6 +260,20 @@
return -1;
}
+ m_bContinuousTransfer = false;
+ setState(MASTERSTATE::STARTING);
+ m_ullStartTime = GetTickCount64();
+
+ return 0;
+ }
+
+ int CMaster::startContinuousTransfer()
+ {
+ if (m_state != MASTERSTATE::READY) {
+ return -1;
+ }
+
+ m_bContinuousTransfer = true;
setState(MASTERSTATE::STARTING);
m_ullStartTime = GetTickCount64();
@@ -254,7 +283,7 @@
int CMaster::stop()
{
// 运行时间为累加结果，本次停止时刷新；
- if (m_state != MASTERSTATE::RUNNING) {
+ if (m_state != MASTERSTATE::RUNNING && m_state != MASTERSTATE::RUNNING_CONTINUOUS_TRANSFER) {
return -1;
}
@@ -264,9 +293,16 @@
return 0;
}
+ void CMaster::clearError()
+ {
+ m_nLastError = 0;
+ m_strLastError = "";
+ setState(MASTERSTATE::READY);
+ }
+
ULONGLONG CMaster::getRunTime()
{
- if (m_state == MASTERSTATE::RUNNING)
+ if (m_state == MASTERSTATE::RUNNING || m_state == MASTERSTATE::RUNNING_CONTINUOUS_TRANSFER)
return m_ullRunTime + (GetTickCount64() - m_ullStartTime);
else
return m_ullRunTime;
@@ -287,11 +323,14 @@
// 各种机器
+ CLoadPort* pLoadPorts[4];
CEFEM* pEFEM = (CEFEM*)getEquipment(EQ_ID_EFEM);
- CLoadPort* pLoadPort1 = (CLoadPort*)getEquipment(EQ_ID_LOADPORT1);
- CLoadPort* pLoadPort2 = (CLoadPort*)getEquipment(EQ_ID_LOADPORT2);
+ pLoadPorts[0] = (CLoadPort*)getEquipment(EQ_ID_LOADPORT1);
+ pLoadPorts[1] = (CLoadPort*)getEquipment(EQ_ID_LOADPORT2);
+ pLoadPorts[2] = (CLoadPort*)getEquipment(EQ_ID_LOADPORT3);
+ pLoadPorts[3] = (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);
@@ -299,10 +338,12 @@
CMeasurement* pMeasurement = (CMeasurement*)getEquipment(EQ_ID_MEASUREMENT);
ASSERT(pEFEM);
- ASSERT(pLoadPort1);
- ASSERT(pLoadPort2);
+ ASSERT(pLoadPorts[0]);
+ ASSERT(pLoadPorts[1]);
+ ASSERT(pLoadPorts[2]);
+ ASSERT(pLoadPorts[3]);
ASSERT(pFliper);
- ASSERT(pVacuumBack);
+ ASSERT(pVacuumBake);
ASSERT(pAligner);
ASSERT(pBonder1);
ASSERT(pBonder2);
@@ -312,7 +353,7 @@
while (1) {
// 待退出信号或时间到
HANDLE hEvents[] = { m_hEventDispatchThreadExit[0], m_hDispatchEvent };
- int nRet = WaitForMultipleObjects(2, hEvents, FALSE, 1000);
+ int nRet = WaitForMultipleObjects(2, hEvents, FALSE, 500);
if (nRet == WAIT_OBJECT_0) {
break;
}
@@ -321,9 +362,119 @@
// 如果状态为STARTING，开始工作并切换到RUNNING状态
lock();
if (m_state == MASTERSTATE::STARTING) {
+ // 发送indexerOperationModeChange到各个机台，成功后切换到RUNNING状态
+ // 否则切换到MSERROR状态
+ int nRet;
+ CEquipment* pEq[6] = { pEFEM, pBonder1, pBonder2, pBakeCooling,
+ pVacuumBake, pMeasurement};
+ BOOL bIomcOk[7] = {FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE};
+ std::vector<std::promise<void>> promises(6);
+ std::vector<std::future<void>> futures;
+
+ nRet = pEq[0]->indexerOperationModeChange(IDNEXER_OPERATION_MODE::Start,
+ [&](int writeCode, int retCode) -> void {
+ bIomcOk[0] = retCode == (int)RET::OK;
+ promises[0].set_value();
+ TRACE("a0001\n", writeCode, retCode);
+ });
+ if (nRet != 0) {
+ LOGI("<Master>EFEM切换Start状态失败");
+ m_strLastError = "EFEM切换Start状态失败.";
+ goto WAIT;
+ }
+ futures.push_back(promises[0].get_future());
+ /*
+ nRet = pEq[1]->indexerOperationModeChange(IDNEXER_OPERATION_MODE::Start,
+ [&](int writeCode, int retCode) -> void {
+ bIomcOk[1] = retCode == (int)RET::OK;
+ promises[1].set_value();
+ TRACE("a0002\n");
+ });
+ if (nRet != 0) {
+ LOGI("<Master>Bonder1切换Start状态失败");
+ m_strLastError = "Bonder1切换Start状态失败.";
+ goto WAIT;
+ }
+ futures.push_back(promises[1].get_future());
+
+ nRet = pEq[2]->indexerOperationModeChange(IDNEXER_OPERATION_MODE::Start,
+ [&](int writeCode, int retCode) -> void {
+ bIomcOk[2] = retCode == (int)RET::OK;
+ promises[2].set_value();
+ TRACE("a0003\n");
+ });
+ if (nRet != 0) {
+ LOGI("<Master>Bonder2切换Start状态失败");
+ m_strLastError = "Bonder2切换Start状态失败.";
+ goto WAIT;
+ }
+ futures.push_back(promises[2].get_future());
+
+ nRet = pEq[3]->indexerOperationModeChange(IDNEXER_OPERATION_MODE::Start,
+ [&](int writeCode, int retCode) -> void {
+ bIomcOk[3] = retCode == (int)RET::OK;
+ promises[3].set_value();
+ TRACE("a0004\n");
+ });
+ if (nRet != 0) {
+ LOGI("<Master>BakeCooling切换Start状态失败");
+ m_strLastError = "BakeCooling切换Start状态失败.";
+ goto WAIT;
+ }
+ futures.push_back(promises[3].get_future());
+
+ nRet = pEq[4]->indexerOperationModeChange(IDNEXER_OPERATION_MODE::Start,
+ [&](int writeCode, int retCode) -> void {
+ bIomcOk[4] = retCode == (int)RET::OK;
+ promises[4].set_value();
+ TRACE("a0005\n");
+ });
+ if (nRet != 0) {
+ LOGI("<Master>VacuumBake切换Start状态失败");
+ m_strLastError = "VacuumBake切换Start状态失败.";
+ goto WAIT;
+ }
+ futures.push_back(promises[4].get_future());
+
+ nRet = pEq[5]->indexerOperationModeChange(IDNEXER_OPERATION_MODE::Start,
+ [&](int writeCode, int retCode) -> void {
+ bIomcOk[5] = retCode == (int)RET::OK;
+ promises[5].set_value();
+ TRACE("a0006\n");
+ });
+ if (nRet != 0) {
+ LOGI("<Master>Measurement切换Start状态失败");
+ m_strLastError = "Measurement切换Start状态失败.";
+ goto WAIT;
+ }
+ futures.push_back(promises[5].get_future());
+ */
+
+WAIT:
+ for (auto& f : futures) {
+ f.wait(); // 阻塞等待对应设备完成
+ }
+ for (int i = 0; i < 6; i++) {
+ if (!bIomcOk[i]) {
+ bIomcOk[6] = FALSE;
+ LOGI("<Master>%s切换Start状态失败", pEq[i]->getName().c_str());
+ }
+ }
+
+ // 检查看是否都已经切换到START状态
+ if (!bIomcOk[6]) {
+ unlock();
+ setState(MASTERSTATE::MSERROR);
+ continue;
+ }
+
+
unlock();
- Sleep(1000);
- setState(MASTERSTATE::RUNNING);
+ if(!m_bContinuousTransfer)
+ setState(MASTERSTATE::RUNNING);
+ else
+ setState(MASTERSTATE::RUNNING_CONTINUOUS_TRANSFER);
+
continue;
}
@@ -331,7 +482,49 @@
// 处理完成当前事务后，切换到停止或就绪状态
else if (m_state == MASTERSTATE::STOPPING) {
unlock();
- Sleep(1000);
+ LOGI("<Master>开始切换各设备到 Stop 模式...");
+
+ std::vector<std::promise<void>> promises(6);
+ std::vector<std::future<void>> futures;
+ BOOL bIomcOk[7] = { FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE };
+
+ int nRet;
+ CEquipment* pEq[6] = { pEFEM, pBonder1, pBonder2, pBakeCooling,
+ pVacuumBake, pMeasurement };
+
+ for (int i = 0; i < 1; ++i) {
+ nRet = pEq[i]->indexerOperationModeChange(IDNEXER_OPERATION_MODE::Stop,
+ [i, &promises, &bIomcOk](int writeCode, int retCode) -> void {
+ bIomcOk[i] = retCode == (int)RET::OK;
+ promises[i].set_value();
+ TRACE("s000%d: ret=%d\n", i + 1, retCode);
+ });
+ if (nRet != 0) {
+ LOGI("<Master>%s切换Stop状态发送失败", pEq[i]->getName().c_str());
+ m_strLastError = pEq[i]->getName() + "切换Stop状态发送失败.";
+ bIomcOk[i] = FALSE;
+ promises[i].set_value(); // 避免 wait 阻塞
+ }
+ futures.push_back(promises[i].get_future());
+ }
+
+ for (auto& f : futures) {
+ f.wait(); // 等待所有完成
+ }
+
+ for (int i = 0; i < 6; ++i) {
+ if (!bIomcOk[i]) {
+ bIomcOk[6] = FALSE;
+ LOGI("<Master>%s切换Stop状态失败", pEq[i]->getName().c_str());
+ }
+ }
+
+ if (!bIomcOk[6]) {
+ setState(MASTERSTATE::MSERROR);
+ continue;
+ }
+
+ LOGI("<Master>所有设备成功切换到 Stop 模式");
setState(MASTERSTATE::READY);
continue;
}
@@ -339,11 +532,17 @@
// 调度逻辑处理
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) {
+ if (m_pActiveRobotTask->isPicked()) {
+ m_pActiveRobotTask->place();
+ }
unlock();
// 检测到当前有正在下午的任务，确保当前任务完成或中止后继续
// LOGI("检测到当前有正在下午的任务，确保当前任务完成或中止后继续...");
@@ -371,180 +570,320 @@
}
- // 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);
+ // Measurement -> LoadPort
+ if (rmd.armState[0] || rmd.armState[1]) {
+ LOGI("Arm1 %s, Arm2 %s.", rmd.armState[0] ? _T("不可用") : _T("可用"),
+ rmd.armState[1] ? _T("不可用") : _T("可用"));
+ }
+ for (int s = 0; s < 4; s++) {
+ PortType pt = pLoadPorts[s]->getPortType();
+ if (!rmd.armState[0] && pLoadPorts[s]->isEnable()
+ && (pt == PortType::Unloading || pt == PortType::Both)
+ && pLoadPorts[s]->getPortStatus() == PORT_INUSE) {
+ m_pActiveRobotTask = createTransferTask(pMeasurement, pLoadPorts[s], primaryType, secondaryType);
+ if (m_pActiveRobotTask != nullptr) {
+ goto PORT_PUT;
+ }
}
- LOGI("创建新任务<%s>...", strDescription.c_str());
- continue;
+ }
+
+ PORT_PUT:
+ CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
+
+
+ // Measurement NG -> LoadPort
+ // NG回原位
+ if (!rmd.armState[1]) {
+ m_pActiveRobotTask = createTransferTask_restore(pMeasurement, pLoadPorts);
+ CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
+ }
+
+
+ // BakeCooling ->Measurement
+ if (!rmd.armState[0]) {
+ m_pActiveRobotTask = createTransferTask_bakecooling_to_measurement(pBakeCooling, pMeasurement);
+ CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
}
// 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);
- }
- LOGI("创建新任务<%s>...", strDescription.c_str());
- continue;
+ if (!rmd.armState[0]) {
+ m_pActiveRobotTask = createTransferTask_bake_to_cooling(pBakeCooling);
+ CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
}
// 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);
+ CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
+ }
+
+ if (!rmd.armState[0]) {
+ m_pActiveRobotTask = createTransferTask_bonder_to_bakecooling(pBonder2, pBakeCooling);
+ CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
+ }
+
+
+ // Fliper(G2) -> Bonder
+ auto pSrcSlot = pVacuumBake->getProcessedSlot(primaryType);
+ if (pSrcSlot != nullptr && !rmd.armState[1] && !pBonder1->hasBondClass()) {
+ m_pActiveRobotTask = createTransferTask(pFliper, pBonder1, primaryType, secondaryType, 2);
+ CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
+ }
+ if (pSrcSlot != nullptr && !rmd.armState[1] && !pBonder2->hasBondClass()) {
+ m_pActiveRobotTask = createTransferTask(pFliper, pBonder2, primaryType, secondaryType, 2);
+ CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
+ }
+
+
+ // VacuumBake(G1) -> Bonder
+ if (!rmd.armState[0] && !pBonder1->hasBondClass()) {
+ m_pActiveRobotTask = createTransferTask(pVacuumBake, pBonder1, primaryType, secondaryType);
+ CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
+ }
+
+ if (!rmd.armState[0] && !pBonder2->hasBondClass()) {
+ m_pActiveRobotTask = createTransferTask(pVacuumBake, pBonder2, primaryType, secondaryType);
+ CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
+ }
+
+
+ // Aligner -> Fliper(G2)
+ // Aligner -> VacuumBake(G1)
+ if (!rmd.armState[1]) {
+ m_pActiveRobotTask = createTransferTask(pAligner, pFliper, primaryType, secondaryType);
+ CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
+ }
+
+ if (!rmd.armState[0]) {
+ m_pActiveRobotTask = createTransferTask(pAligner, pVacuumBake, primaryType, secondaryType);
+ CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
+ }
+
+
+ // Aligner -> LoadPort
+ if (!rmd.armState[1]) {
+ m_pActiveRobotTask = createTransferTask_restore(pAligner, pLoadPorts);
+ CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
+ }
+
+
+ // LoadPort -> Aligner
+ for (int s = 0; s < 4; s++) {
+ PortType pt = pLoadPorts[s]->getPortType();
+ if (!rmd.armState[0] && pLoadPorts[s]->isEnable()
+ && (pt == PortType::Loading || pt == PortType::Both)
+ && pLoadPorts[s]->getPortStatus() == PORT_INUSE) {
+ m_pActiveRobotTask = createTransferTask(pLoadPorts[s], pAligner, primaryType, secondaryType);
+ if (m_pActiveRobotTask != nullptr) {
+ pEFEM->setContext(m_pActiveRobotTask->getContext());
+ goto PORT_GET;
+ }
}
- 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);
- }
- 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);
- }
- 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);
- }
- LOGI("创建新任务<%s>...", strDescription.c_str());
- continue;
- }
-
-
- // LoadPort -> Fliper(G2)
- // LoadPort -> VacuumBake(G1)
- CEquipment* pEqTar1 = pVacuumBack;
- CEquipment* pEqTar2 = pFliper;
- if (primaryType == MaterialsType::G2) {
- pEqTar1 = pFliper;
- pEqTar2 = pVacuumBack;
- }
- m_pActiveRobotTask = createTransferTask(pLoadPort1, pEqTar1, 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(pLoadPort2, pEqTar1, 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;
- }
-
-
-
- // LoadPort -> VacuumBake(G1)
- m_pActiveRobotTask = createTransferTask(pLoadPort1, pEqTar2, 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(pLoadPort2, pEqTar2, 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;
- }
-
-
- // Measurement -> LoadPort
-
+PORT_GET:
+ CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
unlock();
-
+ continue;
}
+
+ // 千传模式调度逻辑
+ else if (m_state == MASTERSTATE::RUNNING_CONTINUOUS_TRANSFER) {
+ // 检测判断robot状态
+ RMDATA& rmd = pEFEM->getRobotMonitoringData();
+ if (rmd.status != ROBOT_STATUS::Idle && rmd.status != ROBOT_STATUS::Run) {
+ unlock();
+ continue;
+ }
+
+ if (m_pActiveRobotTask != nullptr) {
+ if (m_pActiveRobotTask->isPicked()) {
+ m_pActiveRobotTask->place();
+ }
+ unlock();
+ // 检测到当前有正在下午的任务，确保当前任务完成或中止后继续
+ // LOGI("检测到当前有正在下午的任务，确保当前任务完成或中止后继续...");
+ continue;
+ }
+
+ // Measurement -> LoadPort
+ for (int s = 0; s < 4; s++) {
+ PortType pt = pLoadPorts[s]->getPortType();
+ if ((m_nContinuousTransferStep == CTStep_Unknow || m_nContinuousTransferStep == CTStep_BakeCooling_Measurement)
+ && !rmd.armState[0] && pLoadPorts[s]->isEnable()
+ && (pt == PortType::Unloading || pt == PortType::Both)
+ && pLoadPorts[s]->getPortStatus() == PORT_INUSE) {
+ for (int slot = 0; slot < SLOT_MAX; slot++) {
+ m_pActiveRobotTask = createTransferTask_continuous_transfer(pMeasurement,
+ 0, pLoadPorts[s], slot);
+ if (m_pActiveRobotTask != nullptr) {
+ m_nContinuousTransferStep = CTStep_Measurement_LoadPort;
+ m_nContinuousTransferStep = CTStep_end;
+ goto CT_PORT_PUT;
+ }
+ }
+ }
+ }
+
+ CT_PORT_PUT:
+ CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
+
+
+ // BakeCooling ->Measurement
+ if ((m_nContinuousTransferStep == CTStep_Unknow || m_nContinuousTransferStep == CTStep_BakeCooling_BakeCooling3)
+ && !rmd.armState[0]) {
+ m_pActiveRobotTask = createTransferTask_continuous_transfer(pBakeCooling,
+ 3, pMeasurement, 0);
+ if (m_pActiveRobotTask != nullptr) {
+ m_nContinuousTransferStep = CTStep_BakeCooling_Measurement;
+ LOGI("<ContinuousTransfer>千传测试，开始搬送任务(BakeCooling -> Measurement)...");
+ }
+ CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
+ }
+
+
+ // BakeCooling内部
+ if ((m_nContinuousTransferStep == CTStep_Unknow || m_nContinuousTransferStep == CTStep_BakeCooling_BakeCooling2)
+ && !rmd.armState[0]) {
+ m_pActiveRobotTask = createTransferTask_continuous_transfer(pBakeCooling,
+ 2, pBakeCooling, 3);
+ if (m_pActiveRobotTask != nullptr) {
+ m_nContinuousTransferStep = CTStep_BakeCooling_BakeCooling3;
+ LOGI("<ContinuousTransfer>千传测试，开始搬送任务(BakeCooling-2 -> BakeCooling-3)...");
+ }
+ CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
+ }
+ if ((m_nContinuousTransferStep == CTStep_Unknow || m_nContinuousTransferStep == CTStep_BakeCooling_BakeCooling1)
+ && !rmd.armState[0]) {
+ m_pActiveRobotTask = createTransferTask_continuous_transfer(pBakeCooling,
+ 1, pBakeCooling, 2);
+ if (m_pActiveRobotTask != nullptr) {
+ m_nContinuousTransferStep = CTStep_BakeCooling_BakeCooling2;
+ LOGI("<ContinuousTransfer>千传测试，开始搬送任务(BakeCooling-1 -> BakeCooling-2)...");
+ }
+ CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
+ }
+ if ((m_nContinuousTransferStep == CTStep_Unknow || m_nContinuousTransferStep == CTStep_VacuumBake_BakeCooling)
+ && !rmd.armState[0]) {
+ m_pActiveRobotTask = createTransferTask_continuous_transfer(pBakeCooling,
+ 0, pBakeCooling, 1);
+ if (m_pActiveRobotTask != nullptr) {
+ m_nContinuousTransferStep = CTStep_BakeCooling_BakeCooling1;
+ LOGI("<ContinuousTransfer>千传测试，开始搬送任务(BakeCooling-0 -> BakeCooling-1)...");
+ }
+ CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
+ }
+
+ // VacuumBake(G1) -> BakeCooling
+ if ((m_nContinuousTransferStep == CTStep_Unknow || m_nContinuousTransferStep == CTStep_VacuumBake_VacuumBake)
+ && !rmd.armState[0]) {
+ m_pActiveRobotTask = createTransferTask_continuous_transfer(pVacuumBake,
+ 1, pBakeCooling, 0);
+ if (m_pActiveRobotTask != nullptr) {
+ m_nContinuousTransferStep = CTStep_VacuumBake_BakeCooling;
+ LOGI("<ContinuousTransfer>千传测试，开始搬送任务(VacuumBake(G1) -> BakeCooling)...");
+ }
+ CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
+ }
+
+ // VacuumBake(G1) -> VacuumBake(G1)
+ if ((m_nContinuousTransferStep == CTStep_Unknow || m_nContinuousTransferStep == CTStep_Bonder2_VacuumBake)
+ && !rmd.armState[0]) {
+ m_pActiveRobotTask = createTransferTask_continuous_transfer(pVacuumBake,
+ 0, pVacuumBake, 1);
+ if (m_pActiveRobotTask != nullptr) {
+ m_nContinuousTransferStep = CTStep_VacuumBake_VacuumBake;
+ LOGI("<ContinuousTransfer>千传测试，开始搬送任务(VacuumBake(G1-0) -> VacuumBake(G1-1))...");
+ }
+ CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
+ }
+
+ // Bonder2 -> VacuumBake(G1)
+ if ((m_nContinuousTransferStep == CTStep_Unknow || m_nContinuousTransferStep == CTStep_Bonder1_Bonder2)
+ && !rmd.armState[0]) {
+ m_pActiveRobotTask = createTransferTask_continuous_transfer(pBonder2,
+ 1, pVacuumBake, 0);
+ if (m_pActiveRobotTask != nullptr) {
+ m_nContinuousTransferStep = CTStep_Bonder2_VacuumBake;
+ LOGI("<ContinuousTransfer>千传测试，开始搬送任务(Bonder2 -> VacuumBake(G1))...");
+ }
+ CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
+ }
+
+ // Bonder1 -> Bonder2
+ if ((m_nContinuousTransferStep == CTStep_Unknow || m_nContinuousTransferStep == CTStep_Fliper_Bonder1)
+ && !rmd.armState[0] && !pBonder2->hasBondClass()) {
+ m_pActiveRobotTask = createTransferTask_continuous_transfer(pBonder1,
+ 1, pBonder2, 1);
+ if (m_pActiveRobotTask != nullptr) {
+ m_nContinuousTransferStep = CTStep_Bonder1_Bonder2;
+ LOGI("<ContinuousTransfer>千传测试，开始搬送任务(Bonder1 -> Bonder2)...");
+ }
+ CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
+ }
+
+ // Fliper(G2) -> Bonder1
+ if ((m_nContinuousTransferStep == CTStep_Unknow || m_nContinuousTransferStep == CTStep_Aligner_Fliper)
+ &&!rmd.armState[0] && !pBonder1->hasBondClass()) {
+ m_pActiveRobotTask = createTransferTask_continuous_transfer(pFliper,
+ 0, pBonder1, 1);
+ if (m_pActiveRobotTask != nullptr) {
+ m_nContinuousTransferStep = CTStep_Fliper_Bonder1;
+ LOGI("<ContinuousTransfer>千传测试，开始搬送任务(Fliper(G2) -> Bonder1)...");
+ }
+ CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
+ }
+
+ // Aligner -> Fliper(G2)
+ if ((m_nContinuousTransferStep == CTStep_Unknow || m_nContinuousTransferStep == CTStep_LoadPort_Aligner)
+ && !rmd.armState[1]) {
+ m_pActiveRobotTask = createTransferTask_continuous_transfer(pAligner,
+ 0, pFliper, 0);
+ if (m_pActiveRobotTask != nullptr) {
+ m_nContinuousTransferStep = CTStep_Aligner_Fliper;
+ LOGI("<ContinuousTransfer>千传测试，开始搬送任务(Aligner -> Fliper(G2))...");
+ }
+ CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
+ }
+
+ // LoadPort -> Aligner
+ for (int s = 0; s < 4; s++) {
+ PortType pt = pLoadPorts[s]->getPortType();
+ if ((m_nContinuousTransferStep == CTStep_Unknow || m_nContinuousTransferStep == CTStep_end)
+ && !rmd.armState[0] && pLoadPorts[s]->isEnable()
+ && (pt == PortType::Loading || pt == PortType::Both)
+ && pLoadPorts[s]->getPortStatus() == PORT_INUSE) {
+ for (int slot = 0; slot < SLOT_MAX; slot++) {
+ m_pActiveRobotTask = createTransferTask_continuous_transfer(pLoadPorts[s],
+ slot, pAligner, 0);
+ if (m_pActiveRobotTask != nullptr) {
+ m_nContinuousTransferStep = CTStep_LoadPort_Aligner;
+ LOGI("<ContinuousTransfer>千传测试，开始搬送任务(LoadPort -> Aligner)...");
+ pEFEM->setContext(m_pActiveRobotTask->getContext());
+ goto CT_PORT_GET;
+ }
+ }
+ }
+ }
+
+ CT_PORT_GET:
+ if (m_pActiveRobotTask != nullptr) {
+ m_nContinuousTransferStep = CTStep_begin;
+ LOGI("<ContinuousTransfer>千传测试，开始第 %d 轮", m_nContinuousTransferCount + 1);
+ }
+ CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
+
+
+ unlock();
+ continue;
+ }
+
+
unlock();
}
@@ -558,6 +897,16 @@
unsigned CMaster::ReadBitsProc()
{
+ // 标志位清0复位
+ {
+ StationIdentifier station;
+ station.nNetNo = 0;
+ station.nStNo = 255;
+ char szBuffer[528] = { 0 }; // 0x0, 0x1087
+ m_cclink.WriteData(station, (long)DeviceType::B, 0, 528, (short*)szBuffer);
+ }
+
+
while (1) {
// 待退出信号或时间到
int nRet = ::WaitForSingleObject(m_hEventReadBitsThreadExit[0], 1000);
@@ -567,11 +916,9 @@
// 读标志位
for (auto item : m_listEquipment) {
- if (item->getID() == EQ_ID_Bonder1 ||
- item->getID() == EQ_ID_Bonder2) {
- const StationIdentifier& station = item->getStation();
- MemoryBlock& block = item->getReadBitBlock();
-
+ const StationIdentifier& station = item->getStation();
+ MemoryBlock& block = item->getReadBitBlock();
+ if (block.end > block.start) {
int nRet = m_cclink.ReadData2(station, (DeviceType)block.type,
block.start, block.size, block.buffer);
if (0 == nRet) {
@@ -617,9 +964,11 @@
m_listener.onEqVcrEventReport(this, p, p2);
}
};
- listener.onPreFethedOutJob = [&](void* pEquipment, CJobDataB* pJobDataB) -> BOOL {
+ listener.onPreFethedOutJob = [&](void* pEquipment, int port, CJobDataB* pJobDataB) -> BOOL {
CEquipment* p = (CEquipment*)pEquipment;
+ // 可能要加这一句
+ Sleep(750);
// 取片，更新当前搬送任务
BOOL bOk = FALSE;
@@ -628,10 +977,10 @@
if (m_pActiveRobotTask->getSrcPosition() == p->getID()) {
CGlass* pGlass = p->getGlassFromSlot(m_pActiveRobotTask->getSrcSlot());
if (pGlass != nullptr) {
- CJobDataB* pJobDataBSrc = pGlass->getJobDataB();
- if (pJobDataBSrc != nullptr
- && pJobDataBSrc->getCassetteSequenceNo() == pJobDataB->getCassetteSequenceNo()
- && pJobDataBSrc->getJobSequenceNo() == pJobDataB->getJobSequenceNo()) {
+ CJobDataS* pJobDataS = pGlass->getJobDataS();
+ if (pJobDataS != nullptr
+ && pJobDataS->getCassetteSequenceNo() == pJobDataB->getCassetteSequenceNo()
+ && pJobDataS->getJobSequenceNo() == pJobDataB->getJobSequenceNo()) {
bOk = TRUE;
LOGI("<CMaster>onPreFethedOutJob, 已校验数据一致性.");
}
@@ -650,15 +999,28 @@
return bOk;
};
- listener.onPreStoredJob = [&](void* pEquipment, CJobDataB* pJobDataB, short& slot) -> BOOL {
+ listener.onPreStoredJob = [&](void* pEquipment, int port, CJobDataB* pJobDataB, short& slot) -> BOOL {
CEquipment* p = (CEquipment*)pEquipment;
+ // 可能要加这一句
+ Sleep(750);
// 放片，更新当前搬送任务
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;
@@ -666,15 +1028,22 @@
LOGI("<CMaster>onPreFethedOutJob, 已校验数据一致性.");
}
}
- else if (p->getID() == EQ_ID_ARM_TRAY1 || p->getID() == EQ_ID_ARM_TRAY2) {
- slot = 1;
- bOk = TRUE;
+
+ // 是否回撤
+ else if (m_pActiveRobotTask->isRestoring() &&
+ m_pActiveRobotTask->getSrcPosition() == p->getID()) {
+ CGlass* pGlass = p->getGlassFromSlot(m_pActiveRobotTask->getSrcSlot());
+ if (pGlass == nullptr && m_pActiveRobotTask->getSrcSlot() == port) {
+ bOk = TRUE;
+ slot = m_pActiveRobotTask->getSrcSlot();
+ LOGI("<CMaster>onPreFethedOutJob, 已校验数据一致性.");
+ }
}
}
unlock();
if (!bOk) {
- LOGE("<CMaster>onPreFethedOutJob, 数据校验失败.");
+ LOGE("<CMaster>onPreStoredJob, 数据校验失败.");
}
return bOk;
@@ -691,21 +1060,41 @@
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->picked();
+ }
+
+ else if (m_pActiveRobotTask != nullptr
+ && m_pActiveRobotTask->isPlacing()
+ && m_pActiveRobotTask->getTarPosition() == p->getID()) {
m_pActiveRobotTask->stored();
m_pActiveRobotTask->completed();
- LOGI("放片完成...");
+ if (m_state == MASTERSTATE::RUNNING_CONTINUOUS_TRANSFER) {
+ if (m_nContinuousTransferStep == CTStep_end) {
+ m_nContinuousTransferCount++;
+ LOGI("<ContinuousTransfer>千传测试，第 %d 轮结束", m_nContinuousTransferCount);
+ if (m_listener.onCTRoundEnd != nullptr) {
+ m_listener.onCTRoundEnd(this, m_nContinuousTransferCount);
+ }
+ }
+ }
+
+ LOGI("放片完成...");
// 完成此条搬送任务，但要把数据和消息上抛应用层
unlock();
-
lock();
@@ -715,10 +1104,41 @@
delete m_pActiveRobotTask;
m_pActiveRobotTask = nullptr;
}
+
+ else if (m_pActiveRobotTask != nullptr
+ && m_pActiveRobotTask->isRestoring()
+ && m_pActiveRobotTask->getSrcPosition() == p->getID()) {
+ m_pActiveRobotTask->stored();
+ m_pActiveRobotTask->restored();
+ LOGI("回撤完成...");
+ // 完成此条搬送任务，但要把数据和消息上抛应用层
+ unlock();
+
+
+ lock();
+ if (m_listener.onRobotTaskEvent != nullptr) {
+ m_listener.onRobotTaskEvent(this, m_pActiveRobotTask, ROBOT_EVENT_RESTORE);
+ }
+ delete m_pActiveRobotTask;
+ m_pActiveRobotTask = nullptr;
+ stop();
+ }
unlock();
}
};
-
+ listener.onProcessStateChanged = [&](void* pEquipment, PROCESS_STATE state) -> void {
+ LOGI("<Master>onProcessStateChanged<%d>", (int)state);
+ };
+ listener.onMapMismatch = [&](void* pEquipment, short scanMap, short downMap) {
+ LOGE("<Master-%s>Port InUse, map(%d!=%d)不一致，请检查。",
+ ((CEquipment*)pEquipment)->getName().c_str(), scanMap, downMap);
+ };
+ listener.onPortStatusChanged = [&](void* pEquipment, short status, __int64 data) {
+ LOGE("<Master-%s>onPortStatusChanged。status=%d, data=%lld", ((CEquipment*)pEquipment)->getName().c_str(), status);
+ if (m_listener.onLoadPortStatusChanged != nullptr) {
+ m_listener.onLoadPortStatusChanged(this, (CEquipment*)pEquipment, status, data);
+ }
+ };
pEquipment->setListener(listener);
pEquipment->setCcLink(&m_cclink);
m_listEquipment.push_back(pEquipment);
@@ -732,6 +1152,15 @@
}
CEquipment* CMaster::getEquipment(int id)
+ {
+ for (auto item : m_listEquipment) {
+ if (item->getID() == id) return item;
+ }
+
+ return nullptr;
+ }
+
+ CEquipment* CMaster::getEquipment(int id) const
{
for (auto item : m_listEquipment) {
if (item->getID() == id) return item;
@@ -756,6 +1185,7 @@
pEquipment->setID(EQ_ID_LOADPORT1 + index);
pEquipment->setName(szName);
pEquipment->setDescription(szName);
+ pEquipment->setCompareMapsBeforeProceeding(m_isCompareMapsBeforeProceeding);
addToEquipmentList(pEquipment);
@@ -773,7 +1203,7 @@
pEquipment->setBaseAlarmId(BASE_ALARM_EFEM);
pEquipment->setName("Fliper(G2)");
pEquipment->setDescription("Fliper(G2).");
- pEquipment->setReadBitBlock(0x4000, 0x45ff);
+ pEquipment->setReadBitBlock(0x0, 0x0);
pEquipment->setStation(0, 255);
addToEquipmentList(pEquipment);
@@ -790,7 +1220,7 @@
pEquipment->setBaseAlarmId(BASE_ALARM_EFEM);
pEquipment->setName("VacuumBake(G1)");
pEquipment->setDescription("VacuumBake(G1).");
- pEquipment->setReadBitBlock(0x4000, 0x45ff);
+ pEquipment->setReadBitBlock(0x5c00, 0x66ff);
pEquipment->setStation(0, 255);
addToEquipmentList(pEquipment);
@@ -808,7 +1238,7 @@
pEquipment->setBaseAlarmId(BASE_ALARM_EFEM);
pEquipment->setName("Aligner");
pEquipment->setDescription("Aligner.");
- pEquipment->setReadBitBlock(0x4000, 0x45ff);
+ pEquipment->setReadBitBlock(0x0, 0x0);
pEquipment->setStation(0, 255);
addToEquipmentList(pEquipment);
@@ -901,7 +1331,7 @@
pEquipment->setBaseAlarmId(BASE_ALARM_EFEM);
pEquipment->setName("BakeCooling");
pEquipment->setDescription("BakeCooling.");
- pEquipment->setReadBitBlock(0x4000, 0x45ff);
+ pEquipment->setReadBitBlock(0x5100, 0x5bff);
pEquipment->setStation(0, 255);
addToEquipmentList(pEquipment);
@@ -935,27 +1365,8 @@
}
- // 按一定频率扫描LB数据
static int i = 0;
i++;
- /*
- if (i % (4 * 1) == 0) {
-
- for (auto item : m_listEquipment) {
- if (item->getID() == EQ_ID_Bonder1) {
- const StationIdentifier& station = item->getStation();
- MemoryBlock& block = item->getReadBitBlock();
-
- int nRet = m_cclink.ReadData2(station, (DeviceType)block.type,
- block.start, block.size, block.buffer);
- if (0 == nRet) {
- item->onReceiveLBData(block.buffer, block.size);
- }
- }
- }
- }
- */
-
// 自动保存缓存
if (i % (4 * 2) == 0) {
@@ -982,42 +1393,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"));
@@ -1130,8 +1539,13 @@
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*/)
{
+ if (!pSrcEq->IsEnabled()) {
+ return nullptr;
+ }
+
CRobotTask* pTask = nullptr;
CSlot* pSrcSlot, * pTarSlot;
pTarSlot = pTarEq->getAvailableSlotForGlass(primaryType);
@@ -1146,7 +1560,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());
}
@@ -1156,7 +1570,11 @@
CRobotTask* CMaster::createTransferTask_bonder_to_bakecooling(CEquipment* pSrcEq, CEquipment* pTarEq)
{
- std::vector<int> slots = {1, 2};
+ if (!pSrcEq->IsEnabled()) {
+ return nullptr;
+ }
+
+ std::vector<int> slots = {1, 3};
CRobotTask* pTask = nullptr;
CSlot* pSrcSlot, * pTarSlot;
@@ -1167,7 +1585,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());
}
@@ -1177,8 +1595,12 @@
CRobotTask* CMaster::createTransferTask_bake_to_cooling(CEquipment* pSrcEq)
{
- std::vector<int> slotsTar = { 3, 4 };
- std::vector<int> slotsSrc = { 1, 2 };
+ if (!pSrcEq->IsEnabled()) {
+ return nullptr;
+ }
+
+ std::vector<int> slotsTar = { 2, 4 };
+ std::vector<int> slotsSrc = { 1, 3 };
CRobotTask* pTask = nullptr;
CSlot* pSrcSlot, * pTarSlot;
@@ -1189,7 +1611,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());
}
@@ -1199,7 +1621,11 @@
CRobotTask* CMaster::createTransferTask_bakecooling_to_measurement(CEquipment* pSrcEq, CEquipment* pTarEq)
{
- std::vector<int> slots = { 3, 4 };
+ if (!pSrcEq->IsEnabled()) {
+ return nullptr;
+ }
+
+ std::vector<int> slots = { 2, 4 };
CRobotTask* pTask = nullptr;
CSlot* pSrcSlot, * pTarSlot;
@@ -1209,7 +1635,73 @@
if (pSrcSlot != nullptr && nullptr != pTarSlot) {
pTask = new CRobotTask();
pTask->setContext(pSrcSlot->getContext());
- pTask->setRobotTransferParam(++taskSeqNo, 1, pSrcSlot->getPosition(),
+ pTask->setEFEM((CEFEM*)getEquipment(EQ_ID_EFEM));
+ taskSeqNo = pTask->setRobotTransferParam(taskSeqNo, 1, pSrcSlot->getPosition(),
+ pTarSlot->getPosition(), pSrcSlot->getNo(), pTarSlot->getNo());
+ }
+
+
+ return pTask;
+ }
+
+ CRobotTask* CMaster::createTransferTask_restore(CEquipment* pEqSrc, CLoadPort** pPorts)
+ {
+ if (!pEqSrc->IsEnabled()) {
+ return nullptr;
+ }
+
+ CRobotTask* pTask = nullptr;
+ CSlot* pSrcSlot, * pTarSlot = nullptr, * pTempSlot;
+ pSrcSlot = pEqSrc->getInspFailSlot();
+ if (pSrcSlot != nullptr) {
+ CGlass* pGlass = (CGlass*)pSrcSlot->getContext();
+ ASSERT(pGlass);
+ int port, slot;
+ pGlass->getOrginPort(port, slot);
+ pGlass->setInspResult(pPorts[port]->getID(), 0, InspResult::Fail);
+ ASSERT(0 <= port && port < 4);
+ ASSERT(0 <= slot && slot < 8);
+ pTempSlot = pPorts[port]->getSlot(slot);
+ if (pTempSlot->getContext() == nullptr) {
+ pTarSlot = pTempSlot;
+ }
+ }
+
+
+ if (pSrcSlot != nullptr && nullptr != pTarSlot) {
+ pTask = new CRobotTask();
+ pTask->setContext(pSrcSlot->getContext());
+ pTask->setEFEM((CEFEM*)getEquipment(EQ_ID_EFEM));
+ taskSeqNo = pTask->setRobotTransferParam(taskSeqNo, 1, pSrcSlot->getPosition(),
+ pTarSlot->getPosition(), pSrcSlot->getNo(), pTarSlot->getNo());
+ }
+
+
+ return pTask;
+ }
+
+ CRobotTask* CMaster::createTransferTask_continuous_transfer(CEquipment* pSrcEq, int nSrcSlot,
+ CEquipment* pTarEq, int nTarSlot, int armNo/* = 1*/)
+ {
+ if (!pSrcEq->IsEnabled()) {
+ return nullptr;
+ }
+ if (!pTarEq->IsEnabled()) {
+ return nullptr;
+ }
+
+ CRobotTask* pTask = nullptr;
+ CSlot* pSrcSlot = pSrcEq->getProcessedSlotCt(nSrcSlot);
+ if (pSrcSlot != nullptr && pSrcEq->getID() == EQ_ID_MEASUREMENT
+ && (pTarEq->getID() == EQ_ID_LOADPORT1 || pTarEq->getID() == EQ_ID_LOADPORT2 || pTarEq->getID() == EQ_ID_LOADPORT3 || pTarEq->getID() == EQ_ID_LOADPORT4)) {
+ pTarEq->removeGlass(1);
+ }
+ CSlot* pTarSlot = pTarEq->isSlotAvailable(nTarSlot);
+ if (pSrcSlot != nullptr && nullptr != pTarSlot) {
+ pTask = new CRobotTask();
+ pTask->setContext(pSrcSlot->getContext());
+ pTask->setEFEM((CEFEM*)getEquipment(EQ_ID_EFEM));
+ taskSeqNo = pTask->setRobotTransferParam(taskSeqNo, armNo, pSrcSlot->getPosition(),
pTarSlot->getPosition(), pSrcSlot->getNo(), pTarSlot->getNo());
}
@@ -1237,8 +1729,180 @@
unlock();
// 当前任务手动中止后，停止调度，需要操作员在解决问题后，重新启动
- stop();
+ // 25年7月23日后修改为不停止任务
+ // stop();
return 0;
}
+
+ int CMaster::restoreCurrentTask()
+ {
+ lock();
+ if (m_pActiveRobotTask != nullptr) {
+ m_pActiveRobotTask->restore();
+ }
+ unlock();
+
+
+ return 0;
+ }
+
+ int CMaster::resendCurrentTask()
+ {
+ lock();
+ if (m_pActiveRobotTask != nullptr) {
+ m_pActiveRobotTask->resend();
+ }
+ unlock();
+
+
+ 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);
+ }
+
+ void CMaster::setPortCassetteType(unsigned int index, SERVO::CassetteType type)
+ {
+ ASSERT(index < 4);
+ int eqid[] = { EQ_ID_LOADPORT1, EQ_ID_LOADPORT2, EQ_ID_LOADPORT3, EQ_ID_LOADPORT4 };
+ CLoadPort* pPort = (CLoadPort*)getEquipment(eqid[index]);
+ pPort->localSetCessetteType(type);
+ }
+
+ void CMaster::setPortEnable(unsigned int index, BOOL bEnable)
+ {
+ 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(bEnable);
+ }
+
+ void CMaster::setCompareMapsBeforeProceeding(BOOL bCompare)
+ {
+ m_isCompareMapsBeforeProceeding = bCompare;
+ }
+
+ void CMaster::datetimeSync(SYSTEMTIME& time)
+ {
+ for (auto item : m_listEquipment) {
+ item->setDateTime(time.wYear, time.wMonth, time.wDay,
+ time.wHour, time.wMinute, time.wSecond);
+ }
+ }
+
+ void CMaster::enableEventReport(bool bEnable)
+ {
+ m_bEnableEventReport = bEnable;
+ }
+
+ void CMaster::enableAlarmReport(bool bEnable)
+ {
+ m_bEnableAlarmReport = bEnable;
+ }
+
+ bool CMaster::isAlarmReportEnable()
+ {
+ return m_bEnableAlarmReport;
+ }
+
+ int CMaster::proceedWithCarrier(unsigned int port)
+ {
+ if (port >= 4) return -1;
+
+ static int pid[] = { EQ_ID_LOADPORT1, EQ_ID_LOADPORT2, EQ_ID_LOADPORT3, EQ_ID_LOADPORT4};
+ CLoadPort* pPort = (CLoadPort*)getEquipment(pid[port]);
+ pPort->sendCassetteCtrlCmd(CCC_PROCESS_START, nullptr, 0, 0, 0, nullptr, nullptr);
+ return 0;
+ }
+
+ int CMaster::carrierRelease(unsigned int port)
+ {
+ if (port >= 4) return -1;
+
+ static int pid[] = { EQ_ID_LOADPORT1, EQ_ID_LOADPORT2, EQ_ID_LOADPORT3, EQ_ID_LOADPORT4 };
+ CLoadPort* pPort = (CLoadPort*)getEquipment(pid[port]);
+ pPort->sendCassetteCtrlCmd(CCC_PROCESS_CANCEL, nullptr, 0, 0, 0, nullptr, nullptr);
+ return 0;
+ }
+
+ int CMaster::getContinuousTransferCount()
+ {
+ return m_nContinuousTransferCount;
+ }
+
+ void CMaster::setContinuousTransferCount(int round)
+ {
+ m_nContinuousTransferCount = round;
+ }
+
+ int CMaster::setProcessJobs(std::vector<SERVO::CProcessJob*>& pjs)
+ {
+ std::vector<SERVO::CProcessJob*> temp;
+ for (auto p : pjs) {
+ if (p->validate(*this)) {
+ temp.push_back(p);
+ }
+ }
+
+ m_processJobs = temp;
+ return m_processJobs.size();
+ }
+
+ CLoadPort* CMaster::getPortWithCarrierId(const std::string& carrierId) const
+ {
+ CLoadPort* pPort;
+ int eqid[] = { EQ_ID_LOADPORT1, EQ_ID_LOADPORT2, EQ_ID_LOADPORT3, EQ_ID_LOADPORT4};
+ for (int i = 0; i < 4; i++) {
+ pPort = (CLoadPort*)getEquipment(eqid[i]);
+ ASSERT(pPort);
+ if (pPort->getCassetteId().compare(carrierId) == 0) return pPort;
+ }
+
+ return nullptr;
+ }
+
+ bool CMaster::isProcessJobsEmpty() const
+ {
+ return m_processJobs.empty();
+ }
+
+ bool CMaster::recipeExists(const std::string& ppid) const
+ {
+ std::vector<std::string> vecRecipe = RecipeManager::getInstance().getAllPPID();
+ bool exists = std::find(vecRecipe.begin(), vecRecipe.end(), ppid) != vecRecipe.end();
+ return exists;
+ }
+
+ bool CMaster::carrierPresent(const std::string& carrierId) const
+ {
+ CLoadPort* pPort = getPortWithCarrierId(carrierId);
+ return pPort != nullptr;
+ }
+
+ bool CMaster::slotUsable(const std::string& carrierId, uint16_t slot) const
+ {
+ CLoadPort* pPort = getPortWithCarrierId(carrierId);
+ if(pPort == nullptr) return false;
+ CSlot* pSlot = pPort->getSlot(slot);
+ if (pSlot == nullptr) return false;
+ return pSlot->isEnable();
+ }
+
+ bool CMaster::ceidDefined(uint32_t ceid) const
+ {
+ return true;
+ }
+
}
--
Gitblit v1.9.3