시리얼 통신 앱의 함정 - 재접속과 로그 설계까지

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),
                $"프레임 하나의 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. 프레임 하나분이 갖춰졌는지
            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
            {
                // 여기서 프레임 하나분을 한꺼번에 버릴지, 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는 워커 하나만 수행한다.</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}");
    }
}