SDC C-Project CF Review 프로그램
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
#pragma once
#include <pdh.h>
#pragma comment(lib, "pdh.lib")
#include "SequenceProcessor.h"
//#include "akIPCNetAOISystem.h"
#include "akAOISharedSystem.h"//20191017
#include "DitGlassRawClient.h"
#include "DlgReviewHistoryTool.h"
 
 
enum PCControlRecvSignalIndex_CPJT    
{
    PCControlRecvSignalIndex_State=0, 
    //PCControlRecvSignalIndex_StateSub, 
    PCControlRecvSignalIndex_Seq, 
    PCControlRecvSignalIndex_Ack, 
    PCControlRecvSignalAutoDignosis,
    PCControlRecvSignalAutoDignosisComplet,
    PCControlRecvSignalTime,
    PCControlRecvSignalWsiState,
    //PCControlRecvSignalAutoDignosis
 
};
enum PCControlSendSignalIndex_CPJT
{
    PCControlSendSignalIndex_State = 0,
    PCControlSendSignalIndex_Seq,
    PCControlSendSignalIndex_Ack,
    PCControlSendSignalIndex_DiagnoAck,
    PCControlSendSignalIndex_DiagnoComplete,
    PCControlSendSignalIndex_Time
};
 
enum PCControlRecvSignalSeq_CPJT
{    
    PCControlRecv_Loading_CPJT=0,
    PCControlRecv_AlignStart_CPJT,
    PCControlRecv_ReadRawFile_CPJT,
    PCControlRecv_ReviewStart_CPJT,
    PCControlRecv_ReviewEnd_CPJT,
    PCControlRecv_ReviewUnloading_CPJT,
    PCControlRecv_AFM_Home_Move_CPJT,
    PCControlRecv_WSI_Home_Move_CPJT,
    PCControlRecv_TIME_SET,
    PCControlRecv_Autodiagnosis,
    RCControlRecv_AutoDiagnosisComplete
};
 
enum ProcessStatus_CPJT
{
    ProcessLoading_CPJT=0,
    ProcessAlignStart_CPJT, 
    ProcessReadRawFile_CPJT, 
    ProcessReviewStart_CPJT,
    ProcessReviewEnd_CPJT,
    ProcessReviewUnloding_CPJT
 
};
 
enum PCControlSendSignalSeq_CPJT
{    
    PCControlSend_LoadingComplete_CPJT=0,
    PCControlSend_AlignComplete_CPJT,
    PCControlSend_ReviewReady_CPJT,
    PCControlSend_ReviewComplete_CPJT,
    PCControlSend_ResultDataComplete_CPJT
};
 
enum PCControlSendSignalAck_CPJT
{    
    PCControlSend_LoadingAck_CPJT=0,
    PCControlSend_AlignStartAck_CPJT,
    PCControlSend_ReadRawFileAck_CPJT,
    PCControlSend_ReviewStartAck_CPJT,
    PCControlSend_ReviewEndAck_CPJT,
    PCControlSend_ReviewUnloadingAck_CPJT,
    PCControlSend_AFMHomeMoveAck_CPJT,
    PCControlSend_WSIHomeMoveAck_CPJT,
    PCControlSend_AutoDiagnosisAck_CPJT,
    PCControlSendSignalAckCount
}; 
 
enum PCControlRecvSignalAck_CPJT
{    
    PCControlRecv_LoadingCompleteAck_CPJT=0,
    PCControlRecv_AlignCompleteAck_CPJT,
    PCControlRecv_ReviewReadyAck_CPJT,
    PCControlRecv_ReviewCompleteAck_CPJT,
    PCControlRecv_ResultDataCompleteAck_CPJT,
    PCControlRecv_ReviewAckSignalCount
};
 
enum PCControlSendData_CPJT
{
    PCControlSendData_DV_DATA_CPJT=0,
    //PCControlSendData_SV_DATA_CPJT,
    PCControlSendData_LoadingResult_CPJT,
    PCControlSendData_AlignResult_CPJT,
    PCControlSendData_ReviewResult_CPJT,
    PCControlSendData_ReviewComplete_CPJT,
    PCControlSendData_ReviewResultFileCreateComplete_CPJT,
    PCControlSendData_AlarmCode_CPJT
};
 
enum PCControlRecvSignalState_B11
{    
    PCControlRecv_ByPassMode_CPJT=0,
    PCControlRecv_AutoMode_CPJT,
    PCControlRecv_ManualMode_CPJT,
    PCControlRecv_ReviewManualMode_CPJT 
};
 
enum PCControlSendSignalState
{
    PCControlSend_ReviewAlive_CPJT=0,
    PCControlSend_RecipeASCEND,
    PCControlSend_WSIError,
    PCControlSend_Defoucs,
    PCControlSend_Diagnosis //0412 ÀÚ°¡Áø´Ü ÄÚµåÃß°¡
};
 
enum PCControlRecvSignalState_WSI
{
    PCControlRecv_WSI_ALIVE = 0,
    PCControlRecv_WSI_AFM_SAFE_POS
};
 
 
 
enum ProcessMode_CPJT                    { ProcessBypassMode_CPJT=0, ProcessAutoMode_CPJT, ProcessManualMode_CPJT, ProcessReviewMode_CPJT};
enum ChangeZoomLevel_CPJT                { ZoomLevel_Manual_CPJT=0, ZoomLevel_Auto_CPJT};
enum AFMChangeModeToWSISignal_CPJT        { ChangeModeEnd_CPJT=0, ChangeModeStart_CPJT };
 
typedef std::vector<double>                    VectorDouble;
typedef std::vector<double>::iterator        VectorDoubleIt;
 
class CSequenceProcessor_CPJT :    public CSequenceProcessor
{
public:
    CSequenceProcessor_CPJT(void);
    virtual ~CSequenceProcessor_CPJT(void);
 
    virtual void    RecvWSIResult(int nModuleIndex, const SWsiResult& measureResut);
    virtual void    RecvWSIUserResult(int nModuleIndex, const SWsiResult& measureResut);
    virtual void    RecvWSIReflowResult(int nModuleIndex, const SWsiResult& measureResut);
    virtual void    RecvWSIMultiShotResult(int nModuleIndex, const SWsiResult& measureResut);
    virtual void    RecvAlignResult(const CAlignResult* pCurAlignResult);
 
    virtual BOOL    RecvSignalToSignalControl(int nSignalIndex, int nSignalValue, BOOL bSignalOn=TRUE);
    virtual BOOL    SendSignalToSignalControl(int nSignalIndex, int nSignalValue);
    virtual BOOL    SendSignalToSignalControl(int nSignalIndex, int nSignalValue,int nSignalOnTime);
 
    virtual BOOL    SendSignalOffToSignalControl(int nSignalIndex, int nSignalValue);
 
    virtual BOOL    RecvCIMSignalToSignalControl(int nAddrIndex, int nSignalIndex);
    virtual BOOL    SendCIMSignalToSignalControl(int nAddrIndex, int nSignalIndex);
 
    virtual BOOL    CIM_SendRecipeCreate(int nPPID)    {    return TRUE;    };
    virtual BOOL    CIM_SendRecipeDelete(int nPPID)    {    return TRUE;    };
    virtual BOOL    CIM_SendRecipeChange(int nPPID)    {    return TRUE;    };
    virtual BOOL    CIM_SendRecipeModify(int nPPID)    {    return TRUE;    };
 
    virtual void    CompletePlanIndex(int nReviewStatus, int nPlanIndex);
 
    virtual BOOL    CIM_SendAlignAlarmSignal(int nPPID)    {    return TRUE;    };
    virtual BOOL    CIM_SendNoPPIDSignal(int nPPID)        {    return TRUE;    };
 
    virtual BOOL    CalculateReviewPathPlan(CDefectPicker* pDefectPicker, CGlassResult *pGlassResult);
    virtual BOOL    CalculateReviewPathPlan(CDefectPicker* pDefectPicker, CGlassResult *pGlassResult, int nPlanIdx);
    virtual BOOL    CalculateUserPathPlan(CPrioritySorter* pPrioritySorter, CGlassResult *pGlassResult);
    virtual BOOL    CalculateWsiPathPlan(CDefectPicker* pDefectPicker, CGlassResult *pGlassResult);
    virtual BOOL    CalculateReflowPathPlan(CPrioritySorter* pPrioritySorter, CGlassResult *pGlassResult);
    virtual BOOL    CalculateWsiReflowPathPlan(CPrioritySorter* pPrioritySorter, CGlassResult *pGlassResult);
    virtual BOOL    CalculateWsiUserPathPlan(CPrioritySorter* pPrioritySorter, CGlassResult *pGlassResult);
    virtual BOOL    CalculateMeasurePathPlan(CPrioritySorter* pPrioritySorter, CGlassResult *pGlassResult);
    virtual BOOL    CalculateWsiMultiShotPathPlan(CDefectPicker* pDefectPicker, CGlassResult *pGlassResult);
 
    virtual BOOL    ReviewStartProcessing(CGlassResult *pGlassResult, int nPlanIndex=0);
    virtual BOOL    UserStartProcessing(CGlassResult *pGlassResult, int nPlanIndex=0);
    virtual BOOL    MeasureStartProcessing(CGlassResult *pGlassResult, int nPlanIndex=0);
    virtual BOOL    WsiStartProcessing(CGlassResult *pGlassResult, int nPlanIndex=0);
    virtual BOOL    ReflowStartProcessing(CGlassResult *pGlassResult, int nPlanIndex=0);
    virtual BOOL    WsiReflowStartProcessing(CGlassResult *pGlassResult, int nPlanIndex=0);
    virtual BOOL    WsiUserStartProcessing(CGlassResult *pGlassResult, int nPlanIndex=0);
    virtual BOOL    WsiMultiShotStartProcessing(CGlassResult *pGlassResult, int nPlanIndex = 0);
 
    void WsiMultiShotReScheduling(CGlassResult* pGlassResult);
 
    virtual void SetStartTickCount(DWORD dwTick) {
        dwRevStartTickCount = dwTick;
    }
    virtual void SetEndTickCount(DWORD dwTick) {
        dwRevEndTickCount = dwTick;
    }
    virtual DWORD GetStartTickCount() { return dwRevStartTickCount; };
    virtual DWORD GetEndTickCount() { return dwRevEndTickCount; };
 
protected:
    virtual void    WorkThreadProcess(PVOID pParameter);
 
    static UINT ReviewThread(LPVOID pParam);
 
    void ReviewDo();
 
    BOOL SetProcessStatus(int nProcessStatus);
 
    int nReviewCount;
    void SetReviewCount(int nCount) { nReviewCount = nCount; };
    int GetReviewCount() { return nReviewCount; };
    //#3358 KYH FDC µ¥ÀÌÅÍ Àü¼Û ½ÃÁ¡ °³¼± ADD START
    virtual void    MakeDVData2(); 
    //#3358 KYH FDC µ¥ÀÌÅÍ Àü¼Û ½ÃÁ¡ °³¼± ADD END
 
    int nHistoryCount = 0;
    void SetHistoryCount(int nCount) { nHistoryCount = nCount; }
    int GetHistoryCount() { return nHistoryCount; }
 
private:
    void    Process_Loading();
    void    Process_AlignStart();
    void    Process_ReadRawFile();
    void    Process_ReviewStart();
    void    Process_ReviewEnd();
    void    Process_ReviewUnloading();
 
    BOOL    ReJudgeProcessing(CDitGlassRawClient* pRawData);
 
    BOOL    FindRawBinFile(CString strFileName);
 
    int        ReJugdeWSIType(int nWsiType);
    BOOL    ProcessSignal_State(int nSignalValue, BOOL bSignalOn);
    //BOOL ProcessSignal_StateSub(int nSignalValue, BOOL bSignalOn);
    BOOL    ProcessSignal_Ack(int nSignalValue, BOOL bSignalOn);
    BOOL    ProcessSignal_Seq(int nSignalValue, BOOL bSignalOn);
    BOOL    ProcessSignal_Seq2(int nSignalValue, BOOL bSignalOn);
    BOOL    ProcessSignal_WSI_State(int nSignalValue, BOOL bSignalOn);
 
    // signal
    BOOL    SendResultToSignalControl(int nSingalIdx, int nResultValue);
    BOOL    SendResultToSignalControl(int nSingalIdx, CString strResultValue);
 
    // transfer data
    BOOL    ReadTransferDataFromSignalControl(STransferData* pTransferData);
    void    UpdateGlassResultFromTransferData(CGlassResult *pGlassResult, STransferData* pTransferData);
    void    UpdateHistoryResultFromTransferData(CGlassResult *pHistoryResult, CGlassResult* pGlassResult);
    void    CreateResultDirectory(const CString& strGlassID, const CString& strDate);
    void    SetSaveImageBasePathToReviewProcessor(const CString& strGlassID, const CString& strResultDate);
    void    SetSaveImageBasePathToAlignCameraControl(const CString& strGlassID);
 
    // recipe
    BOOL    ReadRecipeDataFromRecipeFile(const CString& strPPID_RC, CString& strRecipeName);
    BOOL    FindRecipeFileName(const CString& strPPID_RC, CString& strRecipeName);
    BOOL    ApplyRecipeDataToGlassResult(CGlassResult *pGlassResult);
 
    // result file
    BOOL    ReadAOIRawFileToGlassResult(CGlassResult *pGlassResult);
    BOOL    FindAOIRawFilePath(CGlassResult *pGlassResult, CString* pRawTDPath, CString* pRawCDPath, CString* pRawSDPath);
 
    // Resize Scheduler Result
    void    ReviewScheduler_ResizeReviewResult(CPathSchedulerResult* pScheduleResult, CReviewResult* pReviewResult, CDefectPicker* pDefectPicker, int nSize);
    void    ReviewScheduler_ResizeUserResult(CPathSchedulerResult* pScheduleResult, CReviewResult* pReviewResult, CPrioritySorter* pPrioritySorter, int nSize);
    void    ReviewScheduler_ResizeWsiResult(CPathSchedulerResult* pScheduleResult, CReviewResult* pWsiResult, CDefectPicker* pDefectPicker, int nSize);
    void    ReviewScheduler_ResizeReflowResult(CPathSchedulerResult* pScheduleResult, CReviewResult* pReviewResult, CPrioritySorter* pPrioritySorter, int nSize);
    void    ReviewScheduler_ResizeWsiReflowResult(CPathSchedulerResult* pScheduleResult, CReviewResult* pReviewResult, CPrioritySorter* pPrioritySorter, int nSize);
    void    ReviewScheduler_ResizeWsiUserResult( CPathSchedulerResult* pScheduleResult, CReviewResult* pReviewResult, CPrioritySorter* pPrioritySorter, int nSize);
    void    ReviewScheduler_ResizeWsiMultiShotResult(CPathSchedulerResult* pScheduleResult, CReviewResult* pReviewResult, CDefectPicker* pDefectPicker, int nSize);
 
    // motor control
    int        SendReviewPositionToMotorControl(CGlassResult *pGlassResult);
    int        SendUserPositionToMotorControl(CGlassResult *pGlassResult);
    int        SendMeasurePositionToMotorControl(CGlassResult *pGlassResult);
    int        SendMeasurePositionToMotorControl_Old(CGlassResult *pGlassResult);
    int        SendWsiPositionToMotorControl(CGlassResult* pGlassResult);
    int        SendReflowPositionToMotorControl(CGlassResult* pGlassResult);
    int        SendWsiReflowPositionToMotorControl(CGlassResult* pGlassResult);
    int     SendWsiUserPositionToMotorControl(CGlassResult* pGlassResult);
    int     SendWsiMultiShotPositionToMotorControl(CGlassResult* pGlassResult);
 
    // etc
    BOOL    ReviewScheduler_AddMeasureResult_ShortestPath(CPrioritySorter* pPrioritySorter, CGlassResult *pGlassResult, double dTacTime);
    BOOL    ReviewScheduler_AddMeasureResult(CPrioritySorter* pPrioritySorter, CGlassResult *pGlassResult);
    void    ReviewScheduler_ResizeMeasureResult(CPathSchedulerResult& scheduleResult, CReviewResult* pReviewResult, CPrioritySorter* pPrioritySorter, int nSize);
    int        ReviewScheduler_ResizeMeasureResult(CReviewResult* pReviewResult, CPrioritySorter* pPrioritySorter);
 
    int        GetCorrectMoudleStatusIdex(CPathSchedulerResult* pReviewScheduleResult, int nModuleType = 1);
    BOOL    IntVectorFinder(std::vector<int> TargetData, int FindData);
    int        SetModuleStatusForReviewResult(VectorReviewResult* pVecReviewResult, int nModuleType = 1);
    void    SetModuleStatusSReviewProcessor(CReviewResult* pReviewResult, int nModuleIdx);
    int        SetModuleStatusForWsiResult(VectorReviewResult* pVecWsiResult, int nModuleType = 4);
    void    SetModuleStatusSWsiProcessor(CReviewResult* pWsiResult, int nModuleIdx);
 
    // Check Motor Motion End
    BOOL    MotorMotionEnd();
 
    // Change Magnification
    BOOL    AllChangeMagnification(int nZoomIdx, int nCmd = ZoomLevel_Manual_CPJT, int nPlanMode=0);
 
    //Set DelayTime to Motor
    BOOL    SetDelayTimeToMotor();
 
    //Calculate Glass information
    int        GetDirectionX(int nGlassDirection, int nMotorDirection);
    int        GetDirectionY(int nGlassDirection, int nMotorDirection);
    
    // Sorting
    static BOOL CompareFuction(CModuleStatus* i, CModuleStatus* j);
    static BOOL GantrySorting(CReviewResult i, CReviewResult j);
 
    // Calculate Direction
    void    GetAxisDirection(int nOrgGlass, int nOrgRecipe, int &nDirX, int& nDirY);
    void    GetMeasureModuleIndex(int nDirX, int nDirY, int& nModuleIdx);
 
    // [2017:4:11]-[WEZASW] :CIM(DV Data) º¸°í Ç׸ñ Ãß°¡.
    BOOL    SendDVDataToSignalControl();
    int        MakeDVData(CGlassResult *pGlassResult, char* pDVData, int nIndex=0);
    DWORD   GetDiskUsage();
    // [2017:4:13]-[WEZASW] : CIM(Change System Time) º¸°í Ç׸ñ Ãß°¡.
    BOOL    ChangeReviewSystemTime();
    int        ReadCIMTimeData(CString strAddr, int nAddrCnt,  int& nData);
    BOOL    SendSystemTime(SYSTEMTIME sysTime);        // to AFM & WSI System
 
    // 181130 SJB, Change Point Index (Wsi Reflow)
    int        ChangeWsiReflowPointIndex(int nIdx);
 
    // 190130 SJB, Change CenterPosition
    BOOL    ChangeUserReviewAxisCenterPosition(const CGlassResult *pGlassResult);
 
    // 190130 SJB, Motor AutoGo Count Remove
    void    RemoveMotorCount();
 
    // 190130 SJB, User,Reflow Plan Memory Update
    BOOL    UpdateMemoryUserReflowPlanInfo(CDitGlassRawClient* pDitSharedGlassRaw);
    
    // 190130 SJB, All Ack Signal Off
    void    AllAckSignalOff();
 
    void    SetUseAfmHomePosition(BOOL bUse)            { m_bUseAFMHomePosition = bUse; }
    BOOL    GetUseAfmHomePosition()                        { return m_bUseAFMHomePosition; }
 
    // 190130 SJB, WriteRawData    -> Å×½ºÆ®¶§ ¾²·Á´Â°Ç°¡!?!?!? È¤½Ã ¸ô¶ó¼­ ³Ã°ÜµÒ
    void    WriteRawData(CGlassResult* pGlassResult);
    void MakeWSIUpLoadDirectory(CString strGlassID);
    BOOL CompareRevType(int nInsType,int nRevType);
    _ProtocolReview* pProtocolData; //cmark
 
    BOOL SendReviewStartMotorPosition(int nModuleIndex,double dPosX,double dPosY,int nMoveAxis);
    BOOL MoveReviewStartMotorPosition(CGlassResult* pGlassResult,int nReviewType);
 
    void SendWsiErrorAlarm_CPJT(int Index);
    void SendWsiAlive_CPJT();
    void WSIAliveCheckRunThread_CPJT();
    static UINT WsiAliveCheckThread(LPVOID pParam);
    BOOL GetWSIAliveCheck(){return bWsiAliveCheck;};
    void SetWSIAliveCheck(BOOL bCheck){ bWsiAliveCheck=bCheck;};
    static BOOL bWsiAliveCheck;
    BOOL GetLastPointCheck() {return bLastPointEndCheck;};
    void SetLastPointCheck(BOOL bCheck) { bLastPointEndCheck = bCheck; };
 
private:
    struct CompareModuleStatusX{
 
        CSequenceProcessor_CPJT* pSequenceProcessor;
 
        CompareModuleStatusX(CSequenceProcessor_CPJT* p) : pSequenceProcessor(p) {};
 
        bool operator()(int i, int j);
    };
 
    struct CompareModuleStatusY{
        CSequenceProcessor_CPJT* pSequenceProcessor;
 
        CompareModuleStatusY(CSequenceProcessor_CPJT* p) : pSequenceProcessor(p) {};
 
        bool operator()(int i, int j);
    };
 
    struct CompareReviewResultX{
        CSequenceProcessor_CPJT* pSequenceProcessor;
 
        CompareReviewResultX(CSequenceProcessor_CPJT* p) : pSequenceProcessor(p) {};
 
        bool operator()(CReviewResult i, CReviewResult j);
    };
 
    struct CompareReviewResultY{
        CSequenceProcessor_CPJT* pSequenceProcessor;
 
        CompareReviewResultY(CSequenceProcessor_CPJT* p) : pSequenceProcessor(p) {};
 
        bool operator()(CReviewResult i, CReviewResult j);
    };
 
    struct CompareWsiResultX{
        CSequenceProcessor_CPJT* pSequenceProcessor;
 
        CompareWsiResultX(CSequenceProcessor_CPJT* p) : pSequenceProcessor(p) {};
 
        bool operator()(CReviewResult i, CReviewResult j);
    };
 
    struct CompareWsiResultY{
        CSequenceProcessor_CPJT* pSequenceProcessor;
 
        CompareWsiResultY(CSequenceProcessor_CPJT* p) : pSequenceProcessor(p) {};
 
        bool operator()(CReviewResult i, CReviewResult j);
    };
 
 
protected:
    int                    m_nGlassCount;
    BOOL                m_nGlassCountCheck;
 
    BOOL                m_bUseAFMHomePosition;
    
    DWORD dwRevStartTickCount;
    DWORD dwRevEndTickCount;
 
    BOOL bLastPointEndCheck;
 
    BOOL bFileFind;
 
};