シリアル通信アプリの落とし穴 - 再接続とログ設計まで

using System;
using System.Buffers.Binary;
using System.Collections.Generic;
using System.Diagnostics;

public static class Crc16Modbus
{
    // CRC-16/MODBUS: 初期値 0xFFFF、多項式 0xA001 の右送り
    public static ushort Compute(ReadOnlySpan<byte> data)
    {
        ushort crc = 0xFFFF;
        foreach (var b in data)
        {
            crc ^= b;
            for (var i = 0; i < 8; i++)
            {
                crc = (crc & 1) != 0 ? (ushort)((crc >> 1) ^ 0xA001) : (ushort)(crc >> 1);
            }
        }

        return crc;
    }
}

public static class Frame
{
    public const byte Stx = 0x02;
    public const int HeaderLength = 2;   // STX + LEN
    public const int CrcLength = 2;

    public static byte[] Build(ReadOnlySpan<byte> payload)
    {
        // LEN は 1 byte なので、256 byte 以上はキャストで折り返す。
        // それでも payload はまるごとコピーされるため、受け手は切り詰められた
        // 長さでフレームを切り、payload の途中を CRC と読む。以降の
        // フレーム境界も総崩れになる。分割するか LEN を 2 byte にするかは
        // プロトコルの決めごとなので、ここでは弾くだけにする
        if (payload.Length > byte.MaxValue)
        {
            throw new ArgumentOutOfRangeException(
                nameof(payload),
                $"1 フレームの payload は {byte.MaxValue} byte までです(LEN が 1 byte のため)。");
        }

        var frame = new byte[HeaderLength + payload.Length + CrcLength];
        frame[0] = Stx;
        frame[1] = (byte)payload.Length;
        payload.CopyTo(frame.AsSpan(HeaderLength));

        var body = frame.AsSpan(0, frame.Length - CrcLength);
        BinaryPrimitives.WriteUInt16LittleEndian(frame.AsSpan(frame.Length - CrcLength), Crc16Modbus.Compute(body));
        return frame;
    }
}

public sealed class FrameParser
{
    private readonly List<byte> _buffer = new();

    /// <summary>3.3 の inter-byte timeout。組み立て中のフレームを諦めるまでの時間。</summary>
    private static readonly TimeSpan AssemblyTimeout = TimeSpan.FromMilliseconds(200);

    /// <summary>いま組み立て中の候補が、いつから待ち状態になったか(単調増加の値)。</summary>
    private long _pendingSince;

    /// <summary>CRC が合わずに捨てたフレームを通知する。ログへ落とすために必ず購読する。</summary>
    public event Action<byte[]>? FrameDiscarded;

    /// <summary>組み立てを諦めて再同期したことを通知する。ここが増え続けるなら結線か設定を疑う。</summary>
    public event Action<int>? Resynchronized;

    /// <summary>受信した byte 列を溜め込み、切り出せたフレームだけを返す。</summary>
    public IReadOnlyList<byte[]> Append(ReadOnlySpan<byte> received)
    {
        foreach (var b in received)
        {
            _buffer.Add(b);
        }

        var frames = new List<byte[]>();

        while (true)
        {
            // 1. 先頭が STX になるまで捨てる。ノイズや前フレームの残りをここで吸収する
            var stxIndex = _buffer.IndexOf(Frame.Stx);
            if (stxIndex < 0)
            {
                _buffer.Clear();
                _pendingSince = 0;   // 候補が無くなったので待ち時間の計測もやめる
                break;
            }

            if (stxIndex > 0)
            {
                // 候補の先頭が変わった = 別のフレームの組み立てを始める
                _buffer.RemoveRange(0, stxIndex);
                _pendingSince = 0;
            }

            // 2. 長さを読めるところまで届いているか
            if (_buffer.Count < Frame.HeaderLength)
            {
                if (GiveUpOnStaleCandidate()) { continue; }
                break;   // 「壊れている」ではなく「まだ足りない」
            }

            int payloadLength = _buffer[1];
            int frameLength = Frame.HeaderLength + payloadLength + Frame.CrcLength;

            // 3. フレーム 1 個分そろっているか
            if (_buffer.Count < frameLength)
            {
                // 「まだ足りない」と「LEN がノイズで壊れている」は、この時点では
                // 区別が付かない。ノイズや偽の STX で LEN が 255 になると、
                // その後に届く正しいフレームまで payload として吸い込み続け、
                // 259 byte そろって CRC で落ちるまで何も上がってこない。
                // 通信量の少ない機器では、これが数分の無反応に見える。
                // 待ちに上限を置き、超えたら候補を捨てて STX を探し直す
                if (GiveUpOnStaleCandidate()) { continue; }
                break;   // ここで抜けて、次の受信を待つ
            }

            var frame = _buffer.GetRange(0, frameLength).ToArray();
            _buffer.RemoveRange(0, frameLength);
            _pendingSince = 0;

            // 4. CRC が合わないものは捨てる。捨てたことは必ず外へ出す
            var expected = BinaryPrimitives.ReadUInt16LittleEndian(frame.AsSpan(frame.Length - Frame.CrcLength));
            if (expected == Crc16Modbus.Compute(frame.AsSpan(0, frame.Length - Frame.CrcLength)))
            {
                frames.Add(frame);
            }
            else
            {
                // ここでフレーム 1 個分まとめて捨てるか、STX 1 byte だけ捨てて読み直すかは設計判断。
                // 前者は単純、後者は LEN 自体がノイズだった場合に強い。どちらにするか決めて明文化する。
                FrameDiscarded?.Invoke(frame);
            }
        }

        return frames;
    }

    /// <summary>
    /// 組み立て中の候補が AssemblyTimeout を超えていたら、先頭の STX を 1 byte だけ捨てる。
    /// 捨てたら true を返し、呼び出し側は次の STX から読み直す。
    /// フレームごと捨てないのは、本物の STX がこの候補の中にいる可能性があるため。
    /// </summary>
    private bool GiveUpOnStaleCandidate()
    {
        if (_pendingSince == 0)
        {
            // 待ち始めた瞬間。壁時計だと NTP 同期で飛ぶので、単調増加の値で測る
            _pendingSince = Stopwatch.GetTimestamp();
            return false;
        }

        if (Stopwatch.GetElapsedTime(_pendingSince) < AssemblyTimeout)
        {
            return false;
        }

        _buffer.RemoveAt(0);
        _pendingSince = 0;
        Resynchronized?.Invoke(_buffer.Count);
        return true;
    }
}

using System;
using System.IO.Ports;
using System.Threading;
using System.Threading.Tasks;

public sealed class SerialReader
{
    private readonly SerialPort _port;
    private readonly FrameParser _parser;
    private readonly byte[] _readBuffer = new byte[4096];

    public SerialReader(SerialPort port, FrameParser parser)
    {
        _port = port;
        _parser = parser;
    }

    public event Action<byte[]>? FrameReceived;

    public async Task RunAsync(CancellationToken token)
    {
        while (!token.IsCancellationRequested)
        {
            int count;
            try
            {
                count = await _port.BaseStream.ReadAsync(_readBuffer.AsMemory(), token);
            }
            catch (OperationCanceledException)
            {
                break;
            }

            if (count <= 0)
            {
                continue;
            }

            foreach (var frame in _parser.Append(_readBuffer.AsSpan(0, count)))
            {
                FrameReceived?.Invoke(frame);
            }
        }
    }
}

using System;
using System.IO.Ports;
using System.Threading;
using System.Threading.Channels;
using System.Threading.Tasks;

public sealed class SingleWriter
{
    private sealed record Outbound(byte[] FrameBytes, TaskCompletionSource<byte[]> Completion);

    /// <summary>送信キューの上限。装置1往復ぶんの時間 × 許容する待ち行列で決める。</summary>
    private const int QueueCapacity = 64;

    private readonly SerialPort _port;
    private readonly TimeSpan _responseTimeout;

    // 上限なしにしない。UI・タイマー・ワーカーが装置の往復より速く積むと、
    // フレームと TaskCompletionSource が際限なく溜まり、装置は応答している
    // のにメモリだけが増え続ける。上限を決めて、あふれたら送り手へ返す
    private readonly Channel<Outbound> _queue = Channel.CreateBounded<Outbound>(
        new BoundedChannelOptions(QueueCapacity)
        {
            // 満杯なら TryWrite が false を返す。呼び出し側は「いま詰まっている」
            // ことを即座に知れる。DropOldest は使わない ── 積んだ側は
            // Task を待っているので、黙って捨てると永久に返らなくなる
            FullMode = BoundedChannelFullMode.Wait,
            SingleReader = true,
        });

    private Outbound? _inFlight;

    public SingleWriter(SerialPort port, TimeSpan responseTimeout)
    {
        _port = port;
        _responseTimeout = responseTimeout;
    }

    /// <summary>UI からでもタイマーからでも呼んでよい。実際の Write はワーカー 1 本だけが行う。</summary>
    public Task<byte[]> SendAsync(ReadOnlySpan<byte> payload)
    {
        var item = new Outbound(
            Frame.Build(payload),
            new TaskCompletionSource<byte[]>(TaskCreationOptions.RunContinuationsAsynchronously));

        if (!_queue.Writer.TryWrite(item))
        {
            // 満杯か、ワーカーが停止済み。どちらの場合も「積めなかった」ことを
            // 呼び出し側へ返す。黙って捨てると、待っている Task が永久に返らない
            item.Completion.TrySetException(new InvalidOperationException(
                $"送信キューへ積めませんでした(上限 {QueueCapacity} 件、またはワーカー停止済み)。"));
        }

        return item.Completion.Task;
    }

    /// <summary>parser がフレームを切り出したら呼ぶ。応答待ちの 1 件へ結び付ける。</summary>
    public void OnFrameReceived(byte[] frame)
    {
        var pending = Interlocked.Exchange(ref _inFlight, null);
        pending?.Completion.TrySetResult(frame);
    }

    public async Task RunAsync(CancellationToken token)
    {
        try
        {
            await foreach (var item in _queue.Reader.ReadAllAsync(token))
            {
                Interlocked.Exchange(ref _inFlight, item);
                try
                {
                    await _port.BaseStream.WriteAsync(item.FrameBytes.AsMemory(), token);
                }
                catch (Exception ex)
                {
                    // 抜線・ポートのクローズ・キャンセルはここで飛んでくる。
                    // この1件を完了させずに抜けると、SendAsync を await している
                    // 呼び出し側が永久に待つ
                    Interlocked.Exchange(ref _inFlight, null);
                    item.Completion.TrySetException(ex);
                    throw;
                }

                // ここで応答まで待つから、次のコマンドが割り込まない
                var timeout = Task.Delay(_responseTimeout, token);
                var finished = await Task.WhenAny(item.Completion.Task, timeout);

                if (finished != item.Completion.Task)
                {
                    // 停止を要求されたときも Task.Delay はキャンセルされて先に終わる。
                    // ここを見ないと、正常な終了処理がタイムアウト扱いになり、
                    // 呼び出し側には TimeoutException が返る
                    token.ThrowIfCancellationRequested();

                    // WhenAny が timeout を選んだあとに応答が届くことがある。
                    // そのとき OnFrameReceived は既に _inFlight を取り、この1件を
                    // 成功で完了させている。取れなかったら応答の勝ちで、ここで
                    // TrySetException を撃っても不発に終わる。それに気付かず
                    // throw まで進むと、呼び出し側は結果を受け取っているのに
                    // ワーカーだけが落ちる。取り合いは CompareExchange で決める
                    if (Interlocked.CompareExchange(ref _inFlight, null, item) != item)
                    {
                        // 応答が勝った。完了は OnFrameReceived が入れる(入れた直後)
                        await item.Completion.Task;
                        continue;
                    }

                    item.Completion.TrySetException(new TimeoutException("応答がありませんでした。"));

                    // タイムアウトしたら、この接続はもう信用できない。
                    // 「諦めて次を送る」で済ませてはいけない理由は下に書いたとおりで、
                    // このプロトコルにはリクエストIDが無いため、遅れて届いたAの応答が
                    // 次のBの応答として結び付いてしまう。3.6 の状態遷移図どおり
                    // Fault へ落として、セッションを作り直す
                    throw new TimeoutException("応答がないため、セッションを作り直します。");
                }
            }
        }
        finally
        {
            // ワーカーが止まる理由が何であれ、待たせている件は必ず終わらせる。
            // 応答待ちの1件と、キューに積まれたまま送られなかった分の両方
            var stopped = new OperationCanceledException("送信ワーカーが停止しました。");
            Interlocked.Exchange(ref _inFlight, null)?.Completion.TrySetException(stopped);
            _queue.Writer.TryComplete();
            while (_queue.Reader.TryRead(out var pending))
            {
                pending.Completion.TrySetException(stopped);
            }
        }
    }
}

using System;
using System.IO.Ports;
using System.Threading;
using System.Threading.Tasks;

// 3.4 で決めた設定を、その場の値ではなくまとめて置く
using var port = new SerialPort("COM3", 115200, Parity.None, 8, StopBits.One)
{
    Handshake = Handshake.None,
    DtrEnable = true,
    RtsEnable = true,
    ReadTimeout = 500,
    WriteTimeout = 500,
};

Console.WriteLine($"open {port.PortName} baud={port.BaudRate} data={port.DataBits} parity={port.Parity} " +
                  $"stop={port.StopBits} handshake={port.Handshake} dtr={port.DtrEnable} rts={port.RtsEnable}");
port.Open();

var parser = new FrameParser();
var writer = new SingleWriter(port, TimeSpan.FromSeconds(2));
var reader = new SerialReader(port, parser);

// 定義したイベントは必ず購読する。ここを忘れると、捨てたフレームも応答も表に出ない
parser.FrameDiscarded += frame => Console.Error.WriteLine($"crc error: {Convert.ToHexString(frame)}");
reader.FrameReceived += writer.OnFrameReceived;

using var cts = new CancellationTokenSource();
var readerTask = reader.RunAsync(cts.Token);
var writerTask = writer.RunAsync(cts.Token);

var request = new byte[] { 0x10, 0x00 };
try
{
    var response = await writer.SendAsync(request);
    Console.WriteLine($"response: {Convert.ToHexString(response)}");
}
finally
{
    // 送信が失敗しても、ワーカーは必ず止めてから抜ける。ここを飛ばすと、
    // using の破棄で SerialPort が閉じられたあとも reader/writer が
    // そのストリームを触り続け、しかもその例外は誰も観測しない
    cts.Cancel();
    try
    {
        await Task.WhenAll(readerTask, writerTask);
    }
    catch (OperationCanceledException)
    {
        // 停止要求による終了。ここは正常系として扱う
    }
    catch (Exception ex)
    {
        // ワーカー側の失敗。ここで投げ直すと、本来の失敗理由
        // (SendAsync の例外)を覆い隠すので、記録に留める
        Console.Error.WriteLine($"worker stopped with error: {ex.Message}");
    }
}