#region class ModbusProtocol

/// <summary>

/// Modbus Protocol informations.

/// </summary>

public class ModbusProtocol

{

public enum ProtocolType { ModbusTCP = 0, ModbusUDP = 1, ModbusRTU = 2};

public DateTime timeStamp;

public bool request;

public bool response;

public UInt16 transactionIdentifier;

public UInt16 protocolIdentifier;

public UInt16 length;

public byte unitIdentifier;

public byte functionCode;

public UInt16 startingAdress;

public UInt16 startingAddressRead;

public UInt16 startingAddressWrite;

public UInt16 quantity;

public UInt16 quantityRead;

public UInt16 quantityWrite;

public byte byteCount;

public byte exceptionCode;

public byte errorCode;

public UInt16[] receiveCoilValues;

public UInt16[] receiveRegisterValues;

public Int16[] sendRegisterValues;

public bool[] sendCoilValues;

public UInt16 crc;

}

#endregion

#region structs

struct NetworkConnectionParameter

{

public NetworkStream stream; //For TCP-Connection only

public Byte[] bytes;

public int portIn; //For UDP-Connection only

public IPAddress ipAddressIn; //For UDP-Connection only

}

#endregion

#region TCPHandler class

internal class TCPHandler

{

public delegate void DataChanged(object networkConnectionParameter);

public event DataChanged dataChanged;

public delegate void NumberOfClientsChanged();

public event NumberOfClientsChanged numberOfClientsChanged;

TcpListener server = null;

private List<Client> tcpClientLastRequestList = new List<Client>();

public int NumberOfConnectedClients { get; set; }

public string ipAddress = null;

public TCPHandler(int port)

{

IPAddress localAddr = IPAddress.Any;

server = new TcpListener(localAddr, port);

server.Start();

server.BeginAcceptTcpClient(AcceptTcpClientCallback, null);

}

public TCPHandler(string ipAddress, int port)

{

this.ipAddress = ipAddress;

IPAddress localAddr = IPAddress.Any;

server = new TcpListener(localAddr, port);

server.Start();

server.BeginAcceptTcpClient(AcceptTcpClientCallback, null);

}

private void AcceptTcpClientCallback(IAsyncResult asyncResult)

{

TcpClient tcpClient = new TcpClient();

try

{

tcpClient = server.EndAcceptTcpClient(asyncResult);

tcpClient.ReceiveTimeout = 4000;

if (ipAddress != null)

{

string ipEndpoint = tcpClient.Client.RemoteEndPoint.ToString();

ipEndpoint = ipEndpoint.Split(':')[0];

if (ipEndpoint != ipAddress)

{

tcpClient.Client.Disconnect(false);

return;

}

}

}

catch (Exception) { }

try

{

server.BeginAcceptTcpClient(AcceptTcpClientCallback, null);

Client client = new Client(tcpClient);

NetworkStream networkStream = client.NetworkStream;

networkStream.ReadTimeout = 4000;

networkStream.BeginRead(client.Buffer, 0, client.Buffer.Length, ReadCallback, client);

}

catch (Exception) { }

}

private int GetAndCleanNumberOfConnectedClients(Client client)

{

lock (this)

{

int i = 0;

bool objetExists = false;

foreach (Client clientLoop in tcpClientLastRequestList)

{

if (client.Equals(clientLoop))

objetExists = true;

}

try

{

tcpClientLastRequestList.RemoveAll(delegate (Client c)

{

return ((DateTime.Now.Ticks - c.Ticks) > 40000000);

}

);

}

catch (Exception) { }

if (!objetExists)

tcpClientLastRequestList.Add(client);

return tcpClientLastRequestList.Count;

}

}

private void ReadCallback(IAsyncResult asyncResult)

{

NetworkConnectionParameter networkConnectionParameter = new NetworkConnectionParameter();

Client client = asyncResult.AsyncState as Client;

client.Ticks = DateTime.Now.Ticks;

NumberOfConnectedClients = GetAndCleanNumberOfConnectedClients(client);

if (numberOfClientsChanged != null)

numberOfClientsChanged();

if (client != null)

{

int read;

NetworkStream networkStream = null;

try

{

networkStream = client.NetworkStream;

read = networkStream.EndRead(asyncResult);

}

catch (Exception ex)

{

return;

}

if (read == 0)

{

//OnClientDisconnected(client.TcpClient);

//connectedClients.Remove(client);

return;

}

byte[] data = new byte[read];

Buffer.BlockCopy(client.Buffer, 0, data, 0, read);

networkConnectionParameter.bytes = data;

networkConnectionParameter.stream = networkStream;

if (dataChanged != null)

dataChanged(networkConnectionParameter);

try

{

networkStream.BeginRead(client.Buffer, 0, client.Buffer.Length, ReadCallback, client);

}

catch (Exception)

{

}

}

}

public void Disconnect()

{

try

{

foreach (Client clientLoop in tcpClientLastRequestList)

{

clientLoop.NetworkStream.Close(00);

}

}

catch (Exception) { }

server.Stop();

}

internal class Client

{

private readonly TcpClient tcpClient;

private readonly byte[] buffer;

public long Ticks { get; set; }

public Client(TcpClient tcpClient)

{

this.tcpClient = tcpClient;

int bufferSize = tcpClient.ReceiveBufferSize;

buffer = new byte[bufferSize];

}

public TcpClient TcpClient

{

get { return tcpClient; }

}

public byte[] Buffer

{

get { return buffer; }

}

public NetworkStream NetworkStream

{

get {

return tcpClient.GetStream();

}

}

}

}

#endregion

/// <summary>

/// Modbus TCP Server.

/// </summary>

public class ModbusServer

{

private bool debug = false;

Int32 port = 502;

ModbusProtocol receiveData;

ModbusProtocol sendData = new ModbusProtocol();

Byte[] bytes = new Byte[2100];

//public Int16[] _holdingRegisters = new Int16[65535];

public HoldingRegisters holdingRegisters;

public InputRegisters inputRegisters;

public Coils coils;

public DiscreteInputs discreteInputs;

private int numberOfConnections = 0;

private bool udpFlag;

private bool serialFlag;

private int baudrate = 9600;

private System.IO.Ports.Parity parity = Parity.Even;

private System.IO.Ports.StopBits stopBits = StopBits.One;

private string serialPort = "COM1";

private SerialPort serialport;

private byte unitIdentifier = 1;

private int portIn;

private IPAddress ipAddressIn;

private UdpClient udpClient;

private IPEndPoint iPEndPoint;

private TCPHandler tcpHandler;

Thread listenerThread;

Thread clientConnectionThread;

private ModbusProtocol[] modbusLogData = new ModbusProtocol[100];

public bool FunctionCode1Disabled {get; set;}

public bool FunctionCode2Disabled { get; set; }

public bool FunctionCode3Disabled { get; set; }

public bool FunctionCode4Disabled { get; set; }

public bool FunctionCode5Disabled { get; set; }

public bool FunctionCode6Disabled { get; set; }

public bool FunctionCode15Disabled { get; set; }

public bool FunctionCode16Disabled { get; set; }

public bool FunctionCode23Disabled { get; set; }

public bool PortChanged { get; set; }

object lockCoils = new object();

object lockHoldingRegisters = new object();

internal object lockMQTT = new object();

private volatile bool shouldStop;

internal EasyModbus2Mqtt easyModbus2Mqtt = new EasyModbus2Mqtt();

public ModbusServer()

{

easyModbus2Mqtt.MqttRootTopic = "easymodbusserver";

easyModbus2Mqtt.RetainMessages = true;

holdingRegisters = new HoldingRegisters(this);

inputRegisters = new InputRegisters(this);

coils = new Coils(this);

discreteInputs = new DiscreteInputs(this);

easyModbus2Mqtt.MqttBrokerAddress = null;

}

#region events

public delegate void CoilsChanged(int coil, int numberOfCoils);

public event CoilsChanged coilsChanged;

public delegate void HoldingRegistersChanged(int register, int numberOfRegisters);

public event HoldingRegistersChanged holdingRegistersChanged;

public delegate void NumberOfConnectedClientsChanged();

public event NumberOfConnectedClientsChanged numberOfConnectedClientsChanged;

public delegate void LogDataChanged();

public event LogDataChanged logDataChanged;

#endregion

public void Listen()

{

listenerThread = new Thread(ListenerThread);

listenerThread.Start();

}

public void StopListening()

{

if (SerialFlag & (serialport != null))

{

if (serialport.IsOpen)

serialport.Close();

shouldStop = true;

}

try

{

tcpHandler.Disconnect();

listenerThread.Abort();

}

catch (Exception) { }

listenerThread.Join();

try

{

clientConnectionThread.Abort();

}

catch (Exception) { }

}

private void ListenerThread()

{

if (!udpFlag & !serialFlag)

{

if (udpClient != null)

{

try

{

udpClient.Close();

}

catch (Exception) { }

}

tcpHandler = new TCPHandler(port);

if (debug) StoreLogData.Instance.Store("EasyModbus Server listing for incomming data at Port " + port, System.DateTime.Now);

tcpHandler.dataChanged += new TCPHandler.DataChanged(ProcessReceivedData);

tcpHandler.numberOfClientsChanged += new TCPHandler.NumberOfClientsChanged(numberOfClientsChanged);

}

else if (serialFlag)

{

if (serialport == null)

{

if (debug) StoreLogData.Instance.Store("EasyModbus RTU-Server listing for incomming data at Serial Port " + serialPort, System.DateTime.Now);

serialport = new SerialPort();

serialport.PortName = serialPort;

serialport.BaudRate = this.baudrate;

serialport.Parity = this.parity;

serialport.StopBits = stopBits;

serialport.WriteTimeout = 10000;

serialport.ReadTimeout = 1000;

serialport.DataReceived += new SerialDataReceivedEventHandler(DataReceivedHandler);

serialport.Open();

}

}

else

while (!shouldStop)

{

if (udpFlag)

{

if (udpClient == null | PortChanged)

{

udpClient = new UdpClient(port);

if (debug) StoreLogData.Instance.Store("EasyModbus Server listing for incomming data at Port " + port, System.DateTime.Now);

udpClient.Client.ReceiveTimeout = 1000;

iPEndPoint = new IPEndPoint(IPAddress.Any, port);

PortChanged = false;

}

if (tcpHandler != null)

tcpHandler.Disconnect();

try

{

bytes = udpClient.Receive(ref iPEndPoint);

portIn = iPEndPoint.Port;

NetworkConnectionParameter networkConnectionParameter = new NetworkConnectionParameter();

networkConnectionParameter.bytes = bytes;

ipAddressIn = iPEndPoint.Address;

networkConnectionParameter.portIn = portIn;

networkConnectionParameter.ipAddressIn = ipAddressIn;

ParameterizedThreadStart pts = new ParameterizedThreadStart(this.ProcessReceivedData);

Thread processDataThread = new Thread(pts);

processDataThread.Start(networkConnectionParameter);

}

catch (Exception)

{

}

}

}

}

#region SerialHandler

private bool dataReceived = false;

private byte[] readBuffer = new byte[2094];

private DateTime lastReceive;

private int nextSign = 0;

private void DataReceivedHandler(object sender,

SerialDataReceivedEventArgs e)

{

int silence = 4000 / baudrate;

if ((DateTime.Now.Ticks - lastReceive.Ticks) > TimeSpan.TicksPerMillisecond*silence)

nextSign = 0;

SerialPort sp = (SerialPort)sender;

int numbytes = sp.BytesToRead;

byte[] rxbytearray = new byte[numbytes];

sp.Read(rxbytearray, 0, numbytes);

Array.Copy(rxbytearray, 0, readBuffer, nextSign, rxbytearray.Length);

lastReceive= DateTime.Now;

nextSign = numbytes+ nextSign;

if (ModbusClient.DetectValidModbusFrame(readBuffer, nextSign))

{

dataReceived = true;

nextSign= 0;

NetworkConnectionParameter networkConnectionParameter = new NetworkConnectionParameter();

networkConnectionParameter.bytes = readBuffer;

ParameterizedThreadStart pts = new ParameterizedThreadStart(this.ProcessReceivedData);

Thread processDataThread = new Thread(pts);

processDataThread.Start(networkConnectionParameter);

dataReceived = false;

}

else

dataReceived = false;

}

#endregion

#region Method numberOfClientsChanged

private void numberOfClientsChanged()

{

numberOfConnections = tcpHandler.NumberOfConnectedClients;

if (numberOfConnectedClientsChanged != null)

numberOfConnectedClientsChanged();

}

#endregion

object lockProcessReceivedData = new object();

#region Method ProcessReceivedData

private void ProcessReceivedData(object networkConnectionParameter)

{

lock (lockProcessReceivedData)

{

Byte[] bytes = new byte[((NetworkConnectionParameter)networkConnectionParameter).bytes.Length];

if (debug) StoreLogData.Instance.Store("Received Data: " + BitConverter.ToString(bytes), System.DateTime.Now);

NetworkStream stream = ((NetworkConnectionParameter)networkConnectionParameter).stream;

int portIn = ((NetworkConnectionParameter)networkConnectionParameter).portIn;

IPAddress ipAddressIn = ((NetworkConnectionParameter)networkConnectionParameter).ipAddressIn;

Array.Copy(((NetworkConnectionParameter)networkConnectionParameter).bytes, 0, bytes, 0, ((NetworkConnectionParameter)networkConnectionParameter).bytes.Length);

ModbusProtocol receiveDataThread = new ModbusProtocol();

ModbusProtocol sendDataThread = new ModbusProtocol();

try

{

UInt16[] wordData = new UInt16[1];

byte[] byteData = new byte[2];

receiveDataThread.timeStamp = DateTime.Now;

receiveDataThread.request = true;

if (!serialFlag)

{

//Lese Transaction identifier

byteData[1] = bytes[0];

byteData[0] = bytes[1];

Buffer.BlockCopy(byteData, 0, wordData, 0, 2);

receiveDataThread.transactionIdentifier = wordData[0];

//Lese Protocol identifier

byteData[1] = bytes[2];

byteData[0] = bytes[3];

Buffer.BlockCopy(byteData, 0, wordData, 0, 2);

receiveDataThread.protocolIdentifier = wordData[0];

//Lese length

byteData[1] = bytes[4];

byteData[0] = bytes[5];

Buffer.BlockCopy(byteData, 0, wordData, 0, 2);

receiveDataThread.length = wordData[0];

}

//Lese unit identifier

receiveDataThread.unitIdentifier = bytes[6 - 6 * Convert.ToInt32(serialFlag)];

//Check UnitIdentifier

if ((receiveDataThread.unitIdentifier != this.unitIdentifier) & (receiveDataThread.unitIdentifier != 0))

return;

// Lese function code

receiveDataThread.functionCode = bytes[7 - 6 * Convert.ToInt32(serialFlag)];

// Lese starting address

byteData[1] = bytes[8 - 6 * Convert.ToInt32(serialFlag)];

byteData[0] = bytes[9 - 6 * Convert.ToInt32(serialFlag)];

Buffer.BlockCopy(byteData, 0, wordData, 0, 2);

receiveDataThread.startingAdress = wordData[0];

if (receiveDataThread.functionCode <= 4)

{

// Lese quantity

byteData[1] = bytes[10 - 6 * Convert.ToInt32(serialFlag)];

byteData[0] = bytes[11 - 6 * Convert.ToInt32(serialFlag)];

Buffer.BlockCopy(byteData, 0, wordData, 0, 2);

receiveDataThread.quantity = wordData[0];

}

if (receiveDataThread.functionCode == 5)

{

receiveDataThread.receiveCoilValues = new ushort[1];

// Lese Value

byteData[1] = bytes[10 - 6 * Convert.ToInt32(serialFlag)];

byteData[0] = bytes[11 - 6 * Convert.ToInt32(serialFlag)];

Buffer.BlockCopy(byteData, 0, receiveDataThread.receiveCoilValues, 0, 2);

}

if (receiveDataThread.functionCode == 6)

{

receiveDataThread.receiveRegisterValues = new ushort[1];

// Lese Value

byteData[1] = bytes[10 - 6 * Convert.ToInt32(serialFlag)];

byteData[0] = bytes[11 - 6 * Convert.ToInt32(serialFlag)];

Buffer.BlockCopy(byteData, 0, receiveDataThread.receiveRegisterValues, 0, 2);

}

if (receiveDataThread.functionCode == 15)

{

// Lese quantity

byteData[1] = bytes[10 - 6 * Convert.ToInt32(serialFlag)];

byteData[0] = bytes[11 - 6 * Convert.ToInt32(serialFlag)];

Buffer.BlockCopy(byteData, 0, wordData, 0, 2);

receiveDataThread.quantity = wordData[0];

receiveDataThread.byteCount = bytes[12 - 6 * Convert.ToInt32(serialFlag)];

if ((receiveDataThread.byteCount % 2) != 0)

receiveDataThread.receiveCoilValues = new ushort[receiveDataThread.byteCount / 2 + 1];

else

receiveDataThread.receiveCoilValues = new ushort[receiveDataThread.byteCount / 2];

// Lese Value

Buffer.BlockCopy(bytes, 13 - 6 * Convert.ToInt32(serialFlag), receiveDataThread.receiveCoilValues, 0, receiveDataThread.byteCount);

}

if (receiveDataThread.functionCode == 16)

{

// Lese quantity

byteData[1] = bytes[10 - 6 * Convert.ToInt32(serialFlag)];

byteData[0] = bytes[11 - 6 * Convert.ToInt32(serialFlag)];

Buffer.BlockCopy(byteData, 0, wordData, 0, 2);

receiveDataThread.quantity = wordData[0];

receiveDataThread.byteCount = bytes[12 - 6 * Convert.ToInt32(serialFlag)];

receiveDataThread.receiveRegisterValues = new ushort[receiveDataThread.quantity];

for (int i = 0; i < receiveDataThread.quantity; i++)

{

// Lese Value

byteData[1] = bytes[13 + i * 2 - 6 * Convert.ToInt32(serialFlag)];

byteData[0] = bytes[14 + i * 2 - 6 * Convert.ToInt32(serialFlag)];

Buffer.BlockCopy(byteData, 0, receiveDataThread.receiveRegisterValues, i * 2, 2);

}

}

if (receiveDataThread.functionCode == 23)

{

// Lese starting Address Read

byteData[1] = bytes[8 - 6 * Convert.ToInt32(serialFlag)];

byteData[0] = bytes[9 - 6 * Convert.ToInt32(serialFlag)];

Buffer.BlockCopy(byteData, 0, wordData, 0, 2);

receiveDataThread.startingAddressRead = wordData[0];

// Lese quantity Read

byteData[1] = bytes[10 - 6 * Convert.ToInt32(serialFlag)];

byteData[0] = bytes[11 - 6 * Convert.ToInt32(serialFlag)];

Buffer.BlockCopy(byteData, 0, wordData, 0, 2);

receiveDataThread.quantityRead = wordData[0];

// Lese starting Address Write

byteData[1] = bytes[12 - 6 * Convert.ToInt32(serialFlag)];

byteData[0] = bytes[13 - 6 * Convert.ToInt32(serialFlag)];

Buffer.BlockCopy(byteData, 0, wordData, 0, 2);

receiveDataThread.startingAddressWrite = wordData[0];

// Lese quantity Write

byteData[1] = bytes[14 - 6 * Convert.ToInt32(serialFlag)];

byteData[0] = bytes[15 - 6 * Convert.ToInt32(serialFlag)];

Buffer.BlockCopy(byteData, 0, wordData, 0, 2);

receiveDataThread.quantityWrite = wordData[0];

receiveDataThread.byteCount = bytes[16 - 6 * Convert.ToInt32(serialFlag)];

receiveDataThread.receiveRegisterValues = new ushort[receiveDataThread.quantityWrite];

for (int i = 0; i < receiveDataThread.quantityWrite; i++)

{

// Lese Value

byteData[1] = bytes[17 + i * 2 - 6 * Convert.ToInt32(serialFlag)];

byteData[0] = bytes[18 + i * 2 - 6 * Convert.ToInt32(serialFlag)];

Buffer.BlockCopy(byteData, 0, receiveDataThread.receiveRegisterValues, i * 2, 2);

}

}

}

catch (Exception exc)

{ }

this.CreateAnswer(receiveDataThread, sendDataThread, stream, portIn, ipAddressIn);

//this.sendAnswer();

this.CreateLogData(receiveDataThread, sendDataThread);

if (logDataChanged != null)

logDataChanged();

}

}

#endregion

#region Method CreateAnswer

private void CreateAnswer(ModbusProtocol receiveData, ModbusProtocol sendData, NetworkStream stream, int portIn, IPAddress ipAddressIn)

{

switch (receiveData.functionCode)

{

// Read Coils

case 1:

if (!FunctionCode1Disabled)

this.ReadCoils(receiveData, sendData, stream, portIn, ipAddressIn);

else

{

sendData.errorCode = (byte)(receiveData.functionCode + 0x80);

sendData.exceptionCode = 1;

sendException(sendData.errorCode, sendData.exceptionCode, receiveData, sendData, stream, portIn, ipAddressIn);

}

break;

// Read Input Registers

case 2:

if (!FunctionCode2Disabled)

this.ReadDiscreteInputs(receiveData, sendData, stream, portIn, ipAddressIn);

else

{

sendData.errorCode = (byte)(receiveData.functionCode + 0x80);

sendData.exceptionCode = 1;

sendException(sendData.errorCode, sendData.exceptionCode, receiveData, sendData, stream, portIn, ipAddressIn);

}

break;

// Read Holding Registers

case 3:

if (!FunctionCode3Disabled)

this.ReadHoldingRegisters(receiveData, sendData, stream, portIn, ipAddressIn);

else

{

sendData.errorCode = (byte)(receiveData.functionCode + 0x80);

sendData.exceptionCode = 1;

sendException(sendData.errorCode, sendData.exceptionCode, receiveData, sendData, stream, portIn, ipAddressIn);

}

break;

// Read Input Registers

case 4:

if (!FunctionCode4Disabled)

this.ReadInputRegisters(receiveData, sendData, stream, portIn, ipAddressIn);

else

{

sendData.errorCode = (byte)(receiveData.functionCode + 0x80);

sendData.exceptionCode = 1;

sendException(sendData.errorCode, sendData.exceptionCode, receiveData, sendData, stream, portIn, ipAddressIn);

}

break;

// Write single coil

case 5:

if (!FunctionCode5Disabled)

this.WriteSingleCoil(receiveData, sendData, stream, portIn, ipAddressIn);

else

{

sendData.errorCode = (byte)(receiveData.functionCode + 0x80);

sendData.exceptionCode = 1;

sendException(sendData.errorCode, sendData.exceptionCode, receiveData, sendData, stream, portIn, ipAddressIn);

}

break;

// Write single register

case 6:

if (!FunctionCode6Disabled)

this.WriteSingleRegister(receiveData, sendData, stream, portIn, ipAddressIn);

else

{

sendData.errorCode = (byte)(receiveData.functionCode + 0x80);

sendData.exceptionCode = 1;

sendException(sendData.errorCode, sendData.exceptionCode, receiveData, sendData, stream, portIn, ipAddressIn);

}

break;

// Write Multiple coils

case 15:

if (!FunctionCode15Disabled)

this.WriteMultipleCoils(receiveData, sendData, stream, portIn, ipAddressIn);

else

{

sendData.errorCode = (byte)(receiveData.functionCode + 0x80);

sendData.exceptionCode = 1;

sendException(sendData.errorCode, sendData.exceptionCode, receiveData, sendData, stream, portIn, ipAddressIn);

}

break;

// Write Multiple registers

case 16:

if (!FunctionCode16Disabled)

this.WriteMultipleRegisters(receiveData, sendData, stream, portIn, ipAddressIn);

else

{

sendData.errorCode = (byte)(receiveData.functionCode + 0x80);

sendData.exceptionCode = 1;

sendException(sendData.errorCode, sendData.exceptionCode, receiveData, sendData, stream, portIn, ipAddressIn);

}

break;

// Error: Function Code not supported

case 23:

if (!FunctionCode23Disabled)

this.ReadWriteMultipleRegisters(receiveData, sendData, stream, portIn, ipAddressIn);

else

{

sendData.errorCode = (byte)(receiveData.functionCode + 0x80);

sendData.exceptionCode = 1;

sendException(sendData.errorCode, sendData.exceptionCode, receiveData, sendData, stream, portIn, ipAddressIn);

}

break;

// Error: Function Code not supported

default: sendData.errorCode = (byte) (receiveData.functionCode + 0x80);

sendData.exceptionCode = 1;

sendException(sendData.errorCode, sendData.exceptionCode, receiveData, sendData, stream, portIn, ipAddressIn);

break;

}

sendData.timeStamp = DateTime.Now;

}

#endregion

private void ReadCoils(ModbusProtocol receiveData, ModbusProtocol sendData, NetworkStream stream, int portIn, IPAddress ipAddressIn)

{

sendData.response = true;

sendData.transactionIdentifier = receiveData.transactionIdentifier;

sendData.protocolIdentifier = receiveData.protocolIdentifier;

sendData.unitIdentifier = this.unitIdentifier;

sendData.functionCode = receiveData.functionCode;

if ((receiveData.quantity < 1) | (receiveData.quantity > 0x07D0)) //Invalid quantity