#include "StdAfx.h"
|
#include "SequenceProcessor_CSOT.h"
|
|
#include "CameraControlAlign.h"
|
#include "CameraController.h"
|
#include "CHReviewSetting/NetworkInfo.h"
|
#include "CHReviewResult/GlassResult.h"
|
#include "CameraControlAlign.h"
|
#include "CHSignalControls/SignalControl.h"
|
#include "CHMotorControls/MotorControl.h"
|
#include "CHAfmControls/AfmControl.h"
|
#include "CHPathScheduler/PathScheduler.h"
|
//#include "MeasureScheduler.h"
|
#include "CHMotorControls/MotorControl.h"
|
#include "CHReviewSetting/SystemInfo.h"
|
#include "CoordCalibrator.h"
|
#include "CHMotorControls/MotorControlInfo.h"
|
#include "ReviewProcessor.h"
|
#include "CHReviewRecipe/RsRecipeManager.h"
|
#include "CHReviewRecipe/RsRcpReviewInfo.h"
|
#include "CHReviewRecipe/RsRcpAlignInfo.h"
|
#include "CHReviewSetting/GlassTypeInfo.h"
|
#include "CHReviewSetting/Sys_AlignManager.h"
|
#include "CHReviewPrioritySorter/PrioritySorter.h"
|
#include "CHReviewRecipe/RsRcpMeasureInfo.h"
|
#include "DlgResultGraph.h"
|
#include "ChartGlassData.h"
|
#include "CHDefectPicker/DefectPicker.h"
|
#include "ReviewProcessor_CSOT.h"
|
#include "CameraControlReview.h"
|
#include "CHWsiControls/WsiControl.h"
|
#include "CHReviewRecipe/Rcp_RsReviewManager.h"
|
#include "ReviewInterface.h"
|
#include "DlgModuleInfo.h"
|
#include <algorithm>
|
#include "DitGlassRawStruct.h"
|
#include <iostream>
|
#include <fstream>
|
#include <afxwin.h>
|
|
|
#define GLASS_GD_FILE_PATH _T("GD")
|
#define SIGNAL_SEND_RESULT_SUCCESS _T("OK")
|
#define SIGNAL_SEND_RESULT_FAIL _T("NG")
|
#define SIGNAL_ON_TIME_INFINITY 0
|
|
enum CSOT_MeasureMode { CSOT_ModeAuto = 0, CSOT_ModeManual };
|
// [2017:4:18]-[WEZASW] : WSI Module ÀåÂø ¼³ºñÀÇ °æ¿ì PlanType ¹øÈ£ º¯°æ.
|
enum CSOT_PlanType { CSOT_PlanReview = 0, CSOT_PlanUser, CSOT_PlanWSI, CSOT_PlanMeasure, CSOT_PlanReflow,CSOT_PlanWsiReflow,CSOT_PlanWsiUser};
|
enum CSOT_InsepectionType{REVIEW_REFLOW = 0, WSI_REFLOW, REV_WSI,WSIUSER, USER};
|
|
enum WSI_REFLOW_POINTINDEX { LEFTTOP=0, TOP, RIGHTTOP, LEFT, RIGHT, LEFTBOTTOM, BOTTOM, RIGHTBOTTOM, LEFTNOTCH, RIGHTNOTCH};
|
enum WSI_REFLOW_CELLSIDE_INDX { CELL_TOP=0, CELL_LEFT, CELL_RIGHT, CELL_LEFTTOP, CELL_RIGHTTOP, CELL_LEFTBOTTOM, CELL_RIGHTBOTTOM, CELL_BOTTOM, CELL_LEFTNOTCH, CELL_RIGHTNOTCH};
|
|
|
enum GlassDataType_CSOT {
|
GLASS_DATA_PROD_ID_CSOT = 0,
|
GLASS_DATA_OPER_ID_CSOT,
|
GLASS_DATA_LOT_ID_CSOT,
|
GLASS_DATA_LOT_SEQUENCE_NUMBER_CSOT,
|
GLASS_DATA_JOB_TYPE_CSOT,
|
GLASS_DATA_JOB_ID_CSOT,
|
GLASS_DATA_PPID_CSOT,
|
GLASS_DATA_GLASS_SCAN_SCHEDULE_CSOT,
|
GLASS_DATA_PPID_RECIPE_CSOT,
|
GLASS_DATA_SLOT_SEQUENCE_NUMBER_CSOT,
|
GLASS_DATA_PROPERTY_CODE_CSOT,
|
GLASS_DATA_JOB_JUDGE_CODE_CSOT,
|
GLASS_DATA_JOB_GRADE_CODE_CSOT,
|
GLASS_DATA_SUBSTRATE_TYPE_CSOT,
|
GLASS_DATA_PROCESSING_FLAG_CSOT,
|
GLASS_DATA_INSPECTION_FLAG_CSOT,
|
GLASS_DATA_SKIP_FLAG_CSOT,
|
GLASS_DATA_JOB_SIZE_CSOT,
|
GLASS_DATA_GLASS_THICKNESS_CSOT,
|
GLASS_DATA_JOB_ANGLE_CSOT,
|
GLASS_DATA_JOB_FLIP_CSOT,
|
GLASS_DATA_CUTTING_GLASS_TYPE_CSOT,
|
GLASS_DATA_PROCESSING_COUNT_CSOT,
|
GLASS_DATA_INSPECTION_JUDGE_DATA_CSOT,
|
GLASS_DATA_PAIR_JOB_ID_CSOT,
|
GLASS_DATA_PAIR_FLAG_CSOT,
|
GLASS_DATA_OPTION_VALUE_CSOT,
|
GLASS_DATA_RESERVED_CSOT
|
|
};
|
|
enum DVDataType_CSOT { DV_DATA_ALIGN1_MACH_VALUE_CSOT = 0,
|
DV_DATA_ALIGN2_MACH_VALUE_CSOT,
|
DV_DATA_ALIGN1_GRAY_VALUE_CSOT,
|
DV_DATA_ALIGN2_GRAY_VALUE_CSOT,
|
DV_DATA_LIGHT_VALUE_CSOT,
|
DV_DATA_LENS_MAGNIFY_CSOT,
|
DV_DATA_REVIEW_DEFECT_DATA_CSOT,
|
DV_DATA_WSI_DEFECT_DATA_CSOT };
|
|
BOOL CSequenceProcessor_CSOT::CompareFuction(CModuleStatus* i, CModuleStatus* j)
|
{
|
if(i->GetMotorPosition()->dGlassPosX == j->GetMotorPosition()->dGlassPosX)
|
return i->GetMotorPosition()->dGlassPosY < j->GetMotorPosition()->dGlassPosY;
|
else
|
return i->GetMotorPosition()->dGlassPosX < j->GetMotorPosition()->dGlassPosX;
|
}
|
|
BOOL CSequenceProcessor_CSOT::GantrySorting(CReviewResult i, CReviewResult j)
|
{
|
return i.GetModuleIndex() < j.GetModuleIndex();
|
}
|
|
CSequenceProcessor_CSOT::CSequenceProcessor_CSOT(void) : CSequenceProcessor()
|
{
|
m_bUseAFMHomePosition = TRUE;
|
m_nGlassCount = 0;
|
CDitGlassRawClient* pDitGlassRaw = CDitGlassRawClient::GetInstance();
|
if(pDitGlassRaw->ConnectServer() == FALSE)
|
{
|
g_pLog->DisplayMessage(_T("°øÀ¯¸Þ¸ð¸® Á¢±Ù ½ÇÆÐ!(Shared memory Access Fail)"));
|
}
|
}
|
|
CSequenceProcessor_CSOT::~CSequenceProcessor_CSOT(void)
|
{
|
m_bUseAFMHomePosition = TRUE;
|
}
|
|
BOOL CSequenceProcessor_CSOT::SetProcessStatus(int nProcessStatus)
|
{
|
EnterCriticalSection(&m_csProcessStatus);
|
|
BOOL bReturn = FALSE;
|
|
// ÇöÀç »óÅ°¡ ÀÌÀü »óÅÂ¿Í ´Ù¸¥°¡?
|
if (nProcessStatus!=m_nProcessStatus || nProcessStatus==0)
|
{
|
if (nProcessStatus==0) // Ãʱâ(0) »óÅÂÀ̸é..
|
{
|
bReturn = TRUE;
|
}
|
else if (nProcessStatus==(m_nProcessStatus+1)) // ÀÌÀü »óÅ ´ÙÀ½(+1)À̸é..
|
{
|
bReturn = TRUE;
|
}
|
|
if (bReturn) // ¼öÇàÀ̸é...
|
{
|
// Thread »ý¼º ÈÄ Thread ¼öÇà
|
CSequenceProcessData* pThreadData = new CSequenceProcessData(this);
|
if (pThreadData)
|
{
|
pThreadData->nProcessStatus = nProcessStatus;
|
bReturn = CreateWorkThread(pThreadData);
|
if(bReturn)
|
{
|
g_pLog->DisplayMessage(_T("[0] nProcessStatus : %d , m_nProcessStatus : %d"), nProcessStatus, m_nProcessStatus);
|
}
|
else
|
{
|
g_pLog->DisplayMessage(_T("[1] nProcessStatus : %d , m_nProcessStatus : %d"), nProcessStatus, m_nProcessStatus);
|
}
|
}
|
else
|
{
|
g_pLog->DisplayMessage(_T("[2] nProcessStatus : %d , m_nProcessStatus : %d"), nProcessStatus, m_nProcessStatus);
|
}
|
}
|
else if(nProcessStatus==2){
|
// Thread »ý¼º ÈÄ Thread ¼öÇà
|
CSequenceProcessData* pThreadData = new CSequenceProcessData(this);
|
if (pThreadData)
|
{
|
pThreadData->nProcessStatus = nProcessStatus;
|
bReturn = CreateWorkThread(pThreadData);
|
if(bReturn)
|
{
|
g_pLog->DisplayMessage(_T("[0] nProcessStatus : %d , m_nProcessStatus : %d"), nProcessStatus, m_nProcessStatus);
|
}
|
else
|
{
|
g_pLog->DisplayMessage(_T("[1] nProcessStatus : %d , m_nProcessStatus : %d"), nProcessStatus, m_nProcessStatus);
|
}
|
}
|
else
|
{
|
g_pLog->DisplayMessage(_T("[2] nProcessStatus : %d , m_nProcessStatus : %d"), nProcessStatus, m_nProcessStatus);
|
}
|
}
|
else
|
{
|
g_pLog->DisplayMessage(_T("[3] nProcessStatus : %d , m_nProcessStatus : %d"), nProcessStatus, m_nProcessStatus);
|
}
|
}
|
else
|
{
|
g_pLog->DisplayMessage(_T("[4] nProcessStatus : %d , m_nProcessStatus : %d"), nProcessStatus, m_nProcessStatus);
|
}
|
|
LeaveCriticalSection(&m_csProcessStatus);
|
|
return bReturn;
|
}
|
|
void CSequenceProcessor_CSOT::RecvWSIResult(int nModuleIndex, const SWsiResult& measureResut)
|
{
|
SReviewResult wisResult;
|
|
if (m_pSP2P==NULL) goto RESULT_FAIL;
|
CGlassResult *pGlassResult = m_pSP2P->ISP2P_GetCurrentGlassResult();
|
if (pGlassResult==NULL) goto RESULT_FAIL;
|
|
g_pLog->DisplayMessage(_T("[WSI_%d]MeasureResult index %d => code %d"), nModuleIndex, measureResut.nResultIndex, measureResut.nResultCode);
|
|
DWORD dwCurTick = GetTickCount();
|
|
CReviewResult* pWsiResult = pGlassResult->GetWsiResult(nModuleIndex);
|
if (pWsiResult==NULL) goto RESULT_FAIL;
|
|
// ¸¶Áö¸· À妽º¸¦ °¡Á®¿Â´Ù.
|
int nCurResultIdx = pWsiResult->GetLastSReviewResultIndex() + 1; // last index + 1
|
int nStartResultIdx = pWsiResult->GetStartSReviewResultIndex();
|
int nEndResultIdx = pWsiResult->GetEndSReviewResultIndex();
|
|
// get grab position
|
const SMotorPosition *pPosition = Module_GetMotorPosition(nModuleIndex);
|
if (pPosition==NULL) goto RESULT_FAIL;
|
int nPosX = int(pPosition->dGlassPosX * 1000.0);
|
int nPosY = int(pPosition->dGlassPosY * 1000.0);
|
int nMPosX = int(pPosition->dMotorPosX * 1000.0);
|
int nMPosY = int(pPosition->dMotorPosY * 1000.0);
|
double dTime = (double) m_ProcessTimer.GetDurationMilliSecond();
|
|
// À妽º°¡ ´Ù¸£¸é ºñÁ¤»óÀÓ.
|
if (measureResut.nResultIndex != nCurResultIdx)
|
{
|
goto RESULT_FAIL;
|
}
|
|
// ÇöÀç µ¥ÀÌÅÍ ÀúÀå.
|
// measureResut
|
|
if(pWsiResult->GetSReviewResultCount() == 0) return ;
|
|
SReviewResult* pSWsiResult = pWsiResult->GetSReviewResult(nCurResultIdx);
|
|
wisResult.nUMOriginX = pSWsiResult->nUMOriginX;//nPosX;
|
wisResult.nUMOriginY = pSWsiResult->nUMOriginY;//nPosY;
|
|
wisResult.dTargetMotorX = pSWsiResult->dTargetMotorX;//pPosition->dMotorPosX;
|
wisResult.dTargetMotorY = pSWsiResult->dTargetMotorY;//pPosition->dMotorPosY;
|
|
wisResult.dDurationTime = dTime;
|
wisResult.nWsi_ResultCode = measureResut.nResultCode;
|
wisResult.nWsi_Type = measureResut.nResultType;
|
wisResult.nWsi_SlopeWarn = measureResut.nXSlopeWarn;
|
|
memcpy(wisResult.pWsi_ResultData, measureResut.pResultData, sizeof(measureResut.pResultData));
|
|
pGlassResult->SetWsiResultData(nModuleIndex, nCurResultIdx, wisResult, nPosX, nPosY, nMPosX, nMPosY, dTime);
|
|
// set last result idx
|
pWsiResult->SetLastSReviewResultIndex(nCurResultIdx);
|
|
// ¸¶Áö¸· Æ÷ÀÎÆ®±îÁö ¿Ô°í, WSI °á°ú°¡ ³²¾Æ ÀÖÀ¸¸é...
|
if(nCurResultIdx==nEndResultIdx && nCurResultIdx<=pWsiResult->GetSReviewResultCount())
|
{
|
nStartResultIdx = nCurResultIdx + 1;
|
nEndResultIdx = nStartResultIdx + MAX_MOTOR_ADDRESS_SIZE - 1;
|
nEndResultIdx = min(nEndResultIdx, (pWsiResult->GetSReviewResultCount()-1));
|
|
g_pLog->DisplayMessage(_T("RemainWsi Started view[%d] start[%d] end[%d]"), nModuleIndex, nStartResultIdx, nEndResultIdx);
|
pWsiResult->SetStartSReviewResultIndex(nStartResultIdx);
|
pWsiResult->SetEndSReviewResultIndex(nEndResultIdx);
|
|
// ³ª¸ÓÁö Æ÷ÀÎÆ® ¸®ºä ¼öÇàÇÏÀÚ.
|
::Sleep(3000); // µô·¹ÀÌ´Â ÇʼöÀÓ. ¾øÀ¸¸é µ¿ÀÛ ¾ÈÇÔ.
|
// Process_RemainWsiPoint(nModuleIndex);
|
}
|
|
// update view
|
m_pSP2P->ISP2P_UpdateReviewResult(nModuleIndex, pGlassResult);
|
RESULT_FAIL:
|
|
return;
|
}
|
|
void CSequenceProcessor_CSOT::RecvWSIUserResult(int nModuleIndex, const SWsiResult& measureResut)
|
{
|
SReviewResult wisUserResult;
|
|
if (m_pSP2P==NULL) goto RESULT_FAIL;
|
CGlassResult *pGlassResult = m_pSP2P->ISP2P_GetCurrentGlassResult();
|
if (pGlassResult==NULL) goto RESULT_FAIL;
|
|
g_pLog->DisplayMessage(_T("[WSI_%d]MeasureResult index %d => code %d"), nModuleIndex, measureResut.nResultIndex, measureResut.nResultCode);
|
|
DWORD dwCurTick = GetTickCount();
|
|
CReviewResult* pWsiResult = pGlassResult->GetWsiUserResult(nModuleIndex);
|
if (pWsiResult==NULL) goto RESULT_FAIL;
|
|
// ¸¶Áö¸· À妽º¸¦ °¡Á®¿Â´Ù.
|
int nCurResultIdx = pWsiResult->GetLastSReviewResultIndex() + 1; // last index + 1
|
int nStartResultIdx = pWsiResult->GetStartSReviewResultIndex();
|
int nEndResultIdx = pWsiResult->GetEndSReviewResultIndex();
|
|
// get grab position
|
const SMotorPosition *pPosition = Module_GetMotorPosition(nModuleIndex);
|
if (pPosition==NULL) goto RESULT_FAIL;
|
int nPosX = int(pPosition->dGlassPosX * 1000.0);
|
int nPosY = int(pPosition->dGlassPosY * 1000.0);
|
int nMPosX = int(pPosition->dMotorPosX * 1000.0);
|
int nMPosY = int(pPosition->dMotorPosY * 1000.0);
|
double dTime = (double) m_ProcessTimer.GetDurationMilliSecond();
|
|
// À妽º°¡ ´Ù¸£¸é ºñÁ¤»óÀÓ.
|
if (measureResut.nResultIndex != nCurResultIdx)
|
{
|
goto RESULT_FAIL;
|
}
|
|
// ÇöÀç µ¥ÀÌÅÍ ÀúÀå.
|
// measureResut
|
|
if(pWsiResult->GetSReviewResultCount() == 0) return ;
|
|
SReviewResult* pSWsiResult = pWsiResult->GetSReviewResult(nCurResultIdx);
|
|
wisUserResult.nUMOriginX = pSWsiResult->nUMOriginX;//nPosX;
|
wisUserResult.nUMOriginY = pSWsiResult->nUMOriginY;//nPosY;
|
|
wisUserResult.dTargetMotorX = pSWsiResult->dTargetMotorX;//pPosition->dMotorPosX;
|
wisUserResult.dTargetMotorY = pSWsiResult->dTargetMotorY;//pPosition->dMotorPosY;
|
|
wisUserResult.dDurationTime = dTime;
|
wisUserResult.nWsi_ResultCode = measureResut.nResultCode;
|
wisUserResult.nWsi_Type = measureResut.nResultType;
|
wisUserResult.nWsi_SlopeWarn = measureResut.nXSlopeWarn;
|
|
memcpy(wisUserResult.pWsi_ResultData, measureResut.pResultData, sizeof(measureResut.pResultData));
|
|
pGlassResult->SetUserWsiResultData(nModuleIndex, nCurResultIdx, wisUserResult, nPosX, nPosY, nMPosX, nMPosY, dTime);
|
|
// set last result idx
|
pWsiResult->SetLastSReviewResultIndex(nCurResultIdx);
|
|
// ¸¶Áö¸· Æ÷ÀÎÆ®±îÁö ¿Ô°í, WSI °á°ú°¡ ³²¾Æ ÀÖÀ¸¸é...
|
if(nCurResultIdx==nEndResultIdx && nCurResultIdx<=pWsiResult->GetSReviewResultCount())
|
{
|
nStartResultIdx = nCurResultIdx + 1;
|
nEndResultIdx = nStartResultIdx + MAX_MOTOR_ADDRESS_SIZE - 1;
|
nEndResultIdx = min(nEndResultIdx, (pWsiResult->GetSReviewResultCount()-1));
|
|
g_pLog->DisplayMessage(_T("RemainWsi Started view[%d] start[%d] end[%d]"), nModuleIndex, nStartResultIdx, nEndResultIdx);
|
pWsiResult->SetStartSReviewResultIndex(nStartResultIdx);
|
pWsiResult->SetEndSReviewResultIndex(nEndResultIdx);
|
|
// ³ª¸ÓÁö Æ÷ÀÎÆ® ¸®ºä ¼öÇàÇÏÀÚ.
|
::Sleep(3000); // µô·¹ÀÌ´Â ÇʼöÀÓ. ¾øÀ¸¸é µ¿ÀÛ ¾ÈÇÔ.
|
// Process_RemainWsiPoint(nModuleIndex);
|
}
|
|
// update view
|
m_pSP2P->ISP2P_UpdateReviewResult(nModuleIndex, pGlassResult);
|
RESULT_FAIL:
|
|
return;
|
}
|
|
|
|
void CSequenceProcessor_CSOT::RecvAlignResult(const CAlignResult* pCurAlignResult)
|
{
|
if (m_pSP2P==NULL || pCurAlignResult==NULL) return;
|
|
CGlassResult *pGlassResult = m_pSP2P->ISP2P_GetCurrentGlassResult();
|
if (pGlassResult==NULL)
|
{
|
g_pLog->DisplayMessage(_T("[AlignResult] Glass Result is NULL!"));
|
SendResultToSignalControl(PCControlSendData_AlignResult_CSOT, SIGNAL_SEND_RESULT_FAIL);
|
m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor::AlignStart] Send Align Fail Signal!"));
|
return;
|
}
|
|
SAlignResult sAlignResult;
|
CAlignResult *pAlignResult = &pGlassResult->m_AlignResult;
|
CAlignRecipe *pAlignRecipe = &pGlassResult->m_AlignRecipe;
|
|
// ¾ó¶óÀÎ ÀÚµ¿Á¶¸í °á°ú ·¹½ÃÇÇ¿¡ ÀúÀåÇÏÀÚ.
|
CRsRcpAlignInfo *pRsRcpAlignInfo = m_pSP2P->ISP2P_Recipe_GetRsRcpAlignInfo();
|
if (pRsRcpAlignInfo!=NULL && pRsRcpAlignInfo->m_bAutoProcess)
|
{
|
if (pCurAlignResult->nAutoLightResult[0]==LightProcessComplete)
|
{
|
pRsRcpAlignInfo->m_dFirstCamExposure = pCurAlignResult->dExposureTime[0];
|
}
|
|
if (pCurAlignResult->nAutoLightResult[1]==LightProcessComplete)
|
{
|
pRsRcpAlignInfo->m_dSecondCamExposure = pCurAlignResult->dExposureTime[1];
|
}
|
|
// ·¹½ÃÇÇ µ¥ÀÌŸ ÀúÀå
|
//m_pDoc->Recipe_WriteRecipeFile();
|
}
|
|
|
BOOL bLastAlignResult = FALSE;
|
CCoordCalibrator *pCoordCalibrator = m_pSP2P->ISP2P_GetCoordCalibrator();
|
// ÃÖÁ¾ ¾ó¶óÀÎ °á°ú..
|
if (pCoordCalibrator && pCurAlignResult->nResultCode==Align_Success)
|
{
|
g_pLog->DisplayMessage(_T("[AlignResult] Align Find Success!"));
|
|
// ¾ó¶óÀÎ °á°ú ±Û¶ó½º Á¤º¸¿¡ °»½Å
|
*pAlignResult = *pCurAlignResult;
|
|
pCoordCalibrator->SetFirstMarkPos(pAlignResult->dFindPositionX[0], pAlignResult->dFindPositionY[0], pAlignRecipe->dGlassPositionX[0], pAlignRecipe->dGlassPositionY[0]);
|
pCoordCalibrator->SetSecondMarkPos(pAlignResult->dFindPositionX[1], pAlignResult->dFindPositionY[1], pAlignRecipe->dGlassPositionX[1], pAlignRecipe->dGlassPositionY[1]);
|
|
// °¢µµ °è»ê
|
if(pCoordCalibrator->CalculateAlignResult() == TRUE)
|
{
|
sAlignResult = pCoordCalibrator->GetAlignResult();
|
g_pLog->DisplayMessage(_T("[AlignResult] Origin Pos: %.03lf, %.03lf, Degree: %.08lf"), sAlignResult.dOriginX, sAlignResult.dOriginY, sAlignResult.dDegree);
|
|
bLastAlignResult = !pAlignRecipe->bRotateProcess;
|
}
|
|
// ±Û¶ó½º °¢µµ º¸Á¤ À¯¹«
|
CCameraControlAlign *pAlignCameraControl = m_pSP2P->ISP2P_GetAlignCameraControl();
|
SThetaMotorInfo* pThetaMotorInfo = m_pSP2P->ISP2P_GetThetaMotorInfo();
|
CMotorControl* pMotorControl = m_pSP2P->ISP2P_GetMotorControl();
|
|
if (pAlignRecipe->bRotateProcess && pAlignCameraControl && pMotorControl && pThetaMotorInfo)
|
{
|
if (fabs(sAlignResult.dDegree) <= pAlignRecipe->dGlassAngleMin) // ÇöÀç ±Û¶ó½º °¢µµ°¡ ÃÖ¼Ò°¢º¸´Ù ÀÛÀ¸¸é ¼º°ø
|
{
|
bLastAlignResult = TRUE;
|
g_pLog->DisplayMessage(_T("[AlignResult] Success! Last Glass Angle : %.8lf degree, Retry Count : %d ea"),
|
sAlignResult.dDegree, pCurAlignResult->nFindCount);
|
}
|
else if (fabs(sAlignResult.dDegree) > pAlignRecipe->dGlassAngleMax) // ÇöÀç ±Û¶ó½º °¢µµ°¡ ÃÖ´ë°¢º¸´Ù Å©¸é ½ÇÆÐ
|
{
|
bLastAlignResult = FALSE;
|
g_pLog->DisplayMessage(_T("[AlignResult] FAIL! Last Glass Angle : %.8lf degree, Retry Count : %d ea"),
|
sAlignResult.dDegree, pCurAlignResult->nFindCount);
|
}
|
else if (pCurAlignResult->nFindCount < pAlignRecipe->nRetryCount) // À纸Á¤ Ƚ¼ö°¡ ·¹½ÃÇÇ È½¼ö ÀÌÇÏÀ̸é À纸Á¤ ¼öÇà
|
{
|
g_pLog->DisplayMessage(_T("[AlignResult] Current Glass Angle : %.8lf degree, Retry Count : %d ea"),
|
sAlignResult.dDegree, pCurAlignResult->nFindCount);
|
|
// ¸ðÅÍ·Î °¢µµ º¸Á¤..
|
double dCalAngle = sAlignResult.dDegree;
|
dCalAngle = pThetaMotorInfo->dPosition - dCalAngle ;
|
g_pLog->DisplayMessage(_T("[AlignResult] Move Rotate Glass Angle : %.8lf degree"), dCalAngle);
|
pMotorControl->AxisThetaManualGoEnd(dCalAngle);
|
::Sleep(100);
|
|
// ¾ó¶óÀÎ ReProcess
|
if (pAlignCameraControl->AlignProcess())
|
{
|
g_pLog->DisplayMessage(_T("[AlignResult] Align Find Process ReStarted!"));
|
return;
|
}
|
}
|
}
|
}
|
else
|
{
|
g_pLog->DisplayMessage(_T("[AlignResult] Align Find FAIL!"));
|
*pAlignResult = *pCurAlignResult;
|
}
|
|
g_pLog->DisplayMessage(_T("[AlignResult] Align Result: %d, Match Rate: %.3lf, %.3lf"),
|
pAlignResult->nResultCode, pAlignResult->dFindScore[0], pAlignResult->dFindScore[1]);
|
|
g_pLog->DisplayMessage(_T("[AlignResult] 1st Align Pixel: %.3lf, %.3lf, 2nd Align Pixel: %.3lf, %.3lf"),
|
pAlignResult->dFindPixelX[0], pAlignResult->dFindPixelY[0],
|
pAlignResult->dFindPixelX[1], pAlignResult->dFindPixelY[1]);
|
|
g_pLog->DisplayMessage(_T("[AlignResult] 1st Align Mot: %.3lf, %.3lf, 2nd Align Mot: %.3lf, %.3lf"),
|
pAlignResult->dFindPositionX[0], pAlignResult->dFindPositionY[0],
|
pAlignResult->dFindPositionX[1], pAlignResult->dFindPositionY[1]);
|
|
AlignNetwork_SendAlignResult(pGlassResult);
|
|
|
if(pCoordCalibrator)
|
{
|
sAlignResult = pCoordCalibrator->GetAlignResult();
|
//m_pView->SetAlignResult(pAlignResult->nResultCode, sAlignResult.dOriginX, sAlignResult.dOriginY, sAlignResult.dDegree);
|
}
|
|
// PCControl ¾ó¶óÀÎ ½ÅÈ£ Àü¼Û.
|
if (bLastAlignResult) // ÃÖÁ¾ ¾ó¶óÀΰá°ú...
|
{
|
SendResultToSignalControl(PCControlSendData_AlignResult_CSOT, SIGNAL_SEND_RESULT_SUCCESS);
|
m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor::AlignStart] Send Align Success Data!"));
|
}
|
else
|
{
|
SendResultToSignalControl(PCControlSendData_AlignResult_CSOT, SIGNAL_SEND_RESULT_FAIL);
|
m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor::AlignStart] Send Align Fail Data!"));
|
}
|
|
SendSignalToSignalControl(PCControlSendSignalIndex_Seq, PCControlSend_AlignComplete_CSOT);
|
m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor::AlignStart] Send Align Complete Signal!"));
|
|
// LJY-20180905
|
m_pSP2P->ISP2P_UpdateAlignResultStatus(0, pGlassResult);
|
}
|
|
BOOL CSequenceProcessor_CSOT::RecvSignalToSignalControl( int nSignalIndex, int nSignalValue, BOOL bSignalOn/*=TRUE*/ )
|
{
|
BOOL bResult = FALSE;
|
|
switch(nSignalIndex)
|
{
|
case PCControlRecvSignalIndex_State:
|
bResult = ProcessSignal_State(nSignalValue, bSignalOn);
|
break;
|
|
case PCControlRecvSignalIndex_StateSub:
|
// bResult = ProcessSignal_StateSub(nSignalValue, bSignalOn);
|
break;
|
|
case PCControlRecvSignalIndex_Seq:
|
bResult = ProcessSignal_Seq(nSignalValue, bSignalOn);
|
break;
|
|
case PCControlRecvSignalIndex_Ack:
|
bResult = ProcessSignal_Ack(nSignalValue, bSignalOn);
|
break;
|
}
|
|
return bResult;
|
}
|
|
void CSequenceProcessor_CSOT::CompletePlanIndex(int nReviewStatus, int nPlanIndex)
|
{
|
CRsRcpReviewInfo* pRsRcpReviewInfo = m_pSP2P->ISP2P_Recipe_GetRsRcpReviewInfo();
|
if(pRsRcpReviewInfo == NULL) return;
|
|
CGlassResult *pGlassResult = m_pSP2P->ISP2P_GetCurrentGlassResult();
|
if(pGlassResult == NULL) return;
|
|
CRcpPlanInfo *BfpPlanInfo = pRsRcpReviewInfo->GetRcpPlanInfo(nPlanIndex);
|
int nBeforePlanIndex = BfpPlanInfo->m_nReviewType;
|
|
switch(nReviewStatus)
|
{
|
case ReviewProcessStatus_ReviewEnd:
|
m_pSP2P->ISP2P_DisplayMessage(_T("[CompletePlanIndex] ProcessSatus Review End / PlanIndex : %02d"),nPlanIndex);
|
break;
|
|
case ReviewProcessStatus_MeasureEnd:
|
m_pSP2P->ISP2P_DisplayMessage(_T("[CompletePlanIndex] ProcessSatus Measure End / PlanIndex : %02d"),nPlanIndex);
|
break;
|
|
case ReviewProcessStatus_UserEnd:
|
m_pSP2P->ISP2P_DisplayMessage(_T("[CompletePlanIndex] ProcessSatus User End / PlanIndex : %02d"),nPlanIndex);
|
break;
|
|
case ReviewProcessStatus_WSIEnd:
|
m_pSP2P->ISP2P_DisplayMessage(_T("[CompletePlanIndex] ProcessSatus WSI End / PlanIndex : %02d"),nPlanIndex);
|
break;
|
|
case ReviewProcessStatus_ReflowEnd:
|
m_pSP2P->ISP2P_DisplayMessage(_T("[CompletePlanIndex] ProcessSatus Reflow End / PlanIndex : %02d"),nPlanIndex);
|
break;
|
|
case ReviewProcessStatus_WSIReflowEnd:
|
m_pSP2P->ISP2P_DisplayMessage(_T("[CompletePlanIndex] ProcessSatus Wsi Reflow End / PlanIndex : %02d"),nPlanIndex);
|
break;
|
}
|
|
// next plan
|
nPlanIndex++;
|
CRcpPlanInfo *pPlanInfo = pRsRcpReviewInfo->GetRcpPlanInfo(nPlanIndex);
|
|
// last plan?
|
if (pPlanInfo==NULL)
|
{
|
m_pSP2P->ISP2P_DisplayMessage(_T("[CompletePlanIndex] LastPlan Complete"));
|
SendResultToSignalControl(PCControlSendData_ReviewResult_CSOT, SIGNAL_SEND_RESULT_SUCCESS);
|
SendSignalToSignalControl(PCControlSendSignalIndex_Seq, PCControlSend_ReviewComplete_CSOT);
|
m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor::ReviewStart] Send Review Success Signal!"));
|
m_pSP2P->ISP2P_UpdateReviewProcessStatus(ReviewProcessStatus_None, nPlanIndex);
|
|
//µ¥¸ð¿ë
|
AFM_SetAFMTracking(FALSE);
|
return;
|
}
|
|
//190727 ÃÖÇü¸ñ WSI ÁøÇà½Ã End üũ ÈÄ ÁøÇà
|
if(nBeforePlanIndex==CSOT_PlanWSI||nBeforePlanIndex==CSOT_PlanWsiReflow||nBeforePlanIndex==CSOT_PlanWsiUser)
|
{
|
if(pPlanInfo->m_nReviewType ==CSOT_PlanWSI ||pPlanInfo->m_nReviewType ==CSOT_PlanWsiReflow||pPlanInfo->m_nReviewType==CSOT_PlanWsiUser)
|
{
|
DWORD dwTick = GetTickCount();
|
if(GetCheckWSIEnd() == 0)
|
{
|
while(1)
|
{
|
if(GetCheckWSIEnd() == 1)
|
{
|
m_pSP2P->ISP2P_DisplayMessage(_T("[Sequence Processor] Wsi end Check Success! WSI TYPE[%d]"),pPlanInfo->m_nReviewType);
|
break;
|
}
|
|
else if(GetTickCount()-dwTick >=4000)
|
{
|
|
m_pSP2P->ISP2P_DisplayMessage(_T("[Sequence Processor] Wsi End Recv Fail! OverTime WSI TYPE[%d]"),pPlanInfo->m_nReviewType);
|
m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor::ReviewStart] Send Review Fail Signal!"));
|
|
break;
|
}
|
}
|
}
|
}
|
}
|
|
//190727 ÃÖÇü¸ñ WSI type ÁøÇàÈÄ Review Ç÷£½Ã ÁøÇà½Ã Ä«¸Þ¶ó°¡ ±Û¶ó½º ¹Û¿¡ ÀÖÀ»°æ¿ì¸¦ À§ÇÑ...
|
if(nBeforePlanIndex==CSOT_PlanWSI ||nBeforePlanIndex==CSOT_PlanWsiReflow||nBeforePlanIndex==CSOT_PlanWsiUser)
|
{
|
if( pPlanInfo->m_nReviewType == CSOT_PlanReview|| pPlanInfo->m_nReviewType ==CSOT_PlanUser|| pPlanInfo->m_nReviewType ==CSOT_PlanMeasure|| pPlanInfo->m_nReviewType ==CSOT_PlanReflow)
|
{
|
|
CTotalPitchMeasure* pTotapPithMeasure = m_pSP2P->ISP2P_GetTotalPitchMeasure(); // ºô·Á¾²±â! 20190730 ÃÖÇü¸ñ ³ªÁß¿¡ ÇÔ¼ö·Î µû·Î....
|
|
const CMotorControlInfo* pSystemMotorInfo = m_pSP2P->ISP2P_System_GetMotorInfo();
|
if(pSystemMotorInfo !=NULL)
|
{
|
|
if( SendReviewStartMotorPosition(0,pSystemMotorInfo->GetStartMotorXpos(),pSystemMotorInfo->GetStartMotorYpos(),0))
|
{
|
Sleep(2000);
|
if(pTotapPithMeasure->GetMotorEnable())
|
{
|
m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor::ReviewStart] Send StartMotorPosition! BP:%d CP :%d"),nBeforePlanIndex,pPlanInfo->m_nReviewType);
|
Sleep(3000);
|
}
|
|
}
|
else
|
{
|
m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor::ReviewStart] Send StartMotorPosition Fail!!!! BP:%d CP :%d"),nBeforePlanIndex,pPlanInfo->m_nReviewType);
|
}
|
}
|
else
|
{
|
m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor::ReviewStart] Send StartMotorPosition pSystemMotorInfo is null"));
|
}
|
|
|
|
}
|
}
|
|
// execute next plan
|
DWORD nWaitTime = 0;
|
int nTotalCount = 0;
|
int temp = 0;
|
BOOL bExcute = FALSE;
|
int nPlanCount = pRsRcpReviewInfo->GetRcpPlanInfoCount();
|
|
for (int nPlanIdx=nPlanIndex; nPlanIdx<nPlanCount; nPlanIdx++)
|
{
|
pPlanInfo = pRsRcpReviewInfo->GetRcpPlanInfo(nPlanIdx);
|
if(pPlanInfo == NULL) continue;
|
|
// plan motion
|
switch(pPlanInfo->m_nReviewType)
|
{
|
case CSOT_PlanReview:
|
if (( nTotalCount += pGlassResult->GetTotalSReviewResultCount()) > 0)
|
{
|
m_pSP2P->ISP2P_DisplayMessage(_T("[Sequence Processor] Review Plan Start!"));
|
::Sleep(nWaitTime);
|
bExcute = ReviewStartProcessing(pGlassResult, nPlanIdx);
|
m_pSP2P->ISP2P_DisplayMessage(_T("[Sequence Processor] Review Plan End!"));
|
}
|
break;
|
|
case CSOT_PlanUser:
|
if (( nTotalCount += pGlassResult->GetTotalSUserResultCount()) > 0)
|
{
|
m_pSP2P->ISP2P_DisplayMessage(_T("[Sequence Processor] User Plan Start!"));
|
::Sleep(nWaitTime);
|
bExcute = UserStartProcessing(pGlassResult, nPlanIdx);
|
m_pSP2P->ISP2P_DisplayMessage(_T("[Sequence Processor] User Plan End!"));
|
}
|
break;
|
|
case CSOT_PlanWSI:
|
if (( nTotalCount += pGlassResult->GetTotalSWsiResultCount()) > 0)
|
{
|
m_pSP2P->ISP2P_DisplayMessage(_T("[Sequence Processor] WSI Plan Start!"));
|
::Sleep(nWaitTime);
|
bExcute = WsiStartProcessing(pGlassResult, nPlanIdx);
|
m_pSP2P->ISP2P_DisplayMessage(_T("[Sequence Processor] WSI Plan End!"));
|
}
|
break;
|
//¹Ì»ç¿ë
|
case CSOT_PlanMeasure:
|
if (( nTotalCount += pGlassResult->GetTotalSMeasureResultCount()) > 0)
|
{
|
::Sleep(nWaitTime);
|
m_pSP2P->ISP2P_DisplayMessage(_T("[Sequence Processor] Measure Plan Start!"));
|
bExcute = MeasureStartProcessing(pGlassResult, nPlanIdx);
|
m_pSP2P->ISP2P_DisplayMessage(_T("[Sequence Processor] Measure Plan End!"));
|
}
|
break;
|
|
case CSOT_PlanReflow:
|
if (( nTotalCount += pGlassResult->GetTotalSReflowResultCount()) > 0)
|
{
|
::Sleep(nWaitTime);
|
m_pSP2P->ISP2P_DisplayMessage(_T("[Sequence Processor] Reflow Plan Start!"));
|
bExcute = ReflowStartProcessing(pGlassResult, nPlanIdx);
|
m_pSP2P->ISP2P_DisplayMessage(_T("[Sequence Processor] Reflow Plan End!"));
|
}
|
break;
|
case CSOT_PlanWsiReflow:
|
if (( nTotalCount += pGlassResult->GetTotalSWsiReflowResultCount()) > 0)
|
{
|
::Sleep(nWaitTime);
|
m_pSP2P->ISP2P_DisplayMessage(_T("[Sequence Processor] WsiReflow Plan Start!"));
|
bExcute = WsiReflowStartProcessing(pGlassResult, nPlanIdx);
|
m_pSP2P->ISP2P_DisplayMessage(_T("[Sequence Processor] WsiReflow Plan End!"));
|
}
|
break;
|
case CSOT_PlanWsiUser:
|
if (( nTotalCount += pGlassResult->GetTotalSWsiUserResultCount()) > 0)
|
{
|
::Sleep(nWaitTime);
|
m_pSP2P->ISP2P_DisplayMessage(_T("[Sequence Processor] WsiUser Plan Start!"));
|
bExcute = WsiUserStartProcessing(pGlassResult, nPlanIdx);
|
m_pSP2P->ISP2P_DisplayMessage(_T("[Sequence Processor] WsiUser Plan End!"));
|
}
|
break;
|
}
|
|
if (nTotalCount>0) break;
|
}
|
|
if (nTotalCount>0 && bExcute==FALSE)
|
{
|
SendResultToSignalControl(PCControlSendData_ReviewResult_CSOT, SIGNAL_SEND_RESULT_FAIL);
|
SendSignalToSignalControl(PCControlSendSignalIndex_Seq, PCControlSend_ReviewComplete_CSOT);
|
m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor::ReviewStart] Send Review Fail Signal!"));
|
}
|
else if (nTotalCount==0)
|
{
|
SendResultToSignalControl(PCControlSendData_ReviewResult_CSOT, SIGNAL_SEND_RESULT_SUCCESS);
|
SendSignalToSignalControl(PCControlSendSignalIndex_Seq, PCControlSend_ReviewComplete_CSOT);
|
m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor::ReviewStart] Send Review Success Signal!"));
|
}
|
}
|
|
void CSequenceProcessor_CSOT::WorkThreadProcess(PVOID pParameter)
|
{
|
if (m_pSP2P==NULL || pParameter==NULL) return;
|
|
CSequenceProcessData* pProcessData = static_cast<CSequenceProcessData*>(pParameter);
|
m_nProcessStatus = pProcessData->nProcessStatus;
|
|
switch(pProcessData->nProcessStatus)
|
{
|
case ProcessLoading_CSOT:
|
Process_Loading();
|
break;
|
|
case ProcessAlignStart_CSOT:
|
Process_AlignStart();
|
break;
|
|
case ProcessReadRawFile_CSOT:
|
Process_ReadRawFile();
|
break;
|
|
case ProcessReviewStart_CSOT:
|
Process_ReviewStart();
|
break;
|
|
case ProcessReviewEnd_CSOT:
|
Process_ReviewEnd();
|
break;
|
|
}
|
return;
|
}
|
|
void CSequenceProcessor_CSOT::Process_Loading()
|
{
|
m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor::IN] Loading!"));
|
|
AllAckSignalOff();
|
|
SetCheckWSIEnd(-1); //190726 wsiendüũ ÃʱâÈ
|
SetWsiType(-1); //wsi reflow ŸÀÔ ±¸º° ÃʱâÈ
|
|
if (SendSignalToSignalControl(PCControlSendSignalIndex_Ack, PCControlSend_LoadingAck_CSOT))
|
m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor::GlassLoading] Send Loading Ack Signal!"));
|
|
// read config file
|
if(!m_pSP2P->ISP2P_System_ReadConfigFile())
|
m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor] System Value Loading FAIL!"));
|
|
m_nWsiTotalCount = 0;
|
|
// make new glass result
|
int nGlassResultCount = 0;
|
CGlassResult* pGlassResult = m_pSP2P->ISP2P_GetNewGlassResult(nGlassResultCount);
|
if (pGlassResult==NULL)
|
{
|
m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor::Loading] Glass Result Create FAIL!"));
|
return;
|
}
|
m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor::Loading] Glass Result Count : %d ea"), nGlassResultCount);
|
|
pGlassResult->ResetDefocusCount();//·Îµù ºÎºÐ¿¡¼ defocus count ÃʱâÈ 190821 ÃÖÇü¸ñ
|
|
|
CTime time = CTime::GetCurrentTime();
|
pGlassResult->m_strResultDate.Format(_T("%04d.%02d.%02d"), time.GetYear(), time.GetMonth(), time.GetDay());
|
|
//if(Revolver_SetGoHome(0)) // ¸®º¼¹ö HOME ½ÃÄö½º
|
//{
|
// m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor::Loading] Revolver Set GoHome Success!"));
|
//}
|
|
// get transfer data
|
int nResultCode = 0;
|
STransferData* pTransferData = m_pSP2P->ISP2P_GetCurrentTransferData();
|
if (pTransferData==NULL)
|
{
|
m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor::Loading] Transfer Data Read FAIL!"));
|
nResultCode = 1;
|
}
|
|
// read transfer data
|
if (pTransferData)
|
{
|
// read transfer data
|
if (ReadTransferDataFromSignalControl(pTransferData)==FALSE)
|
{
|
m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor::Loading] Transfer Data Read FAIL!"));
|
nResultCode = 2;
|
}
|
else
|
{
|
m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor::Loading] Transfer Data Read Success!"));
|
|
UpdateGlassResultFromTransferData(pGlassResult, pTransferData);
|
|
CreateResultDirectory(pTransferData->strJobID, pGlassResult->m_strResultDate);
|
|
SetSaveImageBasePathToReviewProcessor(pTransferData->strJobID, pGlassResult->m_strResultDate);
|
|
SetSaveImageBasePathToAlignCameraControl(pTransferData->strJobID);
|
|
|
CString strRecipefile = _T("");
|
if(ReadRecipeDataFromRecipeFile(pTransferData->strPPID_RC, strRecipefile) == 0)
|
{
|
m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor::Loading] Recipe File Read FAIL!"));
|
nResultCode = 3;
|
}
|
else
|
{
|
m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor::Loading] Recipe File Read Success![ %s ]"), strRecipefile, pTransferData->strPPID_RC);
|
}
|
|
m_pSP2P->ISP2P_DisplayMessage(_T("[Glass Loading] Current Apply Recipe Name : %s"), strRecipefile);
|
|
// recipe data apply
|
if(ApplyRecipeDataToGlassResult(pGlassResult)==FALSE)
|
{
|
m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor::Loading] Apply Recipe Data To GlassResult FAIL!"));
|
nResultCode = 4;
|
}
|
else
|
{
|
|
m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor::Loading] Align First File name %s"),pGlassResult->m_AlignRecipe.strFirstImageFile);
|
m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor::Loading] Align Second File name %s"),pGlassResult->m_AlignRecipe.strSecondImageFile);
|
m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor::Loading] Apply Recipe Data To GlassResult Success!"));
|
}
|
}
|
}
|
|
//// 190725 °í°´»ç ¿äû»çÇ× ÃÖÇü¸ñ ASCEND ½Ã alarm
|
const CRsRcpReviewInfo* pRsRcpReviewInfo = m_pSP2P->ISP2P_Recipe_GetRsRcpReviewInfo();
|
|
const CRcpSortingInfo *pSortingInfo = pRsRcpReviewInfo->GetRcpReviewSortInfo();
|
if(pSortingInfo->m_nSortData== 1) // RCP_SORT_DATA_ORDER_ASCEND == 1
|
{
|
SendSignalToSignalControl(PCControlSendSignalIndex_State,PCControlSend_RecipeASCEND,1000);//
|
|
g_pLog->DisplayMessage(_T("[SequenceProcessor::GlassLoading] Recipe Is ASCEND!!"));
|
//SendSignalOffToSignalControl(PCControlSendSignalIndex_State,PCControlSend_RecipeASCEND); //190723 recipe ASCEND bit off
|
}
|
|
////
|
m_pSP2P->ISP2P_GlassPositionUpdate();
|
|
//·¹½ÃÇÇ ¼¼ÆÃÀ¸·Î ¿È±è 190618
|
if(GetUseAfmHomePosition())
|
{
|
g_pLog->DisplayMessage(_T("[AFM] AFM Home Position Start!!!"));
|
|
if(!MoveAFMHomePosition()) g_pLog->DisplayMessage(_T("[AFM] AFM Home Position Fail"));
|
|
}
|
|
//°øÀ¯¸Þ¸ð¸® Ä¿¸àµå ¸®ºä ½ºÅ¸Æ®(±Û¶ó½º ·Îµù)
|
CDitGlassRawClient* pDitSharedGlassRaw = CDitGlassRawClient::GetInstance();
|
if(pDitSharedGlassRaw->isConnect() == FALSE) m_pSP2P->ISP2P_DisplayMessage(_T("[DitGlassRawClient] Shared Memory Connect Fail"));
|
|
CRsRcpReviewInfo* pRecipeinfo = m_pSP2P->ISP2P_Recipe_GetRsRcpReviewInfo();
|
if(pRecipeinfo == NULL) return;
|
int nWsiTypecount = 0;
|
|
for(int nPlanIndex = 0; nPlanIndex < pRecipeinfo->GetRcpPlanInfoCount(); nPlanIndex++)
|
{
|
CRcpPlanInfo* pRcpPlanInfo = pRecipeinfo->GetRcpPlanInfo(nPlanIndex);
|
if(pRcpPlanInfo == NULL) continue;
|
|
if(pRcpPlanInfo->m_nReviewType == CSOT_PlanWSI ||pRcpPlanInfo->m_nReviewType ==CSOT_PlanWsiUser||pRcpPlanInfo->m_nReviewType == CSOT_PlanWsiReflow)
|
{
|
if(nWsiTypecount>=1) //190725 Çѹø¸¸ Setwsi go go
|
{
|
continue;
|
}
|
|
SetWsiType(pRcpPlanInfo->m_nReviewType);
|
// Send Ready Signal to WIS
|
if(!WSIAllReadySignal())
|
{
|
g_pLog->DisplayMessage(_T("[WSI] Send Ready Signal to All WIS Fail"));
|
}
|
nWsiTypecount += 1;
|
}
|
}
|
|
CakAOISharedSystem* pAOIShared = CReviewInterface::GetInstance(); //20191017
|
pProtocolData =pAOIShared->getReviewProtocol();
|
|
pProtocolData->m_ModuleData[0].m_nPlanDefectCount=0;
|
pProtocolData->m_ModuleData[0].m_nReviewedDefectCount=0;
|
|
//pProtocolData->m_ModuleData[nModuleIdx].m_nPlanDefectCount += pScheduleResult->GetPathSchedulerResultCount();
|
|
/*for (int i=0;i<pScheduleResult->GetPathSchedulerResultCount();i++)
|
{
|
pNode = pScheduleResult->GetPathSchedulerResult(i);
|
pProtocolData->SetPlanReviewPos(nModuleIdx,nStIndex+i, 0, 0);
|
}
|
*/
|
|
//if(!ChangeUserReviewAxisCenterPosition(pGlassResult)) m_pSP2P->ISP2P_DisplayMessage(_T("[ChangeUserReviewPosition] Change Fail!!"));
|
|
RemoveMotorCount();
|
|
// review camera stop
|
ReviewCamera_CameraControl(CameraControlStop);
|
AlignCamera_CameraControl(CameraControlLive);
|
|
// send signal to plc
|
if (nResultCode==0)
|
{
|
SendResultToSignalControl(PCControlSendData_LoadingResult_CSOT, SIGNAL_SEND_RESULT_SUCCESS);
|
m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor::GlassLoading] Send Loading Success Signal!"));
|
}
|
else
|
{
|
SendResultToSignalControl(PCControlSendData_LoadingResult_CSOT, SIGNAL_SEND_RESULT_FAIL);
|
m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor::GlassLoading] Send Loading FAIL Signal!"));
|
}
|
|
// send cell data to review processorm_pDitGlass
|
CReviewProcessor* pReviewProcessor = m_pSP2P->ISP2P_GetReviewProcessor();
|
if(pReviewProcessor == NULL) return ;
|
pReviewProcessor->SetCellData(pGlassResult);
|
pReviewProcessor->SetReviewCount(0); // ¸®ºä Sequence No ÃʱâÈ.
|
|
// Process Status Update
|
if(pGlassResult)
|
{
|
g_pLog->DisplayMessage(_T("[SequenceProcess_CSOT] m_pGlassResult = %d"), pGlassResult);
|
|
m_pSP2P->ISP2P_UpdateProcessStatus(GetProcessStatus(), pGlassResult);
|
m_pSP2P->ISP2P_UpdateReviewResult(0, pGlassResult);
|
|
const SDefectFilter *pDefectFilter = m_pSP2P->ISP2P_GetDefectFilter();
|
m_pSP2P->ISP2P_UpdateDefectFilter(pDefectFilter);
|
}
|
|
SendSignalToSignalControl(PCControlSendSignalIndex_Seq, PCControlSend_LoadingComplete_CSOT);
|
m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor::GlassLoading] Send Loading Complete Signal!"));
|
|
m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor::OUT] Loading!"));
|
|
//pDitSharedGlassRaw->SetReviewStart();
|
|
if(pRecipeinfo->m_bDefocusUse){
|
m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor::GlassLoading] Set Defocus Value : [%f]"),pRecipeinfo->m_dDefocusValue);
|
}
|
|
}
|
|
void CSequenceProcessor_CSOT::Process_AlignStart()
|
{
|
m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor::IN] AlignStart!"));
|
|
if (SendSignalToSignalControl(PCControlSendSignalIndex_Ack, PCControlSend_AlignStartAck_CSOT))
|
m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor::AlignStart] Send Align Start Ack!"));
|
Sleep(400);//¾ó¶óÀÎ ÇÁ·¹ÀÓ ¹®Á¦ µô·¹ÀÌ ÁÖ±â chm190602
|
|
// 1. get current glass result
|
CGlassResult* pGlassResult = m_pSP2P->ISP2P_GetCurrentGlassResult();
|
if (pGlassResult==NULL) { return; }
|
|
const CRsRcpAlignInfo* pRsRcpAlignInfo = m_pSP2P->ISP2P_Recipe_GetRsRcpAlignInfo();
|
if(pRsRcpAlignInfo == NULL) return;
|
|
// 2. get align camera control
|
CCameraControlAlign* pAlignCameraControl = m_pSP2P->ISP2P_GetAlignCameraControl();
|
|
// 3. align process
|
if(pRsRcpAlignInfo->m_bAlignSkipMode)
|
{
|
m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor::AlignStart] Align Skip Mode !!!!!!!"));
|
|
SendResultToSignalControl(PCControlSendData_AlignResult_CSOT, SIGNAL_SEND_RESULT_SUCCESS);
|
m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor::AlignStart] Send Align SUCCESS Data!"));
|
SendSignalToSignalControl(PCControlSendSignalIndex_Seq, PCControlSend_AlignComplete_CSOT);
|
m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor::AlignStart] Send Align Complete Signal!"));
|
}
|
else
|
{
|
// 190710 SJB Align Camera Disconnect Check, Align Step ÁøÇà Àü¿¡ È®ÀÎÇÑ´Ù.
|
if(pAlignCameraControl)
|
{
|
if(pAlignCameraControl->AlignCameraDisconnectCheck() == FALSE)
|
{
|
SendResultToSignalControl(PCControlSendData_AlignResult_CSOT, SIGNAL_SEND_RESULT_FAIL);
|
m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor::AlignStart] Algin Camera Disconnect!!!!"));
|
}
|
}
|
|
if (pGlassResult && pAlignCameraControl && pAlignCameraControl->AlignProcess())
|
{
|
m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor::AlignStart] Align Find Process Started!"));
|
}
|
else
|
{
|
// 4. send align fail signal to plc
|
SendResultToSignalControl(PCControlSendData_AlignResult_CSOT, SIGNAL_SEND_RESULT_FAIL);
|
m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor::AlignStart] Send Align Fail Data!"));
|
SendSignalToSignalControl(PCControlSendSignalIndex_Seq, PCControlSend_AlignComplete_CSOT);
|
m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor::AlignStart] Send Align Complete Signal!"));
|
}
|
}
|
|
ReviewCamera_CameraControl(CameraControlStart);
|
|
m_pSP2P->ISP2P_UpdateProcessStatus(GetProcessStatus(), pGlassResult);
|
|
m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor::OUT] AlignStart!"));
|
}
|
|
void CSequenceProcessor_CSOT::Process_ReadRawFile()
|
{
|
CDitGlassRawClient *pDitRawClient = CDitGlassRawClient::GetInstance();
|
|
pDitRawClient->SetReviewStart();
|
|
Sleep(1000);
|
|
m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor::IN] ReadRawFile!"));
|
|
if (SendSignalToSignalControl(PCControlSendSignalIndex_Ack, PCControlSend_ReadRawFileAck_CSOT))
|
m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor::ReadRawFile] Send Read Raw File Ack!"));
|
|
// get current glass result
|
CGlassResult* pGlassResult = m_pSP2P->ISP2P_GetCurrentGlassResult();
|
if (pGlassResult==NULL) return;
|
|
//°øÀ¯¸Þ¸ð¸® Ä¿¸àµå ¸®ºä ½ºÅ¸Æ®(±Û¶ó½º ·Îµù)
|
CDitGlassRawClient* pDitSharedGlassRaw = CDitGlassRawClient::GetInstance();
|
if(pDitSharedGlassRaw->isConnect() == FALSE) m_pSP2P->ISP2P_DisplayMessage(_T("[DitGlassRawClient] Shared Memory Connect Fail"));
|
|
if(!UpdateMemoryUserReflowPlanInfo(pDitSharedGlassRaw)) m_pSP2P->ISP2P_DisplayMessage(_T("[User,ReflowPlan Shared Memory] Update Fail!!"));
|
|
// read aoi result
|
CProcessTimer processTimer;
|
processTimer.Start();
|
if(ReadAOIMemory(pGlassResult)) // 190201 SJB, Read AOI Memory
|
{
|
processTimer.End();
|
m_pSP2P->ISP2P_DisplayMessage(_T("[ReadRawFile] AOI Result File Read Completed![%.3f ms]"), processTimer.GetDurationMilliSecond());
|
|
pGlassResult->m_bReadRawFile = TRUE;
|
CString strMessage = _T("");
|
strMessage.Format(_T("[Read Raw File] Total: %d [Crack: %d, Mask: %d, Pad: %d, Common: %d, Align: %d, Active: %d]"),
|
pGlassResult->GetDefectResultCount(), pGlassResult->GetCrackDefectResultCount(),
|
pGlassResult->GetMaskDefectResultCount(), pGlassResult->GetPadDefectResultCount(),
|
pGlassResult->GetCommonDefectResultCount(), pGlassResult->GetAlignDefectResultCount(),
|
pGlassResult->GetActiveDefectResultCount());
|
m_pSP2P->ISP2P_DisplayMessage(strMessage);
|
|
// calculate motion plan
|
int nTotalPlanCount = CalculatePlanData(pGlassResult);
|
m_pSP2P->ISP2P_DisplayMessage(_T("[Read Raw File] Review All Plan Total Count : %d"), nTotalPlanCount);
|
|
// send review ready
|
SendSignalToSignalControl(PCControlSendSignalIndex_Seq, PCControlSend_ReviewReady_CSOT);
|
m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor::ReadRawFile] Send Review Ready Signal!"));
|
}
|
else
|
{
|
processTimer.End();
|
m_pSP2P->ISP2P_DisplayMessage(_T("[ReadRawFile] AOI Result File Read Fail![%.3f ms]"), processTimer.GetDurationMilliSecond());
|
|
int nCurPlanIndex = 0;
|
CRsRcpReviewInfo* pRsRcpReviewInfo = m_pSP2P->ISP2P_Recipe_GetRsRcpReviewInfo();
|
if(pRsRcpReviewInfo)
|
{
|
CRcpPlanInfo *pPlanInfo = pRsRcpReviewInfo->GetRcpPlanInfo(nCurPlanIndex);
|
if (pPlanInfo)
|
{
|
if (pPlanInfo->m_nReviewType==CSOT_PlanUser)
|
{
|
// calculate motion plan
|
int nTotalPlanCount = CalculatePlanData(pGlassResult);
|
m_pSP2P->ISP2P_DisplayMessage(_T("[Read Raw File] Review All Plan Total Count : %d"), nTotalPlanCount);
|
|
// send review ready
|
SendSignalToSignalControl(PCControlSendSignalIndex_Seq, PCControlSend_ReviewReady_CSOT);
|
m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor::ReadRawFile] Send Review Ready Signal!"));
|
}
|
}
|
}
|
}
|
|
//// [2017:5:24]-[WEZASW] : Review Image Upload Dir »ý¼º.(FTPUploader¿¡¼ ÀÚµ¿ »èÁ¦ µÇ´õ¶óµµ ½ÇÁ¦ ¸®ºä½Ã »ý¼º)
|
//// '¹Ýº¹°Ë»ç'½Ã FTPUploader¿¡¼ ¾÷·Îµå ÈÄ »èÁ¦ ½ÃÁ¡°ú PCControl Glass Unloading ÈÄ Áï½Ã Loading½Ã Review¿¡¼ÀÇ ¾÷·Îµå °æ·Î(GlassID) »ý¼º ½ÃÁ¡ ¿À·ù
|
const CNetworkInfo *pNetworkInfo = m_pSP2P->ISP2P_System_GetNetworkInfo();
|
CString strPath = _T("");
|
//if(pNetworkInfo && pNetworkInfo->m_strUploadImagePath.IsEmpty() == FALSE)
|
//{
|
// strPath.Format(_T("%s\\%s"), pNetworkInfo->m_strUploadImagePath, *pGlassResult->GetJobID());// pGlassResult->GetGlassID() -> pGlassResult->GetJobID()
|
// CreateDirectory(strPath, NULL);
|
//}
|
|
CReviewProcessor* pReviewProcessor = m_pSP2P->ISP2P_GetReviewProcessor();
|
strPath = pReviewProcessor->GetUploadImagePath();
|
CFileFind Uploadfile;
|
CTime tmServerLoadingTime = CDitGlassRawClient::GetInstance()->GetGlassData()->m_tmGlassLoading;
|
strPath.Format(_T("%s\\%s_%04d%02d%02d%02d%02d%02d"), pNetworkInfo->m_strUploadImagePath,pGlassResult->m_strJobID,tmServerLoadingTime.GetYear(),tmServerLoadingTime.GetMonth(),tmServerLoadingTime.GetDay(),tmServerLoadingTime.GetHour(),tmServerLoadingTime.GetMinute(),tmServerLoadingTime.GetSecond());
|
|
//¾÷·Îµå Æú´õ°¡ ¾øÀ¸¸é Æú´õ »ý¼ºÈÄ ´Ù½Ã ¾÷·Îµå °æ·Î Set 20190917ÃÖÇü¸ñ
|
if(Uploadfile.FindFile(strPath)==FALSE)
|
{
|
CreateDirectory(strPath, NULL);
|
pReviewProcessor->SetUploadImagePath(strPath);
|
}
|
|
if(pGlassResult) m_pSP2P->ISP2P_UpdateProcessStatus(GetProcessStatus(), pGlassResult);
|
|
m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor::ReadRawFile_OUT] ReadRawFile!"));
|
}
|
|
void CSequenceProcessor_CSOT::Process_ReviewStart()
|
{
|
m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor::IN] ReviewStart!"));
|
|
if (SendSignalToSignalControl(PCControlSendSignalIndex_Ack, PCControlSend_ReviewStartAck_CSOT))
|
m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor::ReviewStart] Send Review Start Ack!"));
|
|
const CRsRcpAlignInfo* pRsRcpAlignInfo = m_pSP2P->ISP2P_Recipe_GetRsRcpAlignInfo();
|
if(pRsRcpAlignInfo == NULL) return;
|
|
CTotalPitchMeasure* pTotapPithMeasure = m_pSP2P->ISP2P_GetTotalPitchMeasure();
|
|
|
// 190708 SJB TotalPithchMeasure Start
|
//if(pRsRcpAlignInfo->m_bTotalPitchMeasure && pTotapPithMeasure)
|
//{
|
// ReviewCamera_CameraControl(CameraControlLive);
|
// Sleep(100);
|
|
// AFM_SetAFMTracking(TRUE);
|
|
// pTotapPithMeasure->Reset();
|
// if(pTotapPithMeasure->StartTotalPitchMeasure())
|
// {
|
// m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor] TotalPitchMeasure Result Success!"));
|
|
// CDitGlassRawClient *pDitRawClient = CDitGlassRawClient::GetInstance();
|
// if(pDitRawClient)
|
// {
|
// _grmCellData* pCellData = pDitRawClient->GetCellData(0);
|
// if(pCellData)
|
// {
|
// // pCellData->m_nTotalPitchData[0] = int(pTotapPithMeasure->GetTotalPitchBD() * 1000); // ÀåÃà, ÀÛ¾÷ÀÚ ±âÁØ À§ÂÊ
|
// // pCellData->m_nTotalPitchData[1] = int(pTotapPithMeasure->GetTotalPitchAC() * 1000); // ÀåÃà, ÀÛ¾÷ÀÚ ±âÁØ ¾Æ·¡ÂÊ
|
// // pCellData->m_nTotalPitchData[2] = int(pTotapPithMeasure->GetTotalPitchAB() * 1000); // ´ÜÃà, ÀÛ¾÷ÀÚ ±âÁØ ¿ÞÂÊ
|
// // pCellData->m_nTotalPitchData[3] = int(pTotapPithMeasure->GetTotalPitchCD() * 1000); // ´ÜÃà, ÀÛ¾÷ÀÚ ±âÁØ ¿À¸¥ÂÊ
|
// }
|
// }
|
// }
|
// else
|
// {
|
// m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor] TotalPitchMeasure Result Fail!"));
|
|
// // 190711 SJB, TotalPitchMeasure Fail½Ã¿¡ ¹Ù·Î Motor·Î ¸í·ÉÀ» ³¯¸®±â º¸´Ù´Â Motion Enable ½ÅÈ£¸¦ È®ÀÎÇÏÀÚ
|
//
|
// if(!pTotapPithMeasure->GetMotorEnable())
|
// {
|
// SendResultToSignalControl(PCControlSendData_ReviewResult_CSOT, SIGNAL_SEND_RESULT_FAIL);
|
// m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor] MotionEnable Check Fail!!! Review Fail Signal"));
|
// }
|
// }
|
|
// ReviewCamera_CameraControl(CameraControlStop);
|
// Sleep(200);
|
//}
|
|
// review camera Start
|
ReviewCamera_CameraControl(CameraControlStart);
|
|
CGlassResult *pGlassResult = m_pSP2P->ISP2P_GetCurrentGlassResult();
|
if (pGlassResult==NULL) return;
|
|
if(FirstReviewPlanStart() <= 0)
|
{
|
SendResultToSignalControl(PCControlSendData_ReviewResult_CSOT, SIGNAL_SEND_RESULT_SUCCESS);
|
SendSignalToSignalControl(PCControlSendSignalIndex_Seq, PCControlSend_ReviewComplete_CSOT);
|
m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor::ReviewStart] Send Review Success Signal!"));
|
}
|
|
// Process Status Update
|
if(pGlassResult)
|
{
|
m_pSP2P->ISP2P_UpdateProcessStatus(GetProcessStatus(), pGlassResult);
|
}
|
|
m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor::OUT] ReviewStart!"));
|
}
|
|
void CSequenceProcessor_CSOT::Process_ReviewEnd()
|
{
|
m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor::IN] ReviewEnd!"));
|
|
CDitGlassRawClient* m_pDitGlassRaw = CDitGlassRawClient::GetInstance();
|
|
if(m_pDitGlassRaw->isConnect()!=FALSE) m_pDitGlassRaw->SetReviewEnd();
|
|
SendDVDataToSignalControl();//
|
|
if (SendSignalToSignalControl(PCControlSendSignalIndex_Ack, PCControlSend_ReviewEndAck_CSOT))
|
m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor::ReviewEnd] Send Review End Ack!"));
|
|
|
CGlassResult* pGlassResult = m_pSP2P->ISP2P_GetCurrentGlassResult();
|
if (pGlassResult==NULL) return;
|
|
// review camera stop
|
ReviewCamera_CameraControl(CameraControlStop);
|
|
SetMotionStop();
|
|
AFM_SetAFMTracking(FALSE);
|
|
// °á°úÆÄÀÏ »ý¼ºÀº Review¿¡¼ °ü¿© ¾ÈÇÔ
|
if(m_pDitGlassRaw->isConnect()==FALSE) WriteRawData(pGlassResult);
|
|
//µðÆ÷Ä¿½º ¾Ë¶÷ send 20190819ÃÖÇü¸ñ
|
if(pGlassResult->m_nDeFocusCount >0)
|
{
|
SendSignalToSignalControl(PCControlSendSignalIndex_State,PCControlSend_Defoucs,1000);
|
|
CTime time =CTime::GetCurrentTime();
|
|
CString strTime = _T("");
|
strTime.Format(_T("%04d-%02d-%02d %02d:%02d:%02d"), time.GetYear(), time.GetMonth(), time.GetDay(), time.GetHour(), time.GetMinute(), time.GetSecond());
|
|
CDlgDefocusList::GetInstance()->SetDefocusTotalCount(pGlassResult->m_nDeFocusCount);//ÅäÅ» Ä«¿îÆ® Add
|
CDlgDefocusList::GetInstance()->SetDefocusData(strTime,pGlassResult->m_strGlassID,pGlassResult->m_nDeFocusCount);//ui Ãß°¡ÈÄ °»½Å
|
|
}
|
|
SendSignalToSignalControl(PCControlSendSignalIndex_Seq, PCControlSend_ResultDataComplete_CSOT);
|
m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor::ReviewEnd] Send ResultData Complete Signal!"));
|
|
//5. PCControl ½ÅÈ£ ¾÷µ¥ÀÌÆ®
|
if(pGlassResult)
|
{
|
m_pSP2P->ISP2P_UpdateProcessStatus(GetProcessStatus(), pGlassResult);
|
g_pLog->DisplayMessage(_T("PCControl Update Signal"));
|
}
|
|
m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor::OUT] ReviewEnd!"));
|
}
|
|
BOOL CSequenceProcessor_CSOT::ReadTransferDataFromSignalControl(STransferData* pTransferData)//cmark
|
{
|
if (pTransferData==NULL) return FALSE;
|
pTransferData->Reset();
|
|
CSignalControl* pSignalControl = m_pSP2P->ISP2P_GetSignalControl();
|
if (pSignalControl==NULL) return FALSE;
|
if (pSignalControl->IsConnected() == FALSE) return FALSE;
|
|
const CSignalControlInfo* pSignalInfo = m_pSP2P->ISP2P_System_GetPCControlInfo();
|
if (pSignalInfo==NULL) return FALSE;
|
|
int nPCControlReadDataCount = pSignalInfo->GetReadDataAddressCount();
|
|
// [2017:1:9]-[WEZASW] : PCControl GlassData Ç׸ñ ÀçÁ¤ÀÇ.
|
if(pSignalInfo->GetUseContinuousReadAddress())
|
{
|
CString strReadAddress = _T("");
|
int nReadTotalSize = 0;
|
for(int i=0; i<nPCControlReadDataCount; i++)
|
{
|
const SSignalSettingData *pInfo = pSignalInfo->GetReadDataAddress(i);
|
if (pInfo==NULL) continue;
|
|
if (i==0) strReadAddress = pInfo->strAddr;
|
nReadTotalSize += pInfo->nSize;
|
}
|
|
CString strData = _T("");
|
if (pSignalControl->ReadData(strReadAddress, nReadTotalSize, strData))
|
{
|
m_pSP2P->ISP2P_DisplayMessage(_T("[ReadTransferData] Addr: %s, Size: %d, Data: %s"), strReadAddress, nReadTotalSize, strData);
|
}
|
else
|
{
|
m_pSP2P->ISP2P_DisplayMessage(_T("[ReadTransferData] Read Fail! Addr: %s"), strReadAddress);
|
}
|
|
int nReadSize = 0;
|
int nData = 0;
|
CString strTemp = strData;
|
for(int i=0; i<nPCControlReadDataCount; i++)
|
{
|
const SSignalSettingData *pInfo = pSignalInfo->GetReadDataAddress(i);
|
if (pInfo==NULL) continue;
|
|
nReadSize = pInfo->nSize;
|
if(i == nPCControlReadDataCount - 1)
|
{
|
strData = strTemp;
|
}
|
else
|
{
|
strData = strTemp.Left(nReadSize*2);
|
strTemp = strTemp.Mid(nReadSize*2);
|
}
|
|
switch(i)
|
{
|
case GLASS_DATA_PROD_ID_CSOT:
|
pTransferData->strLotID = strData.TrimRight(_T(" "));
|
break;
|
|
case GLASS_DATA_OPER_ID_CSOT:
|
pTransferData->strOperID = strData.TrimRight(_T(" "));
|
break;
|
|
case GLASS_DATA_LOT_ID_CSOT:
|
pTransferData->strLotID = strData.TrimRight(_T(" "));
|
break;
|
|
case GLASS_DATA_PPID_CSOT:
|
strData.TrimRight(_T(" "));
|
if (strData.Compare(_T("")) != 0)
|
{
|
nData = strData.GetAt(1);
|
nData <<= 8;
|
nData |= strData.GetAt(0);
|
pTransferData->strPPID.Format(_T("%d"), nData);
|
}
|
else
|
pTransferData->strPPID = strData.TrimRight(_T(" "));
|
break;
|
|
case GLASS_DATA_PPID_RECIPE_CSOT:
|
pTransferData->strPPID_RC = strData.TrimRight(_T(""));;
|
//strData.TrimRight(_T(" "));
|
break;
|
|
case GLASS_DATA_JOB_TYPE_CSOT:
|
pTransferData->strJobType = strData.TrimRight(_T(" "));
|
break;
|
|
case GLASS_DATA_JOB_ID_CSOT:
|
pTransferData->strJobID = strData.TrimRight(_T(" "));
|
break;
|
|
case GLASS_DATA_LOT_SEQUENCE_NUMBER_CSOT:
|
break;
|
case GLASS_DATA_SLOT_SEQUENCE_NUMBER_CSOT:
|
break;
|
case GLASS_DATA_PROPERTY_CODE_CSOT:
|
break;
|
case GLASS_DATA_JOB_JUDGE_CODE_CSOT:
|
break;
|
case GLASS_DATA_JOB_GRADE_CODE_CSOT:
|
break;
|
case GLASS_DATA_SUBSTRATE_TYPE_CSOT:
|
break;
|
|
case GLASS_DATA_PROCESSING_FLAG_CSOT:
|
break;
|
case GLASS_DATA_INSPECTION_FLAG_CSOT:
|
break;
|
case GLASS_DATA_SKIP_FLAG_CSOT:
|
break;
|
case GLASS_DATA_JOB_SIZE_CSOT:
|
break;
|
case GLASS_DATA_GLASS_THICKNESS_CSOT:
|
break;
|
case GLASS_DATA_JOB_ANGLE_CSOT:
|
break;
|
case GLASS_DATA_JOB_FLIP_CSOT:
|
break;
|
case GLASS_DATA_CUTTING_GLASS_TYPE_CSOT:
|
break;
|
case GLASS_DATA_PROCESSING_COUNT_CSOT:
|
break;
|
case GLASS_DATA_INSPECTION_JUDGE_DATA_CSOT:
|
break;
|
case GLASS_DATA_PAIR_JOB_ID_CSOT:
|
break;
|
case GLASS_DATA_PAIR_FLAG_CSOT:
|
break;
|
case GLASS_DATA_OPTION_VALUE_CSOT:
|
break;
|
case GLASS_DATA_RESERVED_CSOT:
|
break;
|
case GLASS_DATA_GLASS_SCAN_SCHEDULE_CSOT:
|
pTransferData->strGlassScanSchedule = strData.TrimRight(_T(" "));
|
break;
|
|
}
|
}
|
}
|
else
|
{
|
CString strReadAddress = _T("");
|
CString strReadData = _T("");
|
int nReadSize = 0;
|
int readData = 0;
|
int nData = 0;
|
|
char chReadData[2048] = {0};
|
|
for(int i=0; i<nPCControlReadDataCount; i++)
|
{
|
const SSignalSettingData *pInfo = pSignalInfo->GetReadDataAddress(i);
|
if (pInfo==NULL) continue;
|
|
strReadAddress = pInfo->strAddr;
|
//nReadSize = pInfo->nSize*2;
|
nReadSize = pInfo->nSize;
|
memset(chReadData, 0, sizeof(chReadData));
|
readData = 0;
|
switch(i)
|
{
|
case GLASS_DATA_PROD_ID_CSOT:
|
pSignalControl->ReadData(strReadAddress, nReadSize, chReadData);
|
memcpy(&readData, chReadData, 2);
|
pTransferData->strProdID.Format(_T("%d"), readData);
|
strReadData = pTransferData->strProdID;
|
break;
|
//pSignalControl->ReadData(strReadAddress, nReadSize, strReadData);
|
//pTransferData->strProdID = strReadData.TrimRight(_T(" "));
|
//strReadData = pTransferData->strProdID;
|
//break;
|
|
case GLASS_DATA_OPER_ID_CSOT:
|
pSignalControl->ReadData(strReadAddress, nReadSize, chReadData);
|
memcpy(&readData, chReadData, 2);
|
pTransferData->strOperID.Format(_T("%d"), readData);
|
strReadData = pTransferData->strOperID;
|
break;
|
|
|
case GLASS_DATA_LOT_ID_CSOT:
|
pSignalControl->ReadData(strReadAddress, nReadSize, chReadData);
|
memcpy(&readData, chReadData, 2);
|
pTransferData->strLotID.Format(_T("%d"), readData);
|
strReadData = pTransferData->strLotID;
|
break;
|
|
|
case GLASS_DATA_PPID_CSOT:
|
pSignalControl->ReadData(strReadAddress, nReadSize, strReadData);
|
pTransferData->strPPID = strReadData.TrimRight(_T(" "));
|
strReadData = pTransferData->strPPID;
|
break;
|
|
|
case GLASS_DATA_PPID_RECIPE_CSOT:
|
pSignalControl->ReadData(strReadAddress, nReadSize, strReadData);
|
pTransferData->strPPID_RC = strReadData;
|
pTransferData->strPPID_RC = strReadData.Left(12);
|
strReadData = pTransferData->strPPID_RC;
|
break;
|
|
|
case GLASS_DATA_JOB_TYPE_CSOT:
|
pSignalControl->ReadData(strReadAddress, nReadSize, strReadData);
|
pTransferData->strJobType = strReadData.TrimRight(_T(" "));
|
strReadData = pTransferData->strJobType;
|
break;
|
|
|
case GLASS_DATA_JOB_ID_CSOT: //cmark
|
pSignalControl->ReadData(strReadAddress, nReadSize, strReadData);
|
pTransferData->strJobID = strReadData.TrimRight(_T(" "));
|
strReadData = pTransferData->strJobID;
|
|
pTransferData->strGlassLastName = strReadData.Right(1);
|
|
break;
|
//Á¦¾î¿¡¼ ¸ø¹Þ¾Æ¿Í¼ ÀÌ°Ô 0À¸·Î 󸮵ȴ٠¿ØÁö¸ð¸£°ÙÁö¸¸ GLASSID ´ë½Å ÀÌ°ªÀ» ³Ö¾îÁֱ⠶§¹®¿¡ RAW ÆÄÀÏ¿¡¼ Á¦¾î¿¡¼ ¸ø¹Þ¾Æ¿À¸é default ÀÎ HPANEL12345 À¸·Î ÇØÁִµ¥ ±×°Ô¾Æ´Ñ
|
//0ÀÌ µé¾î¿ÈÀ¸·Î RAW ÆÄÀÏ À̸§À» 0À¸·Î ó¸®ÇÏ°í ¸øÀÐ¾î ¿Â´Ù.
|
|
case GLASS_DATA_LOT_SEQUENCE_NUMBER_CSOT:
|
pSignalControl->ReadData(strReadAddress, nReadSize, chReadData);
|
memcpy(&readData, chReadData, 2);
|
pTransferData->strLotSeqNum.Format(_T("%d"), readData);
|
strReadData = pTransferData->strLotSeqNum;
|
break;
|
|
case GLASS_DATA_SLOT_SEQUENCE_NUMBER_CSOT:
|
pSignalControl->ReadData(strReadAddress, nReadSize, chReadData);
|
memcpy(&readData, chReadData, 2);
|
pTransferData->strSlotSeqNum.Format(_T("%d"), readData);
|
strReadData = pTransferData->strSlotSeqNum;
|
break;
|
|
case GLASS_DATA_PROPERTY_CODE_CSOT:
|
pSignalControl->ReadData(strReadAddress, nReadSize, chReadData);
|
memcpy(&readData, chReadData, nReadSize);
|
pTransferData->strPropertyCode.Format(_T("%d"), readData);
|
strReadData = pTransferData->strPropertyCode;
|
break;
|
|
case GLASS_DATA_JOB_JUDGE_CODE_CSOT:
|
{
|
pSignalControl->ReadData(strReadAddress, nReadSize, strReadData);
|
pTransferData->strJobJudgeCode.Format(_T("%d"), strReadData[0]);
|
strReadData = pTransferData->strJobJudgeCode;
|
}
|
|
break;
|
|
case GLASS_DATA_JOB_GRADE_CODE_CSOT:
|
{
|
pSignalControl->ReadData(strReadAddress, nReadSize, strReadData);
|
pTransferData->strJobGradeCode.Format(_T("%d"), strReadData[0]);
|
strReadData = pTransferData->strJobGradeCode;
|
}
|
|
break;
|
|
case GLASS_DATA_SUBSTRATE_TYPE_CSOT:
|
pSignalControl->ReadData(strReadAddress, nReadSize, chReadData);
|
memcpy(&readData, chReadData, 2);
|
pTransferData->strSubstrateType.Format(_T("%d"), readData);
|
strReadData = pTransferData->strSubstrateType;
|
break;
|
|
case GLASS_DATA_PROCESSING_FLAG_CSOT:
|
pSignalControl->ReadData(strReadAddress, nReadSize, chReadData);
|
memcpy(&readData, chReadData, 2);
|
pTransferData->strProcessingFlag.Format(_T("%d"), readData);
|
strReadData = pTransferData->strProcessingFlag;
|
break;
|
|
case GLASS_DATA_INSPECTION_FLAG_CSOT:
|
pSignalControl->ReadData(strReadAddress, nReadSize, chReadData);
|
memcpy(&readData, chReadData, 2);
|
pTransferData->strInspectionFlag.Format(_T("%d"), readData);
|
strReadData = pTransferData->strInspectionFlag;
|
break;
|
|
case GLASS_DATA_SKIP_FLAG_CSOT:
|
pSignalControl->ReadData(strReadAddress, nReadSize, chReadData);
|
memcpy(&readData, chReadData, 2);
|
pTransferData->strSkipFlag.Format(_T("%d"), readData);
|
strReadData = pTransferData->strSkipFlag;
|
break;
|
|
case GLASS_DATA_JOB_SIZE_CSOT:
|
pSignalControl->ReadData(strReadAddress, nReadSize, chReadData);
|
memcpy(&readData, chReadData, 2);
|
pTransferData->strJobSize.Format(_T("%d"), readData);
|
strReadData = pTransferData->strJobSize;
|
break;
|
|
case GLASS_DATA_GLASS_THICKNESS_CSOT:
|
pSignalControl->ReadData(strReadAddress, nReadSize, chReadData);
|
memcpy(&readData, chReadData, 2);
|
pTransferData->strGlassThickness.Format(_T("%d"), readData);
|
strReadData = pTransferData->strGlassThickness;
|
break;
|
|
case GLASS_DATA_JOB_ANGLE_CSOT:
|
pSignalControl->ReadData(strReadAddress, nReadSize, chReadData);
|
memcpy(&readData, chReadData, 2);
|
pTransferData->strJobAngle.Format(_T("%d"), readData);
|
strReadData = pTransferData->strJobAngle;
|
break;
|
|
case GLASS_DATA_JOB_FLIP_CSOT:
|
pSignalControl->ReadData(strReadAddress, nReadSize, chReadData);
|
memcpy(&readData, chReadData, 2);
|
pTransferData->strJobFlip.Format(_T("%d"), readData);
|
strReadData = pTransferData->strJobFlip;
|
break;
|
|
case GLASS_DATA_CUTTING_GLASS_TYPE_CSOT:
|
pSignalControl->ReadData(strReadAddress, nReadSize, chReadData);
|
memcpy(&readData, chReadData, 2);
|
pTransferData->strCuttingGlassType.Format(_T("%d"), readData);
|
strReadData = pTransferData->strCuttingGlassType;
|
break;
|
|
case GLASS_DATA_PROCESSING_COUNT_CSOT:
|
pSignalControl->ReadData(strReadAddress, nReadSize, chReadData);
|
memcpy(&readData, chReadData, 2);
|
pTransferData->strProcessingCount.Format(_T("%d"), readData);
|
strReadData = pTransferData->strProcessingCount;
|
break;
|
|
case GLASS_DATA_INSPECTION_JUDGE_DATA_CSOT:
|
pSignalControl->ReadData(strReadAddress, nReadSize, chReadData);
|
memcpy(&readData, chReadData, 2);
|
pTransferData->strInspectionJudgeData.Format(_T("%d"), readData);
|
strReadData = pTransferData->strInspectionJudgeData;
|
break;
|
|
case GLASS_DATA_PAIR_JOB_ID_CSOT:
|
pSignalControl->ReadData(strReadAddress, nReadSize, strReadData);
|
pTransferData->strPairJobID = strReadData.TrimRight(_T(" "));
|
strReadData = pTransferData->strPairJobID;
|
break;
|
|
case GLASS_DATA_PAIR_FLAG_CSOT:
|
pSignalControl->ReadData(strReadAddress, nReadSize, chReadData);
|
memcpy(&readData, chReadData, 2);
|
pTransferData->strPairFlag.Format(_T("%d"), readData);
|
strReadData = pTransferData->strPairFlag;
|
break;
|
case GLASS_DATA_OPTION_VALUE_CSOT:
|
pSignalControl->ReadData(strReadAddress, nReadSize, strReadData);
|
pTransferData->strOptionValue = strReadData.TrimRight(_T(" "));
|
strReadData = pTransferData->strOptionValue;
|
break;
|
case GLASS_DATA_RESERVED_CSOT:
|
pSignalControl->ReadData(strReadAddress, nReadSize, strReadData);
|
pTransferData->strReserved = strReadData.TrimRight(_T(" "));
|
strReadData = pTransferData->strReserved;
|
break;
|
|
case GLASS_DATA_GLASS_SCAN_SCHEDULE_CSOT: // ºÐÆÇ Á¤º¸ cmark
|
pSignalControl->ReadData(strReadAddress, nReadSize, strReadData);
|
pTransferData->strGlassScanSchedule = strReadData.TrimRight(_T(" "));
|
|
if(pTransferData->strGlassScanSchedule==_T("L")){
|
pTransferData->strGlassScanSchedule=(_T("0"));
|
}
|
else if(pTransferData->strGlassScanSchedule==_T("R")){
|
pTransferData->strGlassScanSchedule=(_T("1"));
|
}
|
else{
|
pTransferData->strGlassScanSchedule=(_T("0"));
|
}
|
strReadData = pTransferData->strGlassScanSchedule;
|
break;
|
}
|
m_pSP2P->ISP2P_DisplayMessage(_T("[ReadTransferData] Name: %s, Addr: %s, Size: %d, Data: %s"), pInfo->strName, strReadAddress, nReadSize, strReadData);
|
}
|
}
|
|
return TRUE;
|
}
|
|
void CSequenceProcessor_CSOT::UpdateGlassResultFromTransferData(CGlassResult *pGlassResult, STransferData* pTransferData)
|
{
|
if (pGlassResult==NULL || pTransferData==NULL) return;
|
|
// [2017:1:9]-[WEZASW] : PCControl GlassData Ç׸ñ ÀçÁ¤ÀÇ
|
// transfer data is not exist
|
if (pTransferData->strLotID.GetLength()<1)
|
{
|
pTransferData->strLotID = _T("LOTID");
|
}
|
if (pTransferData->strJobID.GetLength()<1)
|
{
|
pTransferData->strJobID = _T("HPANELID");
|
}
|
if (pTransferData->strOperID.GetLength()<1)
|
{
|
pTransferData->strOperID = _T("12345");
|
}
|
if (pTransferData->strGlassCode.GetLength()<1)
|
{
|
pTransferData->strGlassCode = _T("12");
|
}
|
if (pTransferData->strPPID_RC.GetLength()<1)
|
{
|
pTransferData->strPPID_RC = _T("Default");
|
}
|
if (pTransferData->strGlassLastName.GetLength()<1)
|
{
|
pTransferData->strGlassLastName = _T("A");
|
}
|
|
// update transfer data to glass result
|
pGlassResult->m_strGlassLastName = pTransferData->strGlassLastName;
|
pGlassResult->m_strGlassID = pTransferData->strGlassID;
|
pGlassResult->m_strGlassCode = pTransferData->strGlassCode;
|
pGlassResult->m_strMode = pTransferData->strMode;
|
pGlassResult->m_strGlassType = pTransferData->strGlassType;
|
pGlassResult->m_strDummyType = pTransferData->strDummyType;
|
pGlassResult->m_strProdID = pTransferData->strProdID;
|
pGlassResult->m_strOperID = pTransferData->strOperID;
|
pGlassResult->m_strLotID = pTransferData->strLotID;
|
pGlassResult->m_strPPID = pTransferData->strPPID;
|
pGlassResult->m_strPPID_RC = pTransferData->strPPID_RC;
|
pGlassResult->m_strJobType = pTransferData->strJobType;
|
pGlassResult->m_strJobID = pTransferData->strJobID;
|
pGlassResult->m_strLotSeqNum = pTransferData->strLotSeqNum;
|
pGlassResult->m_strSlotSeqNum = pTransferData->strSlotSeqNum;
|
pGlassResult->m_strPropertyCode = pTransferData->strPropertyCode;
|
pGlassResult->m_strJobJudgeCode = pTransferData->strJobJudgeCode;
|
pGlassResult->m_strJobGradeCode = pTransferData->strJobGradeCode;
|
pGlassResult->m_strSubstrateType = pTransferData->strSubstrateType;
|
pGlassResult->m_strProcessingFlag = pTransferData->strProcessingFlag;
|
pGlassResult->m_strInspectionFlag = pTransferData->strInspectionFlag;
|
pGlassResult->m_strSkipFlag = pTransferData->strSkipFlag;
|
pGlassResult->m_strJobSize = pTransferData->strJobSize;
|
pGlassResult->m_strGlassThickness = pTransferData->strGlassThickness;
|
pGlassResult->m_strJobAngle = pTransferData->strJobAngle;
|
pGlassResult->m_strJobFlip = pTransferData->strJobFlip;
|
pGlassResult->m_strCuttingGlassType = pTransferData->strCuttingGlassType;
|
pGlassResult->m_strProcessingCount = pTransferData->strProcessingCount;
|
pGlassResult->m_strInspectionJudgeData = pTransferData->strInspectionJudgeData;
|
pGlassResult->m_strPairJobID = pTransferData->strPairJobID;
|
pGlassResult->m_strPairFlag = pTransferData->strPairFlag;
|
pGlassResult->m_strOptionValue = pTransferData->strOptionValue;
|
pGlassResult->m_strReserved = pTransferData->strReserved;
|
pGlassResult->strGlassScanSchedule = pTransferData->strGlassScanSchedule;//ºÐÆÇ Á¤º¸ cmark
|
|
|
}
|
|
void CSequenceProcessor_CSOT::CreateResultDirectory(const CString& strGlassID, const CString& strDate)
|
{
|
if (m_pSP2P==NULL) return;
|
|
const CNetworkInfo *pNetworkInfo = m_pSP2P->ISP2P_System_GetNetworkInfo();
|
if(pNetworkInfo == NULL) return;
|
|
CString strPath = _T("");
|
|
if (strDate.GetLength()>0)
|
{
|
// raw path
|
if(pNetworkInfo->m_strLocalRawPath.IsEmpty() == FALSE && strGlassID.IsEmpty() == FALSE)
|
{
|
strPath.Format(_T("%s\\%s"), pNetworkInfo->m_strLocalRawPath, strDate);
|
CreateDirectory(strPath, NULL);
|
}
|
|
// raw backup path
|
if(pNetworkInfo->m_strLocalRawPath.IsEmpty() == FALSE && strGlassID.IsEmpty() == FALSE)
|
{
|
strPath.Format(_T("%sBackup\\%s"), pNetworkInfo->m_strLocalRawPath, strDate);
|
CreateDirectory(strPath, NULL);
|
}
|
|
// image path
|
if(pNetworkInfo->m_strLocalImagePath.IsEmpty() == FALSE && strGlassID.IsEmpty() == FALSE)
|
{
|
strPath.Format(_T("%s\\%s"), pNetworkInfo->m_strLocalImagePath, strDate);
|
CreateDirectory(strPath, NULL);
|
}
|
}
|
else
|
{
|
// image path
|
if(pNetworkInfo->m_strLocalImagePath.IsEmpty() == FALSE && strGlassID.IsEmpty() == FALSE)
|
{
|
strPath.Format(_T("%s\\%s"), pNetworkInfo->m_strLocalImagePath, strGlassID);
|
CreateDirectory(strPath, NULL);
|
}
|
}
|
|
if(pNetworkInfo->m_strAlignImagePath.IsEmpty() == FALSE && strGlassID.IsEmpty() == FALSE)
|
{
|
strPath.Format(_T("%s\\%s"),pNetworkInfo->m_strAlignImagePath, strGlassID);
|
CreateDirectory(strPath, NULL);
|
}
|
}
|
|
|
|
|
void CSequenceProcessor_CSOT::SetSaveImageBasePathToReviewProcessor(const CString& strGlassID, const CString& strResultDate)
|
{
|
const CNetworkInfo *pNetworkInfo = m_pSP2P->ISP2P_System_GetNetworkInfo();
|
if(pNetworkInfo == NULL) return;
|
|
CReviewProcessor* pReviewProcessor = m_pSP2P->ISP2P_GetReviewProcessor();
|
if(pReviewProcessor == NULL) return;
|
|
CString strPath = _T("");
|
if(pNetworkInfo->m_strLocalImagePath.IsEmpty() == FALSE && strGlassID.IsEmpty() == FALSE)
|
{
|
CTime snapTime = CTime::GetCurrentTime();
|
CString strSnapTime = _T("");
|
strSnapTime.Format(_T("_%04d%02d%02d%02d%02d%02d"), snapTime.GetYear(), snapTime.GetMonth(), snapTime.GetDay(),
|
snapTime.GetHour(), snapTime.GetMinute(), snapTime.GetSecond()); // snap_time
|
|
// Local
|
if (strResultDate.GetLength()>0)
|
{
|
strPath.Format(_T("%s\\%s\\%s"), pNetworkInfo->m_strLocalImagePath, strResultDate, strGlassID + strSnapTime);
|
}
|
else
|
{
|
strPath.Format(_T("%s\\%s"), pNetworkInfo->m_strLocalImagePath, strGlassID + strSnapTime);
|
}
|
|
CreateDirectory(strPath, NULL);
|
pReviewProcessor->SetSaveImageBasePath(strPath);
|
|
|
CTime tmServerLoadingTime = CDitGlassRawClient::GetInstance()->GetGlassData()->m_tmGlassLoading;
|
|
//¾÷·Îµå Æú´õ ¸¸µå´Â°÷
|
// Upload
|
// strPath.Format(_T("%s\\%s"), pNetworkInfo->m_strUploadImagePath, strGlassID);
|
|
strPath.Format(_T("%s\\%s_%04d%02d%02d%02d%02d%02d"), pNetworkInfo->m_strUploadImagePath, strGlassID,tmServerLoadingTime.GetYear(),tmServerLoadingTime.GetMonth(),tmServerLoadingTime.GetDay(),tmServerLoadingTime.GetHour(),tmServerLoadingTime.GetMinute(),tmServerLoadingTime.GetSecond());
|
CreateDirectory(strPath, NULL);
|
pReviewProcessor->SetUploadImagePath(strPath);
|
|
}
|
}
|
|
void CSequenceProcessor_CSOT::SetSaveImageBasePathToAlignCameraControl(const CString& strGlassID)
|
{
|
const CNetworkInfo *pNetworkInfo = m_pSP2P->ISP2P_System_GetNetworkInfo();
|
if(pNetworkInfo == NULL) return;
|
|
CCameraControlAlign* pAlignCameraControl = m_pSP2P->ISP2P_GetAlignCameraControl();
|
if(pAlignCameraControl == NULL) return;
|
|
CString strPath = _T("");
|
if(pNetworkInfo->m_strAlignImagePath.IsEmpty() == FALSE && strGlassID.IsEmpty() == FALSE)
|
{
|
strPath.Format(_T("%s\\%s"), pNetworkInfo->m_strAlignImagePath, strGlassID);
|
pAlignCameraControl->SetSaveImageBasePath(strPath);
|
}
|
}
|
|
BOOL CSequenceProcessor_CSOT::ReadRecipeDataFromRecipeFile(const CString& strPPID_RC, CString& strRecipeName)// const CString& strPPID, CString& strRecipeName
|
{
|
CRsRecipeManager *pRsRecipeManager = m_pSP2P->ISP2P_Recipe_GetRsRecipeManager();
|
if(pRsRecipeManager == NULL) { return FALSE; }
|
pRsRecipeManager->SetRecipeReadStatus(RCP_READ_STATUS_NONE);
|
|
strRecipeName = _T("");
|
|
// find recipe file
|
if(FindRecipeFileName(strPPID_RC, strRecipeName) == FALSE)
|
{
|
strRecipeName.Format(_T("Default"));
|
}
|
|
// read recipe file
|
if(pRsRecipeManager->ReadRecipeFile(strRecipeName) == FALSE)
|
{
|
pRsRecipeManager->SetRecipeReadStatus(RCP_READ_STATUS_FAIL);
|
return FALSE;
|
}
|
|
pRsRecipeManager->SetRecipeReadStatus(RCP_READ_STATUS_SUCCESS);
|
|
return TRUE;
|
}
|
|
BOOL CSequenceProcessor_CSOT::FindRecipeFileName(const CString& strPPID_RC, CString& strRecipeName/*const CString& strPPID, CString& strRecipeName*/)
|
{
|
BOOL bRet = FALSE, bFind;
|
CFileFind finder;
|
CString strSearchPath;
|
|
//if(strPPID.IsEmpty() == TRUE) return bRet;
|
if(strPPID_RC.IsEmpty() == TRUE) return bRet;
|
|
CGlassResult* pGlassResult = m_pSP2P->ISP2P_GetCurrentGlassResult();
|
if(pGlassResult == NULL) return FALSE;
|
|
const CString* strStepID = pGlassResult->GetStepID();
|
strSearchPath.Format(_T("%s\\%s.rcp"), _REVIEW_RECIPE_PATH_, strPPID_RC);
|
|
bFind = finder.FindFile(strSearchPath);
|
|
while(bFind)
|
{
|
bFind = finder.FindNextFile();
|
|
if(finder.IsDots()) continue;
|
if(finder.IsDirectory()) continue;
|
|
strRecipeName = finder.GetFileTitle();
|
bRet = TRUE;
|
break;
|
}
|
|
finder.Close();
|
|
return bRet;
|
}
|
|
BOOL CSequenceProcessor_CSOT::ApplyRecipeDataToGlassResult(CGlassResult *pGlassResult)
|
{
|
if(pGlassResult == NULL) return FALSE;
|
|
// ·¹½ÃÇÇ ¼³Á¤
|
const CRsRcpReviewInfo* pRsRcpReviewInfo = m_pSP2P->ISP2P_Recipe_GetRsRcpReviewInfo();
|
if (pRsRcpReviewInfo==NULL) return FALSE;
|
|
// system info
|
const CSystemInfo* pSystemInfo = m_pSP2P->ISP2P_System_GetSystemInfo();
|
|
// ±Û¶ó½º Á¤º¸
|
STransferData* pTransferData = m_pSP2P->ISP2P_GetCurrentTransferData();
|
if (pTransferData==NULL) return FALSE;
|
int nGlassTypeInfoIndex = 0;
|
{
|
nGlassTypeInfoIndex = pRsRcpReviewInfo->m_nGlassTypeIdx;
|
if(_ttoi(pTransferData->strGlassScanSchedule) == 1)
|
{
|
nGlassTypeInfoIndex = pRsRcpReviewInfo->m_nGlassTypeIdx + 1;
|
}
|
}
|
|
const CGlassTypeInfo* pGlassTypeInfo = m_pSP2P->ISP2P_System_GetGlassTypeInfo(nGlassTypeInfoIndex);
|
m_pSP2P->ISP2P_DisplayMessage(_T("GlassTypeName : %s,GlassTypeIdx : %s"),pGlassTypeInfo->m_strGlassTypeName,pTransferData->strGlassScanSchedule);
|
|
// ¸ðÅÍ Á¤º¸
|
const CMotorControlInfo *pMotorInfo = m_pSP2P->ISP2P_System_GetMotorInfo();
|
|
// ÁÂÇ¥ º¯È¯±â
|
CCoordCalibrator* pCoordCalibrator = m_pSP2P->ISP2P_GetCoordCalibrator();
|
|
// ÁÂÇ¥°è ¼³Á¤
|
if (pSystemInfo && pGlassTypeInfo && pMotorInfo && pCoordCalibrator)
|
{
|
// Get Direction
|
int nDirectionX = GetDirectionX(pGlassTypeInfo->m_nOriginDirection, pMotorInfo->GetOriginDirection());
|
int nDirectionY = GetDirectionY(pGlassTypeInfo->m_nOriginDirection, pMotorInfo->GetOriginDirection());
|
|
// ÁÂÇ¥°è ¼³Á¤
|
pCoordCalibrator->SetTransDirection(nDirectionX, nDirectionY);
|
pCoordCalibrator->SetOriginMotorPosition(pGlassTypeInfo->m_dOriginMotorX, pGlassTypeInfo->m_dOriginMotorY);
|
if (fabs(pGlassTypeInfo->m_dAlignAngle) > 0.0000001)
|
{
|
pCoordCalibrator->SetRotationInfo(pGlassTypeInfo->m_dFirstAlignMotorX, pGlassTypeInfo->m_dFirstAlignMotorY,
|
pGlassTypeInfo->m_dFirstAlignGlassX, pGlassTypeInfo->m_dFirstAlignGlassY, pGlassTypeInfo->m_dAlignAngle);
|
}
|
|
// ±Û¶ó½º Á¤º¸ ¼³Á¤
|
pGlassResult->SetGlassSize(pGlassTypeInfo->m_nGlassSizeX * 1000, pGlassTypeInfo->m_nGlassSizeY * 1000);
|
pGlassResult->SetGlassOriginDirection(pGlassTypeInfo->m_nOriginDirection);
|
pGlassResult->SetCornerCutDirection(pGlassTypeInfo->m_nCornerCutDirection);
|
pGlassResult->SetGlassCenterCoordinate(pGlassTypeInfo->m_bUseCenterCoodinateSystem);
|
pGlassResult->SetGlassInverseCoordinate(pGlassTypeInfo->m_bUseInverseCoordinate);
|
pGlassResult->SetCollisionDistanceX(int(pSystemInfo->m_dCollisionDistance*1000.));
|
}
|
|
// Align Á¤º¸
|
const CRsRcpAlignInfo* pRsRcpAlignInfo = m_pSP2P->ISP2P_Recipe_GetRsRcpAlignInfo();
|
|
// Align Á¤º¸ ¼³Á¤
|
if (pGlassTypeInfo && pRsRcpAlignInfo)
|
{
|
// Align ¸¶Å© Á¤º¸ ¼³Á¤ (Çȼ¿, ¸ðÅÍ, ±Û¶ó½º À§Ä¡)
|
pGlassResult->m_AlignRecipe.m_nUseAlignPosMove = pGlassTypeInfo->m_nUseAlignPosMove;
|
|
// Çȼ¿ À§Ä¡
|
pGlassResult->m_AlignRecipe.dOriginPixelX[0] = pGlassTypeInfo->m_nFirstAlignFindPixelX;
|
pGlassResult->m_AlignRecipe.dOriginPixelY[0] = pGlassTypeInfo->m_nFirstAlignFindPixelY;
|
pGlassResult->m_AlignRecipe.dOriginPixelX[1] = pGlassTypeInfo->m_nSecondAlignFindPixelX;
|
pGlassResult->m_AlignRecipe.dOriginPixelY[1] = pGlassTypeInfo->m_nSecondAlignFindPixelY;
|
|
// ¸ðÅÍ À§Ä¡
|
pGlassResult->m_AlignRecipe.dOriginPositionX[0] = pGlassTypeInfo->m_dFirstAlignMotorX;
|
pGlassResult->m_AlignRecipe.dOriginPositionY[0] = pGlassTypeInfo->m_dFirstAlignMotorY;
|
pGlassResult->m_AlignRecipe.dOriginPositionX[1] = pGlassTypeInfo->m_dSecondAlignMotorX;
|
pGlassResult->m_AlignRecipe.dOriginPositionY[1] = pGlassTypeInfo->m_dSecondAlignMotorY;
|
|
// ±Û¶ó½º À§Ä¡
|
pGlassResult->m_AlignRecipe.dGlassPositionX[0] = pGlassTypeInfo->m_dFirstAlignGlassX;
|
pGlassResult->m_AlignRecipe.dGlassPositionY[0] = pGlassTypeInfo->m_dFirstAlignGlassY;
|
pGlassResult->m_AlignRecipe.dGlassPositionX[1] = pGlassTypeInfo->m_dSecondAlignGlassX;
|
pGlassResult->m_AlignRecipe.dGlassPositionY[1] = pGlassTypeInfo->m_dSecondAlignGlassY;
|
|
// Align Recipe Á¤º¸ ¼³Á¤ ÀÚµ¿±¤·® ã±â ÆĶó¹ÌÅÍ
|
// Align Skip Mode
|
pGlassResult->m_AlignRecipe.bAlignSkipMode = pRsRcpAlignInfo->m_bAlignSkipMode;
|
pGlassResult->m_AlignRecipe.bUseTotalPitchMeasure = pRsRcpAlignInfo->m_bTotalPitchMeasure;
|
|
// image matching
|
pGlassResult->m_AlignRecipe.bUseImage = pRsRcpAlignInfo->m_bUseImage;
|
pGlassResult->m_AlignRecipe.dMatchingRate = pRsRcpAlignInfo->m_dMatchingRate;
|
pGlassResult->m_AlignRecipe.strFirstImageFile = pRsRcpAlignInfo->m_strFirstImageFile;
|
pGlassResult->m_AlignRecipe.strSecondImageFile = pRsRcpAlignInfo->m_strSecondImageFile;
|
pGlassResult->m_AlignRecipe.strTotalPitchImageFile = pRsRcpAlignInfo->m_strTotalPitchImageFile;
|
|
// edge find param
|
pGlassResult->m_AlignRecipe.bUseEdge = pRsRcpAlignInfo->m_bUseEdge;
|
pGlassResult->m_AlignRecipe.nEdgeWidth = pRsRcpAlignInfo->m_nEdgeWidth;
|
pGlassResult->m_AlignRecipe.nEdgeHeight = pRsRcpAlignInfo->m_nEdgeHeight;
|
pGlassResult->m_AlignRecipe.nEdgeThreshold = pRsRcpAlignInfo->m_nEdgeThreshold;
|
pGlassResult->m_AlignRecipe.nMergeRange = pRsRcpAlignInfo->m_nMergeRange;
|
pGlassResult->m_AlignRecipe.dEdgeRate = pRsRcpAlignInfo->m_dEdgeRate;
|
|
// ³ëÃâ½Ã°£
|
pGlassResult->m_AlignRecipe.bManualProcess = pRsRcpAlignInfo->m_bManualProcess;
|
pGlassResult->m_AlignRecipe.dFirstCamExposure = pRsRcpAlignInfo->m_dFirstCamExposure;
|
pGlassResult->m_AlignRecipe.dSecondCamExposure = pRsRcpAlignInfo->m_dSecondCamExposure;
|
|
// ÀÚµ¿±¤·® Á¶°Ç
|
pGlassResult->m_AlignRecipe.bAutoProcess = pRsRcpAlignInfo->m_bAutoProcess;
|
pGlassResult->m_AlignRecipe.dTargetMin = pRsRcpAlignInfo->m_dTargetMin;
|
pGlassResult->m_AlignRecipe.dTargetMax = pRsRcpAlignInfo->m_dTargetMax;
|
pGlassResult->m_AlignRecipe.dExposureMin = pRsRcpAlignInfo->m_dExposureMin;
|
pGlassResult->m_AlignRecipe.dExposureMax = pRsRcpAlignInfo->m_dExposureMax;
|
|
// Align Recipe Á¤º¸ ¼³Á¤ rotate info
|
pGlassResult->m_AlignRecipe.bRotateProcess = pRsRcpAlignInfo->m_bRotateProcess;
|
pGlassResult->m_AlignRecipe.nRetryCount = pRsRcpAlignInfo->m_nRetryCount;
|
pGlassResult->m_AlignRecipe.dGlassAngleMin = pRsRcpAlignInfo->m_dGlassAngleMin;
|
pGlassResult->m_AlignRecipe.dGlassAngleMax = pRsRcpAlignInfo->m_dGlassAngleMax;
|
|
// Align Ä«¸Þ¶ó ¹æÇâ ¹× ÇØ»óµµ ¼³Á¤
|
int nAlignCameraInfoCount = 2;
|
for(int nAlignCameraIdx = 0; nAlignCameraIdx < nAlignCameraInfoCount; nAlignCameraIdx++)
|
{
|
// Align Á¶¸í °ª °¡Á®¿À±â.
|
int nLightValue = 0;
|
|
|
if(pRsRcpAlignInfo->m_bManualProcess == 1)
|
{
|
nLightValue = (nAlignCameraIdx==0) ? (int)pRsRcpAlignInfo->m_dFirstCamExposure: (int)pRsRcpAlignInfo->m_dSecondCamExposure;
|
|
//Á¶¸í°ª º¯°æ.
|
CLightControl *pLightControl = m_pSP2P->ISP2P_GetAlignLightControl(nAlignCameraIdx);
|
if (pLightControl)
|
{
|
if (pLightControl->SetLightLevel(nLightValue,nAlignCameraIdx))
|
{
|
if (nAlignCameraIdx==0)
|
m_pSP2P->ISP2P_DisplayMessage(_T("[ApplyRecipeData] 1st AlignCamera Light Level Change %d Success!"), nLightValue);
|
else if (nAlignCameraIdx==1)
|
m_pSP2P->ISP2P_DisplayMessage(_T("[ApplyRecipeData] 2nd AlignCamera Light Level Change %d Success!"), nLightValue);
|
}
|
else
|
{
|
if (nAlignCameraIdx==0)
|
m_pSP2P->ISP2P_DisplayMessage(_T("[ApplyRecipeData] 1st AlignCamera Light Level Change %d Fail!"), nLightValue);
|
else if (nAlignCameraIdx==1)
|
m_pSP2P->ISP2P_DisplayMessage(_T("[ApplyRecipeData] 2nd AlignCamera Light Level Change %d Fail!"), nLightValue);
|
}
|
|
}
|
}
|
|
|
// ¾ó¶óÀÎ Ä«¸Þ¶ó Á¤º¸ °¡Á®¿À±â
|
const CAlignCameraInfo *pCameraInfo = m_pSP2P->ISP2P_System_GetAlignCameraInfo(nAlignCameraIdx);
|
if (pCameraInfo)
|
{
|
const CCameraControlInfo_Plus* pCameraControlInfo = pCameraInfo->GetCameraControlInfo();
|
if(pCameraControlInfo)
|
{
|
pGlassResult->m_AlignRecipe.dCameraResolution[nAlignCameraIdx] = pCameraControlInfo->GetPixelResolution();
|
if(pCameraControlInfo->GetAxisDirectionX() == CAMERA_DIRECTION_FORWARD)
|
{
|
pGlassResult->m_AlignRecipe.nCameraDirX[nAlignCameraIdx] = 1;
|
}
|
else
|
{
|
pGlassResult->m_AlignRecipe.nCameraDirX[nAlignCameraIdx] = -1;
|
}
|
|
if(pCameraControlInfo->GetAxisDirectionY() == CAMERA_DIRECTION_FORWARD)
|
{
|
pGlassResult->m_AlignRecipe.nCameraDirY[nAlignCameraIdx] = 1;
|
}
|
else
|
{
|
pGlassResult->m_AlignRecipe.nCameraDirY[nAlignCameraIdx] = -1;
|
}
|
}
|
}
|
|
// ¾ó¶óÀÎ ÅÛÇø´ Á¤º¸ °¡Á®¿À±â
|
if((int)pGlassTypeInfo->m_vecTemplateImagePath.size() == nAlignCameraInfoCount)
|
{
|
pGlassResult->m_AlignRecipe.strTemplateName[nAlignCameraIdx] = pGlassTypeInfo->m_vecTemplateImagePath[nAlignCameraIdx];
|
}
|
}
|
}
|
|
if (pRsRcpReviewInfo)
|
{
|
int nModuleCount = m_pSP2P->ISP2P_GetModuleStatusCount();
|
CString strRecipeName = *pGlassResult->GetPPID();
|
|
for (int nModuleIdx=0; nModuleIdx<nModuleCount; nModuleIdx++)
|
{
|
// Review Module
|
//////////////////////////////////////////////////////////////////////////
|
AFM_SetAFMTracking(nModuleIdx, FALSE);
|
|
const CRcpLightInfo *pRcpReviewLightInfo = pRsRcpReviewInfo->GetRcpLightInfo(nModuleIdx);
|
if (pRcpReviewLightInfo)
|
{
|
ReviewLight_SetLightLevel(nModuleIdx, pRcpReviewLightInfo->m_nLightLevel);
|
}
|
|
const CRcpAFMRecipeInfo *pRcpReviewAFMInfo = pRsRcpReviewInfo->GetRcpAFMRecipeInfo(nModuleIdx);
|
if (pRcpReviewAFMInfo)
|
{
|
int nRealAFMIndex = pRcpReviewAFMInfo->m_nRecipeIndex;
|
if(nRealAFMIndex == -1)// ·¹½ÃÇÇ¿¡ ¼±ÅÃµÈ ¹èÀ²ÀÇ ½ÇÁ¦ MagnificInfo Index¸¦ ¾Ë¾Æ¿È
|
{
|
//-1ÀÇ °æ¿ì ¹èÀ² À妽º °¡Á®´Ù ¾¸.
|
nRealAFMIndex = GetRealMagnification(nModuleIdx, pRcpReviewAFMInfo->m_nZoomIndex);
|
}
|
AFM_SetAFMRecipeName(nModuleIdx, strRecipeName, nRealAFMIndex);
|
|
if(pRcpReviewAFMInfo->m_bAFMHomeOffMode==TRUE) //190618AFMȨ ½ÃÄö½º ÁøÇà X
|
{
|
SetUseAfmHomePosition(FALSE);
|
}
|
else
|
{
|
SetUseAfmHomePosition(TRUE);
|
}
|
}
|
}
|
}
|
|
// °áÇÔ Ã£±â ·¹½ÃÇÇ ¼³Á¤
|
CReviewProcessor* pReviewProcessor = m_pSP2P->ISP2P_GetReviewProcessor();
|
const CRsRcpDefectFindInfo* pRsRcpDefectFindInfo = m_pSP2P->ISP2P_Recipe_GetRsRcpDefectFindInfo();
|
if(pReviewProcessor && pRsRcpDefectFindInfo)
|
{
|
pReviewProcessor->SetDefectFindInfo(pRsRcpDefectFindInfo);
|
}
|
|
// EdgeAlign Check
|
CCameraControlAlign* pCameraControlAlign = m_pSP2P->ISP2P_GetAlignCameraControl();
|
if(pCameraControlAlign)
|
{
|
pCameraControlAlign->SetAlignType(pRsRcpAlignInfo->m_bEdgeAlignProcess);
|
g_pLog->DisplayMessage(_T("[ApplyRecipeDataToGlassResult] EdgeAlignCheck"));
|
}
|
|
// range info
|
CRsRcpReviewInfo* pRsRcpReviewInfo2 = m_pSP2P->ISP2P_Recipe_GetRsRcpReviewInfo();
|
if (pRsRcpReviewInfo2)
|
{
|
CRcpSchedulingInfo* pScheduleInfo = pRsRcpReviewInfo2->GetRcpSchedulingInfo();
|
if (pScheduleInfo)
|
{
|
if (pScheduleInfo->GetUseRangeCntInfo())
|
{
|
// pointer re init
|
m_pSP2P->ISP2P_GetDefectPicker(PICKER_IDX_RANGE);
|
m_pSP2P->ISP2P_GetReviewScheduler(PICKER_IDX_RANGE);
|
|
// add range info
|
for (int nIdx=0; nIdx<Range_Count; nIdx++)
|
{
|
SRangePoint* pRangeInfo = pScheduleInfo->GetRangePointInfo(nIdx);
|
if (pRangeInfo == NULL) continue;
|
|
GetRangeName(nIdx, pRangeInfo);
|
GetRangeSize(nIdx, pRangeInfo);
|
}
|
GetRangeStartEnd(pScheduleInfo);
|
}
|
}
|
}
|
return TRUE;
|
}
|
|
BOOL CSequenceProcessor_CSOT::ReadAOIRawFileToGlassResult(CGlassResult *pGlassResult)
|
{
|
BOOL bRet = FALSE;
|
|
CString strRawTDPath=_T(""), strRawCDPath=_T(""), strRawSDPath=_T("");
|
|
// °á°úÆÄÀÏ À̸§ ã±â
|
FindAOIRawFilePath(pGlassResult, &strRawTDPath, &strRawCDPath, &strRawSDPath);
|
|
bRet = m_pSP2P->ISP2P_ReadAOIRawFileToGlassResult(strRawTDPath);
|
|
return bRet;
|
}
|
|
BOOL CSequenceProcessor_CSOT::FindAOIRawFilePath(CGlassResult *pGlassResult, CString* pRawTDPath, CString* pRawCDPath, CString* pRawSDPath)
|
{
|
*pRawTDPath = _T("");
|
*pRawCDPath = _T("");
|
*pRawSDPath = _T("");
|
|
CString strGlassID = *pGlassResult->GetJobID();
|
|
if (strGlassID.IsEmpty())
|
{
|
m_pSP2P->ISP2P_DisplayMessage(_T("Glass ID is not Exist!"));
|
return FALSE;
|
}
|
|
const CNetworkInfo *pNetworkInfo = m_pSP2P->ISP2P_System_GetNetworkInfo();
|
if(pNetworkInfo == NULL) return 0;
|
|
CString strAOIRawPath = pNetworkInfo->m_strAOIRawPath;
|
CString strLocalRawPath = pNetworkInfo->m_strLocalRawPath;
|
if (strAOIRawPath.IsEmpty() || strLocalRawPath.IsEmpty() )
|
{
|
m_pSP2P->ISP2P_DisplayMessage(_T("%s ResultFile Search Fail!"), strGlassID);
|
return FALSE;
|
}
|
|
// set find name
|
CString strSearchPath;
|
strSearchPath.Format(_T("%s\\%s*"), strAOIRawPath, strGlassID);
|
|
// find file
|
CTime timeLastWrite;
|
CString strFileName, strFileGlassID, strFileWriteTime, strFileExtension, strExtTemp;
|
SRawFile sRawFile;
|
VectorSRawFile vectorSRowFile;
|
|
int nIdx = -1;
|
CFileFind finder;
|
BOOL bRet = finder.FindFile(strSearchPath);
|
while(bRet)
|
{
|
sRawFile.Reset();
|
bRet = finder.FindNextFile();
|
|
if(finder.IsDots()) continue;
|
if(finder.IsDirectory()) continue;
|
|
// [2017:5:16]-[WEZASW] : AOI ServerÀÇ °áÇÔ ÆÄÀÏ À§Ä¡¿¡ °áÇÔ¸Ê À̹ÌÁö ÆÄÀÏ Á¸Àç·Î °áÇÕ ÆÄÀϸ¸ ÃßÃâ
|
sRawFile.strFileName = finder.GetFileName();
|
strExtTemp = sRawFile.strFileName;
|
int nIdx = strExtTemp.Remove('.');
|
AfxExtractSubString(strFileExtension, sRawFile.strFileName, nIdx, '.');
|
//if(strFileExtension.Compare(_T("hgl")) != 0 ) continue;
|
|
finder.GetLastWriteTime(timeLastWrite);
|
sRawFile.dWriteTime = (double)timeLastWrite.GetTime();
|
vectorSRowFile.push_back(sRawFile);
|
}
|
finder.Close();
|
|
// find file size check
|
if(vectorSRowFile.size() < 1)
|
{
|
m_pSP2P->ISP2P_DisplayMessage(_T("%s ResultFile Search Fail!"), strGlassID);
|
return FALSE;
|
}
|
|
// sorting find file
|
SortingFindAOIRawFile(vectorSRowFile, RESULT_SORTING_DESCENDING);
|
|
CString strSourcePath, strTargetPath;
|
strFileName.Format(_T("%s"), vectorSRowFile[0].strFileName);
|
strSourcePath.Format(_T("%s\\%s"), strAOIRawPath, strFileName);
|
strTargetPath.Format(_T("%s\\%s"), strLocalRawPath, strFileName);
|
|
//TD
|
if (CopyFile(strSourcePath, strTargetPath, FALSE))
|
{
|
CString strSrcFilePath, strDstFilePath, strFileTemp;
|
|
bRet = TRUE;
|
pGlassResult->m_strLocalRawFilePath = strTargetPath;
|
pGlassResult->m_strAOIRawFileName = strFileName;
|
pGlassResult->m_strAOIRawFilePath = strSourcePath;
|
m_pSP2P->ISP2P_DisplayMessage(_T("%s -> %s"), strSourcePath, strTargetPath);
|
m_pSP2P->ISP2P_DisplayMessage(_T("[TD] ResultFile Copy Success!"));
|
|
// Backup
|
strSourcePath = strTargetPath;
|
if (pGlassResult->m_strResultDate.GetLength()>0)
|
{
|
strTargetPath.Format(_T("%sBackup\\%s\\%s"), strLocalRawPath, pGlassResult->m_strResultDate, strFileName); // here mch
|
}
|
else
|
{
|
strTargetPath.Format(_T("%sBackup\\%s"), strLocalRawPath, strFileName); // here mch
|
}
|
|
CopyFile(strSourcePath, strTargetPath, FALSE);
|
|
*pRawTDPath = pGlassResult->m_strLocalRawFilePath;
|
}
|
else
|
{
|
bRet = FALSE;
|
pGlassResult->m_strLocalRawFilePath = _T("");
|
pGlassResult->m_strAOIRawFileName = _T("");
|
pGlassResult->m_strAOIRawFilePath = _T("");
|
m_pSP2P->ISP2P_DisplayMessage(_T("[TD] %s ResultFile Copy Fail!"), strTargetPath);
|
}
|
|
return bRet;
|
}
|
|
BOOL CSequenceProcessor_CSOT::ReviewStartProcessing(CGlassResult *pGlassResult, int nPlanIndex)
|
{
|
// clear frame index
|
int nCameraControlCount = m_pSP2P->ISP2P_GetReviewCameraControlCount();
|
for(int nCameraControlIdx = 0; nCameraControlIdx < nCameraControlCount; nCameraControlIdx++)
|
{
|
CCameraControlReview* pCameraControl = m_pSP2P->ISP2P_GetReviewCameraControl(nCameraControlIdx);
|
if(pCameraControl == NULL) continue ;
|
pCameraControl->Camera_ClearIndex();
|
}
|
|
// AFM Tracking OFF
|
//AFM_SetAFMTracking(TRUE);
|
|
// set Mag (Revolver, AFM)
|
if(!AllChangeMagnification(0, ZoomLevel_Auto_CSOT, CSOT_PlanReview))
|
{
|
g_pLog->DisplayMessage(_T("[Revolver] Magnification Change Fail"));
|
}
|
|
// set Light Value
|
CRsRcpReviewInfo *pRsRcpReviewInfo = m_pSP2P->ISP2P_Recipe_GetRsRcpReviewInfo();
|
if (pRsRcpReviewInfo)
|
{
|
int nModuleCount = Module_GetModuleStatusCount();
|
for (int nModuleIdx=0; nModuleIdx<nModuleCount; nModuleIdx++)
|
{
|
const CRcpLightInfo *pRcpLightInfo = pRsRcpReviewInfo->GetRcpLightInfo(nModuleIdx);
|
if (pRcpLightInfo)
|
{
|
ReviewLight_SetLightLevel(nModuleIdx, pRcpLightInfo->m_nLightLevel);
|
}
|
|
BOOL isTopReview = pRsRcpReviewInfo->GetRcpAFMRecipeInfo(nModuleIdx)->GetAFMOffMode();
|
if (!isTopReview)
|
{
|
// AFM Tracking ON
|
AFM_SetAFMTracking(nModuleIdx, TRUE);
|
}
|
}
|
}
|
|
CReviewProcessor* pReviewProcessor = m_pSP2P->ISP2P_GetReviewProcessor();
|
if(pGlassResult && pReviewProcessor)
|
{
|
// ReviewStart
|
pReviewProcessor->SetJobID(pGlassResult->m_strJobID);//pGlassResult->m_strGlassID -> pGlassResult->m_strJobID
|
pReviewProcessor->SetOperID(pGlassResult->m_strOperID);
|
m_pSP2P->ISP2P_UpdateReviewProcessStatus(ReviewProcessStatus_ReviewStart, nPlanIndex);
|
|
// Send ReviewPos to motor
|
m_pSP2P->ISP2P_DisplayMessage(_T("[Motor] Send Review Point to Motor Started!"));
|
SendReviewPositionToMotorControl(pGlassResult);
|
m_pSP2P->ISP2P_DisplayMessage(_T("[Motor] Send Review Point to Motor Ended!"));
|
|
return TRUE;
|
}
|
|
return FALSE;
|
}
|
|
int CSequenceProcessor_CSOT::SendReviewPositionToMotorControl(CGlassResult *pGlassResult)
|
{
|
CMotorControl *pMotorControl = m_pSP2P->ISP2P_GetMotorControl();
|
if(pMotorControl == NULL) return 0;
|
|
const CSystemInfo *pSystemInfo = m_pSP2P->ISP2P_System_GetSystemInfo();
|
if(pSystemInfo == NULL) return -1;
|
|
const CMotorControlInfo* pMotorInfo = m_pSP2P->ISP2P_System_GetMotorInfo();
|
if (pMotorInfo == NULL) return -2;
|
|
const CCoordCalibrator* pCoordCalibrator = m_pSP2P->ISP2P_GetCoordCalibrator();
|
if (pMotorInfo == NULL) return -3;
|
|
// set move count zero
|
for(int i=0; i<pSystemInfo->GetGantryInfoCount(); i++)
|
{
|
pMotorControl->GantrySetMoveCount(i, 0);
|
}
|
|
// set move delay time
|
pMotorControl->CommonSetAfDelayTime(pMotorInfo->GetAfDelayTime());
|
pMotorControl->CommonSetImageDelayTime(pMotorInfo->GetImageDelayTime());
|
pMotorControl->CommonSetWsiDelayTime(pMotorInfo->GetWsiDelayTime());
|
|
// get direction
|
int nDirectionX, nDirectionY;
|
pCoordCalibrator->GetTransDirection(nDirectionX, nDirectionY);
|
|
int nTotalCount = 0;
|
double dDefectPosX, dDefectPosY;
|
|
// review result count
|
for (int nModuleIdx=0; nModuleIdx<Module_GetModuleStatusCount(); nModuleIdx++)
|
{
|
// get review result
|
CReviewResult* pReviewResult = pGlassResult->GetReviewResult(nModuleIdx);
|
if (pReviewResult==NULL) continue;
|
const SCoordInfo* pCoordInfo = Module_GetCoordInfo(nModuleIdx);
|
if (pCoordInfo==NULL) continue;
|
CModuleStatus* pModuleStatus = Module_GetModuleStatus(nModuleIdx);
|
if (pModuleStatus == NULL) continue;
|
|
// set result index
|
int nStartIdx = pReviewResult->GetStartSReviewResultIndex();
|
int nEndIdx = pReviewResult->GetEndSReviewResultIndex();
|
nEndIdx = min(nEndIdx, (pReviewResult->GetSReviewResultCount()-1)) + 1; // End Index ´Ù½Ã¼³Á¤
|
|
// get review pos
|
VectorDouble vectorPosX, vectorPosY;
|
for (int nResultIdx=nStartIdx; nResultIdx<nEndIdx; nResultIdx++)
|
{
|
SReviewResult* pReview = pReviewResult->GetSReviewResult(nResultIdx);
|
if (pReview==NULL) continue;
|
|
// set defect pos
|
dDefectPosX = double(pReview->nUMOriginX) / 1000.0;
|
dDefectPosY = double(pReview->nUMOriginY) / 1000.0;
|
|
// trans glass to motor pos
|
pCoordCalibrator->TransGlass2Motor(pCoordInfo, dDefectPosX, dDefectPosY);
|
|
// set offset
|
ApplyMotorOffset(pReview->nModuleIdx, pReview->nZoomIdx, MotorOffsetCamera + MotorOffsetMag+MotorOffset_Glass, dDefectPosX, dDefectPosY);
|
|
// calibration
|
CalibrateMotorPos(pReview->nModuleIdx,dDefectPosX,dDefectPosY);
|
|
// add review result
|
if((int)vectorPosX.size() < MAX_MOTOR_ADDRESS_SIZE)
|
{
|
pReview->dTargetMotorX = dDefectPosX;
|
pReview->dTargetMotorY = dDefectPosY;
|
vectorPosX.push_back(dDefectPosX);
|
vectorPosY.push_back(dDefectPosY);
|
}
|
}
|
|
// move path to motor
|
// FALSE->TRUE(HSJ TEST)
|
if (pMotorControl->GantryAutoGo(pModuleStatus->GetGantryIndex(), vectorPosX, vectorPosY, TRUE))
|
{
|
nTotalCount += (int)vectorPosX.size();
|
g_pLog->DisplayMessage(_T("[GantryAutoGo] (%d)Gantry Path Send Success! Point[%d]"), pModuleStatus->GetGantryIndex(), int(vectorPosX.size()));
|
//cmark
|
}
|
else
|
{
|
g_pLog->DisplayMessage(_T("[GantryAutoGo] (%d)Gantry Path Send Fail"), pModuleStatus->GetGantryIndex());
|
}
|
}
|
|
// all auto go
|
// HSJ TEST
|
if (pMotorControl->CommonSetAutoGoAll()==FALSE)
|
{
|
g_pLog->DisplayMessage(_T("[GantryAutoGo] All Gantry AutoReview Fail!"));
|
return 0;
|
}
|
|
g_pLog->DisplayMessage(_T("[GantryAutoGo] All Gantry AutoReview Success!"));
|
return nTotalCount;
|
}
|
|
BOOL CSequenceProcessor_CSOT::UserStartProcessing(CGlassResult *pGlassResult, int nPlanIndex)
|
{
|
// clear frame index
|
int nCameraControlCount = m_pSP2P->ISP2P_GetReviewCameraControlCount();
|
for(int nCameraControlIdx = 0; nCameraControlIdx < nCameraControlCount; nCameraControlIdx++)
|
{
|
CCameraControlReview* pCameraControl = m_pSP2P->ISP2P_GetReviewCameraControl(nCameraControlIdx);
|
if(pCameraControl == NULL) continue ;
|
pCameraControl->Camera_ClearIndex();
|
}
|
|
// AFM Tracking OFF
|
AFM_SetAFMTracking(FALSE);
|
|
// set Mag (Revolver, AFM)
|
if(!AllChangeMagnification(0, ZoomLevel_Auto_CSOT, CSOT_PlanUser))
|
{
|
g_pLog->DisplayMessage(_T("[Revolver] Magnification Change Fail"));
|
}
|
|
// set Light Value
|
const CRsRcpReviewInfo *pRsRcpReviewInfo = m_pSP2P->ISP2P_Recipe_GetRsRcpReviewInfo();
|
if (pRsRcpReviewInfo)
|
{
|
int nModuleCount = Module_GetModuleStatusCount();
|
for (int nModuleIdx=0; nModuleIdx<nModuleCount; nModuleIdx++)
|
{
|
const CRcpLightInfo *pRcpLightInfo = pRsRcpReviewInfo->GetRcpUserLightInfo(nModuleIdx);
|
if (pRcpLightInfo)
|
{
|
ReviewLight_SetLightLevel(nModuleIdx, pRcpLightInfo->m_nLightLevel);
|
}
|
}
|
}
|
|
// AFM Tracking ON
|
AFM_SetAFMTracking(TRUE);
|
|
CReviewProcessor* pReviewProcessor = m_pSP2P->ISP2P_GetReviewProcessor();
|
if(pGlassResult && pReviewProcessor)
|
{
|
// UserStart
|
pReviewProcessor->SetJobID(pGlassResult->m_strJobID); //pGlassResult->m_strGlassID -> pGlassResult->m_strJobID º¯°æ
|
pReviewProcessor->SetOperID(pGlassResult->m_strOperID);
|
m_pSP2P->ISP2P_UpdateReviewProcessStatus(ReviewProcessStatus_UserStart, nPlanIndex);
|
|
// Send UserPos to motor
|
m_pSP2P->ISP2P_DisplayMessage(_T("[Motor] Send User Point to Motor Started!"));
|
SendUserPositionToMotorControl(pGlassResult);
|
m_pSP2P->ISP2P_DisplayMessage(_T("[Motor] Send User Point to Motor Ended!"));
|
|
return TRUE;
|
}
|
|
return FALSE;
|
}
|
|
int CSequenceProcessor_CSOT::SendUserPositionToMotorControl(CGlassResult *pGlassResult)
|
{
|
CMotorControl *pMotorControl = m_pSP2P->ISP2P_GetMotorControl();
|
if(pMotorControl == NULL) return 0;
|
|
const CSystemInfo *pSystemInfo = m_pSP2P->ISP2P_System_GetSystemInfo();
|
if(pSystemInfo == NULL) return -1;
|
|
const CMotorControlInfo* pMotorInfo = m_pSP2P->ISP2P_System_GetMotorInfo();
|
if (pMotorInfo == NULL) return -2;
|
|
const CCoordCalibrator* pCoordCalibrator = m_pSP2P->ISP2P_GetCoordCalibrator();
|
if (pMotorInfo == NULL) return -3;
|
|
// set move count zero
|
for(int i=0; i<pSystemInfo->GetGantryInfoCount(); i++)
|
{
|
pMotorControl->GantrySetMoveCount(i, 0);
|
}
|
|
// set move delay time
|
pMotorControl->CommonSetAfDelayTime(pMotorInfo->GetAfDelayTime());
|
pMotorControl->CommonSetImageDelayTime(pMotorInfo->GetImageDelayTime());
|
pMotorControl->CommonSetWsiDelayTime(pMotorInfo->GetWsiDelayTime());
|
|
|
// get direction
|
int nDirectionX, nDirectionY;
|
pCoordCalibrator->GetTransDirection(nDirectionX, nDirectionY);
|
|
int nTotalCount = 0;
|
double dDefectPosX, dDefectPosY;
|
|
// review result count
|
for (int nModuleIdx=0; nModuleIdx<Module_GetModuleStatusCount(); nModuleIdx++)
|
{
|
// get UserResult
|
CReviewResult* pReviewResult = pGlassResult->GetUserResult(nModuleIdx);
|
if (pReviewResult==NULL) continue;
|
const SCoordInfo* pCoordInfo = Module_GetCoordInfo(nModuleIdx);
|
if (pCoordInfo==NULL) continue;
|
CModuleStatus* pModuleStatus = Module_GetModuleStatus(nModuleIdx);
|
if (pModuleStatus == NULL) continue;
|
|
// get result index
|
int nStartIdx = pReviewResult->GetStartSReviewResultIndex();
|
int nEndIdx = pReviewResult->GetEndSReviewResultIndex();
|
nEndIdx = min(nEndIdx, (pReviewResult->GetSReviewResultCount()-1)) + 1; // End Index ´Ù½Ã¼³Á¤
|
|
// [2017:3:8]-[WEZASW] : CameraOffset ¹üÀ§ º¯°æ (-1~1 => -5~5)
|
double m_dMinOffset = -5.0;
|
double m_dMaxOffset = 5.0;
|
|
// get user pos
|
VectorDouble vectorPosX, vectorPosY;
|
for (int nResultIdx=nStartIdx; nResultIdx<nEndIdx; nResultIdx++)
|
{
|
SReviewResult* pReview = pReviewResult->GetSReviewResult(nResultIdx);
|
if (pReview==NULL) continue;
|
|
// set defect pos
|
dDefectPosX = double(pReview->nUMOriginX) / 1000.0;
|
dDefectPosY = double(pReview->nUMOriginY) / 1000.0;
|
|
// trans glass to motor pos
|
pCoordCalibrator->TransGlass2Motor(pCoordInfo, dDefectPosX, dDefectPosY);
|
|
// set offset
|
ApplyMotorOffset(pReview->nModuleIdx, pReview->nZoomIdx, MotorOffsetCamera + MotorOffsetMag+MotorOffset_Glass, dDefectPosX, dDefectPosY);
|
|
CalibrateMotorPos(pReview->nModuleIdx, dDefectPosX, dDefectPosY);
|
|
// push move pos
|
if((int)vectorPosX.size() < MAX_MOTOR_ADDRESS_SIZE)
|
{
|
pReview->dTargetMotorX = dDefectPosX;
|
pReview->dTargetMotorY = dDefectPosY;
|
vectorPosX.push_back(dDefectPosX);
|
vectorPosY.push_back(dDefectPosY);
|
}
|
}
|
|
// move path to motor
|
if (pMotorControl->GantryAutoGo(pModuleStatus->GetGantryIndex(), vectorPosX, vectorPosY, TRUE))
|
{
|
nTotalCount += (int)vectorPosX.size();
|
g_pLog->DisplayMessage(_T("[GantryAutoGo] (%d)Gantry Path Send Success! Point Count : %d"), pModuleStatus->GetGantryIndex(), (int)vectorPosX.size());
|
}
|
else
|
{
|
g_pLog->DisplayMessage(_T("[GantryAutoGo] (%d)Gantry Path Send Fail"), pModuleStatus->GetGantryIndex());
|
}
|
}
|
|
// all auto go
|
if (pMotorControl->CommonSetAutoGoAll()==FALSE)
|
{
|
g_pLog->DisplayMessage(_T("[GantryAutoGo] All Gantry AutoUser Fail!"));
|
return 0;
|
}
|
|
g_pLog->DisplayMessage(_T("[GantryAutoGo] All Gantry AutoUser Success!"));
|
return nTotalCount;
|
}
|
|
BOOL CSequenceProcessor_CSOT::WsiStartProcessing(CGlassResult *pGlassResult, int nPlanIndex)
|
{
|
AFM_SetAFMTracking(FALSE);
|
// send wsi start
|
|
SetWsiType(0);
|
WSIAllReadySignal(0);
|
|
if(!WSIAllStartSignal())
|
{
|
g_pLog->DisplayMessage(_T("[WSI] WSI Start Fail!!"));
|
}
|
|
CReviewProcessor* pReviewProcessor = m_pSP2P->ISP2P_GetReviewProcessor();
|
if(pGlassResult && pReviewProcessor)
|
{
|
// WsiStart
|
pReviewProcessor->SetJobID(pGlassResult->m_strJobID); // pGlassResult->m_strGlassID -> pGlassResult->m_strJobID º¯°æ
|
pReviewProcessor->SetOperID(pGlassResult->m_strOperID);
|
m_pSP2P->ISP2P_UpdateReviewProcessStatus(ReviewProcessStatus_WSIStart, nPlanIndex);
|
|
// Send WsiPos to Motor
|
m_pSP2P->ISP2P_DisplayMessage(_T("[Motor] Send Wsi Point to Motor Started!"));
|
SendWsiPositionToMotorControl(pGlassResult);
|
m_pSP2P->ISP2P_DisplayMessage(_T("[Motor] Send Wsi Point to Motor Ended!"));
|
|
|
MakeWSIUpLoadDirectory(pReviewProcessor->GetUploadImagePath());
|
|
//20190219 chm
|
pReviewProcessor->SetReviewCount(0); // ¸®ºä Sequence No ÃʱâÈ.
|
|
return TRUE;
|
}
|
|
return FALSE;
|
}
|
|
void CSequenceProcessor_CSOT::MakeWSIUpLoadDirectory(CString strPath)
|
{
|
strPath = strPath + _T("\\WSI");
|
if(CreateDirectory(strPath,NULL)==FALSE)
|
{
|
g_pLog->DisplayMessage(_T("[MakeWSIUpLoadDirectory]Directory Create Fail %s "),strPath);
|
}
|
|
}
|
|
int CSequenceProcessor_CSOT::SendWsiPositionToMotorControl(CGlassResult* pGlassResult)
|
{
|
CMotorControl *pMotorControl = m_pSP2P->ISP2P_GetMotorControl();
|
if(pMotorControl == NULL) return 0;
|
|
const CSystemInfo *pSystemInfo = m_pSP2P->ISP2P_System_GetSystemInfo();
|
if(pSystemInfo == NULL) return -1;
|
|
const CMotorControlInfo* pMotorInfo = m_pSP2P->ISP2P_System_GetMotorInfo();
|
if (pMotorInfo == NULL) return -2;
|
|
const CCoordCalibrator* pCoordCalibrator = m_pSP2P->ISP2P_GetCoordCalibrator();
|
if (pMotorInfo == NULL) return -3;
|
|
// set move count zero
|
for(int i=0; i<pSystemInfo->GetGantryInfoCount(); i++)
|
{
|
pMotorControl->GantrySetMoveCount(i, 0);
|
}
|
|
// set move delay time
|
pMotorControl->CommonSetAfDelayTime(pMotorInfo->GetAfDelayTime());
|
pMotorControl->CommonSetImageDelayTime(pMotorInfo->GetImageDelayTime());
|
pMotorControl->CommonSetWsiDelayTime(pMotorInfo->GetWsiDelayTime());
|
|
// get direction
|
int nDirectionX, nDirectionY;
|
pCoordCalibrator->GetTransDirection(nDirectionX, nDirectionY);
|
|
int nTotalCount = 0;
|
double dDefectPosX, dDefectPosY;
|
|
// WSI result count
|
for (int nModuleIdx=0; nModuleIdx<Module_GetModuleStatusCount(); nModuleIdx++)
|
{
|
CReviewResult* pWsiResult = pGlassResult->GetWsiResult(nModuleIdx);
|
if (pWsiResult==NULL) continue;
|
const SCoordInfo* pCoordInfo = Module_GetCoordInfo(nModuleIdx);
|
if (pCoordInfo==NULL) continue;
|
CModuleStatus* pModuleStatus = Module_GetModuleStatus(nModuleIdx);
|
if (pModuleStatus == NULL) continue;
|
|
// get result index
|
int nStartIdx = pWsiResult->GetStartSReviewResultIndex();
|
int nEndIdx = pWsiResult->GetEndSReviewResultIndex();
|
nEndIdx = min(nEndIdx, (pWsiResult->GetSReviewResultCount()-1)) + 1; // set End Index
|
|
// [2017:3:8]-[WEZASW] : CameraOffset ¹üÀ§ º¯°æ (-1~1 => -5~5)
|
double m_dMinOffset = -5.0;
|
double m_dMaxOffset = 5.0;
|
|
// get wsi pos
|
VectorDouble vectorPosX, vectorPosY;
|
|
for (int nResultIdx=nStartIdx; nResultIdx<nEndIdx; nResultIdx++)
|
{
|
SReviewResult* pWsi = pWsiResult->GetSReviewResult(nResultIdx);
|
if (pWsi==NULL) continue;
|
|
// set defect pos
|
dDefectPosX = double(pWsi->nUMOriginX) / 1000.0;
|
dDefectPosY = double(pWsi->nUMOriginY) / 1000.0;
|
|
// trans glass to motor pos
|
pCoordCalibrator->TransGlass2Motor(pCoordInfo, dDefectPosX, dDefectPosY);
|
|
// set offset
|
ApplyMotorOffset(pWsi->nModuleIdx, -1, MotorOffsetCamera + MotorOffsetWSI+MotorOffset_Glass, dDefectPosX, dDefectPosY);
|
|
// motor calibrate
|
CalibrateMotorPos(pWsi->nModuleIdx, dDefectPosX, dDefectPosY);
|
|
// add move pos
|
if((int)vectorPosX.size() < MAX_MOTOR_ADDRESS_SIZE)
|
{
|
pWsi->dTargetMotorX = dDefectPosX;
|
pWsi->dTargetMotorY = dDefectPosY;
|
vectorPosX.push_back(dDefectPosX);
|
vectorPosY.push_back(dDefectPosY);
|
}
|
}
|
|
|
if (pMotorControl->GantryWsiAutoGo(pModuleStatus->GetGantryIndex(), vectorPosX, vectorPosY, TRUE))
|
{
|
nTotalCount += (int)vectorPosX.size();
|
g_pLog->DisplayMessage(_T("[GantryAutoGo] (%d)Gantry Path Send Success! PointCount : %d"), pModuleStatus->GetGantryIndex(), (int)vectorPosX.size());
|
}
|
else
|
{
|
g_pLog->DisplayMessage(_T("[GantryAutoGo] (%d)Gantry Path Send Fail"), pModuleStatus->GetGantryIndex());
|
}
|
}
|
|
// all auto go
|
if (pMotorControl->CommonSetAutoWsiGoAll()==FALSE)
|
{
|
g_pLog->DisplayMessage(_T("[GantryAutoGo] All Gantry AutoWsi Fail!"));
|
return 0;
|
}
|
|
g_pLog->DisplayMessage(_T("[GantryAutoGo] All Gantry AutoWsi Success!"));
|
return nTotalCount;
|
}
|
BOOL CSequenceProcessor_CSOT::ReflowStartProcessing( CGlassResult *pGlassResult, int nPlanIndex/*=0*/ )
|
{
|
// clear frame index
|
int nCameraControlCount = m_pSP2P->ISP2P_GetReviewCameraControlCount();
|
for(int nCameraControlIdx = 0; nCameraControlIdx < nCameraControlCount; nCameraControlIdx++)
|
{
|
CCameraControlReview* pCameraControl = m_pSP2P->ISP2P_GetReviewCameraControl(nCameraControlIdx);
|
if(pCameraControl == NULL) continue ;
|
pCameraControl->Camera_ClearIndex();
|
}
|
|
// AFM Tracking OFF
|
AFM_SetAFMTracking(FALSE);
|
|
// set Mag (Revolver, AFM)
|
if(!AllChangeMagnification(0, ZoomLevel_Auto_CSOT, CSOT_PlanReflow))
|
{
|
g_pLog->DisplayMessage(_T("[Revolver] Magnification Change Fail"));
|
}
|
|
// set Light Value
|
const CRsRcpReviewInfo *pRsRcpReviewInfo = m_pSP2P->ISP2P_Recipe_GetRsRcpReviewInfo();
|
if (pRsRcpReviewInfo)
|
{
|
int nModuleCount = Module_GetModuleStatusCount();
|
for (int nModuleIdx=0; nModuleIdx<nModuleCount; nModuleIdx++)
|
{
|
const CRcpLightInfo *pRcpLightInfo = pRsRcpReviewInfo->GetRcpUserLightInfo(nModuleIdx);
|
if (pRcpLightInfo)
|
{
|
ReviewLight_SetLightLevel(nModuleIdx, pRcpLightInfo->m_nLightLevel);
|
}
|
}
|
}
|
|
// AFM Tracking ON
|
AFM_SetAFMTracking(TRUE);
|
|
CReviewProcessor* pReviewProcessor = m_pSP2P->ISP2P_GetReviewProcessor();
|
if(pGlassResult && pReviewProcessor)
|
{
|
// UserStart
|
pReviewProcessor->SetJobID(pGlassResult->m_strJobID);
|
pReviewProcessor->SetOperID(pGlassResult->m_strOperID);
|
m_pSP2P->ISP2P_UpdateReviewProcessStatus(ReviewProcessStatus_ReflowStart, nPlanIndex);
|
|
// Send UserPos to motor
|
m_pSP2P->ISP2P_DisplayMessage(_T("[Motor] Send Reflow Point to Motor Started!"));
|
SendReflowPositionToMotorControl(pGlassResult);
|
m_pSP2P->ISP2P_DisplayMessage(_T("[Motor] Send Reflow Point to Motor Ended!"));
|
|
return TRUE;
|
}
|
|
return FALSE;
|
}
|
|
int CSequenceProcessor_CSOT::SendReflowPositionToMotorControl( CGlassResult* pGlassResult )
|
{
|
CMotorControl *pMotorControl = m_pSP2P->ISP2P_GetMotorControl();
|
if(pMotorControl == NULL) return 0;
|
|
const CSystemInfo *pSystemInfo = m_pSP2P->ISP2P_System_GetSystemInfo();
|
if(pSystemInfo == NULL) return -1;
|
|
const CMotorControlInfo* pMotorInfo = m_pSP2P->ISP2P_System_GetMotorInfo();
|
if (pMotorInfo == NULL) return -2;
|
|
const CCoordCalibrator* pCoordCalibrator = m_pSP2P->ISP2P_GetCoordCalibrator();
|
if (pMotorInfo == NULL) return -3;
|
|
// set move count zero
|
for(int i=0; i<pSystemInfo->GetGantryInfoCount(); i++)
|
{
|
pMotorControl->GantrySetMoveCount(i, 0);
|
}
|
|
// set move delay time
|
pMotorControl->CommonSetAfDelayTime(pMotorInfo->GetAfDelayTime());
|
pMotorControl->CommonSetImageDelayTime(pMotorInfo->GetImageDelayTime());
|
pMotorControl->CommonSetWsiDelayTime(pMotorInfo->GetWsiDelayTime());
|
|
|
// get direction
|
int nDirectionX, nDirectionY;
|
pCoordCalibrator->GetTransDirection(nDirectionX, nDirectionY);
|
|
int nTotalCount = 0;
|
double dDefectPosX, dDefectPosY;
|
|
// review result count
|
for (int nModuleIdx=0; nModuleIdx<Module_GetModuleStatusCount(); nModuleIdx++)
|
{
|
// get reflow result
|
CReviewResult* pReviewResult = pGlassResult->GetReflowResult(nModuleIdx);
|
if (pReviewResult==NULL) continue;
|
const SCoordInfo* pCoordInfo = Module_GetCoordInfo(nModuleIdx);
|
if (pCoordInfo==NULL) continue;
|
CModuleStatus* pModuleStatus = Module_GetModuleStatus(nModuleIdx);
|
if (pModuleStatus == NULL) continue;
|
|
// get result index
|
int nStartIdx = pReviewResult->GetStartSReviewResultIndex();
|
int nEndIdx = pReviewResult->GetEndSReviewResultIndex();
|
nEndIdx = min(nEndIdx, (pReviewResult->GetSReviewResultCount()-1)) + 1; // End Index ´Ù½Ã¼³Á¤
|
|
// [2017:3:8]-[WEZASW] : CameraOffset ¹üÀ§ º¯°æ (-1~1 => -5~5)
|
double m_dMinOffset = -5.0;
|
double m_dMaxOffset = 5.0;
|
|
// get reflow pos
|
VectorDouble vectorPosX, vectorPosY;
|
for (int nResultIdx=nStartIdx; nResultIdx<nEndIdx; nResultIdx++)
|
{
|
SReviewResult* pReview = pReviewResult->GetSReviewResult(nResultIdx);
|
if (pReview==NULL) continue;
|
|
// set defect pos
|
dDefectPosX = double(pReview->nUMOriginX) / 1000.0;
|
dDefectPosY = double(pReview->nUMOriginY) / 1000.0;
|
|
g_pLog->DisplayMessage(_T("[ReflowStart] %d Module, %d Point, Glass: %.3lf mm, %.3lf mm"), nModuleIdx, nResultIdx, dDefectPosX, dDefectPosY);
|
|
// trans glass to motor pos
|
pCoordCalibrator->TransGlass2Motor(pCoordInfo, dDefectPosX, dDefectPosY);
|
|
// set offset
|
ApplyMotorOffset(pReview->nModuleIdx, pReview->nZoomIdx, MotorOffsetCamera + MotorOffsetMag, dDefectPosX, dDefectPosY);
|
|
CalibrateMotorPos(pReview->nModuleIdx, dDefectPosX, dDefectPosY);
|
|
// push move pos
|
if((int)vectorPosX.size() < MAX_MOTOR_ADDRESS_SIZE)
|
{
|
pReview->dTargetMotorX = dDefectPosX;
|
pReview->dTargetMotorY = dDefectPosY;
|
vectorPosX.push_back(dDefectPosX);
|
vectorPosY.push_back(dDefectPosY);
|
|
g_pLog->DisplayMessage(_T("[ReflowStart] %d Module, %d Point, Motor: %.3lf mm, %.3lf mm"), nModuleIdx, nResultIdx, dDefectPosX, dDefectPosY);
|
}
|
}
|
|
// move path to motor
|
if (pMotorControl->GantryAutoGo(pModuleStatus->GetGantryIndex(), vectorPosX, vectorPosY, TRUE))//
|
{
|
nTotalCount += (int)vectorPosX.size();
|
g_pLog->DisplayMessage(_T("[GantryAutoGo] (%d)Gantry Path Send Success!"), pModuleStatus->GetGantryIndex());
|
}
|
else
|
{
|
g_pLog->DisplayMessage(_T("[GantryAutoGo] (%d)Gantry Path Send Fail"), pModuleStatus->GetGantryIndex());
|
}
|
}
|
|
// all auto go
|
if (pMotorControl->CommonSetAutoGoAll()==FALSE)
|
{
|
g_pLog->DisplayMessage(_T("[GantryAutoGo] All Gantry AutoReflow Fail!"));
|
return 0;
|
}
|
|
g_pLog->DisplayMessage(_T("[GantryAutoGo] All Gantry AutoReflow Success!"));
|
return nTotalCount;
|
}
|
|
BOOL CSequenceProcessor_CSOT::MeasureStartProcessing(CGlassResult *pGlassResult, int nPlanIndex)
|
{
|
// Check Glass per MeausreRecipeGlassCount
|
const CRsRcpMeasureInfo *pRsRcpMeasureInfo = m_pSP2P->ISP2P_Recipe_GetRsRcpMeasureInfo();
|
|
// clear frame index
|
int nCameraControlCount = m_pSP2P->ISP2P_GetReviewCameraControlCount();
|
for(int nCameraControlIdx = 0; nCameraControlIdx < nCameraControlCount; nCameraControlIdx++)
|
{
|
CCameraControlReview* pCameraControl = m_pSP2P->ISP2P_GetReviewCameraControl(nCameraControlIdx);
|
if(pCameraControl == NULL) continue ;
|
pCameraControl->Camera_ClearIndex();
|
}
|
|
// AFM Tracking OFF
|
AFM_SetAFMTracking(FALSE);
|
|
// set Mag (Revolver, AFM)
|
if(!AllChangeMagnification(0, ZoomLevel_Auto_CSOT, CSOT_PlanMeasure))
|
{
|
g_pLog->DisplayMessage(_T("[Revolver] Magnification Change Fail"));
|
}
|
|
// set Light Value
|
// if (pRsRcpMeasureInfo)
|
// {
|
// const CRcpMeasureInfo* pMeasureInfo = pRsRcpMeasureInfo->GetRcpMeasureInfo(0); //first pos
|
// if (pMeasureInfo)
|
// {
|
// int nModuleCount = Module_GetModuleStatusCount();
|
// for (int nModuleIdx=0; nModuleIdx<nModuleCount; nModuleIdx++)
|
// {
|
// ReviewLight_SetLightLevel(nModuleIdx, pMeasureInfo->GetLightLevel());
|
// }
|
// }
|
// }
|
|
if (pRsRcpMeasureInfo)
|
{
|
int nModuleCount = Module_GetModuleStatusCount();
|
int nLightIndex = 0;
|
for (int nModuleIdx=0; nModuleIdx<nModuleCount; nModuleIdx++)
|
{
|
const CRcpMeasureInfo* pMeasureInfo = pRsRcpMeasureInfo->GetRcpMeasureInfo(nLightIndex);
|
ReviewLight_SetLightLevel(nModuleIdx, pMeasureInfo->GetLightLevel());
|
nLightIndex += pRsRcpMeasureInfo->GetResultCount();
|
}
|
}
|
|
// AFM Tracking ON
|
AFM_SetAFMTracking(TRUE);
|
|
CReviewProcessor* pReviewProcessor = m_pSP2P->ISP2P_GetReviewProcessor();
|
if(pGlassResult && pReviewProcessor)
|
{
|
// MeasureStart
|
pReviewProcessor->SetJobID(pGlassResult->m_strJobID); // pGlassResult->m_strGlassID -> pGlassResult->m_strJobID º¯°æ
|
pReviewProcessor->SetOperID(pGlassResult->m_strOperID);
|
m_pSP2P->ISP2P_UpdateReviewProcessStatus(ReviewProcessStatus_MeasureStart, nPlanIndex);
|
|
// Send MeasurePos to Motor
|
m_pSP2P->ISP2P_DisplayMessage(_T("[Motor] Send Measure Point to Motor Started!"));
|
SendMeasurePositionToMotorControl(pGlassResult);
|
m_pSP2P->ISP2P_DisplayMessage(_T("[Motor] Send Measure Point to Motor Ended!"));
|
|
return TRUE;
|
}
|
|
return FALSE;
|
}
|
|
|
int CSequenceProcessor_CSOT::SendMeasurePositionToMotorControl(CGlassResult *pGlassResult)
|
{
|
CMotorControl *pMotorControl = m_pSP2P->ISP2P_GetMotorControl();
|
if(pMotorControl == NULL) return 0;
|
|
const CSystemInfo *pSystemInfo = m_pSP2P->ISP2P_System_GetSystemInfo();
|
if(pSystemInfo == NULL) return -1;
|
|
const CMotorControlInfo* pMotorInfo = m_pSP2P->ISP2P_System_GetMotorInfo();
|
if (pMotorInfo == NULL) return -2;
|
|
const CCoordCalibrator* pCoordCalibrator = m_pSP2P->ISP2P_GetCoordCalibrator();
|
if (pCoordCalibrator == NULL) return -3;
|
|
const CRsRcpMeasureInfo* pRsRcpMeasureInfo = m_pSP2P->ISP2P_Recipe_GetRsRcpMeasureInfo();
|
if (pRsRcpMeasureInfo==NULL) return -4;
|
|
// set move count zero
|
int nGantryCount = pSystemInfo->GetGantryInfoCount();
|
for (int nGantryIdx=0; nGantryIdx<nGantryCount; nGantryIdx++)
|
{
|
pMotorControl->GantrySetMoveCount(nGantryIdx, 0);
|
}
|
|
// set move delay time
|
pMotorControl->CommonSetAfDelayTime(pMotorInfo->GetAfDelayTime());
|
pMotorControl->CommonSetImageDelayTime(pMotorInfo->GetAfDelayTime());
|
pMotorControl->CommonSetWsiDelayTime(pMotorInfo->GetWsiDelayTime());
|
|
// get direction
|
// int nDirectionX, nDirectionY;
|
// pCoordCalibrator->GetTransDirection(nDirectionX, nDirectionY);
|
|
int nTotalCount = 0;
|
double dDefectPosX, dDefectPosY;
|
|
int nResultCount = pRsRcpMeasureInfo->GetResultCount();
|
|
for (int nGantryIdx=0; nGantryIdx<nGantryCount; nGantryIdx++)
|
{
|
VectorDouble vecGantryPos;
|
for (int nResultIdx=0; nResultIdx<nResultCount; nResultIdx++)
|
{
|
VectorDouble vecTempPos;
|
for(int nModuleIdx=0; nModuleIdx<m_pSP2P->ISP2P_GetModuleStatusCount(); nModuleIdx++)
|
{
|
const CModuleStatus* pModuleStatus = m_pSP2P->ISP2P_GetModuleStatus(nModuleIdx);
|
if (pModuleStatus==NULL) continue;
|
|
// check gantry idx
|
if (nGantryIdx!=pModuleStatus->GetGantryIndex()) continue;
|
|
// get measure result
|
SReviewResult* pSReviewResult = pGlassResult->GetSMeasureResult(nModuleIdx, nResultIdx);
|
if (pSReviewResult==NULL) continue;
|
|
const SCoordInfo* pCoordInfo = Module_GetCoordInfo(nModuleIdx);
|
if(pCoordInfo == NULL) continue;
|
|
// [2017:3:8]-[WEZASW] : CameraOffset ¹üÀ§ º¯°æ (-1~1 => -5~5)
|
double m_dMinOffset = -5.0;
|
double m_dMaxOffset = 5.0;
|
|
dDefectPosX = double(pSReviewResult->nUMOriginX) / 1000.0;
|
dDefectPosY = double(pSReviewResult->nUMOriginY) / 1000.0;
|
|
// trans glass to motor pos
|
pCoordCalibrator->TransGlass2Motor(pCoordInfo, dDefectPosX, dDefectPosY);
|
|
// set offset
|
ApplyMotorOffset(nModuleIdx, pSReviewResult->nZoomIdx, MotorOffsetCamera+MotorOffsetMag+MotorOffset_Glass, dDefectPosX, dDefectPosY);
|
|
// motor calibrator
|
CalibrateMotorPos(nModuleIdx, dDefectPosX, dDefectPosY);
|
|
// last motor pos
|
pSReviewResult->dTargetMotorX = dDefectPosX;
|
pSReviewResult->dTargetMotorY = dDefectPosY;
|
|
if (pModuleStatus->GetHeaderIndex()==0) // main header
|
{
|
vecTempPos.push_back(dDefectPosX); // X1
|
vecTempPos.push_back(dDefectPosY); // Y1
|
}
|
else // sub header
|
{
|
vecTempPos.push_back(dDefectPosY); // Y2
|
double dSxPos = dDefectPosX - vecTempPos[0]; // X2 - X1
|
vecTempPos.push_back(dSxPos);
|
}
|
} // end for module
|
|
|
CString strValue = _T("");
|
strValue.Format(_T("[%d_Gantry_%d_Pos] "), nGantryIdx, nResultIdx);
|
CString strTemp = _T("");
|
for (VectorDoubleIt it=vecTempPos.begin(); it!=vecTempPos.end(); it++)
|
{
|
strTemp.Format(_T("%.3lf , "), *it);
|
strValue += strTemp;
|
vecGantryPos.push_back(*it);
|
}
|
|
g_pLog->DisplayMessage(strValue);
|
|
} // end for result
|
|
// send measure pos & count
|
if(pMotorControl->GantryMeasureAutoGo(nGantryIdx, vecGantryPos, TRUE))
|
{
|
nTotalCount += (int)vecGantryPos.size();
|
g_pLog->DisplayMessage(_T("[GantryAutoGo] (%d)Gantry Path Send Success! %d ea"), nGantryIdx, (int)vecGantryPos.size());
|
}
|
else
|
{
|
g_pLog->DisplayMessage(_T("[GantryAutoGo] (%d)Gantry Path Send Fail!"), nGantryIdx);
|
}
|
|
}
|
|
// all gantry measure command
|
if (pMotorControl->CommonSetAutoMeasureGoAll()==FALSE)
|
{
|
g_pLog->DisplayMessage(_T("[GantryAutoGo] All Gantry AutoMeasure Fail!"));
|
return 0;
|
}
|
|
g_pLog->DisplayMessage(_T("[GantryAutoGo] All Gantry AutoMeasure Success!"));
|
|
return nTotalCount;
|
}
|
|
|
int CSequenceProcessor_CSOT::SendMeasurePositionToMotorControl_Old(CGlassResult *pGlassResult)
|
{
|
CMotorControl *pMotorControl = m_pSP2P->ISP2P_GetMotorControl();
|
if(pMotorControl == NULL) return 0;
|
|
const CSystemInfo *pSystemInfo = m_pSP2P->ISP2P_System_GetSystemInfo();
|
if(pSystemInfo == NULL) return -1;
|
|
const CMotorControlInfo* pMotorInfo = m_pSP2P->ISP2P_System_GetMotorInfo();
|
if (pMotorInfo == NULL) return -2;
|
|
const CCoordCalibrator* pCoordCalibrator = m_pSP2P->ISP2P_GetCoordCalibrator();
|
if (pMotorInfo == NULL) return -3;
|
|
// set move count zero
|
for(int i=0; i<pSystemInfo->GetGantryInfoCount(); i++)
|
{
|
pMotorControl->GantrySetMoveCount(i, 0);
|
}
|
|
// set move delay time
|
pMotorControl->CommonSetAfDelayTime(pMotorInfo->GetAfDelayTime());
|
pMotorControl->CommonSetImageDelayTime(pMotorInfo->GetImageDelayTime());
|
pMotorControl->CommonSetWsiDelayTime(pMotorInfo->GetWsiDelayTime());
|
|
// get direction
|
int nDirectionX, nDirectionY;
|
pCoordCalibrator->GetTransDirection(nDirectionX, nDirectionY);
|
|
int nTotalCount = 0;
|
double dDefectPosX, dDefectPosY;
|
|
// ModuleÀÇ À§Ä¡¿¡ µû¸¥ ModuleStatus sorting
|
std::vector<CModuleStatus*> SortedModuleStatus;
|
for(int nModuleIdx = 0; nModuleIdx < m_pSP2P->ISP2P_GetModuleStatusCount(); nModuleIdx++)
|
{
|
SortedModuleStatus.push_back(m_pSP2P->ISP2P_GetModuleStatus(nModuleIdx));
|
}
|
|
// y sort => x sort
|
std::sort(SortedModuleStatus.begin(), SortedModuleStatus.end(), CompareFuction);
|
|
//std::vector<CReviewResult*> vecReviewResult;
|
VectorReviewResult* vecReviewResult = pGlassResult->GetVectorMeasureResult();
|
|
std::vector<VectorReviewResult> vecGantryReviewResult;
|
vecGantryReviewResult.resize(pSystemInfo->GetGantryInfoCount());
|
|
for(int nReviewResultIdx = 0; nReviewResultIdx < vecReviewResult->size(); nReviewResultIdx++)
|
{
|
int nModuleStatusIdx = vecReviewResult->at(nReviewResultIdx).GetModuleIndex();
|
CModuleStatus* pModuleStatus = m_pSP2P->ISP2P_GetModuleStatus(nModuleStatusIdx);
|
if(pModuleStatus == NULL) continue;
|
|
vecGantryReviewResult.at(pModuleStatus->GetGantryIndex()).push_back(vecReviewResult->at(nReviewResultIdx));
|
}
|
|
for(int nGantryIdx = 0; nGantryIdx < pSystemInfo->GetGantryInfoCount(); nGantryIdx++)
|
{
|
std::sort(vecGantryReviewResult.at(nGantryIdx).begin(), vecGantryReviewResult.at(nGantryIdx).begin(), GantrySorting);
|
}
|
|
for(int nGantryIdx = 0; nGantryIdx < pSystemInfo->GetGantryInfoCount(); nGantryIdx++)
|
{
|
VectorDouble vectorPos;
|
VectorReviewResult* pVectorReviewResult = &vecGantryReviewResult.at(nGantryIdx);
|
if(pVectorReviewResult == NULL) continue;
|
if(pVectorReviewResult->size() == 0) continue;
|
|
int nStartIdx = pVectorReviewResult->at(0).GetStartSReviewResultIndex();
|
int nEndIdx = pVectorReviewResult->at(0).GetEndSReviewResultIndex();
|
|
for(int nSReviewResultIdx = nStartIdx; nSReviewResultIdx < nEndIdx; nSReviewResultIdx++)
|
{
|
for(int nHeaderIdx = 0; nHeaderIdx < vecGantryReviewResult.at(nGantryIdx).size(); nHeaderIdx++)
|
{
|
CReviewResult* pReviewResult = &pVectorReviewResult->at(nHeaderIdx);
|
if(pReviewResult == NULL)
|
{
|
m_pSP2P->ISP2P_DisplayMessage(_T("[Measure Error]Gantry[%d] ReviewResult is NULL"), pReviewResult->GetModuleIndex());
|
break;
|
}
|
|
const SCoordInfo* pCoordInfo = Module_GetCoordInfo(pReviewResult->GetModuleIndex());
|
if(pCoordInfo == NULL) continue;
|
|
// [2017:3:8]-[WEZASW] : CameraOffset ¹üÀ§ º¯°æ (-1~1 => -5~5)
|
double m_dMinOffset = -5.0;
|
double m_dMaxOffset = 5.0;
|
|
SReviewResult* pSReviewResult = pReviewResult->GetSReviewResult(nSReviewResultIdx);
|
if(pSReviewResult == NULL) continue;
|
|
dDefectPosX = double(pSReviewResult->nUMOriginX) / 1000.0;
|
dDefectPosY = double(pSReviewResult->nUMOriginY) / 1000.0;
|
|
// trans glass to motor pos
|
pCoordCalibrator->TransGlass2Motor(pCoordInfo, dDefectPosX, dDefectPosY);
|
|
// set offset
|
ApplyMotorOffset(pSReviewResult->nModuleIdx, pSReviewResult->nZoomIdx, MotorOffsetCamera + MotorOffsetMag+MotorOffset_Glass, dDefectPosX, dDefectPosY);
|
|
// motor calibrator
|
CalibrateMotorPos(pSReviewResult->nModuleIdx, dDefectPosX, dDefectPosY);
|
|
if(nHeaderIdx == 0)
|
{
|
// À̵¿ÇÒ ¸ðÅÍÁÂÇ¥ Ãß°¡
|
if((int)vectorPos.size() < MAX_MOTOR_ADDRESS_SIZE)
|
{
|
pSReviewResult->dTargetMotorX = dDefectPosX;
|
pSReviewResult->dTargetMotorY = dDefectPosY;
|
vectorPos.push_back(dDefectPosX);
|
vectorPos.push_back(dDefectPosY);
|
}
|
}
|
else
|
{
|
if((int)vectorPos.size() < MAX_MOTOR_ADDRESS_SIZE)
|
{
|
pSReviewResult->dTargetMotorX = dDefectPosX;
|
pSReviewResult->dTargetMotorY = dDefectPosY;
|
vectorPos.push_back(dDefectPosY);
|
CReviewResult* pFirstReviewResult = &pVectorReviewResult->at(0);
|
SReviewResult* pFirstSReviewResult = pFirstReviewResult->GetSReviewResult(nSReviewResultIdx);
|
double dSXsize = double(pSReviewResult->nUMOriginX - pFirstSReviewResult->nUMOriginX);
|
// pCoordCalibrator->TransGlass2Motor(pCoordInfo, dSXsize, dDefectPosY);
|
vectorPos.push_back(dSXsize);
|
}
|
}
|
}
|
}
|
|
|
if(pMotorControl->GantryMeasureAutoGo(nGantryIdx, vectorPos, TRUE))
|
{
|
nTotalCount += (int)vectorPos.size();
|
g_pLog->DisplayMessage(_T("[GantryAutoGo] (%d)Gantry Path Send Success!"), nGantryIdx);
|
}
|
else
|
{
|
g_pLog->DisplayMessage(_T("[GantryAutoGo] (%d)Gantry Path Send Success!"), nGantryIdx);
|
}
|
}
|
|
// all gantry measure command
|
if (pMotorControl->CommonSetAutoMeasureGoAll()==FALSE)
|
{
|
g_pLog->DisplayMessage(_T("[GantryAutoGo] All Gantry AutoMeasure Fail!"));
|
return 0;
|
}
|
|
g_pLog->DisplayMessage(_T("[GantryAutoGo] All Gantry AutoMeasure Success!"));
|
return nTotalCount;
|
}
|
|
void CSequenceProcessor_CSOT::ReviewScheduler_ResizeReviewResult(CPathSchedulerResult* pScheduleResult, CReviewResult* pReviewResult, CDefectPicker* pDefectPicker, int nSize)
|
{
|
pReviewResult->Reset();
|
int nResultIdx = 0;
|
|
int nModuleIdx = pReviewResult->GetModuleIndex();
|
|
CModuleStatus *pModuleStatus = m_pSP2P->ISP2P_GetModuleStatus(nModuleIdx);
|
if (pModuleStatus==NULL) return;
|
|
CRsRcpReviewInfo *pRsRcpReviewInfo = m_pSP2P->ISP2P_Recipe_GetRsRcpReviewInfo();
|
if (pRsRcpReviewInfo==NULL) return;
|
|
CRcpAFMRecipeInfo *pRcpAFMRecipeInfo = pRsRcpReviewInfo->GetRcpAFMRecipeInfo(nModuleIdx);
|
if (pRcpAFMRecipeInfo==NULL) return;
|
|
int nZoomIdx = GetRealMagnification(nModuleIdx, pRcpAFMRecipeInfo->m_nZoomIndex);
|
|
SMagnificInfo *pMagnificInfo = pModuleStatus->GetMagnificInfo(nZoomIdx);
|
SCameraInfo *pCameraInfo = pModuleStatus->GetCameraInfo(0);
|
if (pMagnificInfo==NULL) return;
|
if (pCameraInfo==NULL) return;
|
|
for (int i=0; i<nSize; i++)
|
{
|
SSchedulerResult *pNode = pScheduleResult->GetPathSchedulerResult(i);
|
if (pNode==NULL) continue;
|
|
SReviewResult* sResult = pDefectPicker->GetPickingResult(pNode->nTotalIndex);
|
if(sResult == NULL) continue;
|
|
sResult->nReviewType = ReviewType_Review;
|
sResult->nModuleIdx = nModuleIdx;
|
sResult->nResultIdx = nResultIdx;
|
|
sResult->nZoomIdx = nZoomIdx;
|
sResult->dMagnification = pMagnificInfo->dMagnification;
|
sResult->dMeasureResolution = pCameraInfo->dResolution / sResult->dMagnification;
|
sResult->bDigitalZoom = FALSE;
|
|
pReviewResult->AddSReviewResult(*sResult);
|
|
nResultIdx++;
|
}
|
|
pScheduleResult->ResizeScheduleResult(nSize);
|
}
|
|
void CSequenceProcessor_CSOT::ReviewScheduler_ResizeUserResult(CPathSchedulerResult* pScheduleResult, CReviewResult* pReviewResult, CPrioritySorter* pPrioritySorter, int nSize)
|
{
|
pReviewResult->Reset();
|
int nResultIdx = 0;
|
|
int nModuleIdx = pScheduleResult->GetModuleIndex();
|
pReviewResult->SetModuleIndex(nModuleIdx);
|
|
CModuleStatus *pModuleStatus = m_pSP2P->ISP2P_GetModuleStatus(nModuleIdx);
|
if (pModuleStatus==NULL) return;
|
|
CRsRcpReviewInfo *pRsRcpReviewInfo = m_pSP2P->ISP2P_Recipe_GetRsRcpReviewInfo();
|
if (pRsRcpReviewInfo==NULL) return;
|
|
CRcpAFMRecipeInfo *pRcpAFMRecipeInfo = pRsRcpReviewInfo->GetRcpUserAFMRecipeInfo(nModuleIdx);//pRsRcpReviewInfo->GetRcpAFMRecipeInfo(nModuleIdx);
|
if (pRcpAFMRecipeInfo==NULL) return;
|
|
int nZoomIdx = GetRealMagnification(nModuleIdx, pRcpAFMRecipeInfo->m_nZoomIndex);
|
|
SMagnificInfo *pMagnificInfo = pModuleStatus->GetMagnificInfo(nZoomIdx);
|
SCameraInfo *pCameraInfo = pModuleStatus->GetCameraInfo(0);
|
if (pMagnificInfo==NULL) return;
|
if (pCameraInfo==NULL) return;
|
|
for (int i=0; i<nSize; i++)
|
{
|
SSchedulerResult *pNode = pScheduleResult->GetPathSchedulerResult(i);
|
if (pNode==NULL) continue;
|
|
SReviewResult* sResult = pPrioritySorter->GetSortingResultUser(pNode->nTotalIndex);
|
if(sResult == NULL) continue;
|
|
sResult->nReviewType = ReviewType_User;
|
sResult->nModuleIdx = nModuleIdx;
|
sResult->nResultIdx = nResultIdx;
|
|
sResult->nZoomIdx = nZoomIdx;
|
sResult->dMagnification = pMagnificInfo->dMagnification;
|
sResult->dMeasureResolution = pCameraInfo->dResolution / sResult->dMagnification;
|
sResult->bDigitalZoom = FALSE;
|
|
pReviewResult->AddSReviewResult(*sResult);
|
|
nResultIdx++;
|
}
|
|
pScheduleResult->ResizeScheduleResult(nSize);
|
}
|
|
void CSequenceProcessor_CSOT::ReviewScheduler_ResizeWsiResult(CPathSchedulerResult* pScheduleResult, CReviewResult* pWsiResult, CDefectPicker* pDefectPicker, int nSize)
|
{
|
pWsiResult->Reset();
|
int nResultIdx = 0;
|
|
int nModuleIdx = pScheduleResult->GetModuleIndex();
|
pWsiResult->SetModuleIndex(nModuleIdx);
|
|
CModuleStatus *pModuleStatus = m_pSP2P->ISP2P_GetModuleStatus(nModuleIdx);
|
if (pModuleStatus==NULL) return;
|
|
CRsRcpReviewInfo *pRsRcpReviewInfo = m_pSP2P->ISP2P_Recipe_GetRsRcpReviewInfo();
|
if (pRsRcpReviewInfo==NULL) return;
|
|
CRcpAFMRecipeInfo *pRcpAFMRecipeInfo = pRsRcpReviewInfo->GetRcpAFMRecipeInfo(nModuleIdx);
|
if (pRcpAFMRecipeInfo==NULL) return;
|
|
int nZoomIdx = GetRealMagnification(nModuleIdx, pRcpAFMRecipeInfo->m_nZoomIndex);
|
|
SMagnificInfo *pMagnificInfo = pModuleStatus->GetMagnificInfo(nZoomIdx);
|
SCameraInfo *pCameraInfo = pModuleStatus->GetCameraInfo(0);
|
if (pMagnificInfo==NULL) return;
|
if (pCameraInfo==NULL) return;
|
|
for (int i=0; i<nSize; i++)
|
{
|
SSchedulerResult *pNode = pScheduleResult->GetPathSchedulerResult(i);
|
if (pNode==NULL) continue;
|
|
SReviewResult* sResult = pDefectPicker->GetPickingResultWsi(pNode->nTotalIndex);
|
if(sResult == NULL) continue;
|
|
sResult->nReviewType = ReviewType_Wsi;
|
sResult->nModuleIdx = nModuleIdx;
|
sResult->nResultIdx = nResultIdx;
|
|
// sResult->nZoomIdx = nZoomIdx;
|
// sResult->dMagnification = pMagnificInfo->dMagnification;
|
// sResult->dMeasureResolution = pCameraInfo->dResolution / sResult->dMagnification;
|
// sResult->bDigitalZoom = FALSE;
|
|
pWsiResult->AddSReviewResult(*sResult);
|
|
nResultIdx++;
|
}
|
|
pScheduleResult->ResizeScheduleResult(nSize);
|
}
|
|
void CSequenceProcessor_CSOT::ReviewScheduler_ResizeReflowResult( CPathSchedulerResult* pScheduleResult, CReviewResult* pReviewResult, CPrioritySorter* pPrioritySorter, int nSize)
|
{
|
pReviewResult->Reset();
|
int nResultIdx = 0;
|
|
int nModuleIdx = pScheduleResult->GetModuleIndex();
|
pReviewResult->SetModuleIndex(nModuleIdx);
|
|
CModuleStatus *pModuleStatus = m_pSP2P->ISP2P_GetModuleStatus(nModuleIdx);
|
if (pModuleStatus==NULL) return;
|
|
CRsRcpReviewInfo *pRsRcpReviewInfo = m_pSP2P->ISP2P_Recipe_GetRsRcpReviewInfo();
|
if (pRsRcpReviewInfo==NULL) return;
|
|
CRcpUserDefectInfo* pRcpUserDefectInfo;
|
|
CRcpAFMRecipeInfo *pRcpAFMRecipeInfo = pRsRcpReviewInfo->GetRcpAFMRecipeInfo(nModuleIdx);
|
if (pRcpAFMRecipeInfo==NULL) return;
|
|
int nZoomIdx = GetRealMagnification(nModuleIdx, pRcpAFMRecipeInfo->m_nZoomIndex);
|
|
SMagnificInfo *pMagnificInfo = pModuleStatus->GetMagnificInfo(nZoomIdx);
|
SCameraInfo *pCameraInfo = pModuleStatus->GetCameraInfo(0);
|
if (pMagnificInfo==NULL) return;
|
if (pCameraInfo==NULL) return;
|
|
CGlassResult* pGlassResult = m_pSP2P->ISP2P_GetCurrentGlassResult();
|
if(pGlassResult ==NULL) return;
|
|
CString strGlassLastName = pGlassResult->m_strGlassLastName;
|
|
for (int i=0; i<nSize; i++)
|
{
|
SSchedulerResult *pNode = pScheduleResult->GetPathSchedulerResult(i);
|
if (pNode==NULL) continue;
|
|
SReviewResult* sResult = pPrioritySorter->GetSortingResultReflow(pNode->nTotalIndex);
|
if(sResult == NULL) continue;
|
|
sResult->nReviewType = ReviewType_Reflow;
|
sResult->nModuleIdx = nModuleIdx;
|
sResult->nResultIdx = nResultIdx;
|
|
sResult->nZoomIdx = nZoomIdx;
|
sResult->dMagnification = pMagnificInfo->dMagnification;
|
sResult->dMeasureResolution = pCameraInfo->dResolution / sResult->dMagnification;
|
sResult->bDigitalZoom = FALSE;
|
|
pRcpUserDefectInfo = pRsRcpReviewInfo->GetRcpUserDefectInfo(pNode->nTotalIndex);
|
if (pRcpUserDefectInfo == NULL) continue;
|
|
if(strGlassLastName.Compare(_T("B")) == 0 || strGlassLastName.Compare(_T("b")) == 0) sResult->strCellID = pRcpUserDefectInfo->GetCellId2();
|
else sResult->strCellID = pRcpUserDefectInfo->GetCellId();
|
|
sResult->nReflow_CellIndex = pRcpUserDefectInfo->m_nReflowCellIndex;
|
|
pReviewResult->AddSReviewResult(*sResult);
|
|
nResultIdx++;
|
}
|
|
pScheduleResult->ResizeScheduleResult(nSize);
|
}
|
|
int CSequenceProcessor_CSOT::GetCorrectMoudleStatusIdex(CPathSchedulerResult* pReviewScheduleResult, int nModuleType)
|
{
|
int nModuleStatusCount = m_pSP2P->ISP2P_GetModuleStatusCount();
|
std::vector<int> vecModuleIdx;
|
std::vector<int> vecGantryIdx;
|
std::vector<int> vecGantryPointX;
|
std::vector<int> vecHeaderIdx;
|
|
for(int nModuleIdx = 0; nModuleIdx < nModuleStatusCount; nModuleIdx++)
|
{
|
CModuleStatus* pModuleStatus = m_pSP2P->ISP2P_GetModuleStatus(nModuleIdx);
|
if(pModuleStatus == NULL) continue;
|
if(pModuleStatus->GetModuleType() == nModuleType)
|
{
|
vecModuleIdx.push_back(nModuleIdx);
|
}
|
}
|
|
for(int nIdx = 0; nIdx < vecModuleIdx.size(); nIdx++)
|
{
|
CModuleStatus* pModuleStatus = m_pSP2P->ISP2P_GetModuleStatus(nIdx);
|
if(pModuleStatus == NULL) continue;
|
//pModuleStatus->GetGantryIndex()
|
if(!IntVectorFinder(vecGantryIdx, pModuleStatus->GetGantryIndex()))
|
{
|
vecGantryIdx.push_back(pModuleStatus->GetGantryIndex());
|
vecGantryPointX.push_back( (int)pModuleStatus->GetMotorPosition()->dGlassPosX );
|
}
|
// if(!IntVectorFinder(vecHeaderIdx, pModuleStatus->GetHeaderIndex()))
|
// {
|
// vecHeaderIdx.push_back(pModuleStatus->GetHeaderIndex());
|
// }
|
}
|
|
// Gantry Sorting
|
int nMinPoint;
|
int nMinIdx;
|
for(int nIdx = 0; nIdx < vecGantryIdx.size(); nIdx++)
|
{
|
nMinPoint = vecGantryPointX.at(nIdx);
|
nMinIdx = nIdx;
|
for(int nIdx2 = nIdx; nIdx2 < vecGantryIdx.size(); nIdx2++)
|
{
|
if(vecGantryPointX.at(nIdx2) < nMinPoint)
|
{
|
nMinPoint = vecGantryPointX.at(nIdx2);
|
nMinIdx = nIdx2;
|
}
|
}
|
std::swap(vecGantryPointX.at(nIdx), vecGantryPointX.at(nMinIdx));
|
std::swap(vecGantryIdx.at(nIdx), vecGantryIdx.at(nMinIdx));
|
}
|
|
return 1;
|
}
|
|
BOOL CSequenceProcessor_CSOT::IntVectorFinder(std::vector<int> TargetData, int FindData)
|
{
|
for(std::vector<int>::iterator It = TargetData.begin(); It != TargetData.end(); It++)
|
{
|
if(FindData == *It) return TRUE;
|
}
|
return FALSE;
|
}
|
|
/*bool CSequenceProcessor_CSOT::sortstruct::CompareModuleStatusX(int i, int j)
|
{
|
CModuleStatus* pLeftModuleStatus = pSequenceProcessor->m_pSP2P->ISP2P_GetModuleStatus(i);
|
CModuleStatus* pRightModuleStatus = pSequenceProcessor->m_pSP2P->ISP2P_GetModuleStatus(j);
|
|
if(pLeftModuleStatus == NULL || pRightModuleStatus == NULL)
|
{
|
return false;
|
}
|
double LGlassX = pLeftModuleStatus->GetMotorPosition()->dGlassPosX;
|
double RGlassX = pRightModuleStatus->GetMotorPosition()->dGlassPosX;
|
|
if(LGlassX < RGlassX) return true;
|
else return false;
|
}*/
|
bool CSequenceProcessor_CSOT::CompareModuleStatusX::operator()(int i, int j)
|
{
|
CModuleStatus* pLeftModuleStatus = pSequenceProcessor->m_pSP2P->ISP2P_GetModuleStatus(i);
|
CModuleStatus* pRightModuleStatus = pSequenceProcessor->m_pSP2P->ISP2P_GetModuleStatus(j);
|
|
if(pLeftModuleStatus == NULL || pRightModuleStatus == NULL)
|
{
|
return false;
|
}
|
double LGlassX = pLeftModuleStatus->GetMotorPosition()->dGlassPosX;
|
double RGlassX = pRightModuleStatus->GetMotorPosition()->dGlassPosX;
|
CGlassResult* pGlassResult = pSequenceProcessor->m_pSP2P->ISP2P_GetCurrentGlassResult();
|
if(pGlassResult == NULL) return false;
|
|
if(pGlassResult->GetOriginDir() == 0 || pGlassResult->GetOriginDir() == 2)
|
{
|
if(LGlassX < RGlassX) return true;
|
else return false;
|
}
|
else
|
{
|
if(LGlassX > RGlassX) return true;
|
else return false;
|
}
|
}
|
|
bool CSequenceProcessor_CSOT::CompareModuleStatusY::operator()(int i, int j)
|
{
|
CModuleStatus* pLeftModuleStatus = pSequenceProcessor->m_pSP2P->ISP2P_GetModuleStatus(i);
|
CModuleStatus* pRightModuleStatus = pSequenceProcessor->m_pSP2P->ISP2P_GetModuleStatus(j);
|
|
if(pLeftModuleStatus == NULL || pRightModuleStatus == NULL)
|
{
|
return false;
|
}
|
double LGlassY = pLeftModuleStatus->GetMotorPosition()->dGlassPosY;
|
double RGlassY = pRightModuleStatus->GetMotorPosition()->dGlassPosY;
|
|
//if(LGlassY < RGlassY) return true;
|
//else return false;
|
CGlassResult* pGlassResult = pSequenceProcessor->m_pSP2P->ISP2P_GetCurrentGlassResult();
|
if(pGlassResult == NULL) return false;
|
|
if(pGlassResult->GetOriginDir() == 2 || pGlassResult->GetOriginDir() == 3)
|
{
|
if(LGlassY < RGlassY) return true;
|
else return false;
|
}
|
else
|
{
|
if(LGlassY > RGlassY) return true;
|
else return false;
|
}
|
}
|
|
bool CSequenceProcessor_CSOT::CompareReviewResultX::operator()(CReviewResult i, CReviewResult j)
|
{
|
SReviewResult* pLeftReviewResult = i.GetSReviewResult(0);
|
SReviewResult* pRightReviewResult = j.GetSReviewResult(0);
|
|
if(pLeftReviewResult == NULL || pRightReviewResult == NULL)
|
{
|
return false;
|
}
|
|
int LPointX = pLeftReviewResult->nUMOriginX;
|
int RPointX = pRightReviewResult->nUMOriginX;
|
|
// if(LPointX < RPointX) return true;
|
|
// return false;
|
|
CGlassResult* pGlassResult = pSequenceProcessor->m_pSP2P->ISP2P_GetCurrentGlassResult();
|
if(pGlassResult == NULL) return false;
|
|
if(pGlassResult->GetOriginDir() == 0 || pGlassResult->GetOriginDir() == 2)
|
{
|
if(LPointX < RPointX) return true;
|
else return false;
|
}
|
else
|
{
|
if(LPointX > RPointX) return true;
|
else return false;
|
}
|
}
|
|
bool CSequenceProcessor_CSOT::CompareReviewResultY::operator()(CReviewResult i, CReviewResult j)
|
{
|
SReviewResult* pLeftReviewResult = i.GetSReviewResult(0);
|
SReviewResult* pRightReviewResult = j.GetSReviewResult(0);
|
|
if(pLeftReviewResult == NULL || pRightReviewResult == NULL)
|
{
|
return false;
|
}
|
|
int LPointY = pLeftReviewResult->nUMOriginY;
|
int RPointY = pRightReviewResult->nUMOriginY;
|
|
// if(LPointY < RPointY) return true;
|
|
// return false;
|
CGlassResult* pGlassResult = pSequenceProcessor->m_pSP2P->ISP2P_GetCurrentGlassResult();
|
if(pGlassResult == NULL) return false;
|
|
if(pGlassResult->GetOriginDir() == 2 || pGlassResult->GetOriginDir() == 3)
|
{
|
if(LPointY < RPointY) return true;
|
else return false;
|
}
|
else
|
{
|
if(LPointY > RPointY) return true;
|
else return false;
|
}
|
}
|
|
bool CSequenceProcessor_CSOT::CompareWsiResultX::operator()(CReviewResult i, CReviewResult j)
|
{
|
SReviewResult* pLeftReviewResult = i.GetSReviewResult(0);
|
SReviewResult* pRightReviewResult = j.GetSReviewResult(0);
|
|
if(pLeftReviewResult == NULL || pRightReviewResult == NULL)
|
{
|
return false;
|
}
|
|
int LPointX = pLeftReviewResult->nUMOriginX;
|
int RPointX = pRightReviewResult->nUMOriginX;
|
|
// if(LPointX < RPointX) return true;
|
|
// return false;
|
CGlassResult* pGlassResult = pSequenceProcessor->m_pSP2P->ISP2P_GetCurrentGlassResult();
|
if(pGlassResult == NULL) return false;
|
|
if(pGlassResult->GetOriginDir() == 0 || pGlassResult->GetOriginDir() == 2)
|
{
|
if(LPointX < RPointX) return true;
|
else return false;
|
}
|
else
|
{
|
if(LPointX > RPointX) return true;
|
else return false;
|
}
|
|
}
|
|
bool CSequenceProcessor_CSOT::CompareWsiResultY::operator()(CReviewResult i, CReviewResult j)
|
{
|
SReviewResult* pLeftReviewResult = i.GetSReviewResult(0);
|
SReviewResult* pRightReviewResult = j.GetSReviewResult(0);
|
|
if(pLeftReviewResult == NULL || pRightReviewResult == NULL)
|
{
|
return false;
|
}
|
|
int LPointY = pLeftReviewResult->nUMOriginY;//.nUMOriginY;
|
int RPointY = pRightReviewResult->nUMOriginY;
|
|
// if(LPointY < RPointY) return true;
|
|
// return false;
|
|
CGlassResult* pGlassResult = pSequenceProcessor->m_pSP2P->ISP2P_GetCurrentGlassResult();
|
if(pGlassResult == NULL) return false;
|
|
if(pGlassResult->GetOriginDir() == 2 || pGlassResult->GetOriginDir() == 3)
|
{
|
if(LPointY < RPointY) return true;
|
else return false;
|
}
|
else
|
{
|
if(LPointY > RPointY) return true;
|
else return false;
|
}
|
}
|
|
void CSequenceProcessor_CSOT::SetModuleStatusSReviewProcessor(CReviewResult* pReviewResult, int nModuleIdx)
|
{
|
int nSReviewResultCount = pReviewResult->GetSReviewResultCount();
|
for(int nSReviewIndx = 0; nSReviewIndx < nSReviewResultCount; nSReviewIndx++)
|
{
|
SReviewResult* pSReviewResult = pReviewResult->GetSReviewResult(nSReviewIndx);
|
if(pSReviewResult == NULL) continue ;
|
|
pSReviewResult->nModuleIdx = nModuleIdx;
|
}
|
}
|
|
void CSequenceProcessor_CSOT::SetModuleStatusSWsiProcessor(CReviewResult* pWsiResult, int nModuleIdx)
|
{
|
int nSWsiResultCount = pWsiResult->GetSReviewResultCount();
|
for(int nSWsiIndx = 0; nSWsiIndx < nSWsiResultCount; nSWsiIndx++)
|
{
|
SReviewResult* pSWsiResult = pWsiResult->GetSReviewResult(nSWsiIndx);
|
if(pSWsiResult == NULL) continue ;
|
|
pSWsiResult->nModuleIdx = nModuleIdx;
|
}
|
}
|
|
int CSequenceProcessor_CSOT::SetModuleStatusForReviewResult(VectorReviewResult* pVecReviewResult, int nModuleType)
|
{
|
if(pVecReviewResult->size() < 2) return 0;
|
int nModuleStatusCount = m_pSP2P->ISP2P_GetModuleStatusCount(nModuleType);
|
std::vector<int> vecModuleIdx;
|
std::vector<int> vecReviewIdx;
|
std::vector<int> vecGantryIdx;
|
std::vector<int> vecHeaderIdx;
|
|
//sortstruct CompareFcuntions(this);
|
|
for(int nModuleIdx = 0; nModuleIdx < m_pSP2P->ISP2P_GetModuleStatusCount(); nModuleIdx++)
|
{
|
CModuleStatus* pModuleStatus = m_pSP2P->ISP2P_GetModuleStatus(nModuleIdx);
|
if(pModuleStatus == NULL) continue;
|
if(pModuleStatus->GetModuleType() & nModuleType)
|
{
|
vecModuleIdx.push_back(nModuleIdx);
|
}
|
}
|
|
// Get Gantry, Header Count
|
for(int nIdx = 0; nIdx < vecModuleIdx.size(); nIdx++)
|
{
|
CModuleStatus* pModuleStatus = m_pSP2P->ISP2P_GetModuleStatus(vecModuleIdx.at(nIdx));
|
if(pModuleStatus == NULL) continue;
|
//pModuleStatus->GetGantryIndex()
|
if(!IntVectorFinder(vecGantryIdx, pModuleStatus->GetGantryIndex()))
|
{
|
vecGantryIdx.push_back(pModuleStatus->GetGantryIndex());
|
}
|
if(!IntVectorFinder(vecHeaderIdx, pModuleStatus->GetHeaderIndex()))
|
{
|
vecHeaderIdx.push_back(pModuleStatus->GetHeaderIndex());
|
}
|
}
|
// Gantry Sorting
|
std::sort(vecModuleIdx.begin(), vecModuleIdx.end(), CompareModuleStatusX(this));
|
//std::sort(vecModuleIdx.begin(), vecModuleIdx.end());
|
|
// Header Sorting
|
for(int nIdx = 0; nIdx < nModuleStatusCount; nIdx += (int)vecHeaderIdx.size())
|
{
|
std::vector<int> vecTmp;
|
for(int nCount = 0; nCount < vecHeaderIdx.size(); nCount++)
|
{
|
vecTmp.push_back(vecModuleIdx.at(nIdx + nCount));
|
}
|
|
std::sort(vecTmp.begin(), vecTmp.end(), CompareModuleStatusY(this));
|
|
for(int nCount = 0; nCount < vecHeaderIdx.size(); nCount++)
|
{
|
vecModuleIdx.at(nIdx + nCount) = vecTmp.at(nCount);
|
}
|
}
|
|
//pVecReviewResult->at(0).GetSReviewResult(0)->nUMOriginX;
|
|
std::sort(pVecReviewResult->begin(), pVecReviewResult->end(), CompareReviewResultX(this));
|
|
for(int nIdx = 0; nIdx < nModuleStatusCount; nIdx += (int)vecHeaderIdx.size())
|
{
|
VectorReviewResult vecTmp;
|
for(int nCount = 0; nCount < vecHeaderIdx.size(); nCount++)
|
{
|
vecTmp.push_back(pVecReviewResult->at(nIdx + nCount));
|
}
|
|
std::sort(vecTmp.begin(), vecTmp.end(), CompareReviewResultY(this));
|
|
for(int nCount = 0; nCount < vecHeaderIdx.size(); nCount++)
|
{
|
pVecReviewResult->at(nIdx + nCount) = vecTmp.at(nCount);
|
}
|
}
|
|
for(int nIdx = 0; nIdx < nModuleStatusCount; nIdx++)
|
{
|
pVecReviewResult->at(nIdx).SetModuleIndex(vecModuleIdx.at(nIdx));
|
SetModuleStatusSReviewProcessor(&pVecReviewResult->at(nIdx), vecModuleIdx.at(nIdx));
|
}
|
|
return 1;
|
}
|
|
int CSequenceProcessor_CSOT::SetModuleStatusForWsiResult(VectorReviewResult* pVecWsiResult, int nModuleType)
|
{
|
if(pVecWsiResult->size() < 2) return 0;
|
int nModuleStatusCount = m_pSP2P->ISP2P_GetModuleStatusCount(nModuleType);
|
std::vector<int> vecModuleIdx;
|
std::vector<int> vecReviewIdx;
|
std::vector<int> vecGantryIdx;
|
std::vector<int> vecHeaderIdx;
|
|
//sortstruct CompareFcuntions(this);
|
|
for(int nModuleIdx = 0; nModuleIdx < m_pSP2P->ISP2P_GetModuleStatusCount(); nModuleIdx++)
|
{
|
CModuleStatus* pModuleStatus = m_pSP2P->ISP2P_GetModuleStatus(nModuleIdx);
|
if(pModuleStatus == NULL) continue;
|
if(pModuleStatus->GetModuleType() & nModuleType)
|
{
|
vecModuleIdx.push_back(nModuleIdx);
|
}
|
}
|
|
// Get Gantry, Header Count
|
for(int nIdx = 0; nIdx < vecModuleIdx.size(); nIdx++)
|
{
|
CModuleStatus* pModuleStatus = m_pSP2P->ISP2P_GetModuleStatus(vecModuleIdx.at(nIdx));
|
if(pModuleStatus == NULL) continue;
|
//pModuleStatus->GetGantryIndex()
|
if(!IntVectorFinder(vecGantryIdx, pModuleStatus->GetGantryIndex()))
|
{
|
vecGantryIdx.push_back(pModuleStatus->GetGantryIndex());
|
}
|
if(!IntVectorFinder(vecHeaderIdx, pModuleStatus->GetHeaderIndex()))
|
{
|
vecHeaderIdx.push_back(pModuleStatus->GetHeaderIndex());
|
}
|
}
|
// Gantry Sorting
|
std::sort(vecModuleIdx.begin(), vecModuleIdx.end(), CompareModuleStatusX(this));
|
//std::sort(vecModuleIdx.begin(), vecModuleIdx.end());
|
|
// Header Sorting
|
for(int nIdx = 0; nIdx < nModuleStatusCount; nIdx += (int)vecHeaderIdx.size())
|
{
|
std::vector<int> vecTmp;
|
for(int nCount = 0; nCount < vecHeaderIdx.size(); nCount++)
|
{
|
vecTmp.push_back(vecModuleIdx.at(nIdx + nCount));
|
}
|
|
std::sort(vecTmp.begin(), vecTmp.end(), CompareModuleStatusY(this));
|
|
for(int nCount = 0; nCount < vecHeaderIdx.size(); nCount++)
|
{
|
vecModuleIdx.at(nIdx + nCount) = vecTmp.at(nCount);
|
}
|
}
|
|
//pVecReviewResult->at(0).GetSReviewResult(0)->nUMOriginX;
|
|
std::sort(pVecWsiResult->begin(), pVecWsiResult->end(), CompareWsiResultX(this));
|
|
for(int nIdx = 0; nIdx < nModuleStatusCount; nIdx += (int)vecHeaderIdx.size())
|
{
|
VectorReviewResult vecTmp;
|
for(int nCount = 0; nCount < vecHeaderIdx.size(); nCount++)
|
{
|
vecTmp.push_back(pVecWsiResult->at(nIdx + nCount));
|
}
|
|
std::sort(vecTmp.begin(), vecTmp.end(), CompareWsiResultY(this));
|
|
for(int nCount = 0; nCount < vecHeaderIdx.size(); nCount++)
|
{
|
pVecWsiResult->at(nIdx + nCount) = vecTmp.at(nCount);
|
}
|
}
|
|
for(int nIdx = 0; nIdx < nModuleStatusCount; nIdx++)
|
{
|
pVecWsiResult->at(nIdx).SetModuleIndex(vecModuleIdx.at(nIdx));
|
SetModuleStatusSWsiProcessor(&pVecWsiResult->at(nIdx), vecModuleIdx.at(nIdx));
|
}
|
|
return 1;
|
}
|
|
BOOL CSequenceProcessor_CSOT::CalculateReviewPathPlan(CDefectPicker* pDefectPicker, CGlassResult *pGlassResult)
|
{
|
CPathScheduler *pReviewScheduler = m_pSP2P->ISP2P_GetReviewScheduler();
|
if (pGlassResult==NULL || pReviewScheduler==NULL || pDefectPicker==NULL) return FALSE;
|
const CRsRcpReviewInfo* pRcpReviewInfo = m_pSP2P->ISP2P_Recipe_GetRsRcpReviewInfo();
|
const CRcpSchedulingInfo* pScheduleInfo = pRcpReviewInfo->GetRcpSchedulingInfo();
|
|
|
int nTotalModuleCount = m_pSP2P->ISP2P_GetModuleStatusCount();
|
int nReviewModuleCount = m_pSP2P->ISP2P_GetModuleStatusCount(ModuleType_Review);
|
int nPointCount = pDefectPicker->GetPickingResultCount();
|
|
// point is zero?
|
if (nPointCount==0) return TRUE;
|
|
// get current glass pos review cameras 181030
|
VectorPathData vecStartPathData;
|
for(int nIdx=0 ; nIdx<nTotalModuleCount ; nIdx++)
|
{
|
const CModuleStatus *pModuleStatus = Module_GetModuleStatus(nIdx);
|
if (pModuleStatus==NULL) continue;
|
|
if ( (pModuleStatus->GetModuleType() & ModuleType_Review) != ModuleType_Review)
|
{
|
continue;
|
}
|
|
const SMotorPosition* pMotorPosition = pModuleStatus->GetMotorPosition();
|
if (pMotorPosition==NULL) continue;
|
|
SPathData ptStartPath;
|
ptStartPath.nIndex = nIdx; // module index
|
ptStartPath.nPosX = (LONG)(pMotorPosition->dGlassPosX * 1000);
|
ptStartPath.nPosY = (LONG)(pMotorPosition->dGlassPosY * 1000);
|
|
if (ptStartPath.nPosX < 0) ptStartPath.nPosX = 1;
|
if (ptStartPath.nPosY < 0) ptStartPath.nPosY = 1;
|
|
if (nIdx == 1)
|
{
|
ptStartPath.nPosX = 925000; // lmk test
|
}
|
|
vecStartPathData.push_back(ptStartPath);
|
}
|
int a = pDefectPicker->GetPickingResultCount();
|
// get review point result
|
VectorPathData vecPathData;
|
for (int nPosIdx=0; nPosIdx<pDefectPicker->GetPickingResultCount(); nPosIdx++)
|
{
|
const SReviewResult *pSReviewResult = pDefectPicker->GetPickingResult(nPosIdx);
|
|
if (pSReviewResult==NULL) continue;
|
|
|
if(pSReviewResult->nStackType == 1) continue; // ½ºÅÃÀº ´Ù ´ÙÀ½¿¡ÇÏÁî¾Æ
|
else if(pSReviewResult->nStackType == 2) continue; // 1==½ºÅà Àε¥ ¸®ºä ¾ÈÇÑ°Å 2==½ºÅÃÀε¥ ¸®ºä ÇÑ°Å
|
|
SPathData pathData(pSReviewResult->nUMOriginX, pSReviewResult->nUMOriginY, pSReviewResult->nResultIdx);
|
vecPathData.push_back(pathData);
|
}
|
// 190405 SJB, StackPathS
|
VectorPathData vecStackPathData;
|
for (int nPosIdx=0; nPosIdx<nPointCount; nPosIdx++)
|
{
|
const SReviewResult *pSReviewResult = pDefectPicker->GetPickingResult(nPosIdx);
|
if (pSReviewResult==NULL) continue;
|
|
if(pSReviewResult->nStackType ==0) continue;
|
|
|
SPathData pathData(pSReviewResult->nUMOriginX, pSReviewResult->nUMOriginY, pSReviewResult->nResultIdx);
|
vecStackPathData.push_back(pathData);
|
}
|
|
BOOL bUseShortest = TRUE;
|
|
if (pRcpReviewInfo)
|
{
|
|
if (pScheduleInfo)
|
bUseShortest = pScheduleInfo->GetShortestPath();
|
}
|
|
// calculate path
|
int nSchedulingCount = 0;
|
|
// 190405 SJB, Double PathScheduling
|
if(int(vecStackPathData.size()) != 0 && int(vecPathData.size()) == 0) nSchedulingCount = pReviewScheduler->PathScheduling(vecStackPathData, vecStartPathData);
|
else if(int(vecStackPathData.size()) != 0 && int(vecPathData.size()) !=0) nSchedulingCount = pReviewScheduler->PathScheduling(vecPathData, vecStackPathData, vecStartPathData);
|
else nSchedulingCount = pReviewScheduler->PathScheduling(vecPathData, vecStartPathData);
|
|
|
if (nSchedulingCount>0)
|
{
|
m_pSP2P->ISP2P_DisplayMessage(_T("[ReviewScheduler] CalculatePath"));
|
|
for(int nModuleIdx=0; nModuleIdx<nReviewModuleCount; nModuleIdx++)
|
{
|
CPathSchedulerResult *pScheduleResult = pReviewScheduler->GetPathSchedulerResult(nModuleIdx);
|
if (pScheduleResult==NULL) continue;
|
|
// add review result
|
pGlassResult->AddReviewResult(CReviewResult(nModuleIdx));
|
|
// get review result
|
CReviewResult *pReviewResult = pGlassResult->GetReviewResult(nModuleIdx);
|
if(pReviewResult == NULL) return FALSE;
|
|
// get sreview result
|
ReviewScheduler_ResizeReviewResult(pScheduleResult, pReviewResult, pDefectPicker, pScheduleResult->GetPathSchedulerResultCount());
|
|
// add review schedule result
|
pGlassResult->AddReviewScheduleResult(*pScheduleResult);
|
|
CakAOISharedSystem* pAOIShared = CReviewInterface::GetInstance(); //20191017
|
pProtocolData =pAOIShared->getReviewProtocol();
|
|
pProtocolData->SetPlanDefectNum(nModuleIdx,pScheduleResult->GetPathSchedulerResultCount());
|
SSchedulerResult *pNode;
|
for (int i=0;i<pScheduleResult->GetPathSchedulerResultCount();i++)
|
{
|
pNode = pScheduleResult->GetPathSchedulerResult(i);
|
pProtocolData->SetPlanReviewPos(nModuleIdx,i,int(pNode->dPositionX*1000), int(pNode->dPositionY*1000));
|
}
|
|
// CString strFilename = _T("");
|
// strFilename.Format(_T("c:\\%d_module_review_path.csv"), nModuleIdx);
|
// CPathSchedulerResult::SaveResult(strFilename, *pScheduleResult);
|
}
|
}
|
else
|
{
|
return FALSE;
|
}
|
|
return TRUE;
|
}
|
|
BOOL CSequenceProcessor_CSOT::CalculateUserPathPlan(CPrioritySorter* pPrioritySorter, CGlassResult *pGlassResult)
|
{
|
CPathScheduler *pReviewScheduler = m_pSP2P->ISP2P_GetReviewScheduler();
|
if (pGlassResult==NULL || pReviewScheduler==NULL || pPrioritySorter==NULL) return FALSE;
|
|
int nTotalModuleCount = m_pSP2P->ISP2P_GetModuleStatusCount();
|
int nReviewModuleCount = m_pSP2P->ISP2P_GetModuleStatusCount(ModuleType_Review);
|
int nPointCount = pPrioritySorter->GetSortingResultUserCount();
|
|
// point is zero?
|
if (nPointCount==0) return TRUE;
|
|
// get current glass pos review cameras
|
VectorPathData vecStartPathData;
|
for(int nIdx=0 ; nIdx<nTotalModuleCount ; nIdx++)
|
{
|
const CModuleStatus *pModuleStatus = Module_GetModuleStatus(nIdx);
|
if (pModuleStatus==NULL) continue;
|
|
if ( (pModuleStatus->GetModuleType() & ModuleType_Review) != ModuleType_Review)
|
{
|
continue;
|
}
|
|
const SMotorPosition* pMotorPosition = pModuleStatus->GetMotorPosition();
|
if (pMotorPosition==NULL) continue;
|
|
SPathData ptStartPath;
|
ptStartPath.nIndex = nIdx; // module index
|
ptStartPath.nPosX = (LONG)(pMotorPosition->dGlassPosX * 1000);
|
ptStartPath.nPosY = (LONG)(pMotorPosition->dGlassPosY * 1000);
|
vecStartPathData.push_back(ptStartPath);
|
}
|
|
const CSystemInfo *pSystemInfo = m_pSP2P->ISP2P_System_GetSystemInfo();
|
|
int nMachine = pSystemInfo->m_nMachineType;
|
|
|
const CModuleStatus *pModuleStatus = Module_GetModuleStatus(0);
|
const SCameraControl *pCameraControl = pModuleStatus->GetCameraControl();
|
const SMagnificInfo *pModuleMag = pModuleStatus->GetMagnificInfo(pCameraControl->nZoomLevel);
|
|
int nPositionX;
|
int nPositionY;
|
// get user point result
|
VectorPathData vecPathData;
|
for (int nPosIdx=0; nPosIdx<nPointCount; nPosIdx++)
|
{
|
const SReviewResult *pSReviewResult = pPrioritySorter->GetSortingResultUser(nPosIdx);
|
if (pSReviewResult==NULL) continue;
|
|
nPositionX = pSReviewResult->nUMOriginX;
|
nPositionY = pSReviewResult->nUMOriginY;
|
|
SPathData pathData( nPositionX,nPositionY,pSReviewResult->nResultIdx);
|
vecPathData.push_back(pathData);
|
}
|
|
// calculate shortest path
|
if (pReviewScheduler->PathScheduling(vecPathData, vecStartPathData)>0)
|
{
|
m_pSP2P->ISP2P_DisplayMessage(_T("[ReviewScheduler] CalculatePath"));
|
|
for(int nModuleIdx=0; nModuleIdx<nReviewModuleCount; nModuleIdx++)
|
{
|
CPathSchedulerResult *pScheduleResult = pReviewScheduler->GetPathSchedulerResult(nModuleIdx);
|
if (pScheduleResult==NULL) continue;
|
|
// add user result
|
pGlassResult->AddUserResult(CReviewResult(nModuleIdx));
|
|
// get user result
|
CReviewResult *pReviewResult = pGlassResult->GetUserResult(nModuleIdx);
|
if(pReviewResult == NULL) return FALSE;
|
|
// get sreviewresult
|
ReviewScheduler_ResizeUserResult(pScheduleResult, pReviewResult, pPrioritySorter, pScheduleResult->GetPathSchedulerResultCount());
|
|
// add user schedule result
|
pGlassResult->AddUserScheduleResult(*pScheduleResult);
|
|
//°øÀ¯¸Þ¸ð¸®¿¡ ä¿öÁÙ ¸®ºäÇÒ °¹¼ö¿Í µðÆå ÁÂÇ¥¸¦ ±¸Á¶Ã¼¿¡ ä¿öÁÖ´Â Àå¼Ò
|
{
|
|
|
CakAOISharedSystem* pAOIShared = CReviewInterface::GetInstance(); //20191017
|
pProtocolData =pAOIShared->getReviewProtocol();
|
|
int nStIndex = pProtocolData->m_ModuleData[nModuleIdx].m_nPlanDefectCount;
|
pProtocolData->m_ModuleData[nModuleIdx].m_nPlanDefectCount += pScheduleResult->GetPathSchedulerResultCount();
|
SSchedulerResult *pNode;
|
for (int i=0;i<pScheduleResult->GetPathSchedulerResultCount();i++)
|
{
|
pNode = pScheduleResult->GetPathSchedulerResult(i);
|
pProtocolData->SetPlanReviewPos(nModuleIdx,nStIndex+i, int(pNode->dPositionX*1000), int(pNode->dPositionY*1000));
|
}
|
}
|
|
// CString strFilename = _T("");
|
// strFilename.Format(_T("c:\\%d_module_user_path.csv"), nModuleIdx);
|
// CPathSchedulerResult::SaveResult(strFilename, *pScheduleResult);
|
}
|
}
|
else
|
{
|
return FALSE;
|
}
|
|
return TRUE;
|
}
|
|
BOOL CSequenceProcessor_CSOT::CalculateWsiPathPlan(CDefectPicker* pDefectPicker, CGlassResult *pGlassResult)
|
{
|
CPathScheduler *pReviewScheduler = m_pSP2P->ISP2P_GetReviewScheduler();
|
if (pGlassResult==NULL || pReviewScheduler==NULL || pDefectPicker==NULL) return FALSE;
|
|
int nTotalModuleCount = m_pSP2P->ISP2P_GetModuleStatusCount();
|
int nReviewModuleCount = m_pSP2P->ISP2P_GetModuleStatusCount(ModuleType_Wsi);
|
int nPointCount = pDefectPicker->GetPickingResultWsiCount();
|
|
// point is zero?
|
if (nPointCount==0) return TRUE;
|
|
// get current glass pos review cameras
|
VectorPathData vecStartPathData;
|
for(int nIdx=0 ; nIdx<nTotalModuleCount ; nIdx++)
|
{
|
const CModuleStatus *pModuleStatus = Module_GetModuleStatus(nIdx);
|
if (pModuleStatus==NULL) continue;
|
|
if ( (pModuleStatus->GetModuleType() & ModuleType_Wsi) != ModuleType_Wsi)
|
{
|
continue;
|
}
|
|
const SMotorPosition* pMotorPosition = pModuleStatus->GetMotorPosition();
|
if (pMotorPosition==NULL) continue;
|
|
SPathData ptStartPath;
|
ptStartPath.nIndex = nIdx; // module index
|
ptStartPath.nPosX = (LONG)(pMotorPosition->dGlassPosX * 1000);
|
ptStartPath.nPosY = (LONG)(pMotorPosition->dGlassPosY * 1000);
|
vecStartPathData.push_back(ptStartPath);
|
}
|
|
// get wsi point result
|
VectorPathData vecPathData;
|
for (int nPosIdx=0; nPosIdx<nPointCount; nPosIdx++)
|
{
|
const SReviewResult *pSWsiResult = pDefectPicker->GetPickingResultWsi(nPosIdx);
|
if (pSWsiResult==NULL) continue;
|
|
if(pSWsiResult->nStackType == 1) continue; // ½ºÅÃÀº ´Ù ´ÙÀ½¿¡ÇÏÁî¾Æ
|
else if(pSWsiResult->nStackType == 2) continue; // 1==½ºÅà Àε¥ ¸®ºä ¾ÈÇÑ°Å 2==½ºÅÃÀε¥ ¸®ºä ÇÑ°Å
|
|
SPathData pathData(pSWsiResult->nUMOriginX, pSWsiResult->nUMOriginY, pSWsiResult->nResultIdx);
|
vecPathData.push_back(pathData);
|
}
|
|
VectorPathData vecStackPathData;;
|
for (int nPosIdx=0; nPosIdx<nPointCount; nPosIdx++)
|
{
|
const SReviewResult *pSWsiResult = pDefectPicker->GetPickingResultWsi(nPosIdx);
|
if (pSWsiResult==NULL) continue;
|
|
if(pSWsiResult->nStackType ==0) continue;
|
|
|
SPathData pathData(pSWsiResult->nUMOriginX, pSWsiResult->nUMOriginY, pSWsiResult->nResultIdx);
|
vecStackPathData.push_back(pathData);
|
}
|
|
// calculate path
|
int nSchedulingCount = 0;
|
|
// 190405 SJB, Double PathScheduling
|
if(int(vecStackPathData.size()) != 0 && int(vecPathData.size()) == 0) nSchedulingCount = pReviewScheduler->PathScheduling(vecStackPathData, vecStartPathData);
|
else if(int(vecStackPathData.size()) != 0 && int(vecPathData.size()) !=0) nSchedulingCount = pReviewScheduler->PathScheduling(vecPathData, vecStackPathData, vecStartPathData);
|
else nSchedulingCount = pReviewScheduler->PathScheduling(vecPathData, vecStartPathData);
|
|
|
if (nSchedulingCount>0)
|
{
|
for(int nModuleIdx=0; nModuleIdx<nReviewModuleCount; nModuleIdx++)
|
{
|
CPathSchedulerResult *pScheduleResult = pReviewScheduler->GetPathSchedulerResult(nModuleIdx);
|
if (pScheduleResult==NULL) continue;
|
|
// add wsi result
|
pGlassResult->AddWsiResult(CReviewResult(nModuleIdx));
|
|
// get wsi result
|
CReviewResult *pWsiResult = pGlassResult->GetWsiResult(nModuleIdx);
|
if(pWsiResult == NULL) return FALSE;
|
|
// get swsiresult
|
ReviewScheduler_ResizeWsiResult(pScheduleResult, pWsiResult, pDefectPicker, pScheduleResult->GetPathSchedulerResultCount());
|
|
// add wsi schedule result
|
pGlassResult->AddWsiScheduleResult(*pScheduleResult);
|
|
// CString strFilename = _T("");
|
// strFilename.Format(_T("c:\\%d_module_wsi_path.csv"), nModuleIdx);
|
// CPathSchedulerResult::SaveResult(strFilename, *pScheduleResult);
|
}
|
}
|
else
|
{
|
return FALSE;
|
}
|
|
return TRUE;
|
}
|
BOOL CSequenceProcessor_CSOT::CalculateReflowPathPlan( CPrioritySorter* pPrioritySorter, CGlassResult *pGlassResult )
|
{
|
CPathScheduler *pReviewScheduler = m_pSP2P->ISP2P_GetReviewScheduler();
|
if (pGlassResult==NULL || pReviewScheduler==NULL || pPrioritySorter==NULL) return FALSE;
|
|
int nTotalModuleCount = m_pSP2P->ISP2P_GetModuleStatusCount();
|
int nReviewModuleCount = m_pSP2P->ISP2P_GetModuleStatusCount(ModuleType_Review);
|
int nPointCount = pPrioritySorter->GetSortingResultReflowCount();
|
|
// point is zero?
|
if (nPointCount==0) return TRUE;
|
|
CRsRcpReviewInfo *pRsRcpReviewInfo = m_pSP2P->ISP2P_Recipe_GetRsRcpReviewInfo();
|
if (pRsRcpReviewInfo == NULL)
|
{
|
return -1;
|
}
|
|
// get current glass pos review cameras
|
VectorPathData vecStartPathData;
|
for(int nIdx=0 ; nIdx<nTotalModuleCount ; nIdx++)
|
{
|
const CModuleStatus *pModuleStatus = Module_GetModuleStatus(nIdx);
|
if (pModuleStatus==NULL) continue;
|
|
if ( (pModuleStatus->GetModuleType() & ModuleType_Review) != ModuleType_Review)
|
{
|
continue;
|
}
|
|
const SMotorPosition* pMotorPosition = pModuleStatus->GetMotorPosition();
|
if (pMotorPosition==NULL) continue;
|
|
SPathData ptStartPath;
|
ptStartPath.nIndex = nIdx; // module index
|
ptStartPath.nPosX = (LONG)(pMotorPosition->dGlassPosX * 1000);
|
ptStartPath.nPosY = (LONG)(pMotorPosition->dGlassPosY * 1000);
|
vecStartPathData.push_back(ptStartPath);
|
}
|
|
// get user point result
|
VectorPathData vecPathData;
|
for (int nPosIdx=0; nPosIdx<nPointCount; nPosIdx++)
|
{
|
const SReviewResult *pSReviewResult = pPrioritySorter->GetSortingResultReflow(nPosIdx);
|
if (pSReviewResult==NULL) continue;
|
|
SPathData pathData(pSReviewResult->nUMOriginX, pSReviewResult->nUMOriginY, pSReviewResult->nResultIdx);
|
vecPathData.push_back(pathData);
|
}
|
|
// calculate shortest path
|
if (pReviewScheduler->PathScheduling(vecPathData, vecStartPathData)>0)
|
{
|
m_pSP2P->ISP2P_DisplayMessage(_T("[ReviewScheduler] CalculatePath"));
|
|
for(int nModuleIdx=0; nModuleIdx<nReviewModuleCount; nModuleIdx++)
|
{
|
CPathSchedulerResult *pScheduleResult = pReviewScheduler->GetPathSchedulerResult(nModuleIdx);
|
if (pScheduleResult==NULL) continue;
|
|
// add reflow result
|
pGlassResult->AddReflowResult(CReviewResult(nModuleIdx));
|
|
// get user result
|
CReviewResult *pReviewResult = pGlassResult->GetReflowResult(nModuleIdx);
|
if(pReviewResult == NULL) return FALSE;
|
|
// get sreview result
|
ReviewScheduler_ResizeReflowResult(pScheduleResult, pReviewResult, pPrioritySorter, pScheduleResult->GetPathSchedulerResultCount());
|
|
// add user schedule result
|
pGlassResult->AddReflowScheduleRedult(*pScheduleResult);
|
|
// CString strFilename = _T("");
|
// strFilename.Format(_T("c:\\%d_module_reflow_path.csv"), nModuleIdx);
|
// CPathSchedulerResult::SaveResult(strFilename, *pScheduleResult);
|
}
|
}
|
else
|
{
|
return FALSE;
|
}
|
|
return TRUE;
|
}
|
void CSequenceProcessor_CSOT::GetAxisDirection(int nOrgGlass, int nOrgRecipe, int &nDirX, int& nDirY)
|
{
|
nDirX = 1; // same dir
|
if ( (nOrgGlass==GlassOriginDir_LeftTop || nOrgGlass==GlassOriginDir_LeftBottom) && (nOrgRecipe==GlassOriginDir_LeftTop || nOrgRecipe==GlassOriginDir_LeftBottom) )
|
{
|
nDirX = 1;
|
}
|
else if ( (nOrgGlass==GlassOriginDir_RightTop || nOrgGlass==GlassOriginDir_RightBottom) && (nOrgRecipe==GlassOriginDir_RightTop || nOrgRecipe==GlassOriginDir_RightBottom) )
|
{
|
nDirX = 1;
|
}
|
else
|
{
|
nDirX = -1;
|
}
|
|
nDirY = 1; // same dir
|
if ( (nOrgGlass==GlassOriginDir_LeftTop || nOrgGlass==GlassOriginDir_RightTop) && (nOrgRecipe==GlassOriginDir_LeftTop || nOrgRecipe==GlassOriginDir_RightTop) )
|
{
|
nDirY = 1;
|
}
|
else if ( (nOrgGlass==GlassOriginDir_LeftBottom || nOrgGlass==GlassOriginDir_RightBottom) && (nOrgRecipe==GlassOriginDir_LeftBottom || nOrgRecipe==GlassOriginDir_RightBottom) )
|
{
|
nDirY = 1;
|
}
|
else
|
{
|
nDirY = -1;
|
}
|
}
|
|
void CSequenceProcessor_CSOT::GetMeasureModuleIndex(int nDirX, int nDirY, int& nModuleIdx)
|
{
|
if (nDirX==-1 && nDirY==-1)
|
{
|
switch(nModuleIdx)
|
{
|
case 0:
|
nModuleIdx = 3;
|
break;
|
case 1:
|
nModuleIdx = 2;
|
break;
|
case 2:
|
nModuleIdx = 1;
|
break;
|
case 3:
|
nModuleIdx = 0;
|
break;
|
}
|
}
|
else if (nDirX==-1)
|
{
|
switch(nModuleIdx)
|
{
|
case 0:
|
nModuleIdx = 2;
|
break;
|
case 1:
|
nModuleIdx = 3;
|
break;
|
case 2:
|
nModuleIdx = 0;
|
break;
|
case 3:
|
nModuleIdx = 1;
|
break;
|
}
|
}
|
else if (nDirY==-1)
|
{
|
switch(nModuleIdx)
|
{
|
case 0:
|
nModuleIdx = 1;
|
break;
|
case 1:
|
nModuleIdx = 0;
|
break;
|
case 2:
|
nModuleIdx = 3;
|
break;
|
case 3:
|
nModuleIdx = 2;
|
break;
|
}
|
}
|
}
|
|
BOOL CSequenceProcessor_CSOT::CalculateMeasurePathPlan(CPrioritySorter* pPrioritySorter, CGlassResult *pGlassResult)
|
{
|
// CMeasureScheduler *pMeasureScheduler = m_pSP2P->ISP2P_GetMeasureScheduler();
|
CRsRcpMeasureInfo* pRsRcpMeasureInfo = m_pSP2P->ISP2P_Recipe_GetRsRcpMeasureInfo();
|
|
if (pGlassResult==NULL || pPrioritySorter==NULL || pRsRcpMeasureInfo==NULL) return FALSE;
|
|
int nPointCount = pPrioritySorter->GetSortingResultMeasureCount();
|
if (nPointCount<1) return TRUE;
|
|
// add measure result
|
int nSystemModuleCount = m_pSP2P->ISP2P_GetModuleStatusCount(ModuleType_Measure);
|
int nRecipeModuleCount = pRsRcpMeasureInfo->GetModuleCount();
|
int nResultCount = pRsRcpMeasureInfo->GetResultCount();
|
|
if (nSystemModuleCount!=nRecipeModuleCount) return FALSE;
|
|
// add measure result to glass result
|
for (int nModuleIdx=0; nModuleIdx<nRecipeModuleCount; nModuleIdx++)
|
{
|
pGlassResult->AddMeasureResult(CReviewResult(nModuleIdx));
|
|
CReviewResult *pReviewResult = pGlassResult->GetMeasureResult(nModuleIdx);
|
|
pReviewResult->ResizeReviewResult(nResultCount);
|
}
|
|
// add measure point to measure result
|
int nGlassDir = pGlassResult->GetOriginDir();
|
int nRecipeDir = pRsRcpMeasureInfo->GetGlassOriginDir();
|
|
int nAxisXDir = 1;
|
int nAxisYDir = 1;
|
GetAxisDirection(nGlassDir, nRecipeDir, nAxisXDir, nAxisYDir);
|
|
for (int nPointIdx=0; nPointIdx<nPointCount; nPointIdx++)
|
{
|
SReviewResult *pSourceResult = pPrioritySorter->GetSortingResultMeasure(nPointIdx);
|
if (pSourceResult==NULL) continue;
|
|
int nModuleIdx = pSourceResult->nModuleIdx;
|
|
// change module index from axis direction
|
GetMeasureModuleIndex(nAxisXDir, nAxisYDir, nModuleIdx);
|
|
SReviewResult *pTargetResult = pGlassResult->GetSMeasureResult(nModuleIdx, pSourceResult->nResultIdx);
|
if (pTargetResult==NULL) continue;
|
|
// copy
|
*pTargetResult = *pSourceResult;
|
|
// add recipe info
|
CModuleStatus *pModuleStatus = m_pSP2P->ISP2P_GetModuleStatus(nModuleIdx);
|
if (pModuleStatus==NULL) continue;
|
|
// get zoom info
|
int nZoomIdx = GetRealMagnification(nModuleIdx, pTargetResult->nZoomIdx);
|
SMagnificInfo *pMagnificInfo = pModuleStatus->GetMagnificInfo(nZoomIdx);
|
SCameraInfo *pCameraInfo = pModuleStatus->GetCameraInfo(0);
|
if (pMagnificInfo==NULL || pCameraInfo==NULL) continue;
|
|
// set info
|
pTargetResult->nZoomIdx = nZoomIdx;
|
pTargetResult->dMagnification = pMagnificInfo->dMagnification;
|
pTargetResult->dMeasureResolution = pCameraInfo->dResolution / pTargetResult->dMagnification;
|
pTargetResult->bDigitalZoom = FALSE;
|
}
|
|
return TRUE;
|
}
|
|
BOOL CSequenceProcessor_CSOT::MotorMotionEnd()
|
{
|
BOOL bMotionEnd = FALSE;
|
|
const CMotorControlInfo* pMotorInfo = m_pSP2P->ISP2P_System_GetMotorInfo();
|
if(pMotorInfo == NULL) return FALSE;
|
|
CMotorControl* pMotorControl = m_pSP2P->ISP2P_GetMotorControl();
|
if(pMotorControl == NULL) return FALSE;
|
|
while(!bMotionEnd)
|
{
|
int nGantryCount = pMotorInfo->GetMotorGantryAddrCount();
|
bMotionEnd = TRUE;
|
for(int nGantryIdx = 0; nGantryIdx < nGantryCount; nGantryIdx++)
|
{
|
const CMotorGantryAddr* pMotorGantryAddr = pMotorInfo->GetMotorGantryAddr(nGantryIdx);
|
if(pMotorGantryAddr == NULL) continue ;
|
int nAxisCount = pMotorGantryAddr->GetMotorAxisAddrCount();
|
for(int nAxisIdx = 0; nAxisIdx < nAxisCount; nAxisIdx++)
|
{
|
const CMotorAxisAddr* pMotorAxisAddr = pMotorGantryAddr->GetMotorAxisAddr(nAxisIdx);
|
if(pMotorAxisAddr == NULL) continue ;
|
int nCheckAddrass = pMotorAxisAddr->m_nStatusAddr;
|
long data = 0;
|
pMotorControl->ReadAddressValue(nCheckAddrass, data);
|
bMotionEnd = 1 & data;
|
if(!bMotionEnd) break;
|
}
|
if(!bMotionEnd) break;
|
}
|
}
|
|
g_pLog->DisplayMessage(_T("[Motor] Motion End!!"));
|
return TRUE;
|
}
|
|
BOOL CSequenceProcessor_CSOT::AllChangeMagnification(int nZoomIdx, int nCmd, int nPlanMode)
|
{
|
CGlassResult* pGlassResult = m_pSP2P->ISP2P_GetCurrentGlassResult();
|
if(pGlassResult == NULL) return FALSE;
|
|
CRsRcpReviewInfo* pRsRcpReviewInfo = NULL;
|
CRsRcpMeasureInfo* pRsRcpMeasureInfo = NULL;
|
switch(nPlanMode)
|
{
|
case CSOT_PlanReview:
|
case CSOT_PlanUser:
|
case CSOT_PlanWSI:
|
pRsRcpReviewInfo = m_pSP2P->ISP2P_Recipe_GetRsRcpReviewInfo();
|
break;
|
case CSOT_PlanReflow:
|
pRsRcpReviewInfo = m_pSP2P->ISP2P_Recipe_GetRsRcpReviewInfo();
|
break;
|
case CSOT_PlanMeasure:
|
pRsRcpMeasureInfo = m_pSP2P->ISP2P_Recipe_GetRsRcpMeasureInfo();
|
break;
|
}
|
|
if (nPlanMode!=CSOT_PlanMeasure && pRsRcpReviewInfo==NULL) return FALSE;
|
if (nPlanMode==CSOT_PlanMeasure && pRsRcpMeasureInfo==NULL) return FALSE;
|
|
int nModuleStatusCount = m_pSP2P->ISP2P_GetModuleStatusCount();
|
for(int nModuleIdx = 0; nModuleIdx < nModuleStatusCount; nModuleIdx++)
|
{
|
int nZoomIndex = -1;
|
switch(nPlanMode)
|
{
|
case CSOT_PlanReview:
|
{
|
const CRcpAFMRecipeInfo* pRcpAFMRecipeInfo = pRsRcpReviewInfo->GetRcpAFMRecipeInfo(nModuleIdx);
|
if(pRcpAFMRecipeInfo == NULL)
|
{
|
g_pLog->DisplayMessage(_T("[AllChangeMagnification] pRcpAFMRecipeInfo NULL Error !!"));
|
}
|
nZoomIndex = pRcpAFMRecipeInfo->GetZoomIndex();
|
break;
|
}
|
|
case CSOT_PlanUser:
|
{
|
const CRcpAFMRecipeInfo* pRcpAFMRecipeInfo = pRsRcpReviewInfo->GetRcpUserAFMRecipeInfo(nModuleIdx);
|
if(pRcpAFMRecipeInfo == NULL)
|
{
|
g_pLog->DisplayMessage(_T("[AllChangeMagnification] pRcpAFMRecipeInfo NULL Error !!"));
|
}
|
nZoomIndex = pRcpAFMRecipeInfo->GetZoomIndex();
|
break;
|
}
|
|
case CSOT_PlanWSI:
|
{
|
const CRcpAFMRecipeInfo* pRcpAFMRecipeInfo = pRsRcpReviewInfo->GetRcpWsiAFMRecipeInfo(nModuleIdx);
|
if(pRcpAFMRecipeInfo == NULL)
|
{
|
g_pLog->DisplayMessage(_T("[AllChangeMagnification] pRcpAFMRecipeInfo NULL Error !!"));
|
}
|
else
|
{
|
nZoomIndex = pRcpAFMRecipeInfo->GetZoomIndex();
|
}
|
break;
|
}
|
break;
|
// ¹Ì»ç¿ë
|
case CSOT_PlanMeasure:
|
{
|
const CRcpMeasureInfo *pRcpMeasureInfo = pRsRcpMeasureInfo->GetRcpMeasureInfo(0);
|
if(pRcpMeasureInfo == NULL)
|
{
|
g_pLog->DisplayMessage(_T("[AllChangeMagnification] pRcpAFMRecipeInfo NULL Error !!"));
|
}
|
|
if (pRsRcpMeasureInfo)
|
{
|
nZoomIndex = pRcpMeasureInfo->GetMagnificationIdx();
|
}
|
break;
|
}
|
|
case CSOT_PlanReflow:
|
{
|
const CRcpAFMRecipeInfo* pRcpAFMRecipeInfo = pRsRcpReviewInfo->GetRcpUserAFMRecipeInfo(nModuleIdx);
|
if(pRcpAFMRecipeInfo == NULL)
|
{
|
g_pLog->DisplayMessage(_T("[AllChangeMagnification] pRcpAFMRecipeInfo NULL Error !!"));
|
}
|
nZoomIndex = pRcpAFMRecipeInfo->GetZoomIndex();
|
break;
|
}
|
}
|
|
int nRealMagIndex = -1;
|
if(nCmd == ZoomLevel_Auto_CSOT)
|
{
|
nRealMagIndex = GetRealMagnification(nModuleIdx, nZoomIndex);
|
}
|
else
|
{
|
nRealMagIndex = nZoomIdx;
|
}
|
|
Revolver_SetRevolverLevel(nModuleIdx, nRealMagIndex);
|
|
CString strRecipeName = *pGlassResult->GetPPID();
|
|
AFM_SetAFMRecipeName(nModuleIdx, strRecipeName, nRealMagIndex);
|
}
|
|
return TRUE;
|
}
|
|
BOOL CSequenceProcessor_CSOT::SetDelayTimeToMotor()
|
{
|
const CMotorControlInfo* pMotorInfo = m_pSP2P->ISP2P_System_GetMotorInfo();
|
|
if(pMotorInfo == NULL) return FALSE;
|
|
CMotorControl* pMotorControl = m_pSP2P->ISP2P_GetMotorControl();
|
if(pMotorControl == NULL) return FALSE;
|
|
if(!pMotorControl->WriteAddressValue(pMotorInfo->GetMotorCommonAddr()->m_nWsiDelayTimeAddr, (long)pMotorInfo->GetWsiDelayTime()))
|
{
|
return FALSE;
|
}
|
|
if(pMotorControl->WriteAddressValue(pMotorInfo->GetMotorCommonAddr()->m_nAfDelayTimeAddr, (long)pMotorInfo->GetAfDelayTime()))
|
{
|
return FALSE;
|
}
|
|
if(!pMotorControl->WriteAddressValue(pMotorInfo->GetMotorCommonAddr()->m_nImageDelayTimeAddr, (long)pMotorInfo->GetImageDelayTime()))
|
{
|
return FALSE;
|
}
|
return TRUE;
|
}
|
|
int CSequenceProcessor_CSOT::GetDirectionX(int nGlassDirection, int nMotorDirection)
|
{
|
if(nGlassDirection == GlassOriginDir_LeftTop || nGlassDirection == GlassOriginDir_LeftBottom)
|
{
|
if(nMotorDirection == MotorOriginDir_LeftTop || nMotorDirection == MotorOriginDir_LeftBottom)
|
{
|
return COORDINATE_DIRECTION_FORWARD;
|
}
|
else
|
{
|
return COORDINATE_DIRECTION_BACKWARD;
|
}
|
}
|
|
if(nGlassDirection == GlassOriginDir_RightTop || nGlassDirection == GlassOriginDir_RightBottom)
|
{
|
if(nMotorDirection == MotorOriginDir_RightTop || nMotorDirection == MotorOriginDir_RightBottom)
|
{
|
return COORDINATE_DIRECTION_FORWARD;
|
}
|
else
|
{
|
return COORDINATE_DIRECTION_BACKWARD;
|
}
|
}
|
|
return COORDINATE_DIRECTION_BACKWARD;
|
}
|
|
int CSequenceProcessor_CSOT::GetDirectionY(int nGlassDirection, int nMotorDirection)
|
{
|
if(nGlassDirection == GlassOriginDir_LeftTop || nGlassDirection == GlassOriginDir_RightTop)
|
{
|
if(nMotorDirection == MotorOriginDir_LeftTop || nMotorDirection == MotorOriginDir_RightTop)
|
{
|
return COORDINATE_DIRECTION_FORWARD;
|
}
|
else
|
{
|
return COORDINATE_DIRECTION_BACKWARD;
|
}
|
}
|
|
if(nGlassDirection == GlassOriginDir_LeftBottom || nGlassDirection == GlassOriginDir_RightBottom)
|
{
|
if(nMotorDirection == MotorOriginDir_LeftBottom || nMotorDirection == MotorOriginDir_RightBottom)
|
{
|
return COORDINATE_DIRECTION_FORWARD;
|
}
|
else
|
{
|
return COORDINATE_DIRECTION_BACKWARD;
|
}
|
}
|
|
return COORDINATE_DIRECTION_BACKWARD;
|
}
|
|
//CIM DV Data
|
BOOL CSequenceProcessor_CSOT::SendDVDataToSignalControl() // ¼öÁ¤
|
{
|
CGlassResult *pGlassResult = m_pSP2P->ISP2P_GetCurrentGlassResult();
|
if (pGlassResult==NULL) return FALSE;
|
|
CSignalControl* pSignalControl = m_pSP2P->ISP2P_GetSignalControl();
|
if (pSignalControl==NULL) return FALSE;
|
if (pSignalControl->IsConnected() == FALSE) return FALSE;
|
|
const CSignalControlInfo* pSignalInfo = m_pSP2P->ISP2P_System_GetPCControlInfo();
|
if (pSignalInfo==NULL) return FALSE;
|
|
const CRsRcpReviewInfo* pRsRcpReviewInfo = m_pSP2P->ISP2P_Recipe_GetRsRcpReviewInfo();
|
if (pRsRcpReviewInfo==NULL) return FALSE;
|
|
char DVData[5000]={};
|
int nSize = MakeDVData(pGlassResult, DVData);
|
|
//pSignalControl->WritePacketData(_T("15100"), nSize, (short*)&DVData);
|
g_pLog->DisplayMessage(_T("[SequenceProcessor] DVData writing succeeded. Addr: %s, size: %d"), PC_ADDR_DCOLL_DATA, nSize);
|
|
return TRUE;
|
}
|
|
|
int CSequenceProcessor_CSOT::MakeDVData(CGlassResult *pGlassResult, char* pDVData, int nIndex) // ¼öÁ¤
|
{
|
g_pLog->DisplayMessage(_T("[SequenceProcessor] SendDVDataToSignalControl->MakeDVData IN."));
|
|
if (pGlassResult==NULL) return FALSE;
|
|
const CRsRcpReviewInfo* pRsRcpReviewInfo = m_pSP2P->ISP2P_Recipe_GetRsRcpReviewInfo();
|
if (pRsRcpReviewInfo==NULL) return FALSE;
|
|
// Review Á¶¸í Á¤º¸
|
const CRcpLightInfo *pReviewLightInfo = pRsRcpReviewInfo->GetRcpLightInfo(nIndex);
|
// Review AFM Á¤º¸
|
const CRcpAFMRecipeInfo *pReviewAFMInfo = pRsRcpReviewInfo->GetRcpAFMRecipeInfo(nIndex);
|
// Review Align Info
|
const CAlignResult* pAlignResult = pGlassResult->GetAlignResult();
|
// Review Defect Info
|
const CReviewResult* pReviewResult = pGlassResult->GetReviewResult(nIndex);
|
|
// Review ¹èÀ² Á¤º¸
|
const CModuleStatus* pModuleStatus = Module_GetModuleStatus(nIndex);
|
const SMagnificInfo* pSMagnificInfo = pModuleStatus->GetMagnificInfo(pReviewAFMInfo->GetZoomIndex());
|
CSignalControl* pSignalControl = m_pSP2P->ISP2P_GetSignalControl();
|
if (pSignalControl==NULL) return FALSE;
|
if (pSignalControl->IsConnected() == FALSE) return FALSE;
|
const SReviewResult* pSReviewResult = pGlassResult->GetSReviewResult(nIndex, 0);
|
|
//int nReviewResultCount = min(_countof(DVDataPack.reviewDefectData), pGlassResult->GetSReviewResultCount(nIndex));
|
//int nReviewResultCount = pGlassResult->GetSReviewResultCount(nIndex);
|
//int nWSIResultCount = pGlassResult->GetSWsiResultCount(nIndex);
|
int nEqpID = m_pSP2P->ISP2P_System_GetSystemInfo()->m_nMachineType;
|
int nReviewResultCount = 0;
|
int nWSIResultCount = 0;
|
int offset=0;
|
int nSize = 0;
|
int nWritePacketDataLimitPlag=0;
|
|
//////////////////////////////////////////////////////////////////////////
|
// Write DVData Packet
|
//_DVDataPack_B7_8ver DVDataPack;
|
//**Review
|
//INLINE : 10°³
|
//TFE-OFF : 20°³
|
//Hcut : 50°³
|
//LAMI : 5°³
|
//**WSI
|
//10°³ °íÁ¤
|
///////////////////////////////////////////////////////////////////////////
|
|
|
|
_DVDataPack_B7_8ver DVDataPack;
|
_DVDataPack_Hcut DVDataPackhcut;
|
_DVDataPack_TFEOFF DVDataPacktfeoff;
|
|
|
char DVData[10000]={};
|
|
if(nEqpID==0){//Crack
|
nReviewResultCount=10;
|
nSize = 1500;
|
nWritePacketDataLimitPlag=1;
|
memset(&DVDataPack, 0, sizeof(DVDataPack));
|
}
|
else if(nEqpID==1){//ijp
|
nReviewResultCount= 10;
|
nSize = 1500;
|
nWritePacketDataLimitPlag=1;
|
memset(&DVDataPack, 0, sizeof(DVDataPack));
|
}
|
else if(nEqpID ==2){ //TFE_IN
|
nReviewResultCount=10;
|
nWSIResultCount=10;
|
memset(&DVDataPack, 0, sizeof(DVDataPack));
|
}
|
else if(nEqpID==3){//lami
|
nReviewResultCount= 5;
|
nSize = 1500;
|
nWritePacketDataLimitPlag=1;
|
memset(&DVDataPack, 0, sizeof(DVDataPack));
|
}
|
else if(nEqpID == 4){ //hcut
|
nReviewResultCount= 50;
|
memset(&DVDataPackhcut, 0, sizeof(DVDataPackhcut));
|
|
}
|
else if(nEqpID==5){//TfeOff
|
nReviewResultCount= 20;
|
nWSIResultCount=10;
|
memset(&DVDataPacktfeoff, 0, sizeof(DVDataPacktfeoff));
|
}
|
|
|
if(nEqpID == 4)
|
{
|
for (int i=0; i<nReviewResultCount; i++)
|
{
|
|
const SReviewResult* pSReviewResult = pGlassResult->GetSReviewResult(nIndex, i);
|
if (NULL == pSReviewResult) continue;
|
|
DVDataPackhcut.reviewDefectData[i].PositionX = (int)pSReviewResult->dUMCenterOriginX; // mm
|
DVDataPackhcut.reviewDefectData[i].PositionY = (int)pSReviewResult->dUMCenterOriginY; // mm
|
|
for(int j=0; j<pSReviewResult->strDefectType.GetLength();j++){
|
if(pSReviewResult->strDefectType.GetAt(j)==NULL){break;}
|
DVDataPackhcut.reviewDefectData[i].defectType[j]= pSReviewResult->strDefectType.GetAt(j);
|
}
|
|
DVDataPackhcut.reviewDefectData[i].judgeCode = pSReviewResult->nSizeType; // ??
|
DVDataPackhcut.reviewDefectData[i].sizeRScale = pSReviewResult->nAOISizeLength*1000; // um
|
}
|
|
for( int j=0; j<_countof(DVDataPackhcut.reviewDefectData); j++ )
|
{
|
if( strcmp( DVDataPackhcut.reviewDefectData[j].defectType, "") == 0 )
|
strcpy( DVDataPackhcut.reviewDefectData[j].defectType, " " );
|
}
|
|
for (int i=0; i<nWSIResultCount; i++)
|
{
|
const SReviewResult* pSWsiResult = pGlassResult->GetSWsiResult(nIndex, i);
|
if (NULL == pSWsiResult) continue;
|
|
// 8.2.WSI_MEASURE_Ruslut
|
DVDataPackhcut.wsiDefectData[i].measureResult = pSWsiResult->nWsi_ResultCode; // ¼º°ø / ½ÇÆÐ
|
// 8.3.WSI_MEASURE_TYPE
|
DVDataPackhcut.wsiDefectData[i].measureType = pSWsiResult->nWsi_Type; // µ¹Ãâ / ÇÔ¸ô
|
// 8.4.WSI_DEFECT_MEASURE_HEIGHT
|
DVDataPackhcut.wsiDefectData[i].measureHeight = int(pSWsiResult->pWsi_ResultData[0]*1000); // um
|
// 8.5.WSI_DEFECT_MEASURE_WIDTH_X
|
DVDataPackhcut.wsiDefectData[i].measureWidthX = int(pSWsiResult->pWsi_ResultData[1]*1000); // um
|
// 8.6.WSI_DEFECT_MEASURE_WIDTH_Y
|
DVDataPackhcut.wsiDefectData[i].measureWidthY = int(pSWsiResult->pWsi_ResultData[2]*1000); // um
|
// 8.7.WSI_DEFECT_MEASURE_RATION
|
}
|
|
memcpy(DVData,&DVDataPackhcut,sizeof(DVDataPackhcut));
|
|
pSignalControl->WritePacketData(_T("15100"), sizeof(DVDataPackhcut), (short*)&DVData);
|
}
|
else if (nEqpID == 5){
|
for (int i=0; i<nReviewResultCount; i++)
|
{
|
|
const SReviewResult* pSReviewResult = pGlassResult->GetSReviewResult(nIndex, i);
|
if (NULL == pSReviewResult) continue;
|
|
DVDataPacktfeoff.reviewDefectData[i].PositionX = (int)pSReviewResult->dUMCenterOriginX; // mm
|
DVDataPacktfeoff.reviewDefectData[i].PositionY = (int)pSReviewResult->dUMCenterOriginY; // mm
|
|
for(int j=0; j<pSReviewResult->strDefectType.GetLength();j++){
|
if(pSReviewResult->strDefectType.GetAt(j)==NULL){break;}
|
DVDataPacktfeoff.reviewDefectData[i].defectType[j]= pSReviewResult->strDefectType.GetAt(j);
|
}
|
|
DVDataPacktfeoff.reviewDefectData[i].judgeCode = pSReviewResult->nSizeType; // ??
|
DVDataPacktfeoff.reviewDefectData[i].sizeRScale = pSReviewResult->nAOISizeLength*1000; // um
|
}
|
|
for( int j=0; j<_countof(DVDataPacktfeoff.reviewDefectData); j++ )
|
{
|
if( strcmp( DVDataPacktfeoff.reviewDefectData[j].defectType, "") == 0 )
|
strcpy( DVDataPacktfeoff.reviewDefectData[j].defectType, " " );
|
}
|
|
for (int i=0; i<nWSIResultCount; i++)
|
{
|
const SReviewResult* pSWsiResult = pGlassResult->GetSWsiResult(nIndex, i);
|
if (NULL == pSWsiResult) continue;
|
|
// 8.2.WSI_MEASURE_Ruslut
|
DVDataPacktfeoff.wsiDefectData[i].measureResult = pSWsiResult->nWsi_ResultCode; // ¼º°ø / ½ÇÆÐ
|
// 8.3.WSI_MEASURE_TYPE
|
DVDataPacktfeoff.wsiDefectData[i].measureType = pSWsiResult->nWsi_Type; // µ¹Ãâ / ÇÔ¸ô
|
// 8.4.WSI_DEFECT_MEASURE_HEIGHT
|
DVDataPacktfeoff.wsiDefectData[i].measureHeight = int(pSWsiResult->pWsi_ResultData[0]*1000); // um
|
// 8.5.WSI_DEFECT_MEASURE_WIDTH_X
|
DVDataPacktfeoff.wsiDefectData[i].measureWidthX = int(pSWsiResult->pWsi_ResultData[1]*1000); // um
|
// 8.6.WSI_DEFECT_MEASURE_WIDTH_Y
|
DVDataPacktfeoff.wsiDefectData[i].measureWidthY = int(pSWsiResult->pWsi_ResultData[2]*1000); // um
|
// 8.7.WSI_DEFECT_MEASURE_RATION
|
}
|
|
memcpy(DVData,&DVDataPacktfeoff,sizeof(DVDataPacktfeoff));
|
|
pSignalControl->WritePacketData(_T("15100"), sizeof(DVDataPacktfeoff), (short*)&DVData);
|
}
|
else
|
{
|
for (int i=0; i<nReviewResultCount; i++)
|
{
|
|
const SReviewResult* pSReviewResult = pGlassResult->GetSReviewResult(nIndex, i);
|
if (NULL == pSReviewResult) continue;
|
|
DVDataPack.reviewDefectData[i].PositionX = (int)pSReviewResult->dUMCenterOriginX; // mm
|
DVDataPack.reviewDefectData[i].PositionY = (int)pSReviewResult->dUMCenterOriginY; // mm
|
|
for(int j=0; j<pSReviewResult->strDefectType.GetLength();j++){
|
if(pSReviewResult->strDefectType.GetAt(j)==NULL){break;}
|
DVDataPack.reviewDefectData[i].defectType[j]= pSReviewResult->strDefectType.GetAt(j);
|
}
|
|
DVDataPack.reviewDefectData[i].judgeCode = pSReviewResult->nSizeType; // ??
|
DVDataPack.reviewDefectData[i].sizeRScale = pSReviewResult->nAOISizeLength*1000; // um
|
}
|
|
for( int j=0; j<nReviewResultCount; j++ )
|
{
|
const SReviewResult* pSReviewResult = pGlassResult->GetSReviewResult(nIndex, j);
|
if (NULL == pSReviewResult) continue;
|
|
if( strcmp( DVDataPack.reviewDefectData[j].defectType, "") == 0 )
|
strcpy( DVDataPack.reviewDefectData[j].defectType, " " );
|
}
|
|
for (int i=0; i<nWSIResultCount; i++)
|
{
|
const SReviewResult* pSWsiResult = pGlassResult->GetSWsiResult(nIndex, i);
|
if (NULL == pSWsiResult) continue;
|
|
// 8.2.WSI_MEASURE_Ruslut
|
DVDataPack.wsiDefectData[i].measureResult = pSWsiResult->nWsi_ResultCode; // ¼º°ø / ½ÇÆÐ
|
// 8.3.WSI_MEASURE_TYPE
|
DVDataPack.wsiDefectData[i].measureType = pSWsiResult->nWsi_Type; // µ¹Ãâ / ÇÔ¸ô
|
// 8.4.WSI_DEFECT_MEASURE_HEIGHT
|
DVDataPack.wsiDefectData[i].measureHeight = int(pSWsiResult->pWsi_ResultData[0]*1000); // um
|
// 8.5.WSI_DEFECT_MEASURE_WIDTH_X
|
DVDataPack.wsiDefectData[i].measureWidthX = int(pSWsiResult->pWsi_ResultData[1]*1000); // um
|
// 8.6.WSI_DEFECT_MEASURE_WIDTH_Y
|
DVDataPack.wsiDefectData[i].measureWidthY = int(pSWsiResult->pWsi_ResultData[2]*1000); // um
|
// 8.7.WSI_DEFECT_MEASURE_RATION
|
}
|
|
memcpy(DVData,&DVDataPack,sizeof(DVDataPack));
|
|
|
if(nWritePacketDataLimitPlag ==1 ){// »çÀÌÁî ³Ê¹« Å©¸é Á¦¾î¸Þ¸ð¸® ¼³ºñ¸¶´Ù ´Þ¶ó¼ ÅÍÁü ¿¹¹æ CRACK,IJP,LAMI
|
pSignalControl->WritePacketData(_T("15100"), nSize, (short*)&DVData);
|
}
|
else{
|
pSignalControl->WritePacketData(_T("15100"), sizeof(DVDataPack), (short*)&DVData);
|
}
|
}
|
|
g_pLog->DisplayMessage(_T("[SequenceProcessor] SendDVDataToSignalControl->MakeDVData OUT."));
|
// return nPackSize;
|
return sizeof(DVDataPack);
|
}
|
|
// [2017:4:13]-[WEZASW] : CIM Signal.
|
BOOL CSequenceProcessor_CSOT::RecvCIMSignalToSignalControl(int nAddrIndex, int nSignalIndex)
|
{
|
CSignalControl* pSignalControl = m_pSP2P->ISP2P_GetSignalControl();
|
if (pSignalControl==NULL) return FALSE;
|
if (pSignalControl->IsConnected() == FALSE) return FALSE;
|
|
BOOL bResult = FALSE;
|
|
// PCControl D2300 (°Ë»ç ¿µ¿ª)
|
switch(nSignalIndex)
|
{
|
case PCControlRecv_TimeChange:
|
g_pLog->DisplayMessage(_T("[PCControl_Signal] CIM IF Signal => PCControlRecv_TimeChange."));
|
bResult = ChangeReviewSystemTime();
|
break;
|
}
|
return bResult;
|
}
|
|
BOOL CSequenceProcessor_CSOT::SendCIMSignalToSignalControl(int nAddrIndex, int nSignalIndex)
|
{
|
CSignalControl* pSignalControl = m_pSP2P->ISP2P_GetSignalControl();
|
if (pSignalControl == NULL) return FALSE;
|
if (pSignalControl->IsConnected() == FALSE) return FALSE;
|
|
if (pSignalControl->Write_SendSignal(nAddrIndex, nSignalIndex, 1, 1000) == FALSE)
|
{
|
m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Send] Send Fail! "));
|
return FALSE;
|
}
|
|
switch (nAddrIndex)
|
{
|
case PCControlSend_D2320:
|
if (nSignalIndex == PCControlSend_ReviewAlive)
|
{
|
m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Send] CIM IF Signal => %d"), nSignalIndex);
|
}
|
break;
|
}
|
return TRUE;
|
}
|
|
// Change System Time
|
BOOL CSequenceProcessor_CSOT::ChangeReviewSystemTime()
|
{
|
g_pLog->DisplayMessage(_T("[SequenceProcessor] ChangeReviewSystemTime IN"));
|
|
SYSTEMTIME CurrentTime, ChangedTime;
|
GetLocalTime(&CurrentTime);
|
ChangedTime = CurrentTime;
|
|
int nReadData = 0;
|
int nReadSize = 1;
|
int nAddrCount = 0;
|
|
if (!ReadCIMTimeData(PCControl_ADDR_TIME_DATA, nAddrCount++, nReadData)) return FALSE;
|
ChangedTime.wYear = nReadData;
|
if (!ReadCIMTimeData(PCControl_ADDR_TIME_DATA, nAddrCount++, nReadData)) return FALSE;
|
ChangedTime.wMonth = nReadData;
|
if (!ReadCIMTimeData(PCControl_ADDR_TIME_DATA, nAddrCount++, nReadData)) return FALSE;
|
ChangedTime.wDay = nReadData;
|
if (!ReadCIMTimeData(PCControl_ADDR_TIME_DATA, nAddrCount++, nReadData)) return FALSE;
|
ChangedTime.wHour = nReadData;
|
if (!ReadCIMTimeData(PCControl_ADDR_TIME_DATA, nAddrCount++, nReadData)) return FALSE;
|
ChangedTime.wMinute = nReadData;
|
if (!ReadCIMTimeData(PCControl_ADDR_TIME_DATA, nAddrCount++, nReadData)) return FALSE;
|
ChangedTime.wSecond = nReadData;
|
if (!ReadCIMTimeData(PCControl_ADDR_TIME_DATA, nAddrCount++, nReadData)) return FALSE;
|
|
if (SetLocalTime(&ChangedTime)) {
|
g_pLog->DisplayMessage(_T("[SequenceProcessor] Success! SetLocalTime(), Current: %04d-%02d-%02d %02d-%02d-%02d, Changed: %04d-%02d-%02d %02d-%02d-%02d"),
|
CurrentTime.wYear, CurrentTime.wMonth, CurrentTime.wDay, CurrentTime.wHour, CurrentTime.wMinute, CurrentTime.wSecond,
|
ChangedTime.wYear, ChangedTime.wMonth, ChangedTime.wDay, ChangedTime.wHour, ChangedTime.wMinute, ChangedTime.wSecond);
|
// AFM & WSI TIME µ¿±âÈ
|
SendSystemTime(ChangedTime);
|
} else {
|
g_pLog->DisplayMessage(_T("[SequenceProcessor] Fail! SetLocalTime()"));
|
}
|
|
g_pLog->DisplayMessage(_T("[SequenceProcessor] ChangeReviewSystemTime OUT"));
|
|
return TRUE;
|
}
|
|
BOOL CSequenceProcessor_CSOT::ReadCIMTimeData(CString strAddr, int nAddrCnt, int& nData)
|
{
|
CSignalControl* pSignalControl = m_pSP2P->ISP2P_GetSignalControl();
|
if (pSignalControl==NULL) return FALSE;
|
if (pSignalControl->IsConnected() == FALSE) return FALSE;
|
|
CString strReadAddr = _T("");
|
char readData[8] = {0};
|
|
strReadAddr.Format(_T("D%d"), _ttoi(strAddr) + nAddrCnt);
|
if (pSignalControl->ReadData(strReadAddr, 1, readData) == FALSE) return FALSE;
|
memcpy(&nData, readData, 2);
|
|
return TRUE;
|
}
|
|
// Local System º¯°æ ½Ã°£°ú º¯°æ ¿äû ÄÁÆ®·Ñ·¯ÀÇ ½Ã°£Â÷ ó¸® »ý°¢
|
BOOL CSequenceProcessor_CSOT::SendSystemTime(SYSTEMTIME sysTime)
|
{
|
SYSTEMTIME CurrentTime;
|
|
int nWSIControlCount = m_pSP2P->ISP2P_GetWSIControlCount();
|
|
for(int nWSIControlIdx = 0; nWSIControlIdx < nWSIControlCount; nWSIControlIdx++)
|
{
|
CWsiControl* pWSIControl = m_pSP2P->ISP2P_GetWSIControl(nWSIControlIdx);
|
if(pWSIControl == NULL) continue;
|
|
GetLocalTime(&CurrentTime);
|
pWSIControl->SetSystemTime(CurrentTime);
|
}
|
|
int nAFMControlCount = m_pSP2P->ISP2P_GetAFMControlCount();
|
for(int nAFMControlIdx = 0; nAFMControlIdx < nAFMControlCount; nAFMControlIdx++)
|
{
|
CAfmControl* pAFMControl = m_pSP2P->ISP2P_GetAFMControl(nAFMControlIdx);
|
if(pAFMControl == NULL) continue;
|
|
GetLocalTime(&CurrentTime);
|
pAFMControl->SetSystemTime(CurrentTime);
|
}
|
return TRUE;
|
}
|
|
BOOL CSequenceProcessor_CSOT::SendSignalOffToSignalControl( int nSignalIndex, int nSignalValue )
|
{
|
CSignalControl* pSignalControl = m_pSP2P->ISP2P_GetSignalControl();
|
if (pSignalControl == NULL) return FALSE;
|
|
if (pSignalControl->IsConnected() == FALSE) return FALSE;
|
|
int nAddrIdx = 0;
|
if (pSignalControl->Write_SendSignal(nSignalIndex, nSignalValue, 0,SIGNAL_ON_TIME_INFINITY) == FALSE)
|
{
|
m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Send] Send Fail! "));
|
return FALSE;
|
}
|
|
if (nSignalIndex==PCControlSendSignalIndex_State)
|
{
|
switch(nSignalValue)
|
{
|
case PCControlSend_RecipeASCEND:
|
m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Send] Recipe ASCEND Bit OFF! => %d"),0);
|
break;
|
case PCControlSend_WSIError:
|
m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Send] WSIError Bit OFF! => %d"),0);
|
break;
|
}
|
}
|
else if (nSignalIndex==PCControlSendSignalIndex_Seq)
|
{
|
switch(nSignalValue)
|
{
|
case PCControlSend_LoadingComplete_CSOT:
|
m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Send] Loading Complete Off! => %d"), 0);
|
break;
|
|
case PCControlSend_AlignComplete_CSOT:
|
m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Send] Align Complete Off! => %d"), 0);
|
break;
|
|
case PCControlSend_ReviewReady_CSOT:
|
m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Send] Review Ready Off! => %d"), 0);
|
break;
|
|
case PCControlSend_ReviewComplete_CSOT:
|
m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Send] Review Complete Off! => %d"), 0);
|
break;
|
|
case PCControlSend_ResultDataComplete_CSOT:
|
m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Send] Result Data Complete Off! => %d"), 0);
|
break;
|
}
|
}
|
else if (nSignalIndex==PCControlSendSignalIndex_Ack)
|
{
|
switch(nSignalValue)
|
{
|
case PCControlSend_LoadingAck_CSOT:
|
m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Send] Loading Ack Off! => %d"), 0);
|
break;
|
|
case PCControlSend_AlignStartAck_CSOT:
|
m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Send] Align Start Ack Off! => %d"), 0);
|
break;
|
|
case PCControlSend_ReadRawFileAck_CSOT:
|
m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Send] Read Raw File Ack Off! => %d"), 0);
|
break;
|
|
case PCControlSend_ReviewStartAck_CSOT:
|
m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Send] Review Start Ack Off! => %d"), 0);
|
break;
|
|
case PCControlSend_ResultDataComplete_CSOT:
|
m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Send] Result Data Complete Off! => %d"), 0);
|
break;
|
}
|
}
|
|
return TRUE;
|
}
|
|
BOOL CSequenceProcessor_CSOT::SendSignalToSignalControl( int nSignalIndex, int nSignalValue )
|
{
|
CSignalControl* pSignalControl = m_pSP2P->ISP2P_GetSignalControl();
|
if (pSignalControl == NULL) return FALSE;
|
|
if (pSignalControl->IsConnected() == FALSE) return FALSE;
|
|
int nAddrIdx = 0;
|
if (pSignalControl->Write_SendSignal(nSignalIndex, nSignalValue, 1, SIGNAL_ON_TIME_INFINITY) == FALSE)
|
{
|
m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Send] Send Fail! "));
|
return FALSE;
|
}
|
|
switch(nSignalIndex)
|
{
|
case PCControlSendSignalIndex_State:
|
{
|
switch(nSignalValue)
|
{
|
case PCControlSend_RecipeASCEND:
|
m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Send] Recipe Is ASCEND! => %d"),1);
|
break;
|
case PCControlSend_WSIError:
|
m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Send] WSIError! => %d"),0);
|
break;
|
case PCControlSend_Defoucs:
|
m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Send] Defoucs! => %d"),0);
|
break;
|
}
|
}
|
break;
|
case PCControlSendSignalIndex_Seq:
|
{
|
switch(nSignalValue)
|
{
|
case PCControlSend_LoadingComplete_CSOT:
|
m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Send] Loading Complete! => %d"), 1);
|
break;
|
|
case PCControlSend_AlignComplete_CSOT:
|
m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Send] Align Complete! => %d"), 1);
|
break;
|
|
case PCControlSend_ReviewReady_CSOT:
|
m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Send] Review Ready! => %d"), 1);
|
break;
|
|
case PCControlSend_ReviewComplete_CSOT:
|
m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Send] Review Complete! => %d"), 1);
|
break;
|
|
case PCControlSend_ResultDataComplete_CSOT:
|
m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Send] Result Data Complete! => %d"), 1);
|
break;
|
}
|
}
|
break;
|
case PCControlSendSignalIndex_Ack:
|
{
|
switch(nSignalValue)
|
{
|
case PCControlSend_LoadingAck_CSOT:
|
m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Send] Loading Ack! => %d"), 1);
|
break;
|
|
case PCControlSend_AlignStartAck_CSOT:
|
m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Send] Align Start Ack! => %d"), 1);
|
break;
|
|
case PCControlSend_ReadRawFileAck_CSOT:
|
m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Send] Read Raw File Ack! => %d"), 1);
|
break;
|
|
case PCControlSend_ReviewStartAck_CSOT:
|
m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Send] Review Start Ack! => %d"), 1);
|
break;
|
|
case PCControlSend_ResultDataComplete_CSOT:
|
m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Send] Result Data Complete! => %d"), 1);
|
break;
|
}
|
}
|
break;
|
}
|
|
return TRUE;
|
}
|
|
BOOL CSequenceProcessor_CSOT::SendSignalToSignalControl( int nSignalIndex, int nSignalValue,int nSignalOnTime )
|
{
|
CSignalControl* pSignalControl = m_pSP2P->ISP2P_GetSignalControl();
|
if (pSignalControl == NULL) return FALSE;
|
|
if (pSignalControl->IsConnected() == FALSE) return FALSE;
|
|
int nAddrIdx = 0;
|
if (pSignalControl->Write_SendSignal(nSignalIndex, nSignalValue, 1, nSignalOnTime) == FALSE)
|
{
|
m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Send] Send Fail! "));
|
return FALSE;
|
}
|
|
switch(nSignalIndex)
|
{
|
case PCControlSendSignalIndex_State:
|
{
|
switch(nSignalValue)
|
{
|
case PCControlSend_RecipeASCEND:
|
m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Send] Recipe Is ASCEND! => %d"),1);
|
break;
|
case PCControlSend_WSIError:
|
m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Send] WSIError! => %d"),0);
|
break;
|
case PCControlSend_Defoucs:
|
m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Send] Defoucs! => %d"),0);
|
break;
|
}
|
}
|
break;
|
case PCControlSendSignalIndex_Seq:
|
{
|
switch(nSignalValue)
|
{
|
case PCControlSend_LoadingComplete_CSOT:
|
m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Send] Loading Complete! => %d"), 1);
|
break;
|
|
case PCControlSend_AlignComplete_CSOT:
|
m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Send] Align Complete! => %d"), 1);
|
break;
|
|
case PCControlSend_ReviewReady_CSOT:
|
m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Send] Review Ready! => %d"), 1);
|
break;
|
|
case PCControlSend_ReviewComplete_CSOT:
|
m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Send] Review Complete! => %d"), 1);
|
break;
|
|
case PCControlSend_ResultDataComplete_CSOT:
|
m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Send] Result Data Complete! => %d"), 1);
|
break;
|
}
|
}
|
break;
|
case PCControlSendSignalIndex_Ack:
|
{
|
switch(nSignalValue)
|
{
|
case PCControlSend_LoadingAck_CSOT:
|
m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Send] Loading Ack! => %d"), 1);
|
break;
|
|
case PCControlSend_AlignStartAck_CSOT:
|
m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Send] Align Start Ack! => %d"), 1);
|
break;
|
|
case PCControlSend_ReadRawFileAck_CSOT:
|
m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Send] Read Raw File Ack! => %d"), 1);
|
break;
|
|
case PCControlSend_ReviewStartAck_CSOT:
|
m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Send] Review Start Ack! => %d"), 1);
|
break;
|
|
case PCControlSend_ResultDataComplete_CSOT:
|
m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Send] Result Data Complete! => %d"), 1);
|
break;
|
}
|
}
|
break;
|
}
|
|
return TRUE;
|
}
|
|
BOOL CSequenceProcessor_CSOT::ProcessSignal_State( int nSignalValue, BOOL bSignalOn )
|
{
|
BOOL bResult = FALSE;
|
|
if (bSignalOn==FALSE) return TRUE;
|
|
switch(nSignalValue)
|
{
|
case PCControlRecv_ByPassMode_CSOT: // bypass mode on
|
{
|
m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Mode] BY-PASS Mode"));
|
bResult = SetProcessMode(ProcessBypassMode_CSOT);
|
if (bResult==FALSE) m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Mode] BY-PASS Mode Error!"));
|
}
|
break;
|
|
case PCControlRecv_AutoMode_CSOT: // auto mode on
|
{
|
m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Mode] Auto Mode"));
|
bResult = SetProcessMode(ProcessAutoMode_CSOT);
|
if (bResult==FALSE) m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Mode] Auto Mode Error!"));
|
}
|
break;
|
|
case PCControlRecv_ManualMode_CSOT: // manual mode on
|
{
|
m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Mode] Manual Mode"));
|
bResult = SetProcessMode(ProcessManualMode_CSOT);
|
if (bResult==FALSE) m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Mode] Manual Mode Error!"));
|
|
// lmk simul manual camera,motor stop
|
//ReviewCamera_CameraControl(CameraControlStop); // ¸ðÅÍ ¸ØÃ߸é Ä«¸Þ¶ó ÀÚµ¿ ½ºÅ¾
|
CMotorControl* pMotorControl = m_pSP2P->ISP2P_GetMotorControl();
|
if(pMotorControl)
|
pMotorControl->CommonSetAutoStop();
|
}
|
break;
|
|
case PCControlRecv_ReviewManualMode_CSOT: // review mode on
|
{
|
m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Mode] Review Mode"));
|
bResult = SetProcessMode(ProcessReviewMode_CSOT);
|
if (bResult==FALSE) m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Mode] Review Mode Error!"));
|
}
|
break;
|
|
default:
|
return FALSE;
|
break;
|
}
|
|
return bResult;
|
}
|
|
|
BOOL CSequenceProcessor_CSOT::ProcessSignal_Seq( int nSignalValue, BOOL bSignalOn )
|
{
|
BOOL bResult = FALSE;
|
|
switch(nSignalValue)
|
{
|
case PCControlRecv_Loading_CSOT: // loading on
|
{
|
m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Signal] Glass Loading! => %d"), bSignalOn);
|
if (bSignalOn)
|
bResult = SetProcessStatus(ProcessLoading_CSOT);
|
else
|
bResult = SendSignalOffToSignalControl(PCControlSendSignalIndex_Ack, PCControlSend_LoadingAck_CSOT);
|
if (bResult==FALSE) m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Signal] Glass Loading Error!"));
|
}
|
break;
|
|
case PCControlRecv_AlignStart_CSOT: // align start on
|
{
|
m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Signal] Align Start! => %d"), bSignalOn);
|
if (bSignalOn)
|
bResult = SetProcessStatus(ProcessAlignStart_CSOT);
|
else
|
bResult = SendSignalOffToSignalControl(PCControlSendSignalIndex_Ack, PCControlSend_AlignStartAck_CSOT);
|
if (bResult==FALSE) m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Signal] Align Start Error!"));
|
}
|
break;
|
|
case PCControlRecv_ReadRawFile_CSOT: // read raw file on
|
{
|
m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Signal] Read Raw File! => %d"), bSignalOn);
|
if (bSignalOn)
|
bResult = SetProcessStatus(ProcessReadRawFile_CSOT);
|
else
|
bResult = SendSignalOffToSignalControl(PCControlSendSignalIndex_Ack, PCControlSend_ReadRawFileAck_CSOT);
|
if (bResult==FALSE) m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Signal] Read Raw File Error!"));
|
}
|
break;
|
|
case PCControlRecv_ReviewStart_CSOT: // review start on
|
{
|
m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Signal] Review Start! => %d"), bSignalOn);
|
if (bSignalOn)
|
bResult = SetProcessStatus(ProcessReviewStart_CSOT);
|
else
|
bResult = SendSignalOffToSignalControl(PCControlSendSignalIndex_Ack, PCControlSend_ReviewStartAck_CSOT);
|
if (bResult==FALSE) m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Signal] Review Start Error!"));
|
}
|
break;
|
|
case PCControlRecv_ReviewEnd_CSOT: // review end on
|
{
|
m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Signal] Review End! => %d"), bSignalOn);
|
if (bSignalOn)
|
bResult = SetProcessStatus(ProcessReviewEnd_CSOT);
|
else
|
bResult = SendSignalOffToSignalControl(PCControlSendSignalIndex_Ack, PCControlSend_ReviewEndAck_CSOT);
|
if (bResult==FALSE) m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Signal] Review End Error!"));
|
}
|
break;
|
|
case PCControlRecv_AFM_Home_Move_CSOT: // AFM Home Move On
|
{
|
m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Signal] AFM Home Move! => %d"), bSignalOn);
|
if (bSignalOn)
|
bResult = SendSignalToSignalControl(PCControlSendSignalIndex_Ack, PCControlSend_AFMHomeMoveAck_CSOT);
|
else
|
bResult = SendSignalOffToSignalControl(PCControlSendSignalIndex_Ack, PCControlSend_AFMHomeMoveAck_CSOT);
|
|
m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Signal] Send AFM Home Move Ack!"));
|
}
|
break;
|
|
case PCControlRecv_WSI_Home_Move_CSOT: // WSI Home Move ON
|
{
|
m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Signal] WSI Home Move!"));
|
if (bSignalOn)
|
bResult = SendSignalToSignalControl(PCControlSendSignalIndex_Ack, PCControlSend_WSIHomeMoveAck_CSOT);
|
else
|
bResult = SendSignalOffToSignalControl(PCControlSendSignalIndex_Ack, PCControlSend_WSIHomeMoveAck_CSOT);
|
|
m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Signal] Send WSI Home Move Ack!"));
|
}
|
break;
|
|
default:
|
return FALSE;
|
break;
|
}
|
|
return bResult;
|
}
|
|
BOOL CSequenceProcessor_CSOT::ProcessSignal_Ack( int nSignalValue, BOOL bSignalOn )
|
{
|
BOOL bResult = FALSE;
|
|
if (bSignalOn==FALSE) return TRUE;
|
|
switch(nSignalValue)
|
{
|
case PCControlRecv_LoadingCompleteAck_CSOT: // Loading complete ack on
|
m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Signal] Loading Complete Ack!"));
|
bResult = SendSignalOffToSignalControl(PCControlSendSignalIndex_Seq, PCControlSend_LoadingComplete_CSOT);
|
if (bResult) m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Signal] Loading Complete Off!"));
|
else m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Signal] Loading Complete Off Fail!"));
|
break;
|
|
case PCControlRecv_AlignCompleteAck_CSOT: // align complete ack on
|
m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Signal] Align Complete Ack!"));
|
bResult = SendSignalOffToSignalControl(PCControlSendSignalIndex_Seq, PCControlSend_AlignComplete_CSOT);
|
if (bResult) m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Signal] Align Complete Off!"));
|
else m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Signal] Align Complete Off Fail!"));
|
break;
|
|
case PCControlRecv_ReviewReadyAck_CSOT: // review ready ack on
|
m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Signal] Review Ready Ack!"));
|
bResult = SendSignalOffToSignalControl(PCControlSendSignalIndex_Seq, PCControlSend_ReviewReady_CSOT);
|
if (bResult) m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Signal] Review Ready Off!"));
|
else m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Signal] Review Ready Off Fail!"));
|
break;
|
|
case PCControlRecv_ReviewCompleteAck_CSOT: // review complete ack on
|
m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Signal] Review Complete Ack!"));
|
bResult = SendSignalOffToSignalControl(PCControlSendSignalIndex_Seq, PCControlSend_ReviewComplete_CSOT);
|
if (bResult) m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Signal] Review Complete Off!"));
|
else m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Signal] Review Complete Off Fail!"));
|
break;
|
|
case PCControlRecv_ResultDataCompleteAck_CSOT: // result data complete ack on
|
m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Signal] Result Data Complete Ack!"));
|
bResult = SendSignalOffToSignalControl(PCControlSendSignalIndex_Seq, PCControlSend_ResultDataComplete_CSOT);
|
if (bResult) m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Signal] Result Data Complete Off!"));
|
else m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Signal] Result Data Complete Off Fail!"));
|
break;
|
|
default:
|
return FALSE;
|
break;
|
}
|
|
return bResult;
|
}
|
|
BOOL CSequenceProcessor_CSOT::SendResultToSignalControl( int nSingalIdx, int nResultValue )
|
{
|
CSignalControl* pSignalControl = m_pSP2P->ISP2P_GetSignalControl();
|
if (pSignalControl == NULL) return FALSE;
|
|
if (pSignalControl->IsConnected() == FALSE) return FALSE;
|
|
const CSignalControlInfo* pSignalControlInfo = m_pSP2P->ISP2P_System_GetPCControlInfo();
|
if (pSignalControlInfo==NULL) return FALSE;
|
|
if (nSingalIdx<0 || nSingalIdx>=pSignalControlInfo->GetSendDataAddressCount()) return FALSE;
|
|
const SSignalSettingData* pSSignalSendAddr = pSignalControlInfo->GetSendDataAddress(nSingalIdx);
|
if (pSSignalSendAddr==NULL) return FALSE;
|
|
if (pSignalControl->WriteWordData(pSSignalSendAddr->strAddr, pSSignalSendAddr->nSize, nResultValue)==FALSE)
|
{
|
m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Send] Write Result Fail! "));
|
return FALSE;
|
}
|
|
m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Send] Write Result : Name[%s], Addr[%s], Data[%d]"),
|
pSSignalSendAddr->strName, pSSignalSendAddr->strAddr, nResultValue);
|
|
return TRUE;
|
}
|
|
BOOL CSequenceProcessor_CSOT::SendResultToSignalControl( int nSingalIdx, CString strResultValue )
|
{
|
CSignalControl* pSignalControl = m_pSP2P->ISP2P_GetSignalControl();
|
if (pSignalControl == NULL) return FALSE;
|
|
if (pSignalControl->IsConnected() == FALSE) return FALSE;
|
|
const CSignalControlInfo* pSignalControlInfo = m_pSP2P->ISP2P_System_GetPCControlInfo();
|
if (pSignalControlInfo==NULL) return FALSE;
|
|
if (nSingalIdx<0 || nSingalIdx>=pSignalControlInfo->GetSendDataAddressCount()) return FALSE;
|
|
const SSignalSettingData* pSSignalSendAddr = pSignalControlInfo->GetSendDataAddress(nSingalIdx);
|
if (pSSignalSendAddr==NULL) return FALSE;
|
|
if (pSignalControl->WriteData(pSSignalSendAddr->strAddr, pSSignalSendAddr->nSize, strResultValue)==FALSE)
|
{
|
m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Send] Write Result Fail! "));
|
return FALSE;
|
}
|
|
m_pSP2P->ISP2P_DisplayMessage(_T("[PCControl_Send] Write Result : Name[%s], Addr[%s], Data[%s]"),
|
pSSignalSendAddr->strName, pSSignalSendAddr->strAddr, strResultValue);
|
|
return TRUE;
|
}
|
|
void CSequenceProcessor_CSOT::RecvWSIReflowResult( int nModuleIndex, const SWsiResult& measureResut )
|
{
|
return;
|
}
|
|
int CSequenceProcessor_CSOT::ChangeWsiReflowPointIndex( int nIdx )
|
{
|
switch(nIdx)
|
{
|
case CELL_TOP:
|
return TOP;
|
break;
|
case CELL_LEFT:
|
return LEFT;
|
break;
|
case CELL_RIGHT:
|
return RIGHT;
|
break;
|
case CELL_LEFTTOP:
|
return LEFTTOP;
|
break;
|
case CELL_RIGHTTOP:
|
return RIGHTTOP;
|
break;
|
case CELL_LEFTBOTTOM:
|
return LEFTBOTTOM;
|
break;
|
case CELL_RIGHTBOTTOM:
|
return RIGHTBOTTOM;
|
break;
|
case CELL_BOTTOM:
|
return BOTTOM;
|
break;
|
case CELL_LEFTNOTCH:
|
return LEFTNOTCH;
|
break;
|
case CELL_RIGHTNOTCH:
|
return RIGHTNOTCH;
|
break;
|
}
|
return 0;
|
}
|
|
BOOL CSequenceProcessor_CSOT::WsiReflowStartProcessing( CGlassResult *pGlassResult, int nPlanIndex/*=0*/ )
|
{
|
|
AFM_SetAFMTracking(FALSE);
|
// send wsi start
|
SetWsiType(5);
|
WSIAllReadySignal(0);
|
|
if(!WSIReflowAllStartSignal())
|
{
|
g_pLog->DisplayMessage(_T("[WSI] WSI Start Fail!!"));
|
}
|
|
CReviewProcessor* pReviewProcessor = m_pSP2P->ISP2P_GetReviewProcessor();
|
if(pGlassResult && pReviewProcessor)
|
{
|
// WsiStart
|
pReviewProcessor->SetJobID(pGlassResult->m_strJobID); // pGlassResult->m_strGlassID -> pGlassResult->m_strJobID º¯°æ
|
pReviewProcessor->SetOperID(pGlassResult->m_strOperID);
|
m_pSP2P->ISP2P_UpdateReviewProcessStatus(ReviewProcessStatus_WSIReflowStart, nPlanIndex);
|
|
// Send WsiPos to Motor
|
m_pSP2P->ISP2P_DisplayMessage(_T("[Motor] Send WsiReflow Point to Motor Started!"));
|
SendWsiReflowPositionToMotorControl(pGlassResult);
|
m_pSP2P->ISP2P_DisplayMessage(_T("[Motor] Send WsiReflow Point to Motor Ended!"));
|
|
MakeWSIUpLoadDirectory(pReviewProcessor->GetUploadImagePath());
|
|
return TRUE;
|
}
|
|
return FALSE;
|
}
|
|
BOOL CSequenceProcessor_CSOT::WsiUserStartProcessing( CGlassResult *pGlassResult, int nPlanIndex/*=0*/ )
|
{
|
// AFM Tracking ON
|
AFM_SetAFMTracking(FALSE);
|
|
SetWsiType(0);
|
WSIAllReadySignal(0);
|
|
// send wsi start
|
if(!WSIUserAllStartSignal())
|
{
|
g_pLog->DisplayMessage(_T("[WSI] WSI Start Fail!!"));
|
}
|
|
|
CReviewProcessor* pReviewProcessor = m_pSP2P->ISP2P_GetReviewProcessor();
|
if(pGlassResult && pReviewProcessor)
|
{
|
// WsiStart
|
pReviewProcessor->SetJobID(pGlassResult->m_strJobID); // pGlassResult->m_strGlassID -> pGlassResult->m_strJobID º¯°æ
|
pReviewProcessor->SetOperID(pGlassResult->m_strOperID);
|
m_pSP2P->ISP2P_UpdateReviewProcessStatus(ReviewProcessStatus_WSIStart, nPlanIndex);
|
|
// Send WsiPos to Motor
|
m_pSP2P->ISP2P_DisplayMessage(_T("[Motor] Send UserWsi Point to Motor Started!"));
|
SendWsiUserPositionToMotorControl(pGlassResult);
|
m_pSP2P->ISP2P_DisplayMessage(_T("[Motor] Send UserWsi Point to Motor Ended!"));
|
MakeWSIUpLoadDirectory(pReviewProcessor->GetUploadImagePath());
|
return TRUE;
|
}
|
|
return FALSE;
|
}
|
|
|
int CSequenceProcessor_CSOT::SendWsiReflowPositionToMotorControl( CGlassResult* pGlassResult )
|
{
|
CMotorControl *pMotorControl = m_pSP2P->ISP2P_GetMotorControl();
|
if(pMotorControl == NULL) return 0;
|
|
const CSystemInfo *pSystemInfo = m_pSP2P->ISP2P_System_GetSystemInfo();
|
if(pSystemInfo == NULL) return -1;
|
|
const CMotorControlInfo* pMotorInfo = m_pSP2P->ISP2P_System_GetMotorInfo();
|
if (pMotorInfo == NULL) return -2;
|
|
const CCoordCalibrator* pCoordCalibrator = m_pSP2P->ISP2P_GetCoordCalibrator();
|
if (pMotorInfo == NULL) return -3;
|
|
// set move count zero
|
for(int i=0; i<pSystemInfo->GetGantryInfoCount(); i++)
|
{
|
pMotorControl->GantrySetMoveCount(i, 0);
|
}
|
|
// set move delay time
|
pMotorControl->CommonSetAfDelayTime(pMotorInfo->GetAfDelayTime());
|
pMotorControl->CommonSetImageDelayTime(pMotorInfo->GetImageDelayTime());
|
pMotorControl->CommonSetWsiDelayTime(pMotorInfo->GetWsiDelayTime());
|
|
// get direction
|
int nDirectionX, nDirectionY;
|
pCoordCalibrator->GetTransDirection(nDirectionX, nDirectionY);
|
|
int nTotalCount = 0;
|
double dDefectPosX, dDefectPosY;
|
|
// WSI result count
|
for (int nModuleIdx=0; nModuleIdx<Module_GetModuleStatusCount(); nModuleIdx++)
|
{
|
CReviewResult* pWsiResult = pGlassResult->GetWsiReflowResult(nModuleIdx);
|
if (pWsiResult==NULL) continue;
|
const SCoordInfo* pCoordInfo = Module_GetCoordInfo(nModuleIdx);
|
if (pCoordInfo==NULL) continue;
|
CModuleStatus* pModuleStatus = Module_GetModuleStatus(nModuleIdx);
|
if (pModuleStatus == NULL) continue;
|
|
// get result index
|
int nStartIdx = pWsiResult->GetStartSReviewResultIndex();
|
int nEndIdx = pWsiResult->GetEndSReviewResultIndex();
|
nEndIdx = min(nEndIdx, (pWsiResult->GetSReviewResultCount()-1)) + 1; // set End Index
|
|
// [2017:3:8]-[WEZASW] : CameraOffset ¹üÀ§ º¯°æ (-1~1 => -5~5)
|
double m_dMinOffset = -5.0;
|
double m_dMaxOffset = 5.0;
|
|
// get wsi pos
|
VectorDouble vectorPosX, vectorPosY;
|
|
for (int nResultIdx=nStartIdx; nResultIdx<nEndIdx; nResultIdx++)
|
{
|
SReviewResult* pWsi = pWsiResult->GetSReviewResult(nResultIdx);
|
if (pWsi==NULL) continue;
|
|
// set defect pos
|
dDefectPosX = double(pWsi->nUMOriginX) / 1000.0;
|
dDefectPosY = double(pWsi->nUMOriginY) / 1000.0;
|
|
// trans glass to motor pos
|
pCoordCalibrator->TransGlass2Motor(pCoordInfo, dDefectPosX, dDefectPosY);
|
|
// set offset
|
ApplyMotorOffset(pWsi->nModuleIdx, -1, MotorOffsetCamera + MotorOffsetWSI, dDefectPosX, dDefectPosY);
|
|
// motor calibrate
|
CalibrateMotorPos(pWsi->nModuleIdx, dDefectPosX, dDefectPosY);
|
|
// add move pos
|
if((int)vectorPosX.size() < MAX_MOTOR_ADDRESS_SIZE)
|
{
|
pWsi->dTargetMotorX = dDefectPosX;
|
pWsi->dTargetMotorY = dDefectPosY;
|
vectorPosX.push_back(dDefectPosX);
|
vectorPosY.push_back(dDefectPosY);
|
|
g_pLog->DisplayMessage(_T("[WsiStart] %d Module, %d Point, Motor: %.3lf mm, %.3lf mm"), nModuleIdx, nResultIdx, dDefectPosX, dDefectPosY);
|
}
|
}
|
|
// move path to motor
|
if (pMotorControl->GantryWsiAutoGo(pModuleStatus->GetGantryIndex(), vectorPosX, vectorPosY, TRUE))
|
{
|
nTotalCount += (int)vectorPosX.size();
|
g_pLog->DisplayMessage(_T("[GantryAutoGo] (%d)Gantry Path Send Success!"), pModuleStatus->GetGantryIndex());
|
}
|
else
|
{
|
g_pLog->DisplayMessage(_T("[GantryAutoGo] (%d)Gantry Path Send Fail"), pModuleStatus->GetGantryIndex());
|
}
|
}
|
|
if (pMotorControl->CommonSetAutoWsiGoAll()==FALSE)
|
{
|
g_pLog->DisplayMessage(_T("[GantryAutoGo] All Gantry AutoWsi Fail!"));
|
return 0;
|
}
|
|
g_pLog->DisplayMessage(_T("[GantryAutoGo] All Gantry WsiReflow Success!"));
|
return nTotalCount;
|
}
|
BOOL CSequenceProcessor_CSOT::SendWsiUserPositionToMotorControl( CGlassResult* pGlassResult )
|
{
|
CMotorControl *pMotorControl = m_pSP2P->ISP2P_GetMotorControl();
|
if(pMotorControl == NULL) return 0;
|
|
const CSystemInfo *pSystemInfo = m_pSP2P->ISP2P_System_GetSystemInfo();
|
if(pSystemInfo == NULL) return -1;
|
|
const CMotorControlInfo* pMotorInfo = m_pSP2P->ISP2P_System_GetMotorInfo();
|
if (pMotorInfo == NULL) return -2;
|
|
const CCoordCalibrator* pCoordCalibrator = m_pSP2P->ISP2P_GetCoordCalibrator();
|
if (pMotorInfo == NULL) return -3;
|
|
// set move count zero
|
for(int i=0; i<pSystemInfo->GetGantryInfoCount(); i++)
|
{
|
pMotorControl->GantrySetMoveCount(i, 0);
|
}
|
|
// set move delay time
|
pMotorControl->CommonSetAfDelayTime(pMotorInfo->GetAfDelayTime());
|
pMotorControl->CommonSetImageDelayTime(pMotorInfo->GetImageDelayTime());
|
pMotorControl->CommonSetWsiDelayTime(pMotorInfo->GetWsiDelayTime());
|
|
// get direction
|
int nDirectionX, nDirectionY;
|
pCoordCalibrator->GetTransDirection(nDirectionX, nDirectionY);
|
|
int nTotalCount = 0;
|
double dDefectPosX, dDefectPosY;
|
|
//sjb
|
/*
|
VectorDouble vectorPosX2, vectorPosY2;
|
vectorPosX2.push_back(2635);
|
vectorPosX2.push_back(2635);
|
vectorPosX2.push_back(2635);
|
vectorPosX2.push_back(2635);
|
vectorPosX2.push_back(2635);
|
vectorPosX2.push_back(2635);
|
vectorPosX2.push_back(2635);
|
vectorPosX2.push_back(2635);
|
vectorPosX2.push_back(2635);
|
vectorPosX2.push_back(2635);
|
//
|
vectorPosY2.push_back(500);
|
vectorPosY2.push_back(400);
|
vectorPosY2.push_back(500);
|
vectorPosY2.push_back(400);
|
vectorPosY2.push_back(500);
|
vectorPosY2.push_back(400);
|
vectorPosY2.push_back(500);
|
vectorPosY2.push_back(400);
|
vectorPosY2.push_back(500);
|
vectorPosY2.push_back(400);
|
*/
|
// WSI result count
|
for (int nModuleIdx=0; nModuleIdx<Module_GetModuleStatusCount(); nModuleIdx++)
|
{
|
CReviewResult* pWsiUserResult = pGlassResult->GetWsiUserResult(nModuleIdx);
|
if (pWsiUserResult==NULL) continue;
|
const SCoordInfo* pCoordInfo = Module_GetCoordInfo(nModuleIdx);
|
if (pCoordInfo==NULL) continue;
|
CModuleStatus* pModuleStatus = Module_GetModuleStatus(nModuleIdx);
|
if (pModuleStatus == NULL) continue;
|
|
// get result index
|
int nStartIdx = pWsiUserResult->GetStartSReviewResultIndex();
|
int nEndIdx = pWsiUserResult->GetEndSReviewResultIndex();
|
nEndIdx = min(nEndIdx, (pWsiUserResult->GetSReviewResultCount()-1)) + 1; // set End Index
|
|
// [2017:3:8]-[WEZASW] : CameraOffset ¹üÀ§ º¯°æ (-1~1 => -5~5)
|
double m_dMinOffset = -5.0;
|
double m_dMaxOffset = 5.0;
|
|
// get wsi pos
|
VectorDouble vectorPosX, vectorPosY;
|
|
for (int nResultIdx=nStartIdx; nResultIdx<nEndIdx; nResultIdx++)
|
{
|
SReviewResult* pWsi = pWsiUserResult->GetSReviewResult(nResultIdx);
|
if (pWsi==NULL) continue;
|
|
// set defect pos
|
dDefectPosX = double(pWsi->nUMOriginX) / 1000.0;
|
dDefectPosY = double(pWsi->nUMOriginY) / 1000.0;
|
|
// trans glass to motor pos
|
pCoordCalibrator->TransGlass2Motor(pCoordInfo, dDefectPosX, dDefectPosY);
|
|
// set offset
|
ApplyMotorOffset(pWsi->nModuleIdx, -1, MotorOffsetCamera + MotorOffsetWSI, dDefectPosX, dDefectPosY);
|
|
// motor calibrate
|
CalibrateMotorPos(pWsi->nModuleIdx, dDefectPosX, dDefectPosY);
|
|
// add move pos
|
if((int)vectorPosX.size() < MAX_MOTOR_ADDRESS_SIZE)
|
{
|
pWsi->dTargetMotorX = dDefectPosX;
|
pWsi->dTargetMotorY = dDefectPosY;
|
vectorPosX.push_back(dDefectPosX);
|
vectorPosY.push_back(dDefectPosY);
|
}
|
}
|
|
// move path to motor
|
if (pMotorControl->GantryWsiAutoGo(pModuleStatus->GetGantryIndex(), vectorPosX, vectorPosY, TRUE))
|
//if (pMotorControl->GantryWsiAutoGo(pModuleStatus->GetGantryIndex(), vectorPosX2, vectorPosY2, TRUE))
|
{
|
nTotalCount += (int)vectorPosX.size();
|
//nTotalCount += (int)vectorPosX2.size();
|
g_pLog->DisplayMessage(_T("[GantryAutoGo] (%d)Gantry Path Send Success!, Point Count : %d"), pModuleStatus->GetGantryIndex(), (int)vectorPosX.size());
|
}
|
else
|
{
|
g_pLog->DisplayMessage(_T("[GantryAutoGo] (%d)Gantry Path Send Fail"), pModuleStatus->GetGantryIndex());
|
}
|
}
|
|
// all auto go
|
if (pMotorControl->CommonSetAutoWsiGoAll()==FALSE)
|
{
|
g_pLog->DisplayMessage(_T("[GantryAutoGo] All Gantry AutoWsi Fail!"));
|
return 0;
|
}
|
|
g_pLog->DisplayMessage(_T("[GantryAutoGo] All Gantry WsiUser Success!"));
|
return nTotalCount;
|
}
|
|
|
BOOL CSequenceProcessor_CSOT::CalculateWsiReflowPathPlan( CPrioritySorter* pPrioritySorter, CGlassResult *pGlassResult )
|
{
|
CPathScheduler *pReviewScheduler = m_pSP2P->ISP2P_GetReviewScheduler();
|
if (pGlassResult==NULL || pReviewScheduler==NULL || pPrioritySorter==NULL) return FALSE;
|
|
int nTotalModuleCount = m_pSP2P->ISP2P_GetModuleStatusCount();
|
int nReviewModuleCount = m_pSP2P->ISP2P_GetModuleStatusCount(ModuleType_Wsi);
|
int nPointCount = pPrioritySorter->GetSortingResultWsiReflowCount();
|
|
// point is zero?
|
if (nPointCount==0) return TRUE;
|
|
// get current glass pos review cameras
|
VectorPathData vecStartPathData;
|
for(int nIdx=0 ; nIdx<nTotalModuleCount ; nIdx++)
|
{
|
const CModuleStatus *pModuleStatus = Module_GetModuleStatus(nIdx);
|
if (pModuleStatus==NULL) continue;
|
|
if ( (pModuleStatus->GetModuleType() & ModuleType_Wsi) != ModuleType_Wsi)
|
{
|
continue;
|
}
|
|
const SMotorPosition* pMotorPosition = pModuleStatus->GetMotorPosition();
|
if (pMotorPosition==NULL) continue;
|
|
SPathData ptStartPath;
|
ptStartPath.nIndex = nIdx; // module index
|
ptStartPath.nPosX = (LONG)(pMotorPosition->dGlassPosX * 1000);
|
ptStartPath.nPosY = (LONG)(pMotorPosition->dGlassPosY * 1000);
|
vecStartPathData.push_back(ptStartPath);
|
}
|
|
// get user point result
|
VectorPathData vecPathData;
|
for (int nPosIdx=0; nPosIdx<nPointCount; nPosIdx++)
|
{
|
const SReviewResult *pSReviewResult = pPrioritySorter->GetSortingResultWsiReflow(nPosIdx);
|
if (pSReviewResult==NULL) continue;
|
|
SPathData pathData(pSReviewResult->nUMOriginX, pSReviewResult->nUMOriginY, pSReviewResult->nResultIdx);
|
vecPathData.push_back(pathData);
|
}
|
|
// calculate shortest path
|
if (pReviewScheduler->PathScheduling(vecPathData, vecStartPathData)>0)
|
{
|
m_pSP2P->ISP2P_DisplayMessage(_T("[ReviewScheduler] CalculatePath"));
|
|
for(int nModuleIdx=0; nModuleIdx<nReviewModuleCount; nModuleIdx++)
|
{
|
CPathSchedulerResult *pScheduleResult = pReviewScheduler->GetPathSchedulerResult(nModuleIdx);
|
if (pScheduleResult==NULL) continue;
|
|
// add reflow result
|
pGlassResult->AddWsiReflowResult(CReviewResult(nModuleIdx));
|
|
// get user result
|
CReviewResult *pReviewResult = pGlassResult->GetWsiReflowResult(nModuleIdx);
|
if(pReviewResult == NULL) return FALSE;
|
|
// get sreview result
|
ReviewScheduler_ResizeWsiReflowResult(pScheduleResult, pReviewResult, pPrioritySorter, pScheduleResult->GetPathSchedulerResultCount());
|
|
// add user schedule result
|
pGlassResult->AddWsiReflowScheduleRedult(*pScheduleResult);
|
|
// CString strFilename = _T("");
|
// strFilename.Format(_T("c:\\%d_module_wsireflow_path.csv"), nModuleIdx);
|
// CPathSchedulerResult::SaveResult(strFilename, *pScheduleResult);
|
}
|
}
|
else
|
{
|
return FALSE;
|
}
|
|
return TRUE;
|
}
|
|
|
BOOL CSequenceProcessor_CSOT::CalculateWsiUserPathPlan( CPrioritySorter* pPrioritySorter, CGlassResult *pGlassResult )
|
{
|
CPathScheduler *pReviewScheduler = m_pSP2P->ISP2P_GetReviewScheduler();
|
if (pGlassResult==NULL || pReviewScheduler==NULL || pPrioritySorter==NULL) return FALSE;
|
|
int nTotalModuleCount = m_pSP2P->ISP2P_GetModuleStatusCount();
|
int nReviewModuleCount = m_pSP2P->ISP2P_GetModuleStatusCount(ModuleType_Wsi);
|
int nPointCount = pPrioritySorter->GetSortingResultWsiUserCount();
|
|
// point is zero?
|
if (nPointCount==0) return TRUE;
|
|
// get current glass pos review cameras
|
VectorPathData vecStartPathData;
|
for(int nIdx=0 ; nIdx<nTotalModuleCount ; nIdx++)
|
{
|
const CModuleStatus *pModuleStatus = Module_GetModuleStatus(nIdx);
|
if (pModuleStatus==NULL) continue;
|
|
if ( (pModuleStatus->GetModuleType() & ModuleType_Wsi) != ModuleType_Wsi)
|
{
|
continue;
|
}
|
|
const SMotorPosition* pMotorPosition = pModuleStatus->GetMotorPosition();
|
if (pMotorPosition==NULL) continue;
|
|
SPathData ptStartPath;
|
ptStartPath.nIndex = nIdx; // module index
|
ptStartPath.nPosX = (LONG)(pMotorPosition->dGlassPosX * 1000);
|
ptStartPath.nPosY = (LONG)(pMotorPosition->dGlassPosY * 1000);
|
vecStartPathData.push_back(ptStartPath);
|
}
|
|
// get user point result
|
VectorPathData vecPathData;
|
for (int nPosIdx=0; nPosIdx<nPointCount; nPosIdx++)
|
{
|
const SReviewResult *pSReviewResult = pPrioritySorter->GetSortingResultWsiUser(nPosIdx);
|
if (pSReviewResult==NULL) continue;
|
|
SPathData pathData(pSReviewResult->nUMOriginX, pSReviewResult->nUMOriginY, pSReviewResult->nResultIdx);
|
vecPathData.push_back(pathData);
|
}
|
|
// calculate shortest path
|
if (pReviewScheduler->PathScheduling(vecPathData, vecStartPathData)>0)
|
{
|
m_pSP2P->ISP2P_DisplayMessage(_T("[ReviewScheduler] CalculatePath"));
|
|
for(int nModuleIdx=0; nModuleIdx<nReviewModuleCount; nModuleIdx++)
|
{
|
CPathSchedulerResult *pScheduleResult = pReviewScheduler->GetPathSchedulerResult(nModuleIdx);
|
if (pScheduleResult==NULL) continue;
|
|
// add reflow result
|
pGlassResult->AddWsiUserResult(CReviewResult(nModuleIdx));
|
|
// get user result
|
CReviewResult *pReviewResult = pGlassResult->GetWsiUserResult(nModuleIdx);
|
if(pReviewResult == NULL) return FALSE;
|
|
// get sreview result
|
ReviewScheduler_ResizeWsiUserResult(pScheduleResult, pReviewResult, pPrioritySorter, pScheduleResult->GetPathSchedulerResultCount());
|
|
// add user schedule result
|
pGlassResult->AddWsiUserScheduleRedult(*pScheduleResult);
|
|
// CString strFilename = _T("");
|
// strFilename.Format(_T("c:\\%d_module_wsireflow_path.csv"), nModuleIdx);
|
// CPathSchedulerResult::SaveResult(strFilename, *pScheduleResult);
|
}
|
}
|
else
|
{
|
return FALSE;
|
}
|
|
return TRUE;
|
|
}
|
|
|
void CSequenceProcessor_CSOT::ReviewScheduler_ResizeWsiReflowResult( CPathSchedulerResult* pScheduleResult, CReviewResult* pReviewResult, CPrioritySorter* pPrioritySorter, int nSize)
|
{
|
pReviewResult->Reset();
|
int nResultIdx = 0;
|
|
int nModuleIdx = pScheduleResult->GetModuleIndex();
|
pReviewResult->SetModuleIndex(nModuleIdx);
|
|
CModuleStatus *pModuleStatus = m_pSP2P->ISP2P_GetModuleStatus(nModuleIdx);
|
if (pModuleStatus==NULL) return;
|
|
CRsRcpReviewInfo *pRsRcpReviewInfo = m_pSP2P->ISP2P_Recipe_GetRsRcpReviewInfo();
|
if (pRsRcpReviewInfo==NULL) return;
|
|
CRcpUserDefectInfo* pRcpUserDefectInfo;
|
|
CRcpAFMRecipeInfo *pRcpAFMRecipeInfo = pRsRcpReviewInfo->GetRcpAFMRecipeInfo(nModuleIdx);
|
if (pRcpAFMRecipeInfo==NULL) return;
|
|
int nZoomIdx = GetRealMagnification(nModuleIdx, pRcpAFMRecipeInfo->m_nZoomIndex);
|
|
SMagnificInfo *pMagnificInfo = pModuleStatus->GetMagnificInfo(nZoomIdx);
|
SCameraInfo *pCameraInfo = pModuleStatus->GetCameraInfo(0);
|
if (pMagnificInfo==NULL) return;
|
if (pCameraInfo==NULL) return;
|
|
CGlassResult* pGlassResult = m_pSP2P->ISP2P_GetCurrentGlassResult();
|
if(pGlassResult ==NULL) return;
|
|
CString strGlassLastName = pGlassResult->m_strGlassLastName;
|
|
for (int i=0; i<nSize; i++)
|
{
|
SSchedulerResult *pNode = pScheduleResult->GetPathSchedulerResult(i);
|
if (pNode==NULL) continue;
|
|
SReviewResult* sResult = pPrioritySorter->GetSortingResultWsiReflow(pNode->nTotalIndex);
|
if(sResult == NULL) continue;
|
|
sResult->nReviewType = ReviewType_WsiReflow;
|
sResult->nModuleIdx = nModuleIdx;
|
sResult->nResultIdx = nResultIdx;
|
|
sResult->nZoomIdx = nZoomIdx;
|
sResult->dMagnification = pMagnificInfo->dMagnification;
|
sResult->dMeasureResolution = pCameraInfo->dResolution / sResult->dMagnification;
|
sResult->bDigitalZoom = FALSE;
|
|
pRcpUserDefectInfo = pRsRcpReviewInfo->GetRcpUserDefectInfo(pNode->nTotalIndex);
|
if (pRcpUserDefectInfo == NULL) continue;
|
|
if(strGlassLastName.Compare(_T("B")) == 0 || strGlassLastName.Compare(_T("b")) == 0) sResult->strCellID = pRcpUserDefectInfo->GetCellId2();
|
else sResult->strCellID = pRcpUserDefectInfo->GetCellId();
|
|
sResult->nReflow_CellIndex = pRcpUserDefectInfo->m_nReflowCellIndex;
|
|
// Point Index Change
|
int nWsiReflowPointIndex = ChangeWsiReflowPointIndex(pRcpUserDefectInfo->GetCellSide());
|
|
sResult->nWsiReflowPositionIndex = nWsiReflowPointIndex;
|
|
pReviewResult->AddSReviewResult(*sResult);
|
|
nResultIdx++;
|
}
|
|
pScheduleResult->ResizeScheduleResult(nSize);
|
}
|
|
void CSequenceProcessor_CSOT::ReviewScheduler_ResizeWsiUserResult( CPathSchedulerResult* pScheduleResult, CReviewResult* pReviewResult, CPrioritySorter* pPrioritySorter, int nSize)
|
{
|
pReviewResult->Reset();
|
int nResultIdx = 0;
|
|
int nModuleIdx = pScheduleResult->GetModuleIndex();
|
pReviewResult->SetModuleIndex(nModuleIdx);
|
|
CModuleStatus *pModuleStatus = m_pSP2P->ISP2P_GetModuleStatus(nModuleIdx);
|
if (pModuleStatus==NULL) return;
|
|
CRsRcpReviewInfo *pRsRcpReviewInfo = m_pSP2P->ISP2P_Recipe_GetRsRcpReviewInfo();
|
if (pRsRcpReviewInfo==NULL) return;
|
|
CRcpUserDefectInfo* pRcpUserDefectInfo;
|
|
CRcpAFMRecipeInfo *pRcpAFMRecipeInfo = pRsRcpReviewInfo->GetRcpAFMRecipeInfo(nModuleIdx);
|
if (pRcpAFMRecipeInfo==NULL) return;
|
|
int nZoomIdx = GetRealMagnification(nModuleIdx, pRcpAFMRecipeInfo->m_nZoomIndex);
|
|
SMagnificInfo *pMagnificInfo = pModuleStatus->GetMagnificInfo(nZoomIdx);
|
SCameraInfo *pCameraInfo = pModuleStatus->GetCameraInfo(0);
|
if (pMagnificInfo==NULL) return;
|
if (pCameraInfo==NULL) return;
|
|
CGlassResult* pGlassResult = m_pSP2P->ISP2P_GetCurrentGlassResult();
|
if(pGlassResult ==NULL) return;
|
|
CString strGlassLastName = pGlassResult->m_strGlassLastName;
|
|
for (int i=0; i<nSize; i++)
|
{
|
SSchedulerResult *pNode = pScheduleResult->GetPathSchedulerResult(i);
|
if (pNode==NULL) continue;
|
|
SReviewResult* sResult = pPrioritySorter->GetSortingResultWsiUser(pNode->nTotalIndex);
|
if(sResult == NULL) continue;
|
|
sResult->nReviewType = ReviewType_WsiUser;
|
sResult->nModuleIdx = nModuleIdx;
|
sResult->nResultIdx = nResultIdx;
|
|
sResult->nZoomIdx = nZoomIdx;
|
sResult->dMagnification = pMagnificInfo->dMagnification;
|
sResult->dMeasureResolution = pCameraInfo->dResolution / sResult->dMagnification;
|
sResult->bDigitalZoom = FALSE;
|
|
pRcpUserDefectInfo = pRsRcpReviewInfo->GetRcpUserDefectInfo(pNode->nTotalIndex);
|
if (pRcpUserDefectInfo == NULL) continue;
|
|
if(strGlassLastName.Compare(_T("B")) == 0 || strGlassLastName.Compare(_T("b")) == 0) sResult->strCellID = pRcpUserDefectInfo->GetCellId2();
|
else sResult->strCellID = pRcpUserDefectInfo->GetCellId();
|
|
sResult->nReflow_CellIndex = pRcpUserDefectInfo->m_nReflowCellIndex;
|
|
// Point Index Change
|
//int nWsiReflowPointIndex = ChangeWsiReflowPointIndex(pRcpUserDefectInfo->GetCellSide());
|
|
//sResult->nWsiReflowPositionIndex = nWsiReflowPointIndex;
|
|
pReviewResult->AddSReviewResult(*sResult);
|
|
nResultIdx++;
|
}
|
|
pScheduleResult->ResizeScheduleResult(nSize);
|
}
|
|
|
BOOL CSequenceProcessor_CSOT::ChangeUserReviewAxisCenterPosition(const CGlassResult *pGlassResult)
|
{
|
if(m_pSP2P == NULL || pGlassResult == NULL) return FALSE;
|
|
const CSystemInfo *pSystemInfo = m_pSP2P->ISP2P_System_GetSystemInfo();
|
if(pSystemInfo == NULL) return FALSE;
|
|
CRsRcpReviewInfo* pRsRcpReviewInfo = m_pSP2P->ISP2P_Recipe_GetRsRcpReviewInfo();
|
if(pRsRcpReviewInfo == NULL) return FALSE;
|
|
if(pRsRcpReviewInfo->GetRcpUserDefectInfoCount() < 1) return TRUE; // °íÁ¤¸®ºä Ä«¿îÆ®°¡ ¾ø´Ù¸é ³Ñ¾î°¡ÀÚ
|
|
double dCenterPosX, dCenterPosY;
|
|
CReviewProcessor* pReviewProcessor = m_pSP2P->ISP2P_GetReviewProcessor();
|
|
for(int nUseCnt=0; nUseCnt<pRsRcpReviewInfo->GetRcpUserDefectInfoCount(); nUseCnt++)
|
{
|
CRcpUserDefectInfo *pUseInfo = pRsRcpReviewInfo->GetRcpUserDefectInfo(nUseCnt);
|
if(pUseInfo == NULL) continue;
|
|
double dGlassPosX = pUseInfo->m_dPosX;
|
double dGlassPosY = pUseInfo->m_dPosY;
|
|
if (pSystemInfo->m_nMachineType == 0 || pSystemInfo->m_nMachineType == 1 ||pSystemInfo->m_nMachineType == 2)
|
{
|
dCenterPosX = pReviewProcessor->GetCentertoOrginCoordinate(dGlassPosX*1000,-1,pGlassResult->GetCornerCutDir(),pGlassResult->GetOriginDir());
|
dCenterPosY = pReviewProcessor->GetCentertoOrginCoordinate(-1,dGlassPosY*1000,pGlassResult->GetCornerCutDir(),pGlassResult->GetOriginDir());
|
|
}
|
else if(pSystemInfo->m_nMachineType == 3 || pSystemInfo->m_nMachineType == 4 || pSystemInfo->m_nMachineType == 5)
|
{
|
dCenterPosY = pReviewProcessor->GetCentertoOrginCoordinate(dGlassPosX*1000,-1,pGlassResult->GetCornerCutDir(),pGlassResult->GetOriginDir());
|
dCenterPosX = pReviewProcessor->GetCentertoOrginCoordinate(-1,dGlassPosY*1000,pGlassResult->GetCornerCutDir(),pGlassResult->GetOriginDir());
|
}
|
|
pUseInfo->m_dPosX = dCenterPosX/= 1000.0;
|
pUseInfo->m_dPosY = dCenterPosY/= 1000.0;
|
}
|
|
return TRUE;
|
}
|
|
void CSequenceProcessor_CSOT::RemoveMotorCount()
|
{
|
CMotorControl* pMotorControl = m_pSP2P->ISP2P_GetMotorControl();
|
if(pMotorControl == NULL)
|
{
|
m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor] MotorControl Init Fail"));
|
return ;
|
}
|
|
const CSystemInfo *pSystemInfo = m_pSP2P->ISP2P_System_GetSystemInfo();
|
if(pSystemInfo == NULL) return;
|
|
for(int nGantryIdx = 0; nGantryIdx < pSystemInfo->GetGantryInfoCount(); nGantryIdx++)
|
{
|
pMotorControl->RemoveAllAutoGoCount(nGantryIdx);
|
}
|
}
|
|
BOOL CSequenceProcessor_CSOT::UpdateMemoryUserReflowPlanInfo(CDitGlassRawClient* pDitSharedGlassRaw)
|
{
|
CRsRcpReviewInfo* pRecipeinfo = m_pSP2P->ISP2P_Recipe_GetRsRcpReviewInfo();
|
if(pRecipeinfo == NULL) return FALSE;
|
|
_grmGlassData* pSharedGlassData = pDitSharedGlassRaw->GetGlassData();
|
if(pSharedGlassData == NULL) return FALSE;
|
|
//pSharedGlassData->m_nUserReviewNum = 0; //°øÀ¯ ¸Þ¸ð¸® User plan
|
|
_grmDefectData* pSharedDefect;
|
int nPointCount = pRecipeinfo->GetRcpUserDefectInfoCount(); // User ÁÂÇ¥ ÃÑ Ä«¿îÆ®
|
|
int nSharedDefectNum = pSharedGlassData->m_nDefectNum; // µðÆå ÃÑ°³¼ö User Idx ÀÇ Ã¹¹ø° Index °¡ µÈ´Ù
|
int nStartIdx=nSharedDefectNum;// USER µðÆå Á¾·ù IDX ºÎ¿©Çϱâ À§ÇÑ ½ÃÀÛÁ¡
|
|
CRcpPlanInfo* pRcpPlanInfo; // ·¹½ÃÇÇ Á¤º¸
|
CRcpUserDefectInfo *pDefectInfo;// ·¹½ÃÇÇ defect Á¤º¸
|
|
int nInsepectionType;// User ŸÀÔ Reviewreflow = 0 wsiReflow =1; REV&WSI =2; WSIUSEr =3; USER =4;
|
|
int nCount = 0;
|
|
for(int nPlanIndex = 0; nPlanIndex < pRecipeinfo->GetRcpPlanInfoCount(); nPlanIndex++)
|
{
|
nInsepectionType= -1;
|
|
pRcpPlanInfo = pRecipeinfo->GetRcpPlanInfo(nPlanIndex);
|
if(pRcpPlanInfo == NULL) continue;
|
|
//=======================USERRVIEW & REFLOW & WSI Reflow & WSI User===========================================
|
if(pRcpPlanInfo->m_nReviewType == CSOT_PlanUser || pRcpPlanInfo->m_nReviewType == CSOT_PlanReflow || pRcpPlanInfo->m_nReviewType == CSOT_PlanWsiUser ||pRcpPlanInfo->m_nReviewType == CSOT_PlanWsiReflow)
|
{
|
for (int nPointIdx=0; nPointIdx<nPointCount; nPointIdx++)
|
{
|
pDefectInfo = pRecipeinfo->GetRcpUserDefectInfo(nPointIdx);
|
if (pDefectInfo==NULL) continue;
|
|
pSharedDefect = pDitSharedGlassRaw->GetDefectData(nStartIdx);
|
|
nInsepectionType =pDefectInfo->GetInspectionMode();
|
|
if(CompareRevType(nInsepectionType,pRcpPlanInfo->m_nReviewType) )
|
{
|
nCount++;
|
|
if (pDefectInfo==NULL) continue;
|
|
pSharedDefect->clear();
|
pSharedDefect->m_nDefectIdx = nStartIdx;
|
pSharedDefect->m_nUMOriginX = int(pDefectInfo->m_dPosX*1000.0);
|
pSharedDefect->m_nUMOriginY = int(pDefectInfo->m_dPosY*1000.0);
|
pSharedDefect->m_nUMCenterAlignX = pSharedDefect->m_nUMOriginX - pSharedGlassData->m_nGlassSizeWidth/2;
|
pSharedDefect->m_nUMCenterAlignY = pSharedDefect->m_nUMOriginY - pSharedGlassData->m_nGlassSizeHeight/2;
|
|
|
pSharedDefect->m_ReviewDefect.m_nReflow_Index = nPointIdx;
|
pDefectInfo->m_nSharedDefectIndex = nStartIdx;
|
|
if(pRcpPlanInfo->m_nReviewType==CSOT_PlanUser)pSharedDefect->m_ReviewDefect.m_nPlanType = ditRaw::RPT_User;
|
else if(pRcpPlanInfo->m_nReviewType==CSOT_PlanReflow)pSharedDefect->m_ReviewDefect.m_nPlanType = ditRaw::RTP_Reflow;
|
else if(pRcpPlanInfo->m_nReviewType==CSOT_PlanWsiUser)pSharedDefect->m_ReviewDefect.m_nPlanType = ditRaw::RTP_UserWsi;
|
else pSharedDefect->m_ReviewDefect.m_nPlanType = ditRaw::RTP_WsiReflow;
|
|
nStartIdx++;
|
}
|
else
|
{
|
continue;
|
}
|
}
|
}
|
}
|
|
//pSharedGlassData->m_nUserReviewNum = nCount;
|
|
//m_pSP2P->ISP2P_DisplayMessage(_T("Fix Position Add Count : %d!!"), pSharedGlassData->m_nUserReviewNum);
|
|
return TRUE;
|
}
|
|
BOOL CSequenceProcessor_CSOT::CompareRevType(int nInsType,int nRevType)
|
{
|
//Plan ŸÀÔ°ú InspectionMode ºñ±³
|
if(nRevType ==CSOT_PlanUser)
|
{
|
if(nInsType == USER) return TRUE;
|
}
|
else if (nRevType == CSOT_PlanReflow)
|
{
|
if(nInsType == REVIEW_REFLOW) return TRUE;
|
}
|
else if (nRevType ==CSOT_PlanWsiReflow)
|
{
|
if(nInsType == WSI_REFLOW) return TRUE;
|
}
|
else if(nRevType==CSOT_PlanWsiUser)
|
{
|
if(nInsType == WSIUSER) return TRUE;
|
}
|
else
|
{
|
return FALSE;
|
}
|
return FALSE;
|
}
|
|
void CSequenceProcessor_CSOT::AllAckSignalOff()
|
{
|
if(m_pSP2P == NULL) return;
|
|
m_pSP2P->ISP2P_DisplayMessage(_T("==========================Ack Signal All Off Start!!"));
|
for (int i = 0; i < PCControlRecv_ReviewAckSignalCount;i++)
|
{
|
RecvSignalToSignalControl(PCControlRecvSignalIndex_Ack,i,TRUE);
|
}
|
|
for (int i = 0; i < PCControlSendSignalAckCount;i++)
|
{
|
SendSignalOffToSignalControl(PCControlSendSignalIndex_Ack, i);
|
}
|
m_pSP2P->ISP2P_DisplayMessage(_T("==========================Ack Signal All Off End!!"));
|
|
|
SendSignalOffToSignalControl(PCControlSendSignalIndex_State,PCControlSend_RecipeASCEND); //190723 recipe ASCEND bit off
|
}
|
|
void CSequenceProcessor_CSOT::WriteRawData(CGlassResult* pGlassResult)
|
{
|
g_pLog->DisplayMessage(_T("[Process_ReviewEnd] Result FILE WRITE IN"));
|
|
const CNetworkInfo *pNetworkInfo = m_pSP2P->ISP2P_System_GetNetworkInfo();
|
if (pNetworkInfo==NULL) return;
|
|
CString strMessage, strResultFilePath, strUploadResultFilePath, strLocalRawPath;
|
CString strUploadRawPath, strUploadImagePath, strAOIRawFileName, strAOIRawFilePath;
|
|
//3-1. ¸®ºä °á°ú ÆÄÀÏ ¾²±â
|
m_pSP2P->ISP2P_SetReviewResultData(pGlassResult);
|
|
strLocalRawPath = pNetworkInfo->m_strLocalRawPath;
|
strUploadRawPath = pNetworkInfo->m_strUploadRawPath;
|
strUploadImagePath = pNetworkInfo->m_strUploadImagePath;
|
strAOIRawFileName = pGlassResult->m_strAOIRawFileName;
|
strAOIRawFilePath = pGlassResult->m_strAOIRawFilePath;
|
|
if(strLocalRawPath.IsEmpty() == FALSE && strAOIRawFileName.IsEmpty() == FALSE)
|
{
|
// TD
|
if (pGlassResult->m_strResultDate.GetLength()>0)
|
{
|
strResultFilePath.Format(_T("%s\\%s\\%s"), strLocalRawPath, pGlassResult->m_strResultDate, strAOIRawFileName); // here mch
|
}
|
else
|
{
|
strResultFilePath.Format(_T("%s\\%s"), strLocalRawPath, strAOIRawFileName); // here mch
|
}
|
|
if(m_pSP2P->ISP2P_WriteGlassResultToAOIRawFile(pGlassResult, strResultFilePath, RESULT_FILE_TD))
|
{
|
m_pSP2P->ISP2P_DisplayMessage(_T("[TD] %s Result File Write Success!"), strResultFilePath);//
|
|
if(strUploadRawPath.IsEmpty() == FALSE && strAOIRawFilePath.IsEmpty() == FALSE)
|
{
|
// [2017:5:16]-[WEZASW] : ¸®ºä PASS½ÃÀÇ ¼³ºñ ¿î¿µÀÇ »óȲ¿¡ µû¶ó AOI Server°¡ RAW ÆÄÀÏ Á÷Á¢ ¾÷·Îµå ÁøÇà.
|
strUploadResultFilePath.Format(_T("%s\\%s"), strUploadRawPath, strAOIRawFileName);
|
|
if(CopyFile(strResultFilePath, strUploadResultFilePath, FALSE))
|
{
|
m_pSP2P->ISP2P_DisplayMessage(_T("[TD]Result File Upload Success![%s]"), strUploadResultFilePath);//
|
}
|
else
|
{
|
m_pSP2P->ISP2P_DisplayMessage(_T("[TD]Result File Upload Fail! Src[%s]"), strResultFilePath);//
|
m_pSP2P->ISP2P_DisplayMessage(_T("[TD]Result File Upload Fail! Dst[%s]"), strUploadResultFilePath);
|
}
|
}
|
}
|
else
|
{
|
m_pSP2P->ISP2P_DisplayMessage(_T("[TD]%s Result File Write Fail!"), strResultFilePath);
|
}
|
}
|
|
// delete file of Glass direction
|
DeleteFile(pNetworkInfo->m_strAOIRawPath + _T("\\") + pGlassResult->m_strJobID + _T("TD"));//pGlassResult->m_strGlassID -> m_StrJobID º¯°æ
|
|
// [2017:4:11]-[WEZASW] :CIM(DV Data) º¸°í Ç׸ñ Ãß°¡.
|
if (SendDVDataToSignalControl()==FALSE)
|
{
|
m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor::ReviewEnd] DV Data Send FAIL!"));
|
}
|
else
|
{
|
m_pSP2P->ISP2P_DisplayMessage(_T("[SequenceProcessor::ReviewEnd] DV Data Send Success!"));
|
}
|
}
|
|
BOOL CSequenceProcessor_CSOT::SendReviewStartMotorPosition( int nModuleIndex,double dPosX,double dPosY,int nMoveAxis )
|
{
|
|
return m_pSP2P->ISP2P_Motor_CameraGo(nModuleIndex,dPosX,dPosY,nMoveAxis);
|
|
}
|
|
BOOL CSequenceProcessor_CSOT::MoveReviewStartMotorPosition(CGlassResult* pGlassResult,int nReviewType)
|
{
|
//Ȥ½Ã³ª ¾²ÀϱîºÁ ³²°Üµã
|
//´ÙÀ½ Ç÷£ÀÇ Ã¹¹ø° À§Ä¡·Î À̵¿
|
|
double dDefectPosX,dDefectPosY = 0;
|
|
if(nReviewType == CSOT_PlanReview){
|
CReviewResult* pReviewResult = pGlassResult->GetReviewResult(0);
|
if(pReviewResult==NULL) return FALSE;
|
|
int nStartIdx = pReviewResult->GetStartSReviewResultIndex();
|
|
SReviewResult* pRev = pReviewResult->GetSReviewResult(nStartIdx);
|
|
if (pRev==NULL) return FALSE;
|
|
dDefectPosX = double(pRev->nUMOriginX) / 1000.0;
|
dDefectPosY = double(pRev->nUMOriginY) / 1000.0;
|
|
}
|
else if(nReviewType == CSOT_PlanUser){
|
|
CReviewResult* pReviewResult = pGlassResult->GetUserResult(0);
|
if(pReviewResult==NULL) return FALSE;
|
|
int nStartIdx = pReviewResult->GetStartSReviewResultIndex();
|
|
SReviewResult* pRev = pReviewResult->GetSReviewResult(nStartIdx);
|
if (pRev==NULL) return FALSE;
|
|
dDefectPosX = double(pRev->nUMOriginX) / 1000.0;
|
dDefectPosY = double(pRev->nUMOriginY) / 1000.0;
|
|
}
|
else if(nReviewType ==CSOT_PlanMeasure)
|
{
|
CReviewResult* pReviewResult = pGlassResult->GetMeasureResult(0);
|
if(pReviewResult==NULL) return FALSE;
|
|
int nStartIdx = pReviewResult->GetStartSReviewResultIndex();
|
|
SReviewResult* pRev = pReviewResult->GetSReviewResult(nStartIdx);
|
if (pRev==NULL) return FALSE;
|
|
dDefectPosX = double(pRev->nUMOriginX) / 1000.0;
|
dDefectPosY = double(pRev->nUMOriginY) / 1000.0;
|
}
|
else if(nReviewType ==CSOT_PlanReflow)
|
{
|
CReviewResult* pReviewResult = pGlassResult->GetReflowResult(0);
|
if(pReviewResult==NULL) return FALSE;
|
|
int nStartIdx = pReviewResult->GetStartSReviewResultIndex();
|
|
SReviewResult* pRev = pReviewResult->GetSReviewResult(nStartIdx);
|
if (pRev==NULL) return FALSE;
|
|
dDefectPosX = double(pRev->nUMOriginX) / 1000.0;
|
dDefectPosY = double(pRev->nUMOriginY) / 1000.0;
|
}
|
|
return SendReviewStartMotorPosition(0,dDefectPosX+1,dDefectPosY+1,0);
|
}
|
|
void CSequenceProcessor_CSOT::SendWsiErrorAlarm_CSOT(int Index) //190801 ÃÖÇü¸ñ
|
{
|
//wsi ¿¡·¯ ¾Ë¶÷
|
if(Index==1)
|
{
|
g_pLog->DisplayMessage(_T("[SequenceProcessor_CSOT] WSI Alive Error!!!"));
|
}
|
else
|
{
|
g_pLog->DisplayMessage(_T("[SequenceProcessor_CSOT] WSI Error!!!"));
|
}
|
SendSignalToSignalControl(PCControlSendSignalIndex_State,PCControlSend_WSIError,1000);
|
}
|
|
void CSequenceProcessor_CSOT::SendWsiAlive_CSOT()//190801 ÃÖÇü¸ñ
|
{
|
//WSI Alive ½ÅÈ£ ¹ÞÀ½
|
SetWSIAliveCheck(TRUE);
|
}
|
|
void CSequenceProcessor_CSOT::WSIAliveCheckRunThread_CSOT() //190801 ÃÖÇü¸ñ
|
{
|
CWinThread *pThread =NULL;
|
pThread = AfxBeginThread(WsiAliveCheckThread,this);
|
|
}
|
|
UINT CSequenceProcessor_CSOT::WsiAliveCheckThread( LPVOID pParam )//190801 ÃÖÇü¸ñ
|
{
|
DWORD dwTick = GetTickCount();
|
|
CSequenceProcessor_CSOT * m_pCSPC =(CSequenceProcessor_CSOT*) pParam;
|
|
while(1)
|
{
|
if(GetTickCount()-dwTick >=30000)
|
{
|
dwTick = GetTickCount();
|
|
if(bWsiAliveCheck ==FALSE){
|
m_pCSPC->SendWsiErrorAlarm_CSOT(1);
|
}
|
bWsiAliveCheck=FALSE; //30ÃÊ¿¡ Çѹø¾¿ 0À¸·Î ÃʱâÈ
|
|
}
|
}
|
return 1;
|
}
|
|
BOOL CSequenceProcessor_CSOT:: bWsiAliveCheck;
|
