SDC C-Project CF Review 프로그램
LYW
2021-07-08 630eb072cca33a7c633f6429a0b5a531d1b83268
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
#pragma once
 
#include "SequenceProcessor.h"
//#include "akIPCNetAOISystem.h"
#include "akAOISharedSystem.h"//20191017
#include "DitGlassRawClient.h"
 
enum PCControlRecvSignalIndex_CSOT    
{
    PCControlRecvSignalIndex_State=0, 
    PCControlRecvSignalIndex_StateSub, 
    PCControlRecvSignalIndex_Seq, 
    PCControlRecvSignalIndex_Ack 
};
enum PCControlSendSignalIndex_CSOT
{
    PCControlSendSignalIndex_State=0, 
    PCControlSendSignalIndex_Seq, 
    PCControlSendSignalIndex_Ack 
};
 
enum PCControlRecvSignalSeq_CSOT
{    
    PCControlRecv_Loading_CSOT=0,
    PCControlRecv_AlignStart_CSOT,
    PCControlRecv_ReadRawFile_CSOT,
    PCControlRecv_ReviewStart_CSOT,
    PCControlRecv_ReviewEnd_CSOT,
    PCControlRecv_AFM_Home_Move_CSOT,
    PCControlRecv_WSI_Home_Move_CSOT
};
 
enum ProcessStatus_CSOT
{
    ProcessLoading_CSOT=0,
    ProcessAlignStart_CSOT, 
    ProcessReadRawFile_CSOT, 
    ProcessReviewStart_CSOT,
    ProcessReviewEnd_CSOT 
};
 
enum PCControlSendSignalSeq_CSOT
{    
    PCControlSend_LoadingComplete_CSOT=0,
    PCControlSend_AlignComplete_CSOT,
    PCControlSend_ReviewReady_CSOT,
    PCControlSend_ReviewComplete_CSOT,
    PCControlSend_ResultDataComplete_CSOT
};
 
enum PCControlSendSignalAck_CSOT
{    
    PCControlSend_LoadingAck_CSOT=0,
    PCControlSend_AlignStartAck_CSOT,
    PCControlSend_ReadRawFileAck_CSOT,
    PCControlSend_ReviewStartAck_CSOT,
    PCControlSend_ReviewEndAck_CSOT,
    PCControlSend_AFMHomeMoveAck_CSOT,
    PCControlSend_WSIHomeMoveAck_CSOT,
    PCControlSendSignalAckCount
}; 
 
enum PCControlRecvSignalAck_CSOT
{    
    PCControlRecv_LoadingCompleteAck_CSOT=0,
    PCControlRecv_AlignCompleteAck_CSOT,
    PCControlRecv_ReviewReadyAck_CSOT,
    PCControlRecv_ReviewCompleteAck_CSOT,
    PCControlRecv_ResultDataCompleteAck_CSOT,
    PCControlRecv_ReviewAckSignalCount
};
 
enum PCControlSendData_CSOT
{
    PCControlSendData_DV_DATA_CSOT=0,
    PCControlSendData_SV_DATA_CSOT,
    PCControlSendData_LoadingResult_CSOT,
    PCControlSendData_AlignResult_CSOT,
    PCControlSendData_ReviewResult_CSOT,
    PCControlSendData_AlarmCode_CSOT
};
 
enum PCControlRecvSignalState_B11
{    
    PCControlRecv_ByPassMode_CSOT=0,
    PCControlRecv_AutoMode_CSOT,
    PCControlRecv_ManualMode_CSOT,
    PCControlRecv_ReviewManualMode_CSOT 
};
 
enum PCControlSendSignalState
{
    PCControlSend_ReviewAlive_CSOT=0,
    PCControlSend_RecipeASCEND,
    PCControlSend_WSIError,
    PCControlSend_Defoucs
};
 
 
enum ProcessMode_CSOT                    { ProcessBypassMode_CSOT=0, ProcessAutoMode_CSOT, ProcessManualMode_CSOT, ProcessReviewMode_CSOT};
enum ChangeZoomLevel_CSOT                { ZoomLevel_Manual_CSOT=0, ZoomLevel_Auto_CSOT};
enum AFMChangeModeToWSISignal_CSOT        { ChangeModeEnd_CSOT=0, ChangeModeStart_CSOT };
 
typedef std::vector<double>                    VectorDouble;
typedef std::vector<double>::iterator        VectorDoubleIt;
 
class CSequenceProcessor_CSOT :    public CSequenceProcessor
{
public:
    CSequenceProcessor_CSOT(void);
    virtual ~CSequenceProcessor_CSOT(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    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    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    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);
protected:
    virtual void    WorkThreadProcess(PVOID pParameter);
 
    static UINT ReviewThread(LPVOID pParam);
 
    void ReviewDo();
 
    BOOL SetProcessStatus(int nProcessStatus);
 
private:
    void    Process_Loading();
    void    Process_AlignStart();
    void    Process_ReadRawFile();
    void    Process_ReviewStart();
    void    Process_ReviewEnd();
 
    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);
 
    // 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    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);
 
    // 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);
 
    // 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_CSOT, 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);
 
    // [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_CSOT(int Index);
    void SendWsiAlive_CSOT();
    void WSIAliveCheckRunThread_CSOT();
    static UINT WsiAliveCheckThread(LPVOID pParam);
    BOOL GetWSIAliveCheck(){return bWsiAliveCheck;};
    void SetWSIAliveCheck(BOOL bCheck){ bWsiAliveCheck=bCheck;};
    static BOOL bWsiAliveCheck;
 
private:
    struct CompareModuleStatusX{
 
        CSequenceProcessor_CSOT* pSequenceProcessor;
 
        CompareModuleStatusX(CSequenceProcessor_CSOT* p) : pSequenceProcessor(p) {};
 
        bool operator()(int i, int j);
    };
 
    struct CompareModuleStatusY{
        CSequenceProcessor_CSOT* pSequenceProcessor;
 
        CompareModuleStatusY(CSequenceProcessor_CSOT* p) : pSequenceProcessor(p) {};
 
        bool operator()(int i, int j);
    };
 
    struct CompareReviewResultX{
        CSequenceProcessor_CSOT* pSequenceProcessor;
 
        CompareReviewResultX(CSequenceProcessor_CSOT* p) : pSequenceProcessor(p) {};
 
        bool operator()(CReviewResult i, CReviewResult j);
    };
 
    struct CompareReviewResultY{
        CSequenceProcessor_CSOT* pSequenceProcessor;
 
        CompareReviewResultY(CSequenceProcessor_CSOT* p) : pSequenceProcessor(p) {};
 
        bool operator()(CReviewResult i, CReviewResult j);
    };
 
    struct CompareWsiResultX{
        CSequenceProcessor_CSOT* pSequenceProcessor;
 
        CompareWsiResultX(CSequenceProcessor_CSOT* p) : pSequenceProcessor(p) {};
 
        bool operator()(CReviewResult i, CReviewResult j);
    };
 
    struct CompareWsiResultY{
        CSequenceProcessor_CSOT* pSequenceProcessor;
 
        CompareWsiResultY(CSequenceProcessor_CSOT* p) : pSequenceProcessor(p) {};
 
        bool operator()(CReviewResult i, CReviewResult j);
    };
 
 
protected:
    int                    m_nGlassCount;
    BOOL                m_nGlassCountCheck;
 
    BOOL                m_bUseAFMHomePosition;
};