public static void SharedSlaveTest(ModbusModel model, ModbusMaster master)
{
master.WriteCoil(1, 2, true);
Assert.AreEqual(true, master.ReadCoil(1, 2));
master.WriteCoil(1, 3, false);
Assert.AreEqual(false, master.ReadCoil(1, 3));
master.WriteCoils(1, 4, H.bo(false, true));
Assert.AreEqual(H.bo(true, false, false, true), master.ReadCoils(1, 2, 4));
//race condition avoided by access order
model.setDIs(11, 12, H.bo(true, true, false, false));
Assert.AreEqual(true, master.ReadInput(11, 12));
Assert.AreEqual(true, master.ReadInput(11, 13));
Assert.AreEqual(false, master.ReadInput(11, 14));
Assert.AreEqual(false, master.ReadInput(11, 15));
Assert.AreEqual(H.bo(true, true, false, false), master.ReadInputs(11, 12, 4));
master.WriteRegister(1, 2, 0xabcd);
Assert.AreEqual(0xabcd, master.ReadHoldingRegister(1, 2));
master.WriteRegister(1, 3, 0xcdab);
Assert.AreEqual(0xcdab, master.ReadHoldingRegister(1, 3));
master.WriteRegisters(1, 4, H.us(0xcda1, 0xcda2));
Assert.AreEqual(H.us(0xabcd, 0xcdab, 0xcda1, 0xcda2), master.ReadHoldingRegisters(1, 2, 4));
//race condition avoided by access order
model.setWIs(11, 12, H.us(0xabcd, 0xcdab, 0xcda1, 0xcda2));
Assert.AreEqual(0xabcd, master.ReadInputRegister(11, 12));
Assert.AreEqual(0xcdab, master.ReadInputRegister(11, 13));
Assert.AreEqual(0xcda1, master.ReadInputRegister(11, 14));
Assert.AreEqual(0xcda2, master.ReadInputRegister(11, 15));
Assert.AreEqual(H.us(0xabcd, 0xcdab, 0xcda1, 0xcda2), master.ReadInputRegisters(11, 12, 4));
}
private void testMaster(ModbusMaster master)
{
for (var i = 0; i < 4; i++)
{
master.WriteCoil(1, us(3000 + i), false);
Thread.Sleep(50);
Assert.AreEqual(false, master.ReadCoil(1, us(3000 + i)));
master.WriteCoil(1, us(3000 + i), true);
Thread.Sleep(50);
Assert.AreEqual(true, master.ReadCoil(1, us(3000 + i)));
}
var s0 = bs(false, false, false, false);
var s1 = bs(false, true, true, false);
var s2 = bs(true, false, false, true);
master.WriteCoils(1, 3000, s1);
Thread.Sleep(50);
Assert.AreEqual(s1, master.ReadCoils(1, 3000, 4));
Thread.Sleep(50);
master.WriteCoils(1, 3000, s2);
Thread.Sleep(50);
Assert.AreEqual(s2, master.ReadCoils(1, 3000, 4));
Thread.Sleep(50);
master.WriteCoils(1, 3000, s0);
Thread.Sleep(50);
Assert.AreEqual(s0, master.ReadCoils(1, 3000, 4));
}
public void Dispose()
{
if (_poll != null)
{
_poll.Stop();
_poll = null;
}
if (_client != null)
{
_client.Disconnect();
_client = null;
}
if (_master != null)
{
_master.DisconnectAllDevices();
_master = null;
}
if (_slave != null)
{
_slave.Terminate();
_slave = null;
}
Task.Delay(1000).Wait();
}
static void Main(string[] args)
{
var logger = new ConsoleModbusLogger();
var modbusMaster = new ModbusMaster
{
Channel = new TcpClientModbusChannel("127.0.0.1", 502, 1000)
//Channel = new UdpClientModbusChannel("127.0.0.1", 502)
{
Logger = logger
},
//Serializer = new ModbusRtuSerializer(),
Serializer = new ModbusTcpSerializer(),
//Serializer = new ModbusAsciiSerializer(),
Logger = logger,
};
while (true)
{
Thread.Sleep(1000);
try
{
var request = new ModbusReadRequest(1, ModbusObjectType.InputRegister, 100, 2);
var resposne = modbusMaster.Request(request, 1000);
Console.WriteLine((resposne as ModbusReadRegisterResponse).GetSingle(100));
}
catch
{
}
}
}
public ModbusCollectDevice(ITransport transport, byte host, MBFunction function)
{
if (transport == null)
{
throw new ArgumentNullException(nameof(transport));
}
if (base.Transport == null)
{
base.Transport = transport;
}
if (_master == null)
{
_master = new ModbusMaster
{
Transport = base.Transport,
Host = host
#if DEBUG
,
EnableDebug = true
#endif
};
}
this.Host = host;
this.Function = function;
Registers = new List <int>();
Values = new List <ushort>();
}
private void checkSampleCompiles()
{
var settings = new SerialSettings()
{
PortName = "COM3",
BaudRate = 57600,
};
//Modbus RTU over serial
using (var master = ModbusMaster.RTU(settings))
{
master.WriteCoil(1, 3000, false);
master.WriteCoils(1, 3001, false, true);
}
//Modbus RTU over isolated serial
using (var master = ModbusMaster.IsolatedRTU(settings))
{
master.WriteCoil(1, 3000, false);
master.WriteCoils(1, 3001, false, true);
}
//Modbus TCP over socket
using (var master = ModbusMaster.TCP("10.77.0.2", 502))
{
master.WriteCoils(1, 4, false, true);
}
}
public static ModbusMaster CreateSerialMaster(SerialPort port, SerialModBusMode type)
{
ModbusMaster master = null;
if (port != null)
{
if (!port.IsOpen)
{
port.Open();
}
switch (type)
{
case SerialModBusMode.Rtu:
master = ModbusSerialMaster.CreateRtu(port);
break;
case SerialModBusMode.Ascii:
master = ModbusSerialMaster.CreateRtu(port);
break;
default:
break;
}
}
return(master);
}
private bool ConnectModbusSerial()
{
if (master != null)
{
master.Dispose();
}
if (serialPort != null)
{
serialPort.Close();
}
serialPort = new SerialPort();
serialPort.PortName = "COM6";
serialPort.BaudRate = 38400;
serialPort.DataBits = 8;
serialPort.Handshake = Handshake.None;
serialPort.Parity = Parity.None;
serialPort.StopBits = StopBits.One;
try
{
serialPort.Open();
master = ModbusSerialMaster.CreateRtu(serialPort);
master.Transport.Retries = 0;
master.Transport.ReadTimeout = 300;
Console.WriteLine("Connected to ModbusRTU");
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
}
return(serialPort.IsOpen);
}
public ModbusControlDevice(ITransport transport, byte host)
{
if (transport == null)
{
throw new ArgumentNullException(nameof(transport));
}
if (base.Transport == null)
{
base.Transport = transport;
}
if (_master == null)
{
_master = new ModbusMaster
{
Transport = base.Transport,
Host = host
#if DEBUG
,
EnableDebug = true
#endif
};
}
this.Host = host;
Registers = new List <int>();
Values = new List <bool>();
}
//Opto22 32-bit IEEE float. Data is in Big Endian format
private void SetAnalog(ModbusMaster master, int point, float value)
{
var bytes = FloatToByteArray(value);
master.WriteRegister(1, (ushort)(2 * point + 0), (ushort)(bytes[0] << 8 | bytes[1]));
master.WriteRegister(1, (ushort)(2 * point + 1), (ushort)(bytes[2] << 8 | bytes[3]));
}
void Test(ModbusModel model, ModbusMaster master)
{
master.WriteCoil(1, 2, true);
Assert.AreEqual(true, master.ReadCoil(1, 2));
master.WriteCoil(1, 3, false);
Assert.AreEqual(false, master.ReadCoil(1, 3));
master.WriteCoils(1, 4, bo(false, true));
Assert.AreEqual(bo(true, false, false, true), master.ReadCoils(1, 2, 4));
model.setDIs(11, 12, bo(true, true, false, false));
Assert.AreEqual(true, master.ReadInput(11, 12));
Assert.AreEqual(true, master.ReadInput(11, 13));
Assert.AreEqual(false, master.ReadInput(11, 14));
Assert.AreEqual(false, master.ReadInput(11, 15));
Assert.AreEqual(bo(true, true, false, false), master.ReadInputs(11, 12, 4));
master.WriteRegister(1, 2, 0xabcd);
Assert.AreEqual(0xabcd, master.ReadHoldingRegister(1, 2));
master.WriteRegister(1, 3, 0xcdab);
Assert.AreEqual(0xcdab, master.ReadHoldingRegister(1, 3));
master.WriteRegisters(1, 4, us(0xcda1, 0xcda2));
Assert.AreEqual(us(0xabcd, 0xcdab, 0xcda1, 0xcda2), master.ReadHoldingRegisters(1, 2, 4));
model.setWIs(11, 12, us(0xabcd, 0xcdab, 0xcda1, 0xcda2));
Assert.AreEqual(0xabcd, master.ReadInputRegister(11, 12));
Assert.AreEqual(0xcdab, master.ReadInputRegister(11, 13));
Assert.AreEqual(0xcda1, master.ReadInputRegister(11, 14));
Assert.AreEqual(0xcda2, master.ReadInputRegister(11, 15));
Assert.AreEqual(us(0xabcd, 0xcdab, 0xcda1, 0xcda2), master.ReadInputRegisters(11, 12, 4));
}
private void IoSetMaster(ModbusMaster current)
{
master = current;
foreach (var control in controls)
{
control.SetMaster(current);
}
}
public void TcpSlaveTest()
{
var model = new ModbusModel();
var stream = new ModelStream(model, new ModbusTCPScanner());
var master = new ModbusMaster(stream, new ModbusTCPProtocol());
Test(model, master);
}
private void InitMaster()
{
Master = ModbusSerialMaster.CreateRtu(MSerialPort);
Master.Transport.Retries = 0;
Master.Transport.WaitToRetryMilliseconds = 100;
Master.Transport.ReadTimeout = 100;
Master.Transport.WriteTimeout = 100;
}
public void RtuTest()
{
var model = new ModbusModel();
var stream = new StreamModel(model, new ModbusRTUScanner());
var master = new ModbusMaster(stream, new ModbusRTUProtocol());
H.SharedSlaveTest(model, master);
}
public void SetMaster(ModbusMaster master)
{
context.Master = master;
var enabled = (master != null);
context.uiRunner.Run(() => {
buttonWrite.Enabled = enabled;
});
}
/// <summary>
/// Write a single 16 bit holding register.
/// </summary>
/// <param name="master">The Modbus master.</param>
/// <param name="slaveAddress">Address of the device to write to.</param>
/// <param name="registerAddress">Address to write.</param>
/// <param name="value">Value to write.</param>
public static void WriteSingleRegister32(this ModbusMaster master, byte slaveAddress, ushort registerAddress, uint value)
{
if (master == null)
{
throw new ArgumentNullException("master");
}
master.WriteMultipleRegisters32(slaveAddress, registerAddress, new[] { value });
}
private void SetAnalog2(ModbusMaster master, int point, float value)
{
var bytes = FloatToByteArray(value);
master.WriteRegisters(1, (ushort)(2 * point), new ushort[] {
(ushort)(bytes[0] << 8 | bytes[1]),
(ushort)(bytes[2] << 8 | bytes[3])
});
}
public async Task WriteMultipleRegistersAsyncThrowsOnNullData()
{
// Arrange
var target = new ModbusMaster(new Mock <IModbusTransport>().Object);
// Act/Assert
await Assert.ThrowsAsync <ArgumentNullException>(
"data",
async() => await target.WriteMultipleRegistersAsync(1, 0, null));
}
private void ConnectMasterAndSlave()
{
_slave = new ModbusSlave("Test", _source, _port, 1);
_slave.Start();
_master = new ModbusMaster();
_client = _master.ConnectDevice("localhost", _port, 1);
AssertWait.Max(2000, () => _client.IsConnected);
}
public static ModbusMaster CreateTcpMaster(TcpClient client)
{
ModbusMaster master = null;
if (client != null)
{
master = ModbusIpMaster.CreateIp(client);
}
return(master);
}
public static ModbusTransport Config(ModbusMaster master)
{
var ts = master.Transport;
ts.ReadTimeout = 0;
ts.Retries = 1;
ts.WriteTimeout = 0;
ts.WaitToRetryMilliseconds = 0;
return(null);
}
public async Task WriteMultipleRegistersAsyncThrowsOnInvalidData(ushort numberOfPoints)
{
// Arrange
var target = new ModbusMaster(new Mock <IModbusTransport>().Object);
// Act/Assert
await Assert.ThrowsAsync <ArgumentOutOfRangeException>(
"data",
async() => await target.WriteMultipleRegistersAsync(1, 0, Enumerable.Repeat((ushort)1, numberOfPoints).ToArray()));
}
public void TcpExceptionTest()
{
var model = new ModbusModel();
var stream = new StreamModel(model, new ModbusTCPScanner());
var master = new ModbusMaster(stream, new ModbusTCPProtocol());
var ex = Assert.Throws <ModbusException>(() => H.SharedExceptionTest(master));
Assert.AreEqual("Modbus exception 2", ex.Message);
Assert.AreEqual(2, ex.Code);
}
public async Task ReadInputRegistersAsyncThrowsOnInvalidNumberOfPoints(ushort numOfPoints)
{
// Arrange
var target = new ModbusMaster(new Mock <IModbusTransport>().Object);
// Act/Assert
await Assert.ThrowsAsync <ArgumentOutOfRangeException>(
"numberOfPoints",
() => target.ReadInputRegistersAsync(1, 0, numOfPoints));
}
private float GetAnalog2(ModbusMaster master, int point)
{
var words = master.ReadHoldingRegisters(1, (ushort)(2 * point), 2);
var bytes = new byte[4];
bytes[0] = (byte)((words[0] >> 8) & 0xff);
bytes[1] = (byte)((words[0] >> 0) & 0xff);
bytes[2] = (byte)((words[1] >> 8) & 0xff);
bytes[3] = (byte)((words[1] >> 0) & 0xff);
return(ByteArrayToFloat(bytes));
}
public void Close()
{
Io(() => {
if (master != null)
{
LogDuration();
}
Disposer.Dispose(master);
master = null;
Ui(() => { connected(false, true); });
});
}
public void RtuOverIsolatedTest()
{
var model = new ModbusModel();
var scanner = new ModbusRTUScanner();
using (var server = new SerialModel(SlaveCOM, model, scanner))
using (var master = ModbusMaster.IsolatedRTU(new SerialSettings(MasterCOM)))
{
//race condition avoided by access order
H.SharedSlaveTest(model, master);
}
}
/// <summary>
/// Read contiguous block of 32 bit input registers.
/// </summary>
/// <param name="master">The Modbus master.</param>
/// <param name="slaveAddress">Address of device to read values from.</param>
/// <param name="startAddress">Address to begin reading.</param>
/// <param name="numberOfPoints">Number of holding registers to read.</param>
/// <returns>Input registers status</returns>
public static uint[] ReadInputRegisters32(this ModbusMaster master, byte slaveAddress, ushort startAddress, ushort numberOfPoints)
{
if (master == null)
{
throw new ArgumentNullException("master");
}
ValidateNumberOfPoints(numberOfPoints, 62);
var rawRegisters = master.ReadInputRegisters(slaveAddress, startAddress, (ushort)(numberOfPoints * 2));
return(Convert(rawRegisters).ToArray());
}
public void TcpOverSocketTest()
{
var model = new ModbusModel();
var scanner = new ModbusTCPScanner();
using (var server = new TcpServerModel(model, scanner))
using (var master = ModbusMaster.TCP(IPAddress.Loopback.ToString(), server.Port))
{
//race condition avoided by access order
H.SharedSlaveTest(model, master);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="RtuSerialModbusMaster" /> class.
/// </summary>
/// <param name="mediaAbstractAdapter">The media abstract adapter.</param>
public RtuSerialModbusMaster(MediaAbstractAdapter<SerialPort> mediaAbstractAdapter)
{
this.modbus = ModbusSerialMaster.CreateRtu(mediaAbstractAdapter.Media);
}
