Joseph Doherty
99 lines
3.9 KiB
C#
99 lines
3.9 KiB
C#
using System.Diagnostics;
|
|
using System.Net.Sockets;
|
|
using System.Text.Json;
|
|
using System.Text.Json.Serialization;
|
|
using ZB.MOM.WW.OtOpcUa.Core.Abstractions;
|
|
|
|
namespace ZB.MOM.WW.OtOpcUa.Driver.Modbus;
|
|
|
|
/// <summary>
|
|
/// Modbus FC03 probe for the <see cref="ModbusDriverOptions"/>-shaped driver config.
|
|
/// Opens a TCP connection to the configured endpoint and sends a one-shot FC03
|
|
/// (Read Holding Registers, qty 1 @ address 0) handshake. A normal FC03 response
|
|
/// or a Modbus exception PDU both confirm a live Modbus device (green + latency);
|
|
/// TCP failure surfaces the SocketError; a Modbus-level handshake failure after
|
|
/// TCP succeeds surfaces a targeted message; timeout surfaces "timed out after Ns."
|
|
/// </summary>
|
|
public sealed class ModbusDriverProbe : IDriverProbe
|
|
{
|
|
private static readonly JsonSerializerOptions _opts = new()
|
|
{
|
|
PropertyNameCaseInsensitive = true,
|
|
UnmappedMemberHandling = JsonUnmappedMemberHandling.Skip,
|
|
};
|
|
|
|
// FC03 Read Holding Registers: function=0x03, addr-hi=0, addr-lo=0, qty-hi=0, qty-lo=1
|
|
private static readonly byte[] Fc03Pdu = [0x03, 0x00, 0x00, 0x00, 0x01];
|
|
|
|
/// <inheritdoc />
|
|
public string DriverType => "Modbus";
|
|
|
|
/// <inheritdoc />
|
|
public async Task<DriverProbeResult> ProbeAsync(string configJson, TimeSpan timeout, CancellationToken ct)
|
|
{
|
|
ModbusDriverOptions? opts;
|
|
try { opts = JsonSerializer.Deserialize<ModbusDriverOptions>(configJson, _opts); }
|
|
catch (Exception ex) { return new(false, $"Config JSON is invalid: {ex.Message}", null); }
|
|
if (opts is null) return new(false, "Config JSON deserialized to null.", null);
|
|
|
|
var (host, port) = ExtractTarget(opts);
|
|
if (string.IsNullOrWhiteSpace(host) || port <= 0)
|
|
return new(false, "Config has no host/port to probe.", null);
|
|
|
|
var unitId = opts.UnitId;
|
|
|
|
var sw = Stopwatch.StartNew();
|
|
using var cts = CancellationTokenSource.CreateLinkedTokenSource(ct);
|
|
cts.CancelAfter(timeout);
|
|
|
|
// Phase 1 — TCP connect (using ModbusTcpTransport which handles IPv4 preference).
|
|
// autoReconnect=false: this is a one-shot probe, no retry loops.
|
|
var transport = new ModbusTcpTransport(host, port, timeout, autoReconnect: false);
|
|
await using (transport.ConfigureAwait(false))
|
|
{
|
|
try
|
|
{
|
|
await transport.ConnectAsync(cts.Token).ConfigureAwait(false);
|
|
}
|
|
catch (SocketException ex)
|
|
{
|
|
return new(false, $"Connect failed: {ex.SocketErrorCode}", null);
|
|
}
|
|
catch (OperationCanceledException)
|
|
{
|
|
return new(false, $"Probe timed out after {timeout.TotalSeconds:F0}s.", null);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return new(false, ex.Message, null);
|
|
}
|
|
|
|
// Phase 2 — FC03 handshake. TCP is up; now prove a Modbus device is answering.
|
|
try
|
|
{
|
|
await transport.SendAsync(unitId, Fc03Pdu, cts.Token).ConfigureAwait(false);
|
|
sw.Stop();
|
|
return new(true, "Modbus FC03 OK", sw.Elapsed);
|
|
}
|
|
catch (ModbusException)
|
|
{
|
|
// Device replied with an exception PDU — it IS a real Modbus device.
|
|
sw.Stop();
|
|
return new(true, "Modbus FC03 OK (device returned exception PDU)", sw.Elapsed);
|
|
}
|
|
catch (OperationCanceledException)
|
|
{
|
|
return new(false, $"Probe timed out after {timeout.TotalSeconds:F0}s.", null);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
sw.Stop();
|
|
return new(false, $"Reachable at {host}:{port} but Modbus FC03 handshake failed: {ex.Message}", null);
|
|
}
|
|
}
|
|
}
|
|
|
|
private static (string host, int port) ExtractTarget(ModbusDriverOptions opts)
|
|
=> (opts.Host, opts.Port);
|
|
}
|