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
#pragma once
 
#include "Global_Define.h"
#include "EdgeInspector_AppView.h"
#include "LogManager.h"
#include "LightManager.h"
#include "Splash.h"
#include "Transfer_Data.h"
#include "HardwareSettings.h"
#include "GlassRecipe.h"
#include "Glass_Data.h"
#include "Thread_Send.h"
#include "Thread_CheckSeq.h"
#include "Thread_ViewRefresh.h"
#include "InspectCamera.h"
#include "PostProcess.h"
#include "StopWatch.h"
#include "LanguageControl.h"
#include "LicenseChecker.h"
#include "TriggerControl_Mvsol.h"
 
#if USE_WEBSOCKET
#include "WebSocketClientPool.h"
#endif // USE_WEBSOCKET
 
class CGrabberMulticam;
class CFrameBufferController;
class CInterfaceManager : public IMainFrameInterface2Parent
                        ,public ICheckSequenceInterface2Parent
                        ,public IPLCSendInterface2Parent
                        ,public IInspect2Sequence
                        ,public IViewRefreshInterface2Parent
{
public:
    CInterfaceManager(void);
    virtual ~CInterfaceManager(void);
 
protected:
    virtual void    IMI2P_PLC_ReceiveSignalValue(int nSignalIndex, int nValue);
 
    virtual void    CheckSeqMSG_Received(CCheckSeqMessage *pCheckSeq);
    virtual void    SendMSG_Received(CPostSendMessage *pSendMSG);
        
    virtual void    II2S_InspectionEnd(int iCamID,int iScan);    
 
    void            SendMsgInspectToControlSignal(CPostSendMessage *pNetMSG);
    void            SendMsgInspectToControlAlarm(CPostSendMessage *pNetMSG);    
 
    virtual void    Send_ViewRefresh(CScheduleViewMessage *pMSG);
 
protected:
    void            InitLoadingProcess();
    BOOL            GlassLoadingProcess();    
    int                Glass_Loading();
    BOOL            ReadTransferData(CString strTransItemFile);    
    BOOL            ScanStartProcess(ControlToInspect emSendSignal);
    BOOL            PLCScanEndProcess(ControlToInspect emSendSignal);
    BOOL            EMOGrabStopProcess(ControlToInspect emSendSignal);    
    BOOL            ScanStartGrabManual(int iCam,int iScan);
    BOOL            ScanStartManual(int iCam,int iScan, BOOL bRecipe=FALSE);
    BOOL            PostProcess();
    void            ScanOverTimeSignal();        
    
    static    UINT    ScanTimeOut(LPVOID pParam);
    void            ScanStartCamera(int iCam);
    static    UINT    ScanStartCam_0(LPVOID pParam);
    static    UINT    ScanStartCam_1(LPVOID pParam);
    static    UINT    ScanStartCam_2(LPVOID pParam);
    static    UINT    ScanStartCam_3(LPVOID pParam);
    static  UINT    CheckScanStart(LPVOID pParam);
    static UINT        PLCSignalThreadFunc(LPVOID pParam);
    static UINT        ScanEndProcess(LPVOID pParam);
 
protected:
    BOOL            InitInspect();
    BOOL            InitGrabber();
    BOOL            DeinitGrabber();    
 
    void            SetSlashText(EmSplashCmd emCommand, CString strLog, UINT nColor);    
    void            CreateThread();
    BOOL            DestroyThread();
    BOOL            InterfaceInit();
    BOOL            ReadHardwareSetting();
 
// Recipe
    BOOL            SendGlassRecipe(BOOL bAll=TRUE,int iCam=-1);
    BOOL            LoadGlassRecipe(CString strRecipe,BOOL bReadProfile);
    BOOL            AutoChangeRecipe();
    CString            GetRecipeName(int iRcpNo);;    
 
// Light    
    void            LightSetRecipeValue();
    void            LightTurnOnOff(BOOL bOn);
    void            LightChangeValue(int iCamera=-1,int nValue=0);
 
    void            PLCSignalRetry(SEND_MESSAGE_SECTION emSection,InspectToControlSignal emSendSignal,enInterface_Send_Control emControlSignal);
    BOOL            WaitEndSignal(InspectToControlSignal emSendSignal);
    
    void            SetInspectionEnd();
    BOOL            IsScanNow();    
    int                LoadFullImage(CString strPath,int iSide,int nStartY = 0, CGlass_Data *pGlassData = NULL, const bool bIsDebugImg = true);
    BOOL            SaveFullImage(CString strPath,int iSide,CPoint ptStart,int nLineCnt);
    BOOL            SaveFullImageModern(CString strPath,LPBYTE lpOrigin,int nImgWidth,int nImgHeight,int iSide,int nStartY,int nQuality = 50);
    LPBYTE            GetGrabBuffer(DimensionDir eDir,int iVline);
    BOOL            SetLiveGrabCommand(DimensionDir eDir,BOOL bStop);    
    void            WriteLogManager(TCHAR *str);
    void            WritePLCResult();
    void            Save_FullImg();
 
    void            SetGlassTimeOut();
 
    static UINT        CopyImageThreadFunc(LPVOID pParam);
 
 
    BOOL            CheckExpireDay();
    void            SetTriggerControl();
 
    int             MeasrueCutLineResult(DimensionDir dir);
    int             MeasrueChamferResult(DimensionDir dir);
 
    //ÅäÖòÎÊý, jiang
    void setLineCameraParamToSDK(void);
 
    long long GetCurrentTimestamp();
 
#if USE_WEBSOCKET
protected:
    void CreateWebSocketClients(WebSocketClientPool** wsClients, CString cstrURI, int nThreadCount);
    void DestroyWebSocketClients(WebSocketClientPool** wsClients);
 
protected:
    WebSocketClientPool* m_wsClients[MAX_CAMERA_COUNT];
#endif // USE_WEBSOCKET
 
#if USE_AI_DETECT
protected:
    //bool m_bUseAIDetect;
#endif // USE_AI_DETECT
 
// Instance
protected:
    CLogManager*                m_pLogManager;
    CSplash                        m_splash;
    CEdgeInspector_AppView*        m_pView;
    CTransDataManager*            m_pTransDataManager;
    CTransfer_Data                m_TransferData;
    CControl_Interface*            m_pControlInterface;    
    CLightManager*                m_pLightManager;
    CHardwareSettings            m_HardwareRecipe;
    CGlassRecipe                m_GlassRecipe;
    CInspectCamera*                m_pInspect[MAX_CAMERA_COUNT];    
    CGrabberControl*            m_pGrabber[MAX_CAMERA_COUNT];        
    CGlass_Data                    m_GlassData;
    CThread_SendMSG*            m_pThread_SendMSG;    
    CThread_CheckSequence*        m_pThread_CheckSequence;
    CThread_ViewRefresh*        m_pThread_ViewRefresh;
    CPostProcess                m_PostProcess;
    CCriticalSection            m_csScanStart;
    int                            m_nScanStartCount;
    BOOL                        m_bGlassLoadingEnd;
 
// Values
protected:
    std::multimap<int, CPoint*> m_mapProfile[MAX_DIMENSION_COUNT];
    std::multimap<int, CPoint*> m_mapAlignProfile[MAX_DIMENSION_COUNT];
    CPoint                        m_ptOriginMapProfile[MAX_DIMENSION_COUNT];
    CCriticalSection            m_csProfile;
    CCriticalSection            m_csPLCSignal;
    SEND_MESSAGE_SECTION        m_emPLCSection;
    InspectToControlSignal        m_emPLCSendSignal;
    enInterface_Send_Control    m_emPLCControlSignal;
    BOOL                        m_bShortPLCEnd;
    BOOL                        m_bLongPLCEnd;
    BOOL                        m_bShortPLCScanStart;
    BOOL                        m_bPLCGlassLoading;
    CString                        m_strReserveRecipe;
    BOOL                        m_bPostProcess;
    CStopWatch                    m_TactStopWatch;
    CLanguageControl            m_LanguageControl;
    CLicenseChecker*            m_pLicense;
    CTriggerControl_Mvsol*        m_pTriggerBoardControl;
 
protected:
    long long m_nStartTime;
};