#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)
|
{
|
if (g_pMaster != NULL) {
|
return g_pMaster->DispatchProc();
|
}
|
|
return 0;
|
}
|
|
unsigned __stdcall ReadBitsThreadFunction(LPVOID lpParam)
|
{
|
if (g_pMaster != NULL) {
|
return g_pMaster->ReadBitsProc();
|
}
|
|
return 0;
|
}
|
|
void CALLBACK MasterTimerProc(HWND hWnd, UINT nMsg, UINT nTimerid, DWORD dwTime)
|
{
|
if (g_pMaster != NULL) {
|
g_pMaster->onTimer(nTimerid);
|
}
|
}
|
|
CMaster::CMaster()
|
{
|
m_listener = {};
|
m_bDataModify = FALSE;
|
m_hEventReadBitsThreadExit[0] = ::CreateEvent(NULL, TRUE, FALSE, NULL);
|
m_hEventReadBitsThreadExit[1] = ::CreateEvent(NULL, TRUE, FALSE, NULL);
|
m_hReadBitsThreadHandle = nullptr;
|
m_nReadBitsThreadAddr = 0;
|
m_hDispatchEvent = ::CreateEvent(NULL, TRUE, FALSE, NULL);
|
m_hEventDispatchThreadExit[0] = ::CreateEvent(NULL, TRUE, FALSE, NULL);
|
m_hEventDispatchThreadExit[1] = ::CreateEvent(NULL, TRUE, FALSE, NULL);
|
m_hDispatchThreadHandle = nullptr;
|
m_nDispatchThreadAddr = 0;
|
m_ullStartTime = 0;
|
m_ullRunTime = 0;
|
m_state = MASTERSTATE::READY;
|
m_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;
|
}
|
|
if (m_hEventReadBitsThreadExit[1] != nullptr) {
|
::CloseHandle(m_hEventReadBitsThreadExit[1]);
|
m_hEventReadBitsThreadExit[1] = nullptr;
|
}
|
|
if (m_hDispatchEvent != nullptr) {
|
::CloseHandle(m_hDispatchEvent);
|
m_hDispatchEvent = nullptr;
|
}
|
|
if (m_hEventDispatchThreadExit[0] != nullptr) {
|
::CloseHandle(m_hEventDispatchThreadExit[0]);
|
m_hEventDispatchThreadExit[0] = nullptr;
|
}
|
|
if (m_hEventDispatchThreadExit[1] != nullptr) {
|
::CloseHandle(m_hEventDispatchThreadExit[1]);
|
m_hEventDispatchThreadExit[1] = nullptr;
|
}
|
|
DeleteCriticalSection(&m_criticalSection);
|
}
|
|
void CMaster::setListener(MasterListener listener)
|
{
|
m_listener = listener;
|
}
|
|
void CMaster::setModelCtx(CModel* pModel)
|
{
|
m_pModelCtx = pModel;
|
}
|
|
CRobotTask* CMaster::getActiveRobotTask()
|
{
|
return m_pActiveRobotTask;
|
}
|
|
int CMaster::init()
|
{
|
const ULONGLONG boot_master_begin = GetTickCount64();
|
LOGI("<Master>正在初始化...");
|
LOGI("[BOOT][MASTER] init begin");
|
|
|
// cclink
|
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成功.");
|
BoardVersion version{};
|
int nRet = m_cclink.GetBoardVersion(version);
|
if (nRet == 0) {
|
LOGD("版本信息：%s.", version.toString().c_str());
|
}
|
else {
|
LOGE("获取CC-Link版本信息失败.");
|
}
|
|
BoardStatus status;
|
nRet = m_cclink.GetBoardStatus(status);
|
if (nRet == 0) {
|
LOGD("状态：%s.", status.toString().c_str());
|
}
|
else {
|
LOGE("获取CC-Link状态失败.");
|
}
|
}
|
|
|
// 初始化添加各子设备
|
CLoadPort* pPort1, * pPort2, * pPort3, * pPort4;
|
CBonder* pBonder1, * pBonder2;
|
CEFEM* pEfem;
|
CArm* pArm;
|
CArmTray* pArmTray1, * pArmTray2;
|
CFliper* pFliper;
|
CVacuumBake* pVacuumBake;
|
CAligner* pAligner;
|
CBakeCooling* pBakeCooling;
|
CMeasurement* pMeasurement;
|
|
pPort1 = addLoadPort(0);
|
pPort2 = addLoadPort(1);
|
pPort3 = addLoadPort(2);
|
pPort4 = addLoadPort(3);
|
pEfem = addEFEM();
|
pArm = addArm();
|
pArmTray1 = addArmTray(0);
|
pArmTray2 = addArmTray(1);
|
pFliper = addFliper();
|
pVacuumBake = addVacuumBake();
|
pAligner = addAligner();
|
pBonder1 = addBonder(0);
|
pBonder2 = addBonder(1);
|
pBakeCooling = addBakeCooling();
|
pMeasurement = addMeasurement();
|
|
ASSERT(pEfem);
|
ASSERT(pFliper);
|
ASSERT(pVacuumBake);
|
ASSERT(pAligner);
|
ASSERT(pBonder1);
|
ASSERT(pBonder2);
|
ASSERT(pBakeCooling);
|
ASSERT(pMeasurement);
|
|
pEfem->setPort(0, pPort1);
|
pEfem->setPort(1, pPort2);
|
pEfem->setPort(2, pPort3);
|
pEfem->setPort(3, pPort4);
|
pEfem->setFliper(pFliper);
|
pEfem->setAligner(pAligner);
|
pEfem->setArmTray(0, pArmTray1);
|
pEfem->setArmTray(1, pArmTray2);
|
pPort1->setArm(pArm);
|
pPort2->setArm(pArm);
|
pPort3->setArm(pArm);
|
pPort4->setArm(pArm);
|
pArmTray1->setArm(pArm);
|
pArmTray2->setArm(pArm);
|
pFliper->setArm(pArm);
|
pVacuumBake->setArm(pArm);
|
pAligner->setArm(pArm);
|
pBonder1->setArm(pArm);
|
pBonder2->setArm(pArm);
|
pBakeCooling->setArm(pArm);
|
pMeasurement->setArm(pArm);
|
|
connectEquipments();
|
|
|
|
// 读缓存数据
|
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线程
|
m_hReadBitsThreadHandle = (HANDLE)_beginthreadex(NULL, 0, SERVO::ReadBitsThreadFunction, this,
|
0, &m_nReadBitsThreadAddr);
|
|
|
// 曲线服务
|
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()
|
{
|
SetEvent(m_hEventReadBitsThreadExit[0]);
|
SetEvent(m_hEventDispatchThreadExit[0]);
|
::WaitForSingleObject(m_hEventReadBitsThreadExit[1], INFINITE);
|
::WaitForSingleObject(m_hEventDispatchThreadExit[1], INFINITE);
|
|
LOGI("<Master>正在结束程序.");
|
for (auto item : m_listEquipment) {
|
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();
|
|
|
if (m_pCollector != nullptr) {
|
m_pCollector->stopLoop();
|
delete m_pCollector;
|
m_pCollector = nullptr;
|
}
|
|
return 0;
|
}
|
|
int CMaster::start()
|
{
|
if (m_state != MASTERSTATE::READY) {
|
return -1;
|
}
|
|
m_bContinuousTransfer = false;
|
m_bBatch = false;
|
setState(MASTERSTATE::STARTING);
|
m_ullStartTime = GetTickCount64();
|
|
return 0;
|
}
|
|
int CMaster::startContinuousTransfer()
|
{
|
if (m_state != MASTERSTATE::READY) {
|
return -1;
|
}
|
|
m_bContinuousTransfer = true;
|
m_bBatch = false;
|
setState(MASTERSTATE::STARTING);
|
m_ullStartTime = GetTickCount64();
|
|
return 0;
|
}
|
|
int CMaster::startBatch()
|
{
|
if (m_state != MASTERSTATE::READY) {
|
return -1;
|
}
|
|
m_bContinuousTransfer = false;
|
m_bBatch = true;
|
setState(MASTERSTATE::STARTING);
|
m_ullStartTime = GetTickCount64();
|
|
return 0;
|
}
|
|
int CMaster::stop(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 || m_state == MASTERSTATE::RUNNING_CONTINUOUS_TRANSFER
|
|| m_state == MASTERSTATE::RUNNING_BATCH)
|
return m_ullRunTime + (GetTickCount64() - m_ullStartTime);
|
else
|
return m_ullRunTime;
|
}
|
|
MASTERSTATE CMaster::getState()
|
{
|
return m_state;
|
}
|
|
unsigned CMaster::DispatchProc()
|
{
|
// 优先考虑的类型和次要类型
|
// 一种情况，如果不分主次，一直搬G1, 等到Bonder1和Bonder2都放了G1, Aligner也放了G1,
|
// Bonder1和Bonder2需要的G2就过不来了
|
// 最基本的实现，可以G2和G2轮流搬送，但最好根据Bonder的需求来决定
|
MaterialsType primaryType, secondaryType;
|
|
|
// 各种机器
|
CLoadPort* pLoadPorts[4];
|
CEFEM* pEFEM = (CEFEM*)getEquipment(EQ_ID_EFEM);
|
pLoadPorts[0] = (CLoadPort*)getEquipment(EQ_ID_LOADPORT1);
|
pLoadPorts[1] = (CLoadPort*)getEquipment(EQ_ID_LOADPORT2);
|
pLoadPorts[2] = (CLoadPort*)getEquipment(EQ_ID_LOADPORT3);
|
pLoadPorts[3] = (CLoadPort*)getEquipment(EQ_ID_LOADPORT4);
|
CFliper* pFliper = (CFliper*)getEquipment(EQ_ID_FLIPER);
|
CVacuumBake* pVacuumBake = (CVacuumBake*)getEquipment(EQ_ID_VACUUMBAKE);
|
CAligner* pAligner = (CAligner*)getEquipment(EQ_ID_ALIGNER);
|
CBonder* pBonder1 = (CBonder*)getEquipment(EQ_ID_Bonder1);
|
CBonder* pBonder2 = (CBonder*)getEquipment(EQ_ID_Bonder2);
|
CBakeCooling* pBakeCooling = (CBakeCooling*)getEquipment(EQ_ID_BAKE_COOLING);
|
CMeasurement* pMeasurement = (CMeasurement*)getEquipment(EQ_ID_MEASUREMENT);
|
|
ASSERT(pEFEM);
|
ASSERT(pLoadPorts[0]);
|
ASSERT(pLoadPorts[1]);
|
ASSERT(pLoadPorts[2]);
|
ASSERT(pLoadPorts[3]);
|
ASSERT(pFliper);
|
ASSERT(pVacuumBake);
|
ASSERT(pAligner);
|
ASSERT(pBonder1);
|
ASSERT(pBonder2);
|
ASSERT(pBakeCooling);
|
ASSERT(pMeasurement);
|
|
while (1) {
|
// 待退出信号或时间到
|
HANDLE hEvents[] = { m_hEventDispatchThreadExit[0], m_hDispatchEvent };
|
int nRet = WaitForMultipleObjects(2, hEvents, FALSE, 500);
|
if (nRet == WAIT_OBJECT_0) {
|
break;
|
}
|
|
|
// 如果状态为STARTING，开始工作并切换到RUNNING状态
|
lock();
|
if (m_state == MASTERSTATE::STARTING) {
|
// 发送indexerOperationModeChange到各个机台，成功后切换到RUNNING状态
|
// 否则切换到MSERROR状态
|
int nRet;
|
CEquipment* pEq[6] = { pEFEM, pBonder1, pBonder2, pBakeCooling,
|
pVacuumBake, pMeasurement};
|
BOOL bIomcOk[7] = {FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE};
|
std::vector<std::promise<void>> promises(6);
|
std::vector<std::future<void>> futures;
|
|
nRet = pEq[0]->indexerOperationModeChange(IDNEXER_OPERATION_MODE::Start,
|
[&](int writeCode, int retCode) -> void {
|
bIomcOk[0] = retCode == (int)RET::OK;
|
promises[0].set_value();
|
TRACE("a0001\n", writeCode, retCode);
|
});
|
if (nRet != 0) {
|
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();
|
if(m_bContinuousTransfer)
|
setState(MASTERSTATE::RUNNING_CONTINUOUS_TRANSFER);
|
else if (m_bBatch)
|
setState(MASTERSTATE::RUNNING_BATCH);
|
else
|
setState(MASTERSTATE::RUNNING);
|
|
continue;
|
}
|
|
|
// 处理完成当前事务后，切换到停止或就绪状态
|
else if (m_state == MASTERSTATE::STOPPING) {
|
unlock();
|
LOGI("<Master>开始切换各设备到 Stop 模式...");
|
|
std::vector<std::promise<void>> promises(6);
|
std::vector<std::future<void>> futures;
|
BOOL bIomcOk[7] = { FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE };
|
|
int nRet;
|
CEquipment* pEq[6] = { pEFEM, pBonder1, pBonder2, pBakeCooling,
|
pVacuumBake, pMeasurement };
|
|
for (int i = 0; i < 1; ++i) {
|
nRet = pEq[i]->indexerOperationModeChange(IDNEXER_OPERATION_MODE::Stop,
|
[i, &promises, &bIomcOk](int writeCode, int retCode) -> void {
|
bIomcOk[i] = retCode == (int)RET::OK;
|
promises[i].set_value();
|
TRACE("s000%d: ret=%d\n", i + 1, retCode);
|
});
|
if (nRet != 0) {
|
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) {
|
// 检测判断robot状态
|
RMDATA& rmd = pEFEM->getRobotMonitoringData();
|
if (rmd.status != ROBOT_STATUS::Idle && rmd.status != ROBOT_STATUS::Run) {
|
unlock();
|
continue;
|
}
|
|
if (m_pActiveRobotTask != nullptr) {
|
if (m_pActiveRobotTask->isPicked()) {
|
m_pActiveRobotTask->place();
|
}
|
unlock();
|
// 检测到当前有正在下午的任务，确保当前任务完成或中止后继续
|
// LOGI("检测到当前有正在下午的任务，确保当前任务完成或中止后继续...");
|
continue;
|
}
|
|
|
// Bonder1、Bonder2、Fliper、VacuumBake、Aligner，统计G2和G1的数量, 配对组数, 多出的类型
|
int nG2Count = 0, nG1Count = 0, nGlassGroup, nExtraType;
|
if (pBonder1->slotHasGlass(0)) {
|
nG2Count++;
|
}
|
if (pBonder1->slotHasGlass(1)) {
|
nG1Count++;
|
}
|
|
if (pBonder2->slotHasGlass(0)) {
|
nG2Count++;
|
}
|
if (pBonder2->slotHasGlass(1)) {
|
nG1Count++;
|
}
|
|
if (pFliper->slotHasGlass(0)) {
|
nG2Count++;
|
}
|
|
if (pVacuumBake->slotHasGlass(0)) {
|
nG1Count++;
|
}
|
if (pVacuumBake->slotHasGlass(1)) {
|
nG1Count++;
|
}
|
|
CGlass* pTempGlass = pAligner->getGlassFromSlot(0);
|
if (pTempGlass != nullptr) {
|
MaterialsType type = pTempGlass->getType();
|
if(type == MaterialsType::G1)
|
nG1Count++;
|
else if (type == MaterialsType::G2)
|
nG2Count++;
|
}
|
nGlassGroup = min(nG1Count, nG2Count);
|
|
if (nG1Count == nG2Count) {
|
nExtraType = 0;
|
}
|
else if (nG1Count > nG2Count) {
|
nExtraType = 1;
|
}
|
else {
|
nExtraType = 2;
|
}
|
secondaryType = MaterialsType::G0;
|
|
|
// Measurement -> LoadPort
|
for (int s = 0; s < 4; s++) {
|
PortType pt = pLoadPorts[s]->getPortType();
|
if (!rmd.armState[0] && pLoadPorts[s]->isEnable()
|
&& (pt == PortType::Unloading || pt == PortType::Both)
|
&& pLoadPorts[s]->getPortStatus() == PORT_INUSE) {
|
m_pActiveRobotTask = createTransferTask(pMeasurement, pLoadPorts[s], MaterialsType::G1, secondaryType);
|
if (m_pActiveRobotTask != nullptr) {
|
goto PORT_PUT;
|
}
|
}
|
}
|
|
PORT_PUT:
|
CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
|
|
|
// Measurement NG -> LoadPort
|
// NG回原位
|
if (!rmd.armState[1]) {
|
m_pActiveRobotTask = createTransferTask_restore(pMeasurement, pLoadPorts);
|
CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
|
}
|
|
|
// BakeCooling ->Measurement
|
if (!rmd.armState[0]) {
|
m_pActiveRobotTask = createTransferTask_bakecooling_to_measurement(pBakeCooling, pMeasurement);
|
CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
|
}
|
|
|
// BakeCooling内部
|
// Bake -> Cooling
|
if (!rmd.armState[0]) {
|
m_pActiveRobotTask = createTransferTask_bake_to_cooling(pBakeCooling);
|
CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
|
}
|
|
|
// Bonder -> BakeCooling
|
if (!rmd.armState[0]) {
|
m_pActiveRobotTask = createTransferTask_bonder_to_bakecooling(pBonder1, pBakeCooling);
|
CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
|
}
|
|
if (!rmd.armState[0]) {
|
m_pActiveRobotTask = createTransferTask_bonder_to_bakecooling(pBonder2, pBakeCooling);
|
CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
|
}
|
|
|
// Fliper(G2) -> Bonder
|
//m_nTestFlag = 1;
|
//pVacuumBake->m_nTestFlag = 1;
|
auto pSrcSlot = pVacuumBake->getProcessedSlot(MaterialsType::G1);
|
//LOGI("<Master>pSrcSlot = %x", pSrcSlot,);
|
if (pSrcSlot != nullptr && !rmd.armState[1]
|
&& pBonder1->canPlaceGlassInSlot(0)) {
|
m_pActiveRobotTask = createTransferTask(pFliper, pBonder1, MaterialsType::G2, MaterialsType::G0, 2);
|
CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
|
}
|
if (pSrcSlot != nullptr && !rmd.armState[1]
|
&& pBonder2->canPlaceGlassInSlot(0)) {
|
m_pActiveRobotTask = createTransferTask(pFliper, pBonder2, MaterialsType::G2, MaterialsType::G0, 2);
|
CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
|
}
|
//m_nTestFlag = 0
|
;
|
// VacuumBake(G1) -> Bonder
|
if (!rmd.armState[0] && pBonder1->slotHasGlass(0) && !pBonder1->slotHasGlass(1)) {
|
m_pActiveRobotTask = createTransferTask(pVacuumBake, pBonder1, MaterialsType::G1, MaterialsType::G0);
|
CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
|
}
|
|
if (!rmd.armState[0] && pBonder2->slotHasGlass(0) && !pBonder2->slotHasGlass(1)) {
|
m_pActiveRobotTask = createTransferTask(pVacuumBake, pBonder2, MaterialsType::G1, MaterialsType::G0);
|
CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
|
}
|
|
|
// Aligner -> Fliper(G2)
|
// Aligner -> VacuumBake(G1)
|
if (!rmd.armState[1]) {
|
m_pActiveRobotTask = createTransferTask(pAligner, pFliper, MaterialsType::G2, secondaryType);
|
CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask);
|
}
|
|
if (!rmd.armState[0]) {
|
// m_nTestFlag = 1;
|
if (m_nTestFlag == 1) 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 块Glass到工艺列队！", 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>调度暂停：ControlJob/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 统一定义（secondary 默认 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 内部（Bake -> 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（restore）
|
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;
|
}
|
|
// 统一：queue -> start -> setContext -> move queue→inProcess -> 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) {
|
// 检测判断robot状态
|
RMDATA& rmd = pEFEM->getRobotMonitoringData();
|
if (rmd.status != ROBOT_STATUS::Idle && rmd.status != ROBOT_STATUS::Run) {
|
unlock();
|
continue;
|
}
|
|
if (m_pActiveRobotTask != nullptr) {
|
if (m_pActiveRobotTask->isPicked()) {
|
m_pActiveRobotTask->place();
|
}
|
unlock();
|
// 检测到当前有正在下午的任务，确保当前任务完成或中止后继续
|
// LOGI("检测到当前有正在下午的任务，确保当前任务完成或中止后继续...");
|
continue;
|
}
|
|
// Measurement -> LoadPort
|
for (int 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();
|
}
|
|
SetEvent(m_hEventDispatchThreadExit[1]);
|
|
|
// _endthreadex(0);
|
TRACE("CMaster::DispatchProc 线程退出\n");
|
return 0;
|
}
|
|
unsigned CMaster::ReadBitsProc()
|
{
|
// 标志位清0复位
|
{
|
StationIdentifier station;
|
station.nNetNo = 0;
|
station.nStNo = 255;
|
char szBuffer[528] = { 0 }; // 0x0, 0x1087
|
m_cclink.WriteData(station, (long)DeviceType::B, 0, 528, (short*)szBuffer);
|
}
|
|
|
while (1) {
|
// 待退出信号或时间到
|
int nRet = ::WaitForSingleObject(m_hEventReadBitsThreadExit[0], 1000);
|
if (nRet == WAIT_OBJECT_0) {
|
break;
|
}
|
|
// 读标志位
|
for (auto item : m_listEquipment) {
|
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) {
|
item->onReceiveLBData(block.buffer, block.size);
|
}
|
}
|
}
|
}
|
|
SetEvent(m_hEventReadBitsThreadExit[1]);
|
|
|
// _endthreadex(0);
|
TRACE("CMaster::ReadBitsProc 线程退出\n");
|
return 0;
|
}
|
|
int CMaster::addToEquipmentList(CEquipment* pEquipment)
|
{
|
EquipmentListener listener;
|
listener.onAlive = [&](void* pEquipment, BOOL bAlive) -> void {
|
CEquipment* p = (CEquipment*)pEquipment;
|
if (m_listener.onEqAlive != nullptr) {
|
m_listener.onEqAlive(this, p, bAlive);
|
}
|
};
|
listener.onCimStateChanged = [&](void* pEquipment, BOOL bOn) -> void {
|
CEquipment* p = (CEquipment*)pEquipment;
|
if (m_listener.onEqCimStateChanged != nullptr) {
|
m_listener.onEqCimStateChanged(this, p, bOn);
|
}
|
};
|
listener.onAlarm = [&](void* pEquipment, int state, int alarmId, int unitId, int level) -> void {
|
CEquipment* p = (CEquipment*)pEquipment;
|
if (m_listener.onEqAlarm != nullptr) {
|
m_listener.onEqAlarm(this, p, state, alarmId, unitId, level);
|
}
|
};
|
listener.onVcrEventReport = [&](void* pEquipment, void* pReport) -> void {
|
CEquipment* p = (CEquipment*)pEquipment;
|
CVcrEventReport* p2 = (CVcrEventReport*)pReport;
|
if (m_listener.onEqVcrEventReport != nullptr) {
|
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("放片完成...");
|
// 完成此条搬送任务，但要把数据和消息上抛应用层
|
|
// 如果是搬送回从AOI搬送回Port, 则glass工艺完成
|
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);
|
}
|
|
// 检查PJ是否已经完成
|
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);
|
}
|
|
// 检查CJ是否已经完成
|
ASSERT(m_pControlJob);
|
if (checkAndUpdateCjComplete(m_pControlJob)) {
|
this->saveState();
|
LOGE("<Master>ControlJob(%s)完成.",
|
m_pControlJob->id().c_str());
|
if (m_listener.onCjEnd != nullptr) {
|
m_listener.onCjEnd(this, pJob);
|
}
|
|
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。status=%d, data=%lld", ((CEquipment*)pEquipment)->getName().c_str(), status);
|
if (status == PORT_INUSE && m_pControlJob != nullptr) {
|
CLoadPort* pPort = (CLoadPort*)pEquipment;
|
auto pjs = m_pControlJob->getPjs();
|
for (auto pj : pjs) {
|
auto carrier = pj->getCarrier(pPort->getCassetteId());
|
if (carrier != nullptr) {
|
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() && channel - 1 < vacuumbakeTypes.size()) {
|
auto& param = params.at(paramIndex);
|
double value = param.getDoubleValue();
|
const std::string& dataType = vacuumbakeTypes[channel - 1];
|
const std::string& paramName = param.getName();
|
const char slotTag = !paramName.empty() ? paramName[0] : '\0';
|
|
if (m_pCollector != nullptr) {
|
if (slotTag == 'A')
|
m_pCollector->buffersPush(SlotToMid(eqid, 1), channel, ts, value);
|
else if (slotTag == 'B')
|
m_pCollector->buffersPush(SlotToMid(eqid, 2), channel, 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() && channel - 1 < coolingTypes.size()) {
|
auto& param = params.at(paramIndex);
|
double value = param.getDoubleValue();
|
const std::string& dataType = coolingTypes[channel - 1];
|
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;
|
|
if (m_pCollector != nullptr && paramIsBake) {
|
if (slotTag == 'A')
|
m_pCollector->buffersPush(SlotToMid(eqid, 1), channel, ts, value);
|
else if (slotTag == 'B')
|
m_pCollector->buffersPush(SlotToMid(eqid, 3), channel, 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);
|
}
|
};
|
pEquipment->setListener(listener);
|
pEquipment->setCcLink(&m_cclink);
|
m_listEquipment.push_back(pEquipment);
|
|
return 0;
|
}
|
|
std::list<CEquipment*>& CMaster::getEquipmentList()
|
{
|
return m_listEquipment;
|
}
|
|
CEquipment* CMaster::getEquipment(int id)
|
{
|
for (auto item : m_listEquipment) {
|
if (item->getID() == id) return item;
|
}
|
|
return nullptr;
|
}
|
|
CEquipment* CMaster::getEquipment(int id) const
|
{
|
for (auto item : m_listEquipment) {
|
if (item->getID() == id) return item;
|
}
|
|
return nullptr;
|
}
|
|
/*
|
* 添加LoadPort1
|
* index -- 0~3
|
*/
|
CLoadPort* CMaster::addLoadPort(int index)
|
{
|
ASSERT(index == 0 || index == 1 || index == 2 || index == 3);
|
|
|
char szName[64];
|
sprintf_s(szName, 64, "LoadPort %d", index + 1);
|
CLoadPort* pEquipment = new CLoadPort();
|
pEquipment->setIndex(index);
|
pEquipment->setID(EQ_ID_LOADPORT1 + index);
|
pEquipment->setName(szName);
|
pEquipment->setDescription(szName);
|
pEquipment->setCompareMapsBeforeProceeding(m_isCompareMapsBeforeProceeding);
|
addToEquipmentList(pEquipment);
|
|
|
pEquipment->init();
|
LOGE("已添加“%s”.", pEquipment->getName().c_str());
|
|
|
return pEquipment;
|
}
|
|
CFliper* CMaster::addFliper()
|
{
|
CFliper* pEquipment = new CFliper();
|
pEquipment->setID(EQ_ID_FLIPER);
|
pEquipment->setBaseAlarmId(BASE_ALARM_EFEM);
|
pEquipment->setName("Fliper(G2)");
|
pEquipment->setDescription("Fliper(G2).");
|
pEquipment->setReadBitBlock(0x0, 0x0);
|
pEquipment->setStation(0, 255);
|
addToEquipmentList(pEquipment);
|
|
|
pEquipment->init();
|
LOGE("已添加“Fliper”.");
|
return pEquipment;
|
}
|
|
CVacuumBake* CMaster::addVacuumBake()
|
{
|
CVacuumBake* pEquipment = new CVacuumBake();
|
pEquipment->setID(EQ_ID_VACUUMBAKE);
|
pEquipment->setBaseAlarmId(BASE_ALARM_EFEM);
|
pEquipment->setName("VacuumBake(G1)");
|
pEquipment->setDescription("VacuumBake(G1).");
|
pEquipment->setReadBitBlock(0x5c00, 0x66ff);
|
pEquipment->setStation(0, 255);
|
addToEquipmentList(pEquipment);
|
|
|
pEquipment->init();
|
LOGE("已添加“VacuumBake”.");
|
|
return pEquipment;
|
}
|
|
CAligner* CMaster::addAligner()
|
{
|
CAligner* pEquipment = new CAligner();
|
pEquipment->setID(EQ_ID_ALIGNER);
|
pEquipment->setBaseAlarmId(BASE_ALARM_EFEM);
|
pEquipment->setName("Aligner");
|
pEquipment->setDescription("Aligner.");
|
pEquipment->setReadBitBlock(0x0, 0x0);
|
pEquipment->setStation(0, 255);
|
addToEquipmentList(pEquipment);
|
|
|
pEquipment->init();
|
LOGE("已添加“Aligner”.");
|
|
return pEquipment;
|
}
|
|
CEFEM* CMaster::addEFEM()
|
{
|
CEFEM* pEquipment = new CEFEM();
|
pEquipment->setID(EQ_ID_EFEM);
|
pEquipment->setBaseAlarmId(BASE_ALARM_EFEM);
|
pEquipment->setName("EFEM(ROBOT)");
|
pEquipment->setDescription("EFEM(ROBOT).");
|
pEquipment->setReadBitBlock(0x3000, 0x3aff);
|
pEquipment->setStation(0, 255);
|
addToEquipmentList(pEquipment);
|
|
|
pEquipment->init();
|
LOGE("已添加“EFEM(ROBOT)”.");
|
|
return pEquipment;
|
}
|
|
CArm* CMaster::addArm()
|
{
|
CArm* pEquipment = new CArm();
|
pEquipment->setID(EQ_ID_ARM);
|
pEquipment->setBaseAlarmId(BASE_ALARM_EFEM);
|
pEquipment->setName("ARM");
|
pEquipment->setDescription("ARM.");
|
addToEquipmentList(pEquipment);
|
|
|
pEquipment->init();
|
LOGE("已添加“ARM”.");
|
|
return pEquipment;
|
}
|
|
CArmTray* CMaster::addArmTray(int index)
|
{
|
CArmTray* pEquipment = new CArmTray();
|
pEquipment->setID(index == 0 ? EQ_ID_ARM_TRAY1 : EQ_ID_ARM_TRAY2);
|
pEquipment->setBaseAlarmId(BASE_ALARM_EFEM);
|
pEquipment->setName(index == 0 ? "Arm Tray1" : "Arm Tray2");
|
pEquipment->setDescription(index == 0 ? "Arm Tray1." : "Arm Tray2.");
|
addToEquipmentList(pEquipment);
|
|
|
pEquipment->init();
|
LOGE("已添加“%s”.", pEquipment->getName().c_str());
|
|
return pEquipment;
|
}
|
|
/* 添加bonder1 或 bonder2
|
* index -- 0, bonder1
|
* index -- 1, bonder2
|
*/
|
CBonder* CMaster::addBonder(int index)
|
{
|
ASSERT(index == 0 || index == 1);
|
CBonder* pEquipment = new CBonder();
|
pEquipment->setID(EQ_ID_Bonder1 + index);
|
pEquipment->setName(index == 0 ? "Bonder 1" : "Bonder 2");
|
pEquipment->setDescription(index == 0 ? "Bonder 1." : "Bonder 2.");
|
pEquipment->setStation(0, 255);
|
pEquipment->setReadBitBlock(index == 0 ? 0x3b00 : 0x4600,
|
index == 0 ? 0x5600 : 0x6100);
|
pEquipment->setIndex(index);
|
addToEquipmentList(pEquipment);
|
|
|
pEquipment->init();
|
LOGE("已添加“%s”.", pEquipment->getName().c_str());
|
|
|
return pEquipment;
|
}
|
|
CBakeCooling* CMaster::addBakeCooling()
|
{
|
CBakeCooling* pEquipment = new CBakeCooling();
|
pEquipment->setID(EQ_ID_BAKE_COOLING);
|
pEquipment->setBaseAlarmId(BASE_ALARM_EFEM);
|
pEquipment->setName("BakeCooling");
|
pEquipment->setDescription("BakeCooling.");
|
pEquipment->setReadBitBlock(0x5100, 0x5bff);
|
pEquipment->setStation(0, 255);
|
addToEquipmentList(pEquipment);
|
|
pEquipment->init();
|
LOGE("已添加“Aligner”.");
|
|
return pEquipment;
|
}
|
|
CMeasurement* CMaster::addMeasurement()
|
{
|
CMeasurement* pEquipment = new CMeasurement();
|
pEquipment->setID(EQ_ID_MEASUREMENT);
|
pEquipment->setBaseAlarmId(BASE_ALARM_EFEM);
|
pEquipment->setName("Measurement");
|
pEquipment->setDescription("Measurement.");
|
pEquipment->setReadBitBlock(0x6700, 0x6e00);
|
pEquipment->setStation(0, 255);
|
addToEquipmentList(pEquipment);
|
|
pEquipment->init();
|
LOGE("已添加“Measurement”.");
|
|
return pEquipment;
|
}
|
|
void CMaster::onTimer(UINT nTimerid)
|
{
|
for (auto item : m_listEquipment) {
|
item->onTimer(nTimerid);
|
}
|
|
|
static int i = 0;
|
i++;
|
|
// 自动保存缓存
|
if (i % (4 * 2) == 0) {
|
if (m_bDataModify) {
|
saveCacheAndBackups();
|
m_bDataModify = FALSE;
|
}
|
}
|
|
|
// 模拟测试（无机器联机时用于联调 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);
|
// 同时触发一次子机台开始（示例：Bonder1, 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);
|
}
|
|
// 检查CJ是否已经完成
|
ASSERT(m_pControlJob);
|
if (checkAndUpdateCjComplete(m_pControlJob)) {
|
this->saveState();
|
LOGE("<Master>ControlJob(%s)完成.",
|
m_pControlJob->id().c_str());
|
if (m_listener.onCjEnd != nullptr) {
|
m_listener.onCjEnd(this, pJob);
|
}
|
}
|
}
|
}
|
}
|
*/
|
}
|
|
void CMaster::connectEquipments()
|
{
|
int nRet;
|
CLoadPort* pLoadPort1 = (CLoadPort*)getEquipment(EQ_ID_LOADPORT1);
|
CLoadPort* pLoadPort2 = (CLoadPort*)getEquipment(EQ_ID_LOADPORT2);
|
CLoadPort* pLoadPort3 = (CLoadPort*)getEquipment(EQ_ID_LOADPORT3);
|
CLoadPort* pLoadPort4 = (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);
|
|
nRet = pLoadPort1->getPin("Out")->connectPin(pAligner->getPin("In1"));
|
if (nRet < 0) {
|
LOGE("连接LoadPort1-Fliper失败");
|
}
|
nRet = pLoadPort2->getPin("Out")->connectPin(pAligner->getPin("In2"));
|
if (nRet < 0) {
|
LOGE("连接LoadPort1-Fliper失败");
|
}
|
|
nRet = pAligner->getPin("Out1")->connectPin(pFliper->getPin("In"));
|
if (nRet < 0) {
|
LOGE("连接Aligner-Fliper失败");
|
}
|
nRet = pAligner->getPin("Out2")->connectPin(pVacuumBake->getPin("In"));
|
if (nRet < 0) {
|
LOGE("连接Aligner-VacuumBake失败");
|
}
|
|
nRet = pFliper->getPin("Out1")->connectPin(pBonder1->getPin("In1"));
|
if (nRet < 0) {
|
LOGE("连接Fliper-Bonder1失败");
|
}
|
nRet = pFliper->getPin("Out2")->connectPin(pBonder2->getPin("In1"));
|
if (nRet < 0) {
|
LOGE("连接Fliper-Bonder2失败");
|
}
|
|
nRet = pVacuumBake->getPin("Out1")->connectPin(pBonder1->getPin("In2"));
|
if (nRet < 0) {
|
LOGE("连接VacuumBake-Bonder1失败");
|
}
|
nRet = pVacuumBake->getPin("Out2")->connectPin(pBonder2->getPin("In2"));
|
if (nRet < 0) {
|
LOGE("连接VacuumBake-Bonder2失败");
|
}
|
|
nRet = pBonder1->getPin("Out")->connectPin(pBakeCooling->getPin("In1"));
|
if (nRet < 0) {
|
LOGE("连接Bonder1-BakeCooling失败");
|
}
|
|
nRet = pBonder2->getPin("Out")->connectPin(pBakeCooling->getPin("In2"));
|
if (nRet < 0) {
|
LOGE("连接Bonder2-BakeCooling失败");
|
}
|
|
nRet = pBakeCooling->getPin("Out")->connectPin(pMeasurement->getPin("In"));
|
if (nRet < 0) {
|
LOGE("连接BakeCooling-LoadPort3失败");
|
}
|
|
nRet = pMeasurement->getPin("Out1")->connectPin(pLoadPort3->getPin("In"));
|
if (nRet < 0) {
|
LOGE("连接BakeCooling-LoadPort3失败");
|
}
|
|
nRet = pMeasurement->getPin("Out2")->connectPin(pLoadPort4->getPin("In"));
|
if (nRet < 0) {
|
LOGE("连接BakeCooling-LoadPort4失败");
|
}
|
}
|
|
int CMaster::saveCache()
|
{
|
CFile file;
|
if (!file.Open(m_strFilepath.c_str(), CFile::modeCreate | CFile::modeWrite)) {
|
return -1;
|
}
|
|
CArchive ar(&file, CArchive::store);
|
serialize(ar);
|
ar.Close();
|
file.Close();
|
|
return 0;
|
}
|
|
int CMaster::saveCacheAndBackups()
|
{
|
saveCache();
|
|
|
// 创建备份目录
|
CString strNewFile;
|
CString strFileDir = m_strFilepath.c_str();
|
int index = strFileDir.ReverseFind('\\');
|
ASSERT(index > 0);
|
strFileDir = strFileDir.Left(index);
|
strFileDir = strFileDir + _T("Backups");
|
::CreateDirectory(strFileDir, nullptr);
|
|
CTime time = CTime::GetCurrentTime();
|
strNewFile.Format(_T("%s//Master_%d_%02d_%02d_%02d_%02d_%02d.dat"),
|
(LPTSTR)(LPCTSTR)strFileDir,
|
time.GetYear(), time.GetMonth(), time.GetDay(),
|
time.GetHour(), time.GetMinute(), time.GetSecond());
|
::CopyFile(m_strFilepath.c_str(), strNewFile, FALSE);
|
|
return 0;
|
}
|
|
void CMaster::setCacheFilepath(const char* pszFilepath)
|
{
|
m_strFilepath = pszFilepath;
|
}
|
|
int CMaster::readCache()
|
{
|
try {
|
CFile file;
|
if (!file.Open(m_strFilepath.c_str(), CFile::modeRead)) {
|
return -1;
|
}
|
|
CArchive ar(&file, CArchive::load);
|
serialize(ar);
|
ar.Close();
|
file.Close();
|
}
|
catch (CFileException* e) {
|
TCHAR szErr[512];
|
e->GetErrorMessage(szErr, 512);
|
AfxMessageBox(szErr);
|
e->Delete();
|
}
|
|
return 0;
|
}
|
|
void CMaster::serialize(CArchive& ar)
|
{
|
for (auto item : m_listEquipment) {
|
item->serialize(ar);
|
}
|
}
|
|
void CMaster::setState(MASTERSTATE state)
|
{
|
m_state = state;
|
if (m_listener.onMasterStateChanged != nullptr) {
|
m_listener.onMasterStateChanged(this, m_state);
|
}
|
}
|
|
static int taskSeqNo = 0;
|
CRobotTask* CMaster::createTransferTask(CEquipment* pSrcEq, CEquipment* pTarEq,
|
MaterialsType primaryType/* = MaterialsType::G1*/, MaterialsType secondaryType/* = MaterialsType::G2*/,
|
int armNo/* = 1*/, BOOL bJobMode/* = FALSE*/)
|
{
|
if (!pSrcEq->IsEnabled()) {
|
return nullptr;
|
}
|
CRobotTask* pTask = nullptr;
|
CSlot* pSrcSlot, * pTarSlot;
|
pSrcEq->m_nTestFlag = m_nTestFlag;
|
pTarSlot = pTarEq->getAvailableSlotForGlass(primaryType);
|
pSrcSlot = pSrcEq->getProcessedSlot(primaryType, bJobMode);
|
if (m_nTestFlag == 1) 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]);
|
pPort->sendCassetteCtrlCmd(CCC_PROCESS_START, nullptr, 0, 0, 0, nullptr, nullptr);
|
return 0;
|
}
|
|
int CMaster::carrierRelease(unsigned int port)
|
{
|
if (port >= 4) return -1;
|
|
static int pid[] = { EQ_ID_LOADPORT1, EQ_ID_LOADPORT2, EQ_ID_LOADPORT3, EQ_ID_LOADPORT4 };
|
CLoadPort* pPort = (CLoadPort*)getEquipment(pid[port]);
|
pPort->sendCassetteCtrlCmd(CCC_PROCESS_CANCEL, nullptr, 0, 0, 0, nullptr, nullptr);
|
return 0;
|
}
|
|
int CMaster::getContinuousTransferCount()
|
{
|
return m_nContinuousTransferCount;
|
}
|
|
void CMaster::setContinuousTransferCount(int round)
|
{
|
m_nContinuousTransferCount = round;
|
}
|
|
int CMaster::setProcessJobs(std::vector<CProcessJob*>& pjs)
|
{
|
std::vector<SERVO::CProcessJob*> temp;
|
for (auto p : pjs) {
|
if (p->validate(*this)) {
|
p->queue();
|
temp.push_back(p);
|
}
|
}
|
m_processJobs = temp;
|
|
// 重置各端口 DownloadMap（Host/本地勾选的期望加工槽位）
|
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);
|
|
|
// 释放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();
|
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;
|
}
|
}
|
