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); }