private void WriteMultipleRegisters(ModbusTransferData modbusTransferData)
{
var data = modbusTransferData.Data;
var address = data.GetUint16(0);
var numOfRegistersToWrite = data.GetUint16(2);
var numOfBytes = data[4];
var registersData = new ushort[numOfRegistersToWrite];
Buffer.BlockCopy(data, 5, registersData, 0, numOfBytes);
for (int i = 0; i < numOfRegistersToWrite; i++)
{
HoldingRegisters[address + i] = registersData[i];
}
var newData = new byte[4];
Buffer.BlockCopy(modbusTransferData.Data, 2, newData, 0, newData.Length);
SendResponse(new ModbusTransferData(
modbusTransferData.DeviceAddress,
modbusTransferData.Command,
newData));
}
private void WriteMultipleCoils(ModbusTransferData modbusTransferData)
{
var data = modbusTransferData.Data;
var address = data.GetUint16(0);
var numOfCoilsToWrite = data.GetUint16(2);
var numOfBytes = data[4];
var coilsData = new byte[numOfBytes];
Buffer.BlockCopy(data, 5, coilsData, 0, coilsData.Length);
var bitArray = new BitArray(coilsData);
for (int i = 0; i < numOfCoilsToWrite; i++)
{
Coils[address + i] = bitArray[i];
}
var newData = new byte[4];
Buffer.BlockCopy(modbusTransferData.Data, 2, newData, 0, newData.Length);
SendResponse(new ModbusTransferData(
modbusTransferData.DeviceAddress,
modbusTransferData.Command,
newData));
}
private void WriteSingleRegister(ModbusTransferData modbusTransferData)
{
var data = modbusTransferData.Data;
var address = data.GetUint16(0);
var valueToWrite = data.GetUint16(2);
HoldingRegisters[address] = valueToWrite;
SendResponse(modbusTransferData);
}
public void SendAsSlave(ModbusTransferData transferData)
{
if (!_connected)
{
OnMastersDataReceived(transferData.EncodeTransferData(), 1);
}
else
{
_modbusSlavesClient.WriteLine(transferData.EncodeTransferData());
}
}
private void OnSlavesDataReceived(ModbusTransferData modbusTransferData)
{
if (modbusTransferData.DeviceAddress == 0)
{
OnDataReceived(modbusTransferData);
}
if (modbusTransferData.DeviceAddress == _slaveModuleProcess.Identifier)
{
OnDataReceived(modbusTransferData);
}
}
public void SendAsMaster(ModbusTransferData transferData, byte masterIdentifier)
{
_logger.WriteDebug("-------------------------------------------------------------------");
if (!_connected)
{
OnSlavesDataReceived(transferData.EncodeTransferData());
}
else
{
_modbusMasterClients[masterIdentifier].WriteLine(transferData.EncodeTransferData());
}
}
private void OnMastersDataReceived(ModbusTransferData modbusTransferData, byte masterIdentifier)
{
if (modbusTransferData.DeviceAddress != 0)
{
return;
}
if (masterIdentifier != MasterModuleProcess.Identifier)
{
return;
}
OnDataReceived(modbusTransferData);
}
private void ReadHoldingOrInputRegisters(ModbusTransferData modbusTransferData, ushort[] holdingOrInput)
{
var data = modbusTransferData.Data;
var startAddress = data.GetUint16(0);
var numOfHoldingOrInputRegistersToRead = data.GetUint16(2);
var newData = new ushort[numOfHoldingOrInputRegistersToRead];
Array.Copy(holdingOrInput, startAddress, newData, 0, numOfHoldingOrInputRegistersToRead);
SendReadHoldingOrInputRegisterResponse(
modbusTransferData.Command,
newData);
}
private void ReadCoilsOrInputs(ModbusTransferData modbusTransferData, BitArray coilsOrInputs)
{
var data = modbusTransferData.Data;
var startAddress = data.GetUint16(0);
var numOfCoilsOrInputsToRead = data.GetUint16(2);
var bitArray = coilsOrInputs.Get(
startAddress,
numOfCoilsOrInputsToRead);
SendReadCoilsOrInputsResponse(
modbusTransferData.Command,
bitArray);
}
private void OnSlavesDataReceived(string data)
{
_logger.WriteDebug(String.Format("Slaves data received: {0}", data.Trim()));
ModbusTransferData decodedMessage;
try {
decodedMessage = new ModbusTransferData(data);
} catch (ArgumentException) {
_logger.WriteDebug("!ERROR! Problems during decoding.");
return;
}
_logger.WriteDebug(String.Format("Decoded as: {0}", decodedMessage));
if (SlavesDataReceived != null)
{
SlavesDataReceived(decodedMessage);
}
}
private void OnDataReceived(ModbusTransferData modbusTransferData)
{
switch (modbusTransferData.Command)
{
case ModbusCommand.ReadCoils:
ReadCoilsOrInputs(modbusTransferData, Coils);
break;
case ModbusCommand.ReadInputs:
ReadCoilsOrInputs(modbusTransferData, Inputs);
break;
case ModbusCommand.ReadHoldingRegisters:
ReadHoldingOrInputRegisters(modbusTransferData, HoldingRegisters);
break;
case ModbusCommand.ReadInputRegisters:
ReadHoldingOrInputRegisters(modbusTransferData, InputRegisters);
break;
case ModbusCommand.WriteSingleCoil:
WriteSingleCoil(modbusTransferData);
break;
case ModbusCommand.WriteSingleRegister:
WriteSingleRegister(modbusTransferData);
break;
case ModbusCommand.WriteMultipleCoils:
WriteMultipleCoils(modbusTransferData);
break;
case ModbusCommand.WriteMultipleRegisters:
WriteMultipleRegisters(modbusTransferData);
break;
default:
throw new ArgumentOutOfRangeException();
}
}
private void WriteSingleCoil(ModbusTransferData modbusTransferData)
{
var data = modbusTransferData.Data;
var address = data.GetUint16(0);
var booleanData = data.GetUint16(2);
switch (booleanData)
{
case 0xFF00:
Coils[address] = true;
break;
case 0x0000:
Coils[address] = false;
break;
default:
throw new IndexOutOfRangeException();
}
SendResponse(modbusTransferData);
}
private void SendResponse(ModbusTransferData modbusTransferData)
{
_modbusTransferManager.SendAsSlave(modbusTransferData);
}
protected override void OnDataReceived(ModbusTransferData modbusTransferData)
{
LastResponse = modbusTransferData.ToString();
}
protected abstract void OnDataReceived(ModbusTransferData modbusTransferData);
