/// <summary>
/// Simple Modbus TCP slave example.
/// </summary>
private void StartModbusTcpSlave()
{
IPAddress ipaddress = IPAddress.Parse(Address);
Console.WriteLine($"Listening on '{Address}:{Port}' at slave ID={SlaveID}.");
// create and start the TCP slave
TcpListener slaveTcpListener = new TcpListener(ipaddress, Port);
slaveTcpListener.Start();
IModbusFactory factory = new ModbusFactory();
IModbusSlaveNetwork network = factory.CreateSlaveNetwork(slaveTcpListener);
// Set the storage operation event handlers.
_storage.InputRegisters.StorageOperationOccurred += InputRegistersStorageOperationOccurred;
_storage.HoldingRegisters.StorageOperationOccurred += HoldingRegistersStorageOperationOccurred;
// Start the update timer.
_timer = new Timer(OnTimerElapsed, null, 0, -1);
// create and start the Modbus slave
IModbusSlave slave = factory.CreateSlave(SlaveID, _storage);
network.AddSlave(slave);
network.ListenAsync().GetAwaiter().GetResult();
// prevent the main thread from exiting
Thread.Sleep(Timeout.Infinite);
}
/// <summary>
/// Simple Modbus TCP slave example.
/// </summary>
public static void StartModbusTcpSlave()
{
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();
IModbusFactory factory = new ModbusFactory();
IModbusSlaveNetwork network = factory.CreateSlaveNetwork(slaveTcpListener);
IModbusSlave slave1 = factory.CreateSlave(1);
IModbusSlave slave2 = factory.CreateSlave(2);
network.AddSlave(slave1);
network.AddSlave(slave2);
network.ListenAsync().GetAwaiter().GetResult();
// prevent the main thread from exiting
Thread.Sleep(Timeout.Infinite);
}
public static async Task StartModbusSerialRtuSlaveWithCustomStore()
{
using (SerialPort slavePort = new SerialPort(PrimarySerialPortName))
{
// configure serial port
slavePort.BaudRate = 9600;
slavePort.DataBits = 8;
slavePort.Parity = Parity.None;
slavePort.StopBits = StopBits.One;
slavePort.Open();
var factory = new ModbusFactory();
var slaveNetwork = factory.CreateRtuSlaveNetwork(slavePort);
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);
await slaveNetwork.ListenAsync();
}
}
/// <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>
/// Simple Modbus TCP slave example.
/// </summary>
public static void StartModbusTcpSlave()
{
IPAddress address = new IPAddress(new byte[] { 0, 0, 0, 0 });
// create and start the TCP slave
TcpListener slaveTcpListener = new TcpListener(address, _port);
slaveTcpListener.Start();
IModbusFactory factory = new ModbusFactory();
IModbusSlaveNetwork network = factory.CreateSlaveNetwork(slaveTcpListener);
for (byte i = 1; i <= _maxDeviceId; i++)
{
var dataStore = new MySlaveDataStore(_maxSize);
IModbusSlave slave = factory.CreateSlave(i, dataStore);
network.AddSlave(slave);
SlaveDataStores.Add(i, dataStore);
}
network.ListenAsync().GetAwaiter().GetResult();
// prevent the main thread from exiting
Thread.Sleep(Timeout.Infinite);
}
/// <summary>
/// Simple Modbus TCP slave example.
/// </summary>
private void StartModbusTcpSlave()
{
int port = 504;
byte slaveid = 180;
IPAddress address = new IPAddress(new byte[] { 127, 0, 0, 1 });
Console.WriteLine($"Listening on '{address}:{port}' at slave ID={slaveid}.");
// create and start the TCP slave
TcpListener slaveTcpListener = new TcpListener(address, port);
slaveTcpListener.Start();
IModbusFactory factory = new ModbusFactory();
IModbusSlaveNetwork network = factory.CreateSlaveNetwork(slaveTcpListener);
_storage.HoldingRegisters.StorageOperationOccurred += HoldingRegistersStorageOperationOccurred;
IModbusSlave slave = factory.CreateSlave(slaveid, _storage);
network.AddSlave(slave);
network.ListenAsync().GetAwaiter().GetResult();
// prevent the main thread from exiting
Thread.Sleep(Timeout.Infinite);
}
public async Task StartModbusSerialRtuSlaveWithCustomStore()
{
using (SerialPort slavePort = new SerialPort(PrimarySerialPortName))
{
// configure serial port
slavePort.BaudRate = 9600;
slavePort.DataBits = 8;
slavePort.Parity = Parity.None;
slavePort.StopBits = StopBits.One;
slavePort.Open();
var factory = new ModbusFactory();
var slaveNetwork = factory.CreateRtuSlaveNetwork(slavePort);
slavePort.ReadTimeout = 500;
slavePort.WriteTimeout = 500;
var dataStore = new SlaveStorage();
var dataStore2 = new SlaveStorage();
dataStore.HoldingRegisters.StorageOperationOccurred += HoldingRegisters_StorageOperationOccurred;
IModbusSlave slave1 = factory.CreateSlave(1, dataStore);
IModbusSlave slave2 = factory.CreateSlave(2, dataStore2);
slaveNetwork.AddSlave(slave1);
slaveNetwork.AddSlave(slave2);
// await slaveNetwork.ListenAsync();
await slaveNetwork.ListenWorkAroundAsync(new CancellationToken());
}
}
private static void Main(string[] args)
{
const int port = 502;
IPAddress localaddr = new IPAddress(new byte[] { 127, 0, 0, 1 });
TcpListener slaveTcpListener = new TcpListener(localaddr, port);
slaveTcpListener.Start();
// NullModbusLogger.Instance = ;
IModbusFactory factory = new ModbusFactory(null, true, new ReadLogger());
IModbusSlaveNetwork network = factory.CreateSlaveNetwork(slaveTcpListener);
List <string> ips = new List <string> {
"192.168.8.200", "192.168.8.201", "192.168.8.202"
};
for (int i = 0; i < ips.Count; i++)
{
SlaveStorage storage = new SlaveStorage();
ElektronikondataReader reader = new ElektronikondataReader(i + 1, storage);
Task.Factory.StartNew(ElektronikondataReader.ReadDataThread, reader);
IModbusSlave slave = factory.CreateSlave((byte)i, storage);
network.AddSlave(slave);
}
network.ListenAsync().GetAwaiter().GetResult();
// prevent the main thread from exiting
// Thread.Sleep(Timeout.Infinite);
Console.WriteLine("Press any key to exit " + args);
Console.ReadKey();
}
//使用.net core 3.1架構開發 - https://docs.microsoft.com/zh-tw/dotnet/core/introduction
//使用NModbus開源程式碼實作Modbus通訊 - https://github.com/NModbus/NModbus
static void Main(string[] args)
{
ModbusFactory modbusFactory = new ModbusFactory();
TcpListener tcpListener = new TcpListener(new IPEndPoint(IPAddress.Any, 502));
IModbusSlaveNetwork modbusSlaveNetwork = modbusFactory.CreateSlaveNetwork(tcpListener);
IModbusSlave modbusSlave = modbusFactory.CreateSlave(1);
modbusSlaveNetwork.AddSlave(modbusSlave);
modbusSlaveNetwork.ListenAsync();
Process.GetCurrentProcess().WaitForExit();
}
public void AddSlave(IModbusSlave slave)
{
if (slave == null)
{
throw new ArgumentNullException(nameof(slave));
}
_slaves.Add(slave.UnitId, slave);
//Logger.Information($"Slave {slave.UnitId} added to slave network.");
}
private async Task HandleRequestAsync()
{
while (true)
{
Logger.Debug($"Begin reading header from Master at IP: {EndPoint}");
int readBytes = await Stream.ReadAsync(_mbapHeader, 0, 6).ConfigureAwait(false);
if (readBytes == 0)
{
Logger.Debug($"0 bytes read, Master at {EndPoint} has closed Socket connection.");
ModbusMasterTcpConnectionClosed?.Invoke(this, new TcpConnectionEventArgs(EndPoint));
return;
}
ushort frameLength = (ushort)IPAddress.HostToNetworkOrder(BitConverter.ToInt16(_mbapHeader, 4));
Logger.Debug($"Master at {EndPoint} sent header: \"{string.Join(", ", _mbapHeader)}\" with {frameLength} bytes in PDU");
_messageFrame = new byte[frameLength];
readBytes = await Stream.ReadAsync(_messageFrame, 0, frameLength).ConfigureAwait(false);
if (readBytes == 0)
{
Logger.Debug($"0 bytes read, Master at {EndPoint} has closed Socket connection.");
ModbusMasterTcpConnectionClosed?.Invoke(this, new TcpConnectionEventArgs(EndPoint));
return;
}
Logger.Debug($"Read frame from Master at {EndPoint} completed {readBytes} bytes");
byte[] frame = _mbapHeader.Concat(_messageFrame).ToArray();
Logger.Trace($"RX from Master at {EndPoint}: {string.Join(", ", frame)}");
var request = _modbusFactory.CreateModbusRequest(_messageFrame);
request.TransactionId = (ushort)IPAddress.NetworkToHostOrder(BitConverter.ToInt16(frame, 0));
IModbusSlave slave = _slaveNetwork.GetSlave(request.SlaveAddress);
if (slave != null)
{
//TODO: Determine if this is appropriate
// perform action and build response
IModbusMessage response = slave.ApplyRequest(request);
response.TransactionId = request.TransactionId;
// write response
byte[] responseFrame = Transport.BuildMessageFrame(response);
Logger.Information($"TX to Master at {EndPoint}: {string.Join(", ", responseFrame)}");
await Stream.WriteAsync(responseFrame, 0, responseFrame.Length).ConfigureAwait(false);
}
}
}
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);
}
}
/// <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 slaveTcpListener = new TcpListener(address, port);
slaveTcpListener.Start();
var factory = new ModbusFactory();
var network = factory.CreateSlaveNetwork(slaveTcpListener);
IModbusSlave slave = factory.CreateSlave(slaveId);
network.AddSlave(slave);
var listenTask = network.ListenAsync();
// create the master
TcpClient masterTcpClient = new TcpClient(address.ToString(), port);
IModbusMaster master = factory.CreateMaster(masterTcpClient);
ushort numInputs = 5;
ushort startAddress = 100;
// read five register values
ushort[] inputs = master.ReadInputRegisters(0, startAddress, numInputs);
for (int i = 0; i < numInputs; i++)
{
Console.WriteLine($"Register {(startAddress + i)}={(inputs[i])}");
}
// clean up
masterTcpClient.Close();
slaveTcpListener.Stop();
// output
// Register 100=0
// Register 101=0
// Register 102=0
// Register 103=0
// Register 104=0
}
/// <summary>
/// Simple Modbus UDP slave example.
/// </summary>
public static void StartModbusUdpSlave()
{
using (UdpClient client = new UdpClient(502))
{
var factory = new ModbusFactory();
IModbusSlaveNetwork network = factory.CreateSlaveNetwork(client);
IModbusSlave slave1 = factory.CreateSlave(1);
IModbusSlave slave2 = factory.CreateSlave(2);
network.AddSlave(slave1);
network.AddSlave(slave2);
network.ListenAsync().GetAwaiter().GetResult();
// prevent the main thread from exiting
Thread.Sleep(Timeout.Infinite);
}
}
/// <summary>
/// Simple Modbus serial RTU slave example.
/// </summary>
public static async Task StartModbusSerialRtuSlaveWithCustomMessage(CancellationToken cancellationToken)
{
using (SerialPort slavePort = new SerialPort(PrimarySerialPortName))
{
// configure serial port
slavePort.BaudRate = 57600;
slavePort.DataBits = 8;
slavePort.Parity = Parity.Even;
slavePort.StopBits = StopBits.One;
slavePort.Open();
var adapter = new SerialPortAdapter(slavePort);
var functionServices = new IModbusFunctionService[]
{
new HmiBufferFunctionService()
};
var factory = new ModbusFactory(functionServices, true, new ConsoleModbusLogger(LoggingLevel.Debug));
// create modbus slave
var slaveNetwork = factory.CreateRtuSlaveNetwork(adapter);
var acTechDataStore = new SlaveStorage();
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 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 actechSlave = factory.CreateSlave(21, acTechDataStore);
IModbusSlave danfossSlave = factory.CreateSlave(1, danfossStore);
slaveNetwork.AddSlave(actechSlave);
slaveNetwork.AddSlave(danfossSlave);
await slaveNetwork.ListenAsync(cancellationToken);
}
}
/// <summary>
/// Apply the request.
/// </summary>
/// <param name="request"></param>
protected IModbusMessage ApplyRequest(IModbusMessage request)
{
//Check for broadcast requests
if (request.SlaveAddress == 0)
{
//Grab each slave
foreach (var slave in _slaves.Values)
{
try
{
//Apply the request
slave.ApplyRequest(request);
}
catch (Exception /*ex*/)
{
//Logger.Error($"Error applying request to slave {slave.UnitId}: {ex.Message}");
}
}
}
else
{
//Attempt to find a slave for this address
IModbusSlave slave = GetSlave(request.SlaveAddress);
// only service requests addressed to our slaves
if (slave == null)
{
Console.WriteLine($"NModbus Slave Network ignoring request intended for NModbus Slave {request.SlaveAddress}");
}
else
{
// perform action
return(slave.ApplyRequest(request));
}
}
return(null);
}
/// <summary>
/// Simple Modbus serial ASCII slave example.
/// </summary>
public static void StartModbusSerialAsciiSlave()
{
using (SerialPort slavePort = new SerialPort(PrimarySerialPortName))
{
// configure serial port
slavePort.BaudRate = 9600;
slavePort.DataBits = 8;
slavePort.Parity = Parity.None;
slavePort.StopBits = StopBits.One;
slavePort.Open();
var factory = new ModbusFactory();
IModbusSlaveNetwork slaveNetwork = factory.CreateAsciiSlaveNetwork(slavePort);
IModbusSlave slave1 = factory.CreateSlave(1);
IModbusSlave slave2 = factory.CreateSlave(2);
slaveNetwork.AddSlave(slave1);
slaveNetwork.AddSlave(slave2);
slaveNetwork.ListenAsync().GetAwaiter().GetResult();
}
}
void ThreadScalWork(object s, DoWorkEventArgs e)
{
if (_slavePort == null)
{
_slavePort = new SerialPort("COM3");
_slavePort.BaudRate = 115200;
_slavePort.DataBits = 8;
_slavePort.Parity = Parity.None;
_slavePort.StopBits = StopBits.Two;
_slavePort.Open();
var adapter = new SerialPortAdapter(_slavePort);
var factory = new ModbusFactory();
var slaveNetwork = factory.CreateRtuSlaveNetwork(adapter);
var dataStore = new SlaveStorage();
var transport = factory.CreateRtuTransport(adapter);
IModbusSlave slave1 = factory.CreateSlave(4, dataStore); //5 - у тестового, 4 - scalodrom
dataStore.CoilDiscretes.StorageOperationOccurred += (sender, args) =>
{
;
};
dataStore.CoilInputs.StorageOperationOccurred += (sender, args) =>
{
if (args.Operation == PointOperation.Read)
{
//i = "c-i read addr = " + args.StartingAddress.ToString() + " cnt = " + args.Points.Length.ToString();
if (false)//switchAngle)
{
//dataStore.CoilInputs.WritePoints(args.StartingAddress, new bool[] { true });
//switchAngle = false;
}
else
{
dataStore.CoilInputs.WritePoints(args.StartingAddress, new bool[] { false });
}
}
};
List <ushort> adr = new List <ushort>(); //5 addr - angle, 7 - flag
dataStore.InputRegisters.StorageOperationOccurred += (sender, args) =>
{
if (args.Operation == PointOperation.Write)
{
if (args.StartingAddress == 9)
{
}
}
else
{
//if (!adr.Contains(args.StartingAddress)) adr.Add(args.StartingAddress);
if (args.StartingAddress == 5)
{
float f = 0.0f;
f = Speed;
int m = (int)f;
byte[] b = BitConverter.GetBytes(m);
ushort high = BitConverter.ToUInt16(b, 0);
ushort low = BitConverter.ToUInt16(b, 2);
//dataStore.InputRegisters.WritePointsSilent(args.StartingAddress, new ushort[] { high, low, high, low, high, low });
}
else if (args.StartingAddress == 1)
{
//172.16.15.65
//1560 220
float f = 0.0f;
if (IsPlaying)
{
f = Speed;
}
else
{
f = 0.0f;
}
//Dbg = f.ToString();
byte[] b = BitConverter.GetBytes(f);
ushort high = BitConverter.ToUInt16(b, 0);
ushort low = BitConverter.ToUInt16(b, 2);
//_currentPoint
ushort nil = 0;
dataStore.InputRegisters.WritePointsSilent(args.StartingAddress, new ushort[] { nil, nil, nil, nil, high, low, }); //{ high, low, nil, nil, nil, nil });
//Dbg = f.ToString();
}
else if (args.StartingAddress == 9)
{
//h = args.StartingAddress.ToString() + " " + args.Points.Length.ToString();
float f = 0.0f;
//if (_currentPoint != null) f = _currentPoint.Speed;
byte[] b = BitConverter.GetBytes(f);
ushort high = BitConverter.ToUInt16(b, 0);
ushort low = BitConverter.ToUInt16(b, 2);
//dataStore.InputRegisters.WritePointsSilent(args.StartingAddress, new ushort[] { high, low });
}
else
{
//h = args.ToString() + " zzzz";
}
}
};
//8.89 на отсчет
//1280 40
//1300 220
int _prevPos = -1;
dataStore.HoldingRegisters.StorageOperationOccurred += (sender, args) =>
{
if (args.Operation == PointOperation.Write)
{
if (args.StartingAddress == 9)
{
}
else if (args.StartingAddress == 13)
{
}
else if (args.StartingAddress == 11)
{
Pos = args.Points[0];
if (args.Points[0] == TargetPos)
{
IsPlaying = false;
}
if (Pos != _prevPos)
{
X = (int)Math.Round(170.2f + 9.2f * (Pos)); // (int)(1280 + args.Points[0] * 8.89);
Y = 590; // 580 + (int)Math.Round(10.3f * (Pos));
_sendMessage = true;
}
_prevPos = Pos;
}
else if (args.StartingAddress == 7)
{
}
}
else
{
}
};
slaveNetwork.AddSlave(slave1);
try
{
slaveNetwork.ListenAsync();
}
catch (Exception exc)
{
}
}
}
public void ListenPort()
{
_slavePort = new SerialPort("COM5");
_slavePort.BaudRate = 115200;
_slavePort.DataBits = 8;
_slavePort.Parity = Parity.None;
_slavePort.StopBits = StopBits.Two;
_slavePort.Open();
var adapter = new SerialPortAdapter(_slavePort);
var factory = new ModbusFactory();
var slaveNetwork = factory.CreateRtuSlaveNetwork(adapter);
var dataStore = new SlaveStorage();
var transport = factory.CreateRtuTransport(adapter);
IModbusSlave slave1 = factory.CreateSlave(4, dataStore); //5 - у тестового, 4 - scalodrom
dataStore.CoilDiscretes.StorageOperationOccurred += (sender, args) =>
{
File.AppendAllLines("log.txt", new string[1] {
$"CoilDiscretes: {args.Operation} starting at {args.StartingAddress} {args.Points.Length}"
});
//File.AppendAllLines("log.txt", new string[1] { $"CoilDiscretes: {args.Operation} starting at {args.StartingAddress} {args.Points.Length}" });
};
dataStore.CoilInputs.StorageOperationOccurred += (sender, args) =>
{
File.AppendAllLines("log.txt", new string[1] {
$"CoilInputs: {args.Operation} starting at {args.StartingAddress} {args.Points.Length}"
});
if (args.Operation == PointOperation.Read)
{
//i = "c-i read addr = " + args.StartingAddress.ToString() + " cnt = " + args.Points.Length.ToString();
//dataStore.CoilInputs.WritePoints(args.StartingAddress, new bool[] { true });
if (Math.Abs(_currentAngle.Speed - _realAngle) > 1)
{
if (!switchAngle)
{
dataStore.CoilInputs.WritePoints(args.StartingAddress, new bool[] { true, false });
switchAngle = true;
}
}
else
{
dataStore.CoilInputs.WritePoints(args.StartingAddress, new bool[] { false, false });
switchAngle = false;
}
}
else
{
//Dbg += $"Input registers: {args.Operation} starting at {args.StartingAddress} {args.Points.Length}\r\n";
//File.AppendAllLines("log.txt", new string[1] { $"CoilInputs: {args.Operation} starting at {args.StartingAddress} {args.Points.Length}" });
}
};
List <ushort> adr = new List <ushort>(); //5 addr - angle, 7 - flag
dataStore.InputRegisters.StorageOperationOccurred += (sender, args) =>
{
File.AppendAllLines("log.txt", new string[1] {
$"InputRegisters: {args.Operation} starting at {args.StartingAddress} {args.Points.Length}"
});
if (args.Operation == PointOperation.Write)
{
//h = "yes"; //Console.WriteLine($"Input registers: {args.Operation} starting at {args.StartingAddress} {args.Points.Length}");
//i = "yes";
//Dbg += $"Input registers: {args.Operation} starting at {args.StartingAddress} {args.Points.Length}" ;
//File.AppendAllLines("log.txt", new string[1] { $"InputRegisters: {args.Operation} starting at {args.StartingAddress} {args.Points.Length}" });
}
else
{
if (args.StartingAddress == 1)
{
float curAngle = -15.0f;
byte[] ab = BitConverter.GetBytes(curAngle);
ushort high = BitConverter.ToUInt16(ab, 0);
ushort low = BitConverter.ToUInt16(ab, 2);
//dataStore.InputRegisters.WritePointsSilent(5, new ushort[] { high, low });
//172.16.15.65
float f1 = 0.0f; float f2 = 0.0f; float f3 = 0.0f;
if (IsPlaying)
{
if (_currentPoint1 != null)
{
f1 = -1 * _currentPoint1.Speed;
}
else
{
f1 = 0.0f;
}
if (_currentPoint2 != null)
{
f2 = -1 * _currentPoint2.Speed;
}
else
{
f2 = 0.0f;
}
if (_currentPoint3 != null)
{
f3 = -1 * _currentPoint3.Speed;
}
else
{
f3 = 0.0f;
}
}
else
{
f1 = 0.0f; f2 = 0.0f; f3 = 0.0f;
}
byte[] b1 = BitConverter.GetBytes(f1); byte[] b2 = BitConverter.GetBytes(f2); byte[] b3 = BitConverter.GetBytes(f3);
ushort high1 = BitConverter.ToUInt16(b1, 0); ushort high2 = BitConverter.ToUInt16(b2, 0); ushort high3 = BitConverter.ToUInt16(b3, 0);
ushort low1 = BitConverter.ToUInt16(b1, 2); ushort low2 = BitConverter.ToUInt16(b2, 2); ushort low3 = BitConverter.ToUInt16(b3, 2);
//_currentPoint1
dataStore.InputRegisters.WritePointsSilent(args.StartingAddress, new ushort[] { high3, low3, high1, low1, high2, low2 });
}
else if (args.StartingAddress == 21)
{
byte[] hl = BitConverter.GetBytes(_currentAngle.Speed);
ushort high = BitConverter.ToUInt16(hl, 0);
ushort low = BitConverter.ToUInt16(hl, 2);
dataStore.InputRegisters.WritePointsSilent(args.StartingAddress, new ushort[] { high, low });
//Dbg = _currentAngle.ToString();
}
else
{
Dbg += args.ToString() + " zzzz";
}
}
};
dataStore.HoldingRegisters.StorageOperationOccurred += (sender, args) =>
{
//Console.WriteLine($"Holding registers: {args.Operation} starting at {args.StartingAddress} {args.Points[0]}");
if (args.Operation == PointOperation.Write)
{
if (args.StartingAddress == 7)
{
ushort high = args.Points[1];
ushort low = args.Points[2];
byte[] bytes = new byte[4];
bytes[0] = (byte)(high & 0xFF);
bytes[1] = (byte)(high >> 8);
bytes[2] = (byte)(low & 0xFF);
bytes[3] = (byte)(low >> 8);
_realAngle = BitConverter.ToSingle(bytes, 0);
File.AppendAllLines("log.txt", new string[1] {
$"HoldingRegisters: {args.Operation} starting at {args.StartingAddress} {args.Points.Length} angle = {_realAngle}"
});
Dbg = _realAngle.ToString();
}
}
else
{
}
};
slaveNetwork.AddSlave(slave1);
try
{
slaveNetwork.ListenAsync();
}
catch (Exception exc) {
}
}
