public void ModbusUdpSlave_NotBound()
{
UdpClient client = new();
ModbusSlave slave = ModbusUdpSlave.CreateUdp(1, client);
Assert.ThrowsAsync <InvalidOperationException>(async() => await slave.ListenAsync());
}
public static void StartSlave(ModbusSlave slave)
{
slave.DataStore = DataStoreFactory.CreateTestDataStore();
Thread?slaveThread = new(async() => await slave.ListenAsync());
slaveThread.Start();
}
public void InitServer()
{
try
{
IPHostEntry ipEntry = Dns.GetHostEntry(Dns.GetHostName());
//IPAddress[] addr = ipEntry.AddressList;
IPAddress IPaddr = IPAddress.Parse(IPaddress);
//IPAddress address = new IPAddress(new byte[] { 192, 168, 0, 33 });
// create and start the TCP slave
slaveTcpListener = new TcpListener(IPaddr, port);
slaveTcpListener.Start();
slave = ModbusTcpSlave.CreateTcp(slaveId, slaveTcpListener);
slave.DataStore = DataStoreFactory.CreateDefaultDataStore();
slave.ModbusSlaveRequestReceived += new EventHandler <ModbusSlaveRequestEventArgs>(Modbus_Request_Event);
//slave.ListenAsync().GetAwaiter().GetResult();
slave.ListenAsync();
Console.WriteLine(DateTime.Now.ToString() + " ModbusTCP/IP сервер запущен на адресе : " + IPaddress);
}
catch (Exception ex)
{
Console.WriteLine(DateTime.Now.ToString() + " Error in InitServer : " + ex.Message);
isListen = false;
slaveTcpListener.Stop();
slaveTcpListener = null;
slave.Dispose();
}
}
/// <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();
}
}
static void Main(string[] args)
{
byte slaveId = 1;
int port = 502;
string data;
IPAddress address = new IPAddress(new byte[] { 0, 0, 0, 0 });
do
{
Console.WriteLine("попытка получить IP");
data = Console.ReadLine();
}while (!IPAddress.TryParse(data, out address));
Console.WriteLine("введите адрес");
slaveId = Convert.ToByte(Console.ReadLine());
// create and start the TCP slave
TcpListener slaveTcpListener = new TcpListener(address, port);
slaveTcpListener.Start();
ModbusSlave slave = ModbusTcpSlave.CreateTcp(slaveId, slaveTcpListener, false);
//slave = ModbusSerialSlave.CreateRtu(1,);
slave.DataStore = DataStoreFactory.CreateDefaultDataStore();
Console.WriteLine("начинаю слушать");
slave.ListenAsync();
while (true)
{
Console.WriteLine("введите вид регистра: 1 - 4");
int type = Convert.ToInt32(Console.ReadLine());
Console.WriteLine("введите адрес регистра");
ushort addr = Convert.ToUInt16(Console.ReadLine());
Console.WriteLine("введите значение регистра");
ushort val = Convert.ToUInt16(Console.ReadLine());
switch (type)
{
case 1:
slave.DataStore.CoilDiscretes[addr] = val > 0;
break;
case 2:
slave.DataStore.InputDiscretes[addr] = val > 0;
break;
case 3:
slave.DataStore.InputRegisters[addr] = val;
break;
case 4:
slave.DataStore.HoldingRegisters[addr] = val;
break;
}
}
}
public void Start()
{
_listener?.Stop();
_slave?.Dispose();
_listener = new TcpListener(IPAddress.Any, 502);
_slave = ModbusTcpSlave.CreateTcp(1, _listener);
_slave.DataStore = DataStoreFactory.CreateDefaultDataStore();
_slave.ListenAsync();
}
private UdpClient CreateAndStartUdpSlave(int port, DataStore dataStore)
{
UdpClient slaveClient = new(port);
ModbusSlave slave = ModbusUdpSlave.CreateUdp(slaveClient);
slave.DataStore = dataStore;
Thread slaveThread = new(async() => await slave.ListenAsync());
slaveThread.Start();
return(slaveClient);
}
/// <summary>
/// Modbus TCP master and slave example.
/// </summary>
public async void ModbusTcpMasterReadInputsFromModbusSlave()
{
byte slaveId = 1;
int port = 502;
IPAddress address = new IPAddress(new byte[] { 127, 0, 0, 1 });
// create and start the TCP slave
TcpListener slaveTcpListener = new TcpListener(address, port);
slaveTcpListener.Start();
ModbusSlave slave = ModbusTcpSlave.CreateTcp(slaveId, slaveTcpListener);
var listenTask = slave.ListenAsync();
// create the master
TcpClient masterTcpClient = new TcpClient();
masterTcpClient.ReceiveTimeout = 3000;
masterTcpClient.SendTimeout = 3000;
await masterTcpClient.ConnectAsync(IpAddressInputBox.Text, int.Parse(TcpPortInputBox.Text));
ModbusIpMaster master = ModbusIpMaster.CreateIp(masterTcpClient);
ushort numInputs = 5;
ushort startAddress = 100;
// read five register values
ushort[] inputs = master.ReadInputRegisters(startAddress, numInputs);
for (int i = 0; i < numInputs; i++)
{
ResultsTextBox.Text += ($"Register {(startAddress + i)}={(inputs[i])}") + "\r\n";
}
// clean up
masterTcpClient.Dispose();
slaveTcpListener.Stop();
}
public static void Write_MultipleRegisters(ushort write_register_addr, ushort[] register_data)
{
write_register_addr = _register_Address;
register_data = _register_Data;
Start_MBServer();
Start_MBCLient();
ModbusSlave slave = ModbusTcpSlave.CreateTcp(_slaveID, slaveTCP);
var listener = slave.ListenAsync();
ModbusIpMaster master = ModbusIpMaster.CreateIp(masterTCP);
master.WriteMultipleRegisters(write_register_addr, register_data);
Stop_MBClient();
Stop_MBServer();
}
public static void Write_SingleRegister(ushort write_register_addr, ushort register_value)
{
write_register_addr = _register_Address;
register_value = _register_Value;
Start_MBServer();
Start_MBCLient();
ModbusSlave slave = ModbusTcpSlave.CreateTcp(_slaveID, slaveTCP);
var listener = slave.ListenAsync();
ModbusIpMaster master = ModbusIpMaster.CreateIp(masterTCP);
master.WriteSingleRegister(write_register_addr, register_value);
Stop_MBClient();
Stop_MBServer();
}
public static void Write_MultipleCoils(ushort write_start_addr, bool[] coils_value)
{
coils_value = _writemultiplecoils_Value;
write_start_addr = _writestartAddress;
Start_MBServer();
Start_MBCLient();
ModbusSlave slave = ModbusTcpSlave.CreateTcp(_slaveID, slaveTCP);
var listener = slave.ListenAsync();
ModbusIpMaster master = ModbusIpMaster.CreateIp(masterTCP);
master.WriteMultipleCoils(write_start_addr, coils_value);
Stop_MBClient();
Stop_MBServer();
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
public static void Write_SingleCoil(ushort write_coil_addr, bool coil_value)
{
write_coil_addr = _writecoil_Address;
coil_value = _writecoil_Value;
Start_MBServer();
Start_MBCLient();
ModbusSlave slave = ModbusTcpSlave.CreateTcp(_slaveID, slaveTCP);
var listener = slave.ListenAsync();
ModbusIpMaster master = ModbusIpMaster.CreateIp(masterTCP);
master.WriteSingleCoil(_writecoil_Address, _writecoil_Value);
Stop_MBClient();
Stop_MBServer();
}
public static bool[] Read_Coils(ushort read_start_addr, ushort num_coils)
{
num_coils = _numOfCoils;
read_start_addr = _readstartAddress;
Start_MBServer();
Start_MBCLient();
ModbusSlave slave = ModbusTcpSlave.CreateTcp(_slaveID, slaveTCP);
var listener = slave.ListenAsync();
ModbusIpMaster master = ModbusIpMaster.CreateIp(masterTCP);
bool[] read_result = master.ReadCoils(read_start_addr, num_coils);
Stop_MBClient();
Stop_MBServer();
return(read_result);
}
public static ushort[] Read_InputRegisters(ushort read_start_addr, ushort num_register)
{
num_register = _numOfInputRegister;
read_start_addr = _readstartAddress;
Start_MBServer();
Start_MBCLient();
ModbusSlave slave = ModbusTcpSlave.CreateTcp(_slaveID, slaveTCP);
var listener = slave.ListenAsync();
ModbusIpMaster master = ModbusIpMaster.CreateIp(masterTCP);
ushort[] read_result = master.ReadInputRegisters(read_start_addr, num_register);
Stop_MBClient();
Stop_MBServer();
return(read_result);
}
/// <summary>
/// Modbus TCP master and slave example.
/// </summary>
public static void ModbusTcpMasterReadInputsFromModbusSlave()
{
byte slaveId = 1;
int port = 502;
IPAddress address = new IPAddress(new byte[] { 127, 0, 0, 1 });
// create and start the TCP slave
TcpListener slaveTcp = new TcpListener(address, port);
slaveTcp.Start();
ModbusSlave slave = ModbusTcpSlave.CreateTcp(slaveId, slaveTcp);
var listenTask = slave.ListenAsync();
// create the master
TcpClient masterTcp = new TcpClient();
masterTcp.ConnectAsync(address.ToString(), port);
ModbusIpMaster master = ModbusIpMaster.CreateIp(masterTcp);
ushort numInputs = 4;
ushort startAddress = 100;
// read five register values
ushort[] inputs = master.ReadInputRegisters(startAddress, numInputs);
bool[] inp = master.ReadCoils(startAddress, 10);
for (int i = 0; i < numInputs; i++)
{
Console.WriteLine($"Register {(startAddress + i)}={(inputs[i])}");
}
// clean up
masterTcp.Dispose();
slaveTcp.Stop();
// // output
// // Register 100=0
// // Register 101=0
// // Register 102=0
// // Register 103=0
// // Register 104=0
//}
}
/// <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;
ModbusSlave slave = ModbusSerialSlave.CreateAscii(slaveId, slaveAdapter);
var listenTask = slave.ListenAsync();
var masterAdapter = new SerialPortAdapter(masterPort);
// create modbus master
ModbusSerialMaster master = ModbusSerialMaster.CreateAscii(masterAdapter);
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
}
/// <summary>
/// Simple Modbus TCP slave example.
/// </summary>
public static void StartModbusTcpSlave()
{
byte slaveId = 1;
int port = 502;
IPAddress address = new IPAddress(new byte[] { 127, 0, 0, 1 });
// create and start the TCP slave
TcpListener slaveTcpListener = new TcpListener(address, port);
slaveTcpListener.Start();
ModbusSlave slave = ModbusTcpSlave.CreateTcp(slaveId, slaveTcpListener);
slave.DataStore = DataStoreFactory.CreateDefaultDataStore();
slave.ListenAsync().GetAwaiter().GetResult();
// prevent the main thread from exiting
Thread.Sleep(Timeout.Infinite);
}
/// <summary>
/// Simple Modbus serial ASCII slave example.
/// </summary>
public static void StartModbusSerialAsciiSlave()
{
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();
byte unitId = 1;
var adapter = new SerialPortAdapter(slavePort);
// create modbus slave
ModbusSlave slave = ModbusSerialSlave.CreateAscii(unitId, adapter);
slave.DataStore = DataStoreFactory.CreateDefaultDataStore();
slave.ListenAsync().GetAwaiter().GetResult();
}
}
/// <summary>
/// Simple Modbus TCP slave example.
/// </summary>
public void StartModbusTcpSlave()
{
byte slaveId = 1;
int port = 502;
IPAddress address = new IPAddress(new byte[] { 127, 0, 0, 1 });
// create and start the TCP slave
TcpListener slaveTcpListener = new TcpListener(address, port);
slaveTcpListener.Start();
ModbusSlave slave = ModbusTcpSlave.CreateTcp(slaveId, slaveTcpListener);
slave.DataStore = DataStoreFactory.CreateDefaultDataStore();
slave.ListenAsync().GetAwaiter().GetResult();
}
