f17ba8e258
Array tags were advertised writable but every write threw InvalidCastException in ConvertForWrite (reported BadTypeMismatch); STRING writes went through the Beckhoff marshaller with no length check against STRING(n) and the host's ANSI code page, which the read side deliberately avoids. - Array write: TwinCATArrayCodec.ToWriteElements converts exactly ArrayLength elements to the declared type (CLR lists convert - ScadaBridge writes int[] to Int16 nodes; a length mismatch or out-of-range element is BadOutOfRange, a scalar value BadTypeMismatch) before any wire traffic; the ADS client plans the layout from the resolved PLC array (TwinCATTypeGuard.CheckArray, as the read does), encodes with TwinCATArrayCodec.Encode - the exact inverse of Decode - and writes the raw bytes (new ITwinCATClient.WriteArrayAsync). - STRING / WSTRING write: encoded at the PLC's declared width by TwinCATStringCodec.EncodeString/EncodeWString (Windows-1252 or UTF-8 per target, NUL-padded, strict: an over-long value or unrepresentable character is OverflowException -> BadOutOfRange) and written as raw bytes. - TwinCAT CLI read/write gain --array-length (+ --separator) for the hardware gate. Refs #739 Claude-Session: https://claude.ai/code/session_01Ub9hGmYLQvn9XETzw7CMsT
121 lines
6.3 KiB
C#
121 lines
6.3 KiB
C#
using System.Text;
|
||
|
||
namespace ZB.MOM.WW.OtOpcUa.Driver.TwinCAT;
|
||
|
||
/// <summary>
|
||
/// Decodes an IEC <c>STRING(n)</c> / <c>WSTRING(n)</c> buffer read at the PLC's own declared width.
|
||
/// The driver reads string symbols as raw bytes and decodes them here instead of letting the
|
||
/// Beckhoff marshaller pick an encoding, because that marshaller falls back to the HOST's ANSI code
|
||
/// page (<c>CultureInfo.CurrentCulture.TextInfo.ANSICodePage</c>) for a non-UTF-8 target — so a
|
||
/// TwinCAT 2 string would decode differently on a Polish (1250) or Cyrillic (1251) server.
|
||
/// </summary>
|
||
/// <remarks>
|
||
/// Two rules, both ported from the ignitionoee TwinCAT driver and both found on a real PLC:
|
||
/// <list type="bullet">
|
||
/// <item>A value ENDS at its first NUL — <c>0x00</c> for a STRING, an aligned <c>0x00 0x00</c>
|
||
/// code unit for a WSTRING. Whatever follows is stale content a longer earlier value left in the
|
||
/// buffer (live on the Elma cleaner Z33856: work order <c>67504440</c> read back with a stale
|
||
/// <c>"\0" + "1"</c> tail).</item>
|
||
/// <item>A STRING is single-byte <b>Windows-1252</b> (umlauts, <c>°</c> in alarm texts), unless
|
||
/// the target reports UTF-8 string data (TwinCAT 3.1 4026+ "UTF8 Encoding for STRING").
|
||
/// ISO-8859-1 is the fallback on a runtime without code-page support — identical outside
|
||
/// 0x80–0x9F.</item>
|
||
/// </list>
|
||
/// </remarks>
|
||
internal static class TwinCATStringCodec
|
||
{
|
||
private static readonly Encoding Windows1252 = CreateWindows1252();
|
||
|
||
private static Encoding CreateWindows1252()
|
||
{
|
||
try
|
||
{
|
||
Encoding.RegisterProvider(CodePagesEncodingProvider.Instance);
|
||
return Encoding.GetEncoding(1252);
|
||
}
|
||
catch (Exception)
|
||
{
|
||
return Encoding.Latin1;
|
||
}
|
||
}
|
||
|
||
/// <summary>Decodes an IEC <c>STRING(n)</c> buffer: ends at the first NUL, Windows-1252 unless <paramref name="utf8"/>.</summary>
|
||
/// <param name="bytes">The raw symbol bytes (n+1 for a <c>STRING(n)</c>).</param>
|
||
/// <param name="utf8">True when the target reports UTF-8 string data.</param>
|
||
/// <returns>The decoded value.</returns>
|
||
public static string DecodeString(ReadOnlySpan<byte> bytes, bool utf8)
|
||
{
|
||
var end = bytes.IndexOf((byte)0);
|
||
if (end >= 0) bytes = bytes[..end];
|
||
return (utf8 ? Encoding.UTF8 : Windows1252).GetString(bytes);
|
||
}
|
||
|
||
// Strict encoders for the WRITE side: a character the target encoding cannot hold is refused rather
|
||
// than silently replaced with '?' (the replacement would be written to the PLC as if it were the value).
|
||
private static readonly Encoding StrictWindows1252 = CreateStrict(Windows1252.CodePage);
|
||
private static readonly Encoding StrictUtf8 = new UTF8Encoding(encoderShouldEmitUTF8Identifier: false, throwOnInvalidBytes: true);
|
||
private static readonly Encoding StrictUtf16 = new UnicodeEncoding(bigEndian: false, byteOrderMark: false, throwOnInvalidBytes: true);
|
||
|
||
private static Encoding CreateStrict(int codePage) =>
|
||
Encoding.GetEncoding(codePage, EncoderFallback.ExceptionFallback, DecoderFallback.ReplacementFallback);
|
||
|
||
/// <summary>
|
||
/// Encodes a value into an IEC <c>STRING(n)</c> buffer of the PLC's declared width (n+1 bytes): the
|
||
/// inverse of <see cref="DecodeString"/> — Windows-1252 unless <paramref name="utf8"/>, NUL-terminated
|
||
/// and NUL-padded so no stale tail of a longer earlier value survives.
|
||
/// </summary>
|
||
/// <param name="value">The value to write.</param>
|
||
/// <param name="byteWidth">The PLC symbol's byte width (n+1 for a <c>STRING(n)</c>).</param>
|
||
/// <param name="utf8">True when the target reports UTF-8 string data.</param>
|
||
/// <returns>Exactly <paramref name="byteWidth"/> bytes.</returns>
|
||
/// <exception cref="OverflowException">The value does not fit <c>STRING(n)</c>, or holds a character the
|
||
/// target encoding cannot represent.</exception>
|
||
public static byte[] EncodeString(string value, int byteWidth, bool utf8) =>
|
||
Encode(value, byteWidth, utf8 ? StrictUtf8 : StrictWindows1252, terminatorBytes: 1, "STRING");
|
||
|
||
/// <summary>
|
||
/// Encodes a value into an IEC <c>WSTRING(n)</c> buffer (UTF-16LE, 2(n+1) bytes): the inverse of
|
||
/// <see cref="DecodeWString"/>, terminated by an aligned <c>U+0000</c> and zero-padded.
|
||
/// </summary>
|
||
/// <param name="value">The value to write.</param>
|
||
/// <param name="byteWidth">The PLC symbol's byte width.</param>
|
||
/// <returns>Exactly <paramref name="byteWidth"/> bytes.</returns>
|
||
/// <exception cref="OverflowException">The value does not fit <c>WSTRING(n)</c>.</exception>
|
||
public static byte[] EncodeWString(string value, int byteWidth) =>
|
||
Encode(value, byteWidth, StrictUtf16, terminatorBytes: 2, "WSTRING");
|
||
|
||
private static byte[] Encode(string value, int byteWidth, Encoding encoding, int terminatorBytes, string kind)
|
||
{
|
||
ArgumentNullException.ThrowIfNull(value);
|
||
byte[] encoded;
|
||
try { encoded = encoding.GetBytes(value); }
|
||
catch (ArgumentException ex) // EncoderFallbackException: a character the encoding cannot hold
|
||
{
|
||
throw new OverflowException($"'{value}' cannot be represented in the PLC's {kind} encoding: {ex.Message}", ex);
|
||
}
|
||
if (encoded.Length + terminatorBytes > byteWidth)
|
||
throw new OverflowException(
|
||
$"'{value}' is {encoded.Length} B but the PLC {kind} holds {Math.Max(0, byteWidth - terminatorBytes)} B");
|
||
var buffer = new byte[byteWidth];
|
||
encoded.CopyTo(buffer, 0);
|
||
return buffer;
|
||
}
|
||
|
||
/// <summary>Decodes an IEC <c>WSTRING(n)</c> buffer (UTF-16LE): ends at the first aligned <c>U+0000</c>.</summary>
|
||
/// <param name="bytes">The raw symbol bytes (2(n+1) for a <c>WSTRING(n)</c>).</param>
|
||
/// <returns>The decoded value.</returns>
|
||
public static string DecodeWString(ReadOnlySpan<byte> bytes)
|
||
{
|
||
var end = bytes.Length & ~1; // whole UTF-16 code units only — a trailing odd byte is ignored
|
||
for (var i = 0; i + 1 < end; i += 2)
|
||
{
|
||
if (bytes[i] == 0 && bytes[i + 1] == 0)
|
||
{
|
||
end = i;
|
||
break;
|
||
}
|
||
}
|
||
return Encoding.Unicode.GetString(bytes[..end]);
|
||
}
|
||
}
|