Joseph Doherty
0ca56cb1f6
Live read-only check against a production CompactLogix press: with one nonexistent tag
first in the read list, libplctag's create threw LibPlcTagException("ErrorNotFound"); the
driver counted it as a failed Forward-Open, opened the device's 05/STAB-8 connect-backoff
window, and every other cold tag on the device - all real (WW_InCycle, WW_ActualPress,
WW_WorkOrderNum) - read BadCommunicationError. In steady polling the bad tag re-opens
the window each attempt, so siblings ordered after it may never connect.
- A create that fails with a "controller answered" status (NotFound/NoMatch/BadDevice,
the probe's existing reachable classification) records backoff SUCCESS, not failure.
Genuine connection failures still open the window (falsification control test).
- Read exceptions map through the libplctag Status they carry: unknown tag ->
BadNodeIdUnknown, decode past the buffer -> BadOutOfRange, timeout -> BadTimeout,
instead of a blanket BadCommunicationError. One status-name parser
(AbCipStatusMapper.TryGetStatus) now serves both the read path and the probe.
130 lines
6.9 KiB
C#
130 lines
6.9 KiB
C#
using libplctag;
|
|
|
|
namespace ZB.MOM.WW.OtOpcUa.Driver.AbCip;
|
|
|
|
/// <summary>
|
|
/// Maps libplctag / CIP General Status codes to OPC UA StatusCodes. Mirrors the shape of
|
|
/// <c>ModbusDriver.MapModbusExceptionToStatus</c> so Admin UI status displays stay
|
|
/// uniform across drivers.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// <para>Coverage: the CIP general-status values an AB PLC actually returns during normal
|
|
/// driver operation. Full CIP Volume 1 Appendix B lists 50+ codes; the ones here are the
|
|
/// ones that move the driver's status needle:</para>
|
|
/// <list type="bullet">
|
|
/// <item>0x00 success — OPC UA <c>Good (0)</c>.</item>
|
|
/// <item>0x04 path segment error / 0x05 path destination unknown — <c>BadNodeIdUnknown</c>
|
|
/// (tag doesn't exist).</item>
|
|
/// <item>0x06 partial data transfer — <c>GoodMoreData</c> (fragmented read underway).</item>
|
|
/// <item>0x08 service not supported — <c>BadNotSupported</c> (e.g. write on a safety
|
|
/// partition tag from a non-safety task).</item>
|
|
/// <item>0x0A / 0x13 attribute-list error / insufficient data — <c>BadOutOfRange</c>
|
|
/// (type mismatch or truncated buffer).</item>
|
|
/// <item>0x0B already in requested mode — benign, treated as <c>Good</c>.</item>
|
|
/// <item>0x0E attribute not settable — <c>BadNotWritable</c>.</item>
|
|
/// <item>0x10 device state conflict — <c>BadDeviceFailure</c> (program-mode protected
|
|
/// writes during download / test-mode transitions).</item>
|
|
/// <item>0x16 object does not exist — <c>BadNodeIdUnknown</c>.</item>
|
|
/// <item>0x1E embedded service error — unwrap to the extended status when possible.</item>
|
|
/// <item>libplctag.NET <see cref="Status"/> errors — mapped per-member by
|
|
/// <see cref="MapLibplctagStatus(Status)"/>: timeout, not-found, not-allowed, and
|
|
/// out-of-bounds get their specific OPC UA codes; the remaining transport errors
|
|
/// fold into <c>BadCommunicationError</c>.</item>
|
|
/// </list>
|
|
/// </remarks>
|
|
public static class AbCipStatusMapper
|
|
{
|
|
public const uint Good = 0u;
|
|
public const uint GoodMoreData = 0x00A60000u;
|
|
public const uint BadInternalError = 0x80020000u;
|
|
public const uint BadNodeIdUnknown = 0x80340000u;
|
|
public const uint BadNotWritable = 0x803B0000u;
|
|
public const uint BadOutOfRange = 0x803C0000u;
|
|
public const uint BadNotSupported = 0x803D0000u;
|
|
public const uint BadDeviceFailure = 0x808B0000u;
|
|
public const uint BadCommunicationError = 0x80050000u;
|
|
public const uint BadTimeout = 0x800A0000u;
|
|
public const uint BadTypeMismatch = 0x80740000u;
|
|
|
|
/// <summary>Map a CIP general-status byte to an OPC UA StatusCode.</summary>
|
|
/// <param name="status">The CIP general-status byte value.</param>
|
|
/// <returns>The mapped OPC UA StatusCode value.</returns>
|
|
public static uint MapCipGeneralStatus(byte status) => status switch
|
|
{
|
|
0x00 => Good,
|
|
0x04 or 0x05 => BadNodeIdUnknown,
|
|
0x06 => GoodMoreData,
|
|
0x08 => BadNotSupported,
|
|
0x0A or 0x13 => BadOutOfRange,
|
|
0x0B => Good,
|
|
0x0E => BadNotWritable,
|
|
0x10 => BadDeviceFailure,
|
|
0x16 => BadNodeIdUnknown,
|
|
_ => BadInternalError,
|
|
};
|
|
|
|
/// <summary>
|
|
/// Map a libplctag return/status code to an OPC UA StatusCode. The integer passed here
|
|
/// is <c>(int)Tag.GetStatus()</c> — i.e. the underlying value of the libplctag.NET
|
|
/// <see cref="Status"/> enum, NOT a raw native <c>PLCTAG_ERR_*</c> constant. The wrapper
|
|
/// renumbers the native codes into a contiguous enum, so this method switches on the
|
|
/// <see cref="Status"/> members directly to stay correct if the wrapper renumbers again.
|
|
/// <see cref="Status.Ok"/> is success; <see cref="Status.Pending"/> is an in-flight
|
|
/// operation; every other (negative) member is an error.
|
|
/// </summary>
|
|
/// <param name="status">The libplctag status code as an integer.</param>
|
|
/// <returns>The mapped OPC UA StatusCode value.</returns>
|
|
public static uint MapLibplctagStatus(int status) => MapLibplctagStatus((Status)status);
|
|
|
|
/// <summary>
|
|
/// Recover the libplctag <see cref="Status"/> a <see cref="LibPlcTagException"/> was thrown on.
|
|
/// The wrapper builds the exception from <c>Status.ToString()</c>, so the message is the enum
|
|
/// name (<c>"ErrorNotFound"</c>).
|
|
/// </summary>
|
|
/// <param name="ex">The exception.</param>
|
|
/// <param name="status">The recovered status.</param>
|
|
/// <returns><c>true</c> when the message names a defined <see cref="Status"/>.</returns>
|
|
public static bool TryGetStatus(LibPlcTagException ex, out Status status)
|
|
{
|
|
ArgumentNullException.ThrowIfNull(ex);
|
|
return Enum.TryParse((ex.Message ?? string.Empty).Trim(), ignoreCase: true, out status)
|
|
&& Enum.IsDefined(status);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Status for an exception thrown while creating / reading a tag: a libplctag exception maps
|
|
/// through its <see cref="Status"/> (so a tag the controller does not have reads
|
|
/// <see cref="BadNodeIdUnknown"/>, not a comms error); anything else is
|
|
/// <see cref="BadCommunicationError"/>.
|
|
/// </summary>
|
|
/// <param name="ex">The exception.</param>
|
|
/// <returns>The OPC UA status code.</returns>
|
|
public static uint MapException(Exception ex) =>
|
|
ex is LibPlcTagException lpe && TryGetStatus(lpe, out var status)
|
|
? MapLibplctagStatus(status)
|
|
: BadCommunicationError;
|
|
|
|
/// <summary>
|
|
/// Map a libplctag.NET <see cref="Status"/> enum value to an OPC UA StatusCode. This is
|
|
/// the strongly-typed core of the mapper; the <c>int</c> overload exists only for the
|
|
/// <see cref="IAbCipTagRuntime.GetStatus"/> seam, which returns the boxed-as-int value.
|
|
/// </summary>
|
|
/// <param name="status">The libplctag Status enum value.</param>
|
|
/// <returns>The mapped OPC UA StatusCode value.</returns>
|
|
public static uint MapLibplctagStatus(Status status) => status switch
|
|
{
|
|
Status.Ok => Good,
|
|
Status.Pending => GoodMoreData,
|
|
Status.ErrorTimeout => BadTimeout,
|
|
Status.ErrorNotFound or Status.ErrorNoMatch or Status.ErrorBadDevice => BadNodeIdUnknown,
|
|
Status.ErrorNotAllowed => BadNotWritable,
|
|
Status.ErrorOutOfBounds or Status.ErrorTooLarge or Status.ErrorTooSmall => BadOutOfRange,
|
|
Status.ErrorUnsupported or Status.ErrorNotImplemented => BadNotSupported,
|
|
Status.ErrorBadConnection or Status.ErrorBadGateway or Status.ErrorBadReply
|
|
or Status.ErrorWinsock or Status.ErrorOpen or Status.ErrorClose
|
|
or Status.ErrorRead or Status.ErrorWrite or Status.ErrorRemoteErr
|
|
or Status.ErrorPartial or Status.ErrorAbort => BadCommunicationError,
|
|
_ => BadCommunicationError,
|
|
};
|
|
}
|