Bond2
blame | 历史 | 原始文档
LAPTOP-SNT8I5JK\Boounion
2025-07-29 1e0e0a4401a783651398c2545e152013d6003939 
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

#pragma once


#include <list>


#include "CEquipment.h"


#include "CEFEM.h"


#include "CBonder.h"


#include "CLoadPort.h"


#include "CFliper.h"


#include "CAligner.h"


#include "CVacuumBake.h"


#include "CBakeCooling.h"


#include "CMeasurement.h"


#include "CArm.h"


#include "CArmTray.h"


#include "CCLinkIEControl.h"


#include "CRobotTask.h"


 


 


namespace SERVO {


    enum class MASTERSTATE {


        READY = 0,


        STARTING,


        RUNNING,


        STOPPING,


        MSERROR


    };


 


    typedef std::function<void(void* pMaster, MASTERSTATE state)> ONMASTERSTATECHANGED;


    typedef std::function<void(void* pMaster, CEquipment* pEiuipment, BOOL bAlive)> ONEQALIVE;


    typedef std::function<void(CStep* pStep, int code, void* pData)> ONEQSTEPEVENT;


    typedef std::function<void(void* pMaster, CEquipment* pEquipment, int state, int alarmId, int unitId, int level)> ONEQALARM;


    typedef std::function<void(void* pMaster, CEquipment* pEquipment, CVcrEventReport* pReport)> ONEQVCREVENTREPORT;


    typedef std::function<void(void* pMaster, CEquipment* pEquipment, int code)> ONEQDATACHANGED;


    typedef std::function<void(void* pMaster, CRobotTask* pTask, int code)> ONROBOTTASKEVENT;


    typedef std::function<void(void* pMaster, CEquipment* pEquipment, short status, __int64 data)> ONLOADPORTSTATUSCHANGED;


    typedef struct _MasterListener


    {


        ONMASTERSTATECHANGED    onMasterStateChanged;


        ONEQALIVE                onEqAlive;


        ONEQALIVE                onEqCimStateChanged;


        ONEQALARM               onEqAlarm;


        ONEQVCREVENTREPORT        onEqVcrEventReport;


        ONEQDATACHANGED         onEqDataChanged;


        ONROBOTTASKEVENT        onRobotTaskEvent;


        ONLOADPORTSTATUSCHANGED    onLoadPortStatusChanged;


    } MasterListener;


 


    class CMaster


    {


    public:


        CMaster();


        virtual ~CMaster();


 


 


    public:


        void setListener(MasterListener listener);


        CRobotTask* getActiveRobotTask();


        int init();


        int term();


        int start();


        int stop();


        void clearError();


        ULONGLONG getRunTime();


        MASTERSTATE getState();


        unsigned DispatchProc();


        unsigned ReadBitsProc();


        void onTimer(UINT nTimerid);


        std::list<CEquipment*>& getEquipmentList();


        CEquipment* getEquipment(int id);


        void setCacheFilepath(const char* pszFilepath);


        int abortCurrentTask();


        int restoreCurrentTask();


        int resendCurrentTask();


        void setPortType(unsigned int index, BOOL enable, int type, int mode,


            int cassetteType, int transferMode, BOOL autoChangeEnable);


        void setPortCassetteType(unsigned int index, SERVO::CassetteType type);


        void setPortEnable(unsigned int index, BOOL bEnable);


        void setCompareMapsBeforeProceeding(BOOL bCompare);


        void datetimeSync(SYSTEMTIME& time);


        void enableEventReport(bool bEnable);


        void enableAlarmReport(bool bEnable);


        bool isAlarmReportEnable();


 


    private:


        inline void lock() { EnterCriticalSection(&m_criticalSection); }


        inline void unlock() { LeaveCriticalSection(&m_criticalSection); }


        int addToEquipmentList(CEquipment* pEquipment);


        CLoadPort* addLoadPort(int index);


        CFliper* addFliper();


        CVacuumBake* addVacuumBake();


        CAligner* addAligner();


        CEFEM* addEFEM();


        CArm* addArm();


        CArmTray* addArmTray(int index);


        CBonder* addBonder(int index);


        CBakeCooling* addBakeCooling();


        CMeasurement* addMeasurement();


        void connectEquipments();


        int saveCache();


        int saveCacheAndBackups();


        int readCache();


        void serialize(CArchive& ar);


        void setState(MASTERSTATE state);


        CRobotTask* createTransferTask(CEquipment* pSrcEq, CEquipment* pTarEq,


            MaterialsType primaryType = MaterialsType::G1, MaterialsType secondaryType = MaterialsType::G2,


            int armNo = 1);


        CRobotTask* createTransferTask_bonder_to_bakecooling(CEquipment* pSrcEq, CEquipment* pTarEq);


        CRobotTask* createTransferTask_bake_to_cooling(CEquipment* pSrcEq);


        CRobotTask* createTransferTask_bakecooling_to_measurement(CEquipment* pSrcEq, CEquipment* pTarEq);


        CRobotTask* createTransferTask_restore(CEquipment* pEqSrc, CLoadPort** pPorts);


 


    private:


        CRITICAL_SECTION m_criticalSection;


        MasterListener m_listener;


        CCCLinkIEControl m_cclink;


        std::list<CEquipment*> m_listEquipment;


        std::string m_strFilepath;


        BOOL m_bDataModify;


 


    private:


        /* ¼à¿Ø±ÈÌØλµÄÏß³Ì*/


        HANDLE m_hEventReadBitsThreadExit[2];


        HANDLE m_hReadBitsThreadHandle;


        unsigned m_nReadBitsThreadAddr;


 


        // µ÷¶ÈÏß³Ì


        HANDLE m_hDispatchEvent;


        HANDLE m_hEventDispatchThreadExit[2];


        HANDLE m_hDispatchThreadHandle;


        unsigned m_nDispatchThreadAddr;


 


        // Æô¶¯Ê±¼ä£¬ÔËÐÐʱ¼ä£¬×´Ì¬


        ULONGLONG m_ullStartTime;


        ULONGLONG m_ullRunTime;


        MASTERSTATE m_state;


 


        // µ±Ç°ÈÎÎñºÍÒÑÍê³ÉÈÎÎñÁбí


        CRobotTask* m_pActiveRobotTask;


        std::list< CRobotTask* > m_listTask;


 


        // ´íÎó´úÂë


        int m_nLastError;


        std::string m_strLastError;


 


        // ÔÚ¿ªÊ¼¹¤ÒÕÇ°ÊÇ·ñÏÈÐèÒªÏȱȽÏmap


        BOOL m_isCompareMapsBeforeProceeding;


    private:


        bool m_bEnableEventReport;


        bool m_bEnableAlarmReport;


    };


}