mrDarker
2025-06-16 56fd8f57fcc763ae079ae752d82e41b38d7d9e5f
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
#pragma once
#include <string>
#include <list>
#include "IRemoteEquipment.h"
#include "Action.h"
#include "Data.h"
#include "Unit.h"
 
 
#define ACTION_GETNAME                1
#define ACTION_GETVERSION            2
#define ACTION_GETDEVICESTATE        3
#define ACTION_GETDOORSTATE            4
#define ACTION_GETALARMINFO            5
#define ACTION_GETSTEP                6
#define ACTION_GETDATA                7
#define ACTION_GETRECIPELIST        8
#define ACTION_RUNRECIPE            9
#define ACTION_LOADREADY            10
#define ACTION_LOADCOMPLETE            11
#define ACTION_UNLOADCOMPLETE        12
 
 
namespace BEQ {
    typedef std::function<void(void* pRemoteEiuipment)> ONREQCONNECTEDEX;
    typedef std::function<void(void* pRemoteEiuipment, int errorCode)> ONREQCONNECTFAILEDEX;
    typedef std::function<void(void* pRemoteEiuipment, const char* pszData, int len)> ONREQREADEX;
    typedef std::function<void(void* pRemoteEquipment, void* pUnit, REMOTE_EQ_EVENT eventCode)> ONREQEVENTUPDATE_EX;
 
    typedef struct _RemoteEquipmentListener
    {
        ONREQCONNECTEDEX        onConnecting;
        ONREQCONNECTEDEX        onConnected;
        ONREQCONNECTFAILEDEX    onConnectFailed;
        ONREQCONNECTEDEX        onDisconnecting;
        ONREQCONNECTEDEX        onDisconnected;
        ONREQREADEX                onRead;
        ONREQEVENTUPDATE_EX        onEventUpdate;
    } RemoteEquipmentListener;
 
    enum class REMOTE_EQ_NET_STATE
    {
        DISCONNECTED = 0,
        CONNECTING,
        CONNECTED,
        DISCONNECTING
    };
 
    class CRemoteEquipment :
        public IRemoteEquipment
    {
    public:
        CRemoteEquipment();
        CRemoteEquipment(const char* pszAddr, int port);
        ~CRemoteEquipment();
 
    public:
        virtual void setRemoteEquipmentListener(RemoteEquipmentListener listener);
        virtual int getAddr(char* pszBuffer, int nMaxCount);
        virtual int getPort();
        virtual int getName(char* pszBuffer, int nMaxCount);
        virtual int getVersion(char* pszBuffer, int nMaxCount);
        virtual bool isConnected();
        virtual int connect();
        virtual int close();
        virtual int reqGetAction(int type, const char* pszCommand, const char* pszUnitName = nullptr, const char* pszParams = nullptr);
        virtual int reqGetName();
        virtual int reqGetVersion();
        virtual int reqGetState(const char* pszUnitName);
        virtual int reqGetDoorState(const char* pszUnitName);
        virtual int reqGetAlarmInfo(const char* pszUnitName);
        virtual int reqGetStep(const char* pszUnitName);
        virtual int reqGetData(const char* pszUnitName);
        virtual int reqRecipeList(const char* pszUnitName);
        virtual int reqRunRecipe(const char* pszUnitName, int nRecipeId, const char* pszRecipeName);
        virtual IUnit* addUnit(const char* pszName, int nDoorCount);
        virtual IUnit* getUnit(const char* pszName);
        virtual const char** getAllUnitNames();
        virtual int getUnitCount() const;
        virtual ULONGLONG getConnectTick();
 
    public:
        inline void lock() { ::EnterCriticalSection(&m_cs); };
        inline void unlock() { ::LeaveCriticalSection(&m_cs); };
 
    private:
        void splitCString(const CString& strText, TCHAR delimiter = ',', std::function<void(const CString&, int)> callback = nullptr);
        void notifyEventUpdate(REMOTE_EQ_EVENT eventCode, CUnit* pUnit);
        void processDoorState(const CString& strPart, int index, int& doorState);
        void updateDoorState(const CString& strText, int& doorState, CUnit* pUnit);
        void parseAlarm(const CString& strText, CUnit* pUnit);
        void handleIdle(CUnit* pUnit);
        void handleMaterialReceived(const std::string& strMaterialId, CUnit* pUnit);
        void handleMaterialRemoved(const std::string& strMaterialId, CUnit* pUnit);
        void handleProcessingStarted(const std::string& strMaterialId, CUnit* pUnit);
        void handleProcessing(const std::string& strMaterialId, CUnit* pUnit, int svTime, int pvTime);
        void handleProcessingCompleted(const std::string& strMaterialId, CUnit* pUnit);
        void handleMachineProcess(const std::string& strMaterialId, const std::string& strStep, CUnit* pUnit, int svTime = 0, int pvTime = 0);
 
    private:
        void handleState(const std::map<std::string, std::string>& params, CUnit* pUnit);
        void handleDoorState(const std::map<std::string, std::string>& params, CUnit* pUnit);
        void handleAlarmInfo(const std::map<std::string, std::string>& params, CUnit* pUnit);
        void handleStep(const std::map<std::string, std::string>& params, CUnit* pUnit);
        void handleData(const std::map<std::string, std::string>& params, CUnit* pUnit);
        void handleRecipeList(const std::map<std::string, std::string>& params, CUnit* pUnit);
 
    private:
        BOOL initClient();
        static UINT WorkerThreadFunction(LPVOID lpvData);
        static UINT ActionsThreadFunction(LPVOID lpvData);
        static UINT TimeoutCheckThreadFunction(LPVOID lpvData);
        UINT WorkerThreadFunctionInner();
        UINT ActionsThreadFunctionInner();
        UINT TimeoutCheckThreadFunctionInner();
        void CurrentActionTimeout();
        int decode(char* pszBuffer, int nBufferSize);
 
    private:
        CRITICAL_SECTION m_cs;        // Í¬²½Ëø
        RemoteEquipmentListener m_listener;
        std::string m_strAddr;
        int m_nPort;
        int m_nLocalPort;
        std::string m_strName;
        std::string m_strVersion;
 
    private:
        SOCKET m_hSocket;
        REMOTE_EQ_NET_STATE m_remoteEqNetState;
        BOOL m_bWorking;
        WSAEVENT m_hWSAEvent;
        HANDLE m_hEventClose;        // µÈ´ýworkerÏß³ÌÍ˳öºó, Closeº¯Êý·µ»Ø
        HANDLE m_hEventWrite;
        HANDLE m_hEventActions;
        HANDLE m_hEventActionsThreadExit;
        HANDLE m_hEventTimeoutCheckThreadExit;
        CAction * m_pCurrentAction;
        std::list<CAction*> m_actions;
        BEQ::CData m_data;
 
    private:
        std::map<std::string, BEQ::CUnit*> m_units;
        ULONGLONG m_ullConnectTick;
    };
}