From 6b80da0fe2a6053b39802a6701db6df0ab1fde24 Mon Sep 17 00:00:00 2001
From: mrDarker <mr.darker@163.com>
Date: 星期五, 05 九月 2025 17:27:35 +0800
Subject: [PATCH] 1. 添加设备配方参数显示界面
---
SourceCode/Bond/Servo/CMaster.cpp | 2931 +++++++++++++++++++++++++++++++++++++++++++++--------------
1 files changed, 2,241 insertions(+), 690 deletions(-)
diff --git a/SourceCode/Bond/Servo/CMaster.cpp b/SourceCode/Bond/Servo/CMaster.cpp
index c05e973..405eca3 100644
--- a/SourceCode/Bond/Servo/CMaster.cpp
+++ b/SourceCode/Bond/Servo/CMaster.cpp
@@ -1,20 +1,24 @@
#include "stdafx.h"
#include "Common.h"
#include "CMaster.h"
+#include <future>
+#include <vector>
+#include "RecipeManager.h"
+#include <fstream>
+#include "SerializeUtil.h"
-
-#define ADD_EQ_CASSETTE_TRANSFER_STATE_STEP(name,ws,index,psd) { \
- CEqCassetteTransferStateStep* pStep = new CEqCassetteTransferStateStep(); \
- pStep->setName(name); \
- pStep->setWriteSignalDev(ws); \
- pStep->setPortStatusDev(psd); \
- if (pEquipment->addStep(index, pStep) != 0) { \
- delete pStep; \
- } \
-}
namespace SERVO {
CMaster* g_pMaster = NULL;
+
+ unsigned __stdcall DispatchThreadFunction(LPVOID lpParam)
+ {
+ if (g_pMaster != NULL) {
+ return g_pMaster->DispatchProc();
+ }
+
+ return 0;
+ }
unsigned __stdcall ReadBitsThreadFunction(LPVOID lpParam)
{
@@ -34,20 +38,46 @@
CMaster::CMaster()
{
- m_listener = {nullptr, nullptr, nullptr, nullptr};
+ m_listener = {};
m_bDataModify = FALSE;
m_hEventReadBitsThreadExit[0] = ::CreateEvent(NULL, TRUE, FALSE, NULL);
m_hEventReadBitsThreadExit[1] = ::CreateEvent(NULL, TRUE, FALSE, NULL);
m_hReadBitsThreadHandle = nullptr;
m_nReadBitsThreadAddr = 0;
+ m_hDispatchEvent = ::CreateEvent(NULL, TRUE, FALSE, NULL);
+ m_hEventDispatchThreadExit[0] = ::CreateEvent(NULL, TRUE, FALSE, NULL);
+ m_hEventDispatchThreadExit[1] = ::CreateEvent(NULL, TRUE, FALSE, NULL);
+ m_hDispatchThreadHandle = nullptr;
+ m_nDispatchThreadAddr = 0;
+ m_ullStartTime = 0;
+ m_ullRunTime = 0;
+ m_state = MASTERSTATE::READY;
+ m_pActiveRobotTask = nullptr;
+ m_nLastError = 0;
+ m_isCompareMapsBeforeProceeding = FALSE;
+ m_bJobMode = FALSE;
+ m_bEnableEventReport = true;
+ m_bEnableAlarmReport = true;
+ m_bContinuousTransfer = false;
+ m_bBatch = false;
+ m_nContinuousTransferCount = 0;
+ m_nContinuousTransferStep = CTStep_Unknow;
+ m_pControlJob = nullptr;
+ m_nTestFlag = 0;
+ InitializeCriticalSection(&m_criticalSection);
}
CMaster::~CMaster()
{
- for (auto item : m_listEquipment) {
+ // 释放Job相关
+ for (auto item : m_processJobs) {
delete item;
}
- m_listEquipment.clear();
+ m_processJobs.clear();
+ if (m_pControlJob != nullptr) {
+ delete m_pControlJob;
+ m_pControlJob = nullptr;
+ }
if (m_hEventReadBitsThreadExit[0] != nullptr) {
::CloseHandle(m_hEventReadBitsThreadExit[0]);
@@ -58,14 +88,33 @@
::CloseHandle(m_hEventReadBitsThreadExit[1]);
m_hEventReadBitsThreadExit[1] = nullptr;
}
+
+ if (m_hDispatchEvent != nullptr) {
+ ::CloseHandle(m_hDispatchEvent);
+ m_hDispatchEvent = nullptr;
+ }
+
+ if (m_hEventDispatchThreadExit[0] != nullptr) {
+ ::CloseHandle(m_hEventDispatchThreadExit[0]);
+ m_hEventDispatchThreadExit[0] = nullptr;
+ }
+
+ if (m_hEventDispatchThreadExit[1] != nullptr) {
+ ::CloseHandle(m_hEventDispatchThreadExit[1]);
+ m_hEventDispatchThreadExit[1] = nullptr;
+ }
+
+ DeleteCriticalSection(&m_criticalSection);
}
void CMaster::setListener(MasterListener listener)
{
- m_listener.onEqAlive = listener.onEqAlive;
- m_listener.onEqCimStateChanged = listener.onEqCimStateChanged;
- m_listener.onEqAlarm = listener.onEqAlarm;
- m_listener.onEqVcrEventReport = listener.onEqVcrEventReport;
+ m_listener = listener;
+ }
+
+ CRobotTask* CMaster::getActiveRobotTask()
+ {
+ return m_pActiveRobotTask;
}
int CMaster::init()
@@ -100,18 +149,68 @@
// 初始化添加各子设备
- addLoadPort(0);
- addLoadPort(1);
- addLoadPort(2);
- addLoadPort(3);
- addFliper();
- addVacuumBake();
- addAligner();
- addEFEM();
- addBonder(0);
- addBonder(1);
- addBakeCooling();
+ CLoadPort* pPort1, * pPort2, * pPort3, * pPort4;
+ CBonder* pBonder1, * pBonder2;
+ CEFEM* pEfem;
+ CArm* pArm;
+ CArmTray* pArmTray1, * pArmTray2;
+ CFliper* pFliper;
+ CVacuumBake* pVacuumBake;
+ CAligner* pAligner;
+ CBakeCooling* pBakeCooling;
+ CMeasurement* pMeasurement;
+
+ pPort1 = addLoadPort(0);
+ pPort2 = addLoadPort(1);
+ pPort3 = addLoadPort(2);
+ pPort4 = addLoadPort(3);
+ pEfem = addEFEM();
+ pArm = addArm();
+ pArmTray1 = addArmTray(0);
+ pArmTray2 = addArmTray(1);
+ pFliper = addFliper();
+ pVacuumBake = addVacuumBake();
+ pAligner = addAligner();
+ pBonder1 = addBonder(0);
+ pBonder2 = addBonder(1);
+ pBakeCooling = addBakeCooling();
+ pMeasurement = addMeasurement();
+
+ ASSERT(pEfem);
+ ASSERT(pFliper);
+ ASSERT(pVacuumBake);
+ ASSERT(pAligner);
+ ASSERT(pBonder1);
+ ASSERT(pBonder2);
+ ASSERT(pBakeCooling);
+ ASSERT(pMeasurement);
+
+ pEfem->setPort(0, pPort1);
+ pEfem->setPort(1, pPort2);
+ pEfem->setPort(2, pPort3);
+ pEfem->setPort(3, pPort4);
+ pEfem->setFliper(pFliper);
+ pEfem->setAligner(pAligner);
+ pEfem->setArmTray(0, pArmTray1);
+ pEfem->setArmTray(1, pArmTray2);
+ pPort1->setArm(pArm);
+ pPort2->setArm(pArm);
+ pPort3->setArm(pArm);
+ pPort4->setArm(pArm);
+ pArmTray1->setArm(pArm);
+ pArmTray2->setArm(pArm);
+ pFliper->setArm(pArm);
+ pVacuumBake->setArm(pArm);
+ pAligner->setArm(pArm);
+ pBonder1->setArm(pArm);
+ pBonder2->setArm(pArm);
+ pBakeCooling->setArm(pArm);
+ pMeasurement->setArm(pArm);
+
connectEquipments();
+
+
+
// 读缓存数据
@@ -123,6 +222,12 @@
SetTimer(NULL, 1, 250, (TIMERPROC)MasterTimerProc);
+ // 调度线程
+ m_hDispatchThreadHandle = (HANDLE)_beginthreadex(NULL, 0, SERVO::DispatchThreadFunction, this,
+ 0, &m_nDispatchThreadAddr);
+
+
+ // 监控bit线程
m_hReadBitsThreadHandle = (HANDLE)_beginthreadex(NULL, 0, SERVO::ReadBitsThreadFunction, this,
0, &m_nReadBitsThreadAddr);
@@ -134,7 +239,9 @@
int CMaster::term()
{
SetEvent(m_hEventReadBitsThreadExit[0]);
+ SetEvent(m_hEventDispatchThreadExit[0]);
::WaitForSingleObject(m_hEventReadBitsThreadExit[1], INFINITE);
+ ::WaitForSingleObject(m_hEventDispatchThreadExit[1], INFINITE);
LOGI("<Master>正在结束程序.");
for (auto item : m_listEquipment) {
@@ -142,13 +249,1002 @@
}
saveCache();
+ lock();
+ if (m_pActiveRobotTask != nullptr) {
+ delete m_pActiveRobotTask;
+ m_pActiveRobotTask = nullptr;
+ }
+ unlock();
+
+ for (auto item : m_listEquipment) {
+ delete item;
+ }
+ m_listEquipment.clear();
return 0;
}
+ int CMaster::start()
+ {
+ if (m_state != MASTERSTATE::READY) {
+ return -1;
+ }
+
+ m_bContinuousTransfer = false;
+ m_bBatch = false;
+ setState(MASTERSTATE::STARTING);
+ m_ullStartTime = GetTickCount64();
+
+ return 0;
+ }
+
+ int CMaster::startContinuousTransfer()
+ {
+ if (m_state != MASTERSTATE::READY) {
+ return -1;
+ }
+
+ m_bContinuousTransfer = true;
+ m_bBatch = false;
+ setState(MASTERSTATE::STARTING);
+ m_ullStartTime = GetTickCount64();
+
+ return 0;
+ }
+
+ int CMaster::startBatch()
+ {
+ if (m_state != MASTERSTATE::READY) {
+ return -1;
+ }
+
+ m_bContinuousTransfer = false;
+ m_bBatch = true;
+ setState(MASTERSTATE::STARTING);
+ m_ullStartTime = GetTickCount64();
+
+ return 0;
+ }
+
+ int CMaster::stop()
+ {
+ // 运行时间为累加结果，本次停止时刷新；
+ lock();
+ if (m_state != MASTERSTATE::RUNNING && m_state != MASTERSTATE::RUNNING_CONTINUOUS_TRANSFER
+ && m_state != MASTERSTATE::RUNNING_BATCH) {
+ unlock();
+ return -1;
+ }
+ m_ullRunTime += (GetTickCount64() - m_ullStartTime);
+ unlock();
+
+
+ // 更新状态
+ setState(MASTERSTATE::STOPPING);
+
+
+ // ControlJob暂停
+ lock();
+ if (m_pControlJob != nullptr) {
+ m_pControlJob->pause();
+ saveState();
+ }
+ unlock();
+
+
+ return 0;
+ }
+
+ void CMaster::clearError()
+ {
+ m_nLastError = 0;
+ m_strLastError = "";
+ setState(MASTERSTATE::READY);
+ }
+
+ ULONGLONG CMaster::getRunTime()
+ {
+ if (m_state == MASTERSTATE::RUNNING || m_state == MASTERSTATE::RUNNING_CONTINUOUS_TRANSFER
+ || m_state == MASTERSTATE::RUNNING_BATCH)
+ return m_ullRunTime + (GetTickCount64() - m_ullStartTime);
+ else
+ return m_ullRunTime;
+ }
+
+ MASTERSTATE CMaster::getState()
+ {
+ return m_state;
+ }
+
+ unsigned CMaster::DispatchProc()
+ {
+ // 优先考虑的类型和次要类型
+ // 一种情况，如果不分主次，一直搬G1, 等到Bonder1和Bonder2都放了G1, Aligner也放了G1,
+ // Bonder1和Bonder2需要的G2就过不来了
+ // 最基本的实现，可以G2和G2轮流搬送，但最好根据Bonder的需求来决定
+ MaterialsType primaryType, secondaryType;
+
+
+ // 各种机器
+ CLoadPort* pLoadPorts[4];
+ CEFEM* pEFEM = (CEFEM*)getEquipment(EQ_ID_EFEM);
+ 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* 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);
+ CBakeCooling* pBakeCooling = (CBakeCooling*)getEquipment(EQ_ID_BAKE_COOLING);
+ CMeasurement* pMeasurement = (CMeasurement*)getEquipment(EQ_ID_MEASUREMENT);
+
+ ASSERT(pEFEM);
+ ASSERT(pLoadPorts[0]);
+ ASSERT(pLoadPorts[1]);
+ ASSERT(pLoadPorts[2]);
+ ASSERT(pLoadPorts[3]);
+ ASSERT(pFliper);
+ ASSERT(pVacuumBake);
+ ASSERT(pAligner);
+ ASSERT(pBonder1);
+ ASSERT(pBonder2);
+ ASSERT(pBakeCooling);
+ ASSERT(pMeasurement);
+
+ while (1) {
+ // 待退出信号或时间到
+ HANDLE hEvents[] = { m_hEventDispatchThreadExit[0], m_hDispatchEvent };
+ int nRet = WaitForMultipleObjects(2, hEvents, FALSE, 500);
+ if (nRet == WAIT_OBJECT_0) {
+ break;
+ }
+
+
+ // 如果状态为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();
+ if(m_bContinuousTransfer)
+ setState(MASTERSTATE::RUNNING_CONTINUOUS_TRANSFER);
+ else if (m_bBatch)
+ setState(MASTERSTATE::RUNNING_BATCH);
+ else
+ setState(MASTERSTATE::RUNNING);
+
+ continue;
+ }
+
+
+ // 处理完成当前事务后，切换到停止或就绪状态
+ else if (m_state == MASTERSTATE::STOPPING) {
+ unlock();
+ 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;
+ }
+
+
+ // 调度逻辑处理
+ else if (m_state == MASTERSTATE::RUNNING) {
+ // 检测判断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;
+ }
+
+
+ // Bonder1、Bonder2、Fliper、VacuumBake、Aligner，统计G2和G1的数量, 配对组数, 多出的类型
+ int nG2Count = 0, nG1Count = 0, nGlassGroup, nExtraType;
+ if (pBonder1->slotHasGlass(0)) {
+ nG2Count++;
+ }
+ if (pBonder1->slotHasGlass(1)) {
+ nG1Count++;
+ }
+
+ if (pBonder2->slotHasGlass(0)) {
+ nG2Count++;
+ }
+ if (pBonder2->slotHasGlass(1)) {
+ nG1Count++;
+ }
+
+ if (pFliper->slotHasGlass(0)) {
+ nG2Count++;
+ }
+
+ if (pVacuumBake->slotHasGlass(0)) {
+ nG1Count++;
+ }
+ if (pVacuumBake->slotHasGlass(1)) {
+ nG1Count++;
+ }
+
+ CGlass* pTempGlass = pAligner->getGlassFromSlot(0);
+ if (pTempGlass != nullptr) {
+ MaterialsType type = pTempGlass->getType();
+ if(type == MaterialsType::G1)
+ nG1Count++;
+ else if (type == MaterialsType::G2)
+ nG2Count++;
+ }
+ nGlassGroup = min(nG1Count, nG2Count);
+
+ if (nG1Count == nG2Count) {
+ nExtraType = 0;
+ }
+ else if (nG1Count > nG2Count) {
+ nExtraType = 1;
+ }
+ else {
+ nExtraType = 2;
+ }
+ secondaryType = MaterialsType::G0;
+
+
+ // Measurement -> LoadPort
+ 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], MaterialsType::G1, secondaryType);
+ if (m_pActiveRobotTask != nullptr) {
+ goto PORT_PUT;
+ }
+ }
+ }
+
+ 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
+ if (!rmd.armState[0]) {
+ m_pActiveRobotTask = createTransferTask_bake_to_cooling(pBakeCooling);
+ CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
+ }
+
+
+ // Bonder -> BakeCooling
+ 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
+ //m_nTestFlag = 1;
+ //pVacuumBake->m_nTestFlag = 1;
+ auto pSrcSlot = pVacuumBake->getProcessedSlot(MaterialsType::G1);
+ //LOGI("<Master>pSrcSlot = %x", pSrcSlot,);
+ if (pSrcSlot != nullptr && !rmd.armState[1]
+ && pBonder1->canPlaceGlassInSlot(0)) {
+ m_pActiveRobotTask = createTransferTask(pFliper, pBonder1, MaterialsType::G2, MaterialsType::G0, 2);
+ CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
+ }
+ if (pSrcSlot != nullptr && !rmd.armState[1]
+ && pBonder2->canPlaceGlassInSlot(0)) {
+ m_pActiveRobotTask = createTransferTask(pFliper, pBonder2, MaterialsType::G2, MaterialsType::G0, 2);
+ CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
+ }
+ //m_nTestFlag = 0
+ ;
+ // VacuumBake(G1) -> Bonder
+ if (!rmd.armState[0] && pBonder1->slotHasGlass(0) && !pBonder1->slotHasGlass(1)) {
+ m_pActiveRobotTask = createTransferTask(pVacuumBake, pBonder1, MaterialsType::G1, MaterialsType::G0);
+ CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
+ }
+
+ if (!rmd.armState[0] && pBonder2->slotHasGlass(0) && !pBonder2->slotHasGlass(1)) {
+ m_pActiveRobotTask = createTransferTask(pVacuumBake, pBonder2, MaterialsType::G1, MaterialsType::G0);
+ CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
+ }
+
+
+ // Aligner -> Fliper(G2)
+ // Aligner -> VacuumBake(G1)
+ if (!rmd.armState[1]) {
+ m_pActiveRobotTask = createTransferTask(pAligner, pFliper, MaterialsType::G2, secondaryType);
+ CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
+ }
+
+ if (!rmd.armState[0]) {
+ // m_nTestFlag = 1;
+ if (m_nTestFlag == 1) LOGI("createTransferTask 004df %d, %d", MaterialsType::G1, secondaryType);
+ m_pActiveRobotTask = createTransferTask(pAligner, pVacuumBake, MaterialsType::G1, secondaryType);
+ CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
+ m_nTestFlag = 0;
+ }
+
+
+ // Aligner -> LoadPort
+ if (!rmd.armState[1]) {
+ m_pActiveRobotTask = createTransferTask_restore(pAligner, pLoadPorts);
+ CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
+ }
+
+
+ // LoadPort -> Aligner
+ if (nGlassGroup >= 2) {
+ unlock();
+ continue;
+ }
+
+ if(nExtraType == 0)
+ primaryType = MaterialsType::G2;
+ else {
+ primaryType = MaterialsType::G1;
+ }
+
+ 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, 1, m_bJobMode);
+ if (m_pActiveRobotTask != nullptr) {
+ CGlass* pGlass = (CGlass*)m_pActiveRobotTask->getContext();
+ if (pGlass->getBuddy() != nullptr) {
+ delete m_pActiveRobotTask;
+ m_pActiveRobotTask = nullptr;
+ continue;
+ }
+
+ pEFEM->setContext(m_pActiveRobotTask->getContext());
+ goto PORT_GET;
+ }
+ }
+ }
+
+PORT_GET:
+ CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
+
+
+ unlock();
+ continue;
+ }
+
+ // 批处理模式，最终以此为准，但先保留之前的单片模式
+ else if (m_state == MASTERSTATE::RUNNING_BATCH) {
+ // 首选检查有没有CControlJob, 状态等
+ if (m_pControlJob == nullptr) {
+ unlock();
+ continue;
+ }
+ CJState state = m_pControlJob->state();
+ if (state == CJState::Completed || state == CJState::Aborted || state == CJState::Failed) {
+ // ConrolJpb已完成
+ LOGI("<Master>ControlJob已经完成或失败中断");
+ unlock();
+ continue;
+ }
+
+
+ if (m_pControlJob->state() == CJState::NoState) {
+ LOGI("<Master>ControlJob已经进入列队");
+ m_pControlJob->queue();
+ }
+ if (m_pControlJob->state() == CJState::Queued) {
+ LOGI("<Master>ControlJob已经启动");
+ m_pControlJob->start();
+
+ if (m_listener.onCjStart != nullptr) {
+ m_listener.onCjStart(this, m_pControlJob);
+ }
+ }
+ if (m_pControlJob->state() == CJState::Paused) {
+ LOGI("<Master>ControlJob已经恢复运行");
+ m_pControlJob->resume();
+ }
+
+
+ // 如果当前未选择CProcessJob, 选择一个
+ if (m_inProcesJobs.empty()) {
+ auto pj = acquireNextProcessJob();
+ if (pj != nullptr) {
+ m_inProcesJobs.push_back(pj);
+
+ // 这里上报PJ Start事件
+ if (m_listener.onPjStart != nullptr) {
+ m_listener.onPjStart(this, pj);
+ }
+ }
+ }
+ if (m_inProcesJobs.empty()) {
+ LOGI("<Master>选择当前ProcessJob失败！");
+ unlock();
+ continue;
+ }
+
+ // 如果当前没有Glass, 选择
+ if (m_queueGlasses.empty()) {
+ int nCount = acquireGlassToQueue();
+ LOGI("<Master>已加入 %d 块Glass到工艺列队！", nCount);
+ }
+
+
+ // 检测判断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;
+ }
+
+
+ // 此处检测优先类型和次要类型（G1或G2）
+ // 如果其中一Bonder有单个玻璃，优先取它的配对类型，否则无所谓了
+ primaryType = MaterialsType::G1;
+ secondaryType = MaterialsType::G2;
+ if ((!pBonder1->canPlaceGlassInSlot(0) && !pBonder1->canPlaceGlassInSlot(1))
+ && (!pBonder2->canPlaceGlassInSlot(0) && !pBonder2->canPlaceGlassInSlot(1))) {
+ // 如果G1和G2都满了，那就看Aligner, 如果Aligner有玻璃为G1, 则取G2
+ CGlass* pGlass = pAligner->getGlassFromSlot(1);
+ if (pGlass != nullptr && pGlass->getType() == MaterialsType::G1) {
+ primaryType = MaterialsType::G2;
+ secondaryType = MaterialsType::G1;
+ }
+ }
+ else if ((pBonder1->canPlaceGlassInSlot(0) && !pBonder1->canPlaceGlassInSlot(1))
+ || (pBonder2->canPlaceGlassInSlot(0) && !pBonder2->canPlaceGlassInSlot(1))) {
+ primaryType = MaterialsType::G2;
+ secondaryType = MaterialsType::G1;
+ }
+
+
+ // 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 BATCH_PORT_PUT;
+ }
+ }
+ }
+
+ BATCH_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
+ if (!rmd.armState[0]) {
+ m_pActiveRobotTask = createTransferTask_bake_to_cooling(pBakeCooling);
+ CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
+ }
+
+
+ // Bonder -> BakeCooling
+ 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->hasBondGlass()) {
+ m_pActiveRobotTask = createTransferTask(pFliper, pBonder1, primaryType, secondaryType, 2);
+ CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
+ }
+ if (pSrcSlot != nullptr && !rmd.armState[1] && !pBonder2->hasBondGlass()) {
+ m_pActiveRobotTask = createTransferTask(pFliper, pBonder2, primaryType, secondaryType, 2);
+ CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
+ }
+
+
+ // VacuumBake(G1) -> Bonder
+ if (!rmd.armState[0] && !pBonder1->hasBondGlass()) {
+ m_pActiveRobotTask = createTransferTask(pVacuumBake, pBonder1, primaryType, secondaryType);
+ CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
+ }
+
+ if (!rmd.armState[0] && !pBonder2->hasBondGlass()) {
+ 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, m_bJobMode);
+ if (m_pActiveRobotTask != nullptr) {
+ CGlass* pGlass = (CGlass*)m_pActiveRobotTask->getContext();
+ if (pGlass->getBuddy() != nullptr) {
+ delete m_pActiveRobotTask;
+ m_pActiveRobotTask = nullptr;
+ continue;
+ }
+
+ pEFEM->setContext(pGlass);
+ pGlass->start();
+ bool bMoved = glassFromQueueToInPorcess(pGlass);
+ if (bMoved) {
+ LOGI("<Master>Glass(%s)从等待列队到工艺列队转移成功.",
+ pGlass->getID().c_str());
+ }
+ else {
+ LOGE("<Master>Glass(%s)从等待列队到工艺列队转移失败.",
+ pGlass->getID().c_str());
+ }
+
+ // 这里上报Panel Start事件
+ if (m_listener.onPanelStart != nullptr) {
+ m_listener.onPanelStart(this, pGlass);
+ }
+
+ goto BATCH_PORT_GET;
+ }
+ }
+ }
+
+ BATCH_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->hasBondGlass()) {
+ 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->hasBondGlass()) {
+ 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();
+ }
+
+ SetEvent(m_hEventDispatchThreadExit[1]);
+
+
+ // _endthreadex(0);
+ TRACE("CMaster::DispatchProc 线程退出\n");
+ return 0;
+ }
+
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);
@@ -156,12 +1252,11 @@
break;
}
+ // 读标志位
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) {
@@ -207,10 +1302,256 @@
m_listener.onEqVcrEventReport(this, p, p2);
}
};
+ listener.onPreFethedOutJob = [&](void* pEquipment, int port, CJobDataB* pJobDataB) -> BOOL {
+ CEquipment* p = (CEquipment*)pEquipment;
+
+ // 可能要加这一句
+ Sleep(750);
+
+ // 取片，更新当前搬送任务
+ BOOL bOk = FALSE;
+ lock();
+ if (m_pActiveRobotTask != nullptr) {
+ LOGI("<CMaster>onPreFethedOutJob 0001.");
+ if (m_pActiveRobotTask->getSrcPosition() == p->getID()) {
+ LOGI("<CMaster>onPreFethedOutJob 0002.");
+ CGlass* pGlass = p->getGlassFromSlot(m_pActiveRobotTask->getSrcSlot());
+ if (pGlass != nullptr) {
+ LOGI("<CMaster>onPreFethedOutJob 0003.");
+ CJobDataS* pJobDataS = pGlass->getJobDataS();
+ if (pJobDataS != nullptr
+ && pJobDataS->getCassetteSequenceNo() == pJobDataB->getCassetteSequenceNo()
+ && pJobDataS->getJobSequenceNo() == pJobDataB->getJobSequenceNo()) {
+ bOk = TRUE;
+ LOGI("<CMaster>onPreFethedOutJob, 已校验数据一致性.");
+ }
+ LOGI("<CMaster>onPreFethedOutJob 0004.");
+ if (pJobDataS != nullptr) {
+ LOGI("<CMaster>onPreFethedOutJob 0005. %d,%d,%d,%d",
+ pJobDataS->getCassetteSequenceNo(),
+ pJobDataB->getCassetteSequenceNo(),
+ pJobDataS->getJobSequenceNo(),
+ pJobDataB->getJobSequenceNo()
+ );
+ }
+ }
+ }
+ else if (p->getID() == EQ_ID_ARM_TRAY1 || p->getID() == EQ_ID_ARM_TRAY2) {
+ bOk = TRUE;
+ }
+ }
+ unlock();
+
+ if (!bOk) {
+ LOGE("<CMaster>onPreFethedOutJob, 数据校验失败.");
+ }
+
+ return bOk;
+
+ };
+ 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->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>onPreStoredJob, 已校验数据一致性.");
+ }
+ }
+
+ // 是否回撤
+ 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>onPreStoredJob, 已校验数据一致性.");
+ }
+ }
+ }
+ unlock();
+
+ if (!bOk) {
+ LOGE("<CMaster>onPreStoredJob, 数据校验失败.");
+ }
+
+ return bOk;
+
+ };
listener.onDataChanged = [&](void* pEquipment, int code) -> void {
m_bDataModify = TRUE;
- };
+ CEquipment* p = (CEquipment*)pEquipment;
+ if (m_listener.onEqDataChanged != nullptr) {
+ m_listener.onEqDataChanged(this, p, 0);
+ }
+ // 取放片，更新当前搬送任务
+ if (code == EDCC_FETCHOUT_JOB) {
+ lock();
+ if (m_pActiveRobotTask != nullptr && m_pActiveRobotTask->getSrcPosition() == p->getID()) {
+ LOGI("开始取片...");
+ }
+ unlock();
+ }
+ else if (code == EDCC_STORED_JOB) {
+ lock();
+ 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();
+
+ 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("放片完成...");
+ // 完成此条搬送任务，但要把数据和消息上抛应用层
+
+ // 如果是搬送回从AOI搬送回Port, 则glass工艺完成
+ if (m_pActiveRobotTask->getSrcPosition() == EQ_ID_MEASUREMENT) {
+ CGlass* pGlass = (CGlass*)m_pActiveRobotTask->getContext();
+ pGlass->complete();
+ this->saveState();
+ bool bMoved = glassFromInPorcessToComplete(pGlass);
+ if (bMoved) {
+ LOGI("<Master>Glass(%s)从工艺列队到完成列队转移成功.",
+ pGlass->getID().c_str());
+ }
+ else {
+ LOGE("<Master>Glass(%s)从工艺列队到完成列队转移失败.",
+ pGlass->getID().c_str());
+ }
+ if (m_listener.onPanelEnd != nullptr) {
+ m_listener.onPanelEnd(this, pGlass);
+ }
+
+ // 检查PJ是否已经完成
+ CProcessJob* pJob = getGlassProcessJob((CGlass*)m_pActiveRobotTask->getContext());
+ if (pJob != nullptr && checkAndUpdatePjComplete(pJob)) {
+ this->saveState();
+ LOGE("<Master>ProcessJob(%s)完成.",
+ pJob->id().c_str());
+ if (m_listener.onPjEnd != nullptr) {
+ m_listener.onPjEnd(this, pJob);
+ }
+
+ // 检查CJ是否已经完成
+ ASSERT(m_pControlJob);
+ if (checkAndUpdateCjComplete(m_pControlJob)) {
+ this->saveState();
+ LOGE("<Master>ControlJob(%s)完成.",
+ m_pControlJob->id().c_str());
+ if (m_listener.onCjEnd != nullptr) {
+ m_listener.onCjEnd(this, pJob);
+ }
+ }
+ }
+ }
+
+
+
+ unlock();
+
+
+ lock();
+ if (m_listener.onRobotTaskEvent != nullptr) {
+ m_listener.onRobotTaskEvent(this, m_pActiveRobotTask, ROBOT_EVENT_FINISH);
+ }
+ 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 (status == PORT_INUSE && m_pControlJob != nullptr) {
+ CLoadPort* pPort = (CLoadPort*)pEquipment;
+ auto pjs = m_pControlJob->getPjs();
+ for (auto pj : pjs) {
+ auto carrier = pj->getCarrier(pPort->getCassetteId());
+ if (carrier != nullptr) {
+ for (auto slot : carrier->slots) {
+ CGlass* pGlass = pPort->getGlassFromSlot(slot);
+ carrier->contexts.push_back((void*)pGlass);
+ if (pGlass != nullptr) {
+ pGlass->setProcessJob(pj);
+ }
+ }
+ }
+ }
+
+
+ }
+
+ 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);
@@ -232,103 +1573,96 @@
return nullptr;
}
- /* 添加LoadPort1
+ CEquipment* CMaster::getEquipment(int id) const
+ {
+ for (auto item : m_listEquipment) {
+ if (item->getID() == id) return item;
+ }
+
+ return nullptr;
+ }
+
+ /*
+ * 添加LoadPort1
* index -- 0~3
*/
- int CMaster::addLoadPort(int index)
+ CLoadPort* CMaster::addLoadPort(int index)
{
ASSERT(index == 0 || index == 1 || index == 2 || index == 3);
- static char* pszCassetteCtrlCmd[] = {
- STEP_EQ_P1_CASSETTE_CTRL_CMD,
- STEP_EQ_P2_CASSETTE_CTRL_CMD,
- STEP_EQ_P3_CASSETTE_CTRL_CMD,
- STEP_EQ_P4_CASSETTE_CTRL_CMD
- };
- int nWriteSignalDev[] = {0x120, 0x121, 0x122, 0x123};
- int nCtrlCmdDev[] = {0x45, 0x1a5, 0x305, 0x465};
- int nStepDev[] = { 0x480, 0x481, 0x482, 0x483 };
char szName[64];
sprintf_s(szName, 64, "LoadPort %d", index + 1);
CLoadPort* pEquipment = new CLoadPort();
+ pEquipment->setIndex(index);
pEquipment->setID(EQ_ID_LOADPORT1 + index);
pEquipment->setName(szName);
pEquipment->setDescription(szName);
+ pEquipment->setCompareMapsBeforeProceeding(m_isCompareMapsBeforeProceeding);
addToEquipmentList(pEquipment);
-
-
- // step
- {
- CEqCassetteCtrlCmdStep* pStep = new CEqCassetteCtrlCmdStep();
- pStep->setName(pszCassetteCtrlCmd[index]);
- pStep->setWriteSignalDev(nWriteSignalDev[index]);
- pStep->setCtrlCmdDev(nCtrlCmdDev[index]);
- if (pEquipment->addStep(nStepDev[index], pStep) != 0) {
- delete pStep;
- }
- }
pEquipment->init();
LOGE("已添加“%s”.", pEquipment->getName().c_str());
- return 0;
+ return pEquipment;
}
- int CMaster::addFliper()
+ CFliper* CMaster::addFliper()
{
CFliper* pEquipment = new CFliper();
pEquipment->setID(EQ_ID_FLIPER);
pEquipment->setBaseAlarmId(BASE_ALARM_EFEM);
- pEquipment->setName("Fliper");
- pEquipment->setDescription("Fliper.");
- pEquipment->setReadBitBlock(0x4000, 0x45ff);
+ pEquipment->setName("Fliper(G2)");
+ pEquipment->setDescription("Fliper(G2).");
+ pEquipment->setReadBitBlock(0x0, 0x0);
pEquipment->setStation(0, 255);
addToEquipmentList(pEquipment);
pEquipment->init();
LOGE("已添加“Fliper”.");
- return 0;
+ return pEquipment;
}
- int CMaster::addVacuumBake()
+ CVacuumBake* CMaster::addVacuumBake()
{
CVacuumBake* pEquipment = new CVacuumBake();
pEquipment->setID(EQ_ID_VACUUMBAKE);
pEquipment->setBaseAlarmId(BASE_ALARM_EFEM);
- pEquipment->setName("VacuumBake");
- pEquipment->setDescription("VacuumBake.");
- pEquipment->setReadBitBlock(0x4000, 0x45ff);
+ pEquipment->setName("VacuumBake(G1)");
+ pEquipment->setDescription("VacuumBake(G1).");
+ pEquipment->setReadBitBlock(0x5c00, 0x66ff);
pEquipment->setStation(0, 255);
addToEquipmentList(pEquipment);
pEquipment->init();
LOGE("已添加“VacuumBake”.");
- return 0;
+
+ return pEquipment;
}
- int CMaster::addAligner()
+ CAligner* CMaster::addAligner()
{
CAligner* pEquipment = new CAligner();
pEquipment->setID(EQ_ID_ALIGNER);
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);
pEquipment->init();
LOGE("已添加“Aligner”.");
- return 0;
+
+ return pEquipment;
}
- int CMaster::addEFEM()
+ CEFEM* CMaster::addEFEM()
{
CEFEM* pEquipment = new CEFEM();
pEquipment->setID(EQ_ID_EFEM);
@@ -340,415 +1674,49 @@
addToEquipmentList(pEquipment);
- // 添加 step
- {
- CEqModeStep* pStep = new CEqModeStep();
- pStep->setName(STEP_MODE);
- pStep->setWriteSignalDev(0x50);
- pStep->setModeDev(0x5d7d);
- if (pEquipment->addStep(STEP_ID_EQMODE_CHANGED, pStep) != 0) {
- delete pStep;
- }
- }
- {
- CEqStatusStep* pStep = new CEqStatusStep();
- pStep->setName(STEP_STATUS);
- pStep->setWriteSignalDev(0x51);
- pStep->setStatusDev(0x5d59);
- if (pEquipment->addStep(STEP_ID_EQSTATUS_CHANGED, pStep) != 0) {
- delete pStep;
- }
- }
- {
- CEqAlarmStep* pStep = new CEqAlarmStep();
- pStep->setName(STEP_ALARM_BLOCK1);
- pStep->setWriteSignalDev(0x52);
- pStep->setAlarmDev(0x5f0e);
- if (pEquipment->addStep(STEP_ID_EQALARM1, pStep) != 0) {
- delete pStep;
- }
- }
- {
- CEqAlarmStep* pStep = new CEqAlarmStep();
- pStep->setName(STEP_ALARM_BLOCK2);
- pStep->setWriteSignalDev(0x53);
- pStep->setAlarmDev(0x5f3b);
- if (pEquipment->addStep(STEP_ID_EQALARM2, pStep) != 0) {
- delete pStep;
- }
- }
- {
- CEqAlarmStep* pStep = new CEqAlarmStep();
- pStep->setName(STEP_ALARM_BLOCK3);
- pStep->setWriteSignalDev(0x54);
- pStep->setAlarmDev(0x5f68);
- if (pEquipment->addStep(STEP_ID_EQALARM3, pStep) != 0) {
- delete pStep;
- }
- }
- {
- CEqAlarmStep* pStep = new CEqAlarmStep();
- pStep->setName(STEP_ALARM_BLOCK4);
- pStep->setWriteSignalDev(0x55);
- pStep->setAlarmDev(0x5f95);
- if (pEquipment->addStep(STEP_ID_EQALARM4, pStep) != 0) {
- delete pStep;
- }
- }
- {
- CEqAlarmStep* pStep = new CEqAlarmStep();
- pStep->setName(STEP_ALARM_BLOCK5);
- pStep->setWriteSignalDev(0x56);
- pStep->setAlarmDev(0x5fc2);
- if (pEquipment->addStep(STEP_ID_EQALARM5, pStep) != 0) {
- delete pStep;
- }
- }
- {
- CEqProcessStep* pStep = new CEqProcessStep();
- pStep->setName(STEP_PROCESS);
- pStep->setWriteSignalDev(0x57);
- pStep->setProcessDev(0x6b55);
- if (pEquipment->addStep(STEP_ID_PROCESS_DATA_REPORT, pStep) != 0) {
- delete pStep;
- }
- }
- {
- CEqCimModeChangeStep* pStep = new CEqCimModeChangeStep();
- pStep->setName(STEP_CIM_MODE_CHANGE);
- pStep->setWriteSignalDev(0x70);
- pStep->setCimModeDev(0x15);
- if (pEquipment->addStep(STEP_ID_CIMMODE_CHANGED_CMD_REPLY, pStep) != 0) {
- delete pStep;
- }
- }
- {
- CEqCimMessageCmdStep* pStep = new CEqCimMessageCmdStep();
- pStep->setName(STEP_CIM_MESSAGE_CMD);
- pStep->setWriteSignalDev(0x71);
- pStep->setCimMessageDev(0x0);
- if (pEquipment->addStep(STEP_ID_CIM_MSG_SET_CMD_REPLY, pStep) != 0) {
- delete pStep;
- }
- }
- {
- // CIM Message Confirm
- CEqReadIntStep* pStep = new CEqReadIntStep(__INT32, 0x5f80);
- pStep->setName(STEP_EQ_CIM_MESSAGE_CONFIRM);
- pStep->setWriteSignalDev(0x59);
- if (pEquipment->addStep(STEP_ID_CIM_MSG_CONFIRM_REPORT, pStep) != 0) {
- delete pStep;
- }
- }
- {
- // VCR1 Event Report
- CEqVcrEventStep* pStep = new CEqVcrEventStep();
- pStep->setName(STEP_EQ_VCR1_EVENT_REPORT);
- pStep->setWriteSignalDev(0x4a);
- pStep->setReturnDev(0x91e);
- pStep->setVcrEventReportDev(0x5fef);
- if (pEquipment->addStep(STEP_ID_VCR1_EVENT_REPORT, pStep) != 0) {
- delete pStep;
- }
- }
- {
- CEqCimMessageClearStep* pStep = new CEqCimMessageClearStep();
- pStep->setName(STEP_CIM_MESSAGE_CLEAR);
- pStep->setWriteSignalDev(0x72);
- pStep->setClearCimMessageDev(0x13);
- if (pEquipment->addStep(STEP_ID_CIM_MSG_CLEAR_CMD_REPLY, pStep) != 0) {
- delete pStep;
- }
- }
- {
- CEqDateTimeSetCmdStep* pStep = new CEqDateTimeSetCmdStep();
- pStep->setName(STEP_DATETIME_SET_CMD);
- pStep->setWriteSignalDev(0x73);
- pStep->setDateTimeDev(0x16);
- if (pEquipment->addStep(STEP_ID_DATETIME_SET_CMD_REPLY, pStep) != 0) {
- delete pStep;
- }
- }
- {
- CEqVCREnableStep* pStep = new CEqVCREnableStep();
- pStep->setName(STEP_EQ_VCR_ENABLE);
- pStep->setWriteSignalDev(0x74);
- pStep->setEqVCRModeDev(0x1F);
- if (pEquipment->addStep(STEP_ID_VCR_ENABLE_CMD_REPLY, pStep) != 0) {
- delete pStep;
- }
- }
- {
- CEqModeChangeStep* pStep = new CEqModeChangeStep();
- pStep->setName(STEP_EQ_MODE_CHANGE);
- pStep->setWriteSignalDev(0x75);
- pStep->setEqModeDev(0x1E);
- if (pEquipment->addStep(STEP_ID_EQMODE_CHANGE_CMD_REPLY, pStep) != 0) {
- delete pStep;
- }
- }
-
- // Port1
- {
- CEqReadIntStep* pStep = new CEqReadIntStep(__INT16, 0x6010);
- pStep->setName(STEP_EQ_PORT1_TYPE);
- pStep->setWriteSignalDev(0xa0);
- if (pEquipment->addStep(STEP_ID_PORT1_TYPE_CHANGE, pStep) != 0) {
- delete pStep;
- }
- }
- {
- CEqReadIntStep* pStep = new CEqReadIntStep(__INT16, 0x6011);
- pStep->setName(STEP_EQ_PORT1_MODE);
- pStep->setWriteSignalDev(0xa8);
- if (pEquipment->addStep(STEP_ID_PORT1_MODE_CHANGE, pStep) != 0) {
- delete pStep;
- }
- }
- {
- CEqReadIntStep* pStep = new CEqReadIntStep(__INT32, 0x6012);
- pStep->setName(STEP_EQ_PORT1_CASSETTE_TYPE);
- pStep->setWriteSignalDev(0xb0);
- if (pEquipment->addStep(STEP_ID_PORT1_CASSETTE_TYPE_CHANGE, pStep) != 0) {
- delete pStep;
- }
- }
- {
- CEqReadIntStep* pStep = new CEqReadIntStep(__INT16, 0x6014);
- pStep->setName(STEP_EQ_PORT1_TRANSFER_MODE);
- pStep->setWriteSignalDev(0xb8);
- if (pEquipment->addStep(STEP_ID_PORT1_TRANSFER_MODE_CHANGE, pStep) != 0) {
- delete pStep;
- }
- }
- {
- CEqReadIntStep* pStep = new CEqReadIntStep(__INT16, 0x6015);
- pStep->setName(STEP_EQ_PORT1_ENABLE);
- pStep->setWriteSignalDev(0xc0);
- if (pEquipment->addStep(STEP_ID_PORT1_ENABLE_MODE_CHANGE, pStep) != 0) {
- delete pStep;
- }
- }
- {
- CEqReadIntStep* pStep = new CEqReadIntStep(__INT16, 0x6016);
- pStep->setName(STEP_EQ_PORT1_TYPE_ATUO);
- pStep->setWriteSignalDev(0xc8);
- if (pEquipment->addStep(STEP_ID_PORT1_TYPE_AUTO_CHANGE, pStep) != 0) {
- delete pStep;
- }
- }
-
- // Port2
- {
- CEqReadIntStep* pStep = new CEqReadIntStep(__INT16, 0x6020);
- pStep->setName(STEP_EQ_PORT2_TYPE);
- pStep->setWriteSignalDev(0xa1);
- if (pEquipment->addStep(STEP_ID_PORT2_TYPE_CHANGE, pStep) != 0) {
- delete pStep;
- }
- }
- {
- CEqReadIntStep* pStep = new CEqReadIntStep(__INT16, 0x6021);
- pStep->setName(STEP_EQ_PORT2_MODE);
- pStep->setWriteSignalDev(0xa9);
- if (pEquipment->addStep(STEP_ID_PORT2_MODE_CHANGE, pStep) != 0) {
- delete pStep;
- }
- }
- {
- CEqReadIntStep* pStep = new CEqReadIntStep(__INT32, 0x6022);
- pStep->setName(STEP_EQ_PORT2_CASSETTE_TYPE);
- pStep->setWriteSignalDev(0xb1);
- if (pEquipment->addStep(STEP_ID_PORT2_CASSETTE_TYPE_CHANGE, pStep) != 0) {
- delete pStep;
- }
- }
- {
- CEqReadIntStep* pStep = new CEqReadIntStep(__INT16, 0x6024);
- pStep->setName(STEP_EQ_PORT2_TRANSFER_MODE);
- pStep->setWriteSignalDev(0xb9);
- if (pEquipment->addStep(STEP_ID_PORT2_TRANSFER_MODE_CHANGE, pStep) != 0) {
- delete pStep;
- }
- }
- {
- CEqReadIntStep* pStep = new CEqReadIntStep(__INT16, 0x6025);
- pStep->setName(STEP_EQ_PORT2_ENABLE);
- pStep->setWriteSignalDev(0xc1);
- if (pEquipment->addStep(STEP_ID_PORT2_ENABLE_MODE_CHANGE, pStep) != 0) {
- delete pStep;
- }
- }
- {
- CEqReadIntStep* pStep = new CEqReadIntStep(__INT16, 0x6026);
- pStep->setName(STEP_EQ_PORT2_TYPE_ATUO);
- pStep->setWriteSignalDev(0xc9);
- if (pEquipment->addStep(STEP_ID_PORT2_TYPE_AUTO_CHANGE, pStep) != 0) {
- delete pStep;
- }
- }
-
- // Port3
- {
- CEqReadIntStep* pStep = new CEqReadIntStep(__INT16, 0x6030);
- pStep->setName(STEP_EQ_PORT3_TYPE);
- pStep->setWriteSignalDev(0xa2);
- if (pEquipment->addStep(STEP_ID_PORT3_TYPE_CHANGE, pStep) != 0) {
- delete pStep;
- }
- }
- {
- CEqReadIntStep* pStep = new CEqReadIntStep(__INT16, 0x6031);
- pStep->setName(STEP_EQ_PORT3_MODE);
- pStep->setWriteSignalDev(0xaa);
- if (pEquipment->addStep(STEP_ID_PORT3_MODE_CHANGE, pStep) != 0) {
- delete pStep;
- }
- }
- {
- CEqReadIntStep* pStep = new CEqReadIntStep(__INT32, 0x6032);
- pStep->setName(STEP_EQ_PORT3_CASSETTE_TYPE);
- pStep->setWriteSignalDev(0xb2);
- if (pEquipment->addStep(STEP_ID_PORT3_CASSETTE_TYPE_CHANGE, pStep) != 0) {
- delete pStep;
- }
- }
- {
- CEqReadIntStep* pStep = new CEqReadIntStep(__INT16, 0x6034);
- pStep->setName(STEP_EQ_PORT3_TRANSFER_MODE);
- pStep->setWriteSignalDev(0xba);
- if (pEquipment->addStep(STEP_ID_PORT3_TRANSFER_MODE_CHANGE, pStep) != 0) {
- delete pStep;
- }
- }
- {
- CEqReadIntStep* pStep = new CEqReadIntStep(__INT16, 0x6035);
- pStep->setName(STEP_EQ_PORT3_ENABLE);
- pStep->setWriteSignalDev(0xc2);
- if (pEquipment->addStep(STEP_ID_PORT3_ENABLE_MODE_CHANGE, pStep) != 0) {
- delete pStep;
- }
- }
- {
- CEqReadIntStep* pStep = new CEqReadIntStep(__INT16, 0x6036);
- pStep->setName(STEP_EQ_PORT3_TYPE_ATUO);
- pStep->setWriteSignalDev(0xca);
- if (pEquipment->addStep(STEP_ID_PORT3_TYPE_AUTO_CHANGE, pStep) != 0) {
- delete pStep;
- }
- }
-
- // Port4
- {
- CEqReadIntStep* pStep = new CEqReadIntStep(__INT16, 0x6040);
- pStep->setName(STEP_EQ_PORT4_TYPE);
- pStep->setWriteSignalDev(0xa3);
- if (pEquipment->addStep(STEP_ID_PORT4_TYPE_CHANGE, pStep) != 0) {
- delete pStep;
- }
- }
- {
- CEqReadIntStep* pStep = new CEqReadIntStep(__INT16, 0x6041);
- pStep->setName(STEP_EQ_PORT4_MODE);
- pStep->setWriteSignalDev(0xab);
- if (pEquipment->addStep(STEP_ID_PORT4_MODE_CHANGE, pStep) != 0) {
- delete pStep;
- }
- }
- {
- CEqReadIntStep* pStep = new CEqReadIntStep(__INT32, 0x6042);
- pStep->setName(STEP_EQ_PORT4_CASSETTE_TYPE);
- pStep->setWriteSignalDev(0xb3);
- if (pEquipment->addStep(STEP_ID_PORT4_CASSETTE_TYPE_CHANGE, pStep) != 0) {
- delete pStep;
- }
- }
- {
- CEqReadIntStep* pStep = new CEqReadIntStep(__INT16, 0x6044);
- pStep->setName(STEP_EQ_PORT4_TRANSFER_MODE);
- pStep->setWriteSignalDev(0xbb);
- if (pEquipment->addStep(STEP_ID_PORT4_TRANSFER_MODE_CHANGE, pStep) != 0) {
- delete pStep;
- }
- }
- {
- CEqReadIntStep* pStep = new CEqReadIntStep(__INT16, 0x6045);
- pStep->setName(STEP_EQ_PORT4_ENABLE);
- pStep->setWriteSignalDev(0xc3);
- if (pEquipment->addStep(STEP_ID_PORT4_ENABLE_MODE_CHANGE, pStep) != 0) {
- delete pStep;
- }
- }
- {
- CEqReadIntStep* pStep = new CEqReadIntStep(__INT16, 0x6046);
- pStep->setName(STEP_EQ_PORT4_TYPE_ATUO);
- pStep->setWriteSignalDev(STEP_ID_PORT4_TYPE_AUTO_CHANGE);
- if (pEquipment->addStep(0xcb, pStep) != 0) {
- delete pStep;
- }
- }
-
-
- // CEqCassetteTranserStateStep
- ADD_EQ_CASSETTE_TRANSFER_STATE_STEP(STEP_EQ_P1_CASSETTE_EMPTY, 0xd8,
- STEP_ID_PORT1_CASSETTIE_EMPTY, 0x6050);
- ADD_EQ_CASSETTE_TRANSFER_STATE_STEP(STEP_EQ_P1_CASSETTE_LOAD_EADY, 0xe0,
- STEP_ID_PORT1_CASSETTIE_LOAD_READY, 0x6050);
- ADD_EQ_CASSETTE_TRANSFER_STATE_STEP(STEP_EQ_P1_CASSETTE_LOADED, 0xe8,
- STEP_ID_PORT1_CASSETTIE_LOADED, 0x6050);
- ADD_EQ_CASSETTE_TRANSFER_STATE_STEP(STEP_EQ_P1_CASSETTE_INUSE, 0xf0,
- STEP_ID_PORT1_CASSETTIE_INUSE, 0x6050);
- ADD_EQ_CASSETTE_TRANSFER_STATE_STEP(STEP_EQ_P1_CASSETTE_UNLOAD_EADY, 0xf8,
- STEP_ID_PORT1_CASSETTIE_UNLOAD_READY, 0x60f50);
- ADD_EQ_CASSETTE_TRANSFER_STATE_STEP(STEP_EQ_P1_CASSETTE_BLOCKED, 0x100,
- STEP_ID_PORT1_CASSETTIE_BLOCKED, 0x6050);
- ADD_EQ_CASSETTE_TRANSFER_STATE_STEP(STEP_EQ_P2_CASSETTE_EMPTY, 0xd9,
- STEP_ID_PORT2_CASSETTIE_EMPTY, 0x6070);
- ADD_EQ_CASSETTE_TRANSFER_STATE_STEP(STEP_EQ_P2_CASSETTE_LOAD_EADY, 0xe1,
- STEP_ID_PORT2_CASSETTIE_LOAD_READY, 0x6070);
- ADD_EQ_CASSETTE_TRANSFER_STATE_STEP(STEP_EQ_P2_CASSETTE_LOADED, 0xe9,
- STEP_ID_PORT2_CASSETTIE_LOADED, 0x6070);
- ADD_EQ_CASSETTE_TRANSFER_STATE_STEP(STEP_EQ_P2_CASSETTE_INUSE, 0xf1,
- STEP_ID_PORT2_CASSETTIE_INUSE, 0x6070);
- ADD_EQ_CASSETTE_TRANSFER_STATE_STEP(STEP_EQ_P2_CASSETTE_UNLOAD_EADY, 0xf9,
- STEP_ID_PORT2_CASSETTIE_UNLOAD_READY, 0x6070);
- ADD_EQ_CASSETTE_TRANSFER_STATE_STEP(STEP_EQ_P2_CASSETTE_BLOCKED, 0x101,
- STEP_ID_PORT2_CASSETTIE_BLOCKED, 0x6070);
- ADD_EQ_CASSETTE_TRANSFER_STATE_STEP(STEP_EQ_P3_CASSETTE_EMPTY, 0xda,
- STEP_ID_PORT3_CASSETTIE_EMPTY, 0x6090);
- ADD_EQ_CASSETTE_TRANSFER_STATE_STEP(STEP_EQ_P3_CASSETTE_LOAD_EADY, 0xe2,
- STEP_ID_PORT3_CASSETTIE_LOAD_READY, 0x6090);
- ADD_EQ_CASSETTE_TRANSFER_STATE_STEP(STEP_EQ_P3_CASSETTE_LOADED, 0xea,
- STEP_ID_PORT3_CASSETTIE_INUSE, 0x6090);
- ADD_EQ_CASSETTE_TRANSFER_STATE_STEP(STEP_EQ_P3_CASSETTE_INUSE, 0xf2,
- STEP_ID_PORT3_CASSETTIE_INUSE, 0x6090);
- ADD_EQ_CASSETTE_TRANSFER_STATE_STEP(STEP_EQ_P3_CASSETTE_UNLOAD_EADY, 0xfa,
- STEP_ID_PORT3_CASSETTIE_UNLOAD_READY, 0x6090);
- ADD_EQ_CASSETTE_TRANSFER_STATE_STEP(STEP_EQ_P3_CASSETTE_BLOCKED, 0x102,
- STEP_ID_PORT3_CASSETTIE_BLOCKED, 0x6090);
- ADD_EQ_CASSETTE_TRANSFER_STATE_STEP(STEP_EQ_P4_CASSETTE_EMPTY, 0xdb,
- STEP_ID_PORT4_CASSETTIE_EMPTY, 0x60b0);
- ADD_EQ_CASSETTE_TRANSFER_STATE_STEP(STEP_EQ_P4_CASSETTE_LOAD_EADY, 0xe3,
- STEP_ID_PORT4_CASSETTIE_LOAD_READY, 0x60b0);
- ADD_EQ_CASSETTE_TRANSFER_STATE_STEP(STEP_EQ_P4_CASSETTE_LOADED, 0xeb,
- STEP_ID_PORT4_CASSETTIE_LOADED, 0x60b0);
- ADD_EQ_CASSETTE_TRANSFER_STATE_STEP(STEP_EQ_P4_CASSETTE_INUSE, 0xf3,
- STEP_ID_PORT4_CASSETTIE_INUSE, 0x60b0);
- ADD_EQ_CASSETTE_TRANSFER_STATE_STEP(STEP_EQ_P4_CASSETTE_UNLOAD_EADY, 0xfb,
- STEP_ID_PORT4_CASSETTIE_UNLOAD_READY, 0x60b0);
- ADD_EQ_CASSETTE_TRANSFER_STATE_STEP(STEP_EQ_P4_CASSETTE_BLOCKED, 0x103,
- STEP_ID_PORT4_CASSETTIE_BLOCKED, 0x60b0);
-
pEquipment->init();
LOGE("已添加“EFEM(ROBOT)”.");
- return 0;
+
+ return pEquipment;
+ }
+
+ CArm* CMaster::addArm()
+ {
+ CArm* pEquipment = new CArm();
+ pEquipment->setID(EQ_ID_ARM);
+ pEquipment->setBaseAlarmId(BASE_ALARM_EFEM);
+ pEquipment->setName("ARM");
+ pEquipment->setDescription("ARM.");
+ addToEquipmentList(pEquipment);
+
+
+ pEquipment->init();
+ LOGE("已添加“ARM”.");
+
+ return pEquipment;
+ }
+
+ CArmTray* CMaster::addArmTray(int index)
+ {
+ CArmTray* pEquipment = new CArmTray();
+ pEquipment->setID(index == 0 ? EQ_ID_ARM_TRAY1 : EQ_ID_ARM_TRAY2);
+ pEquipment->setBaseAlarmId(BASE_ALARM_EFEM);
+ pEquipment->setName(index == 0 ? "Arm Tray1" : "Arm Tray2");
+ pEquipment->setDescription(index == 0 ? "Arm Tray1." : "Arm Tray2.");
+ addToEquipmentList(pEquipment);
+
+
+ pEquipment->init();
+ LOGE("已添加“%s”.", pEquipment->getName().c_str());
+
+ return pEquipment;
}
/* 添加bonder1 或 bonder2
* index -- 0, bonder1
* index -- 1, bonder2
*/
- int CMaster::addBonder(int index)
+ CBonder* CMaster::addBonder(int index)
{
ASSERT(index == 0 || index == 1);
CBonder* pEquipment = new CBonder();
@@ -758,196 +1726,49 @@
pEquipment->setStation(0, 255);
pEquipment->setReadBitBlock(index == 0 ? 0x3b00 : 0x4600,
index == 0 ? 0x5600 : 0x6100);
+ pEquipment->setIndex(index);
addToEquipmentList(pEquipment);
-
-
- // 添加 step
- {
- CEqModeStep* pStep = new CEqModeStep();
- pStep->setName(STEP_MODE);
- pStep->setWriteSignalDev(index == 0 ? 0x350 : 0x650);
- pStep->setModeDev(index == 0 ? 0x9d7d : 0xdd7d);
- if (pEquipment->addStep(STEP_ID_EQMODE_CHANGED, pStep) != 0) {
- delete pStep;
- }
- }
- {
- CEqStatusStep* pStep = new CEqStatusStep();
- pStep->setName(STEP_STATUS);
- pStep->setWriteSignalDev(index == 0 ? 0x351 : 0x651);
- pStep->setStatusDev(index == 0 ? 0x9d59 : 0xdd59);
- if (pEquipment->addStep(STEP_ID_EQSTATUS_CHANGED, pStep) != 0) {
- delete pStep;
- }
- }
- {
- CEqAlarmStep* pStep = new CEqAlarmStep();
- pStep->setName(STEP_ALARM_BLOCK1);
- pStep->setWriteSignalDev(index == 0 ? 0x352 : 0x652);
- pStep->setAlarmDev(index == 0 ? 0x9f0e : 0xdf0e);
- if (pEquipment->addStep(STEP_ID_EQALARM1, pStep) != 0) {
- delete pStep;
- }
- }
- {
- CEqAlarmStep* pStep = new CEqAlarmStep();
- pStep->setName(STEP_ALARM_BLOCK2);
- pStep->setWriteSignalDev(index == 0 ? 0x353 : 0x653);
- pStep->setAlarmDev(index == 0 ? 0x9f3b : 0xdf3b);
- if (pEquipment->addStep(STEP_ID_EQALARM2, pStep) != 0) {
- delete pStep;
- }
- }
- {
- CEqAlarmStep* pStep = new CEqAlarmStep();
- pStep->setName(STEP_ALARM_BLOCK3);
- pStep->setWriteSignalDev(index == 0 ? 0x354 : 0x654);
- pStep->setAlarmDev(index == 0 ? 0x9f68 : 0xdf68);
- if (pEquipment->addStep(STEP_ID_EQALARM3, pStep) != 0) {
- delete pStep;
- }
- }
- {
- CEqAlarmStep* pStep = new CEqAlarmStep();
- pStep->setName(STEP_ALARM_BLOCK4);
- pStep->setWriteSignalDev(index == 0 ? 0x355 : 0x655);
- pStep->setAlarmDev(index == 0 ? 0x9f95 : 0xdf95);
- if (pEquipment->addStep(STEP_ID_EQALARM4, pStep) != 0) {
- delete pStep;
- }
- }
- {
- CEqAlarmStep* pStep = new CEqAlarmStep();
- pStep->setName(STEP_ALARM_BLOCK5);
- pStep->setWriteSignalDev(index == 0 ? 0x356 : 0x656);
- pStep->setAlarmDev(index == 0 ? 0x9fc2 : 0xdfc2);
- if (pEquipment->addStep(STEP_ID_EQALARM5, pStep) != 0) {
- delete pStep;
- }
- }
- {
- CEqProcessStep* pStep = new CEqProcessStep();
- pStep->setName(STEP_PROCESS);
- pStep->setWriteSignalDev(index == 0 ? 0x357 : 0x657);
- pStep->setProcessDev(index == 0 ? 0xab55 : 0xeb55);
- if (pEquipment->addStep(STEP_ID_PROCESS_DATA_REPORT, pStep) != 0) {
- delete pStep;
- }
- }
- {
- CEqCimModeChangeStep* pStep = new CEqCimModeChangeStep();
- pStep->setName(STEP_CIM_MODE_CHANGE);
- pStep->setWriteSignalDev(index == 0 ? 0x370 : 0x670);
- pStep->setCimModeDev(index == 0 ? 0x965 : 0x12b5);
- if (pEquipment->addStep(STEP_ID_CIMMODE_CHANGED_CMD_REPLY, pStep) != 0) {
- delete pStep;
- }
- }
- {
- CEqCimMessageCmdStep* pStep = new CEqCimMessageCmdStep();
- pStep->setName(STEP_CIM_MESSAGE_CMD);
- pStep->setWriteSignalDev(index == 0 ? 0x371 : 0x671);
- pStep->setCimMessageDev(index == 0 ? 0x950 : 0x12a0);
- if (pEquipment->addStep(STEP_ID_CIM_MSG_SET_CMD_REPLY, pStep) != 0) {
- delete pStep;
- }
- }
- {
- // CIM Message Confirm
- CEqReadIntStep* pStep = new CEqReadIntStep(__INT32, index == 0 ? 0x9d80 : 0xdd80);
- pStep->setName(STEP_EQ_CIM_MESSAGE_CONFIRM);
- pStep->setWriteSignalDev(index == 0 ? 0x359 : 0x659);
- if (pEquipment->addStep(STEP_ID_CIM_MSG_CONFIRM_REPORT, pStep) != 0) {
- delete pStep;
- }
- }
- {
- CEqCimMessageClearStep* pStep = new CEqCimMessageClearStep();
- pStep->setName(STEP_CIM_MESSAGE_CLEAR);
- pStep->setWriteSignalDev(index == 0 ? 0x372 : 0x672);
- pStep->setClearCimMessageDev(index == 0 ? 0x963 : 0x12b3);
- if (pEquipment->addStep(STEP_ID_CIM_MSG_CLEAR_CMD_REPLY, pStep) != 0) {
- delete pStep;
- }
- }
- {
- CEqDateTimeSetCmdStep* pStep = new CEqDateTimeSetCmdStep();
- pStep->setName(STEP_DATETIME_SET_CMD);
- pStep->setWriteSignalDev(index == 0 ? 0x373 : 0x673);
- pStep->setDateTimeDev(index == 0 ? 0x966 : 0x12b6);
- if (pEquipment->addStep(STEP_ID_DATETIME_SET_CMD_REPLY, pStep) != 0) {
- delete pStep;
- }
- }
- {
- CEqModeChangeStep* pStep = new CEqModeChangeStep();
- pStep->setName(STEP_EQ_MODE_CHANGE);
- pStep->setWriteSignalDev(index == 0 ? 0x375 : 0x675);
- pStep->setEqModeDev(index == 0 ? 0x96E : 0x12be);
- if (pEquipment->addStep(STEP_ID_EQMODE_CHANGE_CMD_REPLY, pStep) != 0) {
- delete pStep;
- }
- }
- {
- CEqJobEventStep* pStep = new CEqJobEventStep();
- pStep->setName(STEP_EQ_RECEIVED_JOB_UPS1);
- pStep->setWriteSignalDev(index == 0 ? 0x300 : 0x600);
- pStep->setJobDataDev(index == 0 ? 0x8c90 : 0xcc90);
- if (pEquipment->addStep(STEP_ID_RECIVE_JOB_UPS1, pStep) != 0) {
- delete pStep;
- }
- }
- {
- CEqJobEventStep* pStep = new CEqJobEventStep();
- pStep->setName(STEP_EQ_RECEIVED_JOB_UPS2);
- pStep->setWriteSignalDev(index == 0 ? 0x301 : 0x601);
- pStep->setJobDataDev(index == 0 ? 0x8dd0 : 0xcdd0);
- if (pEquipment->addStep(STEP_ID_RECIVE_JOB_UPS2, pStep) != 0) {
- delete pStep;
- }
- }
- {
- CEqJobEventStep* pStep = new CEqJobEventStep();
- pStep->setName(STEP_EQ_SENT_OUT_JOB_DOWNS1);
- pStep->setWriteSignalDev(index == 0 ? 0x310 : 0x610);
- pStep->setJobDataDev(index == 0 ? 0x8000 : 0xc000);
- if (pEquipment->addStep(STEP_ID_SENT_OUT_JOB_DOWNS1, pStep) != 0) {
- delete pStep;
- }
- }
- {
- CEqJobEventStep* pStep = new CEqJobEventStep();
- pStep->setName(STEP_EQ_SENT_OUT_JOB_DOWNS2);
- pStep->setWriteSignalDev(index == 0 ? 0x311 : 0x611);
- pStep->setJobDataDev(index == 0 ? 0x8140 : 0xc140);
- if (pEquipment->addStep(STEP_ID_SENT_OUT_JOB_DOWNS2, pStep) != 0) {
- delete pStep;
- }
- }
pEquipment->init();
LOGE("已添加“%s”.", pEquipment->getName().c_str());
- return 0;
+ return pEquipment;
}
- int CMaster::addBakeCooling()
+ CBakeCooling* CMaster::addBakeCooling()
{
CBakeCooling* pEquipment = new CBakeCooling();
pEquipment->setID(EQ_ID_BAKE_COOLING);
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);
-
pEquipment->init();
LOGE("已添加“Aligner”.");
- return 0;
+
+ return pEquipment;
+ }
+
+ CMeasurement* CMaster::addMeasurement()
+ {
+ CMeasurement* pEquipment = new CMeasurement();
+ pEquipment->setID(EQ_ID_MEASUREMENT);
+ pEquipment->setBaseAlarmId(BASE_ALARM_EFEM);
+ pEquipment->setName("Measurement");
+ pEquipment->setDescription("Measurement.");
+ pEquipment->setReadBitBlock(0x6700, 0x6e00);
+ pEquipment->setStation(0, 255);
+ addToEquipmentList(pEquipment);
+
+ pEquipment->init();
+ LOGE("已添加“Measurement”.");
+
+ return pEquipment;
}
void CMaster::onTimer(UINT nTimerid)
@@ -957,27 +1778,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) {
@@ -987,6 +1789,61 @@
}
}
+
+
+ // 模拟测试
+ static int aaa = 0;
+ aaa++;
+ if (aaa % 30 == 0) {
+ if (!m_queueGlasses.empty()) {
+ CGlass* pGlass = m_queueGlasses.front();
+ pGlass->start();
+ glassFromQueueToInPorcess(pGlass);
+ this->saveState();
+
+ // 这里上报Panel Start事件
+ if (m_listener.onPanelStart != nullptr) {
+ m_listener.onPanelStart(this, pGlass);
+ }
+ }
+ }
+
+ if (aaa % 45 == 0) {
+ if (!m_inProcesGlasses.empty()) {
+ CGlass* pGlass = m_inProcesGlasses.front();
+ pGlass->complete();
+ glassFromInPorcessToComplete(pGlass);
+ this->saveState();
+
+ // 这里上报Panel End事件
+ if (m_listener.onPanelEnd != nullptr) {
+ m_listener.onPanelEnd(this, pGlass);
+ }
+
+ CProcessJob* pJob = getGlassProcessJob(pGlass);
+ if (pJob != nullptr && checkAndUpdatePjComplete(pJob)) {
+ processJobFromInPorcessToComplete(pJob);
+ this->saveState();
+ LOGE("<Master>ProcessJob(%s)完成.",
+ pJob->id().c_str());
+ if (m_listener.onPjEnd != nullptr) {
+ m_listener.onPjEnd(this, pJob);
+ }
+
+ // 检查CJ是否已经完成
+ ASSERT(m_pControlJob);
+ if (checkAndUpdateCjComplete(m_pControlJob)) {
+ this->saveState();
+ LOGE("<Master>ControlJob(%s)完成.",
+ m_pControlJob->id().c_str());
+ if (m_listener.onCjEnd != nullptr) {
+ m_listener.onCjEnd(this, pJob);
+ }
+ }
+ }
+ }
+ }
+
}
void CMaster::connectEquipments()
@@ -1002,43 +1859,42 @@
CBonder* pBonder1 = (CBonder*)getEquipment(EQ_ID_Bonder1);
CBonder* pBonder2 = (CBonder*)getEquipment(EQ_ID_Bonder2);
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"));
@@ -1051,12 +1907,17 @@
LOGE("连接Bonder2-BakeCooling失败");
}
- nRet = pBakeCooling->getPin("Out1")->connectPin(pLoadPort3->getPin("In"));
+ nRet = pBakeCooling->getPin("Out")->connectPin(pMeasurement->getPin("In"));
if (nRet < 0) {
LOGE("连接BakeCooling-LoadPort3失败");
}
- nRet = pBakeCooling->getPin("Out2")->connectPin(pLoadPort4->getPin("In"));
+ nRet = pMeasurement->getPin("Out1")->connectPin(pLoadPort3->getPin("In"));
+ if (nRet < 0) {
+ LOGE("连接BakeCooling-LoadPort3失败");
+ }
+
+ nRet = pMeasurement->getPin("Out2")->connectPin(pLoadPort4->getPin("In"));
if (nRet < 0) {
LOGE("连接BakeCooling-LoadPort4失败");
}
@@ -1108,15 +1969,23 @@
int CMaster::readCache()
{
- CFile file;
- if (!file.Open(m_strFilepath.c_str(), CFile::modeRead)) {
- return -1;
- }
+ try {
+ CFile file;
+ if (!file.Open(m_strFilepath.c_str(), CFile::modeRead)) {
+ return -1;
+ }
- CArchive ar(&file, CArchive::load);
- serialize(ar);
- ar.Close();
- file.Close();
+ CArchive ar(&file, CArchive::load);
+ serialize(ar);
+ ar.Close();
+ file.Close();
+ }
+ catch (CFileException* e) {
+ TCHAR szErr[512];
+ e->GetErrorMessage(szErr, 512);
+ AfxMessageBox(szErr);
+ e->Delete();
+ }
return 0;
}
@@ -1127,4 +1996,686 @@
item->serialize(ar);
}
}
+
+ void CMaster::setState(MASTERSTATE state)
+ {
+ m_state = state;
+ if (m_listener.onMasterStateChanged != nullptr) {
+ m_listener.onMasterStateChanged(this, m_state);
+ }
+ }
+
+ static int taskSeqNo = 0;
+ CRobotTask* CMaster::createTransferTask(CEquipment* pSrcEq, CEquipment* pTarEq,
+ MaterialsType primaryType/* = MaterialsType::G1*/, MaterialsType secondaryType/* = MaterialsType::G2*/,
+ int armNo/* = 1*/, BOOL bJobMode/* = FALSE*/)
+ {
+ if (!pSrcEq->IsEnabled()) {
+ return nullptr;
+ }
+ CRobotTask* pTask = nullptr;
+ CSlot* pSrcSlot, * pTarSlot;
+ pSrcEq->m_nTestFlag = m_nTestFlag;
+ pTarSlot = pTarEq->getAvailableSlotForGlass(primaryType);
+ pSrcSlot = pSrcEq->getProcessedSlot(primaryType, bJobMode);
+ if (m_nTestFlag == 1) LOGI("createTransferTask 003 %x, %x", pTarSlot, pSrcSlot);
+ if (pSrcSlot == nullptr || nullptr == pTarSlot && secondaryType != SERVO::MaterialsType::G0) {
+ pTarSlot = pTarEq->getAvailableSlotForGlass(secondaryType);
+ pSrcSlot = pSrcEq->getProcessedSlot(secondaryType, bJobMode);
+ }
+ if (m_nTestFlag == 1) LOGI("createTransferTask 004 %x, %x", pTarSlot, pSrcSlot);
+
+ 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());
+ }
+
+
+ return pTask;
+ }
+
+ CRobotTask* CMaster::createTransferTask_bonder_to_bakecooling(CEquipment* pSrcEq, CEquipment* pTarEq)
+ {
+ if (!pSrcEq->IsEnabled()) {
+ return nullptr;
+ }
+
+ std::vector<int> slots = {1, 3};
+
+ CRobotTask* pTask = nullptr;
+ CSlot* pSrcSlot, * pTarSlot;
+ pTarSlot = pTarEq->getAvailableSlotForGlass2(MaterialsType::G1, slots);
+ pSrcSlot = pSrcEq->getProcessedSlot(MaterialsType::G1);
+
+ 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_bake_to_cooling(CEquipment* pSrcEq)
+ {
+ if (!pSrcEq->IsEnabled()) {
+ return nullptr;
+ }
+
+ std::vector<int> slotsTar = { 2, 4 };
+ std::vector<int> slotsSrc = { 1, 3 };
+
+ CRobotTask* pTask = nullptr;
+ CSlot* pSrcSlot, * pTarSlot;
+ pTarSlot = pSrcEq->getAvailableSlotForGlass2(MaterialsType::G1, slotsTar);
+ pSrcSlot = pSrcEq->getProcessedSlot2(MaterialsType::G1, slotsSrc);
+
+ 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_bakecooling_to_measurement(CEquipment* pSrcEq, CEquipment* pTarEq)
+ {
+ if (!pSrcEq->IsEnabled()) {
+ return nullptr;
+ }
+
+ std::vector<int> slots = { 2, 4 };
+
+ CRobotTask* pTask = nullptr;
+ CSlot* pSrcSlot, * pTarSlot;
+ pTarSlot = pTarEq->getAvailableSlotForGlass(MaterialsType::G1);
+ pSrcSlot = pSrcEq->getProcessedSlot2(MaterialsType::G1, slots);
+
+ 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_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());
+ }
+
+
+ return pTask;
+ }
+
+ int CMaster::abortCurrentTask()
+ {
+ lock();
+ if (m_pActiveRobotTask != nullptr) {
+ m_pActiveRobotTask->abort();
+ }
+ unlock();
+
+ if (m_listener.onRobotTaskEvent != nullptr) {
+ m_listener.onRobotTaskEvent(this, m_pActiveRobotTask, ROBOT_EVENT_ABORT);
+ }
+
+ lock();
+ if (m_pActiveRobotTask != nullptr) {
+ delete m_pActiveRobotTask;
+ m_pActiveRobotTask = nullptr;
+ }
+ unlock();
+
+ // 当前任务手动中止后，停止调度，需要操作员在解决问题后，重新启动
+ // 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::setJobMode(BOOL bJobMode)
+ {
+ m_bJobMode = bJobMode;
+ }
+
+ 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<CProcessJob*>& pjs)
+ {
+ std::vector<SERVO::CProcessJob*> temp;
+ for (auto p : pjs) {
+ if (p->validate(*this)) {
+ p->queue();
+ temp.push_back(p);
+ }
+ }
+
+ m_processJobs = temp;
+ this->saveState();
+
+ return (int)m_processJobs.size();
+ }
+
+ std::vector<CProcessJob*>& CMaster::getProcessJobs()
+ {
+ return m_processJobs;
+ }
+
+ CProcessJob* CMaster::getProcessJob(const std::string& id)
+ {
+ for (auto item : m_processJobs) {
+ if (item->id().compare(id) == 0) return item;
+ }
+
+ return nullptr;
+ }
+
+ int CMaster::setControlJob(CControlJob& controlJob)
+ {
+ // 回调：是否参创建ControlJob
+ auto canCreateCjFn = [&](uint32_t& cc, std::string& mm) -> bool {
+ if (m_pControlJob != nullptr) {
+ cc = 1100;
+ mm = "当前ControlJob未结批，不能创建新的ControlJob";
+ return false;
+ }
+ return true;
+ };
+
+
+ // 回调：是否存在
+ auto pjExists = [&](const std::string& id) -> bool {
+ return getProcessJob(id) != nullptr;
+ };
+
+ // 回调：是否可加入 CJ（这里定义：必须是 Queued）
+ auto pjJoinable = [&](const std::string& id) -> bool {
+ auto pj = getProcessJob(id);
+ if (pj == nullptr) return false;
+ return pj->state() == PJState::Queued;
+ };
+
+ bool bRet = controlJob.validateForCreate(canCreateCjFn, pjExists, pjJoinable);
+ if (!bRet) return -1;
+
+ std::vector<CProcessJob*> temps;
+ m_pControlJob = new CControlJob(controlJob);
+ auto pjIds = controlJob.pjIds();
+ for (auto id : pjIds) {
+ auto pj = getProcessJob(id);
+ if (pj != nullptr) {
+ temps.push_back(pj);
+ }
+ }
+ m_pControlJob->setPJs(temps);
+ this->saveState();
+
+
+ return 0;
+ }
+
+ CControlJob* CMaster::getControlJob()
+ {
+ return m_pControlJob;
+ }
+
+ 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;
+ }
+
+ bool CMaster::saveState() const
+ {
+ std::ofstream ofs(m_strStatePath, std::ios::binary);
+ if (!ofs) return false;
+
+ // 文件头
+ uint32_t magic = 0x4D415354; // 'MAST'
+ uint16_t version = 1;
+ ofs.write(reinterpret_cast<const char*>(&magic), sizeof(magic));
+ ofs.write(reinterpret_cast<const char*>(&version), sizeof(version));
+
+ // 保存 ControlJob
+ bool hasCJ = (m_pControlJob != nullptr);
+ ofs.write(reinterpret_cast<const char*>(&hasCJ), sizeof(hasCJ));
+ if (hasCJ) {
+ m_pControlJob->serialize(ofs);
+ }
+
+ // 保存 ProcessJob 列表
+ uint32_t count = static_cast<uint32_t>(m_processJobs.size());
+ ofs.write(reinterpret_cast<const char*>(&count), sizeof(count));
+ for (const auto& job : m_processJobs) {
+ job->serialize(ofs);
+ }
+
+ // 以后可以在这里追加新字段
+ return true;
+ }
+
+ bool CMaster::loadState(const std::string& path)
+ {
+ // 保存文件路径
+ m_strStatePath = path;
+
+
+ std::ifstream ifs(path, std::ios::binary);
+ if (!ifs) return false;
+
+ // 文件头
+ uint32_t magic = 0;
+ uint16_t version = 0;
+ ifs.read(reinterpret_cast<char*>(&magic), sizeof(magic));
+ ifs.read(reinterpret_cast<char*>(&version), sizeof(version));
+
+ if (magic != 0x4D415354) {
+ // 文件不合法
+ return false;
+ }
+
+ if (m_pControlJob != nullptr) {
+ delete m_pControlJob;
+ m_pControlJob = nullptr;
+ }
+
+ // 读取 ControlJob
+ bool hasCJ = false;
+ ifs.read(reinterpret_cast<char*>(&hasCJ), sizeof(hasCJ));
+ if (hasCJ) {
+ m_pControlJob = new CControlJob();
+ if (!CControlJob::deserialize(ifs, *m_pControlJob)) return false;
+ }
+ else {
+ return false;
+ }
+
+ // 读取 ProcessJob 列表
+ uint32_t count = 0;
+ ifs.read(reinterpret_cast<char*>(&count), sizeof(count));
+ m_processJobs.clear();
+ for (uint32_t i = 0; i < count; i++) {
+ CProcessJob* pProcessJob = new CProcessJob();
+ if (!CProcessJob::deserialize(ifs, *pProcessJob)) return false;
+ m_processJobs.push_back(pProcessJob);
+ }
+
+
+ // 找到CProcessJob指针加入列表中
+ std::vector<CProcessJob*> tempPjs;
+ auto ids = m_pControlJob->pjIds();
+ for (auto id : ids) {
+ auto pj = getProcessJob(id);
+ if (pj != nullptr) {
+ tempPjs.push_back(pj);
+ }
+ }
+ m_pControlJob->setPJs(tempPjs);
+
+
+ // 如果版本升级，可在这里判断 version 来加载新字段
+
+
+ return true;
+ }
+
+ CProcessJob* CMaster::acquireNextProcessJob()
+ {
+ auto& pjs = m_pControlJob->getPjs();
+ for (const auto pj : pjs) {
+ if (pj->state() == PJState::Queued) {
+ pj->start();
+ return pj;
+ }
+ }
+
+
+ return nullptr;
+ }
+
+ CGlass* CMaster::acquireNextGlass()
+ {
+ for (auto* pj : m_inProcesJobs) {
+ // 遍历 PJ 的 carriers 和 slots
+ for (auto& cs : pj->carriers()) {
+ for (auto ctx : cs.contexts) {
+ CGlass* pGlass = (CGlass*)ctx;
+ if (pGlass->state() == GlsState::NoState) {
+ pGlass->queue();
+ return pGlass;
+ }
+ }
+ }
+ }
+ return nullptr; // 没有可加工的 Glass
+ }
+
+ int CMaster::acquireGlassToQueue()
+ {
+ int nCount = 0;
+ for (auto* pj : m_inProcesJobs) {
+ // 遍历 PJ 的 carriers 和 slots
+ for (auto& cs : pj->carriers()) {
+ for (auto ctx : cs.contexts) {
+ CGlass* pGlass = (CGlass*)ctx;
+ if (pGlass->state() == GlsState::NoState) {
+ pGlass->queue();
+ if(addGlassToQueue(pGlass)) nCount++;
+ }
+ }
+ }
+ }
+ return nCount;
+ }
+
+ bool CMaster::addGlassToQueue(CGlass* pGlass)
+ {
+ for (auto g : m_queueGlasses) {
+ if (g == pGlass) return false;
+ }
+
+ m_queueGlasses.push_back(pGlass);
+ return true;
+ }
+
+ bool CMaster::glassFromQueueToInPorcess(CGlass* pGlass)
+ {
+ auto it = std::find(m_queueGlasses.begin(), m_queueGlasses.end(), pGlass);
+ if (it != m_queueGlasses.end()) {
+ m_inProcesGlasses.push_back(*it);
+ m_queueGlasses.erase(it);
+ return true;
+ }
+ return false;
+ }
+
+ bool CMaster::glassFromInPorcessToComplete(CGlass* pGlass)
+ {
+ auto it = std::find(m_inProcesGlasses.begin(), m_inProcesGlasses.end(), pGlass);
+ if (it != m_inProcesGlasses.end()) {
+ m_completeGlasses.push_back(*it);
+ m_inProcesGlasses.erase(it);
+ return true;
+ }
+ return false;
+ }
+
+ bool CMaster::processJobFromInPorcessToComplete(CProcessJob* pProcessJob)
+ {
+ auto it = std::find(m_inProcesJobs.begin(), m_inProcesJobs.end(), pProcessJob);
+ if (it != m_inProcesJobs.end()) {
+ m_completeProcessJobs.push_back(*it);
+ m_inProcesJobs.erase(it);
+ return true;
+ }
+ return false;
+ }
+
+ bool CMaster::checkAndUpdatePjComplete(CProcessJob* pJob)
+ {
+ ASSERT(pJob);
+ auto state = pJob->state();
+ if (state != PJState::InProcess && state != PJState::Paused) return false;
+
+ for (auto c : pJob->carriers()) {
+ for (auto g : c.contexts) {
+ auto state = ((CGlass*)g)->state();
+ if (state != GlsState::Aborted && state != GlsState::Completed
+ && state != GlsState::Failed) return false;
+ }
+ }
+
+ return pJob->complete();
+ }
+
+ bool CMaster::checkAndUpdateCjComplete(CControlJob* pJob)
+ {
+ ASSERT(pJob);
+ auto state = pJob->state();
+ if (state != CJState::Executing && state != CJState::Paused) return false;
+
+ for (auto pj : pJob->getPjs()) {
+ auto state = pj->state();
+ if (state != PJState::Aborted && state != PJState::Completed
+ && state != PJState::Failed) {
+ return false;
+ }
+ }
+
+ return pJob->complete();
+ }
+
+ CProcessJob* CMaster::getGlassProcessJob(CGlass* pGlass)
+ {
+ if (m_pControlJob == nullptr) return nullptr;
+ for (auto pj : m_pControlJob->getPjs()) {
+ for (auto c : pj->carriers()) {
+ for (auto g : c.contexts) {
+ if (g == pGlass) return pj;
+ }
+ }
+ }
+
+ return nullptr;
+ }
}
--
Gitblit v1.9.3