chenluhua1980
2025-11-11 abeaf384ca65153fa9c66f8953cd0f68ad5f9f9f
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
#pragma once
#include <string>
#include <vector>
 
 
#define CHECK_READ_STEP_SIGNAL(addr, data, size) {                            \
    BOOL bFlag = isBitOn(data, size, addr);                                    \
    SERVO::CStep* pStep = getStep(addr);                                    \
    if (pStep != nullptr) {                                                    \
        ((CReadStep*)pStep)->onReadSignal(bFlag ? addr : 0);                \
    }                                                                        \
}
 
#define CHECK_WRITE_STEP_SIGNAL(addr, data, size) {                            \
    BOOL bFlag = isBitOn(data, size, addr);                                    \
    SERVO::CStep* pStep = getStep(addr);                                    \
    if (pStep != nullptr) {                                                    \
        ((CWriteStep*)pStep)->onRecvSignal(bFlag ? addr : 0);                \
    }                                                                        \
}
 
#define CHECK_RUN_ACTIVE_ROBOT_TASK(art) {                                    \
    if (art != nullptr) {                                                    \
        art->pick();                                                        \
        std::string strDescription = art->getDescription();                    \
        unlock();                                                            \
        if (m_listener.onRobotTaskEvent != nullptr) {                        \
            m_listener.onRobotTaskEvent(this, art, ROBOT_EVENT_CREATE);        \
        }                                                                    \
        LOGI("´´½¨ÐÂÈÎÎñ<%s>...", strDescription.c_str());                    \
        continue;                                                            \
    }                                                                        \
}
 
namespace SERVO {
#define BLOCK_BUFFER_MAX            1024
#define ALIVE_TIMEOUT                15
#define VCR_MAX                        1
#define PATH_MAX                    8
#define SIGNAL_MAX                    8
#define ARM_ALL                        99
 
    enum class RET {
        OK = 1,
        NG,
    };
    using JobDataRequestAck = RET;
 
    enum class InspResult
    {
        NotInspected = 0,  // ³õʼ»¯×´Ì¬£¬ÉÐδ¼ì²â
        Pass,              // ¼ì²âºÏ¸ñ
        Fail               // ¼ì²â²»ºÏ¸ñ
    };
 
    enum class PortType {
        Loading = 1,
        Unloading,
        Both,
        Buffer,
        LoaderInBuffer,
        UnloaderInBuffer,
        UnloadingPartial
    };
 
    enum class PortMode {
        OutOfService = 0,
        TransferBlocked,
        ReadyToLoad,
        ReadyToUnload,
        InService,
        TransferReady
    };
 
    enum class MaterialsType {
        G0 = 0,
        G1 = 1,
        G2 = 2,
        G1G2 = 3
    };
    typedef MaterialsType CassetteType;
 
    enum class TransferMode {
        MGVMode = 1,
        AGVMode,
        StockerInlineMode
    };
 
    // Memory Block ½á¹¹Ì嶨Òå
    typedef struct _MemoryBlock {
        unsigned int type;
        unsigned int start;
        unsigned int end;
        unsigned int size;
        char buffer[BLOCK_BUFFER_MAX];
    } MemoryBlock;
 
    // ALIVE
    typedef struct _ALIVE {
        BOOL flag;
        int count;
        BOOL alive;
    } ALIVE;
 
    enum class DISPATCHING_MODE {
        EAS = 1,
        Local = 2
    };
 
    enum class IDNEXER_OPERATION_MODE {
        Normal = 1,
        Clear_Out = 2,
        Cold_Run = 2,
        Start = 10,
        Stop = 11,
        Pause = 12,
        Resume = 13,
        Abort = 14,
        Cancel = 15,
    };
 
    enum class VCR_Reply_Code {
        OK = 1,
        NG,
        Job_Data_Request,
        VCR_Mismatch
    };
 
    // Robot cmd param
#define ROBOT_CMD_PARAM_SIZE        16            /* ·ÀÖ¹ÒÔºóÐÞ¸ÄROBOT_CMD_PARAMΪ²»ÊÇ4µÄÕûÊý±¶ */
    typedef struct _ROBOT_CMD_PARAM {
        short sequenceNo;
        short rcmd;
        short armNo;
        short getPosition;
        short putPosition;
        short getSlotNo;
        short putSlotNo;
        short subCmd;
    } ROBOT_CMD_PARAM;
 
    enum class RCMD {
        Robot_home = 1,
        Transfer,
        Move,
        Get,
        Put,
        One_Action_Exchange,
        Two_Action_Exchange,
        Command_Clear,
        Batch_get,
        Batch_put
    };
 
    enum class ROBOT_TASK_STATE {
        Ready = 0,
        Running,
        Picking,
        Picked,
        Placing,
        Restoring,
        Error,
        Abort,
        Restored,
        Completed
    };
 
    enum class ROBOT_STATUS {
        Setup = 0,
        Idle,
        Run,
        Pause,
        Stop,
        Moving,
    };
 
    enum class ROBOT_POSITION {
        Port1 = 0,
        Port2,
        Port3,
        Port4,
        Aligner,
        Fliper,
        Bonder1,
        Bonder2,
        Bake,
        Cooling,
        Measurement
    };
 
    /* Indexer Monitoring Status */
    /* Robot Monitoring Data */
    typedef struct _ROBOT_MONITORING_DATA {
        ROBOT_STATUS status;
        ROBOT_POSITION position;
        BOOL armState[2];
    } ROBOT_MONITORING_DATA, RMDATA;
 
    /* ¹¤ÒÕ(¼Ó¹¤´¦Àí)״̬ */
    enum class PROCESS_STATE {
        Ready = 0,
        Processing,
        Complete,
        Error
    };
 
    /* Port Status */
    struct SlotConfig {
        int nSlotID = 0;
        bool isEnabled = false;
    };
 
    struct PortConfig {
        int nMaterialType;               // ÎïÁÏÀàÐÍ£¬1: G1, 2: G2, 3: G1+G2
        std::string strPortName;       // ÀýÈç "Port 1"
        std::string strRecipe;         // ÀýÈç "P1001"
        std::string strLotID;
        std::string strProductID;
        std::string strOperationID;
        std::vector<SlotConfig> vecSlot;
    };
 
    /* EQ Data changed code */
#define EDCC_FETCHOUT_JOB                1000    /* È¡Æ¬ */
#define EDCC_STORED_JOB                    1001    /* ·ÅƬ */
 
 
    /* Cassette Ctrl CMD */
#define CCC_MAP_DOWNLOAD            1
#define CCC_CLAMP                    2
#define CCC_UNCLAMP                    3
#define CCC_RECLAMP                    4
#define CCC_PROCESS_START            5
#define CCC_PROCESS_START_BY_COUNT    6
#define CCC_PROCESS_PAUSE            7
#define CCC_PROCESS_RESUME            8
#define CCC_PROCESS_ABORT            9
#define CCC_PROCESS_CANCEL            10
#define CCC_PROCESS_END                11
#define CCC_ID_UPDATE                12
#define CCC_MAP_UPDATE                13
}