MelsecNetMultiAsync.cs
13.4 KB
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
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
namespace HslCommunication.Profinet.Melsec
{
// internal sealed class MelsecNetMultiAsync : PlcNetBase
// {
// /// <summary>
// /// 实例化一个多PLC请求的对象
// /// </summary>
// /// <param name="networkNumber">要求所有网络号一致</param>
// /// <param name="networkStationNumber">要求所有站号一致</param>
// /// <param name="type">要求所有读取类型一致</param>
// /// <param name="address">要求所有起始地址一致</param>
// /// <param name="length">要求所有读取数据长度一致</param>
// /// <param name="timeout">连接PLC过程中的超时时间</param>
// /// <param name="readCycle">每次请求访问的间隔时间</param>
// /// <param name="allAddress">所有等待访问的PLC的IP地址</param>
// /// <param name="portMain">访问PLC时的主端口</param>
// /// <param name="portBackup">访问PLC时的备用端口</param>
// public MelsecNetMultiAsync(
// byte networkNumber,
// byte networkStationNumber,
// MelsecMcDataType type,
// ushort address,
// ushort length,
// int timeout,
// int readCycle,
// IPAddress[] allAddress,
// int portMain,
// int portBackup )
// {
// NetworkNumber = networkNumber;
// NetworkStationNumber = networkStationNumber;
// MelsecType = type;
// Address = address;
// Length = length;
// Timeout = timeout;
// ReadCycle = readCycle;
// //初始化数据对象
// EveryMachineLength = GetLengthFromPlcType( type, length );
// BytesResult = new byte[EveryMachineLength * allAddress.Length];
// PlcStates = new PlcStateOne[allAddress.Length];
// for (int i = 0; i < PlcStates.Length; i++)
// {
// PlcStates[i] = new PlcStateOne( )
// {
// Index = i,
// PlcDataHead = new byte[9],
// PlcDataContent = new byte[EveryMachineLength],
// LengthDataContent = 0,
// LengthDataHead = 0,
// IsConnect = false,
// PlcIpAddress = allAddress[i],
// PortMain = portMain,
// PortBackup = portBackup,
// };
// }
// //启动线程
// Thread thread = new Thread( new ThreadStart( ThreadDealWithTimeout ) )
// {
// IsBackground = true
// };
// thread.Start( );
// }
// /*********************************************************************************************
// *
// * 拷贝的数据方式仍然需要修改
// *
// *
// *********************************************************************************************/
// private MelsecMcDataType MelsecType = MelsecMcDataType.D;
// private ushort Address = 0;
// private ushort Length = 0;
// /// <summary>
// /// 超时时间
// /// </summary>
// private int Timeout = 600;
// /// <summary>
// /// 访问周期
// /// </summary>
// private int ReadCycle = 1000;
// /// <summary>
// /// 系统的连接状态，0未连接，1连接中
// /// </summary>
// private int ConnectStatus = 0;
// /// <summary>
// /// 用于存储结果的字节数组
// /// </summary>
// private byte[] BytesResult = null;
// /// <summary>
// /// 每台设备的长度
// /// </summary>
// private int EveryMachineLength = 0;
// /// <summary>
// /// 接收到所有的PLC数据时候触发
// /// </summary>
// public event IEDelegate<byte[]> OnReceivedData = null;
// private PlcStateOne[] PlcStates = null;
// /// <summary>
// /// 维护超时连接的线程方法
// /// </summary>
// private void ThreadDealWithTimeout()
// {
// LogNet?.WriteInfo( LogHeaderText, "waitting one second" );
// Thread.Sleep( 1000 );// 刚启动的时候进行休眠一小会
// LogNet?.WriteInfo( LogHeaderText, "begining recyle for reading plc" );
// while (true)
// {
// DateTime firstTime = DateTime.Now;// 连接时间
// TimerCallBack( );// 启动访问PLC
// while ((DateTime.Now - firstTime).TotalMilliseconds < Timeout)
// {
// // 超时时间等待
// }
// // 连接超时处理
// for (int i = 0; i < PlcStates.Length; i++)
// {
// if (!PlcStates[i].IsConnect) PlcStates[i].WorkSocket.Close( );
// }
// while ((DateTime.Now - firstTime).TotalMilliseconds < ReadCycle)
// {
// // 等待下次连接
// }
// }
// }
// private void TimerCallBack()
// {
// // 如果已经连接就返回，此处采用原子操作实现
// if (Interlocked.CompareExchange( ref ConnectStatus, 1, 0 ) == 0)
// {
// m_ac = new AsyncCoordinator( );
// for (int i = 0; i < PlcStates.Length; i++)
// {
// PlcStates[i].IsConnect = false;
// PlcStates[i].WorkSocket = new Socket( AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp );
// PlcStates[i].WorkSocket.BeginConnect( new IPEndPoint( PlcStates[i].PlcIpAddress, PlcStates[i].GetPort( ) ), new AsyncCallback( PlcConnectCallBack ), PlcStates[i] );
// PlcStates[i].LengthDataHead = 0;
// PlcStates[i].LengthDataContent = 0;
// m_ac.AboutToBegin( 1 );
// }
// // 启动检查连接情况
// m_ac.AllBegun( AllDown );
// }
// }
// private byte[] ConnectWrongHead = new byte[] { 0x00, 0x01 };
// private void PlcConnectCallBack( IAsyncResult ar )
// {
// if (ar.AsyncState is PlcStateOne stateone)
// {
// try
// {
// stateone.WorkSocket.EndConnect( ar );
// stateone.WorkSocket.BeginReceive(
// stateone.PlcDataHead,
// stateone.LengthDataHead,
// stateone.PlcDataHead.Length - stateone.LengthDataHead,
// SocketFlags.None,
// new AsyncCallback( PlcHeadReceiveCallBack ),
// stateone );
// stateone.IsConnect = true;// 指示访问成功
// }
// catch (Exception ex)
// {
// LogNet?.WriteException( ToString(), "connect failed", ex );
// // 访问失败
// stateone.WorkSocket.Close( );
// // 初始化数据
// Array.Copy( ConnectWrongHead, 0, BytesResult, stateone.Index * EveryMachineLength, 2 );
// // 更换端口
// stateone.ChangePort( );
// // 结束任务
// m_ac.JustEnded( );
// }
// }
// }
// private void PlcHeadReceiveCallBack( IAsyncResult ar )
// {
// if (ar.AsyncState is PlcStateOne stateone)
// {
// try
// {
// stateone.LengthDataHead += stateone.WorkSocket.EndReceive( ar );
// if (stateone.LengthDataHead < stateone.PlcDataHead.Length)
// {
// // 继续接收头格式
// stateone.WorkSocket.BeginReceive(
// stateone.PlcDataHead,
// stateone.LengthDataHead,
// stateone.PlcDataHead.Length - stateone.LengthDataHead,
// SocketFlags.None,
// new AsyncCallback( PlcHeadReceiveCallBack ),
// stateone );
// }
// else
// {
// // 计算接下来的接收长度，最少还有2个长度的字节数据
// int NeedReceived = BitConverter.ToUInt16( stateone.PlcDataHead, 7 );
// stateone.PlcDataContent = new byte[NeedReceived];
// // 接收内容
// stateone.WorkSocket.BeginReceive(
// stateone.PlcDataContent,
// 0,
// stateone.PlcDataContent.Length - stateone.LengthDataContent,
// SocketFlags.None,
// new AsyncCallback( PlcContentReceiveCallBack ),
// stateone );
// }
// }
// catch (Exception ex)
// {
// LogNet?.WriteException( LogHeaderText, "Head receive", ex );
// // 由于未知原因，数据接收失败
// stateone.WorkSocket.Close( );
// // 初始化数据
// Array.Copy( ConnectWrongHead, 0, BytesResult, stateone.Index * EveryMachineLength, 2 );
// // 结束任务
// m_ac.JustEnded( );
// }
// }
// }
// private void PlcContentReceiveCallBack( IAsyncResult ar )
// {
// if (ar.AsyncState is PlcStateOne stateone)
// {
// try
// {
// stateone.LengthDataContent += stateone.WorkSocket.EndReceive( ar );
// if (stateone.LengthDataHead < stateone.PlcDataHead.Length)
// {
// // 继续接内容格式
// stateone.WorkSocket.BeginReceive(
// stateone.PlcDataContent,
// stateone.LengthDataContent,
// stateone.PlcDataContent.Length - stateone.LengthDataContent,
// SocketFlags.None,
// new AsyncCallback( PlcContentReceiveCallBack ),
// stateone );
// }
// else
// {
// // 所有内容接收完成
// int error = BitConverter.ToUInt16( stateone.PlcDataContent, 0 );
// if (error > 0)
// {
// Array.Copy( ConnectWrongHead, 0, BytesResult, stateone.Index * EveryMachineLength, 2 );
// }
// else
// {
// Array.Copy( stateone.PlcDataContent, 0, BytesResult, stateone.Index * EveryMachineLength, stateone.PlcDataContent.Length );
// }
// // 关闭连接
// stateone.WorkSocket.Close( );
// // 结束任务
// m_ac.JustEnded( );
// }
// }
// catch (Exception ex)
// {
// LogNet?.WriteException( LogHeaderText, "Data receive", ex );
// // 由于未知原因，数据接收失败
// stateone.WorkSocket.Close( );
// // 初始化数据
// Array.Copy( ConnectWrongHead, 0, BytesResult, stateone.Index * EveryMachineLength, 2 );
// // 结束任务
// m_ac.JustEnded( );
// }
// }
// }
// private void AllDown( CoordinationStatus status )
// {
// // 此处没有取消和超时状态，直接完成
// if (status == CoordinationStatus.AllDone)
// {
// Interlocked.Exchange( ref ConnectStatus, 0 );
// LogNet?.WriteDebug( LogHeaderText, "All bytes read complete." );
// OnReceivedData?.Invoke( BytesResult.ToArray( ) );
// }
// }
// private AsyncCoordinator m_ac = new AsyncCoordinator( );
// }
}