fork(7) download 
  1. using System;
  2. using System.IO.Ports;
  3. using System.Net;
  4. using System.Net.Sockets;
  5. using System.Threading;
  6. using Modbus.Data;
  7. using Modbus.Device;
  8. using Modbus.Utility;
  9.  
  10. namespace MySample
  11. {
  12.     /// <summary>
  13.     ///     Demonstration of NModbus
  14.     /// </summary>
  15.     public class Driver
  16.     {
  17.         private static void Main(string[] args)
  18.         {
  19.             log4net.Config.XmlConfigurator.Configure();
  20.  
  21.             try
  22.             {
  23.                 //ModbusTcpMasterReadInputs();
  24.                 //SimplePerfTest();
  25.                 //ModbusSerialRtuMasterWriteRegisters();
  26.                 //ModbusSerialAsciiMasterReadRegisters();
  27.                 //ModbusTcpMasterReadInputs();				
  28.                 //StartModbusAsciiSlave();
  29.                 //ModbusTcpMasterReadInputsFromModbusSlave();
  30.                 //ModbusSerialAsciiMasterReadRegistersFromModbusSlave();
  31.                 //StartModbusTcpSlave();
  32.                 //StartModbusUdpSlave();
  33.                 //StartModbusAsciiSlave();
  34.             }
  35.             catch (Exception e)
  36.             {
  37.                 Console.WriteLine(e.Message);
  38.             }
  39.  
  40.             Console.ReadKey();
  41.         }
  42.  
  43.         /// <summary>
  44.         ///     Simple Modbus serial RTU master write holding registers example.
  45.         /// </summary>
  46.         public static void ModbusSerialRtuMasterWriteRegisters()
  47.         {
  48.             using (SerialPort port = new SerialPort("COM1"))
  49.             {
  50.                 // configure serial port
  51.                 port.BaudRate = 9600;
  52.                 port.DataBits = 8;
  53.                 port.Parity = Parity.None;
  54.                 port.StopBits = StopBits.One;
  55.                 port.Open();
  56.  
  57.                 // create modbus master
  58.                 IModbusSerialMaster master = ModbusSerialMaster.CreateRtu(port);
  59.  
  60.                 byte slaveId = 1;
  61.                 ushort startAddress = 100;
  62.                 ushort[] registers = new ushort[] { 1, 2, 3 };
  63.  
  64.                 // write three registers
  65.                 master.WriteMultipleRegisters(slaveId, startAddress, registers);
  66.             }
  67.         }
  68.  
  69.         /// <summary>
  70.         ///     Simple Modbus serial ASCII master read holding registers example.
  71.         /// </summary>
  72.         public static void ModbusSerialAsciiMasterReadRegisters()
  73.         {
  74.             using (SerialPort port = new SerialPort("COM1"))
  75.             {
  76.                 // configure serial port
  77.                 port.BaudRate = 9600;
  78.                 port.DataBits = 8;
  79.                 port.Parity = Parity.None;
  80.                 port.StopBits = StopBits.One;
  81.                 port.Open();
  82.  
  83.                 // create modbus master
  84.                 IModbusSerialMaster master = ModbusSerialMaster.CreateAscii(port);
  85.  
  86.                 byte slaveId = 1;
  87.                 ushort startAddress = 1;
  88.                 ushort numRegisters = 5;
  89.  
  90.                 // read five registers		
  91.                 ushort[] registers = master.ReadHoldingRegisters(slaveId, startAddress, numRegisters);
  92.  
  93.                 for (int i = 0; i < numRegisters; i++)
  94.                     Console.WriteLine("Register {0}={1}", startAddress + i, registers[i]);
  95.             }
  96.  
  97.             // output: 
  98.             // Register 1=0
  99.             // Register 2=0
  100.             // Register 3=0
  101.             // Register 4=0
  102.             // Register 5=0
  103.         }
  104.  
  105.         /// <summary>
  106.         ///     Simple Modbus TCP master read inputs example.
  107.         /// </summary>
  108.         public static void ModbusTcpMasterReadInputs()
  109.         {
  110.             using (TcpClient client = new TcpClient("127.0.0.1", 502))
  111.             {
  112.                 ModbusIpMaster master = ModbusIpMaster.CreateIp(client);
  113.  
  114.                 // read five input values
  115.                 ushort startAddress = 100;
  116.                 ushort numInputs = 5;
  117.                 bool[] inputs = master.ReadInputs(startAddress, numInputs);
  118.  
  119.                 for (int i = 0; i < numInputs; i++)
  120.                     Console.WriteLine("Input {0}={1}", startAddress + i, inputs[i] ? 1 : 0);
  121.             }
  122.  
  123.             // output: 
  124.             // Input 100=0
  125.             // Input 101=0
  126.             // Input 102=0
  127.             // Input 103=0
  128.             // Input 104=0
  129.         }
  130.  
  131.         /// <summary>
  132.         ///     Simple Modbus UDP master write coils example.
  133.         /// </summary>
  134.         public static void ModbusUdpMasterWriteCoils()
  135.         {
  136.             using (UdpClient client = new UdpClient())
  137.             {
  138.                 IPEndPoint endPoint = new IPEndPoint(new IPAddress(new byte[] { 127, 0, 0, 1 }), 502);
  139.                 client.Connect(endPoint);
  140.  
  141.                 ModbusIpMaster master = ModbusIpMaster.CreateIp(client);
  142.  
  143.                 ushort startAddress = 1;
  144.  
  145.                 // write three coils
  146.                 master.WriteMultipleCoils(startAddress, new bool[] { true, false, true });
  147.             }
  148.         }
  149.  
  150.         /// <summary>
  151.         ///     Simple Modbus serial ASCII slave example.
  152.         /// </summary>
  153.         public static void StartModbusSerialAsciiSlave()
  154.         {
  155.             using (SerialPort slavePort = new SerialPort("COM2"))
  156.             {
  157.                 // configure serial port
  158.                 slavePort.BaudRate = 9600;
  159.                 slavePort.DataBits = 8;
  160.                 slavePort.Parity = Parity.None;
  161.                 slavePort.StopBits = StopBits.One;
  162.                 slavePort.Open();
  163.  
  164.                 byte unitId = 1;
  165.  
  166.                 // create modbus slave
  167.                 ModbusSlave slave = ModbusSerialSlave.CreateAscii(unitId, slavePort);
  168.                 slave.DataStore = DataStoreFactory.CreateDefaultDataStore();
  169.  
  170.                 slave.Listen();
  171.             }
  172.         }
  173.  
  174.         /// <summary>
  175.         ///     Simple Modbus serial RTU slave example.
  176.         /// </summary>
  177.         public static void StartModbusSerialRtuSlave()
  178.         {
  179.             using (SerialPort slavePort = new SerialPort("COM2"))
  180.             {
  181.                 // configure serial port
  182.                 slavePort.BaudRate = 9600;
  183.                 slavePort.DataBits = 8;
  184.                 slavePort.Parity = Parity.None;
  185.                 slavePort.StopBits = StopBits.One;
  186.                 slavePort.Open();
  187.  
  188.                 byte unitId = 1;
  189.  
  190.                 // create modbus slave
  191.                 ModbusSlave slave = ModbusSerialSlave.CreateRtu(unitId, slavePort);
  192.                 slave.DataStore = DataStoreFactory.CreateDefaultDataStore();
  193.  
  194.                 slave.Listen();
  195.             }
  196.         }
  197.  
  198.         /// <summary>
  199.         ///     Simple Modbus serial USB ASCII slave example.
  200.         /// </summary>
  201.         public static void StartModbusSerialUsbAsciiSlave()
  202.         {
  203.             // TODO
  204.         }
  205.  
  206.         /// <summary>
  207.         ///     Simple Modbus serial USB RTU slave example.
  208.         /// </summary>
  209.         public static void StartModbusSerialUsbRtuSlave()
  210.         {
  211.             // TODO
  212.         }
  213.  
  214.         /// <summary>
  215.         ///     Simple Modbus TCP slave example.
  216.         /// </summary>
  217.         public static void StartModbusTcpSlave()
  218.         {
  219.             byte slaveId = 1;
  220.             int port = 502;
  221.             IPAddress address = new IPAddress(new byte[] { 127, 0, 0, 1 });
  222.  
  223.             // create and start the TCP slave
  224.             TcpListener slaveTcpListener = new TcpListener(address, port);
  225.             slaveTcpListener.Start();
  226.  
  227.             ModbusSlave slave = ModbusTcpSlave.CreateTcp(slaveId, slaveTcpListener);
  228.             slave.DataStore = DataStoreFactory.CreateDefaultDataStore();
  229.  
  230.             slave.Listen();
  231.  
  232.             // prevent the main thread from exiting
  233.             Thread.Sleep(Timeout.Infinite);
  234.         }
  235.  
  236.         /// <summary>
  237.         ///     Simple Modbus UDP slave example.
  238.         /// </summary>
  239.         public static void StartModbusUdpSlave()
  240.         {
  241.             using (UdpClient client = new UdpClient(502))
  242.             {
  243.                 ModbusUdpSlave slave = ModbusUdpSlave.CreateUdp(client);
  244.                 slave.DataStore = DataStoreFactory.CreateDefaultDataStore();
  245.  
  246.                 slave.Listen();
  247.  
  248.                 // prevent the main thread from exiting
  249.                 Thread.Sleep(Timeout.Infinite);
  250.             }
  251.         }
  252.  
  253.         /// <summary>
  254.         ///     Modbus TCP master and slave example.
  255.         /// </summary>
  256.         public static void ModbusTcpMasterReadInputsFromModbusSlave()
  257.         {
  258.             byte slaveId = 1;
  259.             int port = 502;
  260.             IPAddress address = new IPAddress(new byte[] { 127, 0, 0, 1 });
  261.  
  262.             // create and start the TCP slave
  263.             TcpListener slaveTcpListener = new TcpListener(address, port);
  264.             slaveTcpListener.Start();
  265.             ModbusSlave slave = ModbusTcpSlave.CreateTcp(slaveId, slaveTcpListener);
  266.             Thread slaveThread = new Thread(slave.Listen);
  267.             slaveThread.Start();
  268.  
  269.             // create the master
  270.             TcpClient masterTcpClient = new TcpClient(address.ToString(), port);
  271.             ModbusIpMaster master = ModbusIpMaster.CreateIp(masterTcpClient);
  272.  
  273.             ushort numInputs = 5;
  274.             ushort startAddress = 100;
  275.  
  276.             // read five register values
  277.             ushort[] inputs = master.ReadInputRegisters(startAddress, numInputs);
  278.  
  279.             for (int i = 0; i < numInputs; i++)
  280.                 Console.WriteLine("Register {0}={1}", startAddress + i, inputs[i]);
  281.  
  282.             // clean up
  283.             masterTcpClient.Close();
  284.             slaveTcpListener.Stop();
  285.  
  286.             // output
  287.             // Register 100=0
  288.             // Register 101=0
  289.             // Register 102=0
  290.             // Register 103=0
  291.             // Register 104=0
  292.         }
  293.  
  294.         /// <summary>
  295.         ///     Modbus serial ASCII master and slave example.
  296.         /// </summary>
  297.         public static void ModbusSerialAsciiMasterReadRegistersFromModbusSlave()
  298.         {
  299.             using (SerialPort masterPort = new SerialPort("COM1"))
  300.             using (SerialPort slavePort = new SerialPort("COM2"))
  301.             {
  302.                 // configure serial ports
  303.                 masterPort.BaudRate = slavePort.BaudRate = 9600;
  304.                 masterPort.DataBits = slavePort.DataBits = 8;
  305.                 masterPort.Parity = slavePort.Parity = Parity.None;
  306.                 masterPort.StopBits = slavePort.StopBits = StopBits.One;
  307.                 masterPort.Open();
  308.                 slavePort.Open();
  309.  
  310.                 // create modbus slave on seperate thread
  311.                 byte slaveId = 1;
  312.                 ModbusSlave slave = ModbusSerialSlave.CreateAscii(slaveId, slavePort);
  313.                 Thread slaveThread = new Thread(new ThreadStart(slave.Listen));
  314.                 slaveThread.Start();
  315.  
  316.                 // create modbus master
  317.                 ModbusSerialMaster master = ModbusSerialMaster.CreateAscii(masterPort);
  318.  
  319.                 master.Transport.Retries = 5;
  320.                 ushort startAddress = 100;
  321.                 ushort numRegisters = 5;
  322.  
  323.                 // read five register values
  324.                 ushort[] registers = master.ReadHoldingRegisters(slaveId, startAddress, numRegisters);
  325.  
  326.                 for (int i = 0; i < numRegisters; i++)
  327.                     Console.WriteLine("Register {0}={1}", startAddress + i, registers[i]);
  328.             }
  329.  
  330.             // output
  331.             // Register 100=0
  332.             // Register 101=0
  333.             // Register 102=0
  334.             // Register 103=0
  335.             // Register 104=0
  336.         }
  337.  
  338.         /// <summary>
  339.         ///     Write a 32 bit value.
  340.         /// </summary>
  341.         public static void ReadWrite32BitValue()
  342.         {
  343.             using (SerialPort port = new SerialPort("COM1"))
  344.             {
  345.                 // configure serial port
  346.                 port.BaudRate = 9600;
  347.                 port.DataBits = 8;
  348.                 port.Parity = Parity.None;
  349.                 port.StopBits = StopBits.One;
  350.                 port.Open();
  351.  
  352.                 // create modbus master
  353.                 ModbusSerialMaster master = ModbusSerialMaster.CreateRtu(port);
  354.  
  355.                 byte slaveId = 1;
  356.                 ushort startAddress = 1008;
  357.                 uint largeValue = UInt16.MaxValue + 5;
  358.  
  359.                 ushort lowOrderValue = BitConverter.ToUInt16(BitConverter.GetBytes(largeValue), 0);
  360.                 ushort highOrderValue = BitConverter.ToUInt16(BitConverter.GetBytes(largeValue), 2);
  361.  
  362.                 // write large value in two 16 bit chunks
  363.                 master.WriteMultipleRegisters(slaveId, startAddress, new ushort[] { lowOrderValue, highOrderValue });
  364.  
  365.                 // read large value in two 16 bit chunks and perform conversion
  366.                 ushort[] registers = master.ReadHoldingRegisters(slaveId, startAddress, 2);
  367.                 uint value = ModbusUtility.GetUInt32(registers[1], registers[0]);
  368.             }
  369.         }
  370.     }
  371. }
Compilation error #stdin compilation error #stdout 0s 0KB
comments (?)
stdin 
Standard input is empty
compilation info 
prog.cs(6,7): error CS0246: The type or namespace name `Modbus' could not be found. Are you missing an assembly reference?
prog.cs(7,7): error CS0246: The type or namespace name `Modbus' could not be found. Are you missing an assembly reference?
prog.cs(8,7): error CS0246: The type or namespace name `Modbus' could not be found. Are you missing an assembly reference?
Compilation failed: 3 error(s), 0 warnings
stdout 
Standard output is empty
https://ideone.com/Hn36P9
language:
C# (gmcs 5.20.1)
created:
10 years ago
visibility:
public

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!