LAPTOP-SNT8I5JK\Boounion
2025-04-30 d38d98d99e873d0a48e75aa9f8472cff4574c132
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
#pragma once
#include "Log.h"
#include "CCLinkIEControl.h"
#include "CSample.h"
#include "CPin.h"
#include "CEqModeStep.h"
#include "CEqStatusStep.h"
#include "CEqAlarmStep.h"
#include "CEqProcessStep.h"
#include "CEqCimModeChangeStep.h"
#include "CEqModeChangeStep.h"
#include "CEqCimMessageCmdStep.h"
#include "CEqCimMessageClearStep.h"
#include "CEqDateTimeSetCmdStep.h"
#include "CEqVCREnableStep.h"
#include "CEqPortChangeStep.h"
#include "CEqReadIntStep.h"
#include "CEqCassetteTransferStateStep.h"
#include "CEqCassetteCtrlCmdStep.h"
#include "CEqJobEventStep.h"
#include "CEqVcrEventStep.h"
#include "CEqCurrentRecipeChangeStep.h"
#include "CEqWriteStep.h"
#include "CEqReadStep.h"
#include <vector>
#include <map>
#include <list>
#include "CGlass.h"
 
 
namespace SERVO {
#define BLOCK_BUFFER_MAX            1024
#define ALIVE_TIMEOUT                15
#define VCR_MAX                        1
 
    typedef std::function<void(void* pEiuipment, BOOL bAlive)> ONALIVE;
    typedef std::function<void(void* pEiuipment, int code)> ONDATACHANGED;
    typedef std::function<void(void* pEiuipment, int state, int alarmId, int unitId, int level)> ONALARM;
    typedef std::function<void(void* pEiuipment, void* pReport)> ONVCREVENTREPORT;
    typedef struct _EquipmentListener
    {
        ONALIVE                onAlive;
        ONALIVE                onCimStateChanged;
        ONALARM                onAlarm;
        ONDATACHANGED        onDataChanged;
        ONVCREVENTREPORT    onVcrEventReport;
    } EquipmentListener;
 
    // 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;
 
    class CEquipment
    {
    public:
        CEquipment();
        virtual ~CEquipment();
 
 
    public:
        virtual const char* getClassName() = 0;
        virtual void setListener(EquipmentListener listener);
        void setCcLink(CCCLinkIEControl* pCcLink);
        void setBaseAlarmId(int nBaseId);
        int getBaseAlarmId();
        void setID(int nID);
        int getID();
        void setName(const char* pszName);
        std::string& getName();
        void setDescription(const char* pszDescription);
        std::string& getDescription();
        void setStation(int network, int station);
        const StationIdentifier& getStation();
        virtual void getAttributeVector(CAttributeVector& attrubutes);
        void setReadBitBlock(unsigned int start, unsigned int end);
        MemoryBlock& getReadBitBlock();
        void setWriteBitBlock(unsigned int start, unsigned int end);
        MemoryBlock& getWriteBitBlock();
        void getProperties(std::vector<std::pair<std::string, std::string>>& container);
        int addStep(unsigned int addr, CStep* pStep);
        CStep* getStep(unsigned int addr);
        CStep* getStepWithName(const char* pszName);
        std::map<unsigned int, CStep*>& getSteps();
        virtual void init();
        virtual void term();
        virtual void initPins() = 0;
        virtual void initSteps();
        virtual void onTimer(UINT nTimerid);
        virtual void serialize(CArchive& ar);
        virtual void onReceiveLBData(const char* pszData, size_t size);
        virtual int onStepEvent(CStep* pStep, int code);
        virtual CPin* addPin(PinType type, char* pszName);
        CPin* getPin(char* pszName);
        std::vector<CPin*>& CEquipment::getInputPins();
        std::vector<CPin*>& CEquipment::getOutputPins();
        virtual int recvIntent(CPin* pPin, CIntent* pIntent);
        virtual BOOL glassWillArrive(CGlass* pGlass);
        virtual int outputGlass(int port);
        virtual int glassArrived(CGlass* pGlass);
        void getGlassList(std::list<CGlass*>& list);
        CGlass* getFrontGlass();
        BOOL removeClass(CGlass* pGlass);
        bool isAlarmStep(SERVO::CStep* pStep);
        bool isVcrEventStep(SERVO::CStep* pStep);
        bool isCassetteTransferStateStep(SERVO::CStep* pStep);
        bool isPortTypeStep(SERVO::CStep* pStep);
        bool isPortModeStep(SERVO::CStep* pStep);
        bool isPortCassetteTypeStep(SERVO::CStep* pStep);
        bool isPortTransferModeStep(SERVO::CStep* pStep);
        bool isPortEnableStep(SERVO::CStep* pStep);
        bool isPortTypeAutoChangeEnableStep(SERVO::CStep* pStep);
        bool isCimMessageConfirmStep(SERVO::CStep* pStep);
        int setEqMode(short mode);
        int setCimMode(BOOL bOn);
        int setCimMessage(const char* pszMessage, short id, short nTouchPanelNo);
        int clearCimMessage(short id, short nTouchPanelNo);
        int setDateTime(short year, short month, short day, short hour, short minute, short second);
        
        // ÇëÇóÖ÷Åä·½Áбí
        // unitNo: 0:local; Others:unit No
        int masterRecipeListRequest(short unitNo);
 
 
    // ÒÔÏÂΪ´ÓCC-Link¶ÁÈ¡µ½µÄBit±ê־λ¼ì²âº¯Êý
    public:
        BOOL isAlive();
        BOOL isCimOn();
        BOOL isUpstreamInline();
        BOOL isDownstreamInline();
        BOOL isLocalAlarm();
        BOOL isAutoRecipeChange();
        BOOL isVCREnable(unsigned int index);
 
    protected:
        inline void Lock() { EnterCriticalSection(&m_criticalSection); }
        inline void Unlock() { LeaveCriticalSection(&m_criticalSection); }
        BOOL isBitOn(const char* pszData, size_t size, int index);
        inline BOOL equalBool(BOOL b1, BOOL b2);
        void addGlassToList(CGlass* pGlass);
 
    protected:
        EquipmentListener m_listener;
        int m_nID;
        std::string m_strName;
        std::string m_strDescription;
        CRITICAL_SECTION m_criticalSection;
        StationIdentifier m_station;
        MemoryBlock m_blockReadBit;
        MemoryBlock m_blockWriteBit;
        std::vector<CPin*> m_inputPins;
        std::vector<CPin*> m_outputPins;
        std::list<CGlass*> m_glassList;
 
 
        // ÒÔÏÂΪ´ÓCC-Link¶ÁÈ¡µ½µÄBit±ê־λ
    protected:
        ALIVE m_alive;
        BOOL m_bCimState;            // ON/OFF
        BOOL m_bUpstreamInline;
        BOOL m_bDownstreamInline;
        BOOL m_bLocalAlarm;
        BOOL m_bAutoRecipeChange;
        BOOL m_bVCREnable[VCR_MAX];
 
    protected:
        CCCLinkIEControl* m_pCclink;
        std::map<unsigned int, CStep*> m_mapStep;
        int m_nBaseAlarmId;
    };
}