826312befe
Clears CommentChecker findings in src/ (3,280 -> 209, the remainder being false positives like PLC-5/IEEE-754/M0.0) by adding missing summaries/params/returns, normalising inheritdoc usage, and removing Gitea/review tracking IDs while keeping the rationale they annotated. Comment-only: comment-stripped sources are identical to the parent commit.
117 lines
5.6 KiB
C#
117 lines
5.6 KiB
C#
namespace ZB.MOM.WW.OtOpcUa.Driver.Ab.Transport.Pccc;
|
|
|
|
/// <summary>Transport-side PCCC data-table address. Independent of the driver's AbLegacyAddress.</summary>
|
|
/// <param name="FileLetter">File letter(s): N, F, B, T, C, R, ST, L, A, I, O, S.</param>
|
|
/// <param name="FileNumber">Explicit file number; null for O/I/S (implicit 0/1/2).</param>
|
|
/// <param name="Element">Element (word) number.</param>
|
|
/// <param name="SubElement">Word offset within a structured element (T/C: PRE=1, ACC=2; R: LEN=1, POS=2); null = 0.</param>
|
|
/// <param name="Bit">Bit within the addressed word (<c>/n</c> or a status-bit sub-element), else null.</param>
|
|
public sealed record PcccAddress(string FileLetter, int? FileNumber, int Element, int? SubElement, int? Bit = null)
|
|
{
|
|
/// <summary>The PCCC file-type byte; throws Unsupported for an unknown letter.</summary>
|
|
public byte FileTypeCode =>
|
|
PcccFileType.CodeFor(FileLetter)
|
|
?? throw new AbTransportException(AbStatus.Unsupported, $"Unknown PCCC file type '{FileLetter}'.");
|
|
|
|
/// <summary>Explicit file number, else the implicit one for O/I/S.</summary>
|
|
public int EffectiveFileNumber =>
|
|
FileNumber ?? PcccFileType.ImplicitFileNumber(FileLetter)
|
|
?? throw new AbTransportException(AbStatus.Unsupported, $"File type '{FileLetter}' needs an explicit file number.");
|
|
|
|
/// <summary>The word offset to read within the element, and the bit within that word if any.</summary>
|
|
/// <returns>The word offset and the optional bit index.</returns>
|
|
public (int Word, int? Bit) ResolveSubElement() => (SubElement ?? 0, Bit);
|
|
|
|
/// <summary>Builds an address from a sub-element mnemonic (PRE, ACC, LEN, POS, or a status bit such as DN).</summary>
|
|
/// <param name="letter">The file letter (T, C or R).</param>
|
|
/// <param name="fileNumber">The explicit file number, or null for the implicit one.</param>
|
|
/// <param name="element">The element number.</param>
|
|
/// <param name="subName">The sub-element mnemonic.</param>
|
|
/// <returns>The resolved address.</returns>
|
|
public static PcccAddress WithSubElementName(string letter, int? fileNumber, int element, string subName)
|
|
{
|
|
var l = letter.ToUpperInvariant();
|
|
var s = subName.ToUpperInvariant();
|
|
(int Word, int? Bit)? r = (l, s) switch
|
|
{
|
|
("T" or "C", "PRE") => (1, null),
|
|
("T" or "C", "ACC") => (2, null),
|
|
("R", "LEN") => (1, null),
|
|
("R", "POS") => (2, null),
|
|
("T", "EN") => (0, 15),
|
|
("T", "TT") => (0, 14),
|
|
("T", "DN") => (0, 13),
|
|
("C", "CU") => (0, 15),
|
|
("C", "CD") => (0, 14),
|
|
("C", "DN") => (0, 13),
|
|
("C", "OV") => (0, 12),
|
|
("C", "UN") => (0, 11),
|
|
("C", "UA") => (0, 10),
|
|
("R", "EN") => (0, 15),
|
|
("R", "EU") => (0, 14),
|
|
("R", "DN") => (0, 13),
|
|
("R", "EM") => (0, 12),
|
|
("R", "ER") => (0, 11),
|
|
("R", "UL") => (0, 10),
|
|
("R", "IN") => (0, 9),
|
|
("R", "FD") => (0, 8),
|
|
_ => null,
|
|
};
|
|
if (r is not { } v)
|
|
throw new AbTransportException(AbStatus.Unsupported, $"Unknown sub-element '{subName}' for file type '{letter}'.");
|
|
return new PcccAddress(l, fileNumber, element, v.Word, v.Bit);
|
|
}
|
|
|
|
/// <summary>Parses <c>N7:0</c>, <c>B3:1/4</c>, <c>T4:0.ACC</c>, <c>I:0/1</c>, <c>ST9:2</c>; null when malformed.</summary>
|
|
/// <param name="text">The address text.</param>
|
|
/// <returns>The parsed address, or null when the text is malformed.</returns>
|
|
public static PcccAddress? TryParse(string? text)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(text)) return null;
|
|
var src = text.Trim();
|
|
int? bit = null;
|
|
var slash = src.IndexOf('/');
|
|
if (slash >= 0)
|
|
{
|
|
if (!int.TryParse(src[(slash + 1)..], out var b) || b < 0) return null;
|
|
bit = b;
|
|
src = src[..slash];
|
|
}
|
|
string? sub = null;
|
|
var dot = src.LastIndexOf('.');
|
|
if (dot >= 0)
|
|
{
|
|
sub = src[(dot + 1)..];
|
|
if (sub.Length == 0 || !sub.All(char.IsLetter)) return null;
|
|
src = src[..dot];
|
|
}
|
|
var colon = src.IndexOf(':');
|
|
if (colon <= 0 || !int.TryParse(src[(colon + 1)..], out var element) || element < 0) return null;
|
|
var filePart = src[..colon];
|
|
if (!char.IsLetter(filePart[0])) return null;
|
|
var end = 1;
|
|
while (end < filePart.Length && char.IsLetter(filePart[end])) end++;
|
|
var letter = filePart[..end].ToUpperInvariant();
|
|
if (PcccFileType.CodeFor(letter) is null) return null;
|
|
int? file = null;
|
|
if (end < filePart.Length)
|
|
{
|
|
if (!int.TryParse(filePart[end..], out var fn) || fn < 0) return null;
|
|
file = fn;
|
|
}
|
|
var implicitFile = PcccFileType.ImplicitFileNumber(letter);
|
|
if (implicitFile is not null && file is not null) return null;
|
|
if (implicitFile is null && file is null) return null;
|
|
if (sub is not null && bit is not null) return null;
|
|
if (bit is int bb)
|
|
{
|
|
// Same limits as AbLegacyAddress: 16-bit words N/B/I/O/S/A 0-15, L 0-31; no bits on F/T/C/R/ST.
|
|
var max = letter switch { "L" => 31, "N" or "B" or "I" or "O" or "S" or "A" => 15, _ => -1 };
|
|
if (bb > max) return null;
|
|
}
|
|
if (sub is null) return new PcccAddress(letter, file, element, null, bit);
|
|
try { return WithSubElementName(letter, file, element, sub); }
|
|
catch (AbTransportException) { return null; }
|
|
}
|
|
}
|