SDC C-Project CF Review 프로그램
LYW
2021-08-17 67bcdefa0aae33fcf16333967744a9aafcaf9433
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
243
244
245
#pragma once
 
#include <vector>
#include "CHCommonClasses/MacroFile.h"
 
interface ISignalControl2Parnet
{
    virtual void ISC2P_DisplayMessage(int nIndex, const TCHAR* lpstrFormat, ...) = 0;
    virtual void ISC2P_ReceiveSignal(int nIndex, int nSignalIndex, int nSignalValue, BOOL bOn=TRUE) = 0;
    virtual void ISC2P_SetSignalStatus(int nReadSignal, int nSendSignal, int nSendSignalWord = 0) = 0;
};
 
enum SignalConnectType        {    SignalConnectType_Simulation = 0, 
                                SignalConnectType_Plc, 
                                SignalConnectType_Dit_PcControl, 
                                SignalConnectType_Count };
 
enum SignalDelayIndex        {    SignalDelayIndex_Loading=0, 
                                SignalDelayIndex_AlignStart, 
                                SignalDelayIndex_AlignEnd, 
                                SignalDelayIndex_ReviewStart, 
                                SignalDelayIndex_ReviewEnd, 
                                SignalDelayIndex_Unloading,
                                SignalDelayIndex_Count };
 
enum ReceiveSignal            {    RecvSig_BypassMode=0, 
                                RecvSig_AutoMode, 
                                RecvSig_ManualMode, 
                                RecvSig_ReviewMode, 
                                RecvSig_Loading, 
                                RecvSig_AlignStart, 
                                RecvSig_AlignEnd, 
                                RecvSig_ReviewStart, 
                                RecvSig_ReviewEnd, 
                                RecvSig_Unloading, 
                                RecvSig_Count };
 
 
struct SSignalSettingData
{
    SSignalSettingData(int nIdx=-1, CString strN=_T(""), CString strA=_T(""), int nS=0)
    {
        nIndex = nIdx;
        strName = strN;
        strAddr = strA;
        nSize = nS;
    }
    ~SSignalSettingData()        { Reset(); }
 
    void Reset()
    {
        nIndex = -1;
        strName = _T("");
        strAddr = _T("");
        nSize = 0;
    }
 
    int        nIndex;
    CString    strName;
    CString strAddr;
    int        nSize;
};
typedef std::vector<SSignalSettingData>                        VectorSignalSettingData;
typedef std::vector<SSignalSettingData>::iterator            VectorSignalSettingDataIt;
typedef std::vector<SSignalSettingData>::const_iterator        constVectorSignalSettingDataIt;
 
typedef std::vector<int>        VectorInt;
typedef std::vector<CString>    VectorCString;
 
class CSignalControlInfo
{
public:
    CSignalControlInfo(int nIndex=0) : m_nIndex(nIndex)        { Reset(); }
    ~CSignalControlInfo(void)                                { Reset(); }
    void Reset()
    {
        m_nIndex                    = 0;
        m_strName                    = _T("");
        m_nPort                        = 0;
        m_nControllerType            = 0;
        m_nReceiveSignalCount        = 1;
        m_nSendSignalCount            = 1;
        m_nMSPeriod                    = 0;
        m_nMSTimerTime                = 0;
        m_nMSTotalTime                = 0;
        memset(m_pMsSignalDelayTime, 0x00, sizeof(int)*SignalDelayIndex_Count);
        m_bUseContinuousReadAddr    = FALSE;
        m_bUseContinuousSendAddr    = FALSE;
 
        m_vecReadSigAddr.clear();
        m_vecSendSigAddr.clear();
        m_vecReadDataAddr.clear();
        m_vecSendDataAddr.clear();
    }
    
    BOOL LoadInfo(CMacroFile* pFile, const CString& strItemName)
    {
        return FALSE;
    }
 
    BOOL SaveInfo(CMacroFile* pFile, const CString& strItemName)
    {
        return FALSE;
    }
 
    // getter
    int            GetIndex() const                    { return m_nIndex; }
    CString        GetName() const                        { return m_strName; }
    int            GetPort() const                        { return m_nPort; }
    int            GetControllerType() const            { return m_nControllerType; }
 
    int            GetReceiveSignalCount() const        { return m_nReceiveSignalCount; }
    int            GetSendSignalCount() const            { return m_nSendSignalCount; }
 
    int            GetMSPeriod() const                    { return m_nMSPeriod; }
    int            GetMSTimerTime() const                { return m_nMSTimerTime; }
    int            GetMSTotalTime() const                { return m_nMSTotalTime; }
    int*        GetDelayTimeData()                    { return &(m_pMsSignalDelayTime[0]); }
    int            GetMSLoadingSignalDelay() const        { return m_pMsSignalDelayTime[SignalDelayIndex_Loading]; }
    int            GetMSAlignStartSignalDelay() const    { return m_pMsSignalDelayTime[SignalDelayIndex_AlignStart]; }
    int            GetMSAlignEndSignalDelay() const    { return m_pMsSignalDelayTime[SignalDelayIndex_AlignEnd]; }
    int            GetMSReviewStartSignalDelay() const    { return m_pMsSignalDelayTime[SignalDelayIndex_ReviewStart]; }
    int            GetMSReviewEndSignalDelay() const    { return m_pMsSignalDelayTime[SignalDelayIndex_ReviewEnd]; }
    int            GetMSUnloadingSignalDelay() const    { return m_pMsSignalDelayTime[SignalDelayIndex_Unloading]; }
    int            GetDefocusValueMin()const            { return m_nDefocusValueMin; }
    int            GetDefocusValueMax()const            { return m_nDefocusValueMax; }
 
    BOOL        GetUseContinuousReadAddress() const { return m_bUseContinuousReadAddr; }
    BOOL        GetUseContinuousSendAddress() const { return m_bUseContinuousSendAddr; }
 
    int GetReadSignalAddressCount() const
    {
        return int(m_vecReadSigAddr.size());
    }
 
    CString GetReadSignalAddress(int nIdx) const
    { 
        if (nIdx<0 || nIdx>=int(m_vecReadSigAddr.size())) return _T("");
        return m_vecReadSigAddr[nIdx];
    }
 
    int GetSendSignalAddressCount() const
    {
        return int(m_vecSendSigAddr.size());
    }
 
    CString GetSendSignalAddress(int nIdx) const
    {
        if (nIdx<0 || nIdx>=int(m_vecSendSigAddr.size())) return _T("");
        return m_vecSendSigAddr[nIdx];
    }
 
    int    GetReadDataAddressCount() const
    {
        return int(m_vecReadDataAddr.size());
    }
 
    SSignalSettingData*    GetReadDataAddress(int nIdx)
    {
        if (nIdx<0 || nIdx>=int(m_vecReadDataAddr.size())) return NULL;
        return &m_vecReadDataAddr[nIdx];
    }
 
    const SSignalSettingData* GetReadDataAddress(int nIdx) const
    {
        if (nIdx<0 || nIdx>=int(m_vecReadDataAddr.size())) return NULL;
        return &m_vecReadDataAddr[nIdx];
    }
 
    int    CSignalControlInfo::GetSendDataAddressCount() const
    {
        return int(m_vecSendDataAddr.size());
    }
 
    SSignalSettingData*    GetSendDataAddress(int nIdx)
    {
        if (nIdx<0 || nIdx>=int(m_vecSendDataAddr.size())) return NULL;
        return &m_vecSendDataAddr[nIdx];
    }
 
    const SSignalSettingData* GetSendDataAddress(int nIdx) const
    {
        if (nIdx<0 || nIdx>=int(m_vecSendDataAddr.size())) return NULL;
        return &m_vecSendDataAddr[nIdx];
    }
 
 
    // setter
    void        SetIndex(int nIndex)                            { m_nIndex = nIndex; }
    void        SetName(const CString& strName)                    { m_strName = strName; }
    void        SetPort(int nPort)                                { m_nPort = nPort; }
    void        SetControllerType(int nType)                    { m_nControllerType = nType; }
    void        SetReceiveSignalCount(int nCount)                { m_nReceiveSignalCount = nCount; }
    void        SetSendSignalCount(int nCount)                    { m_nSendSignalCount = nCount; }
 
    void        SetMSPeriod(int nTime)                            { m_nMSPeriod = nTime; }
    void        SetMSTimerTime(int nTime)                        { m_nMSTimerTime = nTime; }
    void        SetMSLodingSignalDelay(int nTime)                { m_pMsSignalDelayTime[SignalDelayIndex_Loading] = nTime; }
    void        SetMSAlignStartSignalDelay(int nTime)            { m_pMsSignalDelayTime[SignalDelayIndex_AlignStart] = nTime; }
    void        SetMSAlignEndSignalDelay(int nTime)                { m_pMsSignalDelayTime[SignalDelayIndex_AlignEnd] = nTime; }
    void        SetMSReviewStartSignalDelay(int nTime)            { m_pMsSignalDelayTime[SignalDelayIndex_ReviewStart] = nTime; }
    void        SetMSReviewEndSignalDelay(int nTime)            { m_pMsSignalDelayTime[SignalDelayIndex_ReviewEnd] = nTime; }
    void        SetMSUnloadingSignalDelay(int nTime)            { m_pMsSignalDelayTime[SignalDelayIndex_Unloading] = nTime; }
    void        SetMSTotalTime(int nTime)                        { m_nMSTotalTime = nTime; }
    void        SetUseContinuousReadAddress(BOOL bUse)            { m_bUseContinuousReadAddr = bUse; }
    void        SetUseContinuousSendAddress(BOOL bUse)            { m_bUseContinuousSendAddr = bUse; }
    void        SetDefocusValueMin(int nValue)                    { m_nDefocusValueMin = nValue; }
    void        SetDefocusValueMax(int nValue)                    { m_nDefocusValueMax = nValue; }
 
 
    void        SetReadSignalAddressCount(int nCnt)                { m_vecReadSigAddr.resize(nCnt); }
    void        SetReadSignalAddress(CString strAddr)            { m_vecReadSigAddr.push_back(strAddr); }
    void        SetSendSignalAddressCount(int nCnt)                { m_vecSendSigAddr.resize(nCnt); }
    void        SetSendSignalAddress(CString strAddr)            { m_vecSendSigAddr.push_back(strAddr); }
    void        SetReadDataAddressCount(int nCnt)                { m_vecReadDataAddr.resize(nCnt); }
 
    void        SetReadDataAddress(const SSignalSettingData& data)    { m_vecReadDataAddr.push_back(data); }
    void        SetSendDataAddressCount(int nCnt)                    { m_vecSendDataAddr.resize(nCnt); }
    void        SetSendDataAddress(const SSignalSettingData& data)    { m_vecSendDataAddr.push_back(data); }
    
protected:
    // single - param
    int                        m_nIndex;
    CString                    m_strName;
    int                        m_nPort;
    int                        m_nControllerType;
    int                        m_nReceiveSignalCount;
    int                        m_nSendSignalCount;
    int                        m_nMSPeriod;
    int                        m_nMSTimerTime;
    int                        m_nMSTotalTime;
    int                        m_pMsSignalDelayTime[SignalDelayIndex_Count];
    int                        m_nDefocusValueMin;
    int                        m_nDefocusValueMax;
 
    BOOL                    m_bUseContinuousReadAddr;
    BOOL                    m_bUseContinuousSendAddr;
 
    // multi - address
    VectorCString            m_vecReadSigAddr;
    VectorCString            m_vecSendSigAddr;
 
    VectorSignalSettingData    m_vecReadDataAddr;
    VectorSignalSettingData    m_vecSendDataAddr;
};