Sharp7.cs

/*=============================================================================|
|  PROJECT Sharp7                                                        1.1.0 |
|==============================================================================|
|  Copyright (C) 2016 Davide Nardella                                          |
|  All rights reserved.                                                        |
|==============================================================================|
|  Sharp7 is free software: you can redistribute it and/or modify              |
|  it under the terms of the Lesser GNU General Public License as published by |
|  the Free Software Foundation, either version 3 of the License, or           |
|  (at your option) any later version.                                         |
|                                                                              |
|  It means that you can distribute your commercial software which includes    |
|  Sharp7 without the requirement to distribute the source code of your        |
|  application and without the requirement that your application be itself     |
|  distributed under LGPL.                                                     |
|                                                                              |
|  Sharp7 is distributed in the hope that it will be useful,                   |
|  but WITHOUT ANY WARRANTY; without even the implied warranty of              |
|  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the               |
|  Lesser GNU General Public License for more details.                         |
|                                                                              |
|  You should have received a copy of the GNU General Public License and a     |
|  copy of Lesser GNU General Public License along with Sharp7.                |
|  If not, see  http://www.gnu.org/licenses/                                   |
|==============================================================================|
History:
 * 1.0.0 2016/10/09 First Release
 * 1.0.1 2016/10/22 Added CoreCLR compatibility (CORE_CLR symbol must be 
					defined in Build options).
					Thanks to Dirk-Jan Wassink.
 * 1.0.2 2016/11/13 Fixed a bug in CLR compatibility
 * 1.0.3 2017/01/25 Fixed a bug in S7.GetIntAt(). Thanks to lupal1
					Added S7Timer Read/Write. Thanks to Lukas Palkovic 
 * 1.0.4 2018/06/12 Fixed the last bug in S7.GetIntAt(). Thanks to Jérémy HAURAY
					Get/Set LTime. Thanks to Jérémy HAURAY
					Get/Set 1500 WString. Thanks to Jérémy HAURAY
					Get/Set 1500 Array of WChar. Thanks to Jérémy HAURAY
 * 1.0.5 2018/11/21 Implemented ListBlocks and ListBlocksOfType (by Jos Koenis, TEB Engineering)
 * 1.0.6 2019/05/25 Implemented Force Jobs by Bart Swister
 * 1.0.7 2019/10/05 Bugfix in List in ListBlocksOfType. Thanks to Cosimo Ladiana 
 * ------------------------------------------------------------------------------
 * 1.1.0 2020/06/28 Implemented read/write Nck and Drive Data for Sinumerik 840D sl 
 *                  controls (by Chris Schöberlein) 
*/
using System;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading;
using System.Collections.Generic;
using System.Linq;
using System.IO;
//------------------------------------------------------------------------------
// If you are compiling for UWP verify that WINDOWS_UWP or NETFX_CORE are 
// defined into Project Properties->Build->Conditional compilation symbols
//------------------------------------------------------------------------------
#if WINDOWS_UWP || NETFX_CORE
using System.Threading.Tasks;
using Windows.Networking;
using Windows.Networking.Sockets;
using Windows.Storage.Streams;
#else // <-- Including MONO
using System.Net.Sockets;
#endif

namespace Sharp7
{


	#region [Async Sockets UWP(W10,IoT,Phone)/Windows 8/Windows 8 Phone]
#if WINDOWS_UWP || NETFX_CORE
	class MsgSocket
	{
		private DataReader Reader = null;
		private DataWriter Writer = null;
		private StreamSocket TCPSocket;

		private bool _Connected;

		private int _ReadTimeout = 2000;
		private int _WriteTimeout = 2000;
		private int _ConnectTimeout = 1000;

		public static int LastError = 0;


		private void CreateSocket()
		{
			TCPSocket = new StreamSocket();
			TCPSocket.Control.NoDelay = true;
			_Connected = false;
		}

		public MsgSocket()
		{
		}

		public void Close()
		{
			if (Reader != null)
			{
				Reader.Dispose();
				Reader = null;
			}
			if (Writer != null)
			{
				Writer.Dispose();
				Writer = null;
			}
			if (TCPSocket != null)
			{
				TCPSocket.Dispose();
				TCPSocket = null;
			}
			_Connected = false;
		}

		private async Task AsConnect(string Host, string port, CancellationTokenSource cts)
		{
			HostName ServerHost = new HostName(Host);
			try
			{
				await TCPSocket.ConnectAsync(ServerHost, port).AsTask(cts.Token);
				_Connected = true;
			}
			catch (TaskCanceledException)
			{
				LastError = S7Consts.errTCPConnectionTimeout;
			}
			catch
			{
				LastError = S7Consts.errTCPConnectionFailed; // Maybe unreachable peer
			}
		}

		public int Connect(string Host, int Port)
		{
			LastError = 0;
			if (!Connected)
			{
				CreateSocket();
				CancellationTokenSource cts = new CancellationTokenSource();
				try
				{
					try
					{
						cts.CancelAfter(_ConnectTimeout);
						Task.WaitAny(Task.Run(async () => await AsConnect(Host, Port.ToString(), cts)));
					}
					catch
					{
						LastError = S7Consts.errTCPConnectionFailed;
					}
				}
				finally
				{
					if (cts != null)
					{
						try
						{
							cts.Cancel();
							cts.Dispose();
							cts = null;
						}
						catch { }
					}

				}
				if (LastError == 0)
				{
					Reader = new DataReader(TCPSocket.InputStream);
					Reader.InputStreamOptions = InputStreamOptions.Partial;
					Writer = new DataWriter(TCPSocket.OutputStream);
					_Connected = true;
				}
				else
					Close();
			}
			return LastError;
		}

		private async Task AsReadBuffer(byte[] Buffer, int Size, CancellationTokenSource cts)
		{
			try
			{
				await Reader.LoadAsync((uint)Size).AsTask(cts.Token);
				Reader.ReadBytes(Buffer);
			}
			catch
			{
				LastError = S7Consts.errTCPDataReceive;
			}
		}

		public int Receive(byte[] Buffer, int Start, int Size)
		{
			byte[] InBuffer = new byte[Size];
			CancellationTokenSource cts = new CancellationTokenSource();
			LastError = 0;
			try
			{
				try
				{
					cts.CancelAfter(_ReadTimeout);
					Task.WaitAny(Task.Run(async () => await AsReadBuffer(InBuffer, Size, cts)));
				}
				catch
				{
					LastError = S7Consts.errTCPDataReceive;
				}
			}
			finally
			{
				if (cts != null)
				{
					try
					{
						cts.Cancel();
						cts.Dispose();
						cts = null;
					}
					catch { }
				}
			}
			if (LastError == 0)
				Array.Copy(InBuffer, 0, Buffer, Start, Size);
			else
				Close();
			return LastError;
		}

		private async Task WriteBuffer(byte[] Buffer, CancellationTokenSource cts)
		{
			try
			{
				Writer.WriteBytes(Buffer);
				await Writer.StoreAsync().AsTask(cts.Token);
			}
			catch
			{
				LastError = S7Consts.errTCPDataSend;
			}
		}

		public int Send(byte[] Buffer, int Size)
		{
			byte[] OutBuffer = new byte[Size];
			CancellationTokenSource cts = new CancellationTokenSource();
			Array.Copy(Buffer, 0, OutBuffer, 0, Size);
			LastError = 0;
			try
			{
				try
				{
					cts.CancelAfter(_WriteTimeout);
					Task.WaitAny(Task.Run(async () => await WriteBuffer(OutBuffer, cts)));
				}
				catch
				{
					LastError = S7Consts.errTCPDataSend;
				}
			}
			finally
			{
				if (cts != null)
				{
					try
					{
						cts.Cancel();
						cts.Dispose();
						cts = null;
					}
					catch { }
				}
			}
			if (LastError != 0)
				Close();
			return LastError;
		}

		~MsgSocket()
		{
			Close();
		}

		public bool Connected
		{
			get
			{
				return (TCPSocket != null) && _Connected;
			}
		}

		public int ReadTimeout
		{
			get
			{
				return _ReadTimeout;
			}
			set
			{
				_ReadTimeout = value;
			}
		}

		public int WriteTimeout
		{
			get
			{
				return _WriteTimeout;
			}
			set
			{
				_WriteTimeout = value;
			}
		}
		public int ConnectTimeout
		{
			get
			{
				return _ConnectTimeout;
			}
			set
			{
				_ConnectTimeout = value;
			}
		}
	}
#endif
	#endregion

	#region [Sync Sockets Win32/Win64 Desktop Application]
#if !WINDOWS_UWP && !NETFX_CORE
	class MsgSocket
	{
		private Socket TCPSocket;
		private int _ReadTimeout = 2000;
		private int _WriteTimeout = 2000;
		private int _ConnectTimeout = 1000;
		public int LastError = 0;

		public MsgSocket()
		{
		}

		~MsgSocket()
		{
			Close();
		}

		public void Close()
		{
			if (TCPSocket != null)
			{
				TCPSocket.Dispose();
				TCPSocket = null;
			}
		}

		private void CreateSocket()
		{
			TCPSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
			TCPSocket.NoDelay = true;
		}

		private void TCPPing(string Host, int Port)
		{
			// To Ping the PLC an Asynchronous socket is used rather then an ICMP packet.
			// This allows the use also across Internet and Firewalls (obviously the port must be opened)           
			LastError = 0;
			Socket PingSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
			try
			{

#if CORE_CLR
				var task = PingSocket.ConnectAsync(Host, Port);
				task.Wait(_ConnectTimeout);
				bool success = task.IsCompleted;
#else
				IAsyncResult result = PingSocket.BeginConnect(Host, Port, null, null);
				bool success = result.AsyncWaitHandle.WaitOne(_ConnectTimeout, true);
#endif
				if (!success)
				{
					LastError = S7Consts.errTCPConnectionFailed;
				}
			}
			catch
			{
				LastError = S7Consts.errTCPConnectionFailed;
			};
#if CORE_CLR
			PingSocket.Dispose();
#else
			PingSocket.Close();
#endif
		}

		public int Connect(string Host, int Port)
		{
			LastError = 0;
			if (!Connected)
			{
				TCPPing(Host, Port);
				if (LastError == 0)
					try
					{
						CreateSocket();
						TCPSocket.Connect(Host, Port);
					}
					catch
					{
						LastError = S7Consts.errTCPConnectionFailed;
					}
			}
			return LastError;
		}

		private int WaitForData(int Size, int Timeout)
		{
			bool Expired = false;
			int SizeAvail;
			int Elapsed = Environment.TickCount;
			LastError = 0;
			try
			{
				SizeAvail = TCPSocket.Available;
				while ((SizeAvail < Size) && (!Expired))
				{
					Thread.Sleep(2);
					SizeAvail = TCPSocket.Available;
					Expired = Environment.TickCount - Elapsed > Timeout;
					// If timeout we clean the buffer
					if (Expired && (SizeAvail > 0))
						try
						{
							byte[] Flush = new byte[SizeAvail];
							TCPSocket.Receive(Flush, 0, SizeAvail, SocketFlags.None);
						}
						catch { }
				}
			}
			catch
			{
				LastError = S7Consts.errTCPDataReceive;
			}
			if (Expired)
			{
				LastError = S7Consts.errTCPDataReceive;
			}
			return LastError;
		}

		public int Receive(byte[] Buffer, int Start, int Size)
		{

			int BytesRead = 0;
			LastError = WaitForData(Size, _ReadTimeout);
			if (LastError == 0)
			{
				try
				{
					BytesRead = TCPSocket.Receive(Buffer, Start, Size, SocketFlags.None);
				}
				catch
				{
					LastError = S7Consts.errTCPDataReceive;
				}
				if (BytesRead == 0) // Connection Reset by the peer
				{
					LastError = S7Consts.errTCPDataReceive;
					Close();
				}
			}
			return LastError;
		}

		public int Send(byte[] Buffer, int Size)
		{
			LastError = 0;
			try
			{
				int BytesSent = TCPSocket.Send(Buffer, Size, SocketFlags.None);
			}
			catch
			{
				LastError = S7Consts.errTCPDataSend;
				Close();
			}
			return LastError;
		}

		public bool Connected
		{
			get
			{
				return (TCPSocket != null) && (TCPSocket.Connected);
			}
		}

		public int ReadTimeout
		{
			get
			{
				return _ReadTimeout;
			}
			set
			{
				_ReadTimeout = value;
			}
		}

		public int WriteTimeout
		{
			get
			{
				return _WriteTimeout;
			}
			set
			{
				_WriteTimeout = value;
			}

		}
		public int ConnectTimeout
		{
			get
			{
				return _ConnectTimeout;
			}
			set
			{
				_ConnectTimeout = value;
			}
		}
	}
#endif
	#endregion

	public static class S7Consts
	{
		#region [Exported Consts]
		// Error codes
		//------------------------------------------------------------------------------
		//                                     ERRORS                 
		//------------------------------------------------------------------------------
		public const int errTCPSocketCreation = 0x00000001;
		public const int errTCPConnectionTimeout = 0x00000002;
		public const int errTCPConnectionFailed = 0x00000003;
		public const int errTCPReceiveTimeout = 0x00000004;
		public const int errTCPDataReceive = 0x00000005;
		public const int errTCPSendTimeout = 0x00000006;
		public const int errTCPDataSend = 0x00000007;
		public const int errTCPConnectionReset = 0x00000008;
		public const int errTCPNotConnected = 0x00000009;
		public const int errTCPUnreachableHost = 0x00002751;

		public const int errIsoConnect = 0x00010000; // Connection error
		public const int errIsoInvalidPDU = 0x00030000; // Bad format
		public const int errIsoInvalidDataSize = 0x00040000; // Bad Datasize passed to send/recv : buffer is invalid

		public const int errCliNegotiatingPDU = 0x00100000;
		public const int errCliInvalidParams = 0x00200000;
		public const int errCliJobPending = 0x00300000;
		public const int errCliTooManyItems = 0x00400000;
		public const int errCliInvalidWordLen = 0x00500000;
		public const int errCliPartialDataWritten = 0x00600000;
		public const int errCliSizeOverPDU = 0x00700000;
		public const int errCliInvalidPlcAnswer = 0x00800000;
		public const int errCliAddressOutOfRange = 0x00900000;
		public const int errCliInvalidTransportSize = 0x00A00000;
		public const int errCliWriteDataSizeMismatch = 0x00B00000;
		public const int errCliItemNotAvailable = 0x00C00000;
		public const int errCliInvalidValue = 0x00D00000;
		public const int errCliCannotStartPLC = 0x00E00000;
		public const int errCliAlreadyRun = 0x00F00000;
		public const int errCliCannotStopPLC = 0x01000000;
		public const int errCliCannotCopyRamToRom = 0x01100000;
		public const int errCliCannotCompress = 0x01200000;
		public const int errCliAlreadyStop = 0x01300000;
		public const int errCliFunNotAvailable = 0x01400000;
		public const int errCliUploadSequenceFailed = 0x01500000;
		public const int errCliInvalidDataSizeRecvd = 0x01600000;
		public const int errCliInvalidBlockType = 0x01700000;
		public const int errCliInvalidBlockNumber = 0x01800000;
		public const int errCliInvalidBlockSize = 0x01900000;
		public const int errCliNeedPassword = 0x01D00000;
		public const int errCliInvalidPassword = 0x01E00000;
		public const int errCliNoPasswordToSetOrClear = 0x01F00000;
		public const int errCliJobTimeout = 0x02000000;
		public const int errCliPartialDataRead = 0x02100000;
		public const int errCliBufferTooSmall = 0x02200000;
		public const int errCliFunctionRefused = 0x02300000;
		public const int errCliDestroying = 0x02400000;
		public const int errCliInvalidParamNumber = 0x02500000;
		public const int errCliCannotChangeParam = 0x02600000;
		public const int errCliFunctionNotImplemented = 0x02700000;
		//------------------------------------------------------------------------------
		//        PARAMS LIST FOR COMPATIBILITY WITH Snap7.net.cs           
		//------------------------------------------------------------------------------
		public const Int32 p_u16_LocalPort = 1;  // Not applicable here
		public const Int32 p_u16_RemotePort = 2;
		public const Int32 p_i32_PingTimeout = 3;
		public const Int32 p_i32_SendTimeout = 4;
		public const Int32 p_i32_RecvTimeout = 5;
		public const Int32 p_i32_WorkInterval = 6;  // Not applicable here
		public const Int32 p_u16_SrcRef = 7;  // Not applicable here
		public const Int32 p_u16_DstRef = 8;  // Not applicable here
		public const Int32 p_u16_SrcTSap = 9;  // Not applicable here
		public const Int32 p_i32_PDURequest = 10;
		public const Int32 p_i32_MaxClients = 11; // Not applicable here
		public const Int32 p_i32_BSendTimeout = 12; // Not applicable here
		public const Int32 p_i32_BRecvTimeout = 13; // Not applicable here
		public const Int32 p_u32_RecoveryTime = 14; // Not applicable here
		public const Int32 p_u32_KeepAliveTime = 15; // Not applicable here
													 // Area ID
		public const byte S7AreaPE = 0x81;
		public const byte S7AreaPA = 0x82;
		public const byte S7AreaMK = 0x83;
		public const byte S7AreaDB = 0x84;
		public const byte S7AreaCT = 0x1C;
		public const byte S7AreaTM = 0x1D;
		// Word Length
		public const int S7WLBit = 0x01;
		public const int S7WLByte = 0x02;
		public const int S7WLChar = 0x03;
		public const int S7WLWord = 0x04;
		public const int S7WLInt = 0x05;
		public const int S7WLDWord = 0x06;
		public const int S7WLDInt = 0x07;
		public const int S7WLReal = 0x08;
		public const int S7WLCounter = 0x1C;
		public const int S7WLTimer = 0x1D;
		// PLC Status
		public const int S7CpuStatusUnknown = 0x00;
		public const int S7CpuStatusRun = 0x08;
		public const int S7CpuStatusStop = 0x04;

		[StructLayout(LayoutKind.Sequential, Pack = 1)]
		public struct S7Tag
		{
			public Int32 Area;
			public Int32 DBNumber;
			public Int32 Start;
			public Int32 Elements;
			public Int32 WordLen;
		}
		#endregion
	}

	public class S7Timer
	{
		#region S7Timer
		TimeSpan pt;
		TimeSpan et;
		bool input = false;
		bool q = false;
		public S7Timer(byte[] buff, int position)
		{
			if (position + 12 < buff.Length)
			{
				return;
			}
			else
			{
				SetTimer(new List<byte>(buff).GetRange(position, 16).ToArray());
			}
		}

		public S7Timer(byte[] buff)
		{
			SetTimer(buff);
		}

		private void SetTimer(byte[] buff)
		{
			if (buff.Length != 12)
			{
				this.pt = new TimeSpan(0);
				this.et = new TimeSpan(0);
			}
			else
			{
				Int32 resPT;
				resPT = buff[0]; resPT <<= 8;
				resPT += buff[1]; resPT <<= 8;
				resPT += buff[2]; resPT <<= 8;
				resPT += buff[3];
				this.pt = new TimeSpan(0, 0, 0, 0, resPT);

				Int32 resET;
				resET = buff[4]; resET <<= 8;
				resET += buff[5]; resET <<= 8;
				resET += buff[6]; resET <<= 8;
				resET += buff[7];
				this.et = new TimeSpan(0, 0, 0, 0, resET);

				this.input = (buff[8] & 0x01) == 0x01;
				this.q = (buff[8] & 0x02) == 0x02;
			}
		}
		public TimeSpan PT
		{
			get
			{
				return pt;
			}
		}
		public TimeSpan ET
		{
			get
			{
				return et;
			}
		}
		public bool IN
		{
			get
			{
				return input;
			}
		}
		public bool Q
		{
			get
			{
				return q;
			}
		}
		#endregion
	}

	public static class S7
	{
		#region [Help Functions]

		private static Int64 bias = 621355968000000000; // "decimicros" between 0001-01-01 00:00:00 and 1970-01-01 00:00:00

		private static int BCDtoByte(byte B)
		{
			return ((B >> 4) * 10) + (B & 0x0F);
		}

		private static byte ByteToBCD(int Value)
		{
			return (byte)(((Value / 10) << 4) | (Value % 10));
		}

		private static byte[] CopyFrom(byte[] Buffer, int Pos, int Size)
		{
			byte[] Result = new byte[Size];
			Array.Copy(Buffer, Pos, Result, 0, Size);
			return Result;
		}

		public static int DataSizeByte(int WordLength)
		{
			switch (WordLength)
			{
				case S7Consts.S7WLBit: return 1;  // S7 sends 1 byte per bit
				case S7Consts.S7WLByte: return 1;
				case S7Consts.S7WLChar: return 1;
				case S7Consts.S7WLWord: return 2;
				case S7Consts.S7WLDWord: return 4;
				case S7Consts.S7WLInt: return 2;
				case S7Consts.S7WLDInt: return 4;
				case S7Consts.S7WLReal: return 4;
				case S7Consts.S7WLCounter: return 2;
				case S7Consts.S7WLTimer: return 2;
				default: return 0;
			}
		}

		#region Get/Set the bit at Pos.Bit
		public static bool GetBitAt(byte[] Buffer, int Pos, int Bit)
		{
			byte[] Mask = { 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80 };
			if (Bit < 0) Bit = 0;
			if (Bit > 7) Bit = 7;
			return (Buffer[Pos] & Mask[Bit]) != 0;
		}
		public static void SetBitAt(ref byte[] Buffer, int Pos, int Bit, bool Value)
		{
			byte[] Mask = { 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80 };
			if (Bit < 0) Bit = 0;
			if (Bit > 7) Bit = 7;

			if (Value)
				Buffer[Pos] = (byte)(Buffer[Pos] | Mask[Bit]);
			else
				Buffer[Pos] = (byte)(Buffer[Pos] & ~Mask[Bit]);
		}
		#endregion

		#region Get/Set 8 bit signed value (S7 SInt) -128..127
		public static int GetSIntAt(byte[] Buffer, int Pos)
		{
			int Value = Buffer[Pos];
			if (Value < 128)
				return Value;
			else
				return (int)(Value - 256);
		}
		public static void SetSIntAt(byte[] Buffer, int Pos, int Value)
		{
			if (Value < -128) Value = -128;
			if (Value > 127) Value = 127;
			Buffer[Pos] = (byte)Value;
		}
		#endregion

		#region Get/Set 16 bit signed value (S7 int) -32768..32767
		public static short GetIntAt(byte[] Buffer, int Pos)
		{
			return (short)((Buffer[Pos] << 8) | Buffer[Pos + 1]);
		}
		public static void SetIntAt(byte[] Buffer, int Pos, Int16 Value)
		{
			Buffer[Pos] = (byte)(Value >> 8);
			Buffer[Pos + 1] = (byte)(Value & 0x00FF);
		}
		#endregion

		#region Get/Set 32 bit signed value (S7 DInt) -2147483648..2147483647
		public static int GetDIntAt(byte[] Buffer, int Pos)
		{
			int Result;
			Result = Buffer[Pos]; Result <<= 8;
			Result += Buffer[Pos + 1]; Result <<= 8;
			Result += Buffer[Pos + 2]; Result <<= 8;
			Result += Buffer[Pos + 3];
			return Result;
		}
		public static void SetDIntAt(byte[] Buffer, int Pos, int Value)
		{
			Buffer[Pos + 3] = (byte)(Value & 0xFF);
			Buffer[Pos + 2] = (byte)((Value >> 8) & 0xFF);
			Buffer[Pos + 1] = (byte)((Value >> 16) & 0xFF);
			Buffer[Pos] = (byte)((Value >> 24) & 0xFF);
		}
		#endregion

		#region Get/Set 64 bit signed value (S7 LInt) -9223372036854775808..9223372036854775807
		public static Int64 GetLIntAt(byte[] Buffer, int Pos)
		{
			Int64 Result;
			Result = Buffer[Pos]; Result <<= 8;
			Result += Buffer[Pos + 1]; Result <<= 8;
			Result += Buffer[Pos + 2]; Result <<= 8;
			Result += Buffer[Pos + 3]; Result <<= 8;
			Result += Buffer[Pos + 4]; Result <<= 8;
			Result += Buffer[Pos + 5]; Result <<= 8;
			Result += Buffer[Pos + 6]; Result <<= 8;
			Result += Buffer[Pos + 7];
			return Result;
		}
		public static void SetLIntAt(byte[] Buffer, int Pos, Int64 Value)
		{
			Buffer[Pos + 7] = (byte)(Value & 0xFF);
			Buffer[Pos + 6] = (byte)((Value >> 8) & 0xFF);
			Buffer[Pos + 5] = (byte)((Value >> 16) & 0xFF);
			Buffer[Pos + 4] = (byte)((Value >> 24) & 0xFF);
			Buffer[Pos + 3] = (byte)((Value >> 32) & 0xFF);
			Buffer[Pos + 2] = (byte)((Value >> 40) & 0xFF);
			Buffer[Pos + 1] = (byte)((Value >> 48) & 0xFF);
			Buffer[Pos] = (byte)((Value >> 56) & 0xFF);
		}
		#endregion

		#region Get/Set 8 bit unsigned value (S7 USInt) 0..255
		public static byte GetUSIntAt(byte[] Buffer, int Pos)
		{
			return Buffer[Pos];
		}
		public static void SetUSIntAt(byte[] Buffer, int Pos, byte Value)
		{
			Buffer[Pos] = Value;
		}
		#endregion

		#region Get/Set 16 bit unsigned value (S7 UInt) 0..65535
		public static UInt16 GetUIntAt(byte[] Buffer, int Pos)
		{
			return (UInt16)((Buffer[Pos] << 8) | Buffer[Pos + 1]);
		}
		public static void SetUIntAt(byte[] Buffer, int Pos, UInt16 Value)
		{
			Buffer[Pos] = (byte)(Value >> 8);
			Buffer[Pos + 1] = (byte)(Value & 0x00FF);
		}
		#endregion

		#region Get/Set 32 bit unsigned value (S7 UDInt) 0..4294967296
		public static UInt32 GetUDIntAt(byte[] Buffer, int Pos)
		{
			UInt32 Result;
			Result = Buffer[Pos]; Result <<= 8;
			Result |= Buffer[Pos + 1]; Result <<= 8;
			Result |= Buffer[Pos + 2]; Result <<= 8;
			Result |= Buffer[Pos + 3];
			return Result;
		}
		public static void SetUDIntAt(byte[] Buffer, int Pos, UInt32 Value)
		{
			Buffer[Pos + 3] = (byte)(Value & 0xFF);
			Buffer[Pos + 2] = (byte)((Value >> 8) & 0xFF);
			Buffer[Pos + 1] = (byte)((Value >> 16) & 0xFF);
			Buffer[Pos] = (byte)((Value >> 24) & 0xFF);
		}
		#endregion

		#region Get/Set 64 bit unsigned value (S7 ULint) 0..18446744073709551616
		public static UInt64 GetULIntAt(byte[] Buffer, int Pos)
		{
			UInt64 Result;
			Result = Buffer[Pos]; Result <<= 8;
			Result |= Buffer[Pos + 1]; Result <<= 8;
			Result |= Buffer[Pos + 2]; Result <<= 8;
			Result |= Buffer[Pos + 3]; Result <<= 8;
			Result |= Buffer[Pos + 4]; Result <<= 8;
			Result |= Buffer[Pos + 5]; Result <<= 8;
			Result |= Buffer[Pos + 6]; Result <<= 8;
			Result |= Buffer[Pos + 7];
			return Result;
		}
		public static void SetULintAt(byte[] Buffer, int Pos, UInt64 Value)
		{
			Buffer[Pos + 7] = (byte)(Value & 0xFF);
			Buffer[Pos + 6] = (byte)((Value >> 8) & 0xFF);
			Buffer[Pos + 5] = (byte)((Value >> 16) & 0xFF);
			Buffer[Pos + 4] = (byte)((Value >> 24) & 0xFF);
			Buffer[Pos + 3] = (byte)((Value >> 32) & 0xFF);
			Buffer[Pos + 2] = (byte)((Value >> 40) & 0xFF);
			Buffer[Pos + 1] = (byte)((Value >> 48) & 0xFF);
			Buffer[Pos] = (byte)((Value >> 56) & 0xFF);
		}
		#endregion

		#region Get/Set 8 bit word (S7 Byte) 16#00..16#FF
		public static byte GetByteAt(byte[] Buffer, int Pos)
		{
			return Buffer[Pos];
		}
		public static void SetByteAt(byte[] Buffer, int Pos, byte Value)
		{
			Buffer[Pos] = Value;
		}
		#endregion

		#region Get/Set 16 bit word (S7 Word) 16#0000..16#FFFF
		public static UInt16 GetWordAt(byte[] Buffer, int Pos)
		{
			return GetUIntAt(Buffer, Pos);
		}
		public static void SetWordAt(byte[] Buffer, int Pos, UInt16 Value)
		{
			SetUIntAt(Buffer, Pos, Value);
		}
		#endregion

		#region Get/Set 32 bit word (S7 DWord) 16#00000000..16#FFFFFFFF
		public static UInt32 GetDWordAt(byte[] Buffer, int Pos)
		{
			return GetUDIntAt(Buffer, Pos);
		}
		public static void SetDWordAt(byte[] Buffer, int Pos, UInt32 Value)
		{
			SetUDIntAt(Buffer, Pos, Value);
		}
		#endregion

		#region Get/Set 64 bit word (S7 LWord) 16#0000000000000000..16#FFFFFFFFFFFFFFFF
		public static UInt64 GetLWordAt(byte[] Buffer, int Pos)
		{
			return GetULIntAt(Buffer, Pos);
		}
		public static void SetLWordAt(byte[] Buffer, int Pos, UInt64 Value)
		{
			SetULintAt(Buffer, Pos, Value);
		}
		#endregion

		#region Get/Set 32 bit floating point number (S7 Real) (Range of Single)
		public static Single GetRealAt(byte[] Buffer, int Pos)
		{
			UInt32 Value = GetUDIntAt(Buffer, Pos);
			byte[] bytes = BitConverter.GetBytes(Value);
			return BitConverter.ToSingle(bytes, 0);
		}
		public static void SetRealAt(byte[] Buffer, int Pos, Single Value)
		{
			byte[] FloatArray = BitConverter.GetBytes(Value);
			Buffer[Pos] = FloatArray[3];
			Buffer[Pos + 1] = FloatArray[2];
			Buffer[Pos + 2] = FloatArray[1];
			Buffer[Pos + 3] = FloatArray[0];
		}
		#endregion

		#region Get/Set 64 bit floating point number (S7 LReal) (Range of Double)
		public static Double GetLRealAt(byte[] Buffer, int Pos)
		{
			UInt64 Value = GetULIntAt(Buffer, Pos);
			byte[] bytes = BitConverter.GetBytes(Value);
			return BitConverter.ToDouble(bytes, 0);
		}
		public static void SetLRealAt(byte[] Buffer, int Pos, Double Value)
		{
			byte[] FloatArray = BitConverter.GetBytes(Value);
			Buffer[Pos] = FloatArray[7];
			Buffer[Pos + 1] = FloatArray[6];
			Buffer[Pos + 2] = FloatArray[5];
			Buffer[Pos + 3] = FloatArray[4];
			Buffer[Pos + 4] = FloatArray[3];
			Buffer[Pos + 5] = FloatArray[2];
			Buffer[Pos + 6] = FloatArray[1];
			Buffer[Pos + 7] = FloatArray[0];
		}
		#endregion

		#region Get/Set DateTime (S7 DATE_AND_TIME)
		public static DateTime GetDateTimeAt(byte[] Buffer, int Pos)
		{
			int Year, Month, Day, Hour, Min, Sec, MSec;

			Year = BCDtoByte(Buffer[Pos]);
			if (Year < 90)
				Year += 2000;
			else
				Year += 1900;

			Month = BCDtoByte(Buffer[Pos + 1]);
			Day = BCDtoByte(Buffer[Pos + 2]);
			Hour = BCDtoByte(Buffer[Pos + 3]);
			Min = BCDtoByte(Buffer[Pos + 4]);
			Sec = BCDtoByte(Buffer[Pos + 5]);
			MSec = (BCDtoByte(Buffer[Pos + 6]) * 10) + (BCDtoByte(Buffer[Pos + 7]) / 10);
			try
			{
				return new DateTime(Year, Month, Day, Hour, Min, Sec, MSec);
			}
			catch (System.ArgumentOutOfRangeException)
			{
				return new DateTime(0);
			}
		}
		public static void SetDateTimeAt(byte[] Buffer, int Pos, DateTime Value)
		{
			int Year = Value.Year;
			int Month = Value.Month;
			int Day = Value.Day;
			int Hour = Value.Hour;
			int Min = Value.Minute;
			int Sec = Value.Second;
			int Dow = (int)Value.DayOfWeek + 1;
			// MSecH = First two digits of miliseconds 
			int MsecH = Value.Millisecond / 10;
			// MSecL = Last digit of miliseconds
			int MsecL = Value.Millisecond % 10;
			if (Year > 1999)
				Year -= 2000;

			Buffer[Pos] = ByteToBCD(Year);
			Buffer[Pos + 1] = ByteToBCD(Month);
			Buffer[Pos + 2] = ByteToBCD(Day);
			Buffer[Pos + 3] = ByteToBCD(Hour);
			Buffer[Pos + 4] = ByteToBCD(Min);
			Buffer[Pos + 5] = ByteToBCD(Sec);
			Buffer[Pos + 6] = ByteToBCD(MsecH);
			Buffer[Pos + 7] = ByteToBCD(MsecL * 10 + Dow);
		}
		#endregion

		#region Get/Set DATE (S7 DATE) 
		public static DateTime GetDateAt(byte[] Buffer, int Pos)
		{
			try
			{
				return new DateTime(1990, 1, 1).AddDays(GetIntAt(Buffer, Pos));
			}
			catch (System.ArgumentOutOfRangeException)
			{
				return new DateTime(0);
			}
		}
		public static void SetDateAt(byte[] Buffer, int Pos, DateTime Value)
		{
			SetIntAt(Buffer, Pos, (Int16)(Value - new DateTime(1990, 1, 1)).Days);
		}

		#endregion

		#region Get/Set TOD (S7 TIME_OF_DAY)
		public static DateTime GetTODAt(byte[] Buffer, int Pos)
		{
			try
			{
				return new DateTime(0).AddMilliseconds(S7.GetDIntAt(Buffer, Pos));
			}
			catch (System.ArgumentOutOfRangeException)
			{
				return new DateTime(0);
			}
		}
		public static void SetTODAt(byte[] Buffer, int Pos, DateTime Value)
		{
			TimeSpan Time = Value.TimeOfDay;
			SetDIntAt(Buffer, Pos, (Int32)Math.Round(Time.TotalMilliseconds));
		}
		#endregion

		#region Get/Set LTOD (S7 1500 LONG TIME_OF_DAY)
		public static DateTime GetLTODAt(byte[] Buffer, int Pos)
		{
			// .NET Tick = 100 ns, S71500 Tick = 1 ns
			try
			{
				return new DateTime(Math.Abs(GetLIntAt(Buffer, Pos) / 100));
			}
			catch (System.ArgumentOutOfRangeException)
			{
				return new DateTime(0);
			}
		}
		public static void SetLTODAt(byte[] Buffer, int Pos, DateTime Value)
		{
			TimeSpan Time = Value.TimeOfDay;
			SetLIntAt(Buffer, Pos, (Int64)Time.Ticks * 100);
		}
		#endregion

		#region GET/SET LDT (S7 1500 Long Date and Time)
		public static DateTime GetLDTAt(byte[] Buffer, int Pos)
		{
			try
			{
				return new DateTime((GetLIntAt(Buffer, Pos) / 100) + bias);
			}
			catch (System.ArgumentOutOfRangeException)
			{
				return new DateTime(0);
			}
		}
		public static void SetLDTAt(byte[] Buffer, int Pos, DateTime Value)
		{
			SetLIntAt(Buffer, Pos, (Value.Ticks - bias) * 100);
		}
		#endregion

		#region Get/Set DTL (S71200/1500 Date and Time)
		// Thanks to Johan Cardoen for GetDTLAt
		public static DateTime GetDTLAt(byte[] Buffer, int Pos)
		{
			int Year, Month, Day, Hour, Min, Sec, MSec;

			Year = Buffer[Pos] * 256 + Buffer[Pos + 1];
			Month = Buffer[Pos + 2];
			Day = Buffer[Pos + 3];
			Hour = Buffer[Pos + 5];
			Min = Buffer[Pos + 6];
			Sec = Buffer[Pos + 7];
			MSec = (int)GetUDIntAt(Buffer, Pos + 8) / 1000000;

			try
			{
				return new DateTime(Year, Month, Day, Hour, Min, Sec, MSec);
			}
			catch (System.ArgumentOutOfRangeException)
			{
				return new DateTime(0);
			}
		}
		public static void SetDTLAt(byte[] Buffer, int Pos, DateTime Value)
		{
			short Year = (short)Value.Year;
			byte Month = (byte)Value.Month;
			byte Day = (byte)Value.Day;
			byte Hour = (byte)Value.Hour;
			byte Min = (byte)Value.Minute;
			byte Sec = (byte)Value.Second;
			byte Dow = (byte)(Value.DayOfWeek + 1);

			Int32 NanoSecs = Value.Millisecond * 1000000;

			var bytes_short = BitConverter.GetBytes(Year);

			Buffer[Pos] = bytes_short[1];
			Buffer[Pos + 1] = bytes_short[0];
			Buffer[Pos + 2] = Month;
			Buffer[Pos + 3] = Day;
			Buffer[Pos + 4] = Dow;
			Buffer[Pos + 5] = Hour;
			Buffer[Pos + 6] = Min;
			Buffer[Pos + 7] = Sec;
			SetDIntAt(Buffer, Pos + 8, NanoSecs);
		}

		#endregion

		#region Get/Set String (S7 String)
		// Thanks to Pablo Agirre 
		public static string GetStringAt(byte[] Buffer, int Pos)
		{
			int size = (int)Buffer[Pos + 1];
			return Encoding.UTF8.GetString(Buffer, Pos + 2, size);
		}

		public static void SetStringAt(byte[] Buffer, int Pos, int MaxLen, string Value)
		{
			int size = Value.Length;
			Buffer[Pos] = (byte)MaxLen;
			Buffer[Pos + 1] = (byte)size;
			Encoding.UTF8.GetBytes(Value, 0, size, Buffer, Pos + 2);
		}

		#endregion

		#region Get/Set WString (S7-1500 String)
		public static string GetWStringAt(byte[] Buffer, int Pos)
		{
			//WString size = n characters + 2 Words (first for max length, second for real length)
			//Get the real length in Words
			int size = GetIntAt(Buffer, Pos + 2);
			//Extract string in UTF-16 unicode Big Endian.
			return Encoding.BigEndianUnicode.GetString(Buffer, Pos + 4, size * 2);
		}

		public static void SetWStringAt(byte[] Buffer, int Pos, int MaxCharNb, string Value)
		{
			//Get the length in words from number of characters
			int size = Value.Length;
			//Set the Max length in Words 
			SetIntAt(Buffer, Pos, (short)MaxCharNb);
			//Set the real length in words
			SetIntAt(Buffer, Pos + 2, (short)size);
			//Set the UTF-16 unicode Big endian String (after max length and length)
			Encoding.BigEndianUnicode.GetBytes(Value, 0, size, Buffer, Pos + 4);
		}

		#endregion

		#region Get/Set Array of char (S7 ARRAY OF CHARS)
		public static string GetCharsAt(byte[] Buffer, int Pos, int Size)
		{
			return Encoding.UTF8.GetString(Buffer, Pos, Size);
		}

		public static void SetCharsAt(byte[] Buffer, int Pos, string Value)
		{
			int MaxLen = Buffer.Length - Pos;
			// Truncs the string if there's no room enough        
			if (MaxLen > Value.Length) MaxLen = Value.Length;
			Encoding.UTF8.GetBytes(Value, 0, MaxLen, Buffer, Pos);
		}

		#endregion

		#region Get/Set Array of WChar (S7-1500 ARRAY OF CHARS)

		public static String GetWCharsAt(byte[] Buffer, int Pos, int SizeInCharNb)
		{
			//Extract Unicode UTF-16 Big-Endian character from the buffer. To use with WChar Datatype.
			//Size to read is in byte. Be careful, 1 char = 2 bytes
			return Encoding.BigEndianUnicode.GetString(Buffer, Pos, SizeInCharNb * 2);
		}

		public static void SetWCharsAt(byte[] Buffer, int Pos, string Value)
		{
			//Compute Max length in char number
			int MaxLen = (Buffer.Length - Pos) / 2;
			// Truncs the string if there's no room enough        
			if (MaxLen > Value.Length) MaxLen = Value.Length;
			Encoding.BigEndianUnicode.GetBytes(Value, 0, MaxLen, Buffer, Pos);
		}

		#endregion

		#region Get/Set Counter
		public static int GetCounter(ushort Value)
		{
			return BCDtoByte((byte)Value) * 100 + BCDtoByte((byte)(Value >> 8));
		}

		public static int GetCounterAt(ushort[] Buffer, int Index)
		{
			return GetCounter(Buffer[Index]);
		}

		public static ushort ToCounter(int Value)
		{
			return (ushort)(ByteToBCD(Value / 100) + (ByteToBCD(Value % 100) << 8));
		}

		public static void SetCounterAt(ushort[] Buffer, int Pos, int Value)
		{
			Buffer[Pos] = ToCounter(Value);
		}
		#endregion

		#region Get/Set Timer

		public static S7Timer GetS7TimerAt(byte[] Buffer, int Pos)
		{
			return new S7Timer(new List<byte>(Buffer).GetRange(Pos, 12).ToArray());
		}

		public static void SetS7TimespanAt(byte[] Buffer, int Pos, TimeSpan Value)
		{
			SetDIntAt(Buffer, Pos, (Int32)Value.TotalMilliseconds);
		}

		public static TimeSpan GetS7TimespanAt(byte[] Buffer, int pos)
		{
			if (Buffer.Length < pos + 4)
			{
				return new TimeSpan();
			}

			Int32 a;
			a = Buffer[pos + 0]; a <<= 8;
			a += Buffer[pos + 1]; a <<= 8;
			a += Buffer[pos + 2]; a <<= 8;
			a += Buffer[pos + 3];
			TimeSpan sp = new TimeSpan(0, 0, 0, 0, a);

			return sp;
		}

		public static TimeSpan GetLTimeAt(byte[] Buffer, int pos)
		{
			//LTime size : 64 bits (8 octets)
			//Case if the buffer is too small
			if (Buffer.Length < pos + 8) return new TimeSpan();

			try
			{
				// Extract and Convert number of nanoseconds to tick (1 tick = 100 nanoseconds)
				return TimeSpan.FromTicks(GetLIntAt(Buffer, pos) / 100);
			}
			catch (Exception)
			{
				return new TimeSpan();
			}
		}

		public static void SetLTimeAt(byte[] Buffer, int Pos, TimeSpan Value)
		{
			SetLIntAt(Buffer, Pos, (long)(Value.Ticks * 100));
		}

		#endregion

		#endregion [Help Functions]
	}

	public class S7MultiVar
	{
		#region [MultiRead/Write Helper]
		private S7Client FClient;
		private GCHandle[] Handles = new GCHandle[S7Client.MaxVars];
		private int Count = 0;
		private S7Client.S7DataItem[] Items = new S7Client.S7DataItem[S7Client.MaxVars];


		public int[] Results = new int[S7Client.MaxVars];

		private bool AdjustWordLength(int Area, ref int WordLen, ref int Amount, ref int Start)
		{
			// Calc Word size          
			int WordSize = S7.DataSizeByte(WordLen);
			if (WordSize == 0)
				return false;

			if (Area == S7Consts.S7AreaCT)
				WordLen = S7Consts.S7WLCounter;
			if (Area == S7Consts.S7AreaTM)
				WordLen = S7Consts.S7WLTimer;

			if (WordLen == S7Consts.S7WLBit)
				Amount = 1;  // Only 1 bit can be transferred at time
			else
			{
				if ((WordLen != S7Consts.S7WLCounter) && (WordLen != S7Consts.S7WLTimer))
				{
					Amount = Amount * WordSize;
					Start = Start * 8;
					WordLen = S7Consts.S7WLByte;
				}
			}
			return true;
		}

		public S7MultiVar(S7Client Client)
		{
			FClient = Client;
			for (int c = 0; c < S7Client.MaxVars; c++)
				Results[c] = (int)S7Consts.errCliItemNotAvailable;
		}
		~S7MultiVar()
		{
			Clear();
		}

		public bool Add<T>(S7Consts.S7Tag Tag, ref T[] Buffer, int Offset)
		{
			return Add(Tag.Area, Tag.WordLen, Tag.DBNumber, Tag.Start, Tag.Elements, ref Buffer, Offset);
		}

		public bool Add<T>(S7Consts.S7Tag Tag, ref T[] Buffer)
		{
			return Add(Tag.Area, Tag.WordLen, Tag.DBNumber, Tag.Start, Tag.Elements, ref Buffer);
		}

		public bool Add<T>(Int32 Area, Int32 WordLen, Int32 DBNumber, Int32 Start, Int32 Amount, ref T[] Buffer)
		{
			return Add(Area, WordLen, DBNumber, Start, Amount, ref Buffer, 0);
		}

		public bool Add<T>(Int32 Area, Int32 WordLen, Int32 DBNumber, Int32 Start, Int32 Amount, ref T[] Buffer, int Offset)
		{
			if (Count < S7Client.MaxVars)
			{
				if (AdjustWordLength(Area, ref WordLen, ref Amount, ref Start))
				{
					Items[Count].Area = Area;
					Items[Count].WordLen = WordLen;
					Items[Count].Result = (int)S7Consts.errCliItemNotAvailable;
					Items[Count].DBNumber = DBNumber;
					Items[Count].Start = Start;
					Items[Count].Amount = Amount;
					GCHandle handle = GCHandle.Alloc(Buffer, GCHandleType.Pinned);
#if WINDOWS_UWP || NETFX_CORE
					if (IntPtr.Size == 4)
						Items[Count].pData = (IntPtr)(handle.AddrOfPinnedObject().ToInt32() + Offset * Marshal.SizeOf<T>());
					else
						Items[Count].pData = (IntPtr)(handle.AddrOfPinnedObject().ToInt64() + Offset * Marshal.SizeOf<T>());
#else
					if (IntPtr.Size == 4)
						Items[Count].pData = (IntPtr)(handle.AddrOfPinnedObject().ToInt32() + Offset * Marshal.SizeOf(typeof(T)));
					else
						Items[Count].pData = (IntPtr)(handle.AddrOfPinnedObject().ToInt64() + Offset * Marshal.SizeOf(typeof(T)));
#endif
					Handles[Count] = handle;
					Count++;
					return true;
				}
				else
					return false;
			}
			else
				return false;
		}

		public int Read()
		{
			int FunctionResult;
			int GlobalResult = (int)S7Consts.errCliFunctionRefused;
			try
			{
				if (Count > 0)
				{
					FunctionResult = FClient.ReadMultiVars(Items, Count);
					if (FunctionResult == 0)
						for (int c = 0; c < S7Client.MaxVars; c++)
							Results[c] = Items[c].Result;
					GlobalResult = FunctionResult;
				}
				else
					GlobalResult = (int)S7Consts.errCliFunctionRefused;
			}
			finally
			{
				Clear(); // handles are no more needed and MUST be freed
			}
			return GlobalResult;
		}

		public int Write()
		{
			int FunctionResult;
			int GlobalResult = (int)S7Consts.errCliFunctionRefused;
			try
			{
				if (Count > 0)
				{
					FunctionResult = FClient.WriteMultiVars(Items, Count);
					if (FunctionResult == 0)
						for (int c = 0; c < S7Client.MaxVars; c++)
							Results[c] = Items[c].Result;
					GlobalResult = FunctionResult;
				}
				else
					GlobalResult = (int)S7Consts.errCliFunctionRefused;
			}
			finally
			{
				Clear(); // handles are no more needed and MUST be freed
			}
			return GlobalResult;
		}

		public void Clear()
		{
			for (int c = 0; c < Count; c++)
			{
				if (Handles[c] != null)
					Handles[c].Free();
			}
			Count = 0;
		}
		#endregion
	}

	public class S7Client
	{
		#region [Constants and TypeDefs]

		// Block type
		public const int Block_OB = 0x38;
		public const int Block_DB = 0x41;
		public const int Block_SDB = 0x42;
		public const int Block_FC = 0x43;
		public const int Block_SFC = 0x44;
		public const int Block_FB = 0x45;
		public const int Block_SFB = 0x46;

		// Sub Block Type 
		public const byte SubBlk_OB = 0x08;
		public const byte SubBlk_DB = 0x0A;
		public const byte SubBlk_SDB = 0x0B;
		public const byte SubBlk_FC = 0x0C;
		public const byte SubBlk_SFC = 0x0D;
		public const byte SubBlk_FB = 0x0E;
		public const byte SubBlk_SFB = 0x0F;

		// Block languages
		public const byte BlockLangAWL = 0x01;
		public const byte BlockLangKOP = 0x02;
		public const byte BlockLangFUP = 0x03;
		public const byte BlockLangSCL = 0x04;
		public const byte BlockLangDB = 0x05;
		public const byte BlockLangGRAPH = 0x06;

		// Max number of vars (multiread/write)
		public static readonly int MaxVars = 20;

		// Result transport size
		const byte TS_ResBit = 0x03;
		const byte TS_ResByte = 0x04;
		const byte TS_ResInt = 0x05;
		const byte TS_ResReal = 0x07;
		const byte TS_ResOctet = 0x09;

		const ushort Code7Ok = 0x0000;
		const ushort Code7AddressOutOfRange = 0x0005;
		const ushort Code7InvalidTransportSize = 0x0006;
		const ushort Code7WriteDataSizeMismatch = 0x0007;
		const ushort Code7ResItemNotAvailable = 0x000A;
		const ushort Code7ResItemNotAvailable1 = 0xD209;
		const ushort Code7InvalidValue = 0xDC01;
		const ushort Code7NeedPassword = 0xD241;
		const ushort Code7InvalidPassword = 0xD602;
		const ushort Code7NoPasswordToClear = 0xD604;
		const ushort Code7NoPasswordToSet = 0xD605;
		const ushort Code7FunNotAvailable = 0x8104;
		const ushort Code7DataOverPDU = 0x8500;

		// Client Connection Type
		public static readonly UInt16 CONNTYPE_PG = 0x01;  // Connect to the PLC as a PG
		public static readonly UInt16 CONNTYPE_OP = 0x02;  // Connect to the PLC as an OP
		public static readonly UInt16 CONNTYPE_BASIC = 0x03;  // Basic connection 

		public int _LastError = 0;

		public struct S7DataItem
		{
			public int Area;
			public int WordLen;
			public int Result;
			public int DBNumber;
			public int Start;
			public int Amount;
			public IntPtr pData;
		}

		// Order Code + Version
		public struct S7OrderCode
		{
			public string Code; // such as "6ES7 151-8AB01-0AB0"
			public byte V1;     // Version 1st digit
			public byte V2;     // Version 2nd digit
			public byte V3;     // Version 3th digit
		};

		// CPU Info
		public struct S7CpuInfo
		{
			public string ModuleTypeName;
			public string SerialNumber;
			public string ASName;
			public string Copyright;
			public string ModuleName;
		}

		public struct S7CpInfo
		{
			public int MaxPduLength;
			public int MaxConnections;
			public int MaxMpiRate;
			public int MaxBusRate;
		};

		// Block List
		[StructLayout(LayoutKind.Sequential, Pack = 1)]
		public struct S7BlocksList
		{
			public Int32 OBCount;
			public Int32 FBCount;
			public Int32 FCCount;
			public Int32 SFBCount;
			public Int32 SFCCount;
			public Int32 DBCount;
			public Int32 SDBCount;
		};

		// Managed Block Info
		public struct S7BlockInfo
		{
			public int BlkType;
			public int BlkNumber;
			public int BlkLang;
			public int BlkFlags;
			public int MC7Size;  // The real size in bytes
			public int LoadSize;
			public int LocalData;
			public int SBBLength;
			public int CheckSum;
			public int Version;
			// Chars info
			public string CodeDate;
			public string IntfDate;
			public string Author;
			public string Family;
			public string Header;
		};

		// See §33.1 of "System Software for S7-300/400 System and Standard Functions"
		// and see SFC51 description too
		[StructLayout(LayoutKind.Sequential, Pack = 1)]
		public struct SZL_HEADER
		{
			public UInt16 LENTHDR;
			public UInt16 N_DR;
		};

		[StructLayout(LayoutKind.Sequential, Pack = 1)]
		public struct S7SZL
		{
			public SZL_HEADER Header;
			[MarshalAs(UnmanagedType.ByValArray)]
			public byte[] Data;
		};

		// SZL List of available SZL IDs : same as SZL but List items are big-endian adjusted
		[StructLayout(LayoutKind.Sequential, Pack = 1)]
		public struct S7SZLList
		{
			public SZL_HEADER Header;
			[MarshalAs(UnmanagedType.ByValArray, SizeConst = 0x2000 - 2)]
			public UInt16[] Data;
		};

		// S7 Protection
		// See §33.19 of "System Software for S7-300/400 System and Standard Functions"
		public struct S7Protection
		{
			public ushort sch_schal;
			public ushort sch_par;
			public ushort sch_rel;
			public ushort bart_sch;
			public ushort anl_sch;
		};

		#endregion

		#region [S7 Telegrams]

		// ISO Connection Request telegram (contains also ISO Header and COTP Header)
		byte[] ISO_CR = {
			// TPKT (RFC1006 Header)
			0x03, // RFC 1006 ID (3) 
			0x00, // Reserved, always 0
			0x00, // High part of packet lenght (entire frame, payload and TPDU included)
			0x16, // Low part of packet lenght (entire frame, payload and TPDU included)
			// COTP (ISO 8073 Header)
			0x11, // PDU Size Length
			0xE0, // CR - Connection Request ID
			0x00, // Dst Reference HI
			0x00, // Dst Reference LO
			0x00, // Src Reference HI
			0x01, // Src Reference LO
			0x00, // Class + Options Flags
			0xC0, // PDU Max Length ID
			0x01, // PDU Max Length HI
			0x0A, // PDU Max Length LO
			0xC1, // Src TSAP Identifier
			0x02, // Src TSAP Length (2 bytes)
			0x01, // Src TSAP HI (will be overwritten)
			0x00, // Src TSAP LO (will be overwritten)
			0xC2, // Dst TSAP Identifier
			0x02, // Dst TSAP Length (2 bytes)
			0x01, // Dst TSAP HI (will be overwritten)
			0x02  // Dst TSAP LO (will be overwritten)
		};

		// TPKT + ISO COTP Header (Connection Oriented Transport Protocol)
		byte[] TPKT_ISO = { // 7 bytes
			0x03,0x00,
			0x00,0x1f,      // Telegram Length (Data Size + 31 or 35)
			0x02,0xf0,0x80  // COTP (see above for info)
		};

		// S7 PDU Negotiation Telegram (contains also ISO Header and COTP Header)
		byte[] S7_PN = {
			0x03, 0x00, 0x00, 0x19,
			0x02, 0xf0, 0x80, // TPKT + COTP (see above for info)
			0x32, 0x01, 0x00, 0x00,
			0x04, 0x00, 0x00, 0x08,
			0x00, 0x00, 0xf0, 0x00,
			0x00, 0x01, 0x00, 0x01,
			0x00, 0x1e        // PDU Length Requested = HI-LO Here Default 480 bytes
		};

		// S7 Read/Write Request Header (contains also ISO Header and COTP Header)
		byte[] S7_RW = { // 31-35 bytes
			0x03,0x00,
			0x00,0x1f,       // Telegram Length (Data Size + 31 or 35)
			0x02,0xf0, 0x80, // COTP (see above for info)
			0x32,            // S7 Protocol ID 
			0x01,            // Job Type
			0x00,0x00,       // Redundancy identification
			0x05,0x00,       // PDU Reference
			0x00,0x0e,       // Parameters Length
			0x00,0x00,       // Data Length = Size(bytes) + 4      
			0x04,            // Function 4 Read Var, 5 Write Var  
			0x01,            // Items count
			0x12,            // Var spec.
			0x0a,            // Length of remaining bytes
			0x10,            // Syntax ID 
			(byte)S7Consts.S7WLByte,  // Transport Size idx=22                       
			0x00,0x00,       // Num Elements                          
			0x00,0x00,       // DB Number (if any, else 0)            
			0x84,            // Area Type                            
			0x00,0x00,0x00,  // Area Offset                     
			// WR area
			0x00,            // Reserved 
			0x04,            // Transport size
			0x00,0x00,       // Data Length * 8 (if not bit or timer or counter) 
		};
		private static int Size_RD = 31; // Header Size when Reading 
		private static int Size_WR = 35; // Header Size when Writing

		// S7 Variable MultiRead Header
		byte[] S7_MRD_HEADER = {
			0x03,0x00,
			0x00,0x1f,       // Telegram Length 
			0x02,0xf0, 0x80, // COTP (see above for info)
			0x32,            // S7 Protocol ID 
			0x01,            // Job Type
			0x00,0x00,       // Redundancy identification
			0x05,0x00,       // PDU Reference
			0x00,0x0e,       // Parameters Length
			0x00,0x00,       // Data Length = Size(bytes) + 4      
			0x04,            // Function 4 Read Var, 5 Write Var  
			0x01             // Items count (idx 18)
		};

		// S7 Variable MultiRead Item
		byte[] S7_MRD_ITEM = {
			0x12,            // Var spec.
			0x0a,            // Length of remaining bytes
			0x10,            // Syntax ID 
			(byte)S7Consts.S7WLByte,  // Transport Size idx=3                   
			0x00,0x00,       // Num Elements                          
			0x00,0x00,       // DB Number (if any, else 0)            
			0x84,            // Area Type                            
			0x00,0x00,0x00   // Area Offset                     
		};

		// S7 Variable MultiWrite Header
		byte[] S7_MWR_HEADER = {
			0x03,0x00,
			0x00,0x1f,       // Telegram Length 
			0x02,0xf0, 0x80, // COTP (see above for info)
			0x32,            // S7 Protocol ID 
			0x01,            // Job Type
			0x00,0x00,       // Redundancy identification
			0x05,0x00,       // PDU Reference
			0x00,0x0e,       // Parameters Length (idx 13)
			0x00,0x00,       // Data Length = Size(bytes) + 4 (idx 15)     
			0x05,            // Function 5 Write Var  
			0x01             // Items count (idx 18)
		};

		// S7 Variable MultiWrite Item (Param)
		byte[] S7_MWR_PARAM = {
			0x12,            // Var spec.
			0x0a,            // Length of remaining bytes
			0x10,            // Syntax ID 
			(byte)S7Consts.S7WLByte,  // Transport Size idx=3                      
			0x00,0x00,       // Num Elements                          
			0x00,0x00,       // DB Number (if any, else 0)            
			0x84,            // Area Type                            
			0x00,0x00,0x00,  // Area Offset                     
		};

		// SZL First telegram request   
		byte[] S7_SZL_FIRST = {
			0x03, 0x00, 0x00, 0x21,
			0x02, 0xf0, 0x80, 0x32,
			0x07, 0x00, 0x00,
			0x05, 0x00, // Sequence out
			0x00, 0x08, 0x00,
			0x08, 0x00, 0x01, 0x12,
			0x04, 0x11, 0x44, 0x01,
			0x00, 0xff, 0x09, 0x00,
			0x04,
			0x00, 0x00, // ID (29)
			0x00, 0x00  // Index (31)
		};

		// SZL Next telegram request 
		byte[] S7_SZL_NEXT = {
			0x03, 0x00, 0x00, 0x21,
			0x02, 0xf0, 0x80, 0x32,
			0x07, 0x00, 0x00, 0x06,
			0x00, 0x00, 0x0c, 0x00,
			0x04, 0x00, 0x01, 0x12,
			0x08, 0x12, 0x44, 0x01,
			0x01, // Sequence
			0x00, 0x00, 0x00, 0x00,
			0x0a, 0x00, 0x00, 0x00
		};

		// Get Date/Time request
		byte[] S7_GET_DT = {
			0x03, 0x00, 0x00, 0x1d,
			0x02, 0xf0, 0x80, 0x32,
			0x07, 0x00, 0x00, 0x38,
			0x00, 0x00, 0x08, 0x00,
			0x04, 0x00, 0x01, 0x12,
			0x04, 0x11, 0x47, 0x01,
			0x00, 0x0a, 0x00, 0x00,
			0x00
		};

		// Set Date/Time command
		byte[] S7_SET_DT = {
			0x03, 0x00, 0x00, 0x27,
			0x02, 0xf0, 0x80, 0x32,
			0x07, 0x00, 0x00, 0x89,
			0x03, 0x00, 0x08, 0x00,
			0x0e, 0x00, 0x01, 0x12,
			0x04, 0x11, 0x47, 0x02,
			0x00, 0xff, 0x09, 0x00,
			0x0a, 0x00,
			0x19, // Hi part of Year (idx=30)
			0x13, // Lo part of Year
			0x12, // Month
			0x06, // Day
			0x17, // Hour
			0x37, // Min
			0x13, // Sec
			0x00, 0x01 // ms + Day of week   
		};

		// S7 Set Session Password 
		byte[] S7_SET_PWD = {
			0x03, 0x00, 0x00, 0x25,
			0x02, 0xf0, 0x80, 0x32,
			0x07, 0x00, 0x00, 0x27,
			0x00, 0x00, 0x08, 0x00,
			0x0c, 0x00, 0x01, 0x12,
			0x04, 0x11, 0x45, 0x01,
			0x00, 0xff, 0x09, 0x00,
			0x08, 
			// 8 Char Encoded Password
			0x00, 0x00, 0x00, 0x00,
			0x00, 0x00, 0x00, 0x00
		};

		// S7 Clear Session Password 
		byte[] S7_CLR_PWD = {
			0x03, 0x00, 0x00, 0x1d,
			0x02, 0xf0, 0x80, 0x32,
			0x07, 0x00, 0x00, 0x29,
			0x00, 0x00, 0x08, 0x00,
			0x04, 0x00, 0x01, 0x12,
			0x04, 0x11, 0x45, 0x02,
			0x00, 0x0a, 0x00, 0x00,
			0x00
		};

		// S7 STOP request
		byte[] S7_STOP = {
			0x03, 0x00, 0x00, 0x21,
			0x02, 0xf0, 0x80, 0x32,
			0x01, 0x00, 0x00, 0x0e,
			0x00, 0x00, 0x10, 0x00,
			0x00, 0x29, 0x00, 0x00,
			0x00, 0x00, 0x00, 0x09,
			0x50, 0x5f, 0x50, 0x52,
			0x4f, 0x47, 0x52, 0x41,
			0x4d
		};

		// S7 HOT Start request
		byte[] S7_HOT_START = {
			0x03, 0x00, 0x00, 0x25,
			0x02, 0xf0, 0x80, 0x32,
			0x01, 0x00, 0x00, 0x0c,
			0x00, 0x00, 0x14, 0x00,
			0x00, 0x28, 0x00, 0x00,
			0x00, 0x00, 0x00, 0x00,
			0xfd, 0x00, 0x00, 0x09,
			0x50, 0x5f, 0x50, 0x52,
			0x4f, 0x47, 0x52, 0x41,
			0x4d
		};

		// S7 COLD Start request
		byte[] S7_COLD_START = {
			0x03, 0x00, 0x00, 0x27,
			0x02, 0xf0, 0x80, 0x32,
			0x01, 0x00, 0x00, 0x0f,
			0x00, 0x00, 0x16, 0x00,
			0x00, 0x28, 0x00, 0x00,
			0x00, 0x00, 0x00, 0x00,
			0xfd, 0x00, 0x02, 0x43,
			0x20, 0x09, 0x50, 0x5f,
			0x50, 0x52, 0x4f, 0x47,
			0x52, 0x41, 0x4d
		};
		const byte pduStart = 0x28;   // CPU start
		const byte pduStop = 0x29;   // CPU stop
		const byte pduAlreadyStarted = 0x02;   // CPU already in run mode
		const byte pduAlreadyStopped = 0x07;   // CPU already in stop mode

		// S7 Get PLC Status 
		byte[] S7_GET_STAT = {
			0x03, 0x00, 0x00, 0x21,
			0x02, 0xf0, 0x80, 0x32,
			0x07, 0x00, 0x00, 0x2c,
			0x00, 0x00, 0x08, 0x00,
			0x08, 0x00, 0x01, 0x12,
			0x04, 0x11, 0x44, 0x01,
			0x00, 0xff, 0x09, 0x00,
			0x04, 0x04, 0x24, 0x00,
			0x00
		};

		// S7 Get Block Info Request Header (contains also ISO Header and COTP Header)
		byte[] S7_BI = {
			0x03, 0x00, 0x00, 0x25,
			0x02, 0xf0, 0x80, 0x32,
			0x07, 0x00, 0x00, 0x05,
			0x00, 0x00, 0x08, 0x00,
			0x0c, 0x00, 0x01, 0x12,
			0x04, 0x11, 0x43, 0x03,
			0x00, 0xff, 0x09, 0x00,
			0x08, 0x30,
			0x41, // Block Type
			0x30, 0x30, 0x30, 0x30, 0x30, // ASCII Block Number
			0x41
		};

		// S7 List Blocks Request Header
		byte[] S7_LIST_BLOCKS = {
			0x03, 0x00, 0x00, 0x1d,
			0x02, 0xf0, 0x80, 0x32,
			0x07, 0x00, 0x00, 0x00,
			0x00, 0x00, 0x08, 0x00,
			0x04, 0x00, 0x01, 0x12,
			0x04, 0x11, 0x43, 0x01, // 0x43 0x01 = ListBlocks
			0x00, 0x0a, 0x00, 0x00,
			0x00
		};

		// S7 List Blocks Of Type Request Header
		byte[] S7_LIST_BLOCKS_OF_TYPE = {
			0x03, 0x00, 0x00, 0x1f,
			0x02, 0xf0, 0x80, 0x32,
			0x07, 0x00, 0x00, 0x00,
			0x00, 0x00, 0x08, 0x00,
			0x06, 0x00, 0x01, 0x12,
			0x04, 0x11, 0x43, 0x02, // 0x43 0x02 = ListBlocksOfType
			0x00 // ... append ReqData
		};

		#endregion

		#region [Internals]

		// Defaults
		private static int ISOTCP = 102; // ISOTCP Port
		private static int MinPduSize = 16;
		private static int MinPduSizeToRequest = 240;
		private static int MaxPduSizeToRequest = 960;
		private static int DefaultTimeout = 2000;
		private static int IsoHSize = 7; // TPKT+COTP Header Size

		// Properties
		private int _PDULength = 0;
		private int _PduSizeRequested = 480;
		private int _PLCPort = ISOTCP;
		private int _RecvTimeout = DefaultTimeout;
		private int _SendTimeout = DefaultTimeout;
		private int _ConnTimeout = DefaultTimeout;

		// Privates
		private string IPAddress;
		private byte LocalTSAP_HI;
		private byte LocalTSAP_LO;
		private byte RemoteTSAP_HI;
		private byte RemoteTSAP_LO;
		private byte LastPDUType;
		private ushort ConnType = CONNTYPE_PG;
		private byte[] PDU = new byte[2048];
		private MsgSocket Socket = null;
		private int Time_ms = 0;
		private ushort cntword = 0;

		private void CreateSocket()
		{
			try
			{
				Socket = new MsgSocket();
				Socket.ConnectTimeout = _ConnTimeout;
				Socket.ReadTimeout = _RecvTimeout;
				Socket.WriteTimeout = _SendTimeout;
			}
			catch
			{
			}
		}

		private int TCPConnect()
		{
			if (_LastError == 0)
				try
				{
					_LastError = Socket.Connect(IPAddress, _PLCPort);
				}
				catch
				{
					_LastError = S7Consts.errTCPConnectionFailed;
				}
			return _LastError;
		}

		private void RecvPacket(byte[] Buffer, int Start, int Size)
		{
			if (Connected)
				_LastError = Socket.Receive(Buffer, Start, Size);
			else
				_LastError = S7Consts.errTCPNotConnected;
		}

		private void SendPacket(byte[] Buffer, int Len)
		{
			_LastError = Socket.Send(Buffer, Len);
		}

		private void SendPacket(byte[] Buffer)
		{
			if (Connected)
				SendPacket(Buffer, Buffer.Length);
			else
				_LastError = S7Consts.errTCPNotConnected;
		}

		private int RecvIsoPacket()
		{
			Boolean Done = false;
			int Size = 0;
			while ((_LastError == 0) && !Done)
			{
				// Get TPKT (4 bytes)
				RecvPacket(PDU, 0, 4);
				if (_LastError == 0)
				{
					Size = S7.GetWordAt(PDU, 2);
					// Check 0 bytes Data Packet (only TPKT+COTP = 7 bytes)
					if (Size == IsoHSize)
						RecvPacket(PDU, 4, 3); // Skip remaining 3 bytes and Done is still false
					else
					{
						if ((Size > _PduSizeRequested + IsoHSize) || (Size < MinPduSize))
							_LastError = S7Consts.errIsoInvalidPDU;
						else
							Done = true; // a valid Length !=7 && >16 && <247
					}
				}
			}
			if (_LastError == 0)
			{
				RecvPacket(PDU, 4, 3); // Skip remaining 3 COTP bytes
				LastPDUType = PDU[5];   // Stores PDU Type, we need it 
										// Receives the S7 Payload          
				RecvPacket(PDU, 7, Size - IsoHSize);
			}
			if (_LastError == 0)
				return Size;
			else
				return 0;
		}

		private int ISOConnect()
		{
			int Size;
			ISO_CR[16] = LocalTSAP_HI;
			ISO_CR[17] = LocalTSAP_LO;
			ISO_CR[20] = RemoteTSAP_HI;
			ISO_CR[21] = RemoteTSAP_LO;

			// Sends the connection request telegram      
			SendPacket(ISO_CR);
			if (_LastError == 0)
			{
				// Gets the reply (if any)
				Size = RecvIsoPacket();
				if (_LastError == 0)
				{
					if (Size == 22)
					{
						if (LastPDUType != (byte)0xD0) // 0xD0 = CC Connection confirm
							_LastError = S7Consts.errIsoConnect;
					}
					else
						_LastError = S7Consts.errIsoInvalidPDU;
				}
			}
			return _LastError;
		}

		private int NegotiatePduLength()
		{
			int Length;
			// Set PDU Size Requested
			S7.SetWordAt(S7_PN, 23, (ushort)_PduSizeRequested);
			// Sends the connection request telegram
			SendPacket(S7_PN);
			if (_LastError == 0)
			{
				Length = RecvIsoPacket();
				if (_LastError == 0)
				{
					// check S7 Error
					if ((Length == 27) && (PDU[17] == 0) && (PDU[18] == 0))  // 20 = size of Negotiate Answer
					{
						// Get PDU Size Negotiated
						_PDULength = S7.GetWordAt(PDU, 25);
						if (_PDULength <= 0)
							_LastError = S7Consts.errCliNegotiatingPDU;
					}
					else
						_LastError = S7Consts.errCliNegotiatingPDU;
				}
			}
			return _LastError;
		}

		private int CpuError(ushort Error)
		{
			switch (Error)
			{
				case 0: return 0;
				case Code7AddressOutOfRange: return S7Consts.errCliAddressOutOfRange;
				case Code7InvalidTransportSize: return S7Consts.errCliInvalidTransportSize;
				case Code7WriteDataSizeMismatch: return S7Consts.errCliWriteDataSizeMismatch;
				case Code7ResItemNotAvailable:
				case Code7ResItemNotAvailable1: return S7Consts.errCliItemNotAvailable;
				case Code7DataOverPDU: return S7Consts.errCliSizeOverPDU;
				case Code7InvalidValue: return S7Consts.errCliInvalidValue;
				case Code7FunNotAvailable: return S7Consts.errCliFunNotAvailable;
				case Code7NeedPassword: return S7Consts.errCliNeedPassword;
				case Code7InvalidPassword: return S7Consts.errCliInvalidPassword;
				case Code7NoPasswordToSet:
				case Code7NoPasswordToClear: return S7Consts.errCliNoPasswordToSetOrClear;
				default:
					return S7Consts.errCliFunctionRefused;
			};
		}

		private ushort GetNextWord()
		{
			return cntword++;
		}

		#endregion

		#region [Class Control]

		public S7Client()
		{
			CreateSocket();
		}

		~S7Client()
		{
			Disconnect();
		}

		public int Connect()
		{
			_LastError = 0;
			Time_ms = 0;
			int Elapsed = Environment.TickCount;
			if (!Connected)
			{
				TCPConnect(); // First stage : TCP Connection
				if (_LastError == 0)
				{
					ISOConnect(); // Second stage : ISOTCP (ISO 8073) Connection
					if (_LastError == 0)
					{
						_LastError = NegotiatePduLength(); // Third stage : S7 PDU negotiation
					}
				}
			}
			if (_LastError != 0)
				Disconnect();
			else
				Time_ms = Environment.TickCount - Elapsed;

			return _LastError;
		}

		public int ConnectTo(string Address, int Rack, int Slot)
		{
			UInt16 RemoteTSAP = (UInt16)((ConnType << 8) + (Rack * 0x20) + Slot);
			SetConnectionParams(Address, 0x0100, RemoteTSAP);
			return Connect();
		}

		public int SetConnectionParams(string Address, ushort LocalTSAP, ushort RemoteTSAP)
		{
			int LocTSAP = LocalTSAP & 0x0000FFFF;
			int RemTSAP = RemoteTSAP & 0x0000FFFF;
			IPAddress = Address;
			LocalTSAP_HI = (byte)(LocTSAP >> 8);
			LocalTSAP_LO = (byte)(LocTSAP & 0x00FF);
			RemoteTSAP_HI = (byte)(RemTSAP >> 8);
			RemoteTSAP_LO = (byte)(RemTSAP & 0x00FF);
			return 0;
		}

		public int SetConnectionType(ushort ConnectionType)
		{
			ConnType = ConnectionType;
			return 0;
		}

		public int Disconnect()
		{
			Socket.Close();
			return 0;
		}

		public int GetParam(Int32 ParamNumber, ref int Value)
		{
			int Result = 0;
			switch (ParamNumber)
			{
				case S7Consts.p_u16_RemotePort:
					{
						Value = PLCPort;
						break;
					}
				case S7Consts.p_i32_PingTimeout:
					{
						Value = ConnTimeout;
						break;
					}
				case S7Consts.p_i32_SendTimeout:
					{
						Value = SendTimeout;
						break;
					}
				case S7Consts.p_i32_RecvTimeout:
					{
						Value = RecvTimeout;
						break;
					}
				case S7Consts.p_i32_PDURequest:
					{
						Value = PduSizeRequested;
						break;
					}
				default:
					{
						Result = S7Consts.errCliInvalidParamNumber;
						break;
					}
			}
			return Result;
		}

		// Set Properties for compatibility with Snap7.net.cs
		public int SetParam(Int32 ParamNumber, ref int Value)
		{
			int Result = 0;
			switch (ParamNumber)
			{
				case S7Consts.p_u16_RemotePort:
					{
						PLCPort = Value;
						break;
					}
				case S7Consts.p_i32_PingTimeout:
					{
						ConnTimeout = Value;
						break;
					}
				case S7Consts.p_i32_SendTimeout:
					{
						SendTimeout = Value;
						break;
					}
				case S7Consts.p_i32_RecvTimeout:
					{
						RecvTimeout = Value;
						break;
					}
				case S7Consts.p_i32_PDURequest:
					{
						PduSizeRequested = Value;
						break;
					}
				default:
					{
						Result = S7Consts.errCliInvalidParamNumber;
						break;
					}
			}
			return Result;
		}

		public delegate void S7CliCompletion(IntPtr usrPtr, int opCode, int opResult);
		public int SetAsCallBack(S7CliCompletion Completion, IntPtr usrPtr)
		{
			return S7Consts.errCliFunctionNotImplemented;
		}

		#endregion

		#region [Data I/O main functions]

		public int ReadArea(int Area, int DBNumber, int Start, int Amount, int WordLen, byte[] Buffer)
		{
			int BytesRead = 0;
			return ReadArea(Area, DBNumber, Start, Amount, WordLen, Buffer, ref BytesRead);
		}

		public int ReadArea(int Area, int DBNumber, int Start, int Amount, int WordLen, byte[] Buffer, ref int BytesRead)
		{
			int Address;
			int NumElements;
			int MaxElements;
			int TotElements;
			int SizeRequested;
			int Length;
			int Offset = 0;
			int WordSize = 1;

			_LastError = 0;
			Time_ms = 0;
			int Elapsed = Environment.TickCount;
			// Some adjustment
			if (Area == S7Consts.S7AreaCT)
				WordLen = S7Consts.S7WLCounter;
			if (Area == S7Consts.S7AreaTM)
				WordLen = S7Consts.S7WLTimer;

			// Calc Word size          
			WordSize = S7.DataSizeByte(WordLen);
			if (WordSize == 0)
				return S7Consts.errCliInvalidWordLen;

			if (WordLen == S7Consts.S7WLBit)
				Amount = 1;  // Only 1 bit can be transferred at time
			else
			{
				if ((WordLen != S7Consts.S7WLCounter) && (WordLen != S7Consts.S7WLTimer))
				{
					Amount = Amount * WordSize;
					WordSize = 1;
					WordLen = S7Consts.S7WLByte;
				}
			}

			MaxElements = (_PDULength - 18) / WordSize; // 18 = Reply telegram header
			TotElements = Amount;

			while ((TotElements > 0) && (_LastError == 0))
			{
				NumElements = TotElements;
				if (NumElements > MaxElements)
					NumElements = MaxElements;

				SizeRequested = NumElements * WordSize;

				// Setup the telegram
				Array.Copy(S7_RW, 0, PDU, 0, Size_RD);
				// Set DB Number
				PDU[27] = (byte)Area;
				// Set Area
				if (Area == S7Consts.S7AreaDB)
					S7.SetWordAt(PDU, 25, (ushort)DBNumber);

				// Adjusts Start and word length
				if ((WordLen == S7Consts.S7WLBit) || (WordLen == S7Consts.S7WLCounter) || (WordLen == S7Consts.S7WLTimer))
				{
					Address = Start;
					PDU[22] = (byte)WordLen;
				}
				else
					Address = Start << 3;

				// Num elements
				S7.SetWordAt(PDU, 23, (ushort)NumElements);

				// Address into the PLC (only 3 bytes)           
				PDU[30] = (byte)(Address & 0x0FF);
				Address = Address >> 8;
				PDU[29] = (byte)(Address & 0x0FF);
				Address = Address >> 8;
				PDU[28] = (byte)(Address & 0x0FF);

				SendPacket(PDU, Size_RD);
				if (_LastError == 0)
				{
					Length = RecvIsoPacket();
					if (_LastError == 0)
					{
						if (Length < 25)
							_LastError = S7Consts.errIsoInvalidDataSize;
						else
						{
							if (PDU[21] != 0xFF)
								_LastError = CpuError(PDU[21]);
							else
							{
								Array.Copy(PDU, 25, Buffer, Offset, SizeRequested);
								Offset += SizeRequested;
							}
						}
					}
				}
				TotElements -= NumElements;
				Start += NumElements * WordSize;
			}

			if (_LastError == 0)
			{
				BytesRead = Offset;
				Time_ms = Environment.TickCount - Elapsed;
			}
			else
				BytesRead = 0;
			return _LastError;
		}

		public int WriteArea(int Area, int DBNumber, int Start, int Amount, int WordLen, byte[] Buffer)
		{
			int BytesWritten = 0;
			return WriteArea(Area, DBNumber, Start, Amount, WordLen, Buffer, ref BytesWritten);
		}

		public int WriteArea(int Area, int DBNumber, int Start, int Amount, int WordLen, byte[] Buffer, ref int BytesWritten)
		{
			int Address;
			int NumElements;
			int MaxElements;
			int TotElements;
			int DataSize;
			int IsoSize;
			int Length;
			int Offset = 0;
			int WordSize = 1;

			_LastError = 0;
			Time_ms = 0;
			int Elapsed = Environment.TickCount;
			// Some adjustment
			if (Area == S7Consts.S7AreaCT)
				WordLen = S7Consts.S7WLCounter;
			if (Area == S7Consts.S7AreaTM)
				WordLen = S7Consts.S7WLTimer;

			// Calc Word size          
			WordSize = S7.DataSizeByte(WordLen);
			if (WordSize == 0)
				return S7Consts.errCliInvalidWordLen;

			if (WordLen == S7Consts.S7WLBit) // Only 1 bit can be transferred at time
				Amount = 1;
			else
			{
				if ((WordLen != S7Consts.S7WLCounter) && (WordLen != S7Consts.S7WLTimer))
				{
					Amount = Amount * WordSize;
					WordSize = 1;
					WordLen = S7Consts.S7WLByte;
				}
			}

			MaxElements = (_PDULength - 35) / WordSize; // 35 = Reply telegram header
			TotElements = Amount;

			while ((TotElements > 0) && (_LastError == 0))
			{
				NumElements = TotElements;
				if (NumElements > MaxElements)
					NumElements = MaxElements;

				DataSize = NumElements * WordSize;
				IsoSize = Size_WR + DataSize;

				// Setup the telegram
				Array.Copy(S7_RW, 0, PDU, 0, Size_WR);
				// Whole telegram Size
				S7.SetWordAt(PDU, 2, (ushort)IsoSize);
				// Data Length
				Length = DataSize + 4;
				S7.SetWordAt(PDU, 15, (ushort)Length);
				// Function
				PDU[17] = (byte)0x05;
				// Set DB Number
				PDU[27] = (byte)Area;
				if (Area == S7Consts.S7AreaDB)
					S7.SetWordAt(PDU, 25, (ushort)DBNumber);


				// Adjusts Start and word length
				if ((WordLen == S7Consts.S7WLBit) || (WordLen == S7Consts.S7WLCounter) || (WordLen == S7Consts.S7WLTimer))
				{
					Address = Start;
					Length = DataSize;
					PDU[22] = (byte)WordLen;
				}
				else
				{
					Address = Start << 3;
					Length = DataSize << 3;
				}

				// Num elements
				S7.SetWordAt(PDU, 23, (ushort)NumElements);
				// Address into the PLC
				PDU[30] = (byte)(Address & 0x0FF);
				Address = Address >> 8;
				PDU[29] = (byte)(Address & 0x0FF);
				Address = Address >> 8;
				PDU[28] = (byte)(Address & 0x0FF);

				// Transport Size
				switch (WordLen)
				{
					case S7Consts.S7WLBit:
						PDU[32] = TS_ResBit;
						break;
					case S7Consts.S7WLCounter:
					case S7Consts.S7WLTimer:
						PDU[32] = TS_ResOctet;
						break;
					default:
						PDU[32] = TS_ResByte; // byte/word/dword etc.
						break;
				};
				// Length
				S7.SetWordAt(PDU, 33, (ushort)Length);

				// Copies the Data
				Array.Copy(Buffer, Offset, PDU, 35, DataSize);

				SendPacket(PDU, IsoSize);
				if (_LastError == 0)
				{
					Length = RecvIsoPacket();
					if (_LastError == 0)
					{
						if (Length == 22)
						{
							if (PDU[21] != (byte)0xFF)
								_LastError = CpuError(PDU[21]);
						}
						else
							_LastError = S7Consts.errIsoInvalidPDU;
					}
				}
				Offset += DataSize;
				TotElements -= NumElements;
				Start += NumElements * WordSize;
			}

			if (_LastError == 0)
			{
				BytesWritten = Offset;
				Time_ms = Environment.TickCount - Elapsed;
			}
			else
				BytesWritten = 0;

			return _LastError;
		}

		public int ReadMultiVars(S7DataItem[] Items, int ItemsCount)
		{
			int Offset;
			int Length;
			int ItemSize;
			byte[] S7Item = new byte[12];
			byte[] S7ItemRead = new byte[1024];

			_LastError = 0;
			Time_ms = 0;
			int Elapsed = Environment.TickCount;

			// Checks items
			if (ItemsCount > MaxVars)
				return S7Consts.errCliTooManyItems;

			// Fills Header
			Array.Copy(S7_MRD_HEADER, 0, PDU, 0, S7_MRD_HEADER.Length);
			S7.SetWordAt(PDU, 13, (ushort)(ItemsCount * S7Item.Length + 2));
			PDU[18] = (byte)ItemsCount;
			// Fills the Items
			Offset = 19;
			for (int c = 0; c < ItemsCount; c++)
			{
				Array.Copy(S7_MRD_ITEM, S7Item, S7Item.Length);
				S7Item[3] = (byte)Items[c].WordLen;
				S7.SetWordAt(S7Item, 4, (ushort)Items[c].Amount);
				if (Items[c].Area == S7Consts.S7AreaDB)
					S7.SetWordAt(S7Item, 6, (ushort)Items[c].DBNumber);
				S7Item[8] = (byte)Items[c].Area;

				// Address into the PLC
				int Address = Items[c].Start;
				S7Item[11] = (byte)(Address & 0x0FF);
				Address = Address >> 8;
				S7Item[10] = (byte)(Address & 0x0FF);
				Address = Address >> 8;
				S7Item[09] = (byte)(Address & 0x0FF);

				Array.Copy(S7Item, 0, PDU, Offset, S7Item.Length);
				Offset += S7Item.Length;
			}

			if (Offset > _PDULength)
				return S7Consts.errCliSizeOverPDU;

			S7.SetWordAt(PDU, 2, (ushort)Offset); // Whole size
			SendPacket(PDU, Offset);

			if (_LastError != 0)
				return _LastError;
			// Get Answer
			Length = RecvIsoPacket();
			if (_LastError != 0)
				return _LastError;
			// Check ISO Length
			if (Length < 22)
			{
				_LastError = S7Consts.errIsoInvalidPDU; // PDU too Small
				return _LastError;
			}
			// Check Global Operation Result
			_LastError = CpuError(S7.GetWordAt(PDU, 17));
			if (_LastError != 0)
				return _LastError;
			// Get true ItemsCount
			int ItemsRead = S7.GetByteAt(PDU, 20);
			if ((ItemsRead != ItemsCount) || (ItemsRead > MaxVars))
			{
				_LastError = S7Consts.errCliInvalidPlcAnswer;
				return _LastError;
			}
			// Get Data
			Offset = 21;
			for (int c = 0; c < ItemsCount; c++)
			{
				// Get the Item
				Array.Copy(PDU, Offset, S7ItemRead, 0, Length - Offset);
				if (S7ItemRead[0] == 0xff)
				{
					ItemSize = (int)S7.GetWordAt(S7ItemRead, 2);
					if ((S7ItemRead[1] != TS_ResOctet) && (S7ItemRead[1] != TS_ResReal) && (S7ItemRead[1] != TS_ResBit))
						ItemSize = ItemSize >> 3;
					Marshal.Copy(S7ItemRead, 4, Items[c].pData, ItemSize);
					Items[c].Result = 0;
					if (ItemSize % 2 != 0)
						ItemSize++; // Odd size are rounded
					Offset = Offset + 4 + ItemSize;
				}
				else
				{
					Items[c].Result = CpuError(S7ItemRead[0]);
					Offset += 4; // Skip the Item header                           
				}
			}
			Time_ms = Environment.TickCount - Elapsed;
			return _LastError;
		}

		public int WriteMultiVars(S7DataItem[] Items, int ItemsCount)
		{
			int Offset;
			int ParLength;
			int DataLength;
			int ItemDataSize;
			byte[] S7ParItem = new byte[S7_MWR_PARAM.Length];
			byte[] S7DataItem = new byte[1024];

			_LastError = 0;
			Time_ms = 0;
			int Elapsed = Environment.TickCount;

			// Checks items
			if (ItemsCount > MaxVars)
				return S7Consts.errCliTooManyItems;
			// Fills Header
			Array.Copy(S7_MWR_HEADER, 0, PDU, 0, S7_MWR_HEADER.Length);
			ParLength = ItemsCount * S7_MWR_PARAM.Length + 2;
			S7.SetWordAt(PDU, 13, (ushort)ParLength);
			PDU[18] = (byte)ItemsCount;
			// Fills Params
			Offset = S7_MWR_HEADER.Length;
			for (int c = 0; c < ItemsCount; c++)
			{
				Array.Copy(S7_MWR_PARAM, 0, S7ParItem, 0, S7_MWR_PARAM.Length);
				S7ParItem[3] = (byte)Items[c].WordLen;
				S7ParItem[8] = (byte)Items[c].Area;
				S7.SetWordAt(S7ParItem, 4, (ushort)Items[c].Amount);
				S7.SetWordAt(S7ParItem, 6, (ushort)Items[c].DBNumber);
				// Address into the PLC
				int Address = Items[c].Start;
				S7ParItem[11] = (byte)(Address & 0x0FF);
				Address = Address >> 8;
				S7ParItem[10] = (byte)(Address & 0x0FF);
				Address = Address >> 8;
				S7ParItem[09] = (byte)(Address & 0x0FF);
				Array.Copy(S7ParItem, 0, PDU, Offset, S7ParItem.Length);
				Offset += S7_MWR_PARAM.Length;
			}
			// Fills Data
			DataLength = 0;
			for (int c = 0; c < ItemsCount; c++)
			{
				S7DataItem[0] = 0x00;
				switch (Items[c].WordLen)
				{
					case S7Consts.S7WLBit:
						S7DataItem[1] = TS_ResBit;
						break;
					case S7Consts.S7WLCounter:
					case S7Consts.S7WLTimer:
						S7DataItem[1] = TS_ResOctet;
						break;
					default:
						S7DataItem[1] = TS_ResByte; // byte/word/dword etc.
						break;
				};
				if ((Items[c].WordLen == S7Consts.S7WLTimer) || (Items[c].WordLen == S7Consts.S7WLCounter))
					ItemDataSize = Items[c].Amount * 2;
				else
					ItemDataSize = Items[c].Amount;

				if ((S7DataItem[1] != TS_ResOctet) && (S7DataItem[1] != TS_ResBit))
					S7.SetWordAt(S7DataItem, 2, (ushort)(ItemDataSize * 8));
				else
					S7.SetWordAt(S7DataItem, 2, (ushort)ItemDataSize);

				Marshal.Copy(Items[c].pData, S7DataItem, 4, ItemDataSize);
				if (ItemDataSize % 2 != 0)
				{
					S7DataItem[ItemDataSize + 4] = 0x00;
					ItemDataSize++;
				}
				Array.Copy(S7DataItem, 0, PDU, Offset, ItemDataSize + 4);
				Offset = Offset + ItemDataSize + 4;
				DataLength = DataLength + ItemDataSize + 4;
			}

			// Checks the size
			if (Offset > _PDULength)
				return S7Consts.errCliSizeOverPDU;

			S7.SetWordAt(PDU, 2, (ushort)Offset); // Whole size
			S7.SetWordAt(PDU, 15, (ushort)DataLength); // Whole size
			SendPacket(PDU, Offset);

			RecvIsoPacket();
			if (_LastError == 0)
			{
				// Check Global Operation Result
				_LastError = CpuError(S7.GetWordAt(PDU, 17));
				if (_LastError != 0)
					return _LastError;
				// Get true ItemsCount
				int ItemsWritten = S7.GetByteAt(PDU, 20);
				if ((ItemsWritten != ItemsCount) || (ItemsWritten > MaxVars))
				{
					_LastError = S7Consts.errCliInvalidPlcAnswer;
					return _LastError;
				}

				for (int c = 0; c < ItemsCount; c++)
				{
					if (PDU[c + 21] == 0xFF)
						Items[c].Result = 0;
					else
						Items[c].Result = CpuError((ushort)PDU[c + 21]);
				}
				Time_ms = Environment.TickCount - Elapsed;
			}
			return _LastError;
		}

		#endregion

		#region [Data I/O lean functions]

		public int DBRead(int DBNumber, int Start, int Size, byte[] Buffer)
		{
			return ReadArea(S7Consts.S7AreaDB, DBNumber, Start, Size, S7Consts.S7WLByte, Buffer);
		}

		public int DBWrite(int DBNumber, int Start, int Size, byte[] Buffer)
		{
			return WriteArea(S7Consts.S7AreaDB, DBNumber, Start, Size, S7Consts.S7WLByte, Buffer);
		}

		public int MBRead(int Start, int Size, byte[] Buffer)
		{
			return ReadArea(S7Consts.S7AreaMK, 0, Start, Size, S7Consts.S7WLByte, Buffer);
		}

		public int MBWrite(int Start, int Size, byte[] Buffer)
		{
			return WriteArea(S7Consts.S7AreaMK, 0, Start, Size, S7Consts.S7WLByte, Buffer);
		}

		public int EBRead(int Start, int Size, byte[] Buffer)
		{
			return ReadArea(S7Consts.S7AreaPE, 0, Start, Size, S7Consts.S7WLByte, Buffer);
		}

		public int EBWrite(int Start, int Size, byte[] Buffer)
		{
			return WriteArea(S7Consts.S7AreaPE, 0, Start, Size, S7Consts.S7WLByte, Buffer);
		}

		public int ABRead(int Start, int Size, byte[] Buffer)
		{
			return ReadArea(S7Consts.S7AreaPA, 0, Start, Size, S7Consts.S7WLByte, Buffer);
		}

		public int ABWrite(int Start, int Size, byte[] Buffer)
		{
			return WriteArea(S7Consts.S7AreaPA, 0, Start, Size, S7Consts.S7WLByte, Buffer);
		}

		public int TMRead(int Start, int Amount, ushort[] Buffer)
		{
			byte[] sBuffer = new byte[Amount * 2];
			int Result = ReadArea(S7Consts.S7AreaTM, 0, Start, Amount, S7Consts.S7WLTimer, sBuffer);
			if (Result == 0)
			{
				for (int c = 0; c < Amount; c++)
				{
					Buffer[c] = (ushort)((sBuffer[c * 2 + 1] << 8) + (sBuffer[c * 2]));
				}
			}
			return Result;
		}

		public int TMWrite(int Start, int Amount, ushort[] Buffer)
		{
			byte[] sBuffer = new byte[Amount * 2];
			for (int c = 0; c < Amount; c++)
			{
				sBuffer[c * 2 + 1] = (byte)((Buffer[c] & 0xFF00) >> 8);
				sBuffer[c * 2] = (byte)(Buffer[c] & 0x00FF);
			}
			return WriteArea(S7Consts.S7AreaTM, 0, Start, Amount, S7Consts.S7WLTimer, sBuffer);
		}

		public int CTRead(int Start, int Amount, ushort[] Buffer)
		{
			byte[] sBuffer = new byte[Amount * 2];
			int Result = ReadArea(S7Consts.S7AreaCT, 0, Start, Amount, S7Consts.S7WLCounter, sBuffer);
			if (Result == 0)
			{
				for (int c = 0; c < Amount; c++)
				{
					Buffer[c] = (ushort)((sBuffer[c * 2 + 1] << 8) + (sBuffer[c * 2]));
				}
			}
			return Result;
		}

		public int CTWrite(int Start, int Amount, ushort[] Buffer)
		{
			byte[] sBuffer = new byte[Amount * 2];
			for (int c = 0; c < Amount; c++)
			{
				sBuffer[c * 2 + 1] = (byte)((Buffer[c] & 0xFF00) >> 8);
				sBuffer[c * 2] = (byte)(Buffer[c] & 0x00FF);
			}
			return WriteArea(S7Consts.S7AreaCT, 0, Start, Amount, S7Consts.S7WLCounter, sBuffer);
		}

		#endregion

		#region [Directory functions]

		public int ListBlocks(ref S7BlocksList List)
		{
			_LastError = 0;
			Time_ms = 0;
			int Elapsed = Environment.TickCount;

			ushort Sequence = GetNextWord();

			Array.Copy(S7_LIST_BLOCKS, 0, PDU, 0, S7_LIST_BLOCKS.Length);
			PDU[0x0b] = (byte)(Sequence & 0xff);
			PDU[0x0c] = (byte)(Sequence >> 8);

			SendPacket(PDU, S7_LIST_BLOCKS.Length);

			if (_LastError != 0) return _LastError;
			int Length = RecvIsoPacket();
			if (Length <= 32)// the minimum expected
			{
				_LastError = S7Consts.errIsoInvalidPDU;
				return _LastError;
			}

			ushort Result = S7.GetWordAt(PDU, 27);
			if (Result != 0)
			{
				_LastError = CpuError(Result);
				return _LastError;
			}

			List = default(S7BlocksList);
			int BlocksSize = S7.GetWordAt(PDU, 31);

			if (Length <= 32 + BlocksSize)
			{
				_LastError = S7Consts.errIsoInvalidPDU;
				return _LastError;
			}

			int BlocksCount = BlocksSize >> 2;
			for (int blockNum = 0; blockNum < BlocksCount; blockNum++)
			{
				int Count = S7.GetWordAt(PDU, (blockNum << 2) + 35);

				switch (S7.GetByteAt(PDU, (blockNum << 2) + 34)) //BlockType
				{
					case Block_OB:
						List.OBCount = Count;
						break;
					case Block_DB:
						List.DBCount = Count;
						break;
					case Block_SDB:
						List.SDBCount = Count;
						break;
					case Block_FC:
						List.FCCount = Count;
						break;
					case Block_SFC:
						List.SFCCount = Count;
						break;
					case Block_FB:
						List.FBCount = Count;
						break;
					case Block_SFB:
						List.SFBCount = Count;
						break;
					default:
						//Unknown block type. Ignore
						break;
				}
			}

			Time_ms = Environment.TickCount - Elapsed;
			return _LastError; // 0
		}

		private string SiemensTimestamp(long EncodedDate)
		{
			DateTime DT = new DateTime(1984, 1, 1).AddSeconds(EncodedDate * 86400);
#if WINDOWS_UWP || NETFX_CORE || CORE_CLR
			return DT.ToString(System.Globalization.DateTimeFormatInfo.CurrentInfo.ShortDatePattern);
#else
			return DT.ToShortDateString();
			//  return DT.ToString();
#endif
		}

		public int GetAgBlockInfo(int BlockType, int BlockNum, ref S7BlockInfo Info)
		{
			_LastError = 0;
			Time_ms = 0;
			int Elapsed = Environment.TickCount;

			S7_BI[30] = (byte)BlockType;
			// Block Number
			S7_BI[31] = (byte)((BlockNum / 10000) + 0x30);
			BlockNum = BlockNum % 10000;
			S7_BI[32] = (byte)((BlockNum / 1000) + 0x30);
			BlockNum = BlockNum % 1000;
			S7_BI[33] = (byte)((BlockNum / 100) + 0x30);
			BlockNum = BlockNum % 100;
			S7_BI[34] = (byte)((BlockNum / 10) + 0x30);
			BlockNum = BlockNum % 10;
			S7_BI[35] = (byte)((BlockNum / 1) + 0x30);

			SendPacket(S7_BI);

			if (_LastError == 0)
			{
				int Length = RecvIsoPacket();
				if (Length > 32) // the minimum expected
				{
					ushort Result = S7.GetWordAt(PDU, 27);
					if (Result == 0)
					{
						Info.BlkFlags = PDU[42];
						Info.BlkLang = PDU[43];
						Info.BlkType = PDU[44];
						Info.BlkNumber = S7.GetWordAt(PDU, 45);
						Info.LoadSize = S7.GetDIntAt(PDU, 47);
						Info.CodeDate = SiemensTimestamp(S7.GetWordAt(PDU, 59));
						Info.IntfDate = SiemensTimestamp(S7.GetWordAt(PDU, 65));
						Info.SBBLength = S7.GetWordAt(PDU, 67);
						Info.LocalData = S7.GetWordAt(PDU, 71);
						Info.MC7Size = S7.GetWordAt(PDU, 73);
						Info.Author = S7.GetCharsAt(PDU, 75, 8).Trim(new char[] { (char)0 });
						Info.Family = S7.GetCharsAt(PDU, 83, 8).Trim(new char[] { (char)0 });
						Info.Header = S7.GetCharsAt(PDU, 91, 8).Trim(new char[] { (char)0 });
						Info.Version = PDU[99];
						Info.CheckSum = S7.GetWordAt(PDU, 101);
					}
					else
						_LastError = CpuError(Result);
				}
				else
					_LastError = S7Consts.errIsoInvalidPDU;
			}
			if (_LastError == 0)
				Time_ms = Environment.TickCount - Elapsed;

			return _LastError;

		}

		public int GetPgBlockInfo(ref S7BlockInfo Info, byte[] Buffer, int Size)
		{
			return S7Consts.errCliFunctionNotImplemented;
		}

		public int ListBlocksOfType(int BlockType, ushort[] List, ref int ItemsCount)
		{
			var First = true;
			bool Done = false;
			byte In_Seq = 0;
			int Count = 0; //Block 1...n
			int PduLength;
			int Elapsed = Environment.TickCount;

			//Consequent packets have a different ReqData
			byte[] ReqData = new byte[] { 0xff, 0x09, 0x00, 0x02, 0x30, (byte)BlockType };
			byte[] ReqDataContinue = new byte[] { 0x00, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00 };

			_LastError = 0;
			Time_ms = 0;

			do
			{
				PduLength = S7_LIST_BLOCKS_OF_TYPE.Length + ReqData.Length;
				ushort Sequence = GetNextWord();

				Array.Copy(S7_LIST_BLOCKS_OF_TYPE, 0, PDU, 0, S7_LIST_BLOCKS_OF_TYPE.Length);
				S7.SetWordAt(PDU, 0x02, (ushort)PduLength);
				PDU[0x0b] = (byte)(Sequence & 0xff);
				PDU[0x0c] = (byte)(Sequence >> 8);
				if (!First)
				{
					S7.SetWordAt(PDU, 0x0d, 12); //ParLen
					S7.SetWordAt(PDU, 0x0f, 4); //DataLen
					PDU[0x14] = 8; //PLen
					PDU[0x15] = 0x12; //Uk
				}
				PDU[0x17] = 0x02;
				PDU[0x18] = In_Seq;
				Array.Copy(ReqData, 0, PDU, 0x19, ReqData.Length);

				SendPacket(PDU, PduLength);
				if (_LastError != 0) return _LastError;

				PduLength = RecvIsoPacket();
				if (_LastError != 0) return _LastError;

				if (PduLength <= 32)// the minimum expected
				{
					_LastError = S7Consts.errIsoInvalidPDU;
					return _LastError;
				}

				ushort Result = S7.GetWordAt(PDU, 0x1b);
				if (Result != 0)
				{
					_LastError = CpuError(Result);
					return _LastError;
				}

				if (PDU[0x1d] != 0xFF)
				{
					_LastError = S7Consts.errCliItemNotAvailable;
					return _LastError;
				}

				Done = PDU[0x1a] == 0;
				In_Seq = PDU[0x18];

				int CThis = S7.GetWordAt(PDU, 0x1f) >> 2; //Amount of blocks in this message


				for (int c = 0; c < CThis; c++)
				{
					if (Count >= ItemsCount) //RoomError
					{
						_LastError = S7Consts.errCliPartialDataRead;
						return _LastError;
					}
					List[Count++] = S7.GetWordAt(PDU, 0x21 + 4 * c);
					Done |= Count == 0x8000; //but why?
				}

				if (First)
				{
					ReqData = ReqDataContinue;
					First = false;
				}
			} while (_LastError == 0 && !Done);

			if (_LastError == 0)
				ItemsCount = Count;

			Time_ms = Environment.TickCount - Elapsed;
			return _LastError; // 0
		}

		#endregion

		#region [Blocks functions]

		public int Upload(int BlockType, int BlockNum, byte[] UsrData, ref int Size)
		{
			return S7Consts.errCliFunctionNotImplemented;
		}

		public int FullUpload(int BlockType, int BlockNum, byte[] UsrData, ref int Size)
		{
			return S7Consts.errCliFunctionNotImplemented;
		}

		public int Download(int BlockNum, byte[] UsrData, int Size)
		{
			return S7Consts.errCliFunctionNotImplemented;
		}

		public int Delete(int BlockType, int BlockNum)
		{
			return S7Consts.errCliFunctionNotImplemented;
		}

		public int DBGet(int DBNumber, byte[] UsrData, ref int Size)
		{
			S7BlockInfo BI = new S7BlockInfo();
			int Elapsed = Environment.TickCount;
			Time_ms = 0;

			_LastError = GetAgBlockInfo(Block_DB, DBNumber, ref BI);

			if (_LastError == 0)
			{
				int DBSize = BI.MC7Size;
				if (DBSize <= UsrData.Length)
				{
					Size = DBSize;
					_LastError = DBRead(DBNumber, 0, DBSize, UsrData);
					if (_LastError == 0)
						Size = DBSize;
				}
				else
					_LastError = S7Consts.errCliBufferTooSmall;
			}
			if (_LastError == 0)
				Time_ms = Environment.TickCount - Elapsed;
			return _LastError;
		}

		public int DBFill(int DBNumber, int FillChar)
		{
			S7BlockInfo BI = new S7BlockInfo();
			int Elapsed = Environment.TickCount;
			Time_ms = 0;

			_LastError = GetAgBlockInfo(Block_DB, DBNumber, ref BI);

			if (_LastError == 0)
			{
				byte[] Buffer = new byte[BI.MC7Size];
				for (int c = 0; c < BI.MC7Size; c++)
					Buffer[c] = (byte)FillChar;
				_LastError = DBWrite(DBNumber, 0, BI.MC7Size, Buffer);
			}
			if (_LastError == 0)
				Time_ms = Environment.TickCount - Elapsed;
			return _LastError;
		}

		#endregion

		#region [Date/Time functions]

		public int GetPlcDateTime(ref DateTime DT)
		{
			int Length;
			_LastError = 0;
			Time_ms = 0;
			int Elapsed = Environment.TickCount;

			SendPacket(S7_GET_DT);
			if (_LastError == 0)
			{
				Length = RecvIsoPacket();
				if (Length > 30) // the minimum expected
				{
					if ((S7.GetWordAt(PDU, 27) == 0) && (PDU[29] == 0xFF))
					{
						DT = S7.GetDateTimeAt(PDU, 35);
					}
					else
						_LastError = S7Consts.errCliInvalidPlcAnswer;
				}
				else
					_LastError = S7Consts.errIsoInvalidPDU;
			}

			if (_LastError == 0)
				Time_ms = Environment.TickCount - Elapsed;

			return _LastError;
		}

		public int SetPlcDateTime(DateTime DT)
		{
			int Length;
			_LastError = 0;
			Time_ms = 0;
			int Elapsed = Environment.TickCount;

			S7.SetDateTimeAt(S7_SET_DT, 31, DT);
			SendPacket(S7_SET_DT);
			if (_LastError == 0)
			{
				Length = RecvIsoPacket();
				if (Length > 30) // the minimum expected
				{
					if (S7.GetWordAt(PDU, 27) != 0)
						_LastError = S7Consts.errCliInvalidPlcAnswer;
				}
				else
					_LastError = S7Consts.errIsoInvalidPDU;
			}
			if (_LastError == 0)
				Time_ms = Environment.TickCount - Elapsed;

			return _LastError;
		}

		public int SetPlcSystemDateTime()
		{
			return SetPlcDateTime(DateTime.Now);
		}

		#endregion

		#region [System Info functions]

		public int GetOrderCode(ref S7OrderCode Info)
		{
			S7SZL SZL = new S7SZL();
			int Size = 1024;
			SZL.Data = new byte[Size];
			int Elapsed = Environment.TickCount;
			_LastError = ReadSZL(0x0011, 0x000, ref SZL, ref Size);
			if (_LastError == 0)
			{
				Info.Code = S7.GetCharsAt(SZL.Data, 2, 20);
				Info.V1 = SZL.Data[Size - 3];
				Info.V2 = SZL.Data[Size - 2];
				Info.V3 = SZL.Data[Size - 1];
			}
			if (_LastError == 0)
				Time_ms = Environment.TickCount - Elapsed;
			return _LastError;
		}

		public int GetCpuInfo(ref S7CpuInfo Info)
		{
			S7SZL SZL = new S7SZL();
			int Size = 1024;
			SZL.Data = new byte[Size];
			int Elapsed = Environment.TickCount;
			_LastError = ReadSZL(0x001C, 0x000, ref SZL, ref Size);
			if (_LastError == 0)
			{
				Info.ModuleTypeName = S7.GetCharsAt(SZL.Data, 172, 32);
				Info.SerialNumber = S7.GetCharsAt(SZL.Data, 138, 24);
				Info.ASName = S7.GetCharsAt(SZL.Data, 2, 24);
				Info.Copyright = S7.GetCharsAt(SZL.Data, 104, 26);
				Info.ModuleName = S7.GetCharsAt(SZL.Data, 36, 24);
			}
			if (_LastError == 0)
				Time_ms = Environment.TickCount - Elapsed;
			return _LastError;
		}

		public int GetCpInfo(ref S7CpInfo Info)
		{
			S7SZL SZL = new S7SZL();
			int Size = 1024;
			SZL.Data = new byte[Size];
			int Elapsed = Environment.TickCount;
			_LastError = ReadSZL(0x0131, 0x001, ref SZL, ref Size);
			if (_LastError == 0)
			{
				Info.MaxPduLength = S7.GetIntAt(PDU, 2);
				Info.MaxConnections = S7.GetIntAt(PDU, 4);
				Info.MaxMpiRate = S7.GetDIntAt(PDU, 6);
				Info.MaxBusRate = S7.GetDIntAt(PDU, 10);
			}
			if (_LastError == 0)
				Time_ms = Environment.TickCount - Elapsed;
			return _LastError;
		}

		public int ReadSZL(int ID, int Index, ref S7SZL SZL, ref int Size)
		{
			int Length;
			int DataSZL;
			int Offset = 0;
			bool Done = false;
			bool First = true;
			byte Seq_in = 0x00;
			ushort Seq_out = 0x0000;

			_LastError = 0;
			Time_ms = 0;
			int Elapsed = Environment.TickCount;
			SZL.Header.LENTHDR = 0;

			do
			{
				if (First)
				{
					S7.SetWordAt(S7_SZL_FIRST, 11, ++Seq_out);
					S7.SetWordAt(S7_SZL_FIRST, 29, (ushort)ID);
					S7.SetWordAt(S7_SZL_FIRST, 31, (ushort)Index);
					SendPacket(S7_SZL_FIRST);
				}
				else
				{
					S7.SetWordAt(S7_SZL_NEXT, 11, ++Seq_out);
					PDU[24] = (byte)Seq_in;
					SendPacket(S7_SZL_NEXT);
				}
				if (_LastError != 0)
					return _LastError;

				Length = RecvIsoPacket();
				if (_LastError == 0)
				{
					if (First)
					{
						if (Length > 32) // the minimum expected
						{
							if ((S7.GetWordAt(PDU, 27) == 0) && (PDU[29] == (byte)0xFF))
							{
								// Gets Amount of this slice
								DataSZL = S7.GetWordAt(PDU, 31) - 8; // Skips extra params (ID, Index ...)
								Done = PDU[26] == 0x00;
								Seq_in = (byte)PDU[24]; // Slice sequence
								SZL.Header.LENTHDR = S7.GetWordAt(PDU, 37);
								SZL.Header.N_DR = S7.GetWordAt(PDU, 39);
								Array.Copy(PDU, 41, SZL.Data, Offset, DataSZL);
								//                                SZL.Copy(PDU, 41, Offset, DataSZL);
								Offset += DataSZL;
								SZL.Header.LENTHDR += SZL.Header.LENTHDR;
							}
							else
								_LastError = S7Consts.errCliInvalidPlcAnswer;
						}
						else
							_LastError = S7Consts.errIsoInvalidPDU;
					}
					else
					{
						if (Length > 32) // the minimum expected
						{
							if ((S7.GetWordAt(PDU, 27) == 0) && (PDU[29] == (byte)0xFF))
							{
								// Gets Amount of this slice
								DataSZL = S7.GetWordAt(PDU, 31);
								Done = PDU[26] == 0x00;
								Seq_in = (byte)PDU[24]; // Slice sequence
								Array.Copy(PDU, 37, SZL.Data, Offset, DataSZL);
								Offset += DataSZL;
								SZL.Header.LENTHDR += SZL.Header.LENTHDR;
							}
							else
								_LastError = S7Consts.errCliInvalidPlcAnswer;
						}
						else
							_LastError = S7Consts.errIsoInvalidPDU;
					}
				}
				First = false;
			}
			while (!Done && (_LastError == 0));
			if (_LastError == 0)
			{
				Size = SZL.Header.LENTHDR;
				Time_ms = Environment.TickCount - Elapsed;
			}
			return _LastError;
		}

		public int ReadSZLList(ref S7SZLList List, ref Int32 ItemsCount)
		{
			return S7Consts.errCliFunctionNotImplemented;
		}

		#endregion

		#region [Control functions]

		public int PlcHotStart()
		{
			_LastError = 0;
			int Elapsed = Environment.TickCount;

			SendPacket(S7_HOT_START);
			if (_LastError == 0)
			{
				int Length = RecvIsoPacket();
				if (Length > 18) // 18 is the minimum expected
				{
					if (PDU[19] != pduStart)
						_LastError = S7Consts.errCliCannotStartPLC;
					else
					{
						if (PDU[20] == pduAlreadyStarted)
							_LastError = S7Consts.errCliAlreadyRun;
						else
							_LastError = S7Consts.errCliCannotStartPLC;
					}
				}
				else
					_LastError = S7Consts.errIsoInvalidPDU;
			}
			if (_LastError == 0)
				Time_ms = Environment.TickCount - Elapsed;
			return _LastError;
		}

		public int PlcColdStart()
		{
			_LastError = 0;
			int Elapsed = Environment.TickCount;

			SendPacket(S7_COLD_START);
			if (_LastError == 0)
			{
				int Length = RecvIsoPacket();
				if (Length > 18) // 18 is the minimum expected
				{
					if (PDU[19] != pduStart)
						_LastError = S7Consts.errCliCannotStartPLC;
					else
					{
						if (PDU[20] == pduAlreadyStarted)
							_LastError = S7Consts.errCliAlreadyRun;
						else
							_LastError = S7Consts.errCliCannotStartPLC;
					}
				}
				else
					_LastError = S7Consts.errIsoInvalidPDU;
			}
			if (_LastError == 0)
				Time_ms = Environment.TickCount - Elapsed;
			return _LastError;
		}

		public int PlcStop()
		{
			_LastError = 0;
			int Elapsed = Environment.TickCount;

			SendPacket(S7_STOP);
			if (_LastError == 0)
			{
				int Length = RecvIsoPacket();
				if (Length > 18) // 18 is the minimum expected
				{
					if (PDU[19] != pduStop)
						_LastError = S7Consts.errCliCannotStopPLC;
					else
					{
						if (PDU[20] == pduAlreadyStopped)
							_LastError = S7Consts.errCliAlreadyStop;
						else
							_LastError = S7Consts.errCliCannotStopPLC;
					}
				}
				else
					_LastError = S7Consts.errIsoInvalidPDU;
			}
			if (_LastError == 0)
				Time_ms = Environment.TickCount - Elapsed;
			return _LastError;
		}

		public int PlcCopyRamToRom(UInt32 Timeout)
		{
			return S7Consts.errCliFunctionNotImplemented;
		}

		public int PlcCompress(UInt32 Timeout)
		{
			return S7Consts.errCliFunctionNotImplemented;
		}

		public int PlcGetStatus(ref Int32 Status)
		{
			_LastError = 0;
			int Elapsed = Environment.TickCount;

			SendPacket(S7_GET_STAT);
			if (_LastError == 0)
			{
				int Length = RecvIsoPacket();
				if (Length > 30) // the minimum expected
				{
					ushort Result = S7.GetWordAt(PDU, 27);
					if (Result == 0)
					{
						switch (PDU[44])
						{
							case S7Consts.S7CpuStatusUnknown:
							case S7Consts.S7CpuStatusRun:
							case S7Consts.S7CpuStatusStop:
								{
									Status = PDU[44];
									break;
								}
							default:
								{
									// Since RUN status is always 0x08 for all CPUs and CPs, STOP status
									// sometime can be coded as 0x03 (especially for old cpu...)
									Status = S7Consts.S7CpuStatusStop;
									break;
								}
						}
					}
					else
						_LastError = CpuError(Result);
				}
				else
					_LastError = S7Consts.errIsoInvalidPDU;
			}
			if (_LastError == 0)
				Time_ms = Environment.TickCount - Elapsed;
			return _LastError;
		}

		#endregion

		#region [Security functions]
		public int SetSessionPassword(string Password)
		{
			byte[] pwd = { 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20 };
			int Length;
			_LastError = 0;
			int Elapsed = Environment.TickCount;
			// Encodes the Password
			S7.SetCharsAt(pwd, 0, Password);
			pwd[0] = (byte)(pwd[0] ^ 0x55);
			pwd[1] = (byte)(pwd[1] ^ 0x55);
			for (int c = 2; c < 8; c++)
			{
				pwd[c] = (byte)(pwd[c] ^ 0x55 ^ pwd[c - 2]);
			}
			Array.Copy(pwd, 0, S7_SET_PWD, 29, 8);
			// Sends the telegrem
			SendPacket(S7_SET_PWD);
			if (_LastError == 0)
			{
				Length = RecvIsoPacket();
				if (Length > 32) // the minimum expected
				{
					ushort Result = S7.GetWordAt(PDU, 27);
					if (Result != 0)
						_LastError = CpuError(Result);
				}
				else
					_LastError = S7Consts.errIsoInvalidPDU;
			}
			if (_LastError == 0)
				Time_ms = Environment.TickCount - Elapsed;
			return _LastError;
		}

		public int ClearSessionPassword()
		{
			int Length;
			_LastError = 0;
			int Elapsed = Environment.TickCount;
			SendPacket(S7_CLR_PWD);
			if (_LastError == 0)
			{
				Length = RecvIsoPacket();
				if (Length > 30) // the minimum expected
				{
					ushort Result = S7.GetWordAt(PDU, 27);
					if (Result != 0)
						_LastError = CpuError(Result);
				}
				else
					_LastError = S7Consts.errIsoInvalidPDU;
			}
			return _LastError;
		}

		public int GetProtection(ref S7Protection Protection)
		{
			S7Client.S7SZL SZL = new S7Client.S7SZL();
			int Size = 256;
			SZL.Data = new byte[Size];
			_LastError = ReadSZL(0x0232, 0x0004, ref SZL, ref Size);
			if (_LastError == 0)
			{
				Protection.sch_schal = S7.GetWordAt(SZL.Data, 2);
				Protection.sch_par = S7.GetWordAt(SZL.Data, 4);
				Protection.sch_rel = S7.GetWordAt(SZL.Data, 6);
				Protection.bart_sch = S7.GetWordAt(SZL.Data, 8);
				Protection.anl_sch = S7.GetWordAt(SZL.Data, 10);
			}
			return _LastError;
		}
		#endregion

		#region [Low Level]

		public int IsoExchangeBuffer(byte[] Buffer, ref Int32 Size)
		{
			_LastError = 0;
			Time_ms = 0;
			int Elapsed = Environment.TickCount;
			Array.Copy(TPKT_ISO, 0, PDU, 0, TPKT_ISO.Length);
			S7.SetWordAt(PDU, 2, (ushort)(Size + TPKT_ISO.Length));
			try
			{
				Array.Copy(Buffer, 0, PDU, TPKT_ISO.Length, Size);
			}
			catch
			{
				return S7Consts.errIsoInvalidPDU;
			}
			SendPacket(PDU, TPKT_ISO.Length + Size);
			if (_LastError == 0)
			{
				int Length = RecvIsoPacket();
				if (_LastError == 0)
				{
					Array.Copy(PDU, TPKT_ISO.Length, Buffer, 0, Length - TPKT_ISO.Length);
					Size = Length - TPKT_ISO.Length;
				}
			}
			if (_LastError == 0)
				Time_ms = Environment.TickCount - Elapsed;
			else
				Size = 0;
			return _LastError;
		}

		#endregion

		#region [Async functions (not implemented)]

		public int AsReadArea(int Area, int DBNumber, int Start, int Amount, int WordLen, byte[] Buffer)
		{
			return S7Consts.errCliFunctionNotImplemented;
		}

		public int AsWriteArea(int Area, int DBNumber, int Start, int Amount, int WordLen, byte[] Buffer)
		{
			return S7Consts.errCliFunctionNotImplemented;
		}

		public int AsDBRead(int DBNumber, int Start, int Size, byte[] Buffer)
		{
			return S7Consts.errCliFunctionNotImplemented;
		}

		public int AsDBWrite(int DBNumber, int Start, int Size, byte[] Buffer)
		{
			return S7Consts.errCliFunctionNotImplemented;
		}

		public int AsMBRead(int Start, int Size, byte[] Buffer)
		{
			return S7Consts.errCliFunctionNotImplemented;
		}

		public int AsMBWrite(int Start, int Size, byte[] Buffer)
		{
			return S7Consts.errCliFunctionNotImplemented;
		}

		public int AsEBRead(int Start, int Size, byte[] Buffer)
		{
			return S7Consts.errCliFunctionNotImplemented;
		}

		public int AsEBWrite(int Start, int Size, byte[] Buffer)
		{
			return S7Consts.errCliFunctionNotImplemented;
		}

		public int AsABRead(int Start, int Size, byte[] Buffer)
		{
			return S7Consts.errCliFunctionNotImplemented;
		}

		public int AsABWrite(int Start, int Size, byte[] Buffer)
		{
			return S7Consts.errCliFunctionNotImplemented;
		}

		public int AsTMRead(int Start, int Amount, ushort[] Buffer)
		{
			return S7Consts.errCliFunctionNotImplemented;
		}

		public int AsTMWrite(int Start, int Amount, ushort[] Buffer)
		{
			return S7Consts.errCliFunctionNotImplemented;
		}

		public int AsCTRead(int Start, int Amount, ushort[] Buffer)
		{
			return S7Consts.errCliFunctionNotImplemented;
		}

		public int AsCTWrite(int Start, int Amount, ushort[] Buffer)
		{
			return S7Consts.errCliFunctionNotImplemented;
		}

		public int AsListBlocksOfType(int BlockType, ushort[] List)
		{
			return S7Consts.errCliFunctionNotImplemented;
		}

		public int AsReadSZL(int ID, int Index, ref S7SZL Data, ref Int32 Size)
		{
			return S7Consts.errCliFunctionNotImplemented;
		}

		public int AsReadSZLList(ref S7SZLList List, ref Int32 ItemsCount)
		{
			return S7Consts.errCliFunctionNotImplemented;
		}

		public int AsUpload(int BlockType, int BlockNum, byte[] UsrData, ref int Size)
		{
			return S7Consts.errCliFunctionNotImplemented;
		}

		public int AsFullUpload(int BlockType, int BlockNum, byte[] UsrData, ref int Size)
		{
			return S7Consts.errCliFunctionNotImplemented;
		}

		public int ASDownload(int BlockNum, byte[] UsrData, int Size)
		{
			return S7Consts.errCliFunctionNotImplemented;
		}

		public int AsPlcCopyRamToRom(UInt32 Timeout)
		{
			return S7Consts.errCliFunctionNotImplemented;
		}

		public int AsPlcCompress(UInt32 Timeout)
		{
			return S7Consts.errCliFunctionNotImplemented;
		}

		public int AsDBGet(int DBNumber, byte[] UsrData, ref int Size)
		{
			return S7Consts.errCliFunctionNotImplemented;
		}

		public int AsDBFill(int DBNumber, int FillChar)
		{
			return S7Consts.errCliFunctionNotImplemented;
		}

		public bool CheckAsCompletion(ref int opResult)
		{
			opResult = 0;
			return false;
		}

		public int WaitAsCompletion(int Timeout)
		{
			return S7Consts.errCliFunctionNotImplemented;
		}

		#endregion

		#region [Info Functions / Properties]

		public string ErrorText(int Error)
		{
			switch (Error)
			{
				case 0: return "OK";
				case S7Consts.errTCPSocketCreation: return "SYS : Error creating the Socket";
				case S7Consts.errTCPConnectionTimeout: return "TCP : Connection Timeout";
				case S7Consts.errTCPConnectionFailed: return "TCP : Connection Error";
				case S7Consts.errTCPReceiveTimeout: return "TCP : Data receive Timeout";
				case S7Consts.errTCPDataReceive: return "TCP : Error receiving Data";
				case S7Consts.errTCPSendTimeout: return "TCP : Data send Timeout";
				case S7Consts.errTCPDataSend: return "TCP : Error sending Data";
				case S7Consts.errTCPConnectionReset: return "TCP : Connection reset by the Peer";
				case S7Consts.errTCPNotConnected: return "CLI : Client not connected";
				case S7Consts.errTCPUnreachableHost: return "TCP : Unreachable host";
				case S7Consts.errIsoConnect: return "ISO : Connection Error";
				case S7Consts.errIsoInvalidPDU: return "ISO : Invalid PDU received";
				case S7Consts.errIsoInvalidDataSize: return "ISO : Invalid Buffer passed to Send/Receive";
				case S7Consts.errCliNegotiatingPDU: return "CLI : Error in PDU negotiation";
				case S7Consts.errCliInvalidParams: return "CLI : invalid param(s) supplied";
				case S7Consts.errCliJobPending: return "CLI : Job pending";
				case S7Consts.errCliTooManyItems: return "CLI : too may items (>20) in multi read/write";
				case S7Consts.errCliInvalidWordLen: return "CLI : invalid WordLength";
				case S7Consts.errCliPartialDataWritten: return "CLI : Partial data written";
				case S7Consts.errCliSizeOverPDU: return "CPU : total data exceeds the PDU size";
				case S7Consts.errCliInvalidPlcAnswer: return "CLI : invalid CPU answer";
				case S7Consts.errCliAddressOutOfRange: return "CPU : Address out of range";
				case S7Consts.errCliInvalidTransportSize: return "CPU : Invalid Transport size";
				case S7Consts.errCliWriteDataSizeMismatch: return "CPU : Data size mismatch";
				case S7Consts.errCliItemNotAvailable: return "CPU : Item not available";
				case S7Consts.errCliInvalidValue: return "CPU : Invalid value supplied";
				case S7Consts.errCliCannotStartPLC: return "CPU : Cannot start PLC";
				case S7Consts.errCliAlreadyRun: return "CPU : PLC already RUN";
				case S7Consts.errCliCannotStopPLC: return "CPU : Cannot stop PLC";
				case S7Consts.errCliCannotCopyRamToRom: return "CPU : Cannot copy RAM to ROM";
				case S7Consts.errCliCannotCompress: return "CPU : Cannot compress";
				case S7Consts.errCliAlreadyStop: return "CPU : PLC already STOP";
				case S7Consts.errCliFunNotAvailable: return "CPU : Function not available";
				case S7Consts.errCliUploadSequenceFailed: return "CPU : Upload sequence failed";
				case S7Consts.errCliInvalidDataSizeRecvd: return "CLI : Invalid data size received";
				case S7Consts.errCliInvalidBlockType: return "CLI : Invalid block type";
				case S7Consts.errCliInvalidBlockNumber: return "CLI : Invalid block number";
				case S7Consts.errCliInvalidBlockSize: return "CLI : Invalid block size";
				case S7Consts.errCliNeedPassword: return "CPU : Function not authorized for current protection level";
				case S7Consts.errCliInvalidPassword: return "CPU : Invalid password";
				case S7Consts.errCliNoPasswordToSetOrClear: return "CPU : No password to set or clear";
				case S7Consts.errCliJobTimeout: return "CLI : Job Timeout";
				case S7Consts.errCliFunctionRefused: return "CLI : function refused by CPU (Unknown error)";
				case S7Consts.errCliPartialDataRead: return "CLI : Partial data read";
				case S7Consts.errCliBufferTooSmall: return "CLI : The buffer supplied is too small to accomplish the operation";
				case S7Consts.errCliDestroying: return "CLI : Cannot perform (destroying)";
				case S7Consts.errCliInvalidParamNumber: return "CLI : Invalid Param Number";
				case S7Consts.errCliCannotChangeParam: return "CLI : Cannot change this param now";
				case S7Consts.errCliFunctionNotImplemented: return "CLI : Function not implemented";
				default: return "CLI : Unknown error (0x" + Convert.ToString(Error, 16) + ")";
			};
		}

		public int LastError()
		{
			return _LastError;
		}

		public int RequestedPduLength()
		{
			return _PduSizeRequested;
		}

		public int NegotiatedPduLength()
		{
			return _PDULength;
		}

		public int ExecTime()
		{
			return Time_ms;
		}

		public int ExecutionTime
		{
			get
			{
				return Time_ms;
			}
		}

		public int PduSizeNegotiated
		{
			get
			{
				return _PDULength;
			}
		}

		public int PduSizeRequested
		{
			get
			{
				return _PduSizeRequested;
			}
			set
			{
				if (value < MinPduSizeToRequest)
					value = MinPduSizeToRequest;
				if (value > MaxPduSizeToRequest)
					value = MaxPduSizeToRequest;
				_PduSizeRequested = value;
			}
		}

		public int PLCPort
		{
			get
			{
				return _PLCPort;
			}
			set
			{
				_PLCPort = value;
			}
		}

		public int ConnTimeout
		{
			get
			{
				return _ConnTimeout;
			}
			set
			{
				_ConnTimeout = value;
			}
		}

		public int RecvTimeout
		{
			get
			{
				return _RecvTimeout;
			}
			set
			{
				_RecvTimeout = value;
			}
		}

		public int SendTimeout
		{
			get
			{
				return _SendTimeout;
			}
			set
			{
				_SendTimeout = value;
			}
		}

		public bool Connected
		{
			get
			{
				return (Socket != null) && (Socket.Connected);
			}
		}
		#endregion

		#region forcejob

		public class S7Forces
		{
			public List<ForceJob> Forces;
		}


		internal int GetActiveForces(List<ForceJob> forces, byte[] forceframe)
		{


			// sending second package only if there are force jobs active 
			SendPacket(forceframe);
			var length = RecvIsoPacket();

			switch (WordFromByteArr(PDU, 27))
			{
				default:
					_LastError = S7Consts.errTCPDataReceive;
					break;
				case 0x000:

					// creating byte [] with length of useful data (first 67 bytes aren't useful data )
					byte[] forceData = new byte[length - 67];
					// copy pdu to other byte[] and remove the unused data 
					Array.Copy(PDU, 67, forceData, 0, length - 67);
					// check array transition definition > value's 
					byte[] splitDefData = new byte[] { 0x00, 0x09, 0x00 };
					int Splitposition = 0;
					for (int x = 0; x < forceData.Length - 3; x = x + 6)
					{
						// checking when the definitions go to data (the data starts with split definition data and the amount of bytes before should always be a plural of 6)
						if (forceData[x] == splitDefData[0] && forceData[x + 1] == splitDefData[1] && forceData[x + 2] == splitDefData[2] && x % 6 == 0)
						{
							Splitposition = x;
							break;
						}

					}
					// calculating amount of forces 
					int amountForces = Splitposition / 6;
					// setting first byte from data
					int dataposition = Splitposition;
					for (int x = 0; x < amountForces; x++)
					{
						ForceJob force = new ForceJob
						{
							// bit value
							BitAdress = (forceData[(1 + (6 * x))]),

							// byte value

							ByteAdress = ((forceData[(4 + (6 * x))]) * 256) + (forceData[(5 + (6 * x))])
						};
						// foce identity
						switch (forceData[0 + (6 * x)])
						{

							case 0x0:
								force.ForceType = "M";
								break;

							case 0x1:
								force.ForceType = "MB";
								force.BitAdress = null;
								break;
							case 0x2:
								force.ForceType = "MW";
								force.BitAdress = null;
								break;
							case 0x3:
								force.ForceType = "MD";
								force.BitAdress = null;
								break;

							case 0x10:
								force.ForceType = "I";
								break;

							case 0x11:
								force.ForceType = "IB";
								force.BitAdress = null;
								break;

							case 0x12:
								force.ForceType = "IW";
								force.BitAdress = null;
								break;

							case 0x13:
								force.ForceType = "ID";
								force.BitAdress = null;
								break;


							case 0x20:
								force.ForceType = "Q";
								break;

							case 0x21:
								force.ForceType = "QB";
								force.BitAdress = null;
								break;

							case 0x22:
								force.ForceType = "QW";
								force.BitAdress = null;
								break;

							case 0x23:
								force.ForceType = "QD";
								force.BitAdress = null;
								break;

							// if you get this code You can add it in the list above.
							default:
								force.ForceType = forceData[0 + (6 * x)].ToString() + " unknown";
								break;
						}

						// setting force value depending on the data length
						switch (forceData[dataposition + 3])// Data length from force
						{

							case 0x01:
								force.ForceValue = forceData[dataposition + 4];
								break;

							case 0x02:
								force.ForceValue = WordFromByteArr(forceData, dataposition + 4);
								break;

							case 0x04:
								force.ForceValue = DoubleFromByteArr(forceData, dataposition + 4);
								break;

							default:
								break;


						}

						// calculating when the next force start 

						var nextForce = 0x04 + (forceData[dataposition + 3]);
						if (nextForce < 6)
						{
							nextForce = 6;
						}
						dataposition += nextForce;
						// adding force to list 
						forces.Add(force);
					}
					break;
			}
			return _LastError;
		}

		public int GetForceValues300(ref S7Forces forces)
		{
			_LastError = 00;
			int Elapsed = Environment.TickCount;
			List<ForceJob> forcedValues = new List<ForceJob>();
			SendPacket(S7_FORCE_VAL1);
			var Length = RecvIsoPacket();

			// when response is 45 there are no force jobs active or no correct response from plc

			switch (WordFromByteArr(PDU, 27))
			{
				case 0x0000:// no error code

					if (WordFromByteArr(PDU, 31) >= 16)
					{
						_LastError = GetActiveForces(forcedValues, S7_FORCE_VAL300);
					}
					break;

				default:
					_LastError = S7Consts.errTCPDataReceive;
					break;
			}

			forces.Forces = forcedValues;

			Time_ms = Environment.TickCount - Elapsed;
			return _LastError;
		}

		public int GetForceValues400(ref S7Forces forces)
		{
			_LastError = 00;
			int Elapsed = Environment.TickCount;
			List<ForceJob> forcedValues = new List<ForceJob>();
			SendPacket(S7_FORCE_VAL1);
			var Length = RecvIsoPacket();

			// when response is 45 there are no force jobs active or no correct response from PLC

			switch (WordFromByteArr(PDU, 27))
			{
				case 0x0000:

					if (WordFromByteArr(PDU, 31) >= 12)
					{
						_LastError = GetActiveForces(forcedValues, S7_FORCE_VAL400);
					}
					break;

				default:
					_LastError = S7Consts.errTCPDataReceive;
					break;
			}

			forces.Forces = forcedValues;
			Time_ms = Environment.TickCount - Elapsed;
			return _LastError;
		}

		public int WordFromByteArr(byte[] data, int position)
		{
			int result = Convert.ToInt32((data[position] << 8) + data[position + 1]);
			return result;
		}

		public int DoubleFromByteArr(byte[] data, int position)
		{
			int result = Convert.ToInt32((data[position] << 24) + (data[position + 1] << 16) + (data[position + 2] << 8) + (data[position + 3]));
			return result;
		}


		// S7 Get Force Values frame 1
		byte[] S7_FORCE_VAL1 = {
			0x03, 0x00, 0x00, 0x3d,
			0x02, 0xf0 ,0x80, 0x32,
			0x07, 0x00, 0x00, 0x07,
			0x00, 0x00, 0x0c, 0x00,
			0x20, 0x00, 0x01, 0x12,
			0x08, 0x12, 0x41, 0x10,
			0x00, 0x00, 0x00, 0x00,
			0x00, 0xff, 0x09, 0x00,
			0x1c, 0x00, 0x14, 0x00,
			0x04, 0x00, 0x00, 0x00,
			0x00, 0x00, 0x01, 0x00,
			0x00, 0x00, 0x01, 0x00,
			0x01, 0x00, 0x01, 0x00,
			0x01, 0x00, 0x01, 0x00,
			0x00, 0x00, 0x00, 0x00,
			0x00

		};

		// S7 Get Force Values frame 2 (300 series )
		byte[] S7_FORCE_VAL300 = {
			0x03, 0x00, 0x00, 0x3b,
			0x02, 0xf0, 0x80, 0x32,
			0x07, 0x00, 0x00, 0x0c,
			0x00, 0x00, 0x0c, 0x00,
			0x1e, 0x00, 0x01, 0x12,
			0x08, 0x12, 0x41, 0x11,
			0x00, 0x00, 0x00, 0x00,
			0x00, 0xff, 0x09, 0x00,
			0x1a, 0x00, 0x14, 0x00,
			0x02, 0x00, 0x00, 0x00,
			0x00, 0x00, 0x01, 0x00,
			0x00, 0x00, 0x01, 0x00,
			0x01, 0x00, 0x01, 0x00,
			0x01, 0x00, 0x01, 0x00,
			0x00, 0x09, 0x03

		};

		// S7 Get Force Values frame 2 (400 series )
		byte[] S7_FORCE_VAL400 = {
			0x03, 0x00, 0x00, 0x3b,
			0x02, 0xf0, 0x80, 0x32,
			0x07, 0x00, 0x00, 0x0c,
			0x00, 0x00, 0x0c, 0x00,
			0x1e, 0x00, 0x01, 0x12,
			0x08, 0x12, 0x41, 0x11,
			0x00, 0x00, 0x00, 0x00,
			0x00, 0xff, 0x09, 0x00,
			0x1a, 0x00, 0x14, 0x00,
			0x02, 0x00, 0x00, 0x00,
			0x00, 0x00, 0x01, 0x00,
			0x00, 0x00, 0x01, 0x00,
			0x01, 0x00, 0x01, 0x00,
			0x01, 0x00, 0x01, 0x00,
			0x00, 0x09, 0x05
		};

		public class ForceJob
		{
			public string FullAdress
			{
				get
				{
					if (BitAdress == null)
					{
						return $"{ForceType} {ByteAdress}";
					}
					else
					{
						return $"{ForceType} {ByteAdress}.{BitAdress}";
					}
				}
			}
			public int ForceValue { get; set; }
			public string ForceType { get; set; }
			public int ByteAdress { get; set; }
			public int? BitAdress { get; set; }
			public string Symbol { get; set; }
			public string Comment { get; set; }

		}
		#endregion

		#region CommentedForce
		public class CommentForces
		{
			// Only symbol table's with.seq extension
			public List<ForceJob> AddForceComments(string filepath, List<ForceJob> actualForces)
			{
				if (Path.GetExtension(filepath).ToLower() == ".seq")
				{
					var SymbolTableDataText = ReadSymbolTable(filepath);
					if (SymbolTableDataText.Length >= 1)
					{
						var SymbolTableDataList = ConvertDataArrToList(SymbolTableDataText);
						var CommentedForceList = AddCommentToForce(actualForces, SymbolTableDataList);
						return CommentedForceList;
					}
				}
				return ErrorSymbTableProces(actualForces);
			}

			private List<ForceJob> AddCommentToForce(List<ForceJob> forceringen, List<SymbolTableRecord> symbolTable)
			{
				List<ForceJob> commentedforces = new List<ForceJob>();

				foreach (ForceJob force in forceringen)
				{

					var found = symbolTable.Where(s => s.Address == force.FullAdress).FirstOrDefault();
					ForceJob commentedforce = new ForceJob();
					commentedforce = force;


					if (found != null)
					{
						commentedforce.Symbol = found.Symbol;
						commentedforce.Comment = found.Comment;
					}
					else
					{
						commentedforce.Symbol = "NOT SET";
						commentedforce.Comment = "not in variable table";
					}
					commentedforces.Add(commentedforce);

				}

				return commentedforces;

			}

			private List<SymbolTableRecord> ConvertDataArrToList(string[] text)
			{
				List<SymbolTableRecord> Symbollist = new List<SymbolTableRecord>();

				foreach (var line in text)
				{
					SymbolTableRecord temp = new SymbolTableRecord();
					string[] splited = new string[10];
					splited = line.Split('\t');
					temp.Address = splited[1];
					temp.Symbol = splited[2];
					temp.Comment = splited[3];

					Symbollist.Add(temp);
				}
				return Symbollist;
			}

			private string[] ReadSymbolTable(string Filepath)
			{

				string[] lines = System.IO.File.ReadAllLines(Filepath);
				return lines;
			}



			private List<ForceJob> ErrorSymbTableProces(List<ForceJob> actualForces)
			{
				var errorForceTable = actualForces;
				foreach (var forcerecord in errorForceTable)
				{
					forcerecord.Comment = "Force Table could not be processed";
					forcerecord.Symbol = "ERROR";

				}
				return errorForceTable;
			}
		}


		public class SymbolTableRecord
		{
			public string Symbol { get; set; }
			public string Address { get; set; }
			public string Comment { get; set; }
		}


        #endregion

        #region Sinumerik Client Functions

        #region S7DriveES Client Functions
        // The following functions were only tested with Sinumerik 840D Solution Line (no Power Line support)
        // Connection to Sinumerik-Drive Main CU: use slot number 9
        // Connection to Sinumerik-Drive NX-Extensions: slot number usually starts with 13 (check via starter for individual configuration)
        #region [S7 DriveES Telegrams]
        // S7 DriveES Read/Write Request Header (contains also ISO Header and COTP Header)
        byte[] S7_DrvRW = { // 31-35 bytes
        0x03,0x00,
		0x00,0x1f,       // Telegram Length (Data Size + 31 or 35)
        0x02,0xf0, 0x80, // COTP (see above for info)
        0x32,            // S7 Protocol ID 
        0x01,            // Job Type
        0x00,0x00,       // Redundancy identification
        0x05,0x00,       // PDU Reference
        0x00,0x0e,       // Parameters Length
        0x00,0x00,       // Data Length = Size(bytes) + 4      
        0x04,            // Function 4 Read Var, 5 Write Var  
        0x01,            // Items count
        0x12,            // Var spec.
        0x0a,            // Length of remaining bytes
        0xa2,            // Syntax ID 
        0x00,            // Empty --> Parameter Type                       
        0x00,0x00,       // Empty --> Number of Rows                          
        0x00,0x00,       // Empty --> Number of DriveObject          
        0x00,0x00,       // Empty --> Parameter Number                           
        0x00,0x00,       // Empty --> Parameter Index                     
        // WR area
        0x00,            // Reserved 
        0x04,            // Transport size
        0x00,0x00,       // Data Length * 8 (if not bit or timer or counter) 
    };

		// S7 Drv Variable MultiRead Header
		byte[] S7Drv_MRD_HEADER = {
		0x03,0x00,
		0x00,0x1f,       // Telegram Length (Data Size + 31 or 35)
        0x02,0xf0, 0x80, // COTP (see above for info)
        0x32,            // S7 Protocol ID 
        0x01,            // Job Type
        0x00,0x00,       // Redundancy identification
        0x05,0x00,       // PDU Reference
        0x00,0x0e,       // Parameters Length
        0x00,0x00,       // Data Length = Size(bytes) + 4      
        0x04,            // Function 4 Read Var, 5 Write Var  
        0x01,            // Items count
    };

		// S7 Drv Variable MultiRead Item
		byte[] S7Drv_MRD_ITEM =
			{
		0x12,            // Var spec.
        0x0a,            // Length of remaining bytes
        0xa2,            // Syntax ID 
        0x00,            // Empty --> Parameter Type                       
        0x00,0x00,       // Empty --> Number of Rows                          
        0x00,0x00,       // Empty --> Number of DriveObject          
        0x00,0x00,       // Empty --> Parameter Number                           
        0x00,0x00,       // Empty --> Parameter Index                    
    };

		// S7 Drv Variable MultiWrite Header
		byte[] S7Drv_MWR_HEADER = {
		0x03,0x00,
		0x00,0x1f,       // Telegram Length (Data Size + 31 or 35)
        0x02,0xf0, 0x80, // COTP (see above for info)
        0x32,            // S7 Protocol ID 
        0x01,            // Job Type
        0x00,0x00,       // Redundancy identification
        0x05,0x00,       // PDU Reference
        0x00,0x0e,       // Parameters Length
        0x00,0x00,       // Data Length = Size(bytes) + 4      
        0x05,            // Function 4 Read Var, 5 Write Var  
        0x01,            // Items count
    };

		// S7 Drv Variable MultiWrite Item
		byte[] S7Drv_MWR_PARAM =
			{
		0x12,            // Var spec.
        0x0a,            // Length of remaining bytes
        0xa2,            // Syntax ID 
        0x00,            // Empty --> Parameter Type                       
        0x00,0x00,       // Empty --> Number of Rows                          
        0x00,0x00,       // Empty --> Number of DriveObject          
        0x00,0x00,       // Empty --> Parameter Number                           
        0x00,0x00,       // Empty --> Parameter Index                    
    };
		#endregion [S7 DriveES Telegrams]


		/// <summary>
		/// Data I/O main function: Read Drive Area
		/// Function reads one drive parameter and defined amount of indizes of this parameter
		/// </summary>
		/// <param name="DONumber"></param>
		/// <param name="ParameterNumber"></param>
		/// <param name="Start"></param>
		/// <param name="Amount"></param>
		/// <param name="WordLen"></param>
		/// <param name="Buffer"></param>
		/// <returns></returns>
		public int ReadDrvArea(int DONumber, int ParameterNumber, int Start, int Amount, int WordLen, byte[] Buffer)
		{
			int BytesRead = 0;
			return ReadDrvArea(DONumber, ParameterNumber, Start, Amount, WordLen, Buffer, ref BytesRead);
		}
		public int ReadDrvArea(int DONumber, int ParameterNumber, int Start, int Amount, int WordLen, byte[] Buffer, ref int BytesRead)
		{
			// Variables
			int NumElements;
			int MaxElements;
			int TotElements;
			int SizeRequested;
			int Length;
			int Offset = 0;
			int WordSize = 1;

			_LastError = 0;
			Time_ms = 0;
			int Elapsed = Environment.TickCount;
			// Calc Word size          
			WordSize = S7Drv.DrvDataSizeByte(WordLen);
			if (WordSize == 0)
				return S7Consts.errCliInvalidWordLen;
			MaxElements = (_PDULength - 18) / WordSize; // 18 = Reply telegram header
			TotElements = Amount;

			while ((TotElements > 0) && (_LastError == 0))
			{
				NumElements = TotElements;
				if (NumElements > MaxElements)
					NumElements = MaxElements;

				SizeRequested = NumElements * WordSize;

				//$7+: Setup the telegram - New Implementation for Drive Parameters
				Array.Copy(S7_DrvRW, 0, PDU, 0, Size_RD);
				//set DriveParameters
				S7.SetWordAt(PDU, 23, (ushort)NumElements);
				S7.SetWordAt(PDU, 25, (ushort)DONumber);
				S7.SetWordAt(PDU, 27, (ushort)ParameterNumber);
				S7.SetWordAt(PDU, 29, (ushort)Start);
				PDU[22] = (byte)WordLen;

				SendPacket(PDU, Size_RD);
				if (_LastError == 0)
				{
					Length = RecvIsoPacket();
					if (_LastError == 0)
					{
						if (Length < 25)
							_LastError = S7Consts.errIsoInvalidDataSize;
						else
						{
							if (PDU[21] != 0xFF)
								_LastError = CpuError(PDU[21]);
							else
							{
								Array.Copy(PDU, 25, Buffer, Offset, SizeRequested);
								Offset += SizeRequested;
							}
						}
					}
				}
				TotElements -= NumElements;
				Start += NumElements;




			}

			if (_LastError == 0)
			{
				BytesRead = Offset;
				Time_ms = Environment.TickCount - Elapsed;
			}
			else
				BytesRead = 0;
			return _LastError;
		}

		/// <summary>
		/// Data I/O main function: Read Multiple Drive Values
		/// </summary>
		/// <param name="Items"></param>
		/// <param name="ItemsCount"></param>
		/// <returns></returns>
		public int ReadMultiDrvVars(S7DrvDataItem[] Items, int ItemsCount)
		{
			int Offset;
			int Length;
			int ItemSize;
			byte[] S7DrvItem = new byte[12];
			byte[] S7DrvItemRead = new byte[1024];

			_LastError = 0;
			Time_ms = 0;
			int Elapsed = Environment.TickCount;

			// Checks items
			if (ItemsCount > MaxVars)
				return S7Consts.errCliTooManyItems;

			// Fills Header
			Array.Copy(S7Drv_MRD_HEADER, 0, PDU, 0, S7Drv_MRD_HEADER.Length);
			S7.SetWordAt(PDU, 13, (ushort)(ItemsCount * S7DrvItem.Length + 2));
			PDU[18] = (byte)ItemsCount;
			// Fills the Items
			Offset = 19;
			for (int c = 0; c < ItemsCount; c++)
			{
				Array.Copy(S7Drv_MRD_ITEM, S7DrvItem, S7DrvItem.Length);
				S7DrvItem[3] = (byte)Items[c].WordLen;
				S7.SetWordAt(S7DrvItem, 4, (ushort)Items[c].Amount);
				S7.SetWordAt(S7DrvItem, 6, (ushort)Items[c].DONumber);
				S7.SetWordAt(S7DrvItem, 8, (ushort)Items[c].ParameterNumber);
				S7.SetWordAt(S7DrvItem, 10, (ushort)Items[c].Start);


				Array.Copy(S7DrvItem, 0, PDU, Offset, S7DrvItem.Length);
				Offset += S7DrvItem.Length;
			}

			if (Offset > _PDULength)
				return S7Consts.errCliSizeOverPDU;

			S7.SetWordAt(PDU, 2, (ushort)Offset); // Whole size
			SendPacket(PDU, Offset);

			if (_LastError != 0)
				return _LastError;
			// Get Answer
			Length = RecvIsoPacket();
			if (_LastError != 0)
				return _LastError;
			// Check ISO Length
			if (Length < 22)
			{
				_LastError = S7Consts.errIsoInvalidPDU; // PDU too Small
				return _LastError;
			}
			// Check Global Operation Result
			_LastError = CpuError(S7.GetWordAt(PDU, 17));
			if (_LastError != 0)
				return _LastError;
			// Get true ItemsCount
			int ItemsRead = S7.GetByteAt(PDU, 20);
			if ((ItemsRead != ItemsCount) || (ItemsRead > MaxVars))
			{
				_LastError = S7Consts.errCliInvalidPlcAnswer;
				return _LastError;
			}
			// Get Data
			Offset = 21;
			for (int c = 0; c < ItemsCount; c++)
			{
				// Get the Item
				Array.Copy(PDU, Offset, S7DrvItemRead, 0, Length - Offset);
				if (S7DrvItemRead[0] == 0xff)
				{
					ItemSize = (int)S7.GetWordAt(S7DrvItemRead, 2);
					if ((S7DrvItemRead[1] != TS_ResOctet) && (S7DrvItemRead[1] != TS_ResReal) && (S7DrvItemRead[1] != TS_ResBit))
						ItemSize = ItemSize >> 3;
					Marshal.Copy(S7DrvItemRead, 4, Items[c].pData, ItemSize);
					Items[c].Result = 0;
					if (ItemSize % 2 != 0)
						ItemSize++; // Odd size are rounded
					Offset = Offset + 4 + ItemSize;
				}
				else
				{
					Items[c].Result = CpuError(S7DrvItemRead[0]);
					Offset += 4; // Skip the Item header                           
				}
			}
			Time_ms = Environment.TickCount - Elapsed;
			return _LastError;
		}

		/// <summary>
		/// Data I/O main function: Write Multiple Drive Values
		/// </summary>
		/// <param name="Items"></param>
		/// <param name="ItemsCount"></param>
		/// <returns></returns>
		public int WriteMultiDrvVars(S7DrvDataItem[] Items, int ItemsCount)
		{
			int Offset;
			int ParLength;
			int DataLength;
			int ItemDataSize = 4; //default
			byte[] S7DrvParItem = new byte[S7Drv_MWR_PARAM.Length];
			byte[] S7DrvDataItem = new byte[1024];

			_LastError = 0;
			Time_ms = 0;
			int Elapsed = Environment.TickCount;

			// Checks items
			if (ItemsCount > MaxVars)
				return S7Consts.errCliTooManyItems;
			// Fills Header
			Array.Copy(S7Drv_MWR_HEADER, 0, PDU, 0, S7Drv_MWR_HEADER.Length);
			ParLength = ItemsCount * S7Drv_MWR_PARAM.Length + 2;
			S7.SetWordAt(PDU, 13, (ushort)ParLength);
			PDU[18] = (byte)ItemsCount;
			// Fills Params
			Offset = S7Drv_MWR_HEADER.Length;
			for (int c = 0; c < ItemsCount; c++)
			{
				Array.Copy(S7Drv_MWR_PARAM, 0, S7DrvParItem, 0, S7Drv_MWR_PARAM.Length);
				S7DrvParItem[3] = (byte)Items[c].WordLen;
				S7.SetWordAt(S7DrvParItem, 4, (ushort)Items[c].Amount);
				S7.SetWordAt(S7DrvParItem, 6, (ushort)Items[c].DONumber);
				S7.SetWordAt(S7DrvParItem, 8, (ushort)Items[c].ParameterNumber);
				S7.SetWordAt(S7DrvParItem, 10, (ushort)Items[c].Start);

				Array.Copy(S7DrvParItem, 0, PDU, Offset, S7DrvParItem.Length);
				Offset += S7Drv_MWR_PARAM.Length;
			}
			// Fills Data
			DataLength = 0;
			for (int c = 0; c < ItemsCount; c++)
			{
				S7DrvDataItem[0] = 0x00;
				switch (Items[c].WordLen)
				{
					case S7DrvConsts.S7WLReal:
						S7DrvDataItem[1] = TS_ResReal;      // Real
						ItemDataSize = 4;
						break;
					case S7DrvConsts.S7WLDWord:            // DWord
						S7DrvDataItem[1] = TS_ResByte;
						ItemDataSize = 4;
						break;
					case S7DrvConsts.S7WLDInt:            // DWord
						S7DrvDataItem[1] = TS_ResByte;
						ItemDataSize = 4;
						break;
					default:
						S7DrvDataItem[1] = TS_ResByte;     // byte/word/int etc.
						ItemDataSize = 2;
						break;
				};


				if ((S7DrvDataItem[1] != TS_ResOctet) && (S7DrvDataItem[1] != TS_ResBit) && (S7DrvDataItem[1] != TS_ResReal))
					S7.SetWordAt(S7DrvDataItem, 2, (ushort)(ItemDataSize * 8));
				else
					S7.SetWordAt(S7DrvDataItem, 2, (ushort)ItemDataSize);

				Marshal.Copy(Items[c].pData, S7DrvDataItem, 4, ItemDataSize);

				if (ItemDataSize % 2 != 0)
				{
					S7DrvDataItem[ItemDataSize + 4] = 0x00;
					ItemDataSize++;
				}
				Array.Copy(S7DrvDataItem, 0, PDU, Offset, ItemDataSize + 4);
				Offset = Offset + ItemDataSize + 4;
				DataLength = DataLength + ItemDataSize + 4;
			}

			// Checks the size
			if (Offset > _PDULength)
				return S7Consts.errCliSizeOverPDU;

			S7.SetWordAt(PDU, 2, (ushort)Offset); // Whole size
			S7.SetWordAt(PDU, 15, (ushort)DataLength); // Whole size
			SendPacket(PDU, Offset);

			RecvIsoPacket();
			if (_LastError == 0)
			{
				// Check Global Operation Result
				_LastError = CpuError(S7.GetWordAt(PDU, 17));
				if (_LastError != 0)
					return _LastError;
				// Get true ItemsCount
				int ItemsWritten = S7.GetByteAt(PDU, 20);
				if ((ItemsWritten != ItemsCount) || (ItemsWritten > MaxVars))
				{
					_LastError = S7Consts.errCliInvalidPlcAnswer;
					return _LastError;
				}

				for (int c = 0; c < ItemsCount; c++)
				{
					if (PDU[c + 21] == 0xFF)
						Items[c].Result = 0;
					else
						Items[c].Result = CpuError((ushort)PDU[c + 21]);
				}
				Time_ms = Environment.TickCount - Elapsed;
			}
			return _LastError;
		}


		// S7 Drive Data Item
		public struct S7DrvDataItem
		{
			public int DONumber;
			public int WordLen;
			public int Result;
			public int ParameterNumber;
			public int Start;
			public int Amount;
			public IntPtr pData;
		}

		// S7 Drive Connection
		public int DrvConnectTo(string Address)
		{
			UInt16 RemoteTSAP = (UInt16)((ConnType << 8) + (0 * 0x20) + 9);
			// testen
			SetConnectionParams(Address, 0x0100, RemoteTSAP);
			return Connect();
		}
		// S7 Drive Connection with Slot
		public int DrvConnectTo(string Address, int Slot)
		{
			UInt16 RemoteTSAP = (UInt16)((ConnType << 8) + (0 * 0x20) + Slot);
			// testen
			SetConnectionParams(Address, 0x0100, RemoteTSAP);
			return Connect();
		}
		// S7 Drive Connection with Rack & Slot
		public int DrvConnectTo(string Address, int Rack, int Slot)
		{
			UInt16 RemoteTSAP = (UInt16)((ConnType << 8) + (Rack * 0x20) + Slot);
			// testen
			SetConnectionParams(Address, 0x0100, RemoteTSAP);
			return Connect();
		}


		#endregion S7DriveES Functions

		#region S7Nck Client Functions
		// Connection to Sinumerik NC: use slot number 3
		#region [S7 NckTelegrams]
		// Size NCK-Protocoll not equal to S7-Any-Protocoll
		private static int Size_NckRD = 29; // Header Size when Reading 
		private static int Size_NckWR = 33; // Header Size when Writing
		
		// S7 NCK Read/Write Request Header (contains also ISO Header and COTP Header)
		byte[] S7_NckRW = { // 31-35 bytes
            0x03,0x00,
			0x00,0x1d,       // Telegram Length (Data Size + 29 or 33)
            0x02,0xf0, 0x80, // COTP (see above for info)
            0x32,            // S7 Protocol ID 
            0x01,            // Job Type
            0x00,0x00,       // Redundancy identification
            0x05,0x00,       // PDU Reference
            0x00,0x0c,       // Parameters Length
            0x00,0x00,       // Data Length = Size(bytes) + 4      
            0x04,            // Function 4 Read Var, 5 Write Var  
            0x01,            // Items count
            0x12,            // Var spec.
            0x08,            // Length of remaining bytes
            0x82,            // Syntax ID 
            0x00,            // Empty --> NCK Area and Unit                     
            0x00,0x00,       // Empty --> Parameter Number                          
            0x00,0x00,       // Empty --> Parameter Index          
            0x00,            // Empty --> NCK Module (See NCVar-Selector for help)                           
            0x00,            // Empty --> Number of Rows                     
            // WR area
            0x00,            // Reserved 
            0x04,            // Transport size
            0x00,0x00,       // Data Length * 8 (if not bit or timer or counter) 
        };

		// S7 Nck Variable MultiRead Header
		byte[] S7Nck_MRD_HEADER = {
			0x03,0x00,
			0x00,0x1d,       // Telegram Length (Data Size + 29 or 33)
            0x02,0xf0, 0x80, // COTP (see above for info)
            0x32,            // S7 Protocol ID 
            0x01,            // Job Type
            0x00,0x00,       // Redundancy identification
            0x05,0x00,       // PDU Reference
            0x00,0x0c,       // Parameters Length
            0x00,0x00,       // Data Length = Size(bytes) + 4      
            0x04,            // Function 4 Read Var, 5 Write Var  
            0x01,            // Items count
        };

		// S7 Nck Variable MultiRead Item
		byte[] S7Nck_MRD_ITEM = {
			0x12,            // Var spec.
            0x08,            // Length of remaining bytes
            0x82,            // Syntax ID 
            0x00,            // Empty --> NCK Area and Unit                     
            0x00,0x00,       // Empty --> Parameter Number                          
            0x00,0x00,       // Empty --> Parameter Index          
            0x00,            // Empty --> NCK Module (See NCVar-Selector for help)                           
            0x00,            // Empty --> Number of Rows                     
        };

		// S7 Nck Variable MultiWrite Header
		byte[] S7Nck_MWR_HEADER = {
			0x03,0x00,
			0x00,0x1d,       // Telegram Length (Data Size + 29 or 33)
            0x02,0xf0, 0x80, // COTP (see above for info)
            0x32,            // S7 Protocol ID 
            0x01,            // Job Type
            0x00,0x00,       // Redundancy identification
            0x05,0x00,       // PDU Reference
            0x00,0x0c,       // Parameters Length
            0x00,0x00,       // Data Length = Size(bytes) + 4      
            0x05,            // Function 4 Read Var, 5 Write Var  
            0x01,            // Items count
        };

		// S7 Nck Variable MultiWrite Item
		byte[] S7Nck_MWR_PARAM = {
			0x12,            // Var spec.
            0x08,            // Length of remaining bytes
            0x82,            // Syntax ID 
            0x00,            // Empty --> NCK Area and Unit                     
            0x00,0x00,       // Empty --> Parameter Number                          
            0x00,0x00,       // Empty --> Parameter Index          
            0x00,            // Empty --> NCK Module (See NCVar-Selector for help)                           
            0x00,            // Empty --> Number of Rows                     
        };
		#endregion [S7 NckTelegrams]

		/// <summary>
		/// Data I/O main function: Read Nck Area
		/// Function reads one Nck parameter and defined amount of indizes of this parameter
		/// </summary>
		/// <param name="NckArea"></param>
		/// <param name="NckModule"></param>
		/// <param name="ParameterNumber"></param>
		/// <param name="Start"></param>
		/// <param name="Amount"></param>
		/// <param name="WordLen"></param>
		/// <param name="Buffer"></param>
		/// <returns></returns>
		public int ReadNckArea(int NckArea, int NckUnit, int NckModule, int ParameterNumber, int Start, int Amount, int WordLen, byte[] Buffer)
		{
			int BytesRead = 0;
			return ReadNckArea(NckArea, NckUnit, NckModule, ParameterNumber, Start, Amount, WordLen, Buffer, ref BytesRead);
		}
		public int ReadNckArea(int NckArea, int NckUnit, int NckModule, int ParameterNumber, int Start, int Amount, int WordLen, byte[] Buffer, ref int BytesRead)
		{
			// Variables
			int NumElements;
			int MaxElements;
			int TotElements;
			int SizeRequested;
			int Length;
			int Offset = 0;
			int WordSize = 1;

			_LastError = 0;
			Time_ms = 0;
			int Elapsed = Environment.TickCount;
			// Calc Word size 
			//New Definition used: NCKDataSizeByte         
			WordSize = S7Nck.NckDataSizeByte(WordLen);
			if (WordSize == 0)
				return S7Consts.errCliInvalidWordLen;
			MaxElements = (_PDULength - 18) / WordSize; // 18 = Reply telegram header
			TotElements = Amount;

			while ((TotElements > 0) && (_LastError == 0))
			{
				NumElements = TotElements;
				if (NumElements > MaxElements)
					NumElements = MaxElements;

				SizeRequested = NumElements * WordSize;
				//Setup the telegram - New Implementation for NCK Parameters
				Array.Copy(S7_NckRW, 0, PDU, 0, Size_NckRD);
				//set NckParameters        
				NckArea = NckArea << 4;
				PDU[22] = (byte)(NckArea + NckUnit);
				S7.SetWordAt(PDU, 23, (ushort)ParameterNumber);
				S7.SetWordAt(PDU, 25, (ushort)Start);
				PDU[27] = (byte)NckModule;
				PDU[28] = (byte)NumElements;

				SendPacket(PDU, Size_NckRD);
				if (_LastError == 0)
				{
					Length = RecvIsoPacket();
					if (_LastError == 0)
					{
						if (Length < 25)
							_LastError = S7Consts.errIsoInvalidDataSize;
						else
						{
							if (PDU[21] != 0xFF)
								_LastError = CpuError(PDU[21]);
							else
							{
								Array.Copy(PDU, 25, Buffer, Offset, SizeRequested);
								Offset += SizeRequested;
							}
						}
					}
				}
				TotElements -= NumElements;
				Start += NumElements;
			}
			if (_LastError == 0)
			{
				BytesRead = Offset;
				Time_ms = Environment.TickCount - Elapsed;
			}
			else
				BytesRead = 0;
			return _LastError;
		}

		/// <summary>
		/// Data I/O main function: Read Multiple Nck Values
		/// </summary>
		/// <param name="Items"></param>
		/// <param name="ItemsCount"></param>
		/// <returns></returns>
		public int ReadMultiNckVars(S7NckDataItem[] Items, int ItemsCount)
		{
			int Offset;
			int Length;
			int ItemSize;
			byte[] S7NckItem = new byte[10];
			byte[] S7NckItemRead = new byte[1024];

			_LastError = 0;
			Time_ms = 0;
			int Elapsed = Environment.TickCount;

			// Checks items
			if (ItemsCount > MaxVars)
				return S7Consts.errCliTooManyItems;

			// Fills Header
			Array.Copy(S7Nck_MRD_HEADER, 0, PDU, 0, S7Nck_MRD_HEADER.Length);
			S7.SetWordAt(PDU, 13, (ushort)(ItemsCount * S7NckItem.Length + 2));
			PDU[18] = (byte)ItemsCount;
			// Fills the Items
			Offset = 19;
			for (int c = 0; c < ItemsCount; c++)
			{
				Array.Copy(S7Nck_MRD_ITEM, S7NckItem, S7NckItem.Length);
				int NckArea = Items[c].NckArea << 4;
				S7NckItem[3] = (byte)(NckArea + Items[c].NckUnit);
				S7.SetWordAt(S7NckItem, 4, (ushort)Items[c].ParameterNumber);
				S7.SetWordAt(S7NckItem, 6, (ushort)Items[c].Start);
				S7.SetByteAt(S7NckItem, 8, (byte)Items[c].NckModule);
				S7.SetByteAt(S7NckItem, 9, (byte)Items[c].Amount);

				Array.Copy(S7NckItem, 0, PDU, Offset, S7NckItem.Length);
				Offset += S7NckItem.Length;
			}

			if (Offset > _PDULength)
				return S7Consts.errCliSizeOverPDU;

			S7.SetWordAt(PDU, 2, (ushort)Offset); // Whole size
			SendPacket(PDU, Offset);

			if (_LastError != 0)
				return _LastError;
			// Get Answer
			Length = RecvIsoPacket();
			if (_LastError != 0)
				return _LastError;
			// Check ISO Length
			if (Length < 22)
			{
				_LastError = S7Consts.errIsoInvalidPDU; // PDU too Small
				return _LastError;
			}
			// Check Global Operation Result
			_LastError = CpuError(S7.GetWordAt(PDU, 17));
			if (_LastError != 0)
				return _LastError;
			// Get true ItemsCount
			int ItemsRead = S7.GetByteAt(PDU, 20);
			if ((ItemsRead != ItemsCount) || (ItemsRead > MaxVars))
			{
				_LastError = S7Consts.errCliInvalidPlcAnswer;
				return _LastError;
			}
			// Get Data
			Offset = 21;
			for (int c = 0; c < ItemsCount; c++)
			{
				// Get the Item
				Array.Copy(PDU, Offset, S7NckItemRead, 0, Length - Offset);
				if (S7NckItemRead[0] == 0xff)
				{
					ItemSize = (int)S7.GetWordAt(S7NckItemRead, 2);
					if ((S7NckItemRead[1] != TS_ResOctet) && (S7NckItemRead[1] != TS_ResReal) && (S7NckItemRead[1] != TS_ResBit))
						ItemSize = ItemSize >> 3;
					Marshal.Copy(S7NckItemRead, 4, Items[c].pData, ItemSize);
					Items[c].Result = 0;
					if (ItemSize % 2 != 0)
						ItemSize++; // Odd size are rounded
					Offset = Offset + 4 + ItemSize;
				}
				else
				{
					Items[c].Result = CpuError(S7NckItemRead[0]);
					Offset += 4; // Skip the Item header                           
				}
			}
			Time_ms = Environment.TickCount - Elapsed;
			return _LastError;
		}

		/// <summary>
		/// $7+ new Data I/O main function: Write Multiple Nck Values (under construction)
		/// </summary>
		/// <param name="Items"></param>
		/// <param name="ItemsCount"></param>
		/// <returns></returns>
		public int WriteMultiNckVars(S7NckDataItem[] Items, int ItemsCount)
		{
			int Offset;
			int ParLength;
			int DataLength;
			int ItemDataSize;
			byte[] S7NckParItem = new byte[S7Nck_MWR_PARAM.Length];
			byte[] S7NckDataItem = new byte[1024];

			_LastError = 0;
			Time_ms = 0;
			int Elapsed = Environment.TickCount;

			// Checks items
			if (ItemsCount > MaxVars)
				return S7Consts.errCliTooManyItems;
			// Fills Header
			Array.Copy(S7Nck_MWR_HEADER, 0, PDU, 0, S7Nck_MWR_HEADER.Length);
			ParLength = ItemsCount * S7Nck_MWR_PARAM.Length + 2;
			S7.SetWordAt(PDU, 13, (ushort)ParLength);
			PDU[18] = (byte)ItemsCount;
			// Fills Params
			Offset = S7Nck_MWR_HEADER.Length;
			for (int c = 0; c < ItemsCount; c++)
			{
				// Set Parameters
				Array.Copy(S7Nck_MWR_PARAM, 0, S7NckParItem, 0, S7Nck_MWR_PARAM.Length);
				int NckArea = Items[c].NckArea << 4;
				S7NckParItem[3] = (byte)(NckArea + Items[c].NckUnit);
				S7.SetWordAt(S7NckParItem, 4, (ushort)Items[c].ParameterNumber);
				S7.SetWordAt(S7NckParItem, 6, (ushort)Items[c].Start);
				S7.SetByteAt(S7NckParItem, 8, (byte)Items[c].NckModule);
				S7.SetByteAt(S7NckParItem, 9, (byte)Items[c].Amount);
				Array.Copy(S7NckParItem, 0, PDU, Offset, S7NckParItem.Length);
				Offset += S7Nck_MWR_PARAM.Length;
			}
			// Fills Data
			DataLength = 0;
			for (int c = 0; c < ItemsCount; c++)
			{
				S7NckDataItem[0] = 0x00;
				// All Nck-Parameters are written as octet-string
				S7NckDataItem[1] = TS_ResOctet;
				if (Items[c].WordLen == S7NckConsts.S7WLBit || Items[c].WordLen == S7Consts.S7WLByte)
					ItemDataSize = 1;
				else if (Items[c].WordLen == S7NckConsts.S7WLDouble)
					ItemDataSize = 8;
				else if (Items[c].WordLen == S7NckConsts.S7WLString)
					ItemDataSize = 16;
				else
					ItemDataSize = 4;


				if ((S7NckDataItem[1] != TS_ResOctet) && (S7NckDataItem[1] != TS_ResBit) && (S7NckDataItem[1] != TS_ResReal))
					S7.SetWordAt(S7NckDataItem, 2, (ushort)(ItemDataSize * 8));
				else
					S7.SetWordAt(S7NckDataItem, 2, (ushort)ItemDataSize);

				Marshal.Copy(Items[c].pData, S7NckDataItem, 4, ItemDataSize);

				if (ItemDataSize % 2 != 0)
				{
					S7NckDataItem[ItemDataSize + 4] = 0x00;
					ItemDataSize++;
				}
				Array.Copy(S7NckDataItem, 0, PDU, Offset, ItemDataSize + 4);
				Offset = Offset + ItemDataSize + 4;
				DataLength = DataLength + ItemDataSize + 4;
			}




			// Checks the size
			if (Offset > _PDULength)
				return S7Consts.errCliSizeOverPDU;

			S7.SetWordAt(PDU, 2, (ushort)Offset); // Whole size
			S7.SetWordAt(PDU, 15, (ushort)DataLength); // Whole size
			SendPacket(PDU, Offset);

			RecvIsoPacket();
			if (_LastError == 0)
			{
				// Check Global Operation Result
				_LastError = CpuError(S7.GetWordAt(PDU, 17));
				if (_LastError != 0)
					return _LastError;
				// Get true ItemsCount
				int ItemsWritten = S7.GetByteAt(PDU, 20);
				if ((ItemsWritten != ItemsCount) || (ItemsWritten > MaxVars))
				{
					_LastError = S7Consts.errCliInvalidPlcAnswer;
					return _LastError;
				}

				for (int c = 0; c < ItemsCount; c++)
				{
					if (PDU[c + 21] == 0xFF)
						Items[c].Result = 0;
					else
						Items[c].Result = CpuError((ushort)PDU[c + 21]);
				}
				Time_ms = Environment.TickCount - Elapsed;
			}
			return _LastError;
		}

		// S7 Nck Data Item
		public struct S7NckDataItem
		{
			public int NckArea;
			public int NckUnit;
			public int NckModule;
			public int WordLen;
			public int Result;
			public int ParameterNumber;
			public int Start;
			public int Amount;
			public IntPtr pData;
		}

		// S7 Nck Connection
		public int NckConnectTo(string Address)
		{
			UInt16 RemoteTSAP = (UInt16)((ConnType << 8) + (0 * 0x20) + 3);
			// testen
			SetConnectionParams(Address, 0x0100, RemoteTSAP);
			return Connect();
		}
		// S7 Nck Connection with Rack
		public int NckConnectTo(string Address, int Rack)
		{
			UInt16 RemoteTSAP = (UInt16)((ConnType << 8) + (Rack * 0x20) + 3);
			// testen
			SetConnectionParams(Address, 0x0100, RemoteTSAP);
			return Connect();
		}

		#endregion S7Nck Client Functions

		#endregion Sinumerik Client Functions
	}


    #region [S7 Sinumerik]

    #region [S7 DriveES]
    #region [S7 Drive MultiVar]
    // S7 DriveES MultiRead and MultiWrite
    public class S7DrvMultiVar
	{
		#region [MultiRead/Write Helper]
		private S7Client FClient;
		private GCHandle[] Handles = new GCHandle[S7Client.MaxVars];
		private int Count = 0;
		private S7Client.S7DrvDataItem[] DrvItems = new S7Client.S7DrvDataItem[S7Client.MaxVars];
		public int[] Results = new int[S7Client.MaxVars];
		// Adapt WordLength
		private bool AdjustWordLength(int Area, ref int WordLen, ref int Amount, ref int Start)
		{
			// Calc Word size          
			int WordSize = S7.DataSizeByte(WordLen);
			if (WordSize == 0)
				return false;

			return true;
		}

		public S7DrvMultiVar(S7Client Client)
		{
			FClient = Client;
			for (int c = 0; c < S7Client.MaxVars; c++)
				Results[c] = (int)S7Consts.errCliItemNotAvailable;
		}

		~S7DrvMultiVar()
		{
			Clear();
		}

		// Add Drive Variables
		public bool DrvAdd<T>(S7DrvConsts.S7DrvTag Tag, ref T[] Buffer, int Offset)
		{
			return DrvAdd(Tag.DONumber, Tag.ParameterNumber, Tag.WordLen, Tag.Start, Tag.Elements, ref Buffer, Offset);
		}
		public bool DrvAdd<T>(S7DrvConsts.S7DrvTag Tag, ref T[] Buffer)
		{
			return DrvAdd(Tag.DONumber, Tag.ParameterNumber, Tag.WordLen, Tag.Start, Tag.Elements, ref Buffer);
		}
		public bool DrvAdd<T>(Int32 DONumber, Int32 ParameterNumber, Int32 WordLen, Int32 Start, ref T[] Buffer)
		{
			int Amount = 1;
			return DrvAdd(DONumber, ParameterNumber, WordLen, Start, Amount, ref Buffer, 0);
		}
		public bool DrvAdd<T>(Int32 DONumber, Int32 ParameterNumber, Int32 WordLen, Int32 Start, Int32 Amount, ref T[] Buffer)
		{
			return DrvAdd(DONumber, ParameterNumber, WordLen, Start, Amount, ref Buffer, 0);
		}
		public bool DrvAdd<T>(Int32 DONumber, Int32 ParameterNumber, Int32 WordLen, Int32 Start, ref T[] Buffer, int Offset)
		{
			int Amount = 1;
			return DrvAdd(DONumber, ParameterNumber, WordLen, Start, Amount, ref Buffer, Offset);
		}
		public bool DrvAdd<T>(Int32 DONumber, Int32 ParameterNumber, Int32 WordLen, Int32 Start, Int32 Amount, ref T[] Buffer, int Offset)
		{

			if (Count < S7Client.MaxVars)
			{
				//Syntax-ID for DriveES-Communication
				int DrvSynID = 162;
				if (AdjustWordLength(DrvSynID, ref WordLen, ref Amount, ref Start))
				{
					DrvItems[Count].DONumber = DONumber;
					DrvItems[Count].WordLen = WordLen;
					DrvItems[Count].Result = (int)S7Consts.errCliItemNotAvailable;
					DrvItems[Count].ParameterNumber = ParameterNumber;
					DrvItems[Count].Start = Start;
					DrvItems[Count].Amount = Amount;
					GCHandle handle = GCHandle.Alloc(Buffer, GCHandleType.Pinned);
#if WINDOWS_UWP || NETFX_CORE
                    if (IntPtr.Size == 4)
                        DrvItems[Count].pData = (IntPtr)(handle.AddrOfPinnedObject().ToInt32() + DataOffset * Marshal.SizeOf<T>());
                    else
                        DrvItems[Count].pData = (IntPtr)(handle.AddrOfPinnedObject().ToInt64() + DataOffset * Marshal.SizeOf<T>());
#else
					if (IntPtr.Size == 4)
						DrvItems[Count].pData = (IntPtr)(handle.AddrOfPinnedObject().ToInt32() + Offset * Marshal.SizeOf(typeof(T)));
					else
						DrvItems[Count].pData = (IntPtr)(handle.AddrOfPinnedObject().ToInt64() + Offset * Marshal.SizeOf(typeof(T)));
#endif
					Handles[Count] = handle;
					Count++;
					Offset = WordLen;
					return true;
				}
				else
					return false;
			}
			else
				return false;
		}

		// Read Drive Parameter
		public int ReadDrv()
		{
			int FunctionResult;
			int GlobalResult = (int)S7Consts.errCliFunctionRefused;
			try
			{
				if (Count > 0)
				{
					FunctionResult = FClient.ReadMultiDrvVars(DrvItems, Count);
					if (FunctionResult == 0)
						for (int c = 0; c < S7Client.MaxVars; c++)
							Results[c] = DrvItems[c].Result;
					GlobalResult = FunctionResult;
				}
				else
					GlobalResult = S7Consts.errCliFunctionRefused;
			}
			finally
			{
				Clear(); // handles are no more needed and MUST be freed
			}
			return GlobalResult;
		}

		// Write Drive Parameter
		public int WriteDrv()
		{
			int FunctionResult;
			int GlobalResult = S7Consts.errCliFunctionRefused;
			try
			{
				if (Count > 0)
				{
					FunctionResult = FClient.WriteMultiDrvVars(DrvItems, Count);
					if (FunctionResult == 0)
						for (int c = 0; c < S7Client.MaxVars; c++)
							Results[c] = DrvItems[c].Result;
					GlobalResult = FunctionResult;
				}
				else
					GlobalResult = S7Consts.errCliFunctionRefused;
			}
			finally
			{
				Clear(); // handles are no more needed and MUST be freed
			}
			return GlobalResult;
		}

		public void Clear()
		{
			for (int c = 0; c < Count; c++)
			{
				if (Handles[c] != null)
					Handles[c].Free();
			}
			Count = 0;
		}
		#endregion
	}
	#endregion  [S7 Drive MultiVar]

	#region  [S7 Drive Constants]
	// S7 DriveES Constants
	public static class S7DrvConsts
	{

		// Word Length
		public const int S7WLByte = 0x02;
		public const int S7WLWord = 0x04;
		public const int S7WLInt = 0x05;
		public const int S7WLDWord = 0x06;
		public const int S7WLDInt = 0x07;
		public const int S7WLReal = 0x08;

		//S7 DriveEs Tag
		public struct S7DrvTag
		{
			public Int32 DONumber;
			public Int32 ParameterNumber;
			public Int32 Start;
			public Int32 Elements;
			public Int32 WordLen;
		}
	}
	#endregion   [S7 Drive Constants]

	//$CS: Help Funktionen
	#region [S7 Drv  Help Functions]
	public static class S7Drv
	{

		private static Int64 bias = 621355968000000000; // "decimicros" between 0001-01-01 00:00:00 and 1970-01-01 00:00:00

		private static int BCDtoByte(byte B)
		{
			return ((B >> 4) * 10) + (B & 0x0F);
		}

		private static byte ByteToBCD(int Value)
		{
			return (byte)(((Value / 10) << 4) | (Value % 10));
		}

		private static byte[] CopyFrom(byte[] Buffer, int Pos, int Size)
		{
			byte[] Result = new byte[Size];
			Array.Copy(Buffer, Pos, Result, 0, Size);
			return Result;
		}

		//S7 DriveES Constants
		public static int DrvDataSizeByte(int WordLength)
		{
			switch (WordLength)
			{
				case S7DrvConsts.S7WLByte: return 1;
				case S7DrvConsts.S7WLWord: return 2;
				case S7DrvConsts.S7WLDWord: return 4;
				case S7DrvConsts.S7WLInt: return 2;
				case S7DrvConsts.S7WLDInt: return 4;
				case S7DrvConsts.S7WLReal: return 4;
				default: return 0;
			}
		}

		#region Get/Set 8 bit signed value (S7 SInt) -128..127
		public static int GetSIntAt(byte[] Buffer, int Pos)
		{
			int Value = Buffer[Pos];
			if (Value < 128)
				return Value;
			else
				return (int)(Value - 256);
		}
		public static void SetSIntAt(byte[] Buffer, int Pos, int Value)
		{
			if (Value < -128) Value = -128;
			if (Value > 127) Value = 127;
			Buffer[Pos] = (byte)Value;
		}
		#endregion

		#region Get/Set 16 bit signed value (S7 int) -32768..32767
		public static short GetIntAt(byte[] Buffer, int Pos)
		{
			return (short)((Buffer[Pos] << 8) | Buffer[Pos + 1]);
		}
		public static void SetIntAt(byte[] Buffer, int Pos, Int16 Value)
		{
			Buffer[Pos] = (byte)(Value >> 8);
			Buffer[Pos + 1] = (byte)(Value & 0x00FF);
		}
		#endregion

		#region Get/Set 32 bit signed value (S7 DInt) -2147483648..2147483647
		public static int GetDIntAt(byte[] Buffer, int Pos)
		{
			int Result;
			Result = Buffer[Pos]; Result <<= 8;
			Result += Buffer[Pos + 1]; Result <<= 8;
			Result += Buffer[Pos + 2]; Result <<= 8;
			Result += Buffer[Pos + 3];
			return Result;
		}
		public static void SetDIntAt(byte[] Buffer, int Pos, int Value)
		{
			Buffer[Pos + 3] = (byte)(Value & 0xFF);
			Buffer[Pos + 2] = (byte)((Value >> 8) & 0xFF);
			Buffer[Pos + 1] = (byte)((Value >> 16) & 0xFF);
			Buffer[Pos] = (byte)((Value >> 24) & 0xFF);
		}
		#endregion

		#region Get/Set 8 bit unsigned value (S7 USInt) 0..255
		public static byte GetUSIntAt(byte[] Buffer, int Pos)
		{
			return Buffer[Pos];
		}
		public static void SetUSIntAt(byte[] Buffer, int Pos, byte Value)
		{
			Buffer[Pos] = Value;
		}
		#endregion

		#region Get/Set 16 bit unsigned value (S7 UInt) 0..65535
		public static UInt16 GetUIntAt(byte[] Buffer, int Pos)
		{
			return (UInt16)((Buffer[Pos] << 8) | Buffer[Pos + 1]);
		}
		public static void SetUIntAt(byte[] Buffer, int Pos, UInt16 Value)
		{
			Buffer[Pos] = (byte)(Value >> 8);
			Buffer[Pos + 1] = (byte)(Value & 0x00FF);
		}
		#endregion

		#region Get/Set 32 bit unsigned value (S7 UDInt) 0..4294967296
		public static UInt32 GetUDIntAt(byte[] Buffer, int Pos)
		{
			UInt32 Result;
			Result = Buffer[Pos]; Result <<= 8;
			Result |= Buffer[Pos + 1]; Result <<= 8;
			Result |= Buffer[Pos + 2]; Result <<= 8;
			Result |= Buffer[Pos + 3];
			return Result;
		}
		public static void SetUDIntAt(byte[] Buffer, int Pos, UInt32 Value)
		{
			Buffer[Pos + 3] = (byte)(Value & 0xFF);
			Buffer[Pos + 2] = (byte)((Value >> 8) & 0xFF);
			Buffer[Pos + 1] = (byte)((Value >> 16) & 0xFF);
			Buffer[Pos] = (byte)((Value >> 24) & 0xFF);
		}
		#endregion

		#region Get/Set 8 bit word (S7 Byte) 16#00..16#FF
		public static byte GetByteAt(byte[] Buffer, int Pos)
		{
			return Buffer[Pos];
		}
		public static void SetByteAt(byte[] Buffer, int Pos, byte Value)
		{
			Buffer[Pos] = Value;
		}
		#endregion

		#region Get/Set 16 bit word (S7 Word) 16#0000..16#FFFF
		public static UInt16 GetWordAt(byte[] Buffer, int Pos)
		{
			return GetUIntAt(Buffer, Pos);
		}
		public static void SetWordAt(byte[] Buffer, int Pos, UInt16 Value)
		{
			SetUIntAt(Buffer, Pos, Value);
		}
		#endregion

		#region Get/Set 32 bit word (S7 DWord) 16#00000000..16#FFFFFFFF
		public static UInt32 GetDWordAt(byte[] Buffer, int Pos)
		{
			return GetUDIntAt(Buffer, Pos);
		}
		public static void SetDWordAt(byte[] Buffer, int Pos, UInt32 Value)
		{
			SetUDIntAt(Buffer, Pos, Value);
		}
		#endregion

		#region Get/Set 32 bit floating point number (S7 Real) (Range of Single)
		public static Single GetRealAt(byte[] Buffer, int Pos)
		{
			UInt32 Value = GetUDIntAt(Buffer, Pos);
			byte[] bytes = BitConverter.GetBytes(Value);
			return BitConverter.ToSingle(bytes, 0);
		}
		public static void SetRealAt(byte[] Buffer, int Pos, Single Value)
		{
			byte[] FloatArray = BitConverter.GetBytes(Value);
			Buffer[Pos] = FloatArray[3];
			Buffer[Pos + 1] = FloatArray[2];
			Buffer[Pos + 2] = FloatArray[1];
			Buffer[Pos + 3] = FloatArray[0];
		}
		#endregion

	}
	#endregion [S7 Drv  Help Functions]

	#endregion [S7 DriveES]

	#region [S7 Nck]
	#region [S7 Nck MultiVar]
	// S7 Nck MultiRead and MultiWrite
	public class S7NckMultiVar
	{
		#region [MultiRead/Write Helper]
		private S7Client FClient;
		private GCHandle[] Handles = new GCHandle[S7Client.MaxVars];
		private int Count = 0;
		private S7Client.S7NckDataItem[] NckItems = new S7Client.S7NckDataItem[S7Client.MaxVars];
		public int[] Results = new int[S7Client.MaxVars];
		// Adapt WordLength
		private bool AdjustWordLength(int Area, ref int WordLen, ref int Amount, ref int Start)
		{
			// Calc Word size          
			int WordSize = S7Nck.NckDataSizeByte(WordLen);
			if (WordSize == 0)
				return false;

			if (WordLen == S7NckConsts.S7WLBit)
				Amount = 1;  // Only 1 bit can be transferred at time
			return true;
		}

		public S7NckMultiVar(S7Client Client)
		{
			FClient = Client;
			for (int c = 0; c < S7Client.MaxVars; c++)
				Results[c] = S7Consts.errCliItemNotAvailable;
		}

		~S7NckMultiVar()
		{
			Clear();
		}

		// Add Nck Variables
		public bool NckAdd<T>(S7NckConsts.S7NckTag Tag, ref T[] Buffer, int Offset)
		{
			return NckAdd(Tag.NckArea, Tag.NckUnit, Tag.NckModule, Tag.ParameterNumber, Tag.WordLen, Tag.Start, Tag.Elements, ref Buffer, Offset);
		}
		public bool NckAdd<T>(S7NckConsts.S7NckTag Tag, ref T[] Buffer)
		{
			return NckAdd(Tag.NckArea, Tag.NckUnit, Tag.NckModule, Tag.ParameterNumber, Tag.WordLen, Tag.Start, Tag.Elements, ref Buffer);
		}
		public bool NckAdd<T>(Int32 NckArea, Int32 NckUnit, Int32 NckModule, Int32 ParameterNumber, Int32 WordLen, Int32 Start, ref T[] Buffer)
		{
			int Amount = 1;
			return NckAdd(NckArea, NckUnit, NckModule, ParameterNumber, WordLen, Start, Amount, ref Buffer);
		}
		public bool NckAdd<T>(Int32 NckArea, Int32 NckUnit, Int32 NckModule, Int32 ParameterNumber, Int32 WordLen, Int32 Start, Int32 Amount, ref T[] Buffer)
		{
			return NckAdd(NckArea, NckUnit, NckModule, ParameterNumber, WordLen, Start, Amount, ref Buffer, 0);
		}
		public bool NckAdd<T>(Int32 NckArea, Int32 NckUnit, Int32 NckModule, Int32 ParameterNumber, Int32 WordLen, Int32 Start, Int32 Amount, ref T[] Buffer, int Offset)
		{
			if (Count < S7Client.MaxVars)
			{
				//Syntax-ID for Nck-Communication
				int NckSynID = 130;
				if (AdjustWordLength(NckSynID, ref WordLen, ref Amount, ref Start))
				{
					NckItems[Count].NckArea = NckArea;
					NckItems[Count].WordLen = WordLen;
					NckItems[Count].Result = (int)S7Consts.errCliItemNotAvailable;
					NckItems[Count].ParameterNumber = ParameterNumber;
					NckItems[Count].Start = Start;
					NckItems[Count].Amount = Amount;
					NckItems[Count].NckUnit = NckUnit;
					NckItems[Count].NckModule = NckModule;
					GCHandle handle = GCHandle.Alloc(Buffer, GCHandleType.Pinned);
#if WINDOWS_UWP || NETFX_CORE
                    if (IntPtr.Size == 4)
                        NckItems[Count].pData = (IntPtr)(handle.AddrOfPinnedObject().ToInt32() + Offset * Marshal.SizeOf<T>());
                    else
                        NckItems[Count].pData = (IntPtr)(handle.AddrOfPinnedObject().ToInt64() + Offset * Marshal.SizeOf<T>());
#else
					if (IntPtr.Size == 4)
						NckItems[Count].pData = (IntPtr)(handle.AddrOfPinnedObject().ToInt32() + Offset * Marshal.SizeOf(typeof(T)));
					else
						NckItems[Count].pData = (IntPtr)(handle.AddrOfPinnedObject().ToInt64() + Offset * Marshal.SizeOf(typeof(T)));
#endif
					Handles[Count] = handle;
					Count++;
					return true;
				}
				else
					return false;
			}
			else
				return false;
		}

		//Read Nck Parameter
		public int ReadNck()
		{
			int FunctionResult;
			int GlobalResult = (int)S7Consts.errCliFunctionRefused;
			try
			{
				if (Count > 0)
				{
					FunctionResult = FClient.ReadMultiNckVars(NckItems, Count);
					if (FunctionResult == 0)
						for (int c = 0; c < S7Client.MaxVars; c++)
							Results[c] = NckItems[c].Result;
					GlobalResult = FunctionResult;
				}
				else
					GlobalResult = (int)S7Consts.errCliFunctionRefused;
			}
			finally
			{
				Clear(); // handles are no more needed and MUST be freed
			}
			return GlobalResult;
		}

		// Write Nck Parameter
		public int WriteNck()
		{
			int FunctionResult;
			int GlobalResult = (int)S7Consts.errCliFunctionRefused;
			try
			{
				if (Count > 0)
				{
					FunctionResult = FClient.WriteMultiNckVars(NckItems, Count);
					if (FunctionResult == 0)
						for (int c = 0; c < S7Client.MaxVars; c++)
							Results[c] = NckItems[c].Result;
					GlobalResult = FunctionResult;
				}
				else
					GlobalResult = (int)S7Consts.errCliFunctionRefused;
			}
			finally
			{
				Clear(); // handles are no more needed and MUST be freed
			}
			return GlobalResult;
		}

		public void Clear()
		{
			for (int c = 0; c < Count; c++)
			{
				if (Handles[c] != null)
					Handles[c].Free();
			}
			Count = 0;
		}
		#endregion
	}
	#endregion

	#region [S7 Nck Constants]
	// Nck Constants
	public static class S7NckConsts
	{

		// Word Length
		public const int S7WLBit = 0x01;
		public const int S7WLByte = 0x02;
		public const int S7WLChar = 0x03;
		public const int S7WLWord = 0x04;
		public const int S7WLInt = 0x05;
		public const int S7WLDWord = 0x06;
		public const int S7WLDInt = 0x07;
		public const int S7WLDouble = 0x1A;
		public const int S7WLString = 0x1B;


		//S7 Nck Tag
		public struct S7NckTag
		{
			public Int32 NckArea;
			public Int32 NckUnit;
			public Int32 NckModule;
			public Int32 ParameterNumber;
			public Int32 Start;
			public Int32 Elements;
			public Int32 WordLen;
		}



	}
	#endregion

	//$CS: Help Funktionen sind zu überarbeiten
	#region [S7 Nck  Help Functions]

	public static class S7Nck
	{

		private static Int64 bias = 621355968000000000; // "decimicros" between 0001-01-01 00:00:00 and 1970-01-01 00:00:00

		private static int BCDtoByte(byte B)
		{
			return ((B >> 4) * 10) + (B & 0x0F);
		}

		private static byte ByteToBCD(int Value)
		{
			return (byte)(((Value / 10) << 4) | (Value % 10));
		}

		private static byte[] CopyFrom(byte[] Buffer, int Pos, int Size)
		{
			byte[] Result = new byte[Size];
			Array.Copy(Buffer, Pos, Result, 0, Size);
			return Result;
		}

		private static byte[] OctRev(byte[] bytes, int Size)
		{
			byte[] reverse = new byte[Size];
			int j = 0;
			for (int i = Size - 1; i >= 0; i--)
			{
				reverse[j] = bytes[i];
				j++;
			}
			return reverse;

		}

		//S7 Nck Constants
		public static int NckDataSizeByte(int WordLength)
		{
			switch (WordLength)
			{
				case S7NckConsts.S7WLBit: return 1;  // S7 sends 1 byte per bit
				case S7NckConsts.S7WLByte: return 1;
				case S7NckConsts.S7WLChar: return 1;
				case S7NckConsts.S7WLWord: return 2;
				case S7NckConsts.S7WLDWord: return 4;
				case S7NckConsts.S7WLInt: return 2;
				case S7NckConsts.S7WLDInt: return 4;
				case S7NckConsts.S7WLDouble: return 8;
				case S7NckConsts.S7WLString: return 16;
				default: return 0;
			}
		}

		#region Get/Set the bit at Pos.Bit
		public static bool GetBitAt(byte[] Buffer, int Pos, int Bit)
		{
			byte[] Mask = { 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80 };
			if (Bit < 0) Bit = 0;
			if (Bit > 7) Bit = 7;
			return (Buffer[Pos] & Mask[Bit]) != 0;
		}
		public static void SetBitAt(ref byte[] Buffer, int Pos, int Bit, bool Value)
		{
			byte[] Mask = { 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80 };
			if (Bit < 0) Bit = 0;
			if (Bit > 7) Bit = 7;

			if (Value)
				Buffer[Pos] = (byte)(Buffer[Pos] | Mask[Bit]);
			else
				Buffer[Pos] = (byte)(Buffer[Pos] & ~Mask[Bit]);
		}
		#endregion

		#region Get/Set 8 bit signed value (S7 SInt) -128..127
		public static int GetSIntAt(byte[] Buffer, int Pos)
		{
			int Value = Buffer[Pos];
			if (Value < 128)
				return Value;
			else
				return (int)(Value - 256);
		}
		public static void SetSIntAt(byte[] Buffer, int Pos, int Value)
		{
			if (Value < -128) Value = -128;
			if (Value > 127) Value = 127;
			Buffer[Pos] = (byte)Value;
		}
		#endregion

		#region Get/Set 16 bit signed value (S7 int) -32768..32767
		public static short GetIntAt(byte[] Buffer, int Pos)
		{
			return (short)((Buffer[Pos + 1] << 8) | Buffer[Pos]);
		}
		public static void SetIntAt(byte[] Buffer, int Pos, Int16 Value)
		{
			Buffer[Pos + 1] = (byte)(Value >> 8);
			Buffer[Pos] = (byte)(Value & 0x00FF);
		}
		#endregion

		#region Get/Set 32 bit signed value (S7 DInt) -2147483648..2147483647
		public static int GetDIntAt(byte[] Buffer, int Pos)
		{
			int Result;
			Result = Buffer[Pos + 3]; Result <<= 8;
			Result += Buffer[Pos + 2]; Result <<= 8;
			Result += Buffer[Pos + 1]; Result <<= 8;
			Result += Buffer[Pos];
			return Result;
		}
		public static void SetDIntAt(byte[] Buffer, int Pos, int Value)
		{
			Buffer[Pos] = (byte)(Value & 0xFF);
			Buffer[Pos + 1] = (byte)((Value >> 8) & 0xFF);
			Buffer[Pos + 2] = (byte)((Value >> 16) & 0xFF);
			Buffer[Pos + 3] = (byte)((Value >> 24) & 0xFF);
		}
		#endregion

		#region Get/Set 64 bit signed value (S7 LInt) -9223372036854775808..9223372036854775807
		public static Int64 GetLIntAt(byte[] Buffer, int Pos)
		{
			Int64 Result;
			Result = Buffer[Pos + 7]; Result <<= 8;
			Result += Buffer[Pos + 6]; Result <<= 8;
			Result += Buffer[Pos + 5]; Result <<= 8;
			Result += Buffer[Pos + 4]; Result <<= 8;
			Result += Buffer[Pos + 3]; Result <<= 8;
			Result += Buffer[Pos + 2]; Result <<= 8;
			Result += Buffer[Pos + 1]; Result <<= 8;
			Result += Buffer[Pos];
			return Result;
		}
		public static void SetLIntAt(byte[] Buffer, int Pos, Int64 Value)
		{
			Buffer[Pos] = (byte)(Value & 0xFF);
			Buffer[Pos + 1] = (byte)((Value >> 8) & 0xFF);
			Buffer[Pos + 2] = (byte)((Value >> 16) & 0xFF);
			Buffer[Pos + 3] = (byte)((Value >> 24) & 0xFF);
			Buffer[Pos + 4] = (byte)((Value >> 32) & 0xFF);
			Buffer[Pos + 5] = (byte)((Value >> 40) & 0xFF);
			Buffer[Pos + 6] = (byte)((Value >> 48) & 0xFF);
			Buffer[Pos + 7] = (byte)((Value >> 56) & 0xFF);
		}
		#endregion

		#region Get/Set 8 bit unsigned value (S7 USInt) 0..255
		public static byte GetUSIntAt(byte[] Buffer, int Pos)
		{
			return Buffer[Pos];
		}
		public static void SetUSIntAt(byte[] Buffer, int Pos, byte Value)
		{
			Buffer[Pos] = Value;
		}
		#endregion

		#region Get/Set 16 bit unsigned value (S7 UInt) 0..65535
		public static UInt16 GetUIntAt(byte[] Buffer, int Pos)
		{
			return (UInt16)((Buffer[Pos + 1] << 8) | Buffer[Pos]);
		}
		public static void SetUIntAt(byte[] Buffer, int Pos, UInt16 Value)
		{
			Buffer[Pos + 1] = (byte)(Value >> 8);
			Buffer[Pos] = (byte)(Value & 0x00FF);
		}
		#endregion

		#region Get/Set 32 bit unsigned value (S7 UDInt) 0..4294967296
		public static UInt32 GetUDIntAt(byte[] Buffer, int Pos)
		{
			UInt32 Result;
			Result = Buffer[Pos + 3]; Result <<= 8;
			Result |= Buffer[Pos + 2]; Result <<= 8;
			Result |= Buffer[Pos + 1]; Result <<= 8;
			Result |= Buffer[Pos];
			return Result;
		}
		public static void SetUDIntAt(byte[] Buffer, int Pos, UInt32 Value)
		{
			Buffer[Pos] = (byte)(Value & 0xFF);
			Buffer[Pos + 1] = (byte)((Value >> 8) & 0xFF);
			Buffer[Pos + 2] = (byte)((Value >> 16) & 0xFF);
			Buffer[Pos + 3] = (byte)((Value >> 24) & 0xFF);
		}
		#endregion

		#region Get/Set 64 bit unsigned value (S7 ULint) 0..18446744073709551616
		public static UInt64 GetULIntAt(byte[] Buffer, int Pos)
		{
			UInt64 Result;
			Result = Buffer[Pos + 7]; Result <<= 8;
			Result |= Buffer[Pos + 6]; Result <<= 8;
			Result |= Buffer[Pos + 5]; Result <<= 8;
			Result |= Buffer[Pos + 4]; Result <<= 8;
			Result |= Buffer[Pos + 3]; Result <<= 8;
			Result |= Buffer[Pos + 2]; Result <<= 8;
			Result |= Buffer[Pos + 1]; Result <<= 8;
			Result |= Buffer[Pos ];
			return Result;
		}
		public static void SetULintAt(byte[] Buffer, int Pos, UInt64 Value)
		{
			Buffer[Pos + 7] = (byte)(Value & 0xFF);
			Buffer[Pos + 6] = (byte)((Value >> 8) & 0xFF);
			Buffer[Pos + 5] = (byte)((Value >> 16) & 0xFF);
			Buffer[Pos + 4] = (byte)((Value >> 24) & 0xFF);
			Buffer[Pos + 3] = (byte)((Value >> 32) & 0xFF);
			Buffer[Pos + 2] = (byte)((Value >> 40) & 0xFF);
			Buffer[Pos + 1] = (byte)((Value >> 48) & 0xFF);
			Buffer[Pos] = (byte)((Value >> 56) & 0xFF);
		}
		#endregion

		#region Get/Set 8 bit word (S7 Byte) 16#00..16#FF
		public static byte GetByteAt(byte[] Buffer, int Pos)
		{
			return Buffer[Pos];
		}
		public static void SetByteAt(byte[] Buffer, int Pos, byte Value)
		{
			Buffer[Pos] = Value;
		}
		#endregion

		#region Get/Set 16 bit word (S7 Word) 16#0000..16#FFFF
		public static UInt16 GetWordAt(byte[] Buffer, int Pos)
		{
			return GetUIntAt(Buffer, Pos);
		}
		public static void SetWordAt(byte[] Buffer, int Pos, UInt16 Value)
		{
			SetUIntAt(Buffer, Pos, Value);
		}
		#endregion

		#region Get/Set 32 bit word (S7 DWord) 16#00000000..16#FFFFFFFF
		public static UInt32 GetDWordAt(byte[] Buffer, int Pos)
		{
			return GetUDIntAt(Buffer, Pos);
		}
		public static void SetDWordAt(byte[] Buffer, int Pos, UInt32 Value)
		{
			SetUDIntAt(Buffer, Pos, Value);
		}
		#endregion

		#region Get/Set 64 bit word (S7 LWord) 16#0000000000000000..16#FFFFFFFFFFFFFFFF
		public static UInt64 GetLWordAt(byte[] Buffer, int Pos)
		{

			return GetULIntAt(Buffer, Pos);
		}
		public static void SetLWordAt(byte[] Buffer, int Pos, UInt64 Value)
		{
			SetULintAt(Buffer, Pos, Value);
		}
		#endregion

		#region Get/Set 64 bit floating point number (S7 LReal) (Range of Double)
		public static Double GetLRealAt(byte[] Buffer, int Pos)
		{
			UInt64 Value = GetULIntAt(Buffer, Pos);			
			byte[] bytes = BitConverter.GetBytes(Value);
			return BitConverter.ToDouble(bytes, 0);
		}
		public static void SetLRealAt(byte[] Buffer, int Pos, Double Value)
		{
			byte[] FloatArray = BitConverter.GetBytes(Value);
			Buffer[Pos + 7] = FloatArray[7];
			Buffer[Pos + 6] = FloatArray[6];
			Buffer[Pos + 5] = FloatArray[5];
			Buffer[Pos + 4] = FloatArray[4];
			Buffer[Pos + 3] = FloatArray[3];
			Buffer[Pos + 2] = FloatArray[2];
			Buffer[Pos + 1] = FloatArray[1];
			Buffer[Pos] = FloatArray[0];
		}
		#endregion

		#region Get/Set String (Nck Octet String)
		public static string GetStringAt(byte[] Buffer, int Pos)
		{
			int size = 16;
			return Encoding.UTF8.GetString(Buffer, Pos, size);
		}

		public static void SetStringAt(byte[] Buffer, int Pos, string Value)
		{
			int size = Value.Length;
			Encoding.UTF8.GetBytes(Value, 0, size, Buffer, Pos);
		}

		#endregion



		
	}
	#endregion

	#endregion [S7 Nck]

	#endregion [S7 Sinumerik]







}