Joseph Doherty
397 lines
17 KiB
C#
397 lines
17 KiB
C#
using ZB.MOM.WW.OtOpcUa.Driver.AbLegacy.PlcFamilies;
|
|
|
|
namespace ZB.MOM.WW.OtOpcUa.Driver.AbLegacy;
|
|
|
|
/// <summary>
|
|
/// Parsed PCCC file-based address: file letter + file number + word number, optionally a
|
|
/// sub-element (<c>.ACC</c> on a timer) or bit index (<c>/0</c> on a bit file).
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// <para>Logix symbolic tags are parsed elsewhere (<see cref="AbLegacy"/> is for SLC / PLC-5 /
|
|
/// MicroLogix — no symbol table; everything is file-letter + file-number + word-number).</para>
|
|
/// <list type="bullet">
|
|
/// <item><c>N7:0</c> — integer file 7, word 0 (signed 16-bit).</item>
|
|
/// <item><c>N7:5</c> — integer file 7, word 5.</item>
|
|
/// <item><c>F8:0</c> — float file 8, word 0 (32-bit IEEE754).</item>
|
|
/// <item><c>B3:0/0</c> — bit file 3, word 0, bit 0.</item>
|
|
/// <item><c>ST9:0</c> — string file 9, string 0 (82-byte fixed-length + length word).</item>
|
|
/// <item><c>T4:0.ACC</c> — timer file 4, timer 0, accumulator sub-element.</item>
|
|
/// <item><c>C5:0.PRE</c> — counter file 5, counter 0, preset sub-element.</item>
|
|
/// <item><c>I:0/0</c> — input file, slot 0, bit 0 (no file-number for I/O).</item>
|
|
/// <item><c>O:1/2</c> — output file, slot 1, bit 2.</item>
|
|
/// <item><c>S:1</c> — status file, word 1.</item>
|
|
/// <item><c>L9:0</c> — long-integer file (SLC 5/05+, 32-bit).</item>
|
|
/// </list>
|
|
/// <para>Pass the original string straight through to libplctag's <c>name=...</c> attribute —
|
|
/// the PLC-side decoder handles the format. This parser only validates the shape + surfaces
|
|
/// the structural pieces for driver-side routing (e.g. deciding whether a tag needs
|
|
/// bit-level read-modify-write).</para>
|
|
/// </remarks>
|
|
public sealed record AbLegacyAddress(
|
|
string FileLetter,
|
|
int? FileNumber,
|
|
int WordNumber,
|
|
int? BitIndex,
|
|
string? SubElement,
|
|
AbLegacyAddress? IndirectFileSource = null,
|
|
AbLegacyAddress? IndirectWordSource = null,
|
|
int? ArrayCount = null)
|
|
{
|
|
/// <summary>
|
|
/// PR 7 — PCCC frame ceiling. A single SLC/PLC-5 PCCC read can return up to about 240
|
|
/// bytes (~120 INT words / 60 DINTs / 60 floats). The parser caps <see cref="ArrayCount"/>
|
|
/// at 120 so a misconfigured tag fails fast instead of bouncing off the wire as a fragmented
|
|
/// multi-frame read.
|
|
/// </summary>
|
|
public const int MaxArrayCount = 120;
|
|
|
|
/// <summary>
|
|
/// True when either the file number or the word number is sourced from another PCCC
|
|
/// address evaluated at runtime (PLC-5 / SLC indirect addressing — <c>N7:[N7:0]</c> or
|
|
/// <c>N[N7:0]:5</c>). libplctag PCCC does not natively decode bracket-form indirection,
|
|
/// so the runtime layer must resolve the inner address first and rewrite the tag name
|
|
/// before issuing the actual read/write. See <see cref="ToLibplctagName"/>.
|
|
/// </summary>
|
|
public bool IsIndirect => IndirectFileSource is not null || IndirectWordSource is not null;
|
|
|
|
public string ToLibplctagName()
|
|
{
|
|
// Re-emit using bracket form when indirect. libplctag's PCCC text decoder does not
|
|
// accept the bracket form directly — callers that need a libplctag-ready name must
|
|
// resolve the inner addresses first and substitute concrete numbers. Driver runtime
|
|
// path (TODO: resolve-then-read) is gated on IsIndirect.
|
|
string filePart;
|
|
if (IndirectFileSource is not null)
|
|
{
|
|
filePart = $"{FileLetter}[{IndirectFileSource.ToLibplctagName()}]";
|
|
}
|
|
else
|
|
{
|
|
filePart = FileNumber is null ? FileLetter : $"{FileLetter}{FileNumber}";
|
|
}
|
|
|
|
string wordSegment = IndirectWordSource is not null
|
|
? $"[{IndirectWordSource.ToLibplctagName()}]"
|
|
: WordNumber.ToString();
|
|
|
|
var wordPart = $"{filePart}:{wordSegment}";
|
|
// PR 7 — emit libplctag's `[N]` array suffix when the parsed address carries an
|
|
// ArrayCount. libplctag's PCCC text decoder treats `N7:0[10]` as "10 consecutive
|
|
// words starting at N7:0"; the comma form (`N7:0,10`) is Rockwell-native and gets
|
|
// canonicalised to bracket form here so the driver always hands libplctag a single
|
|
// recognisable shape.
|
|
if (ArrayCount is int n) wordPart += $"[{n}]";
|
|
if (SubElement is not null) wordPart += $".{SubElement}";
|
|
if (BitIndex is not null) wordPart += $"/{BitIndex}";
|
|
return wordPart;
|
|
}
|
|
|
|
public static AbLegacyAddress? TryParse(string? value) => TryParse(value, family: null);
|
|
|
|
/// <summary>
|
|
/// Family-aware parser. PLC-5 (RSLogix 5) displays the word + bit indices on
|
|
/// <c>I:</c>/<c>O:</c> file references as octal — <c>I:001/17</c> is rack 1, bit 15.
|
|
/// Pass the device's family so the parser can interpret those digits as octal when the
|
|
/// family's <see cref="AbLegacyPlcFamilyProfile.OctalIoAddressing"/> is true. The parsed
|
|
/// record stores decimal values; <see cref="ToLibplctagName"/> emits decimal too, which
|
|
/// is what libplctag's PCCC layer expects.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Also accepts indirect / indexed forms (Issue #247): <c>N7:[N7:0]</c> reads file 7,
|
|
/// word=value-of(N7:0); <c>N[N7:0]:5</c> reads file=value-of(N7:0), word 5. Recursion
|
|
/// depth is capped at 1 — the inner address must be a plain direct PCCC address.
|
|
/// </remarks>
|
|
public static AbLegacyAddress? TryParse(string? value, AbLegacyPlcFamily? family)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(value)) return null;
|
|
var src = value.Trim();
|
|
|
|
var profile = family is null ? null : AbLegacyPlcFamilyProfile.ForFamily(family.Value);
|
|
|
|
// BitIndex: trailing /N. Defer numeric parsing until the file letter is known — PLC-5
|
|
// I:/O: bit indices are octal in RSLogix 5, everything else is decimal.
|
|
string? bitText = null;
|
|
var slashIdx = src.LastIndexOf('/');
|
|
if (slashIdx >= 0 && slashIdx > src.LastIndexOf(']'))
|
|
{
|
|
bitText = src[(slashIdx + 1)..];
|
|
src = src[..slashIdx];
|
|
}
|
|
|
|
return ParseTail(src, bitText, profile, allowIndirect: true);
|
|
}
|
|
|
|
private static AbLegacyAddress? ParseTail(string src, string? bitText, AbLegacyPlcFamilyProfile? profile, bool allowIndirect)
|
|
{
|
|
// SubElement: trailing .NAME (ACC / PRE / EN / DN / TT / CU / CD / FD / etc.)
|
|
// Only consider dots OUTSIDE of any bracketed inner address — the inner address may
|
|
// itself contain a sub-element dot (e.g. N[T4:0.ACC]:5).
|
|
string? subElement = null;
|
|
var dotIdx = LastIndexOfTopLevel(src, '.');
|
|
if (dotIdx >= 0)
|
|
{
|
|
var candidate = src[(dotIdx + 1)..];
|
|
if (candidate.Length > 0 && candidate.All(char.IsLetter))
|
|
{
|
|
subElement = candidate.ToUpperInvariant();
|
|
src = src[..dotIdx];
|
|
}
|
|
}
|
|
|
|
var colonIdx = IndexOfTopLevel(src, ':');
|
|
if (colonIdx <= 0) return null;
|
|
var filePart = src[..colonIdx];
|
|
var wordPart = src[(colonIdx + 1)..];
|
|
|
|
// File letter (always literal) + optional file number — either decimal digits or a
|
|
// bracketed indirect address like N[N7:0].
|
|
if (filePart.Length == 0 || !char.IsLetter(filePart[0])) return null;
|
|
var letterEnd = 1;
|
|
while (letterEnd < filePart.Length && char.IsLetter(filePart[letterEnd])) letterEnd++;
|
|
|
|
var letter = filePart[..letterEnd].ToUpperInvariant();
|
|
int? fileNumber = null;
|
|
AbLegacyAddress? indirectFile = null;
|
|
if (letterEnd < filePart.Length)
|
|
{
|
|
var fileTail = filePart[letterEnd..];
|
|
if (fileTail.Length >= 2 && fileTail[0] == '[' && fileTail[^1] == ']')
|
|
{
|
|
if (!allowIndirect) return null;
|
|
var inner = fileTail[1..^1];
|
|
indirectFile = ParseInner(inner, profile);
|
|
if (indirectFile is null) return null;
|
|
}
|
|
else
|
|
{
|
|
if (!int.TryParse(fileTail, out var fn) || fn < 0) return null;
|
|
fileNumber = fn;
|
|
}
|
|
}
|
|
|
|
// Reject unknown file letters — these cover SLC/ML/PLC-5 canonical families.
|
|
// Function-file letters (RTC/HSC/DLS/MMI/PTO/PWM/STI/EII/IOS/BHI) are MicroLogix-only.
|
|
// Structure-file letters (PD/MG/PLS/BT) are gated per family — PD/MG are common on
|
|
// SLC500 + PLC-5; PLS/BT are PLC-5 only. MicroLogix and LogixPccc reject them.
|
|
if (!IsKnownFileLetter(letter))
|
|
{
|
|
if (IsFunctionFileLetter(letter))
|
|
{
|
|
if (profile?.SupportsFunctionFiles != true) return null;
|
|
}
|
|
else if (IsStructureFileLetter(letter))
|
|
{
|
|
if (!StructureFileSupported(letter, profile)) return null;
|
|
}
|
|
else return null;
|
|
}
|
|
|
|
var octalForIo = profile?.OctalIoAddressing == true && (letter == "I" || letter == "O");
|
|
|
|
// PR 7 — strip an optional array suffix from the trailing edge of the word part.
|
|
// Two accepted forms: Rockwell-native `,N` (e.g. `N7:0,10`) and libplctag-native
|
|
// `[N]` (e.g. `N7:0[10]`). Both resolve to the same ArrayCount. The bracket form
|
|
// collides syntactically with the indirect-word form (`N7:[N7:0]`) — the
|
|
// disambiguation is "leading bracket = indirect; trailing bracket after the
|
|
// numeric word literal = array". A trailing `[N]` may also follow an indirect
|
|
// word (`N7:[N7:0][10]`) — supported.
|
|
int? arrayCount = null;
|
|
|
|
// Try comma form first — only meaningful when no leading-bracket indirect form is
|
|
// present. Comma never appears in indirect-word source addresses (those use ':').
|
|
var commaIdx = wordPart.LastIndexOf(',');
|
|
if (commaIdx > 0 && wordPart[0] != '[')
|
|
{
|
|
var arrayText = wordPart[(commaIdx + 1)..];
|
|
if (!int.TryParse(arrayText, out var ac) || ac < 1 || ac > MaxArrayCount) return null;
|
|
arrayCount = ac;
|
|
wordPart = wordPart[..commaIdx];
|
|
}
|
|
else if (wordPart.Length > 0 && wordPart[^1] == ']')
|
|
{
|
|
// Trailing `[N]` — only valid when there's already a primary word/indirect
|
|
// segment in front of it. Walk back to the matching `[`.
|
|
// Use top-level-aware index so a nested indirect like `[N7:0]` doesn't trip us.
|
|
// We want the LAST top-level `[` whose body is a pure integer.
|
|
var openIdx = MatchingOpenBracket(wordPart, wordPart.Length - 1);
|
|
if (openIdx > 0)
|
|
{
|
|
var arrayText = wordPart[(openIdx + 1)..^1];
|
|
if (int.TryParse(arrayText, out var ac))
|
|
{
|
|
if (ac < 1 || ac > MaxArrayCount) return null;
|
|
arrayCount = ac;
|
|
wordPart = wordPart[..openIdx];
|
|
}
|
|
// If the bracket body isn't a pure integer, leave wordPart alone — likely
|
|
// an indirect-word source address (handled below) or malformed input.
|
|
}
|
|
}
|
|
|
|
// Word part: either a numeric literal (octal-aware for PLC-5 I:/O:) or a bracketed
|
|
// indirect address.
|
|
int word = 0;
|
|
AbLegacyAddress? indirectWord = null;
|
|
if (wordPart.Length >= 2 && wordPart[0] == '[' && wordPart[^1] == ']')
|
|
{
|
|
if (!allowIndirect) return null;
|
|
var inner = wordPart[1..^1];
|
|
indirectWord = ParseInner(inner, profile);
|
|
if (indirectWord is null) return null;
|
|
}
|
|
else
|
|
{
|
|
if (!TryParseIndex(wordPart, octalForIo, out word) || word < 0) return null;
|
|
}
|
|
|
|
int? bitIndex = null;
|
|
if (bitText is not null)
|
|
{
|
|
if (!TryParseIndex(bitText, octalForIo, out var bit) || bit < 0 || bit > 31) return null;
|
|
bitIndex = bit;
|
|
}
|
|
|
|
// PR 7 — array tags can't combine with a bit suffix (`N7:0,10/3` is meaningless —
|
|
// "the third bit of ten different words"?) or with a sub-element pull (`T4:0,5.ACC`
|
|
// is also meaningless — the sub-element targets one timer's accumulator). The
|
|
// libplctag PCCC layer would silently accept the combination; reject up-front so
|
|
// the OPC UA client sees a clean parse failure rather than a wire-level surprise.
|
|
if (arrayCount is not null)
|
|
{
|
|
if (bitIndex is not null) return null;
|
|
if (subElement is not null) return null;
|
|
}
|
|
|
|
return new AbLegacyAddress(letter, fileNumber, word, bitIndex, subElement, indirectFile, indirectWord, arrayCount);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Find the index of the `[` that matches the `]` at <paramref name="closeIdx"/> in
|
|
/// <paramref name="s"/>, accounting for nested brackets. Returns -1 if no match.
|
|
/// </summary>
|
|
private static int MatchingOpenBracket(string s, int closeIdx)
|
|
{
|
|
if (closeIdx < 0 || closeIdx >= s.Length || s[closeIdx] != ']') return -1;
|
|
var depth = 1;
|
|
for (var i = closeIdx - 1; i >= 0; i--)
|
|
{
|
|
if (s[i] == ']') depth++;
|
|
else if (s[i] == '[')
|
|
{
|
|
depth--;
|
|
if (depth == 0) return i;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Parse an inner (bracketed) PCCC address with depth-1 cap. The inner address itself
|
|
/// must NOT be indirect — nesting beyond one level is rejected.
|
|
/// </summary>
|
|
private static AbLegacyAddress? ParseInner(string inner, AbLegacyPlcFamilyProfile? profile)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(inner)) return null;
|
|
var src = inner.Trim();
|
|
// Reject any further bracket — depth cap at 1.
|
|
if (src.IndexOf('[') >= 0 || src.IndexOf(']') >= 0) return null;
|
|
|
|
string? bitText = null;
|
|
var slashIdx = src.LastIndexOf('/');
|
|
if (slashIdx >= 0)
|
|
{
|
|
bitText = src[(slashIdx + 1)..];
|
|
src = src[..slashIdx];
|
|
}
|
|
return ParseTail(src, bitText, profile, allowIndirect: false);
|
|
}
|
|
|
|
private static int IndexOfTopLevel(string s, char c)
|
|
{
|
|
var depth = 0;
|
|
for (var i = 0; i < s.Length; i++)
|
|
{
|
|
if (s[i] == '[') depth++;
|
|
else if (s[i] == ']') depth--;
|
|
else if (depth == 0 && s[i] == c) return i;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
private static int LastIndexOfTopLevel(string s, char c)
|
|
{
|
|
var depth = 0;
|
|
var last = -1;
|
|
for (var i = 0; i < s.Length; i++)
|
|
{
|
|
if (s[i] == '[') depth++;
|
|
else if (s[i] == ']') depth--;
|
|
else if (depth == 0 && s[i] == c) last = i;
|
|
}
|
|
return last;
|
|
}
|
|
|
|
private static bool TryParseIndex(string text, bool octal, out int value)
|
|
{
|
|
if (octal)
|
|
{
|
|
// Octal accepts only digits 0-7. Reject 8/9 explicitly.
|
|
if (text.Length == 0) { value = 0; return false; }
|
|
var start = 0;
|
|
var sign = 1;
|
|
if (text[0] == '-') { sign = -1; start = 1; }
|
|
if (start >= text.Length) { value = 0; return false; }
|
|
var acc = 0;
|
|
for (var i = start; i < text.Length; i++)
|
|
{
|
|
var c = text[i];
|
|
if (c < '0' || c > '7') { value = 0; return false; }
|
|
acc = (acc * 8) + (c - '0');
|
|
}
|
|
value = sign * acc;
|
|
return true;
|
|
}
|
|
return int.TryParse(text, out value);
|
|
}
|
|
|
|
private static bool IsKnownFileLetter(string letter) => letter switch
|
|
{
|
|
"N" or "F" or "B" or "L" or "ST" or "T" or "C" or "R" or "I" or "O" or "S" or "A" => true,
|
|
_ => false,
|
|
};
|
|
|
|
/// <summary>
|
|
/// MicroLogix 1100/1400 function-file prefixes. Each maps to a single fixed instance with a
|
|
/// known sub-element catalogue (see <see cref="AbLegacyDataType"/>).
|
|
/// </summary>
|
|
internal static bool IsFunctionFileLetter(string letter) => letter switch
|
|
{
|
|
"RTC" or "HSC" or "DLS" or "MMI" or "PTO" or "PWM" or "STI" or "EII" or "IOS" or "BHI" => true,
|
|
_ => false,
|
|
};
|
|
|
|
/// <summary>
|
|
/// Structure-file prefixes added in #248: PD (PID), MG (Message), PLS (Programmable Limit
|
|
/// Switch), BT (Block Transfer). Per-family availability is gated by the matching
|
|
/// <c>Supports*File</c> flag on <see cref="AbLegacyPlcFamilyProfile"/>.
|
|
/// </summary>
|
|
internal static bool IsStructureFileLetter(string letter) => letter switch
|
|
{
|
|
"PD" or "MG" or "PLS" or "BT" => true,
|
|
_ => false,
|
|
};
|
|
|
|
private static bool StructureFileSupported(string letter, AbLegacyPlcFamilyProfile? profile)
|
|
{
|
|
if (profile is null) return false;
|
|
return letter switch
|
|
{
|
|
"PD" => profile.SupportsPidFile,
|
|
"MG" => profile.SupportsMessageFile,
|
|
"PLS" => profile.SupportsPlsFile,
|
|
"BT" => profile.SupportsBlockTransferFile,
|
|
_ => false,
|
|
};
|
|
}
|
|
}
|