/// <summary> /// Simple Modbus serial RTU slave example. /// </summary> public static void StartModbusSerialRtuSlave() { using (SerialPort slavePort = new SerialPort("COM2")) { // configure serial port slavePort.BaudRate = 9600; slavePort.DataBits = 8; slavePort.Parity = Parity.None; slavePort.StopBits = StopBits.One; slavePort.Open(); var adapter = new SerialPortAdapter(slavePort); var factory = new ModbusFactory(); // create modbus slave var slaveNetwork = factory.CreateRtuSlaveNetwork(adapter); IModbusSlave slave1 = factory.CreateSlave(1); IModbusSlave slave2 = factory.CreateSlave(2); slaveNetwork.AddSlave(slave1); slaveNetwork.AddSlave(slave2); slaveNetwork.ListenAsync().GetAwaiter().GetResult(); } }
/// <summary> /// 写线圈 /// </summary> /// <param name="slaveAddress">从站地址</param> /// <param name="registerAddress">寄存器地址</param> /// <param name="value">数据</param> public void WriteCoil(byte slaveAddress, ushort registerAddress, bool value) { using (SerialPort port = new SerialPort(SerialPortName)) { //配置串口 port.BaudRate = BaudRate; port.DataBits = 8; port.Parity = Parity.Even; port.StopBits = StopBits.One; port.Open(); //创建Modbus主机 var adapter = new SerialPortAdapter(port); adapter.ReadTimeout = ReadTimeout; adapter.WriteTimeout = WriteTimeout; var factory = new ModbusFactory(); IModbusMaster master = factory.CreateRtuMaster(adapter); lock (_modbusLock) { //写到寄存器 master.WriteSingleCoil(slaveAddress, registerAddress, value); } } }
static void Main(string[] args) { int port = 502; var address = new IPAddress(new byte[] { 127, 0, 0, 1 }); var factory = new ModbusFactory(); using (var serialPort = new SerialPort("COM1")) { var adapter = new SerialPortAdapter(serialPort); var master = factory.CreateRtuMaster(adapter); var slaveTcpListener = new TcpListener(address, port); slaveTcpListener.Start(); var tcpNetwork = factory.CreateSlaveNetwork(slaveTcpListener); var proxy1 = factory.CreateSlaveProxy(1, master); var proxy2 = factory.CreateSlaveProxy(2, master); tcpNetwork.AddSlave(proxy1); tcpNetwork.AddSlave(proxy2); var tcpClient = new TcpClient(address.ToString(), port); var secondMaster = factory.CreateMaster(tcpClient); ushort[] holdingRegs = secondMaster.ReadHoldingRegisters(1, 1, 2); } }
static void Main(string[] args) { using (SerialPort slavePort = new SerialPort("COM2")) { // configure serial port slavePort.BaudRate = 19200; slavePort.DataBits = 8; slavePort.Parity = Parity.None; slavePort.Open(); slavePort.StopBits = StopBits.One; byte unitId = 1; var adapter = new SerialPortAdapter(slavePort); // create modbus slave ModbusLib.Device.ModbusSlave slave = ModbusSerialSlave.CreateRtu(unitId, adapter); slave.DataStore = DataStoreFactory.CreateDefaultDataStore(); for (int i = 1; i < 21; i++) { slave.DataStore.HoldingRegisters[i] = (ushort)i; slave.DataStore.InputRegisters[i] = (ushort)i; } slave.DataStore.CoilDiscretes[1] = true; slave.DataStore.CoilDiscretes[8] = true; slave.DataStore.CoilDiscretes[9] = true; slave.ListenAsync().GetAwaiter().GetResult(); } }
public static async Task SendStart(SerialPort port, ushort address, int value) { var adapter = new SerialPortAdapter(port); // create modbus master var factory = new ModbusFactory(); IModbusMaster master = factory.CreateRtuMaster(adapter); byte slaveId = 1; ushort[] result = new ushort[] { BitConverter.ToUInt16(BitConverter.GetBytes(value), 0), BitConverter.ToUInt16(BitConverter.GetBytes(value), 2) }; // write three registers await master.WriteMultipleRegistersAsync(slaveId, address, result); // 写入距离二 await master.WriteSingleCoilAsync(slaveId, 2054, true); await master.WriteSingleCoilAsync(slaveId, 2054, false); // 启动 await master.WriteSingleCoilAsync(slaveId, 2078, true); // read registers //var x = await master.ReadHoldingRegistersAsync(slaveId, address, 2); //System.Diagnostics.Debug.WriteLine(BitConverter.ToInt32(BitConverter.GetBytes(x[0]).Concat(BitConverter.GetBytes(x[1])).ToArray(), 0)); }
/// <summary> /// Write a 32 bit value. /// </summary> public static void ReadWrite32BitValue() { using (SerialPort port = new SerialPort("COM1")) { // configure serial port port.BaudRate = 9600; port.DataBits = 8; port.Parity = Parity.None; port.StopBits = StopBits.One; port.Open(); var factory = new ModbusFactory(); var adapter = new SerialPortAdapter(port); IModbusRtuTransport transport = factory.CreateRtuTransport(adapter); // create modbus master IModbusSerialMaster master = factory.CreateMaster(transport); byte slaveId = 1; ushort startAddress = 1008; uint largeValue = UInt16.MaxValue + 5; ushort lowOrderValue = BitConverter.ToUInt16(BitConverter.GetBytes(largeValue), 0); ushort highOrderValue = BitConverter.ToUInt16(BitConverter.GetBytes(largeValue), 2); // write large value in two 16 bit chunks master.WriteMultipleRegisters(slaveId, startAddress, new ushort[] { lowOrderValue, highOrderValue }); // read large value in two 16 bit chunks and perform conversion ushort[] registers = master.ReadHoldingRegisters(slaveId, startAddress, 2); uint value = ModbusUtility.GetUInt32(registers[1], registers[0]); } }
/// <summary> /// 读多个寄存器 /// </summary> /// <param name="slaveAddress">从站地址</param> /// <param name="registerAddress">寄存器地址</param> /// <param name="value">数据</param> private void ModbusSerialRtuMasterReadRegister(byte slaveAddress, ushort registerAddress, ushort numberOfPoints, out ushort[] data) { data = null; using (SerialPort port = new SerialPort(PrimarySerialPortName)) { //配置串口 port.BaudRate = SerialPortBaudRate; port.DataBits = 8; port.Parity = Parity.None; port.StopBits = StopBits.One; port.Open(); //创建Modbus主机 var adapter = new SerialPortAdapter(port); adapter.ReadTimeout = ReadTimeout; adapter.WriteTimeout = WriteTimeout; var factory = new ModbusFactory(); IModbusMaster master = factory.CreateRtuMaster(adapter); lock (powerLock) { //读寄存器 data = master.ReadHoldingRegisters(slaveAddress, registerAddress, numberOfPoints); } } }
public static void StartModbusSerialRtuSlaveWithCustomStore() { using (SerialPort slavePort = new SerialPort("COM2")) { // configure serial port slavePort.BaudRate = 9600; slavePort.DataBits = 8; slavePort.Parity = Parity.None; slavePort.StopBits = StopBits.One; slavePort.Open(); var adapter = new SerialPortAdapter(slavePort); var factory = new ModbusFactory(); // create modbus slave var slaveNetwork = factory.CreateRtuSlaveNetwork(adapter); var dataStore = new SlaveStorage(); dataStore.CoilDiscretes.StorageOperationOccurred += (sender, args) => Console.WriteLine($"Coil discretes: {args.Operation} starting at {args.StartingAddress}"); dataStore.CoilInputs.StorageOperationOccurred += (sender, args) => Console.WriteLine($"Coil inputs: {args.Operation} starting at {args.StartingAddress}"); dataStore.InputRegisters.StorageOperationOccurred += (sender, args) => Console.WriteLine($"Input registers: {args.Operation} starting at {args.StartingAddress}"); dataStore.HoldingRegisters.StorageOperationOccurred += (sender, args) => Console.WriteLine($"Holding registers: {args.Operation} starting at {args.StartingAddress}"); IModbusSlave slave1 = factory.CreateSlave(1, dataStore); slaveNetwork.AddSlave(slave1); slaveNetwork.ListenAsync().GetAwaiter().GetResult(); } }
/// <summary> /// 读单个寄存器 /// </summary> /// <param name="slaveAddress">从站地址</param> /// <param name="registerAddress">寄存器地址</param> /// <param name="value">数据</param> private void ModbusSerialRtuMasterReadRegister(byte slaveAddress, ushort registerAddress, out ushort value) { value = 0xFFFF; using (SerialPort port = new SerialPort(PrimarySerialPortName)) { //配置串口 port.BaudRate = SerialPortBaudRate; port.DataBits = 8; port.Parity = Parity.None; port.StopBits = StopBits.One; port.Open(); //创建Modbus主机 var adapter = new SerialPortAdapter(port); adapter.ReadTimeout = ReadTimeout; adapter.WriteTimeout = WriteTimeout; var factory = new ModbusFactory(); IModbusMaster master = factory.CreateRtuMaster(adapter); lock (powerLock) { //读寄存器 var values = master.ReadHoldingRegisters(slaveAddress, registerAddress, 1); if (values?.Length >= 1) { value = values[0]; } } } }
/// <summary> /// Simple Modbus serial RTU slave example. /// </summary> public async void StartModbusSerialRtuSlave() { using (SerialDevice slavePort = await SerialDevice.FromIdAsync("COM2")) { // configure serial port slavePort.BaudRate = 9600; slavePort.DataBits = 8; slavePort.Parity = SerialParity.None; slavePort.StopBits = SerialStopBitCount.One; byte unitId = 1; var adapter = new SerialPortAdapter(slavePort); // create modbus slave ModbusSlave slave = ModbusSerialSlave.CreateRtu(unitId, adapter); slave.DataStore = DataStoreFactory.CreateDefaultDataStore(); slave.ListenAsync().GetAwaiter().GetResult(); } }
/// <summary> /// 读取线圈 /// </summary> /// <param name="slaveAddress">从站地址</param> /// <param name="registerAddress">寄存器地址</param> /// <param name="value">数据</param> public void ReadCoil(byte slaveAddress, ushort registerAddress, out bool value) { value = false; using (SerialPort port = new SerialPort(SerialPortName)) { //配置串口 port.BaudRate = BaudRate; port.DataBits = 8; port.Parity = Parity.Even; port.StopBits = StopBits.One; port.Open(); //创建Modbus主机 var adapter = new SerialPortAdapter(port); adapter.ReadTimeout = ReadTimeout; adapter.WriteTimeout = WriteTimeout; var factory = new ModbusFactory(); IModbusMaster master = factory.CreateRtuMaster(adapter); lock (_modbusLock) { //读寄存器 var values = master.ReadCoils(slaveAddress, registerAddress, 1); if (values?.Length >= 1) { value = values[0]; } } } }
/// <summary> /// Simple Modbus serial ASCII master read holding registers example. /// </summary> public static void ModbusSerialAsciiMasterReadRegisters() { using (SerialPort port = new SerialPort("COM1")) { // configure serial port port.BaudRate = 9600; port.DataBits = 8; port.Parity = Parity.None; port.StopBits = StopBits.One; port.Open(); var adapter = new SerialPortAdapter(port); // create modbus master IModbusSerialMaster master = ModbusSerialMaster.CreateAscii(adapter); byte slaveId = 1; ushort startAddress = 1; ushort numRegisters = 5; // read five registers ushort[] registers = master.ReadHoldingRegisters(slaveId, startAddress, numRegisters); for (int i = 0; i < numRegisters; i++) { Console.WriteLine($"Register {startAddress + i}={registers[i]}"); } } // output: // Register 1=0 // Register 2=0 // Register 3=0 // Register 4=0 // Register 5=0 }
public ModbusCommunication(String portName) { // Creae an instance of a serial port SerialPort serialPort = new SerialPort() { // Settings for the serial port PortName = portName, BaudRate = 57600, DataBits = 8, Parity = Parity.Even, StopBits = StopBits.One, Handshake = Handshake.None, ReadTimeout = 20, WriteTimeout = 20 }; // Open up a serial port serialPort.Open(); var adapter = new SerialPortAdapter(serialPort); // Create modbus master Master = ModbusSerialMaster.CreateRtu(adapter); }
public static IModbusMaster CreateSerialMaster(this IModbusFactory factory, SerialSettings settings) { SerialPort serialPort = new SerialPort() { PortName = settings.PortName, BaudRate = settings.BaudRate, DataBits = settings.DataBits, Parity = settings.Parity, StopBits = settings.StopBits, Handshake = settings.Handshake }; var adapter = new SerialPortAdapter(serialPort); serialPort.Open(); switch (settings.ModbusType) { case ModbusType.Rtu: return(factory.CreateRtuMaster(adapter)); case ModbusType.Ascii: return(factory.CreateAsciiMaster(adapter)); default: throw new ArgumentException("Serial Settings must be either of type Rtu or Ascii."); } }
public void GivenConnected_AndString_WhenFakeReceiveData_ThenCallbackInvoked() { // Arrange var config = new PrinterConfigurationModel() { Port = "com9", BaudRate = 1001 }; var expectedDataReceived = "Hello World!"; var actualDataReceived = string.Empty; Action <SerialPortAdapterRef, string> callback = delegate(SerialPortAdapterRef portRef, string data) { actualDataReceived = data; }; var sut = new SerialPortAdapter <TestableSerialPort>(); var portRef = sut.Connect( config, callback); var port = (TestableSerialPort)sut.GetSerialPort(portRef); // Act port.FakeReceiveData(expectedDataReceived); // Assert Assert.Equal(expectedDataReceived, actualDataReceived); }
/// <summary> /// 读寄存器(多个数据) /// </summary> /// <param name="slaveAddress">从站地址</param> /// <param name="registerAddress">寄存器地址</param> /// <param name="numberOfPoints">读取的数量</param> /// <param name="values">数据</param> public void ReadRegister(byte slaveAddress, ushort registerAddress, ushort numberOfPoints, out ushort[] values) { using (SerialPort port = new SerialPort(SerialPortName)) { //配置串口 port.BaudRate = BaudRate; port.DataBits = 8; port.Parity = Parity.Even; port.StopBits = StopBits.One; port.Open(); //创建Modbus主机 var adapter = new SerialPortAdapter(port); adapter.ReadTimeout = ReadTimeout; adapter.WriteTimeout = WriteTimeout; var factory = new ModbusFactory(); IModbusMaster master = factory.CreateRtuMaster(adapter); lock (_modbusLock) { //读寄存器 values = master.ReadHoldingRegisters(slaveAddress, registerAddress, numberOfPoints); } } }
/// <summary> /// Simple Modbus serial RTU master write holding registers example. /// </summary> public static void ModbusSerialRtuMasterWriteRegisters() { using (SerialPort port = new SerialPort("COM1")) { // configure serial port port.BaudRate = 9600; port.DataBits = 8; port.Parity = Parity.None; port.StopBits = StopBits.One; port.Open(); var adapter = new SerialPortAdapter(port); // create modbus master var factory = new ModbusFactory(); IModbusMaster master = factory.CreateRtuMaster(adapter); byte slaveId = 1; ushort startAddress = 100; ushort[] registers = new ushort[] { 1, 2, 3 }; // write three registers master.WriteMultipleRegisters(slaveId, startAddress, registers); } }
/// <summary> /// 写多个寄存器 /// </summary> /// <param name="slaveAddress">从站地址</param> /// <param name="registerAddress">寄存器地址</param> /// <param name="data">数据</param> private void ModbusSerialRtuMasterWriteRegister(byte slaveAddress, ushort registerAddress, ushort[] data) { using (SerialPort port = new SerialPort(PrimarySerialPortName)) { //配置串口 port.BaudRate = SerialPortBaudRate; port.DataBits = 8; port.Parity = Parity.None; port.StopBits = StopBits.One; port.Open(); //创建Modbus主机 var adapter = new SerialPortAdapter(port); adapter.ReadTimeout = ReadTimeout; adapter.WriteTimeout = WriteTimeout; var factory = new ModbusFactory(); IModbusMaster master = factory.CreateRtuMaster(adapter); lock (powerLock) { //写到寄存器 master.WriteMultipleRegisters(slaveAddress, registerAddress, data); } } }
public void InitializeService(Channel ch) { try { lock (this) { Channels.Add(ch); if (Channels == null) { return; } // Initialize #region XGT. IPLC_LS_Master PLC_LS = null; switch (ch.ConnectionType) { case "SerialPort": var dis = (DISerialPort)ch; var sp = new SerialPort(dis.PortName, dis.BaudRate, dis.Parity, dis.DataBits, dis.StopBits); sp.Handshake = dis.Handshake; var spAdaper = new SerialPortAdapter(sp); PLC_LS = new LS_CNET(); PLC_LS.AllSerialPortAdapter(spAdaper); _cnet.Add(ch.ChannelName, (LS_CNET)PLC_LS); break; case "Ethernet": var die = (DIEthernet)ch; PLC_LS = new LS_FENET(die.IPAddress, die.Port, 500); FENET.Add(ch.ChannelName, (LS_FENET)PLC_LS); break; } #endregion Initialize foreach (var dv in ch.Devices) { foreach (var db in dv.DataBlocks) { foreach (var tg in db.Tags) { TagCollection.Tags.Add( $"{ch.ChannelName}.{dv.DeviceName}.{db.DataBlockName}.{tg.TagName}", tg); } } } } } catch (CommunicationException ex) { EventscadaException?.Invoke(this.GetType().Name, ex.Message); } }
public IStreamResource CreateStreamResource() { SerialPort serialPort = CreateSerialPort(); IStreamResource adapter = new SerialPortAdapter(serialPort); return(adapter); }
/// <summary> /// Modbus serial ASCII master and slave example. /// </summary> public static void ModbusSerialAsciiMasterReadRegistersFromModbusSlave() { using (SerialPort masterPort = new SerialPort("COM1")) using (SerialPort slavePort = new SerialPort("COM2")) { // configure serial ports masterPort.BaudRate = slavePort.BaudRate = 9600; masterPort.DataBits = slavePort.DataBits = 8; masterPort.Parity = slavePort.Parity = Parity.None; masterPort.StopBits = slavePort.StopBits = StopBits.One; masterPort.Open(); slavePort.Open(); var slaveAdapter = new SerialPortAdapter(slavePort); // create modbus slave on seperate thread byte slaveId = 1; var factory = new ModbusFactory(); var transport = factory.CreateAsciiTransport(slaveAdapter); var network = factory.CreateSlaveNetwork(transport); var slave = factory.CreateSlave(slaveId); network.AddSlave(slave); var listenTask = network.ListenAsync(); var masterAdapter = new SerialPortAdapter(masterPort); var masterTransport = factory.CreateAsciiTransport(masterAdapter); // create modbus master IModbusSerialMaster master = factory.CreateMaster(masterTransport); master.Transport.Retries = 5; ushort startAddress = 100; ushort numRegisters = 5; // read five register values ushort[] registers = master.ReadHoldingRegisters(slaveId, startAddress, numRegisters); for (int i = 0; i < numRegisters; i++) { Console.WriteLine($"Register {(startAddress + i)}={registers[i]}"); } } // output // Register 100=0 // Register 101=0 // Register 102=0 // Register 103=0 // Register 104=0 }
internal SerialMasterContext(SerialPort serialPort, int readTimeout, int writeTimeout) { var factory = new ModbusFactory(); var adapter = new SerialPortAdapter(serialPort); _serialPort = serialPort; _master = factory.CreateRtuMaster(adapter); _master.Transport.ReadTimeout = readTimeout; _master.Transport.WriteTimeout = writeTimeout; _master.Transport.Retries = 0; }
public static SerialPortAdapter GetSerialPortAdapter(string portName, int deviceNumber, int portSpeed, int timeOut) { SerialPort serialPort = new SerialPort(portName, portSpeed, Parity.None, 8); serialPort.ReadTimeout = timeOut; serialPort.WriteTimeout = timeOut; SerialPortAdapter serialPortAdapter = new SerialPortAdapter(serialPort); serialPort.Open(); return(serialPortAdapter); }
public void Port_choised(string arg) { if (port.PortName != null) { try { if (port.PortName == arg) { if (!port.IsOpen) { port.Open(); } output += "Port " + port.PortName + " opened" + "\n"; RaisePropertyChanged("Terminal"); } else { if (port.IsOpen) { port.Close(); } port.PortName = arg; port.Open(); } _port_state = port.PortName + " opened"; if (baudrate != 0) { port.BaudRate = baudrate; } port.Handshake = Handshake.None; adapter = new SerialPortAdapter(port); factory = new ModbusFactory(); master = factory.CreateRtuMaster(adapter); master.Transport.ReadTimeout = 300; master.Transport.WriteTimeout = 1000; output += "Master created " + port.BaudRate.ToString() + "\n"; RaisePropertyChanged("Terminal"); } catch (System.IO.IOException) { Refresh_List(); _port_state = arg + " was lost"; output += "Master create error: " + "\n"; RaisePropertyChanged("Terminal"); } } else { output += "Port not choised" + "\n"; RaisePropertyChanged("Terminal"); } RaisePropertyChanged("Port_state"); }
/// <summary> /// Write a 32 bit value. /// </summary> public async void ReadWriteSerial32BitValue() { using (SerialDevice device = await SerialDevice.FromIdAsync("device_id")) { // configure serial port device.BaudRate = 9600; device.DataBits = 8; device.Parity = SerialParity.Even; device.StopBits = SerialStopBitCount.One; var adapter = new SerialPortAdapter(device); // create modbus master ModbusSerialMaster master = ModbusSerialMaster.CreateRtu(adapter); byte slaveId = 1; ushort startAddress = 1008; uint largeValue = UInt16.MaxValue + 5; ushort lowOrderValue = BitConverter.ToUInt16(BitConverter.GetBytes(largeValue), 0); ushort highOrderValue = BitConverter.ToUInt16(BitConverter.GetBytes(largeValue), 2); // write large value in two 16 bit chunks master.WriteMultipleRegisters(slaveId, startAddress, new ushort[] { lowOrderValue, highOrderValue }); // read large value in two 16 bit chunks and perform conversion ushort[] registers = master.ReadHoldingRegisters(slaveId, startAddress, 2); uint value = ModbusUtility.GetUInt32(registers[1], registers[0]); } }
public static async Task SendBack(SerialPort port, ushort address) { var adapter = new SerialPortAdapter(port); // create modbus master var factory = new ModbusFactory(); IModbusMaster master = factory.CreateRtuMaster(adapter); byte slaveId = 1; await master.WriteSingleCoilAsync(slaveId, address, true); await master.WriteSingleCoilAsync(slaveId, address, false); }
public void ExerciseOfTheRealSerialPort() { // Arrange SerialPortAdapter portAdapter = new SerialPortAdapter(new SerialPort()); string mockedSerialInput = "Hello I am a happy device."; // Act DeviceController controller = new DeviceController(portAdapter); string result = controller.ReadPort(); // Assert Assert.AreEqual(mockedSerialInput, result, "expected result"); }
public static async Task StartModbusSerialRtuSlaveNetwork() { using (SerialPort slavePort = new SerialPort("COM4")) { // configure serial port slavePort.BaudRate = 19200; slavePort.DataBits = 8; slavePort.Parity = Parity.Even; slavePort.StopBits = StopBits.One; slavePort.Open(); IModbusFactory factory = new ModbusFactory(); var adapter = new SerialPortAdapter(slavePort); IModbusSlaveNetwork modbusSlaveNetwork = factory.CreateRtuSlaveNetwork(adapter); adapter.ReadTimeout = 50; adapter.WriteTimeout = 500; var acTechDataStore = new SlaveStorage(); //acTechDataStore.CoilDiscretes.StorageOperationOccurred += (sender, args) => Console.WriteLine($"Coil discretes: {args.Operation} starting at {args.StartingAddress}"); //acTechDataStore.CoilInputs.StorageOperationOccurred += (sender, args) => Console.WriteLine($"Coil inputs: {args.Operation} starting at {args.StartingAddress}"); acTechDataStore.InputRegisters.StorageOperationOccurred += (sender, args) => Console.WriteLine($"ACTECH Input registers: {args.Operation} starting at {args.StartingAddress}"); acTechDataStore.HoldingRegisters.StorageOperationOccurred += (sender, args) => Console.WriteLine($"ACTECH Holding registers: {args.Operation} starting at {args.StartingAddress}"); var casHmiDataStore = new SlaveStorage(); casHmiDataStore.InputRegisters.StorageOperationOccurred += (sender, args) => Console.WriteLine($"CASHMI Input registers: {args.Operation} starting at {args.StartingAddress}"); casHmiDataStore.HoldingRegisters.StorageOperationOccurred += (sender, args) => Console.WriteLine($"CASHMI Holding registers: {args.Operation} starting at {args.StartingAddress}"); var danfossStore = new SlaveStorage(); danfossStore.InputRegisters.StorageOperationOccurred += (sender, args) => Console.WriteLine($"DANFOSS Input registers: {args.Operation} starting at {args.StartingAddress}"); danfossStore.HoldingRegisters.StorageOperationOccurred += (sender, args) => Console.WriteLine($"DANFOSS Holding registers: {args.Operation} starting at {args.StartingAddress}"); IModbusSlave slave1 = factory.CreateSlave(21, acTechDataStore); IModbusSlave slave2 = factory.CreateSlave(55, casHmiDataStore); IModbusSlave slave3 = factory.CreateSlave(1, danfossStore); modbusSlaveNetwork.AddSlave(slave1); //modbusSlaveNetwork.AddSlave(slave2); modbusSlaveNetwork.AddSlave(slave2); modbusSlaveNetwork.AddSlave(slave3); await modbusSlaveNetwork.ListenAsync(); await Task.Delay(1); } }
public ushort[] LerRegistradoresDeEscravo(List <HoldingRegisters> escravo, SerialPort port) { using (SerialPortAdapter adapter = new SerialPortAdapter(port)) using (IModbusSerialMaster master = ModbusSerialMaster.CreateRtu(adapter)) { var idEscravo = escravo.First().idEscravo; var min = escravo.Min(x => x.offSet); var max = escravo.Max(x => x.offSet); ushort limite = ushort.Parse((Int32.Parse(max) + 1).ToString()); ushort[] registers; registers = master.ReadHoldingRegisters(byte.Parse(idEscravo), ushort.Parse(min), limite); return(registers); } }
public bool Connect(TimeSpan timeout) { if (this.EasySerialPort == null) { return(false); } if (!this.EasySerialPort.Open()) { return(false); } CommunicationOK = ComCommunicationSts.OK; SerialPortAdapter adapter = new SerialPortAdapter(this.EasySerialPort.SerialPort); this.ModbusMaster = ModbusSerialMaster.CreateRtu(adapter); return(true); }
private void btn_OpenJigPort_Click(object sender, EventArgs e) { if (_portOpened == false && Open(cbCOMPorts.Text)) { _comInterface = new SerialPortAdapter(); _comInterface.SerialDataRxedHandler = RxByteStreamParser; btn_OpenJigPort.Text = "Disconnect!"; _portOpened = true; } else if (_portOpened == true) { _comInterface.Close(); btn_OpenJigPort.Text = "Connect!"; _portOpened = false; } }