mrDarker
2025-07-16 1dbe46cd9d0f181d08d5a69f72d8548628a13b9d
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
#pragma once
 
#include "Thread_ControlIF.h"
#include "TransDataManager.h"
#include "BICommon.h"
 
// MINI LED EI, NOTCH (狐傅)
// #define        MINI_LED_PLC_ADDR_SENDSIGNAL        2129
// #define        MINI_LED_PLC_TRASFERDATA_ADDR        2000
// #define        MINI_LED_PLC_ADDR_GLASS_JUDEMENT    2100
// #define        MINI_LED_PLC_ADDR_PROFILE_JUDEMENT    4300
 
// EI, NOTCH, RCUT (扁粮 BF)
#if MINI_LED
#define        EI_PLC_ADDR_SENDSIGNAL                2129
#define        EI_PLC_TRASFERDATA_ADDR                2000
#define        EI_PLC_ADDR_GLASS_JUDEMENT            2100
#else
#define        EI_PLC_ADDR_SENDSIGNAL                629
#define        EI_PLC_TRASFERDATA_ADDR                500
#define        EI_PLC_ADDR_GLASS_JUDEMENT            600
#endif
 
#define        EI_PLC_ADDR_PROFILE_JUDEMENT        4300
#define        EI_PLC_RECIPE_ADDR                    520
#define        EI_PLC_STAGE_NO_ADDR                521
 
enum    emInterface_Send_Control {emSnd_Vision_Alive=0, emSnd_Loading_Ack, emSnd_Short_ScanStart_Ack,emSnd_Short_ScanEnd_Ack, emSnd_Long_ScanStart_Ack,emSnd_Long_ScanEnd_Ack, emInterface_Snd_None};
enum    emInterface_Rcv_Control {emRcv_PLC_Alive=0, emRcv_Loading, emRcv_Short_Start, emRcv_Short_End, emRcv_Long_Start, emRcv_Long_End, emRcv_Grab_Stop_EMO, emInterface_Rcv_None};
 
#define    ALIVE_BIT(nValue, add, bit)     nValue= nValue | ((add)<<(bit));
#define IS_ALIVE_BIT(nValue, bit)         ((nValue & (0x01<<(bit))) >>(bit));
 
typedef struct _ST_PLC_RECIVE_BIT
{
    BOOL                    bPLCHeatbit;
    BOOL                    bGlassLoading;    
    BOOL                    bShortScanStart;        
    BOOL                    bShortScanEnd;                    
    BOOL                    bLongScanStart;        
    BOOL                    bLongScanEnd;                    
    BOOL                    bEMOGrabStop;
 
    _ST_PLC_RECIVE_BIT()
    {
        Reset();
    }
    _ST_PLC_RECIVE_BIT(int nPLCData)
    {    
        (nPLCData & 0x01)?    bPLCHeatbit=TRUE        :bPLCHeatbit=FALSE;
        (nPLCData & 0x02)?    bGlassLoading=TRUE        :bGlassLoading=FALSE;
        (nPLCData & 0x04)?    bShortScanStart=TRUE    :bShortScanStart=FALSE;
        (nPLCData & 0x08)?    bShortScanEnd=TRUE        :bShortScanEnd=FALSE;            
        (nPLCData & 0x10)?    bLongScanStart=TRUE        :bLongScanStart=FALSE;
        (nPLCData & 0x20)?    bLongScanEnd=TRUE        :bLongScanEnd=FALSE;
        (nPLCData & 0x40)?    bEMOGrabStop=TRUE        :bEMOGrabStop=FALSE;        
    }
    void Reset()
    {
        bPLCHeatbit = bGlassLoading = bShortScanStart = bShortScanEnd = bLongScanStart =FALSE;
        bLongScanEnd = bEMOGrabStop = FALSE;        
    }        
}ST_PLC_RECIVE_BIT,*pST_PLC_RECIVE_BIT;
 
typedef struct _ST_PLC_SEND_BIT
{
    BOOL    bServerAlive;
    BOOL    bGlassLoadingAck;        
    BOOL    bShortScanStartAck;
    BOOL    bShortScanEndAck;
    BOOL    bLongScanStartAck;
    BOOL    bLongScanEndAck;
 
    _ST_PLC_SEND_BIT()
    {
        bServerAlive = FALSE;
        Reset(FALSE);
    }
    void Reset(BOOL bSet)
    {        
        bGlassLoadingAck = bShortScanStartAck = bShortScanEndAck = bLongScanStartAck = bLongScanEndAck = bSet;                                    
    }
    void MakeSend(int &nSendData)
    {        
        nSendData = 0;    
        ALIVE_BIT(nSendData, bLongScanEndAck, 5);
        ALIVE_BIT(nSendData, bLongScanStartAck, 4);
        ALIVE_BIT(nSendData, bShortScanEndAck, 3);
        ALIVE_BIT(nSendData, bShortScanStartAck, 2);
        ALIVE_BIT(nSendData, bGlassLoadingAck, 1);
        ALIVE_BIT(nSendData, bServerAlive, 0);    
    }
}ST_PLC_SEND_BIT,*pST_PLC_SEND_BIT;
 
interface IControlInterface2MainInterface
{
    virtual void IControl2P_ReceiveSignalValue(emInterface_Rcv_Control emSignal, BOOL bValue) = 0;    
};
 
class CControl_Interface_New : public IControlInterface2Parent
{
public:
    CControl_Interface_New(void);
    virtual ~CControl_Interface_New(void);
 
public:    
    BOOL                IsConnect()                                                {return m_bConnect;}
    void                SetI2M(IControlInterface2MainInterface *pInterface)        {m_pInterface=pInterface;}
 
    // Connect & Disconnect
public:
    virtual BOOL        ControlProcess();
    virtual    BOOL        ConnectToControl();
    virtual BOOL        DisconnectToPLC();
 
    // Send & Write
public:
    virtual BOOL        SendControlBit(emInterface_Send_Control emSendBit,int nValue);
    virtual BOOL        SendControlData(short *pBuf,int nAddr, int nCnt);
private:
    void                SendSignalBit();    // Timer Thread
    bool                WritePLC_Data(int nSharedMemIdx, TCHAR* strAddress, short* WriteData, unsigned int nWORDSize);
 
    // Rcv & Read
public:
    BOOL                ReadControl_CheckSignal();
    virtual BOOL        ReadControlBit(emInterface_Rcv_Control emRcvBit,int& nValue);
    virtual BOOL        ReadControlData(int nAddr, int &nData, int nLen);
private:
    BOOL                ReadSignalBit();    // Timer Thread
    bool                ReadPLC_Data(int nSharedMemIdx, char* pData, TCHAR* strAddress, unsigned short nWORDSize);
 
    BOOL                ReadTransferData(CTransDataManager *TData,char *lpTransBuffer,int Addr);
    BOOL                StrToHex(CHAR* pchData, CHAR* pchDataSrc, INT nLength, BOOL bWordReverse=TRUE);
 
protected:
    BOOL                ConnectPLCConnector();
    BOOL                CheckAliveTime();
 
protected:
    HANDLE                m_hMap;
    char*                m_pSharedMemory;            
    
    CCriticalSection    m_csRcvBit;
    BOOL                m_bRcvSignal;
    int                    m_nRcvSignal;
    ST_PLC_RECIVE_BIT    m_Rcv_Bit, m_Rcv_Bit_Backup;
    
    CCriticalSection    m_csSendBit;
    ST_PLC_SEND_BIT        m_Send_Bit, m_Sent_Bit_Backup;
 
 
    CEvent                m_ReadEvent;
    double                m_dSendAlive_TickTime;
 
protected:    
    BOOL                                m_bConnect;
    IControlInterface2MainInterface*    m_pInterface;
    CThread_ControlIF*                    m_pThreadControlIF;
};