chenluhua1980
9 天以前 bca7e5d43c28757b3de88050e585eb40aa202bce
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
#pragma once
#include "Context.h"
#include <string>
#include "CPath.h"
#include "CJobDataA.h"
#include "CJobDataB.h"
#include "CJobDataC.h"
#include "CJobDataS.h"
#include "ServoCommo.h"
#include "ProcessJob.h"
#include "CParam.h"
 
 
namespace SERVO {
    /// Êý¾ÝÏʱ¼ä´Á + ÊýÖµ
    struct SVDataItem {
        std::chrono::system_clock::time_point timestamp;
        double value;  // »òÕ߸ù¾Ýʵ¼ÊÇé¿öʹÓÃÆäËûÀàÐÍ
 
        SVDataItem(std::chrono::system_clock::time_point ts, double val)
            : timestamp(ts), value(val) {}
    };
 
    /// PJ ÉúÃüÖÜÆÚ£¨Ìù½ü E40 ³£¼û״̬£©
    enum class GlsState : uint8_t {
        NoState = 0,
        Queued,
        InProcess,
        Paused,
        Completed,
        Aborted,
        Failed
    };
 
    class CGlass : public CContext
    {
    public:
        CGlass();
        virtual ~CGlass();
        void reset();
 
    public:
        virtual std::string& getClassName();
        virtual std::string toString();
        short getCassetteSequenceNo() const { return m_jobDataS.getCassetteSequenceNo(); }
        short getJobSequenceNo() const { return m_jobDataS.getJobSequenceNo(); }
        MaterialsType getType() const;
        void setType(MaterialsType type);
        void setID(const char* pszID);
        const std::string& getID() const;
        void setOriginPort(int port, int slot);
        void getOrginPort(int& port, int& slot);
        BOOL isScheduledForProcessing();
        void setScheduledForProcessing(BOOL bProcessing);
        CProcessJob* getProcessJob();
        void setProcessJob(CProcessJob* pProcessJob);
        CPath* getPathWithEq(unsigned int nEqId, unsigned int nUnit) const;
        CPath* getPath();
        void addPath(unsigned int nEqId, unsigned int nUnit, unsigned int slot);
        std::string getPathDescription() const;
        std::string getParamsDescription() const;
        void serialize(CArchive& ar);
        void setJobDataS(CJobDataS* pJobDataS);
        void updateJobDataS(CJobDataS* pJobDataS);
        CJobDataS* getJobDataS();
        BOOL setBuddy(CGlass* pGlass);
        BOOL forceSetBuddy(CGlass* pGlass);
        CGlass* getBuddy();
        const std::string& getBuddyId() const;
        void setBuddyId(std::string& strId);
        int processEnd(unsigned int nEqId, unsigned int nUnit);
        BOOL isProcessed(unsigned int nEqId, unsigned int nUnit);
        int setInspResult(unsigned int nEqId, unsigned int nUnit, InspResult result);
        InspResult getInspResult(unsigned int nEqId, unsigned int nUnit) const;
        InspResult getAOIInspResult() const;
 
    public:
        // ÐÂÔö״̬
        GlsState state() const noexcept { return m_state; }
        std::string getStateText();
        GlsState m_state{ GlsState::NoState };
        static void clampString(std::string& s, size_t maxLen);
        static std::string trimCopy(std::string s);
        std::string m_failReason;
 
        // ¡ª¡ª ×´Ì¬»ú£¨´øÊØÎÀ£©¡ª¡ª
        bool queue();           // NoState -> Queued
        bool start();           // Queued -> InProcess
        bool pause();           // InProcess -> Paused
        bool resume();          // Paused -> InProcess
        bool complete();        // InProcess -> Completed
        bool abort();           // Any (δÖÕ̬) -> Aborted
        bool fail(std::string reason); // ÈÎÒâ̬ -> Failed£¨¼Ç¼ʧ°ÜÔ­Òò£©
 
        // Ê±¼ä´Á
        std::optional<std::chrono::system_clock::time_point> m_tQueued;
        std::optional<std::chrono::system_clock::time_point> m_tStart;
        std::optional<std::chrono::system_clock::time_point> m_tEnd;
 
        // Ê±¼ä´Á£¨¿ÉÓÃÓÚ±¨±í/×·ËÝ£©
        std::optional<std::chrono::system_clock::time_point> tQueued() const { return m_tQueued; }
        std::optional<std::chrono::system_clock::time_point> tStart()  const { return m_tStart; }
        std::optional<std::chrono::system_clock::time_point> tEnd()    const { return m_tEnd; }
        void markQueued();
        void markStart();
        void markEnd();
 
        // ¹¤ÒÕ²ÎÊý
        void addParams(std::vector<CParam>& params);
        std::vector<CParam>& getParams();
 
        // ========== SVÊý¾Ý¹ÜÀí½Ó¿Ú£¨ÐÂÉè¼Æ£©==========
 
        // Ìí¼ÓÊý¾Ýµ½Ö¸¶¨»úÆ÷µÄÖ¸¶¨Êý¾ÝÀàÐÍ
        void addSVData(int machineId, const std::string& dataType, const SVDataItem& dataItem);
        void addSVData(int machineId, const std::string& dataType, double value); // ×Ô¶¯Ê¹Óõ±Ç°Ê±¼ä
        void addSVData(int machineId, const std::string& dataType, int64_t timestamp, double value);
 
        // ÅúÁ¿Ìí¼ÓÊý¾Ýµ½Ö¸¶¨»úÆ÷µÄÖ¸¶¨Êý¾ÝÀàÐÍ
        void addSVData(int machineId, const std::string& dataType, const std::vector<SVDataItem>& dataItems);
 
        // »ñȡָ¶¨»úÆ÷µÄÖ¸¶¨Êý¾ÝÀàÐ͵ÄËùÓÐÊý¾Ý
        std::vector<SVDataItem> getSVData(int machineId, const std::string& dataType) const;
 
        // »ñȡָ¶¨»úÆ÷µÄËùÓÐÊý¾ÝÀàÐÍ
        std::vector<std::string> getSVDataTypes(int machineId) const;
 
        // »ñȡָ¶¨»úÆ÷µÄËùÓÐÊý¾Ý£¨°´Êý¾ÝÀàÐÍ×éÖ¯£©
        std::unordered_map<std::string, std::vector<SVDataItem>> getMachineSVData(int machineId) const;
 
        // »ñÈ¡ËùÓлúÆ÷µÄÊý¾Ý
        const std::unordered_map<int, std::unordered_map<std::string, std::vector<SVDataItem>>>& getAllSVData() const;
 
        // ¼ì²éÖ¸¶¨»úÆ÷ÊÇ·ñÓÐÖ¸¶¨ÀàÐ͵ÄÊý¾Ý
        bool hasSVData(int machineId, const std::string& dataType) const;
 
        // ¼ì²éÖ¸¶¨»úÆ÷ÊÇ·ñÓÐÈκÎÊý¾Ý
        bool hasMachineSVData(int machineId) const;
 
        // »ñÈ¡ËùÓÐÓÐSVÊý¾ÝµÄ»úÆ÷ID
        std::vector<int> getMachineIdsWithSVData() const;
 
        // Çå¿ÕÖ¸¶¨»úÆ÷µÄÖ¸¶¨Êý¾ÝÀàÐ͵ÄÊý¾Ý
        void clearSVData(int machineId, const std::string& dataType);
 
        // Çå¿ÕÖ¸¶¨»úÆ÷µÄËùÓÐÊý¾Ý
        void clearMachineSVData(int machineId);
 
        // Çå¿ÕËùÓлúÆ÷µÄËùÓÐÊý¾Ý
        void clearAllSVData();
 
        // »ñȡָ¶¨»úÆ÷µÄÖ¸¶¨Êý¾ÝÀàÐ͵ÄÊý¾ÝÊýÁ¿
        size_t getSVDataCount(int machineId, const std::string& dataType) const;
 
        // »ñȡָ¶¨»úÆ÷µÄ×ÜÊý¾ÝÊýÁ¿
        size_t getMachineSVDataCount(int machineId) const;
 
        // »ñÈ¡ËùÓлúÆ÷µÄ×ÜÊý¾ÝÊýÁ¿
        size_t getTotalSVDataCount() const;
 
        // »ñȡָ¶¨Êý¾ÝÀàÐÍÔÚËùÓлúÆ÷ÖеÄÊý¾Ý
        std::vector<std::pair<int, SVDataItem>> findSVDataByType(const std::string& dataType) const;
 
    private:
        MaterialsType m_type;
        std::string m_strID;
        CPath* m_pPath;
        CJobDataS m_jobDataS;
        CGlass* m_pBuddy;
        std::string m_strBuddyId;
        int m_nOriginPort;
        int m_nOriginSlot;
        BOOL m_bScheduledForProcessing;            /* ÊÇ·ñ½«¼Ó¹¤´¦Àí */
        CProcessJob* m_pProcessJob;
        std::vector<CParam> m_params;            // ¹¤ÒÕ²ÎÊý
 
        // ÐµÄÈý²ãÊý¾Ý½á¹¹£º»úÆ÷ID -> Êý¾ÝÀàÐÍ -> Êý¾ÝÁбí
        std::unordered_map<int, std::unordered_map<std::string, std::vector<SVDataItem>>> m_svDatas;
    };
}