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