From dd4d7532a85ae70e303117a80dd65b3bc803d457 Mon Sep 17 00:00:00 2001
From: chenluhua1980 <Chenluhua@qq.com>
Date: 星期五, 30 一月 2026 15:01:54 +0800
Subject: [PATCH] 1.关于ProcessStart下发数据的完善；
---
SourceCode/Bond/Servo/CMaster.cpp | 3205 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++--
1 files changed, 3,073 insertions(+), 132 deletions(-)
diff --git a/SourceCode/Bond/Servo/CMaster.cpp b/SourceCode/Bond/Servo/CMaster.cpp
index 3bd5d26..d9fb326 100644
--- a/SourceCode/Bond/Servo/CMaster.cpp
+++ b/SourceCode/Bond/Servo/CMaster.cpp
@@ -1,9 +1,24 @@
-#include "stdafx.h"
+锘�#include "stdafx.h"
#include "Common.h"
#include "CMaster.h"
+#include <future>
+#include <vector>
+#include <algorithm>
+#include "RecipeManager.h"
+#include <fstream>
+#include "SerializeUtil.h"
+#include "CServoUtilsTool.h"
+#include "AlarmManager.h"
+#include "ToolUnits.h"
+#include "Model.h"
namespace SERVO {
+ static inline int64_t now_ms_epoch() {
+ using namespace std::chrono;
+ return duration_cast<milliseconds>(system_clock::now().time_since_epoch()).count();
+ }
+
CMaster* g_pMaster = NULL;
unsigned __stdcall DispatchThreadFunction(LPVOID lpParam)
@@ -33,7 +48,7 @@
CMaster::CMaster()
{
- m_listener = {nullptr, nullptr, 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);
@@ -47,12 +62,38 @@
m_ullStartTime = 0;
m_ullRunTime = 0;
m_state = MASTERSTATE::READY;
+ m_curveMode = CurveMode::Production;
m_pActiveRobotTask = nullptr;
+ m_nLastError = ER_CODE_NOERROR;
+ 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_nContinuousWorkingPort = 0;
+ m_nContinuousWorkingSlot = 0;
+ m_pControlJob = nullptr;
+ m_bPauseAlarmRaised = false;
+ m_pModelCtx = nullptr;
+ m_nTestFlag = 0;
InitializeCriticalSection(&m_criticalSection);
}
CMaster::~CMaster()
{
+ // 閲婃斁Job鐩稿叧
+ for (auto item : m_processJobs) {
+ delete item;
+ }
+ m_processJobs.clear();
+ if (m_pControlJob != nullptr) {
+ delete m_pControlJob;
+ m_pControlJob = nullptr;
+ }
+
if (m_hEventReadBitsThreadExit[0] != nullptr) {
::CloseHandle(m_hEventReadBitsThreadExit[0]);
m_hEventReadBitsThreadExit[0] = nullptr;
@@ -78,17 +119,18 @@
m_hEventDispatchThreadExit[1] = nullptr;
}
+
DeleteCriticalSection(&m_criticalSection);
}
void CMaster::setListener(MasterListener listener)
{
- m_listener.onMasterStateChanged = listener.onMasterStateChanged;
- m_listener.onEqAlive = listener.onEqAlive;
- m_listener.onEqCimStateChanged = listener.onEqCimStateChanged;
- m_listener.onEqAlarm = listener.onEqAlarm;
- m_listener.onEqVcrEventReport = listener.onEqVcrEventReport;
- m_listener.onEqDataChanged = listener.onEqDataChanged;
+ m_listener = listener;
+ }
+
+ void CMaster::setModelCtx(CModel* pModel)
+ {
+ m_pModelCtx = pModel;
}
CRobotTask* CMaster::getActiveRobotTask()
@@ -98,36 +140,43 @@
int CMaster::init()
{
- LOGI("<Master>正在初始化...");
+ const ULONGLONG boot_master_begin = GetTickCount64();
+ LOGI("<Master>姝ｅ湪鍒濆鍖�...");
+ LOGI("[BOOT][MASTER] init begin");
// cclink
- if (m_cclink.Connect(CC_LINK_IE_CONTROL_CHANNEL(1)) != 0) {
- LOGE("连接CC-Link失败.");
+ const ULONGLONG boot_cclink_begin = GetTickCount64();
+ const int cc_ret = m_cclink.Connect(CC_LINK_IE_CONTROL_CHANNEL(1));
+ LOGI("[BOOT][MASTER] CC-Link connect ret=%d, cost=%llu ms",
+ cc_ret,
+ (unsigned long long)(GetTickCount64() - boot_cclink_begin));
+ if (cc_ret != 0) {
+ LOGE("杩炴帴CC-Link澶辫触.");
}
else {
- LOGI("连接CC-Link成功.");
+ LOGI("杩炴帴CC-Link鎴愬姛.");
BoardVersion version{};
int nRet = m_cclink.GetBoardVersion(version);
if (nRet == 0) {
- LOGI("版本信息：%s.", version.toString().c_str());
+ LOGD("鐗堟湰淇℃伅锛�%s.", version.toString().c_str());
}
else {
- LOGE("获取CC-Link版本信息失败.");
+ LOGE("鑾峰彇CC-Link鐗堟湰淇℃伅澶辫触.");
}
BoardStatus status;
nRet = m_cclink.GetBoardStatus(status);
if (nRet == 0) {
- LOGI("状态：%s.", status.toString().c_str());
+ LOGD("鐘舵�侊細%s.", status.toString().c_str());
}
else {
- LOGE("获取CC-Link状态失败.");
+ LOGE("鑾峰彇CC-Link鐘舵�佸け璐�.");
}
}
- // 初始化添加各子设备
+ // 鍒濆鍖栨坊鍔犲悇瀛愯澶�
CLoadPort* pPort1, * pPort2, * pPort3, * pPort4;
CBonder* pBonder1, * pBonder2;
CEFEM* pEfem;
@@ -165,9 +214,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);
@@ -190,29 +239,77 @@
-
-
- // 读缓存数据
+ // 璇荤紦瀛樻暟鎹�
+ const ULONGLONG boot_cache_begin = GetTickCount64();
+ const ULONGLONG boot_read_begin = GetTickCount64();
readCache();
+ LOGI("[BOOT][MASTER] readCache finished, cost=%llu ms", (unsigned long long)(GetTickCount64() - boot_read_begin));
+
+ const ULONGLONG boot_state_begin = GetTickCount64();
+ loadState();
+ LOGI("[BOOT][MASTER] loadState finished, cost=%llu ms", (unsigned long long)(GetTickCount64() - boot_state_begin));
+ if (m_listener.onControlJobChanged) {
+ notifyControlJobChanged();
+ }
+
+ LOGI("[BOOT][MASTER] cache/state loaded, cost=%llu ms (since init %llu ms)",
+ (unsigned long long)(GetTickCount64() - boot_cache_begin),
+ (unsigned long long)(GetTickCount64() - boot_master_begin));
- // 定时器
+ // 瀹氭椂鍣�
g_pMaster = this;
SetTimer(NULL, 1, 250, (TIMERPROC)MasterTimerProc);
- // 调度线程
+ // 璋冨害绾跨▼
m_hDispatchThreadHandle = (HANDLE)_beginthreadex(NULL, 0, SERVO::DispatchThreadFunction, this,
0, &m_nDispatchThreadAddr);
- // 监控bit线程
+ // 鐩戞帶bit绾跨▼
m_hReadBitsThreadHandle = (HANDLE)_beginthreadex(NULL, 0, SERVO::ReadBitsThreadFunction, this,
0, &m_nReadBitsThreadAddr);
- LOGI("<Master>初始化完成.");
+ // 鏇茬嚎鏈嶅姟
+ CreateDAQBridgeServer();
+
+
+ LOGI("<Master>鍒濆鍖栧畬鎴�.");
+ LOGI("[BOOT][MASTER] init finished, total cost=%llu ms",
+ (unsigned long long)(GetTickCount64() - boot_master_begin));
return 0;
+ }
+
+ void CMaster::setCurveMode(CurveMode mode)
+ {
+ if (m_curveMode == mode) {
+ return;
+ }
+ m_curveMode = mode;
+ if (m_pCollector != nullptr) {
+ const uint32_t mids[] = {
+ MID_Bonder1, MID_Bonder2,
+ MID_VacuumBakeA, MID_VacuumBakeB,
+ MID_BakeCoolingA, MID_BakeCoolingB
+ };
+ for (uint32_t mid : mids) {
+ if (mode == CurveMode::EmptyChamber) {
+ m_pCollector->batchStart(mid, "EMPTY_CHAMBER", 30 * 60 * 1000ULL); // 绌鸿厰妯″紡锛氬惎鍔ㄩ噰鏍锋壒娆�
+ }
+ else {
+ m_pCollector->batchStop(mid);
+ m_pCollector->buffersClear(mid); // 鍒囧洖鐢熶骇妯″紡锛屾竻鎺夌┖鑵旀暟鎹�
+ }
+ }
+ }
+ LOGI("<Master>CurveMode=%s", mode == CurveMode::EmptyChamber ? "EmptyChamber" : "Production");
+ }
+
+ CurveMode CMaster::getCurveMode() const
+ {
+ return m_curveMode;
}
int CMaster::term()
@@ -222,18 +319,37 @@
::WaitForSingleObject(m_hEventReadBitsThreadExit[1], INFINITE);
::WaitForSingleObject(m_hEventDispatchThreadExit[1], INFINITE);
- LOGI("<Master>正在结束程序.");
+ LOGI("<Master>姝ｅ湪缁撴潫绋嬪簭.");
for (auto item : m_listEquipment) {
item->term();
}
saveCache();
+ lock();
+ if (m_pActiveRobotTask != nullptr) {
+ delete m_pActiveRobotTask;
+ m_pActiveRobotTask = nullptr;
+ }
+ unlock();
for (auto item : m_listEquipment) {
delete item;
}
m_listEquipment.clear();
+ // release manual-remove buffer before glass pool is torn down
+ for (auto* pGlass : m_bufGlass) {
+ if (pGlass != nullptr) {
+ pGlass->release();
+ }
+ }
+ m_bufGlass.clear();
+
+ if (m_pCollector != nullptr) {
+ m_pCollector->stopLoop();
+ delete m_pCollector;
+ m_pCollector = nullptr;
+ }
return 0;
}
@@ -244,28 +360,83 @@
return -1;
}
+ m_bContinuousTransfer = false;
+ m_bBatch = false;
setState(MASTERSTATE::STARTING);
m_ullStartTime = GetTickCount64();
return 0;
}
- int CMaster::stop()
+ int CMaster::startContinuousTransfer()
{
- // 运行时间为累加结果，本次停止时刷新；
- if (m_state != MASTERSTATE::RUNNING) {
+ if (m_state != MASTERSTATE::READY) {
return -1;
}
- m_ullRunTime += (GetTickCount64() - m_ullStartTime);
- setState(MASTERSTATE::STOPPING);
+ 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(int nErCode/* = ER_CODE_NOERROR*/)
+ {
+ // 杩愯鏃堕棿涓虹疮鍔犵粨鏋滐紝鏈鍋滄鏃跺埛鏂帮紱
+ 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();
+
+
+ // 鏇存柊鐘舵��
+ m_nLastError = nErCode;
+ 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)
+ 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;
@@ -278,69 +449,890 @@
unsigned CMaster::DispatchProc()
{
+ // 浼樺厛鑰冭檻鐨勭被鍨嬪拰娆¤绫诲瀷
+ // 涓�绉嶆儏鍐碉紝濡傛灉涓嶅垎涓绘锛屼竴鐩存惉G1, 绛夊埌Bonder1鍜孊onder2閮芥斁浜咷1, Aligner涔熸斁浜咷1,
+ // Bonder1鍜孊onder2闇�瑕佺殑G2灏辫繃涓嶆潵浜�
+ // 鏈�鍩烘湰鐨勫疄鐜帮紝鍙互G2鍜孏2杞祦鎼�侊紝浣嗘渶濂芥牴鎹瓸onder鐨勯渶姹傛潵鍐冲畾
+ 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, 1000);
+ int nRet = WaitForMultipleObjects(2, hEvents, FALSE, 500);
if (nRet == WAIT_OBJECT_0) {
break;
}
- // 如果状态为STARTING，开始工作并切换到RUNNING状态
+ // 濡傛灉鐘舵�佷负STARTING锛屽紑濮嬪伐浣滃苟鍒囨崲鍒癛UNNING鐘舵��
lock();
if (m_state == MASTERSTATE::STARTING) {
+ // 鍙戦�乮ndexerOperationModeChange鍒板悇涓満鍙帮紝鎴愬姛鍚庡垏鎹㈠埌RUNNING鐘舵��
+ // 鍚﹀垯鍒囨崲鍒癕SERROR鐘舵��
+ 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) {
+ LOGE("<Master>EFEM鍒囨崲Start鐘舵�佸け璐�");
+ m_nLastError = ER_CODE_OPERATION_MODE_FAIL;
+ 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) {
+ LOGE("<Master>Bonder1鍒囨崲Start鐘舵�佸け璐�");
+ m_nLastError = ER_CODE_BONDER_OPERATION_MODE_FAIL;
+ 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) {
+ LOGE("<Master>Bonder2鍒囨崲Start鐘舵�佸け璐�");
+ m_nLastError = ER_CODE_BONDER_OPERATION_MODE_FAIL;
+ 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) {
+ LOGE("<Master>BakeCooling鍒囨崲Start鐘舵�佸け璐�");
+ m_nLastError = ER_CODE_OPERATION_MODE_FAIL;
+ 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) {
+ LOGE("<Master>VacuumBake鍒囨崲Start鐘舵�佸け璐�");
+ m_nLastError = ER_CODE_OPERATION_MODE_FAIL;
+ 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) {
+ LOGE("<Master>Measurement鍒囨崲Start鐘舵�佸け璐�");
+ m_nLastError = ER_CODE_OPERATION_MODE_FAIL;
+ 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;
+ LOGE("<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_CONTINUOUS_TRANSFER);
+ else if (m_bBatch)
+ setState(MASTERSTATE::RUNNING_BATCH);
+ else
+ setState(MASTERSTATE::RUNNING);
+
continue;
}
- // 处理完成当前事务后，切换到停止或就绪状态
+ // 澶勭悊瀹屾垚褰撳墠浜嬪姟鍚庯紝鍒囨崲鍒板仠姝㈡垨灏辩华鐘舵��
else if (m_state == MASTERSTATE::STOPPING) {
unlock();
- Sleep(1000);
- setState(MASTERSTATE::READY);
+ 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) {
+ LOGE("<Master>%s鍒囨崲Stop鐘舵�佸彂閫佸け璐�", pEq[i]->getName().c_str());
+ m_nLastError = ER_CODE_OPERATION_MODE_FAIL;
+ 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;
+ LOGE("<Master>%s鍒囨崲Stop鐘舵�佸け璐�", pEq[i]->getName().c_str());
+ }
+ }
+
+ if (!bIomcOk[6]) {
+ setState(MASTERSTATE::MSERROR);
+ continue;
+ }
+
+ LOGI("<Master>鎵�鏈夎澶囨垚鍔熷垏鎹㈠埌 Stop 妯″紡");
+ if(m_nLastError == ER_CODE_NOERROR)
+ setState(MASTERSTATE::READY);
+ else
+ setState(MASTERSTATE::ATHERERROR);
+
continue;
}
- // 调度逻辑处理
+ // 璋冨害閫昏緫澶勭悊
else if (m_state == MASTERSTATE::RUNNING) {
- unlock();
- LOGI("调度处理中...");
- Sleep(1000);
+ // 妫�娴嬪垽鏂璻obot鐘舵��
+ 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;
+ }
- // LoadPort -> Fliper(G2)
+ // Bonder1銆丅onder2銆丗liper銆乂acuumBake銆丄ligner锛岀粺璁2鍜孏1鐨勬暟閲�, 閰嶅缁勬暟, 澶氬嚭鐨勭被鍨�
+ 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++;
+ }
- // LoadPort -> VacuumBake(G1)
+ if (pFliper->slotHasGlass(0)) {
+ nG2Count++;
+ }
+ if (pVacuumBake->slotHasGlass(0)) {
+ nG1Count++;
+ }
+ if (pVacuumBake->slotHasGlass(1)) {
+ nG1Count++;
+ }
- // Fliper(G2) -> Aligner
-
-
- // VacuumBake(G1) -> Aligner
-
-
- // Aligner -> Bonder
-
-
- // Bonder -> BakeCooling
-
-
- // BakeCooling ->Measurement
+ 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) LOGD("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;
+ }
+
+ pGlass->queue();
+ pGlass->start();
+ 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) {
+ // 1) 鎺у埗浣滀笟鐢熷懡鍛ㄦ湡淇濋殰
+ if (m_pControlJob == nullptr) { unlock(); continue; }
+ CJState cjst = m_pControlJob->state();
+ if (cjst == CJState::Completed || cjst == CJState::Aborted || cjst == CJState::Failed) {
+ unlock();
+ continue;
+ }
+ if (cjst == CJState::NoState) {
+ LOGI("<Master>ControlJob宸茬粡杩涘叆鍒楅槦");
+ m_pControlJob->queue();
+ }
+ if (m_pControlJob->state() == CJState::Queued) {
+ LOGI("<Master>ControlJob宸茬粡鍚姩");
+ m_pControlJob->start();
+ if (m_listener.onCjStart) m_listener.onCjStart(this, m_pControlJob);
+ }
+ if (m_pControlJob->state() == CJState::Paused) {
+ LOGI("<Master>ControlJob宸茬粡鎭㈠杩愯");
+ m_pControlJob->resume();
+ }
+
+ // 2) 鑻ュ綋鍓嶆棤 PJ锛屽垯閫夋嫨涓�涓苟涓婃姤
+ if (m_inProcesJobs.empty()) {
+ if (auto pj = acquireNextProcessJob()) {
+ m_inProcesJobs.push_back(pj);
+ if (m_listener.onPjStart) m_listener.onPjStart(this, pj);
+ }
+ }
+ if (m_inProcesJobs.empty()) {
+ LOGE("<Master>閫夋嫨褰撳墠ProcessJob澶辫触锛�");
+ unlock();
+ continue;
+ }
+
+ // 3) 鑻ラ槦鍒楁棤 Glass锛屾媺鍙栧埌绛夊緟闃熷垪
+ if (m_queueGlasses.empty()) {
+ int nCount = acquireGlassToQueue();
+ if (nCount > 0) {
+ LOGI("<Master>宸插姞鍏� %d 鍧桮lass鍒板伐鑹哄垪闃燂紒", nCount);
+ }
+ }
+
+ // 4) 鏈哄櫒浜虹姸鎬�
+ RMDATA& rmd = pEFEM->getRobotMonitoringData();
+ if (rmd.status != ROBOT_STATUS::Idle && rmd.status != ROBOT_STATUS::Run) {
+ unlock(); continue;
+ }
+
+ // 5) 姝ｅ湪鎵ц鐨� RobotTask 鍏堣瀹冭窇瀹屼竴鎷�
+ if (m_pActiveRobotTask != nullptr) {
+ if (m_pActiveRobotTask->isPicked()) {
+ m_pActiveRobotTask->place();
+ }
+ unlock(); // 绛夊綋鍓嶄换鍔″畬鎴愭垨涓鍚庣户缁�
+ continue;
+ }
+
+ // 5.5) 鏆傚仠鐘舵�佹鏌ワ細鑻� CJ 鎴栧湪鍒� PJ 澶勪簬 Paused锛屾殏缂撹皟搴︽柊鐨勬惉閫�
+ bool pausedByEvent = false;
+ if (m_pControlJob != nullptr && m_pControlJob->state() == CJState::Paused) {
+ pausedByEvent = true;
+ }
+ for (auto pj : m_inProcesJobs) {
+ if (pj != nullptr && pj->state() == PJState::Paused) {
+ pausedByEvent = true;
+ break;
+ }
+ }
+ if (!pausedByEvent && m_bPauseAlarmRaised) {
+ if (m_pModelCtx != nullptr) {
+ m_pModelCtx->clearSoftAlarm(ALID_SOFTWARE_PAUSE_EVENT, 0, 0);
+ }
+ else {
+ AlarmManager& alarmManager = AlarmManager::getInstance();
+ alarmManager.clearAlarmByAttributes(ALID_SOFTWARE_PAUSE_EVENT, 0, 0, CToolUnits::getCurrentTimeString());
+ }
+ m_bPauseAlarmRaised = false;
+ }
+ if (pausedByEvent) {
+ LOGI("<Master>璋冨害鏆傚仠锛欳ontrolJob/ProcessJob 澶勪簬 Paused 鐘舵�侊紙鍙兘鐢� PauseEvent 瑙﹀彂锛�");
+ unlock();
+ continue;
+ }
+
+ // 6) 鈥斺�斿叧閿細鍏ㄥ眬缁熻 G1/G2 涓庣粍鏁伴棬闄愶紙涓庡崟鐗囧垎鏀榻愶級鈥斺��
+ auto countG1G2 = [&]() {
+ int g1 = 0, g2 = 0;
+ if (pBonder1->slotHasGlass(0)) g2++;
+ if (pBonder1->slotHasGlass(1)) g1++;
+ if (pBonder2->slotHasGlass(0)) g2++;
+ if (pBonder2->slotHasGlass(1)) g1++;
+ if (pFliper->slotHasGlass(0)) g2++;
+ if (pVacuumBake->slotHasGlass(0)) g1++;
+ if (pVacuumBake->slotHasGlass(1)) g1++;
+ if (auto g = pAligner->getGlassFromSlot(0)) {
+ auto t = g->getType();
+ if (t == MaterialsType::G1) g1++; else if (t == MaterialsType::G2) g2++;
+ }
+ return std::pair<int, int>(g1, g2);
+ };
+
+ int g1Count = 0, g2Count = 0;
+ std::tie(g1Count, g2Count) = countG1G2();
+ int nGlassGroup = min(g1Count, g2Count);
+ int nExtraType = (g1Count == g2Count ? 0 : (g1Count > g2Count ? 1 : 2));
+
+ // primary/secondary 缁熶竴瀹氫箟锛坰econdary 榛樿 G0锛�
+ MaterialsType primaryType = MaterialsType::G1;
+ MaterialsType secondaryType = MaterialsType::G0;
+ if (nExtraType == 0) primaryType = MaterialsType::G2; // 涓庡崟鐗囧垎鏀竴鑷�
+ else primaryType = MaterialsType::G1;
+
+ // 缁勬暟闂ㄩ檺锛氣墺2 缁勬椂涓嶅啀浠� LP 涓婄墖锛岄伩鍏嶅爢绉紙涓庡崟鐗囦竴鑷达級
+ bool blockLoadFromLP = (nGlassGroup >= 2);
+
+ // 7) Measurement -> LoadPort锛堝浐瀹氾細G1 浼樺厛鍥� LP锛�
+ if (rmd.armState[0] || rmd.armState[1]) {
+ LOGD("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], MaterialsType::G1, secondaryType);
+ if (m_pActiveRobotTask != nullptr) { goto BATCH_PORT_PUT; }
+ }
+ }
+
+ BATCH_PORT_PUT:
+ CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
+
+ // 8) Measurement NG -> LoadPort锛堝師浣嶅洖閫�锛�
+ if (!rmd.armState[1]) {
+ m_pActiveRobotTask = createTransferTask_restore(pMeasurement, pLoadPorts);
+ CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
+ }
+
+ // 9) BakeCooling -> Measurement
+ if (!rmd.armState[0]) {
+ m_pActiveRobotTask = createTransferTask_bakecooling_to_measurement(pBakeCooling, pMeasurement);
+ CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
+ }
+
+ // 10) BakeCooling 鍐呴儴锛圔ake -> Cooling锛�
+ if (!rmd.armState[0]) {
+ m_pActiveRobotTask = createTransferTask_bake_to_cooling(pBakeCooling);
+ CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
+ }
+
+ // 11) 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);
+ }
+
+ // 12) Fliper(G2) -> Bonder锛堝墠缃細VacuumBake 鏈� processed G1锛涜緭鍑� G2 鍒� Bonder slot0锛�
+ if (auto pSrcSlot = pVacuumBake->getProcessedSlot(MaterialsType::G1)) {
+ if (!rmd.armState[1] && pBonder1->canPlaceGlassInSlot(0)) {
+ m_pActiveRobotTask = createTransferTask(pFliper, pBonder1, MaterialsType::G2, MaterialsType::G0, 2);
+ CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
+ }
+ if (!rmd.armState[1] && pBonder2->canPlaceGlassInSlot(0)) {
+ m_pActiveRobotTask = createTransferTask(pFliper, pBonder2, MaterialsType::G2, MaterialsType::G0, 2);
+ CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
+ }
+ }
+
+ // 13) VacuumBake(G1) -> Bonder锛堟Ы绾у垽瀹氾細slot0(G2) 宸叉湁涓� slot1(G1) 涓虹┖锛�
+ 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);
+ }
+
+ // 14) Aligner -> Fliper(G2) 浠ュ強 -> VacuumBake(G1)锛堝浐瀹氭槧灏勶級
+ if (!rmd.armState[1]) {
+ m_pActiveRobotTask = createTransferTask(pAligner, pFliper, MaterialsType::G2, MaterialsType::G0);
+ CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
+ }
+ if (!rmd.armState[0]) {
+ m_pActiveRobotTask = createTransferTask(pAligner, pVacuumBake, MaterialsType::G1, MaterialsType::G0);
+ CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
+ }
+
+ // 15) Aligner -> LoadPort锛坮estore锛�
+ if (!rmd.armState[1]) {
+ m_pActiveRobotTask = createTransferTask_restore(pAligner, pLoadPorts);
+ CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
+ }
+
+ // 16) LoadPort -> Aligner锛堝彈缁勬暟闂ㄩ檺鎺у埗锛涚粺涓� buddy/鐘舵�佹椂搴忥級
+ if (blockLoadFromLP) { unlock(); continue; }
+
+ 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) {
+ auto* pGlass = static_cast<CGlass*>(m_pActiveRobotTask->getContext());
+ if (pGlass->getBuddy() != nullptr) {
+ delete m_pActiveRobotTask; m_pActiveRobotTask = nullptr;
+ continue;
+ }
+
+ // 缁熶竴锛歲ueue -> start -> setContext -> move queue鈫抜nProcess -> onPanelStart
+ pGlass->queue();
+ pGlass->start();
+ pEFEM->setContext(pGlass);
+
+ bool bMoved = glassFromQueueToInPorcess(pGlass);
+ if (bMoved) {
+ LOGI("<Master>Glass(%s)浠庣瓑寰呭垪闃熷埌宸ヨ壓鍒楅槦杞Щ鎴愬姛.", pGlass->getID().c_str());
+ }
+ else {
+ LOGE("<Master>Glass(%s)浠庣瓑寰呭垪闃熷埌宸ヨ壓鍒楅槦杞Щ澶辫触.", pGlass->getID().c_str());
+ }
+
+ if (m_listener.onPanelStart) 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) {
+ // 妫�娴嬪垽鏂璻obot鐘舵��
+ 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 p = 0; p < 4; p++) {
+ if (p != m_nContinuousWorkingPort) continue;
+ PortType pt = pLoadPorts[p]->getPortType();
+ if ((m_nContinuousTransferStep == CTStep_Unknow || m_nContinuousTransferStep == CTStep_BakeCooling_Measurement)
+ && !rmd.armState[0] && pLoadPorts[p]->isEnable()
+ && (pt == PortType::Unloading || pt == PortType::Both)
+ && pLoadPorts[p]->getPortStatus() == PORT_INUSE) {
+ for (int slot = 0; slot < SLOT_MAX; slot++) {
+ if (slot != m_nContinuousWorkingSlot) continue;
+ m_pActiveRobotTask = createTransferTask_continuous_transfer(pMeasurement,
+ 0, pLoadPorts[p], 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 p = 0; p < 4; p++) {
+ PortType pt = pLoadPorts[p]->getPortType();
+ if ((m_nContinuousTransferStep == CTStep_Unknow || m_nContinuousTransferStep == CTStep_end)
+ && !rmd.armState[0] && pLoadPorts[p]->isEnable()
+ && (pt == PortType::Loading || pt == PortType::Both)
+ && pLoadPorts[p]->getPortStatus() == PORT_INUSE) {
+ for (int slot = 0; slot < SLOT_MAX; slot++) {
+ m_pActiveRobotTask = createTransferTask_continuous_transfer(pLoadPorts[p],
+ slot, pAligner, 0);
+ if (m_pActiveRobotTask != nullptr) {
+ m_nContinuousTransferStep = CTStep_LoadPort_Aligner;
+ m_nContinuousWorkingPort = p;
+ m_nContinuousWorkingSlot = slot;
+ 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();
}
@@ -348,25 +1340,34 @@
// _endthreadex(0);
- TRACE("CMaster::DispatchProc 线程退出\n");
+ 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);
if (nRet == WAIT_OBJECT_0) {
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) {
@@ -380,7 +1381,7 @@
// _endthreadex(0);
- TRACE("CMaster::ReadBitsProc 线程退出\n");
+ TRACE("CMaster::ReadBitsProc 绾跨▼閫�鍑篭n");
return 0;
}
@@ -412,14 +1413,533 @@
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) {
+ LOGD("<CMaster>onPreFethedOutJob 0001.");
+ if (m_pActiveRobotTask->getSrcPosition() == p->getID()) {
+ LOGD("<CMaster>onPreFethedOutJob 0002.");
+ CGlass* pGlass = p->getGlassFromSlot(m_pActiveRobotTask->getSrcSlot());
+ if (pGlass != nullptr) {
+ LOGD("<CMaster>onPreFethedOutJob 0003.");
+ CJobDataS* pJobDataS = pGlass->getJobDataS();
+ if (pJobDataS != nullptr
+ && pJobDataS->getCassetteSequenceNo() == pJobDataB->getCassetteSequenceNo()
+ && pJobDataS->getJobSequenceNo() == pJobDataB->getJobSequenceNo()) {
+ bOk = TRUE;
+ LOGD("<CMaster>onPreFethedOutJob, 宸叉牎楠屾暟鎹竴鑷存��.");
+ }
+ LOGD("<CMaster>onPreFethedOutJob 0004.");
+ if (pJobDataS != nullptr) {
+ LOGD("<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("鏀剧墖瀹屾垚...");
+ // 瀹屾垚姝ゆ潯鎼�佷换鍔★紝浣嗚鎶婃暟鎹拰娑堟伅涓婃姏搴旂敤灞�
+
+ // 濡傛灉鏄惉閫佸洖浠嶢OI鎼�佸洖Port, 鍒檊lass宸ヨ壓瀹屾垚
+ if (m_pActiveRobotTask->getSrcPosition() == EQ_ID_MEASUREMENT) {
+ CGlass* pGlass = (CGlass*)m_pActiveRobotTask->getContext();
+ pGlass->complete();
+ CGlass* pBuddy = pGlass->getBuddy();
+ if (pBuddy != nullptr) pBuddy->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);
+ }
+
+ // 妫�鏌J鏄惁宸茬粡瀹屾垚
+ CProcessJob* pJob = getGlassProcessJob((CGlass*)m_pActiveRobotTask->getContext());
+ if (pJob != nullptr && checkAndUpdatePjComplete(pJob)) {
+ this->saveState();
+ LOGE("<Master>ProcessJob(%s)瀹屾垚.",
+ pJob->id().c_str());
+ processJobFromInPorcessToComplete(pJob);
+ if (m_listener.onPjEnd != nullptr) {
+ m_listener.onPjEnd(this, pJob);
+ }
+
+ // 妫�鏌J鏄惁宸茬粡瀹屾垚
+ 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);
+ }
+
+ completeControlJob();
+ }
+ }
+ }
+
+
+
+ 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, int slotNo, PROCESS_STATE prevState, PROCESS_STATE state) -> void {
+ ASSERT(1 <= slotNo && slotNo <= 8);
+ int eqid = ((CEquipment*)pEquipment)->getID();
+ CGlass* pGlass = ((CEquipment*)pEquipment)->getGlassFromSlot(slotNo);
+ LOGI("<Master>onProcessStateChanged<%d>", (int)state);
+ if (state == PROCESS_STATE::Processing) {
+ if (pGlass != nullptr) {
+ m_pCollector->batchStart(SlotToMid(eqid, slotNo),
+ pGlass->getID().c_str(), 10 * 60 * 1000ULL);
+ }
+ }
+ else if (state == PROCESS_STATE::Complete) {
+ if (pGlass != nullptr) {
+ m_pCollector->batchStop(SlotToMid(eqid, slotNo));
+ }
+ }
+
+ if (m_listener.onProcessStateChanged != nullptr) {
+ m_listener.onProcessStateChanged(this, (CEquipment*)pEquipment, slotNo, prevState, state);
+ }
+ };
+ listener.onProcessDataReport = [&](void* pEquipment, const std::vector<CParam>& params) {
+ if (m_listener.onProcessDataReport != nullptr) {
+ m_listener.onProcessDataReport(this, (CEquipment*)pEquipment, params);
+ }
+ };
+ 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銆俿tatus=%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) {
+ carrier->contexts.clear();
+ for (auto slot : carrier->slots) {
+ CGlass* pGlass = pPort->getGlassFromSlot(slot);
+ carrier->contexts.push_back((void*)pGlass);
+ if (pGlass != nullptr) {
+ pGlass->setProcessJob(pj);
+
+ PJWarp& jpWarp = pj->getPjWarp();
+ int nRecipeID = RecipeManager::getInstance().getIdByPPID(pj->recipeSpec());
+ RecipeInfo stRecipeInfo = RecipeManager::getInstance().getRecipeByPPID(pj->recipeSpec());
+ std::vector<DeviceRecipe> vecRecipeInfo = stRecipeInfo.vecDeviceList;
+
+ pGlass->setScheduledForProcessing(jpWarp.checkSlot[slot-1]);
+ pGlass->setType(static_cast<SERVO::MaterialsType>(jpWarp.material[slot-1]));
+
+ SERVO::CJobDataS* pJobDataS = pGlass->getJobDataS();
+ if (pJobDataS != nullptr) {
+ SERVO::CJobDataS* pJobDataS = pGlass->getJobDataS();
+ pJobDataS->setLotId(pj->getLotId().c_str());
+ pJobDataS->setProductId(pj->getProductId().c_str());
+ pJobDataS->setOperationId(pj->getOperationId().c_str());
+ pJobDataS->setMaterialsType(jpWarp.material[slot - 1]);
+ pJobDataS->setMasterRecipe(nRecipeID);
+ for (const auto& info : vecRecipeInfo) {
+ const std::string& name = info.strDeviceName;
+ short nRecipeID = (short)info.nRecipeID;
+
+ if (name == EQ_NAME_EFEM) {
+ pJobDataS->setDeviceRecipeId(0, nRecipeID);
+ }
+ else if (name == EQ_NAME_BONDER1) {
+ pJobDataS->setDeviceRecipeId(1, nRecipeID);
+ }
+ else if (name == EQ_NAME_BONDER2) {
+ pJobDataS->setDeviceRecipeId(2, nRecipeID);
+ }
+ else if (name == EQ_NAME_BAKE_COOLING) {
+ pJobDataS->setDeviceRecipeId(3, nRecipeID);
+ }
+ else if (name == EQ_NAME_VACUUMBAKE) {
+ pJobDataS->setDeviceRecipeId(4, nRecipeID);
+ }
+ else if (name == EQ_NAME_MEASUREMENT) {
+ pJobDataS->setDeviceRecipeId(5, nRecipeID);
+ }
+ }
+
+ }
+ }
+ }
+ }
+ }
+ }
+
+ if (m_listener.onLoadPortStatusChanged != nullptr) {
+ m_listener.onLoadPortStatusChanged(this, (CEquipment*)pEquipment, status, data);
+ }
+ };
+ listener.onSVDataReport = [&](void* pEquipment, void* pData) {
+ const bool allowSvLog =
+ (m_state == MASTERSTATE::RUNNING ||
+ m_state == MASTERSTATE::RUNNING_CONTINUOUS_TRANSFER ||
+ m_state == MASTERSTATE::RUNNING_BATCH ||
+ m_state == MASTERSTATE::STARTING);
+ const bool allowCurve = allowSvLog || (m_curveMode == CurveMode::EmptyChamber);
+ if (!allowCurve) {
+ return;
+ }
+ CSVData* pSVData = (CSVData*)pData;
+ auto rawData = pSVData->getSVRawData();
+ std::vector<CParam> params;
+ ((CEquipment*)pEquipment)->parsingSVData((const char*)rawData.data(), rawData.size(), params);
+
+
+ // 浠ヤ笅鍔犲叆鍒版洸绾挎暟鎹腑
+ LOGD("<Master>onSVDataReport 001");
+
+ const int64_t ts = now_ms_epoch();
+ int eqid = ((CEquipment*)pEquipment)->getID();
+ if (eqid == EQ_ID_Bonder1 || eqid == EQ_ID_Bonder2) {
+ LOGD("<Master>onSVDataReport 002A");
+ // 瀹氫箟 Bonder 鐨勭壒瀹氭槧灏�
+ std::vector<std::pair<int, int>> bonderMapping = {
+ {1, 1}, {2, 2}, {3, 3}, {4, 4}, {5, 5}, {6, 6}, {7, 7},
+ {8, 8}, {9, 9}, {10, 10}, {11, 11}, {12, 12}, {13, 13}, {14, 14}, {15, 15}, {16, 16}
+ };
+
+ CGlass* pGlass = ((CEquipment*)pEquipment)->getGlassFromSlot(2);
+ auto& dataTypes = CServoUtilsTool::getEqDataTypes();
+ auto& bonderTypes = dataTypes[SlotToMid(eqid, 2)];
+ for (const auto& mapping : bonderMapping) {
+ int paramIndex = mapping.first;
+ int channel = mapping.second;
+
+ if (paramIndex < params.size() && channel - 1 < bonderTypes.size()) {
+ if(m_pCollector != nullptr)
+ m_pCollector->buffersPush(SlotToMid(eqid, 2), channel, ts, params.at(paramIndex).getDoubleValue());
+ if(pGlass != nullptr)
+ pGlass->addSVData(eqid, bonderTypes[channel - 1], ts, params.at(paramIndex).getDoubleValue());
+ }
+ }
+ }
+ else if (eqid == EQ_ID_VACUUMBAKE) {
+ LOGD("<Master>onSVDataReport 002");
+ // 瀹氫箟 VACUUMBAKE 鐨勭壒瀹氭槧灏�
+ std::vector<std::pair<int, int>> vacuumMapping = {
+ {1, 1}, {2, 2}, {3, 3}, {4, 4}, {5, 5}, {6, 6}, {7, 7},
+ {10, 8}, {11, 9}, {12, 10}, {13, 11}, {14, 12}, {15, 13}, {16, 14}
+ };
+
+ CGlass* pGlass1 = ((CEquipment*)pEquipment)->getGlassFromSlot(1);
+ CGlass* pGlass2 = ((CEquipment*)pEquipment)->getGlassFromSlot(2);
+ auto& dataTypes = CServoUtilsTool::getEqDataTypes();
+ auto& vacuumbakeTypes = dataTypes[SlotToMid(eqid, 1)];
+ LOGD("<Master>onSVDataReport 003 : %d", vacuumMapping.size());
+ for (const auto& mapping : vacuumMapping) {
+ int paramIndex = mapping.first;
+ int channel = mapping.second;
+
+ if (paramIndex < params.size()) {
+ auto& param = params.at(paramIndex);
+ double value = param.getDoubleValue();
+ const std::string& paramName = param.getName();
+ const char slotTag = !paramName.empty() ? paramName[0] : '\0';
+ const int typeIndex = (slotTag == 'B') ? (channel - 8) : (channel - 1);
+ if (typeIndex < 0 || typeIndex >= (int)vacuumbakeTypes.size()) {
+ continue;
+ }
+ const int pushChannel = typeIndex + 1;
+ const std::string& dataType = vacuumbakeTypes[typeIndex];
+
+ if (m_pCollector != nullptr) {
+ if (slotTag == 'A')
+ m_pCollector->buffersPush(SlotToMid(eqid, 1), pushChannel, ts, value);
+ else if (slotTag == 'B')
+ m_pCollector->buffersPush(SlotToMid(eqid, 2), pushChannel, ts, value);
+ }
+
+ // 鏍规嵁鑵斾綋鍓嶇紑鍐欏叆瀵瑰簲 Slot 鐨勭幓鐠�
+ if (pGlass1 != nullptr && !dataType.empty() && slotTag == 'A')
+ pGlass1->addSVData(eqid, dataType, ts, value);
+ if (pGlass2 != nullptr && !dataType.empty() && slotTag == 'B')
+ pGlass2->addSVData(eqid, dataType, ts, value);
+ }
+ }
+ }
+ else if (eqid == EQ_ID_BAKE_COOLING) {
+ LOGD("<Master>onSVDataReport 002B");
+ // 瀹氫箟 BAKE_COOLING 鐨勭壒瀹氭槧灏�
+ std::vector<std::pair<int, int>> coolingMapping = {
+ {1, 1}, {2, 2}, {3, 3}, {4, 4}, {5, 5}, {6, 6},
+ {11, 7}, {12, 8}, {13, 9}, {14, 10}, {15, 11}, {16, 12}
+ };
+
+ CGlass* pGlass1 = ((CEquipment*)pEquipment)->getGlassFromSlot(1); // A Bake
+ CGlass* pGlass2 = ((CEquipment*)pEquipment)->getGlassFromSlot(2); // A Cool
+ CGlass* pGlass3 = ((CEquipment*)pEquipment)->getGlassFromSlot(3); // B Bake
+ CGlass* pGlass4 = ((CEquipment*)pEquipment)->getGlassFromSlot(4); // B Cool
+ auto& dataTypes = CServoUtilsTool::getEqDataTypes();
+ auto& coolingTypes = dataTypes[SlotToMid(eqid, 1)];
+ LOGD("<Master>onSVDataReport 003B : %d", coolingMapping.size());
+ auto addToGlass = [&](CGlass* glass, const std::string& type, double val) {
+ if (glass != nullptr)
+ glass->addSVData(eqid, type, ts, val);
+ };
+ for (const auto& mapping : coolingMapping) {
+ int paramIndex = mapping.first;
+ int channel = mapping.second;
+
+ if (paramIndex < params.size()) {
+ auto& param = params.at(paramIndex);
+ double value = param.getDoubleValue();
+ const std::string& paramName = param.getName();
+ const char slotTag = !paramName.empty() ? paramName[0] : '\0';
+ const bool paramIsBake = paramName.find("鐑樼儰") != std::string::npos;
+ const bool paramIsCooling = paramName.find("鍐峰嵈") != std::string::npos;
+ const int typeIndex = (slotTag == 'B') ? (channel - 7) : (channel - 1);
+ if (typeIndex < 0 || typeIndex >= (int)coolingTypes.size()) {
+ continue;
+ }
+ const int pushChannel = typeIndex + 1;
+ const std::string& dataType = coolingTypes[typeIndex];
+
+ if (m_pCollector != nullptr && paramIsBake) {
+ if (slotTag == 'A')
+ m_pCollector->buffersPush(SlotToMid(eqid, 1), pushChannel, ts, value);
+ else if (slotTag == 'B')
+ m_pCollector->buffersPush(SlotToMid(eqid, 3), pushChannel, ts, value);
+ }
+
+ if (!dataType.empty()) {
+ switch (slotTag) {
+ case 'A':
+ if (paramIsBake)
+ addToGlass(pGlass1, dataType, value);
+ else if (paramIsCooling)
+ addToGlass(pGlass2, dataType, value);
+ break;
+ case 'B':
+ if (paramIsBake)
+ addToGlass(pGlass3, dataType, value);
+ else if (paramIsCooling)
+ addToGlass(pGlass4, dataType, value);
+ break;
+ default:
+ break;
+ }
+ }
+ }
+ }
+ }
+
+
+ // 浠ヤ笅鏄緭鍑烘祴璇�
+ std::string strOut;
+ char szBuffer[256];
+ for (auto p : params) {
+ if (!strOut.empty()) strOut.append(",");
+ if (p.getValueType() == PVT_INT) {
+ sprintf_s(szBuffer, 256, "%s:%d", p.getName().c_str(), p.getIntValue());
+ }
+ else if (p.getValueType() == PVT_DOUBLE) {
+ sprintf_s(szBuffer, 256, "%s:%f", p.getName().c_str(), p.getDoubleValue());
+ }
+ strOut.append(szBuffer);
+ }
+ LOGD("<CMaster-%s>SVDataReport:%s", ((CEquipment*)pEquipment)->getName().c_str(), strOut.c_str());
+
+ if (m_listener.onSVDataReport != nullptr) {
+ m_listener.onSVDataReport(this, (CEquipment*)pEquipment, params);
+ }
+ };
+ listener.onPanelDataReport = [&](void* pEquipment, void* pContext) {
+ LOGD("<CMaster-%s>onPanelDataReport", ((CEquipment*)pEquipment)->getName().c_str());
+
+ CEquipment* pEq = (CEquipment*)pEquipment;
+ CGlass* pGlass = (CGlass*)pContext;
+
+ // 濡傛灉AOI妫�娴嬪け璐ワ紝瑕佸仠鏈�
+ if (pEq->getID() == EQ_ID_MEASUREMENT) {
+ LOGD("<CMaster-%s>onPanelDataReport 01", ((CEquipment*)pEquipment)->getName().c_str());
+ if (pGlass->getAOIInspResult() == InspResult::Fail) {
+ LOGD("<CMaster-%s>onPanelDataReport 02", ((CEquipment*)pEquipment)->getName().c_str());
+ if (stop() == 0) {
+ m_nLastError = ER_CODE_AOI_NG;
+ m_strLastError = "AOI妫�娴嬫湭閫氳繃.";
+ }
+ }
+ }
+
+ };
+ listener.onReceivedJob = [&](void* pEquipment, int port, CJobDataS* pJobDataS) {
+ if (m_listener.onJobReceived != nullptr) {
+ m_listener.onJobReceived(this, (CEquipment*)pEquipment, port, pJobDataS);
+ }
+ };
+ listener.onSentOutJob = [&](void* pEquipment, int port, CJobDataS* pJobDataS) {
+ if (m_listener.onJobSentOut != nullptr) {
+ m_listener.onJobSentOut(this, (CEquipment*)pEquipment, port, pJobDataS);
+ }
+ };
+ listener.onEqStatusChanged = [&](void* pEquipment, int unitId, int status, int reason) {
+ if (m_listener.onEqStatusChanged != nullptr) {
+ m_listener.onEqStatusChanged(this, (CEquipment*)pEquipment, unitId, status, reason);
+ }
+ };
pEquipment->setListener(listener);
pEquipment->setCcLink(&m_cclink);
m_listEquipment.push_back(pEquipment);
@@ -441,8 +1961,17 @@
return nullptr;
}
+ CEquipment* CMaster::getEquipment(int id) const
+ {
+ for (auto item : m_listEquipment) {
+ if (item->getID() == id) return item;
+ }
+
+ return nullptr;
+ }
+
/*
- * 添加LoadPort1
+ * 娣诲姞LoadPort1
* index -- 0~3
*/
CLoadPort* CMaster::addLoadPort(int index)
@@ -457,11 +1986,12 @@
pEquipment->setID(EQ_ID_LOADPORT1 + index);
pEquipment->setName(szName);
pEquipment->setDescription(szName);
+ pEquipment->setCompareMapsBeforeProceeding(m_isCompareMapsBeforeProceeding);
addToEquipmentList(pEquipment);
pEquipment->init();
- LOGE("已添加“%s”.", pEquipment->getName().c_str());
+ LOGE("宸叉坊鍔犫��%s鈥�.", pEquipment->getName().c_str());
return pEquipment;
@@ -474,13 +2004,13 @@
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);
pEquipment->init();
- LOGE("已添加“Fliper”.");
+ LOGE("宸叉坊鍔犫�淔liper鈥�.");
return pEquipment;
}
@@ -491,13 +2021,13 @@
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);
pEquipment->init();
- LOGE("已添加“VacuumBake”.");
+ LOGE("宸叉坊鍔犫�淰acuumBake鈥�.");
return pEquipment;
}
@@ -509,13 +2039,13 @@
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”.");
+ LOGE("宸叉坊鍔犫�淎ligner鈥�.");
return pEquipment;
}
@@ -533,7 +2063,7 @@
pEquipment->init();
- LOGE("已添加“EFEM(ROBOT)”.");
+ LOGE("宸叉坊鍔犫�淓FEM(ROBOT)鈥�.");
return pEquipment;
}
@@ -549,7 +2079,7 @@
pEquipment->init();
- LOGE("已添加“ARM”.");
+ LOGE("宸叉坊鍔犫�淎RM鈥�.");
return pEquipment;
}
@@ -565,12 +2095,12 @@
pEquipment->init();
- LOGE("已添加“%s”.", pEquipment->getName().c_str());
+ LOGE("宸叉坊鍔犫��%s鈥�.", pEquipment->getName().c_str());
return pEquipment;
}
- /* 添加bonder1 或 bonder2
+ /* 娣诲姞bonder1 鎴� bonder2
* index -- 0, bonder1
* index -- 1, bonder2
*/
@@ -589,7 +2119,7 @@
pEquipment->init();
- LOGE("已添加“%s”.", pEquipment->getName().c_str());
+ LOGE("宸叉坊鍔犫��%s鈥�.", pEquipment->getName().c_str());
return pEquipment;
@@ -602,12 +2132,12 @@
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”.");
+ LOGE("宸叉坊鍔犫�淎ligner鈥�.");
return pEquipment;
}
@@ -624,7 +2154,7 @@
addToEquipmentList(pEquipment);
pEquipment->init();
- LOGE("已添加“Measurement”.");
+ LOGE("宸叉坊鍔犫�淢easurement鈥�.");
return pEquipment;
}
@@ -636,29 +2166,10 @@
}
- // 按一定频率扫描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) {
if (m_bDataModify) {
saveCacheAndBackups();
@@ -666,6 +2177,259 @@
}
}
+
+ // 妯℃嫙娴嬭瘯锛堟棤鏈哄櫒鑱旀満鏃剁敤浜庤仈璋� EAP锛�
+ // 璇诲彇 test.ini锛堝綋鍓嶇洰褰曟垨 exe 鍚岀洰褰曪級
+ {
+ struct SimCfg {
+ bool enabled{ false };
+ DWORD intervalMs{ 5000 };
+ int step{ 0 };
+ };
+ auto loadCfg = [&]() -> SimCfg {
+ SimCfg cfg;
+
+ // Try INI: current dir, then exe dir
+ char iniPath[MAX_PATH] = { 0 };
+ strcpy_s(iniPath, "test.ini");
+ auto readIni = [&](const char* path) -> bool {
+ const UINT en = GetPrivateProfileIntA("SimEap", "Enabled", 0, path);
+ if (en == 0) return false; // treat as missing/disabled
+ cfg.enabled = (en != 0);
+ cfg.intervalMs = (DWORD)GetPrivateProfileIntA("SimEap", "IntervalMs", 5000, path);
+ cfg.intervalMs = max(500u, cfg.intervalMs);
+ cfg.step = (int)GetPrivateProfileIntA("SimEap", "Step", 0, path);
+ return true;
+ };
+ if (!readIni(iniPath)) {
+ char exePath[MAX_PATH] = { 0 };
+ GetModuleFileNameA(NULL, exePath, MAX_PATH);
+ char* lastSlash = strrchr(exePath, '\\');
+ if (lastSlash != nullptr) {
+ *(lastSlash + 1) = '\0';
+ strcat_s(exePath, "test.ini");
+ readIni(exePath);
+ }
+ }
+ return cfg;
+ };
+
+ const SimCfg cfg = loadCfg();
+ if (cfg.enabled) {
+ static DWORD lastTick = 0;
+ static int lastExecutedStep = -1;
+ static bool inited = false;
+ static SERVO::CGlass simGlass;
+ static SERVO::CVcrEventReport simVcr;
+ static SERVO::CProcessJob simPj("PJ1001");
+ static SERVO::CControlJob simCj("CJ5007");
+
+ if (!inited) {
+ inited = true;
+ simGlass.setID("SIM_PANEL_001");
+ simVcr.getGlassId() = "SIM_PANEL_001";
+ }
+
+ DWORD now = GetTickCount();
+ if (lastTick == 0) lastTick = now;
+ if ((now - lastTick) < cfg.intervalMs) {
+ return;
+ }
+ lastTick = now;
+
+ // 鍗曟瑙﹀彂锛氭瘡涓� Step 鍙墽琛屼竴娆★紱浣犳墜鍔ㄤ慨鏀� ini 鐨� Step 鍊煎悗浼氬啀娆¤Е鍙�
+ const int step = cfg.step;
+ if (step <= 0 || step == lastExecutedStep) {
+ return;
+ }
+ lastExecutedStep = step;
+
+ // 鍙栦竴涓� LoadPort 浣滀负妯℃嫙鐩爣
+ SERVO::CLoadPort* pLpEq = (SERVO::CLoadPort*)getEquipment(EQ_ID_LOADPORT1);
+
+ auto fireLoadPortStatus = [&](short status) {
+ pLpEq->simulateSetCassetteId("Test-Cassette-001");
+ if (m_listener.onLoadPortStatusChanged != nullptr && pLpEq != nullptr) {
+ m_listener.onLoadPortStatusChanged(this, pLpEq, status, 0);
+ }
+ };
+ auto fireProcessState = [&](SERVO::CEquipment* pEq, int slotNo, SERVO::PROCESS_STATE st) {
+ // Drive equipment state so listeners receive prev/current states consistently.
+ if (pEq != nullptr) {
+ pEq->fireSetProcessState(slotNo, st);
+ }
+ };
+
+ LOGI("<Master>SIM_EAP single-step=%d", step);
+ switch (step) {
+ // ===== 涓氬姟娴佺▼姝ラ锛�1~23锛�=====
+ case 1: // E87_06 Material Arrived(TransferBlock) -> Port Blocked
+ fireLoadPortStatus(PORT_BLOCKED);
+ break;
+ case 2: // E87_03 CarrierID Readed -> Port InUse
+ fireLoadPortStatus(PORT_INUSE);
+ break;
+ case 3: // S1F3 Query CJ Space (Host->EQ) - wait host
+ LOGI("<Master>SIM_EAP step3: wait host S1F3");
+ break;
+ case 4: // S16F21 Query PJ Space (Host->EQ) - wait host
+ LOGI("<Master>SIM_EAP step4: wait host S16F21");
+ break;
+ case 5: // S7F19 Query PPID List (Host->EQ) - wait host
+ LOGI("<Master>SIM_EAP step5: wait host S7F19");
+ break;
+ case 6: // S3F17 ProceedWithCarrier (Host->EQ) - wait host
+ LOGI("<Master>SIM_EAP step6: wait host S3F17 ProceedWithCarrier");
+ break;
+ case 7: // E87_14 Check SlotMap (璁惧涓婃姤/杩涘叆 WFH) - 鐢� PORT_INUSE 鍐呴儴瑙﹀彂
+ fireLoadPortStatus(PORT_INUSE);
+ break;
+ case 8: // S3F17 ProceedWithSlotMap (Host->EQ) - wait host
+ LOGI("<Master>SIM_EAP step8: wait host S3F17 ProceedWithSlotMap");
+ break;
+ case 9: // SlotMap Verify OK (鏈」鐩湪鏀跺埌 ProceedWithSlotMap 鍚庝笂鎶�) - wait host
+ LOGI("<Master>SIM_EAP step9: wait host ProceedWithSlotMap to trigger VerifyOK");
+ break;
+ case 10: // Create PJ (Host->EQ) - wait host
+ LOGI("<Master>SIM_EAP step10: wait host S16F15 CreateMultiPJ");
+ break;
+ case 11: // PJ Queued锛堟湰椤圭洰鍦ㄥ垱寤� PJ 鍚庝笂鎶ワ級 - wait host
+ LOGI("<Master>SIM_EAP step11: wait host CreateMultiPJ to trigger PJ_Queued");
+ break;
+ case 12: // Create CJ (Host->EQ) - wait host
+ LOGI("<Master>SIM_EAP step12: wait host S14F9 CreateCJ");
+ break;
+ case 13: // CJ Start
+ if (m_listener.onCjStart != nullptr) m_listener.onCjStart(this, &simCj);
+ break;
+ case 14: // PJ Start
+ if (m_listener.onPjStart != nullptr) m_listener.onPjStart(this, &simPj);
+ break;
+ case 15: // OCR
+ if (m_listener.onEqVcrEventReport != nullptr && pLpEq != nullptr) {
+ m_listener.onEqVcrEventReport(this, pLpEq, &simVcr);
+ }
+ break;
+ case 16: // Panel Start
+ if (m_listener.onPanelStart != nullptr) m_listener.onPanelStart(this, &simGlass);
+ // 鍚屾椂瑙﹀彂涓�娆″瓙鏈哄彴寮�濮嬶紙绀轰緥锛欱onder1, slot 1锛�
+ fireProcessState(getEquipment(EQ_ID_Bonder1), 1, SERVO::PROCESS_STATE::Processing);
+ break;
+ case 17: // Panel End
+ // 鍚屾椂瑙﹀彂涓�娆″瓙鏈哄彴缁撴潫锛堢ず渚嬶細Bonder1, slot 1锛�
+ fireProcessState(getEquipment(EQ_ID_Bonder1), 1, SERVO::PROCESS_STATE::Complete);
+ if (m_listener.onPanelEnd != nullptr) m_listener.onPanelEnd(this, &simGlass);
+ break;
+ case 18: // PJ End
+ if (m_listener.onPjEnd != nullptr) m_listener.onPjEnd(this, &simPj);
+ break;
+ case 19: // CJ End
+ if (m_listener.onCjEnd != nullptr) m_listener.onCjEnd(this, &simCj);
+ break;
+ case 20: // Ready to Release (Port Unload Ready; with prev INUSE will also trigger ReadyToRelease)
+ fireLoadPortStatus(PORT_UNLOAD_READY);
+ break;
+ case 21: // CarrierRelease (Host->EQ) - optional / wait host
+ LOGI("<Master>SIM_EAP step21: wait host S3F17 CarrierRelease");
+ break;
+ case 22: // Ready to Unload
+ fireLoadPortStatus(PORT_UNLOAD_READY);
+ break;
+ case 23: // Material Removed (and ReadyToLoad)
+ fireLoadPortStatus(PORT_LOAD_READY);
+ fireLoadPortStatus(PORT_EMPTY); // will also raise LoadPortNotAssoc via Model
+ break;
+ case 24: { // 妯℃嫙 SV Data锛堢ず渚嬶細Bonder1锛�
+ SERVO::CEquipment* pEq = getEquipment(EQ_ID_Bonder1);
+ if (pEq != nullptr && m_listener.onSVDataReport != nullptr) {
+ static int counter = 0;
+ ++counter;
+ std::vector<CParam> params;
+ params.emplace_back("MockSV_Temp", "1", "C", 25 + (counter % 5));
+ params.emplace_back("MockSV_Pressure", "2", "kPa", 100 + (counter % 3));
+ params.emplace_back("MockSV_Speed", "3", "mm/s", 50 + (counter % 7));
+ m_listener.onSVDataReport(this, pEq, params);
+ LOGI("<Master>SIM_EAP step24: mock SVData (Bonder1), params=%zu", params.size());
+ }
+ break;
+ }
+ case 25: { // 妯℃嫙 Process Data锛堢ず渚嬶細Bonder1锛�
+ SERVO::CEquipment* pEq = getEquipment(EQ_ID_Bonder1);
+ if (pEq != nullptr && m_listener.onProcessDataReport != nullptr) {
+ static int counter = 0;
+ ++counter;
+ std::vector<CParam> params;
+ params.emplace_back("MockProc_CycleTime", "1", "s", 30 + (counter % 4));
+ params.emplace_back("MockProc_MaxTemp", "2", "C", 200 + (counter % 6));
+ params.emplace_back("MockProc_Result", "3", "", (counter % 2) ? 1 : 0);
+ m_listener.onProcessDataReport(this, pEq, params);
+ LOGI("<Master>SIM_EAP step25: mock ProcessData (Bonder1), params=%zu", params.size());
+ }
+ break;
+ }
+ default:
+ break;
+ }
+ }
+ }
+
+
+ // 妯℃嫙娴嬭瘯
+ /*
+ 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();
+ CGlass* pBuddy = pGlass->getBuddy();
+ if (pBuddy != nullptr) pBuddy->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);
+ }
+
+ // 妫�鏌J鏄惁宸茬粡瀹屾垚
+ 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()
@@ -683,67 +2447,65 @@
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失败");
+ 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失败");
+ 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"));
if (nRet < 0) {
- LOGE("连接Bonder1-BakeCooling失败");
+ LOGE("杩炴帴Bonder1-BakeCooling澶辫触");
}
nRet = pBonder2->getPin("Out")->connectPin(pBakeCooling->getPin("In2"));
if (nRet < 0) {
- LOGE("连接Bonder2-BakeCooling失败");
+ LOGE("杩炴帴Bonder2-BakeCooling澶辫触");
}
nRet = pBakeCooling->getPin("Out")->connectPin(pMeasurement->getPin("In"));
if (nRet < 0) {
- LOGE("连接BakeCooling-LoadPort3失败");
+ LOGE("杩炴帴BakeCooling-LoadPort3澶辫触");
}
nRet = pMeasurement->getPin("Out1")->connectPin(pLoadPort3->getPin("In"));
if (nRet < 0) {
- LOGE("连接BakeCooling-LoadPort3失败");
+ LOGE("杩炴帴BakeCooling-LoadPort3澶辫触");
}
nRet = pMeasurement->getPin("Out2")->connectPin(pLoadPort4->getPin("In"));
if (nRet < 0) {
- LOGE("连接BakeCooling-LoadPort4失败");
+ LOGE("杩炴帴BakeCooling-LoadPort4澶辫触");
}
}
@@ -767,7 +2529,7 @@
saveCache();
- // 创建备份目录
+ // 鍒涘缓澶囦唤鐩綍
CString strNewFile;
CString strFileDir = m_strFilepath.c_str();
int index = strFileDir.ReverseFind('\\');
@@ -828,4 +2590,1183 @@
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) LOGD("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) LOGD("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, int 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->localSetPortType((SERVO::PortType)type);
+ }
+
+ void CMaster::setPortTypeEx(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);
+ }
+
+ int CMaster::getPortCassetteSnSeed(int port)
+ {
+ ASSERT(1 <= port && port <= 4);
+ int eqid[] = { EQ_ID_LOADPORT1, EQ_ID_LOADPORT2, EQ_ID_LOADPORT3, EQ_ID_LOADPORT4 };
+ CLoadPort* pPort = (CLoadPort*)getEquipment(eqid[port - 1]);
+ return pPort->getPortCassetteSnSeed();
+ }
+
+ void CMaster::setPortCassetteSnSeed(int port, int seed)
+ {
+ ASSERT(1 <= port && port <= 4);
+ int eqid[] = { EQ_ID_LOADPORT1, EQ_ID_LOADPORT2, EQ_ID_LOADPORT3, EQ_ID_LOADPORT4 };
+ CLoadPort* pPort = (CLoadPort*)getEquipment(eqid[port - 1]);
+ return pPort->setPortCassetteSnSeed(seed);
+ }
+
+ 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]);
+ if (pPort == nullptr) return -1;
+
+ short jobExistence[12] = { 0 };
+ short slotProcess = 0;
+ short jobCount = 0; // 0 = Process All Glass
+ bool anyScheduled = false;
+
+ // Prefer hardware scan map for job existence (first 16 slots).
+ const short scanMap = pPort->getScanCassetteMap();
+ if (scanMap != 0) {
+ jobExistence[0] = scanMap;
+ }
+
+ const int maxSlots = 12 * 16;
+ const int totalSlots = (SLOT_MAX < maxSlots) ? SLOT_MAX : maxSlots;
+ for (int slot = 1; slot <= totalSlots; ++slot) {
+ CGlass* pGlass = pPort->getGlassFromSlot(slot);
+ if (pGlass == nullptr) continue;
+
+ const int wordIndex = (slot - 1) / 16;
+ const int bitIndex = (slot - 1) % 16;
+ jobExistence[wordIndex] = (short)(jobExistence[wordIndex] | (1 << bitIndex));
+
+ if (slot <= 16 && pGlass->isScheduledForProcessing()) {
+ slotProcess = (short)(slotProcess | (1 << bitIndex));
+ anyScheduled = true;
+ }
+ }
+
+ if (!anyScheduled) {
+ slotProcess = jobExistence[0];
+ }
+
+ pPort->sendCassetteCtrlCmd(CCC_PROCESS_START, jobExistence, 12, slotProcess, jobCount, 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;
+
+ // 閲嶇疆鍚勭鍙� DownloadMap锛圚ost/鏈湴鍕鹃�夌殑鏈熸湜鍔犲伐妲戒綅锛�
+ for (int i = 0; i < 4; i++) {
+ auto* pPort = (CLoadPort*)getEquipment(EQ_ID_LOADPORT1 + i);
+ if (pPort != nullptr) {
+ pPort->setDownloadCassetteMap(0);
+ }
+ }
+
+
+ // 鏇存柊context
+ for (auto pj : m_processJobs) {
+ for (auto& c : pj->carriers()) {
+ auto pPort = getPortWithCarrierId(c.carrierId);
+ if (pPort == nullptr) continue;
+
+ short downloadMap = 0;
+ for (auto s : c.slots) {
+ if (s >= 1 && s <= 8) {
+ downloadMap |= (short)(1 << (s - 1));
+ }
+ }
+ pPort->setDownloadCassetteMap((short)(pPort->getDownloadCassetteMap() | downloadMap));
+
+ std::vector<uint8_t> newSlots;
+ std::vector<void*> newContexts;
+ for (auto s : c.slots) {
+ auto pGlass = pPort->getGlassFromSlot(s);
+ if (pGlass == nullptr) continue;
+
+ newSlots.push_back(s);
+ newContexts.push_back(pGlass);
+ }
+
+ pj->setCarrierSlotsAndContexts(c.carrierId, newSlots, newContexts);
+ }
+ }
+
+
+
+ this->saveState();
+ if (m_listener.onControlJobChanged) {
+ notifyControlJobChanged();
+ }
+
+ 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();
+ if (m_listener.onControlJobChanged) {
+ notifyControlJobChanged();
+ }
+
+
+ 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
+ {
+ if (m_allowedCeids.empty()) return true; // backward compatible: treat as all allowed when not configured
+ return m_allowedCeids.find(ceid) != m_allowedCeids.end();
+ }
+
+ bool CMaster::raiseSoftAlarm(int alarmId,
+ const std::string& desc,
+ int level/* = -1*/,
+ int deviceId/* = 0*/,
+ int unitId/* = 0*/,
+ const char* deviceName/* = "Software"*/,
+ const char* unitName/* = "App"*/)
+ {
+ AlarmManager& alarmManager = AlarmManager::getInstance();
+ const AlarmInfo* info = alarmManager.getAlarmInfoByID(alarmId);
+
+ int severity = level;
+ if (severity < 0 && info != nullptr) {
+ severity = info->nAlarmLevel;
+ }
+ if (severity < 0) severity = 0; // fallback
+
+ std::string descText = desc;
+ if (descText.empty() && info != nullptr) {
+ descText = !info->strDescription.empty() ? info->strDescription : info->strAlarmText;
+ }
+ if (descText.empty()) {
+ descText = CToolUnits::formatString("Alarm %d", alarmId);
+ }
+
+ AlarmData alarmData;
+ alarmData.nId = alarmId;
+ alarmData.nSeverityLevel = severity;
+ alarmData.nDeviceId = deviceId;
+ alarmData.nUnitId = unitId;
+ alarmData.strDeviceName = deviceName;
+ alarmData.strUnitName = unitName;
+ alarmData.strStartTime = CToolUnits::timeToString2(CToolUnits::getTimestamp());
+ alarmData.strEndTime = "";
+ alarmData.strDescription = descText;
+
+ int nAlarmEventId = 0;
+ return alarmManager.addAlarm(alarmData, nAlarmEventId);
+ }
+
+ void CMaster::handleCollectionEvent(uint32_t ceid)
+ {
+ // 閬嶅巻褰撳墠 PJ锛屽懡涓� pauseEvents 鏃跺彲鍦ㄦ鎵╁睍鏆傚仠鍔ㄤ綔
+ bool pausedAny = false;
+ for (auto pj : m_processJobs) {
+ if (pj == nullptr) continue;
+ const auto& pauseList = pj->pauseEvents();
+ if (std::find(pauseList.begin(), pauseList.end(), ceid) != pauseList.end()) {
+ LOGW("<Master>PauseEvent hit: CEID=%u, PJ=%s, state=%d", ceid, pj->id().c_str(), (int)pj->state());
+ if (pj->pause()) {
+ LOGI("<Master>PJ paused by CEID=%u", ceid);
+ pausedAny = true;
+ }
+ if (m_pControlJob != nullptr && m_pControlJob->state() == CJState::Executing) {
+ if (m_pControlJob->pause()) {
+ LOGI("<Master>ControlJob paused by CEID=%u", ceid);
+ pausedAny = true;
+ }
+ }
+ }
+ }
+ if (pausedAny && m_listener.onControlJobChanged) {
+ // 閫氱煡搴旂敤灞傚埛鏂� UI/鎸夐挳鐘舵��
+ notifyControlJobChanged();
+ }
+ if (pausedAny && !m_bPauseAlarmRaised) {
+ std::string desc = CToolUnits::formatString("<PauseEvent CEID=%u>", ceid);
+ bool raised = false;
+ if (m_pModelCtx != nullptr) {
+ raised = m_pModelCtx->raiseSoftAlarm(ALID_SOFTWARE_PAUSE_EVENT, desc);
+ }
+ else {
+ raised = raiseSoftAlarm(ALID_SOFTWARE_PAUSE_EVENT, desc);
+ }
+ if (raised) {
+ LOGI("<Master>PauseEvent soft alarm raised, CEID=%u", ceid);
+ m_bPauseAlarmRaised = true;
+ }
+ }
+ }
+
+ void CMaster::setAllowedCeids(const std::vector<unsigned int>& ceids)
+ {
+ m_allowedCeids.clear();
+ m_allowedCeids.reserve(ceids.size());
+ for (auto id : ceids) {
+ m_allowedCeids.insert(id);
+ }
+ }
+
+ 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()
+ {
+ std::ifstream ifs(m_strStatePath, 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);
+
+
+ // 鏇存柊contexts
+ auto pjs = m_pControlJob->getPjs();
+ for (auto pj : pjs) {
+ for (auto& c : pj->carriers()) {
+ auto p = getPortWithCarrierId(c.carrierId);
+ if (p == nullptr) continue;
+
+ std::vector<void*> contexts;
+ for (auto s : c.slots) {
+ auto g = getGlass(p->getIndex(), s - 1);
+ if (g == nullptr) continue;
+ contexts.push_back(g);
+ }
+ pj->setCarrierContexts(c.carrierId, contexts);
+ }
+ }
+
+
+ // 濡傛灉鐗堟湰鍗囩骇锛屽彲鍦ㄨ繖閲屽垽鏂� version 鏉ュ姞杞芥柊瀛楁
+
+
+ return true;
+ }
+
+ void CMaster::setStateFile(const std::string& path)
+ {
+ m_strStatePath = path;
+ }
+
+ 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
+ if (pj->carriers().empty()) continue;
+ 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;
+ }
+
+
+ bool CMaster::completeControlJob()
+ {
+ if (m_pControlJob == nullptr) {
+ return false;
+ }
+ for (auto item : m_processJobs) {
+ if (item->state() != PJState::Completed) return false;
+ }
+ if (m_pControlJob->state() != CJState::Completed)
+ return false;
+
+
+
+ // 閲婃斁Job鐩稿叧
+ for (auto item : m_processJobs) {
+ delete item;
+ }
+ m_processJobs.clear();
+ if (m_pControlJob != nullptr) {
+ delete m_pControlJob;
+ m_pControlJob = nullptr;
+ }
+
+ // 娉ㄦ剰瑕侀噴鏀惧紩鐢�
+ m_inProcesJobs.clear();
+ m_completeProcessJobs.clear();
+ m_queueGlasses.clear();
+ m_inProcesGlasses.clear();
+ m_completeGlasses.clear();
+
+
+ saveState();
+ if (m_listener.onControlJobChanged) {
+ notifyControlJobChanged();
+ }
+
+ return true;
+ }
+
+ bool CMaster::forceCompleteControlJob(std::string description)
+ {
+ if (m_pControlJob == nullptr || m_state != SERVO::MASTERSTATE::READY) {
+ return false;
+ }
+ for (auto item : m_processJobs) {
+ item->abort(description);
+ }
+ m_pControlJob->abort(description);
+
+ // 鍏堜笂鎶ヤ竴娆＄姸鎬佸彉鍖栵紙渚夸簬 PrJobAbort 瑙﹀彂锛�
+ if (m_listener.onControlJobChanged) {
+ notifyControlJobChanged();
+ }
+
+
+ // 閲婃斁Job鐩稿叧
+ for (auto item : m_processJobs) {
+ delete item;
+ }
+ m_processJobs.clear();
+ if (m_pControlJob != nullptr) {
+ delete m_pControlJob;
+ m_pControlJob = nullptr;
+ }
+
+ // 娉ㄦ剰瑕侀噴鏀惧紩鐢�
+ m_inProcesJobs.clear();
+ m_completeProcessJobs.clear();
+ m_queueGlasses.clear();
+ m_inProcesGlasses.clear();
+ m_completeGlasses.clear();
+
+
+ saveState();
+ if (m_listener.onControlJobChanged) {
+ notifyControlJobChanged();
+ }
+
+ return true;
+ }
+
+ bool CMaster::canCreateControlJob()
+ {
+ return m_pControlJob == nullptr;
+ }
+
+ bool CMaster::canCompleteControlJob()
+ {
+ return m_pControlJob != nullptr && m_state == SERVO::MASTERSTATE::READY;
+ }
+
+ bool CMaster::canDeleteControlJob()
+ {
+ return m_pControlJob != nullptr
+ && m_pControlJob->state() == CJState::NoState
+ && m_state == SERVO::MASTERSTATE::READY;
+ }
+
+ int CMaster::getWipGlasses(std::vector<CGlass*>& glasses)
+ {
+ for (auto eq : m_listEquipment) {
+ auto p = dynamic_cast<CLoadPort*>(eq);
+ if (p == nullptr) {
+ eq->getAllGlass(glasses);
+ }
+
+ }
+
+ return (int)glasses.size();
+ }
+
+ int CMaster::getLastError()
+ {
+ return m_nLastError;
+ }
+
+ std::string& CMaster::getLastErrorText()
+ {
+ return m_strLastError;
+ }
+
+ void CMaster::test()
+ {
+ if (stop() == 0) {
+ m_nLastError = ER_CODE_AOI_NG;
+ m_strLastError = "AOI妫�娴嬫湭閫氳繃.";
+ }
+ }
+
+ bool CMaster::moveGlassToBuf(int eqid, int slotNo)
+ {
+ CEquipment* pEquipment = getEquipment(eqid);
+ if (pEquipment == nullptr) return false;
+
+ CSlot* pSlot = pEquipment->getSlotWithNo(slotNo);
+ if (pSlot == nullptr) return false;
+
+ CGlass* pGlass = (CGlass*)pSlot->getContext();
+ if (pGlass == nullptr) return false;
+
+ // Buffer 涓婇檺涓� 1锛氭柊鎼嚭鏃朵涪寮冩棫鐨�
+ if (!m_bufGlass.empty()) {
+ for (auto* oldGlass : m_bufGlass) {
+ if (oldGlass != nullptr) oldGlass->release();
+ }
+ m_bufGlass.clear();
+ }
+ m_bufGlass.push_back(pGlass);
+ pGlass->addRef();
+ pSlot->setContext(nullptr);
+
+ m_bDataModify = TRUE;
+ if (m_listener.onEqDataChanged != nullptr) {
+ m_listener.onEqDataChanged(this, pEquipment, 0);
+ }
+
+ return true;
+ }
+
+ bool CMaster::moveGlassToSlot(int eqid, int slotNo)
+ {
+ CEquipment* pEquipment = getEquipment(eqid);
+ if (pEquipment == nullptr) return false;
+
+ CSlot* pSlot = pEquipment->getSlotWithNo(slotNo);
+ if (pSlot == nullptr) return false;
+ if (m_bufGlass.empty()) return false;
+
+ CGlass* pGlass = m_bufGlass.front();
+ m_bufGlass.pop_front();
+ if (pGlass == nullptr) return false;
+ pSlot->setContext(pGlass);
+ pGlass->release();
+
+ m_bDataModify = TRUE;
+ if (m_listener.onEqDataChanged != nullptr) {
+ m_listener.onEqDataChanged(this, pEquipment, 0);
+ }
+
+ return true;
+ }
+
+ CGlass* CMaster::getGlass(int scrPort, int scrSlot)
+ {
+ for (auto eq : m_listEquipment) {
+ std::vector<CGlass*> glasses;
+ eq->getAllGlass(glasses);
+ for (auto g : glasses) {
+ int p, s;
+ g->getOrginPort(p, s);
+ if (p == scrPort && s == scrSlot) {
+ return g;
+ }
+ }
+ }
+
+ return nullptr;
+ }
+
+ void CMaster::CreateDAQBridgeServer()
+ {
+ auto connectionStatusCallback = [&](int code, const std::string& status) {
+ LOGI("<DAQBridge>status:", status.c_str());
+ };
+ auto rawDataCallback = [](const std::vector<uint8_t>& bytes) {
+
+ };
+
+ // 浜嬩欢锛氭湁浜鸿繛鍏�/鏂紑灏变笂鏃ュ織
+ auto clieintEventCallback = [](const std::string& ip, uint16_t port, bool connected) {
+ LOGI("<DAQBridge>[Client %s] %s:%u", connected ? _T("JOIN") : _T("LEAVE"), ip.c_str(), port);
+ };
+
+ if (m_pCollector == nullptr) {
+ m_pCollector = new Collector();
+ m_pCollector->setConnectionStatusCallback(connectionStatusCallback);
+ m_pCollector->setRawDataCallback(rawDataCallback);
+ m_pCollector->setClientEventCallback(clieintEventCallback);
+ m_pCollector->createServer(8081);
+ m_pCollector->startLoop(10);
+
+ // 1) 娉ㄥ唽鏈哄彴锛堟帹鑽愶細鍏堟敞鍐� id + 鏈哄櫒鍚嶇О锛�
+ RetentionPolicy defP; defP.mode = RetainMode::ByCount; defP.maxSamples = 200;
+ m_pCollector->registryAddMachine(MID_Bonder1, "Bonder1", defP);
+ m_pCollector->registryAddMachine(MID_Bonder2, "Bonder2", defP);
+ m_pCollector->registryAddMachine(MID_VacuumBakeA, "鍓嶇儤-A", defP);
+ m_pCollector->registryAddMachine(MID_VacuumBakeB, "鍓嶇儤-B", defP);
+ m_pCollector->registryAddMachine(MID_BakeCoolingA, "鍚庣儤-A", defP);
+ m_pCollector->registryAddMachine(MID_BakeCoolingB, "鍚庣儤-B", defP);
+
+
+ // 2) 涓洪�氶亾璁剧疆鈥滄洸绾垮悕绉扳��
+ auto& dataTypes = CServoUtilsTool::getEqDataTypes();
+ auto& bonderTypes = dataTypes[MID_Bonder1];
+ for (size_t i = 0; i < bonderTypes.size(); ++i) {
+ m_pCollector->buffersSetChannelName(MID_Bonder1, (UINT)i + 1, bonderTypes[(UINT)i].c_str());
+ m_pCollector->buffersSetChannelName(MID_Bonder2, (UINT)i + 1, bonderTypes[(UINT)i].c_str());
+ }
+
+ auto& vacuumbakeTypes = dataTypes[MID_VacuumBakeA];
+ for (size_t i = 0; i < vacuumbakeTypes.size(); ++i) {
+ m_pCollector->buffersSetChannelName(MID_VacuumBakeA, (UINT)i + 1, vacuumbakeTypes[(UINT)i].c_str());
+ m_pCollector->buffersSetChannelName(MID_VacuumBakeB, (UINT)i + 1, vacuumbakeTypes[(UINT)i].c_str());
+ }
+
+ auto& coolingTypes = dataTypes[MID_BakeCoolingA];
+ for (size_t i = 0; i < coolingTypes.size(); ++i) {
+ m_pCollector->buffersSetChannelName(MID_BakeCoolingA, i + 1, coolingTypes[i].c_str());
+ m_pCollector->buffersSetChannelName(MID_BakeCoolingB, i + 1, coolingTypes[i].c_str());
+ }
+
+ if (m_curveMode == CurveMode::EmptyChamber) {
+ const uint32_t mids[] = {
+ MID_Bonder1, MID_Bonder2,
+ MID_VacuumBakeA, MID_VacuumBakeB,
+ MID_BakeCoolingA, MID_BakeCoolingB
+ };
+ for (uint32_t mid : mids) {
+ m_pCollector->batchStart(mid, "EMPTY_CHAMBER", 10 * 60 * 1000ULL);
+ }
+ }
+ }
+ }
+
+ uint32_t CMaster::SlotToMid(int eqid, int slot)
+ {
+ if (eqid == EQ_ID_Bonder1) {
+ return MID_Bonder1;
+ }
+
+ if (eqid == EQ_ID_Bonder2) {
+ return MID_Bonder2;
+ }
+
+ if (eqid == EQ_ID_VACUUMBAKE) {
+ if(slot == 1)
+ return MID_VacuumBakeA;
+ if (slot == 2)
+ return MID_VacuumBakeB;
+ }
+
+ if (eqid == EQ_ID_BAKE_COOLING) {
+ if (slot == 1)
+ return MID_BakeCoolingA;
+ if (slot == 3)
+ return MID_BakeCoolingB;
+ }
+
+ return 0;
+ }
}
--
Gitblit v1.9.3